diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java index bc070928e4f..e849efb984b 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/AsmUtil.java @@ -73,6 +73,9 @@ import static org.jetbrains.kotlin.types.TypeUtils.isNullableType; import static org.jetbrains.org.objectweb.asm.Opcodes.*; public class AsmUtil { + + public static final boolean IS_BUILT_WITH_ASM6 = Opcodes.API_VERSION <= Opcodes.ASM6; + private static final Set STRING_BUILDER_OBJECT_APPEND_ARG_TYPES = Sets.newHashSet( getType(String.class), getType(StringBuffer.class), diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java index f3dc17a6bc6..0849f624483 100644 --- a/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java @@ -517,12 +517,27 @@ public class FunctionCodegen { Iterator iterator = valueParameters.iterator(); List kotlinParameterTypes = jvmSignature.getValueParameters(); + int syntheticParameterCount = 0; + for (int i = 0; i < kotlinParameterTypes.size(); i++) { + JvmMethodParameterSignature parameterSignature = kotlinParameterTypes.get(i); + JvmMethodParameterKind kind = parameterSignature.getKind(); + if (kind.isSkippedInGenericSignature()) { + if (AsmUtil.IS_BUILT_WITH_ASM6) { + markEnumOrInnerConstructorParameterAsSynthetic(mv, i, state.getClassBuilderMode()); + } + else { + syntheticParameterCount++; + } + } + } + if (!AsmUtil.IS_BUILT_WITH_ASM6) { + Asm7UtilKt.visitAnnotableParameterCount(mv, kotlinParameterTypes.size() - syntheticParameterCount); + } for (int i = 0; i < kotlinParameterTypes.size(); i++) { JvmMethodParameterSignature parameterSignature = kotlinParameterTypes.get(i); JvmMethodParameterKind kind = parameterSignature.getKind(); if (kind.isSkippedInGenericSignature()) { - markEnumOrInnerConstructorParameterAsSynthetic(mv, i, state.getClassBuilderMode()); continue; } @@ -534,7 +549,9 @@ public class FunctionCodegen { : null; if (annotated != null) { - AnnotationCodegen.forParameter(i, mv, innerClassConsumer, state).genAnnotations(annotated, parameterSignature.getAsmType()); + //noinspection ConstantConditions + AnnotationCodegen.forParameter(AsmUtil.IS_BUILT_WITH_ASM6 ? i : i - syntheticParameterCount, mv, innerClassConsumer, state) + .genAnnotations(annotated, parameterSignature.getAsmType()); } } } diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/asm7Util.kt b/compiler/backend/src/org/jetbrains/kotlin/codegen/asm7Util.kt new file mode 100644 index 00000000000..80470a1da60 --- /dev/null +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/asm7Util.kt @@ -0,0 +1,10 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codegen + +import org.jetbrains.org.objectweb.asm.MethodVisitor + +internal fun visitAnnotableParameterCount(mv: MethodVisitor, paramCount: Int) {} \ No newline at end of file diff --git a/compiler/backend/src/org/jetbrains/kotlin/codegen/asm7Util.kt.183 b/compiler/backend/src/org/jetbrains/kotlin/codegen/asm7Util.kt.183 new file mode 100644 index 00000000000..b75508e1a38 --- /dev/null +++ b/compiler/backend/src/org/jetbrains/kotlin/codegen/asm7Util.kt.183 @@ -0,0 +1,13 @@ +/* + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * that can be found in the license/LICENSE.txt file. + */ + +package org.jetbrains.kotlin.codegen + +import org.jetbrains.org.objectweb.asm.MethodVisitor + +internal fun visitAnnotableParameterCount(mv: MethodVisitor, paramCount: Int) { + mv.visitAnnotableParameterCount(paramCount, true) + mv.visitAnnotableParameterCount(paramCount, false) +} \ No newline at end of file diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt index 9a1b0390a7d..3819e1209fe 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Annotations.kt @@ -60,7 +60,7 @@ internal class AnnotationsAndParameterCollectorMethodVisitor( ) override fun visitParameterAnnotation(parameter: Int, desc: String, visible: Boolean): AnnotationVisitor? { - val index = parameter - parametersToSkipNumber + val index = if (Opcodes.API_VERSION <= Opcodes.ASM6) parameter - parametersToSkipNumber else parameter if (index < 0) return null val annotations = diff --git a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java index 1f305654539..3fd11bb30c9 100644 --- a/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java +++ b/compiler/frontend.java/src/org/jetbrains/kotlin/load/kotlin/FileBasedKotlinClass.java @@ -252,7 +252,12 @@ public abstract class FileBasedKotlinClass implements KotlinJvmBinaryClass { MethodAnnotationVisitor v = memberVisitor.visitMethod(Name.identifier(name), desc); if (v == null) return null; + int methodParamCount = Type.getArgumentTypes(desc).length; return new MethodVisitor(ASM5) { + + private int visibleAnnotableParameterCount = methodParamCount; + private int invisibleAnnotableParameterCount = methodParamCount; + @Override public org.jetbrains.org.objectweb.asm.AnnotationVisitor visitAnnotation(@NotNull String desc, boolean visible) { return convertAnnotationVisitor(v, desc, innerClasses); @@ -260,10 +265,19 @@ public abstract class FileBasedKotlinClass implements KotlinJvmBinaryClass { @Override public org.jetbrains.org.objectweb.asm.AnnotationVisitor visitParameterAnnotation(int parameter, @NotNull String desc, boolean visible) { - AnnotationArgumentVisitor av = v.visitParameterAnnotation(parameter, resolveNameByDesc(desc, innerClasses), SourceElement.NO_SOURCE); + int parameterIndex = parameter + methodParamCount - (visible ? visibleAnnotableParameterCount : invisibleAnnotableParameterCount); + AnnotationArgumentVisitor av = v.visitParameterAnnotation(parameterIndex, resolveNameByDesc(desc, innerClasses), SourceElement.NO_SOURCE); return av == null ? null : convertAnnotationVisitor(av, innerClasses); } + public void visitAnnotableParameterCount(int parameterCount, boolean visible) { + if (visible) + visibleAnnotableParameterCount = parameterCount; + else { + invisibleAnnotableParameterCount = parameterCount; + } + } + @Override public void visitEnd() { v.visitEnd(); diff --git a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/StubClassBuilder.java b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/StubClassBuilder.java index c3d9f64d9ed..1c33c8491d3 100644 --- a/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/StubClassBuilder.java +++ b/compiler/light-classes/src/org/jetbrains/kotlin/asJava/builder/StubClassBuilder.java @@ -81,6 +81,7 @@ public class StubClassBuilder extends AbstractClassBuilder { ) { assert v == null : "defineClass() called twice?"; + //noinspection ConstantConditions v = new StubBuildingVisitor<>(null, EMPTY_STRATEGY, parent, access, calculateShortName(name)); super.defineClass(origin, version, access, name, signature, superName, interfaces); diff --git a/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.java b/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.java new file mode 100644 index 00000000000..a370e4fe9c4 --- /dev/null +++ b/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.java @@ -0,0 +1,5 @@ +public enum AnnotatedParameterInEnumConstructor { + A; + + private AnnotatedParameterInEnumConstructor(@test.Anno(x = "a") java.lang.String a, @test.Anno(x = "b") java.lang.String b) { /* compiled code */ } +} \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt b/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt new file mode 100644 index 00000000000..84f0f47adf9 --- /dev/null +++ b/compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt @@ -0,0 +1,8 @@ +// test.AnnotatedParameterInEnumConstructor +package test + +annotation class Anno(val x: String) + +enum class AnnotatedParameterInEnumConstructor(@Anno("a") a: String, @Anno("b") b: String) { + A("1", "b") +} diff --git a/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.java b/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.java new file mode 100644 index 00000000000..7c6dee4f8c6 --- /dev/null +++ b/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.java @@ -0,0 +1,11 @@ +public final class AnnotatedParameterInInnerClassConstructor { + public AnnotatedParameterInInnerClassConstructor() { /* compiled code */ } + + public final class Inner { + public Inner(@test.Anno(x = "a") @org.jetbrains.annotations.NotNull java.lang.String $outer, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ } + } + + public final class InnerGeneric { + public InnerGeneric(@test.Anno(x = "a") T $outer, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ } + } +} \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.java.183 b/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.java.183 new file mode 100644 index 00000000000..c7002108cdc --- /dev/null +++ b/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.java.183 @@ -0,0 +1,11 @@ +public final class AnnotatedParameterInInnerClassConstructor { + public AnnotatedParameterInInnerClassConstructor() { /* compiled code */ } + + public final class Inner { + public Inner(@test.Anno(x = "a") @org.jetbrains.annotations.NotNull java.lang.String a, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String b) { /* compiled code */ } + } + + public final class InnerGeneric { + public InnerGeneric(@test.Anno(x = "a") T a, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String b) { /* compiled code */ } + } +} \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt b/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt new file mode 100644 index 00000000000..5845747652a --- /dev/null +++ b/compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt @@ -0,0 +1,15 @@ +// test.AnnotatedParameterInInnerClassConstructor +package test + +annotation class Anno(val x: String) + +class AnnotatedParameterInInnerClassConstructor { + + inner class Inner(@Anno("a") a: String, @Anno("b") b: String) { + + } + + inner class InnerGeneric(@Anno("a") a: T, @Anno("b") b: String) { + + } +} \ No newline at end of file diff --git a/compiler/testData/codegen/box/reflection/annotations/localClassParameterAnnotation.kt b/compiler/testData/codegen/box/reflection/annotations/localClassParameterAnnotation.kt new file mode 100644 index 00000000000..f5bd92fd349 --- /dev/null +++ b/compiler/testData/codegen/box/reflection/annotations/localClassParameterAnnotation.kt @@ -0,0 +1,29 @@ +// IGNORE_BACKEND: JS_IR +// TODO: muted automatically, investigate should it be ran for JS or not +// IGNORE_BACKEND: JS, NATIVE + +// WITH_REFLECT + +import kotlin.reflect.full.valueParameters + +@Retention(AnnotationRetention.RUNTIME) +annotation class Simple(val value: String) + +fun local(): Any { + class A(@Simple("OK") val z: String) + return A("OK") +} + +fun localCaptured(): Any { + val z = 1 + class A(@Simple("K") val z: String) { + val x = z + } + return A("K") +} + +fun box(): String { + return (local()::class.constructors.single().valueParameters.single().annotations.single() as Simple).value + //KT-25573 + //return (localCaptured()::class.constructors.single().valueParameters.single().annotations.single() as Simple).value +} diff --git a/compiler/testData/codegen/bytecodeListing/annotations/localClassWithCapturedParams.kt b/compiler/testData/codegen/bytecodeListing/annotations/localClassWithCapturedParams.kt new file mode 100644 index 00000000000..5bc9bd54e7f --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/annotations/localClassWithCapturedParams.kt @@ -0,0 +1,9 @@ +annotation class Simple(val value: String) + +fun localCaptured(): Any { + val z = 1 + class A(@Simple("K") val z: String) { + val x = z + } + return A("K") +} diff --git a/compiler/testData/codegen/bytecodeListing/annotations/localClassWithCapturedParams.txt b/compiler/testData/codegen/bytecodeListing/annotations/localClassWithCapturedParams.txt new file mode 100644 index 00000000000..f549acd9d6e --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/annotations/localClassWithCapturedParams.txt @@ -0,0 +1,22 @@ +@kotlin.Metadata +public final class LocalClassWithCapturedParamsKt$localCaptured$A { + synthetic final field $z: int + private final field x: int + private final @org.jetbrains.annotations.NotNull field z: java.lang.String + inner class LocalClassWithCapturedParamsKt$localCaptured$A + public method (p0: int, @Simple @org.jetbrains.annotations.NotNull p1: java.lang.String): void + public final method getX(): int + public final @org.jetbrains.annotations.NotNull method getZ(): java.lang.String +} + +@kotlin.Metadata +public final class LocalClassWithCapturedParamsKt { + inner class LocalClassWithCapturedParamsKt$localCaptured$A + public final static @org.jetbrains.annotations.NotNull method localCaptured(): java.lang.Object +} + +@java.lang.annotation.Retention +@kotlin.Metadata +public annotation class Simple { + public abstract method value(): java.lang.String +} diff --git a/compiler/testData/codegen/bytecodeListing/inlineClasses/annotationsOnHiddenConstructor.txt.183 b/compiler/testData/codegen/bytecodeListing/inlineClasses/annotationsOnHiddenConstructor.txt.183 new file mode 100644 index 00000000000..14b00333657 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/inlineClasses/annotationsOnHiddenConstructor.txt.183 @@ -0,0 +1,69 @@ +@java.lang.annotation.Retention +@kotlin.Metadata +public annotation class Ann + +@kotlin.Metadata +public final class Sealed$Derived { + inner class Sealed$Derived + private method (p0: int): void + public synthetic @Ann method (p0: int, p1: kotlin.jvm.internal.DefaultConstructorMarker): void +} + +@kotlin.Metadata +public final class Sealed$Inner { + synthetic final field this$0: Sealed + private final field z2: int + inner class Sealed$Inner + public synthetic @Ann method (p0: Sealed, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void + private method (p0: Sealed, p1: int, p2: int, p3: java.lang.String): void + public final method getZ2(): int +} + +@kotlin.Metadata +public abstract class Sealed { + private final field z: int + inner class Sealed$Derived + inner class Sealed$Inner + private @Ann method (@Ann p0: int): void + public synthetic method (p0: int, p1: kotlin.jvm.internal.DefaultConstructorMarker): void + public final method getZ(): int +} + +@kotlin.Metadata +public final class Test$Inner { + synthetic final field this$0: Test + private final field z2: int + inner class Test$Inner + public synthetic @Ann method (p0: Test, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void + private method (p0: Test, p1: int, p2: int, p3: java.lang.String): void + public final method getZ2(): int +} + +@kotlin.Metadata +public final class Test { + private final field z: int + inner class Test$Inner + public synthetic @Ann method (@Ann p0: int, p1: kotlin.jvm.internal.DefaultConstructorMarker): void + private method (p0: int): void + public synthetic @Ann method (p0: int, @Ann p1: int, p2: kotlin.jvm.internal.DefaultConstructorMarker): void + private @Ann method (p0: int, @Ann p1: java.lang.String): void + private method (p0: int, p1: int): void + public final method getZ(): int +} + +@kotlin.Metadata +public final class Z { + private final field x: int + private synthetic method (p0: int): void + public synthetic final static @org.jetbrains.annotations.NotNull method box-impl(p0: int): Z + public static method constructor-impl(p0: int): int + public method equals(p0: java.lang.Object): boolean + public static method equals-impl(p0: int, @org.jetbrains.annotations.Nullable p1: java.lang.Object): boolean + public final static method equals-impl0(p0: int, p1: int): boolean + public final method getX(): int + public method hashCode(): int + public static method hashCode-impl(p0: int): int + public method toString(): java.lang.String + public static @org.jetbrains.annotations.NotNull method toString-impl(p0: int): java.lang.String + public synthetic final method unbox-impl(): int +} diff --git a/compiler/testData/codegen/bytecodeListing/jvmOverloadsAndParametersAnnotations.txt.183 b/compiler/testData/codegen/bytecodeListing/jvmOverloadsAndParametersAnnotations.txt.183 new file mode 100644 index 00000000000..3ef26525862 --- /dev/null +++ b/compiler/testData/codegen/bytecodeListing/jvmOverloadsAndParametersAnnotations.txt.183 @@ -0,0 +1,133 @@ +@kotlin.Metadata +public final class ASimpleClass { + public method (): void + public synthetic static @kotlin.jvm.JvmOverloads method showSnackbar$default(p0: ASimpleClass, p1: java.lang.String, p2: int, p3: int, p4: int, p5: java.lang.Object): void + public final @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int): void + public final @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, p2: int): void + public synthetic static @kotlin.jvm.JvmOverloads method showSnackbarLong$default(p0: ASimpleClass, p1: java.lang.String, p2: int, p3: int, p4: long, p5: java.lang.String, p6: int, p7: java.lang.Object): void + public final @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void + public final @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void + public final @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @LongRes p2: long): void + public synthetic static @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension$default(p0: ASimpleClass, p1: int, p2: int, p3: long, p4: java.lang.String, p5: int, p6: java.lang.Object): void + public final @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long): void + public final @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long, @org.jetbrains.annotations.NotNull p3: java.lang.String): void + public final @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @LongRes p1: long): void + public synthetic static @kotlin.jvm.JvmOverloads method showSnackbarNoExtension$default(p0: ASimpleClass, p1: int, p2: int, p3: int, p4: java.lang.Object): void + public final @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int): void + public final @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int, p1: int): void +} + +@kotlin.Metadata +public final class BSimpleObject { + public final static field INSTANCE: BSimpleObject + static method (): void + private method (): void + public synthetic static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbar$default(p0: java.lang.String, p1: int, p2: int, p3: int, p4: java.lang.Object): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, p2: int): void + public synthetic static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong$default(p0: java.lang.String, p1: int, p2: int, p3: long, p4: java.lang.String, p5: int, p6: java.lang.Object): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @LongRes p2: long): void + public synthetic static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension$default(p0: int, p1: int, p2: long, p3: java.lang.String, p4: int, p5: java.lang.Object): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long, @org.jetbrains.annotations.NotNull p3: java.lang.String): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @LongRes p1: long): void + public synthetic static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarNoExtension$default(p0: int, p1: int, p2: int, p3: java.lang.Object): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int, p1: int): void +} + +@kotlin.Metadata +public final class CClassWithCompanion$Companion { + inner class CClassWithCompanion$Companion + private method (): void + public synthetic method (p0: kotlin.jvm.internal.DefaultConstructorMarker): void + public synthetic static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbar$default(p0: CClassWithCompanion$Companion, p1: java.lang.String, p2: int, p3: int, p4: int, p5: java.lang.Object): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, p2: int): void + public synthetic static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong$default(p0: CClassWithCompanion$Companion, p1: java.lang.String, p2: int, p3: int, p4: long, p5: java.lang.String, p6: int, p7: java.lang.Object): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @LongRes p2: long): void + public synthetic static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension$default(p0: CClassWithCompanion$Companion, p1: int, p2: int, p3: long, p4: java.lang.String, p5: int, p6: java.lang.Object): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long, @org.jetbrains.annotations.NotNull p3: java.lang.String): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @LongRes p1: long): void + public synthetic static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarNoExtension$default(p0: CClassWithCompanion$Companion, p1: int, p2: int, p3: int, p4: java.lang.Object): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int): void + public final @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int, p1: int): void +} + +@kotlin.Metadata +public final class CClassWithCompanion { + public final static field Companion: CClassWithCompanion$Companion + inner class CClassWithCompanion$Companion + static method (): void + public method (): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, p2: int): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @LongRes p2: long): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long, @org.jetbrains.annotations.NotNull p3: java.lang.String): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @LongRes p1: long): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int): void + public final static @kotlin.jvm.JvmStatic @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int, p1: int): void +} + +@kotlin.Metadata +public final class DClassConstuctors$InnerClass { + synthetic final field this$0: DClassConstuctors + inner class DClassConstuctors$InnerClass + public @kotlin.jvm.JvmOverloads method (p0: DClassConstuctors, @StringRes p1: int): void + public @kotlin.jvm.JvmOverloads method (p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void + public @kotlin.jvm.JvmOverloads method (p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void + public @kotlin.jvm.JvmOverloads method (p0: DClassConstuctors, @StringRes p1: int, @LongRes p2: long): void + public @kotlin.jvm.JvmOverloads method (p0: DClassConstuctors, @StringRes p1: int, p2: int): void + public synthetic @kotlin.jvm.JvmOverloads method (p0: DClassConstuctors, p1: int, p2: int, p3: int, p4: kotlin.jvm.internal.DefaultConstructorMarker): void + public synthetic @kotlin.jvm.JvmOverloads method (p0: DClassConstuctors, p1: int, p2: int, p3: long, p4: java.lang.String, p5: int, p6: kotlin.jvm.internal.DefaultConstructorMarker): void +} + +@kotlin.Metadata +public final class DClassConstuctors { + inner class DClassConstuctors$InnerClass + public @kotlin.jvm.JvmOverloads method (@StringRes p0: int): void + public @kotlin.jvm.JvmOverloads method (@StringRes p0: int, @DefRes p1: int, @LongRes p2: long): void + public @kotlin.jvm.JvmOverloads method (@StringRes p0: int, @DefRes p1: int, @LongRes p2: long, @org.jetbrains.annotations.NotNull p3: java.lang.String): void + public @kotlin.jvm.JvmOverloads method (@StringRes p0: int, @LongRes p1: long): void + public @kotlin.jvm.JvmOverloads method (@StringRes p0: int, p1: int): void + public synthetic @kotlin.jvm.JvmOverloads method (p0: int, p1: int, p2: int, p3: kotlin.jvm.internal.DefaultConstructorMarker): void + public synthetic @kotlin.jvm.JvmOverloads method (p0: int, p1: int, p2: long, p3: java.lang.String, p4: int, p5: kotlin.jvm.internal.DefaultConstructorMarker): void +} + +@java.lang.annotation.Retention +@kotlin.Metadata +public annotation class DefRes + +@kotlin.Metadata +public final class JvmOverloadsAndParametersAnnotationsKt { + public synthetic static @kotlin.jvm.JvmOverloads method showSnackbar$default(p0: java.lang.String, p1: int, p2: int, p3: int, p4: java.lang.Object): void + public final static @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int): void + public final static @kotlin.jvm.JvmOverloads method showSnackbar(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, p2: int): void + public synthetic static @kotlin.jvm.JvmOverloads method showSnackbarLong$default(p0: java.lang.String, p1: int, p2: int, p3: long, p4: java.lang.String, p5: int, p6: java.lang.Object): void + public final static @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void + public final static @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long, @org.jetbrains.annotations.NotNull p4: java.lang.String): void + public final static @kotlin.jvm.JvmOverloads method showSnackbarLong(@org.jetbrains.annotations.NotNull p0: java.lang.String, @StringRes p1: int, @LongRes p2: long): void + public synthetic static @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension$default(p0: int, p1: int, p2: long, p3: java.lang.String, p4: int, p5: java.lang.Object): void + public final static @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long): void + public final static @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long, @org.jetbrains.annotations.NotNull p3: java.lang.String): void + public final static @kotlin.jvm.JvmOverloads method showSnackbarLongNoExtension(@StringRes p0: int, @LongRes p1: long): void + public synthetic static @kotlin.jvm.JvmOverloads method showSnackbarNoExtension$default(p0: int, p1: int, p2: int, p3: java.lang.Object): void + public final static @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int): void + public final static @kotlin.jvm.JvmOverloads method showSnackbarNoExtension(@StringRes p0: int, p1: int): void +} + +@java.lang.annotation.Retention +@kotlin.Metadata +public annotation class LongRes + +@java.lang.annotation.Retention +@kotlin.Metadata +public annotation class StringRes diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.java b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.java new file mode 100644 index 00000000000..226906b6bfc --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.java @@ -0,0 +1,16 @@ +package test; + +class AnnotatedParameterInInnerClassConstructor { + + public @interface Anno { + String value(); + } + + class Inner { + Inner(@Anno("a") String a , @Anno("b") String b) {} + } + + class InnerGeneric { + InnerGeneric(@Anno("a") String a , @Anno("b") String b) {} + } +} \ No newline at end of file diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.txt new file mode 100644 index 00000000000..87fbeac2ee4 --- /dev/null +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.txt @@ -0,0 +1,18 @@ +package test + +public/*package*/ open class AnnotatedParameterInInnerClassConstructor { + public/*package*/ constructor AnnotatedParameterInInnerClassConstructor() + + public final annotation class Anno : kotlin.Annotation { + public constructor Anno(/*0*/ value: kotlin.String) + public final val value: kotlin.String + } + + public/*package*/ open inner class Inner { + public/*package*/ constructor Inner(/*0*/ @test.AnnotatedParameterInInnerClassConstructor.Anno(value = "a") p0: kotlin.String!, /*1*/ @test.AnnotatedParameterInInnerClassConstructor.Anno(value = "b") p1: kotlin.String!) + } + + public/*package*/ open inner class InnerGeneric { + public/*package*/ constructor InnerGeneric(/*0*/ @test.AnnotatedParameterInInnerClassConstructor.Anno(value = "a") p0: kotlin.String!, /*1*/ @test.AnnotatedParameterInInnerClassConstructor.Anno(value = "b") p1: kotlin.String!) + } +} diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt index 7a93b1685cd..b0f9262a72c 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt @@ -160,8 +160,12 @@ class BytecodeListingTextCollectingVisitor(val filter: Filter, val withSignature val parameterAnnotations = hashMapOf>() handleModifiers(access, methodAnnotations) + val methodParamCount = Type.getArgumentTypes(desc).size return object : MethodVisitor(ASM5) { + private var visibleAnnotableParameterCount = methodParamCount + private var invisibleAnnotableParameterCount = methodParamCount + override fun visitAnnotation(desc: String, visible: Boolean): AnnotationVisitor? { val type = Type.getType(desc).className methodAnnotations += "@$type " @@ -170,7 +174,9 @@ class BytecodeListingTextCollectingVisitor(val filter: Filter, val withSignature override fun visitParameterAnnotation(parameter: Int, desc: String, visible: Boolean): AnnotationVisitor? { val type = Type.getType(desc).className - parameterAnnotations.getOrPut(parameter, { arrayListOf() }).add("@$type ") + parameterAnnotations.getOrPut( + parameter + methodParamCount - (if (visible) visibleAnnotableParameterCount else invisibleAnnotableParameterCount), + { arrayListOf() }).add("@$type ") return super.visitParameterAnnotation(parameter, desc, visible) } @@ -185,6 +191,15 @@ class BytecodeListingTextCollectingVisitor(val filter: Filter, val withSignature ) super.visitEnd() } + + @Suppress("NOTHING_TO_OVERRIDE") + override fun visitAnnotableParameterCount(parameterCount: Int, visible: Boolean) { + if (visible) + visibleAnnotableParameterCount = parameterCount + else { + invisibleAnnotableParameterCount = parameterCount + } + } } } diff --git a/compiler/tests/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java index 402acd05aa0..7f91cf395e1 100644 --- a/compiler/tests/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java @@ -29,6 +29,16 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true, "local", "ideRegression"); } + @TestMetadata("AnnotatedParameterInEnumConstructor.kt") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt"); + } + + @TestMetadata("AnnotatedParameterInInnerClassConstructor.kt") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt"); + } + @TestMetadata("AnnotationClass.kt") public void testAnnotationClass() throws Exception { runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java index 4b059767c37..ebf28c4c659 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BlackBoxCodegenTestGenerated.java @@ -18934,6 +18934,11 @@ public class BlackBoxCodegenTestGenerated extends AbstractBlackBoxCodegenTest { runTest("compiler/testData/codegen/box/reflection/annotations/findAnnotation.kt"); } + @TestMetadata("localClassParameterAnnotation.kt") + public void testLocalClassParameterAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/reflection/annotations/localClassParameterAnnotation.kt"); + } + @TestMetadata("openSuspendFun.kt") public void testOpenSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/reflection/annotations/openSuspendFun.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java index f9f22ee0fe3..e532dd2bd8a 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/BytecodeListingTestGenerated.java @@ -230,6 +230,11 @@ public class BytecodeListingTestGenerated extends AbstractBytecodeListingTest { runTest("compiler/testData/codegen/bytecodeListing/annotations/literals.kt"); } + @TestMetadata("localClassWithCapturedParams.kt") + public void testLocalClassWithCapturedParams() throws Exception { + runTest("compiler/testData/codegen/bytecodeListing/annotations/localClassWithCapturedParams.kt"); + } + @TestMetadata("noAdditionalAnnotationsInAccessors.kt") public void testNoAdditionalAnnotationsInAccessors() throws Exception { runTest("compiler/testData/codegen/bytecodeListing/annotations/noAdditionalAnnotationsInAccessors.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java index 8f5edf28507..56eb7a61994 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/LightAnalysisModeTestGenerated.java @@ -18934,6 +18934,11 @@ public class LightAnalysisModeTestGenerated extends AbstractLightAnalysisModeTes runTest("compiler/testData/codegen/box/reflection/annotations/findAnnotation.kt"); } + @TestMetadata("localClassParameterAnnotation.kt") + public void testLocalClassParameterAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/reflection/annotations/localClassParameterAnnotation.kt"); + } + @TestMetadata("openSuspendFun.kt") public void testOpenSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/reflection/annotations/openSuspendFun.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java index dabe86d0953..6c89d15f362 100644 --- a/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/codegen/ir/IrBlackBoxCodegenTestGenerated.java @@ -18939,6 +18939,11 @@ public class IrBlackBoxCodegenTestGenerated extends AbstractIrBlackBoxCodegenTes runTest("compiler/testData/codegen/box/reflection/annotations/findAnnotation.kt"); } + @TestMetadata("localClassParameterAnnotation.kt") + public void testLocalClassParameterAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/reflection/annotations/localClassParameterAnnotation.kt"); + } + @TestMetadata("openSuspendFun.kt") public void testOpenSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/reflection/annotations/openSuspendFun.kt"); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java index 61d0b1aaa93..fccf68c80f7 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaTestGenerated.java @@ -293,6 +293,11 @@ public class LoadJavaTestGenerated extends AbstractLoadJavaTest { runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.java"); } + @TestMetadata("AnnotatedParameterInInnerClassConstructor.java") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.java"); + } + @TestMetadata("AnnotatedValueParameter.java") public void testAnnotatedValueParameter() throws Exception { runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.java"); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaWithFastClassReadingTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaWithFastClassReadingTestGenerated.java index b50b0825aac..cff3c0af159 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaWithFastClassReadingTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/LoadJavaWithFastClassReadingTestGenerated.java @@ -291,6 +291,11 @@ public class LoadJavaWithFastClassReadingTestGenerated extends AbstractLoadJavaW runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.java"); } + @TestMetadata("AnnotatedParameterInInnerClassConstructor.java") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.java"); + } + @TestMetadata("AnnotatedValueParameter.java") public void testAnnotatedValueParameter() throws Exception { runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.java"); diff --git a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java index fde82426b34..b48957a9ea2 100644 --- a/compiler/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java +++ b/compiler/tests/org/jetbrains/kotlin/jvm/compiler/javac/LoadJavaUsingJavacTestGenerated.java @@ -293,6 +293,11 @@ public class LoadJavaUsingJavacTestGenerated extends AbstractLoadJavaUsingJavacT runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.java"); } + @TestMetadata("AnnotatedParameterInInnerClassConstructor.java") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.java"); + } + @TestMetadata("AnnotatedValueParameter.java") public void testAnnotatedValueParameter() throws Exception { runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.java"); diff --git a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java index 1ce394f1058..a5326fde822 100644 --- a/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java +++ b/core/descriptors.runtime/tests/org/jetbrains/kotlin/jvm/runtime/JvmRuntimeDescriptorLoaderTestGenerated.java @@ -3174,6 +3174,11 @@ public class JvmRuntimeDescriptorLoaderTestGenerated extends AbstractJvmRuntimeD runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedMethod.java"); } + @TestMetadata("AnnotatedParameterInInnerClassConstructor.java") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedParameterInInnerClassConstructor.java"); + } + @TestMetadata("AnnotatedValueParameter.java") public void testAnnotatedValueParameter() throws Exception { runTest("compiler/testData/loadJava/compiledJava/annotations/AnnotatedValueParameter.java"); diff --git a/idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor.expected.kt b/idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor.expected.kt new file mode 100644 index 00000000000..4fb130a8077 --- /dev/null +++ b/idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor.expected.kt @@ -0,0 +1,9 @@ +// IntelliJ API Decompiler stub source generated from a class file +// Implementation of methods is not available + +package test + +public final enum class AnnotatedParameterInEnumConstructor private constructor(@test.AnnoA a: kotlin.String, @test.AnnoB b: kotlin.String) : kotlin.Enum { + A; +} + diff --git a/idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.kt b/idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.kt new file mode 100644 index 00000000000..d2c28a62e00 --- /dev/null +++ b/idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.kt @@ -0,0 +1,8 @@ +package test + +annotation class AnnoA +annotation class AnnoB + +enum class AnnotatedParameterInEnumConstructor(@AnnoA a: String, @AnnoB b: String) { + A("1", "b") +} diff --git a/idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor.expected.kt b/idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor.expected.kt new file mode 100644 index 00000000000..5609f46b9c1 --- /dev/null +++ b/idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor.expected.kt @@ -0,0 +1,13 @@ +// IntelliJ API Decompiler stub source generated from a class file +// Implementation of methods is not available + +package test + +public final class AnnotatedParameterInInnerClassConstructor public constructor() { + public final inner class Inner public constructor(@test.AnnoA a: kotlin.String, @test.AnnoB b: kotlin.String) { + } + + public final inner class InnerGeneric public constructor(@test.AnnoA a: T, @test.AnnoB b: kotlin.String) { + } +} + diff --git a/idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.kt b/idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.kt new file mode 100644 index 00000000000..19c0f607160 --- /dev/null +++ b/idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.kt @@ -0,0 +1,15 @@ +package test + +annotation class AnnoA +annotation class AnnoB + +class AnnotatedParameterInInnerClassConstructor { + + inner class Inner(@AnnoA a: String, @AnnoB b: String) { + + } + + inner class InnerGeneric(@AnnoA a: T, @AnnoB b: String) { + + } +} \ No newline at end of file diff --git a/idea/testData/decompiler/stubBuilder/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.kt b/idea/testData/decompiler/stubBuilder/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.kt new file mode 100644 index 00000000000..d2c28a62e00 --- /dev/null +++ b/idea/testData/decompiler/stubBuilder/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.kt @@ -0,0 +1,8 @@ +package test + +annotation class AnnoA +annotation class AnnoB + +enum class AnnotatedParameterInEnumConstructor(@AnnoA a: String, @AnnoB b: String) { + A("1", "b") +} diff --git a/idea/testData/decompiler/stubBuilder/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.txt b/idea/testData/decompiler/stubBuilder/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.txt new file mode 100644 index 00000000000..6f666667ad8 --- /dev/null +++ b/idea/testData/decompiler/stubBuilder/AnnotatedParameterInEnumConstructor/AnnotatedParameterInEnumConstructor.txt @@ -0,0 +1,53 @@ +PsiJetFileStubImpl[package=test] + PACKAGE_DIRECTIVE + REFERENCE_EXPRESSION[referencedName=test] + IMPORT_LIST + CLASS[fqName=test.AnnotatedParameterInEnumConstructor, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=AnnotatedParameterInEnumConstructor, superNames=[Enum]] + MODIFIER_LIST[enum public final] + PRIMARY_CONSTRUCTOR + MODIFIER_LIST[private] + VALUE_PARAMETER_LIST + VALUE_PARAMETER[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=a] + MODIFIER_LIST[] + ANNOTATION_ENTRY[hasValueArguments=false, shortName=AnnoA] + CONSTRUCTOR_CALLEE + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=test] + REFERENCE_EXPRESSION[referencedName=AnnoA] + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=kotlin] + REFERENCE_EXPRESSION[referencedName=String] + VALUE_PARAMETER[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=b] + MODIFIER_LIST[] + ANNOTATION_ENTRY[hasValueArguments=false, shortName=AnnoB] + CONSTRUCTOR_CALLEE + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=test] + REFERENCE_EXPRESSION[referencedName=AnnoB] + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=kotlin] + REFERENCE_EXPRESSION[referencedName=String] + SUPER_TYPE_LIST + SUPER_TYPE_ENTRY + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=kotlin] + REFERENCE_EXPRESSION[referencedName=Enum] + TYPE_ARGUMENT_LIST + TYPE_PROJECTION[projectionKind=NONE] + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=test] + REFERENCE_EXPRESSION[referencedName=AnnotatedParameterInEnumConstructor] + CLASS_BODY + ENUM_ENTRY[fqName=test.AnnotatedParameterInEnumConstructor.A, isEnumEntry=true, isInterface=false, isLocal=false, isTopLevel=false, name=A, superNames=[]] diff --git a/idea/testData/decompiler/stubBuilder/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.kt b/idea/testData/decompiler/stubBuilder/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.kt new file mode 100644 index 00000000000..efb3618595c --- /dev/null +++ b/idea/testData/decompiler/stubBuilder/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.kt @@ -0,0 +1,16 @@ +package test + +annotation class AnnoA +annotation class AnnoB + +class AnnotatedParameterInInnerClassConstructor { + + inner class Inner(@AnnoA a: String, @AnnoB b: String) { + + } + + inner class InnerGeneric(@AnnoA a: T, @AnnoB + b: String) { + + } +} \ No newline at end of file diff --git a/idea/testData/decompiler/stubBuilder/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.txt b/idea/testData/decompiler/stubBuilder/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.txt new file mode 100644 index 00000000000..05957bbf64e --- /dev/null +++ b/idea/testData/decompiler/stubBuilder/AnnotatedParameterInInnerClassConstructor/AnnotatedParameterInInnerClassConstructor.txt @@ -0,0 +1,78 @@ +PsiJetFileStubImpl[package=test] + PACKAGE_DIRECTIVE + REFERENCE_EXPRESSION[referencedName=test] + IMPORT_LIST + CLASS[fqName=test.AnnotatedParameterInInnerClassConstructor, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=true, name=AnnotatedParameterInInnerClassConstructor, superNames=[]] + MODIFIER_LIST[public final] + PRIMARY_CONSTRUCTOR + MODIFIER_LIST[public] + VALUE_PARAMETER_LIST + CLASS_BODY + CLASS[fqName=test.AnnotatedParameterInInnerClassConstructor.Inner, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=false, name=Inner, superNames=[]] + MODIFIER_LIST[inner public final] + PRIMARY_CONSTRUCTOR + MODIFIER_LIST[public] + VALUE_PARAMETER_LIST + VALUE_PARAMETER[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=a] + MODIFIER_LIST[] + ANNOTATION_ENTRY[hasValueArguments=false, shortName=AnnoA] + CONSTRUCTOR_CALLEE + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=test] + REFERENCE_EXPRESSION[referencedName=AnnoA] + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=kotlin] + REFERENCE_EXPRESSION[referencedName=String] + VALUE_PARAMETER[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=b] + MODIFIER_LIST[] + ANNOTATION_ENTRY[hasValueArguments=false, shortName=AnnoB] + CONSTRUCTOR_CALLEE + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=test] + REFERENCE_EXPRESSION[referencedName=AnnoB] + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=kotlin] + REFERENCE_EXPRESSION[referencedName=String] + CLASS_BODY + CLASS[fqName=test.AnnotatedParameterInInnerClassConstructor.InnerGeneric, isEnumEntry=false, isInterface=false, isLocal=false, isTopLevel=false, name=InnerGeneric, superNames=[]] + MODIFIER_LIST[inner public final] + TYPE_PARAMETER_LIST + TYPE_PARAMETER[fqName=null, isInVariance=false, isOutVariance=false, name=T] + PRIMARY_CONSTRUCTOR + MODIFIER_LIST[public] + VALUE_PARAMETER_LIST + VALUE_PARAMETER[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=a] + MODIFIER_LIST[] + ANNOTATION_ENTRY[hasValueArguments=false, shortName=AnnoA] + CONSTRUCTOR_CALLEE + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=test] + REFERENCE_EXPRESSION[referencedName=AnnoA] + TYPE_REFERENCE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=T] + VALUE_PARAMETER[fqName=null, hasDefaultValue=false, hasValOrVar=false, isMutable=false, name=b] + MODIFIER_LIST[] + ANNOTATION_ENTRY[hasValueArguments=false, shortName=AnnoB] + CONSTRUCTOR_CALLEE + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=test] + REFERENCE_EXPRESSION[referencedName=AnnoB] + TYPE_REFERENCE + USER_TYPE + USER_TYPE + REFERENCE_EXPRESSION[referencedName=kotlin] + REFERENCE_EXPRESSION[referencedName=String] + CLASS_BODY diff --git a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassSanityTestGenerated.java b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassSanityTestGenerated.java index 3ed0f8a4569..4f561f73c00 100644 --- a/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassSanityTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/asJava/classes/UltraLightClassSanityTestGenerated.java @@ -29,6 +29,16 @@ public class UltraLightClassSanityTestGenerated extends AbstractUltraLightClassS KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^(.+)\\.(kt|kts)$"), TargetBackend.ANY, true); } + @TestMetadata("AnnotatedParameterInEnumConstructor.kt") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt"); + } + + @TestMetadata("AnnotatedParameterInInnerClassConstructor.kt") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt"); + } + @TestMetadata("AnnotationClass.kt") public void testAnnotationClass() throws Exception { runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeCompiledLightClassTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeCompiledLightClassTestGenerated.java index 8ed672ff995..e0da9dd27e4 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeCompiledLightClassTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeCompiledLightClassTestGenerated.java @@ -29,6 +29,16 @@ public class IdeCompiledLightClassTestGenerated extends AbstractIdeCompiledLight KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true, "local", "compilationErrors", "ideRegression"); } + @TestMetadata("AnnotatedParameterInEnumConstructor.kt") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt"); + } + + @TestMetadata("AnnotatedParameterInInnerClassConstructor.kt") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt"); + } + @TestMetadata("AnnotationClass.kt") public void testAnnotationClass() throws Exception { runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassTestGenerated.java index c71b80a6929..5fa215fbfe9 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/caches/resolve/IdeLightClassTestGenerated.java @@ -29,6 +29,16 @@ public class IdeLightClassTestGenerated extends AbstractIdeLightClassTest { KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("compiler/testData/asJava/lightClasses"), Pattern.compile("^([^.]+)\\.(kt|kts)$"), TargetBackend.ANY, true, "delegation"); } + @TestMetadata("AnnotatedParameterInEnumConstructor.kt") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/AnnotatedParameterInEnumConstructor.kt"); + } + + @TestMetadata("AnnotatedParameterInInnerClassConstructor.kt") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("compiler/testData/asJava/lightClasses/AnnotatedParameterInInnerClassConstructor.kt"); + } + @TestMetadata("AnnotationClass.kt") public void testAnnotationClass() throws Exception { runTest("compiler/testData/asJava/lightClasses/AnnotationClass.kt"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java index 3b2e01e560c..4ed84fc6baf 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/stubBuilder/ClsStubBuilderTestGenerated.java @@ -34,6 +34,16 @@ public class ClsStubBuilderTestGenerated extends AbstractClsStubBuilderTest { runTest("idea/testData/decompiler/stubBuilder/AnnotatedFlexibleTypes/"); } + @TestMetadata("AnnotatedParameterInEnumConstructor") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("idea/testData/decompiler/stubBuilder/AnnotatedParameterInEnumConstructor/"); + } + + @TestMetadata("AnnotatedParameterInInnerClassConstructor") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("idea/testData/decompiler/stubBuilder/AnnotatedParameterInInnerClassConstructor/"); + } + @TestMetadata("AnnotationClass") public void testAnnotationClass() throws Exception { runTest("idea/testData/decompiler/stubBuilder/AnnotationClass/"); diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java index a953aca7cbc..27e8f11176a 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextFromJsMetadataTestGenerated.java @@ -34,6 +34,16 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom runTest("idea/testData/decompiler/decompiledText/AnnotatedEnumEntry/"); } + @TestMetadata("AnnotatedParameterInEnumConstructor") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor/"); + } + + @TestMetadata("AnnotatedParameterInInnerClassConstructor") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor/"); + } + @TestMetadata("Annotations") public void testAnnotations() throws Exception { runTest("idea/testData/decompiler/decompiledText/Annotations/"); @@ -137,6 +147,32 @@ public class CommonDecompiledTextFromJsMetadataTestGenerated extends AbstractCom } } + @TestMetadata("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotatedParameterInEnumConstructor extends AbstractCommonDecompiledTextFromJsMetadataTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInAnnotatedParameterInEnumConstructor() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JS, true); + } + } + + @TestMetadata("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotatedParameterInInnerClassConstructor extends AbstractCommonDecompiledTextFromJsMetadataTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.JS, testDataFilePath); + } + + public void testAllFilesPresentInAnnotatedParameterInInnerClassConstructor() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor"), Pattern.compile("^([^\\.]+)$"), TargetBackend.JS, true); + } + } + @TestMetadata("idea/testData/decompiler/decompiledText/Annotations") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java index 5354d7d5126..7ea8de879c5 100644 --- a/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java +++ b/idea/tests/org/jetbrains/kotlin/idea/decompiler/textBuilder/CommonDecompiledTextTestGenerated.java @@ -34,6 +34,16 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT runTest("idea/testData/decompiler/decompiledText/AnnotatedEnumEntry/"); } + @TestMetadata("AnnotatedParameterInEnumConstructor") + public void testAnnotatedParameterInEnumConstructor() throws Exception { + runTest("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor/"); + } + + @TestMetadata("AnnotatedParameterInInnerClassConstructor") + public void testAnnotatedParameterInInnerClassConstructor() throws Exception { + runTest("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor/"); + } + @TestMetadata("Annotations") public void testAnnotations() throws Exception { runTest("idea/testData/decompiler/decompiledText/Annotations/"); @@ -142,6 +152,32 @@ public class CommonDecompiledTextTestGenerated extends AbstractCommonDecompiledT } } + @TestMetadata("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotatedParameterInEnumConstructor extends AbstractCommonDecompiledTextTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInAnnotatedParameterInEnumConstructor() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInEnumConstructor"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); + } + } + + @TestMetadata("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor") + @TestDataPath("$PROJECT_ROOT") + @RunWith(JUnit3RunnerWithInners.class) + public static class AnnotatedParameterInInnerClassConstructor extends AbstractCommonDecompiledTextTest { + private void runTest(String testDataFilePath) throws Exception { + KotlinTestUtils.runTest(this::doTest, TargetBackend.ANY, testDataFilePath); + } + + public void testAllFilesPresentInAnnotatedParameterInInnerClassConstructor() throws Exception { + KotlinTestUtils.assertAllTestsPresentByMetadata(this.getClass(), new File("idea/testData/decompiler/decompiledText/AnnotatedParameterInInnerClassConstructor"), Pattern.compile("^([^\\.]+)$"), TargetBackend.ANY, true); + } + } + @TestMetadata("idea/testData/decompiler/decompiledText/Annotations") @TestDataPath("$PROJECT_ROOT") @RunWith(JUnit3RunnerWithInners.class) diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java index b26cdca7d8d..ae0fd560850 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/IrJsCodegenBoxTestGenerated.java @@ -16474,6 +16474,11 @@ public class IrJsCodegenBoxTestGenerated extends AbstractIrJsCodegenBoxTest { runTest("compiler/testData/codegen/box/reflection/annotations/findAnnotation.kt"); } + @TestMetadata("localClassParameterAnnotation.kt") + public void testLocalClassParameterAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/reflection/annotations/localClassParameterAnnotation.kt"); + } + @TestMetadata("openSuspendFun.kt") public void testOpenSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/reflection/annotations/openSuspendFun.kt"); diff --git a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java index 8d432bc6feb..e2def4c6bbd 100644 --- a/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java +++ b/js/js.tests/test/org/jetbrains/kotlin/js/test/semantics/JsCodegenBoxTestGenerated.java @@ -17519,6 +17519,11 @@ public class JsCodegenBoxTestGenerated extends AbstractJsCodegenBoxTest { runTest("compiler/testData/codegen/box/reflection/annotations/findAnnotation.kt"); } + @TestMetadata("localClassParameterAnnotation.kt") + public void testLocalClassParameterAnnotation() throws Exception { + runTest("compiler/testData/codegen/box/reflection/annotations/localClassParameterAnnotation.kt"); + } + @TestMetadata("openSuspendFun.kt") public void testOpenSuspendFun() throws Exception { runTest("compiler/testData/codegen/box/reflection/annotations/openSuspendFun.kt"); diff --git a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt index d9ecdbe0f7a..7017b3f3e7d 100644 --- a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt +++ b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/ClassFileToSourceStubConverter.kt @@ -382,7 +382,7 @@ class ClassFileToSourceStubConverter( if (it.name == "valueOf" && it.desc == "(Ljava/lang/String;)L${clazz.name};") return@mapJList null } - convertMethod(it, clazz, lineMappings, packageFqName) + convertMethod(it, clazz, lineMappings, packageFqName, isInner) } val nestedClasses = mapJList(clazz.innerClasses) { innerClass -> @@ -626,7 +626,8 @@ class ClassFileToSourceStubConverter( method: MethodNode, containingClass: ClassNode, lineMappings: KaptLineMappingCollector, - packageFqName: String + packageFqName: String, + isInner: Boolean ): JCMethodDecl? { if (isIgnored(method.invisibleAnnotations)) return null val descriptor = kaptContext.origins[method]?.descriptor as? CallableDescriptor ?: return null @@ -659,7 +660,7 @@ class ClassFileToSourceStubConverter( val asmReturnType = Type.getReturnType(method.desc) val jcReturnType = if (isConstructor) null else treeMaker.Type(asmReturnType) - val parametersInfo = method.getParametersInfo(containingClass) + val parametersInfo = method.getParametersInfo(containingClass, isInner) if (!checkIfValidTypeName(containingClass, asmReturnType) || parametersInfo.any { !checkIfValidTypeName(containingClass, it.type) } diff --git a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/parseParameters.kt b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/parseParameters.kt index 0f0fe0c18a4..bc750136ff0 100644 --- a/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/parseParameters.kt +++ b/plugins/kapt3/kapt3-compiler/src/org/jetbrains/kotlin/kapt3/stubs/parseParameters.kt @@ -16,6 +16,7 @@ package org.jetbrains.kotlin.kapt3.stubs +import org.jetbrains.kotlin.codegen.AsmUtil import org.jetbrains.kotlin.kapt3.util.isAbstract import org.jetbrains.kotlin.kapt3.util.isEnum import org.jetbrains.kotlin.kapt3.util.isJvmOverloadsGenerated @@ -34,7 +35,7 @@ internal class ParameterInfo( val invisibleAnnotations: List? ) -internal fun MethodNode.getParametersInfo(containingClass: ClassNode): List { +internal fun MethodNode.getParametersInfo(containingClass: ClassNode, isInnerClassMember: Boolean): List { val localVariables = this.localVariables ?: emptyList() val parameters = this.parameters ?: emptyList() val isStatic = isStatic(access) @@ -42,7 +43,9 @@ internal fun MethodNode.getParametersInfo(containingClass: ClassNode): List") 1 else 0 val parameterTypes = Type.getArgumentTypes(desc) @@ -71,8 +74,9 @@ internal fun MethodNode.getParametersInfo(containingClass: ClassNode): List