Update synthetic parameter processing logic according to ASM 7 changes

#KT-27774 Fixed

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<Type> STRING_BUILDER_OBJECT_APPEND_ARG_TYPES = Sets.newHashSet(
             getType(String.class),
             getType(StringBuffer.class),

compiler/backend/src/org/jetbrains/kotlin/codegen/FunctionCodegen.java

@@ -517,12 +517,27 @@ public class FunctionCodegen {
 
         Iterator<ValueParameterDescriptor> iterator = valueParameters.iterator();
         List<JvmMethodParameterSignature> 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());
             }
         }
     }

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) {}

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)
+}

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 =

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();

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);

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 */ }
+}

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")
+}

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 <T> {
+        public InnerGeneric(@test.Anno(x = "a") T $outer, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String a) { /* compiled code */ }
+    }
+}

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 <T> {
+        public InnerGeneric(@test.Anno(x = "a") T a, @test.Anno(x = "b") @org.jetbrains.annotations.NotNull java.lang.String b) { /* compiled code */ }
+    }
+}

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<T>(@Anno("a") a: T, @Anno("b") b: String) {
+
+    }
+}

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
+}

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")
+}

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 <init>(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
+}

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 <init>(p0: int): void
+    public synthetic @Ann method <init>(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 <init>(p0: Sealed, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    private method <init>(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 <init>(@Ann p0: int): void
+    public synthetic method <init>(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 <init>(p0: Test, p1: int, @Ann p2: int, @Ann p3: java.lang.String, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    private method <init>(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 <init>(@Ann p0: int, p1: kotlin.jvm.internal.DefaultConstructorMarker): void
+    private method <init>(p0: int): void
+    public synthetic @Ann method <init>(p0: int, @Ann p1: int, p2: kotlin.jvm.internal.DefaultConstructorMarker): void
+    private @Ann method <init>(p0: int, @Ann p1: java.lang.String): void
+    private method <init>(p0: int, p1: int): void
+    public final method getZ(): int
+}
+
+@kotlin.Metadata
+public final class Z {
+    private final field x: int
+    private synthetic method <init>(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
+}

compiler/testData/codegen/bytecodeListing/jvmOverloadsAndParametersAnnotations.txt.183

@@ -0,0 +1,133 @@
+@kotlin.Metadata
+public final class ASimpleClass {
+    public method <init>(): 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 <clinit>(): void
+    private method <init>(): 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 <init>(): void
+    public synthetic method <init>(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 <clinit>(): void
+    public method <init>(): 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 <init>(p0: DClassConstuctors, @StringRes p1: int): void
+    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, @DefRes p2: int, @LongRes p3: long): void
+    public @kotlin.jvm.JvmOverloads method <init>(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 <init>(p0: DClassConstuctors, @StringRes p1: int, @LongRes p2: long): void
+    public @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, @StringRes p1: int, p2: int): void
+    public synthetic @kotlin.jvm.JvmOverloads method <init>(p0: DClassConstuctors, p1: int, p2: int, p3: int, p4: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public synthetic @kotlin.jvm.JvmOverloads method <init>(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 <init>(@StringRes p0: int): void
+    public @kotlin.jvm.JvmOverloads method <init>(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long): void
+    public @kotlin.jvm.JvmOverloads method <init>(@StringRes p0: int, @DefRes p1: int, @LongRes p2: long, @org.jetbrains.annotations.NotNull p3: java.lang.String): void
+    public @kotlin.jvm.JvmOverloads method <init>(@StringRes p0: int, @LongRes p1: long): void
+    public @kotlin.jvm.JvmOverloads method <init>(@StringRes p0: int, p1: int): void
+    public synthetic @kotlin.jvm.JvmOverloads method <init>(p0: int, p1: int, p2: int, p3: kotlin.jvm.internal.DefaultConstructorMarker): void
+    public synthetic @kotlin.jvm.JvmOverloads method <init>(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

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<T> {
+        InnerGeneric(@Anno("a") String a , @Anno("b")  String 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</*0*/ T : kotlin.Any!> {
+        public/*package*/ constructor InnerGeneric</*0*/ T : kotlin.Any!>(/*0*/ @test.AnnotatedParameterInInnerClassConstructor.Anno(value = "a") p0: kotlin.String!, /*1*/ @test.AnnotatedParameterInInnerClassConstructor.Anno(value = "b") p1: kotlin.String!)
+    }
+}

compiler/tests-common/tests/org/jetbrains/kotlin/codegen/AbstractBytecodeListingTest.kt

@@ -160,8 +160,12 @@ class BytecodeListingTextCollectingVisitor(val filter: Filter, val withSignature
         val parameterAnnotations = hashMapOf<Int, MutableList<String>>()
 
         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
+                }
+            }
         }
     }
 

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");

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");

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");

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");

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");

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");

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");

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");

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");

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<test.AnnotatedParameterInEnumConstructor> {
+    A;
+}
+

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")
+}

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<T> public constructor(@test.AnnoA a: T, @test.AnnoB b: kotlin.String) {
+    }
+}
+

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<T>(@AnnoA a: T, @AnnoB b: String) {
+
+    }
+}

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")
+}

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=[]]

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<T>(@AnnoA a: T, @AnnoB
+    b: String) {
+
+    }
+}

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

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");

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");

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");

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/");

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)

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)

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");

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");

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<InnerClassNode, JCTree>(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) }

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<AnnotationNode>?
 )
 
-internal fun MethodNode.getParametersInfo(containingClass: ClassNode): List<ParameterInfo> {
+internal fun MethodNode.getParametersInfo(containingClass: ClassNode, isInnerClassMember: Boolean): List<ParameterInfo> {
     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<Para
 
     // First and second parameters in enum constructors are synthetic, we should ignore them
     val isEnumConstructor = (name == "<init>") && containingClass.isEnum()
-    val startParameterIndex = if (isEnumConstructor) 2 else 0
+    val startParameterIndex =
+        if (isEnumConstructor) 2 else
+            if (isInnerClassMember && name == "<init>") 1 else 0
 
     val parameterTypes = Type.getArgumentTypes(desc)
 
@@ -71,8 +74,9 @@ internal fun MethodNode.getParametersInfo(containingClass: ClassNode): List<Para
             name = "p${index - startParameterIndex}"
         }
 
-        val visibleAnnotations = visibleParameterAnnotations?.get(index)
+        val indexForAnnotation = if (AsmUtil.IS_BUILT_WITH_ASM6) index else index - startParameterIndex
-        val invisibleAnnotations = invisibleParameterAnnotations?.get(index)
+        val visibleAnnotations = visibleParameterAnnotations?.get(indexForAnnotation)
+        val invisibleAnnotations = invisibleParameterAnnotations?.get(indexForAnnotation)
         parameterInfos += ParameterInfo(0, name, type, visibleAnnotations, invisibleAnnotations)
     }
     return parameterInfos