Support type annotations

#KT-35843 Fixed

compiler/testData/codegen/asmLike/typeAnnotations/complex.kt

@@ -0,0 +1,51 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann2
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann3
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann4
+
+class Bar<T>
+
+class Kotlin {
+
+    fun foo(s: @Ann Bar<@Ann2 String>) {
+    }
+
+    fun foo(): @Ann Bar<@Ann2 String>? {
+        return null
+    }
+
+    fun fooArray(s: @Ann Array<@Ann2 Bar<@Ann3 String>>) {
+    }
+
+    fun fooArray(): @Ann Array<@Ann2 Bar<@Ann3 String>>? {
+        return null
+    }
+
+    fun fooArrayArray(s: @Ann Array<@Ann2 Array<@Ann3 Bar<@Ann4 String>>>) {
+    }
+
+    fun fooArrayArray(): @Ann Array<@Ann2 Array<@Ann3 Bar<@Ann4 String>>>? {
+        return null
+    }
+
+
+    fun <T> foo(s: @Ann T) {
+    }
+
+    fun <T> fooGeneric(s: @Ann Bar<@Ann2 T>) {
+    }
+}

compiler/testData/codegen/asmLike/typeAnnotations/complex.txt

@@ -0,0 +1,60 @@
+public abstract interface foo/Ann : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann2 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann3 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann4 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public final class foo/Bar : java/lang/Object {
+    public void <init>()
+}
+
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+
+    public final void foo(foo.Bar s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/Ann2;([]) : METHOD_FORMAL_PARAMETER 0, 0;
+
+    public final foo.Bar foo()
+      @Lfoo/Ann;([]) : METHOD_RETURN, null
+      @Lfoo/Ann2;([]) : METHOD_RETURN, 0;
+
+    public final void foo(java.lang.Object s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+
+    public final void fooArray(foo.Bar[] s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/Ann2;([]) : METHOD_FORMAL_PARAMETER 0, [
+      @Lfoo/Ann3;([]) : METHOD_FORMAL_PARAMETER 0, [0;
+
+    public final foo.Bar[] fooArray()
+      @Lfoo/Ann;([]) : METHOD_RETURN, null
+      @Lfoo/Ann2;([]) : METHOD_RETURN, [
+      @Lfoo/Ann3;([]) : METHOD_RETURN, [0;
+
+    public final void fooArrayArray(foo.Bar[][] s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/Ann2;([]) : METHOD_FORMAL_PARAMETER 0, [
+      @Lfoo/Ann3;([]) : METHOD_FORMAL_PARAMETER 0, [[
+      @Lfoo/Ann4;([]) : METHOD_FORMAL_PARAMETER 0, [[0;
+
+    public final foo.Bar[][] fooArrayArray()
+      @Lfoo/Ann;([]) : METHOD_RETURN, null
+      @Lfoo/Ann2;([]) : METHOD_RETURN, [
+      @Lfoo/Ann3;([]) : METHOD_RETURN, [[
+      @Lfoo/Ann4;([]) : METHOD_RETURN, [[0;
+
+    public final void fooGeneric(foo.Bar s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/Ann2;([]) : METHOD_FORMAL_PARAMETER 0, 0;
+}

compiler/testData/codegen/asmLike/typeAnnotations/constructor.kt

@@ -0,0 +1,18 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+class Kotlin(s: @TypeAnn("1") String, p: @TypeAnn("123") String) {
+
+    private constructor(s: @TypeAnn("private") String) : this("1", "2")
+
+    fun foo() {
+        { Kotlin("123") }()
+    }
+}

compiler/testData/codegen/asmLike/typeAnnotations/constructor.txt

@@ -0,0 +1,28 @@
+final class foo/Kotlin$foo$1 : kotlin/jvm/internal/Lambda, kotlin/jvm/functions/Function0 {
+    public final static foo.Kotlin$foo$1 INSTANCE
+
+    static void <clinit>()
+
+    void <init>()
+
+    public java.lang.Object invoke()
+
+    public final foo.Kotlin invoke()
+}
+
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>(java.lang.String s, java.lang.String p)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="123"]) : METHOD_FORMAL_PARAMETER 1, null
+
+    private void <init>(java.lang.String s)
+      @Lfoo/TypeAnn;([name="private"]) : METHOD_FORMAL_PARAMETER 0, null
+
+    public void <init>(java.lang.String s, kotlin.jvm.internal.DefaultConstructorMarker $constructor_marker)
+
+    public final void foo()
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+    public abstract java.lang.String name()
+}

compiler/testData/codegen/asmLike/typeAnnotations/defaultArgs.kt

@@ -0,0 +1,17 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+class Kotlin {
+
+    fun foo(s: @TypeAnn("1") String = "1", x: @TypeAnn("2") Int = 123): @TypeAnn("return") Any? {
+        return null
+    }
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/defaultArgs.txt

@@ -0,0 +1,14 @@
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+
+    public final java.lang.Object foo(java.lang.String s, int x)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_FORMAL_PARAMETER 1, null
+      @Lfoo/TypeAnn;([name="return"]) : METHOD_RETURN, null
+
+    public static java.lang.Object foo$default(foo.Kotlin p0, java.lang.String p1, int p2, int p3, java.lang.Object p4)
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+    public abstract java.lang.String name()
+}

compiler/testData/codegen/asmLike/typeAnnotations/enumClassConstructor.kt

@@ -0,0 +1,16 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn
+
+enum class Kotlin (s: @TypeAnn String) {
+    A("123") {
+        fun foo() {}
+    };
+}

compiler/testData/codegen/asmLike/typeAnnotations/enumClassConstructor.txt

@@ -0,0 +1,26 @@
+final class foo/Kotlin$A : foo/Kotlin {
+    void <init>(java.lang.String $enum_name_or_ordinal$0, int $enum_name_or_ordinal$1)
+
+    public final void foo()
+}
+
+public class foo/Kotlin : java/lang/Enum {
+    private final static foo.Kotlin[] $VALUES
+
+    public final static foo.Kotlin A
+
+    static void <clinit>()
+
+    private void <init>(java.lang.String $enum_name_or_ordinal$0, int $enum_name_or_ordinal$1, java.lang.String s)
+      @Lfoo/TypeAnn;([]) : METHOD_FORMAL_PARAMETER 0, null
+
+    public void <init>(java.lang.String $enum_name_or_ordinal$0, int $enum_name_or_ordinal$1, java.lang.String s, kotlin.jvm.internal.DefaultConstructorMarker $constructor_marker)
+
+    public static foo.Kotlin valueOf(java.lang.String p0)
+
+    public static foo.Kotlin[] values()
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/extension.kt

@@ -0,0 +1,15 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+class Kotlin {
+
+    fun @TypeAnn("ext") String.foo2(s: @TypeAnn("param") String) {
+    }
+}

compiler/testData/codegen/asmLike/typeAnnotations/extension.txt

@@ -0,0 +1,11 @@
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+
+    public final void foo2(java.lang.String $this$foo2, java.lang.String s)
+      @Lfoo/TypeAnn;([name="ext"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="param"]) : METHOD_FORMAL_PARAMETER 1, null
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+    public abstract java.lang.String name()
+}

compiler/testData/codegen/asmLike/typeAnnotations/implicit.kt

@@ -0,0 +1,29 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+@Target(AnnotationTarget.TYPE)
+@Retention(AnnotationRetention.BINARY)
+annotation class TypeAnnBinary
+
+@Target(AnnotationTarget.TYPE)
+@Retention(AnnotationRetention.SOURCE)
+annotation class TypeAnnSource
+
+class Kotlin {
+
+    fun foo2(): @TypeAnn("2") @TypeAnnBinary @TypeAnnSource String {
+        return "OK"
+    }
+
+    fun foo3() = foo2()
+
+    fun foo4() = { foo2() }()
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/implicit.txt

@@ -0,0 +1,39 @@
+final class foo/Kotlin$foo4$1 : kotlin/jvm/internal/Lambda, kotlin/jvm/functions/Function0 {
+    final foo.Kotlin this$0
+
+    void <init>(foo.Kotlin p0)
+
+    public java.lang.Object invoke()
+
+    public final java.lang.String invoke()
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_RETURN, null
+      @Lfoo/TypeAnnBinary;([]) : METHOD_RETURN, null // invisible
+}
+
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+
+    public final java.lang.String foo2()
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_RETURN, null
+      @Lfoo/TypeAnnBinary;([]) : METHOD_RETURN, null // invisible
+
+    public final java.lang.String foo3()
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_RETURN, null
+      @Lfoo/TypeAnnBinary;([]) : METHOD_RETURN, null // invisible
+
+    public final java.lang.String foo4()
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_RETURN, null
+      @Lfoo/TypeAnnBinary;([]) : METHOD_RETURN, null // invisible
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+    public abstract java.lang.String name()
+}
+
+public abstract interface foo/TypeAnnBinary : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/TypeAnnSource : java/lang/Object, java/lang/annotation/Annotation {
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/innerClassConstructor.kt

@@ -0,0 +1,13 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn
+
+class Kotlin {
+    inner class Inner(s: @TypeAnn String) {}
+}

compiler/testData/codegen/asmLike/typeAnnotations/innerClassConstructor.txt

@@ -0,0 +1,14 @@
+public final class foo/Kotlin$Inner : java/lang/Object {
+    final foo.Kotlin this$0
+
+    public void <init>(foo.Kotlin $outer, java.lang.String s)
+      @Lfoo/TypeAnn;([]) : METHOD_FORMAL_PARAMETER 0, null
+}
+
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/jvmOverload.kt

@@ -0,0 +1,17 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+class FooClass {
+    @JvmOverloads
+    fun foo(s: @TypeAnn("1") String = "1", x: @TypeAnn("2") Int = 123) : @TypeAnn("return") Any? {
+        return null
+    }
+}

compiler/testData/codegen/asmLike/typeAnnotations/jvmOverload.txt

@@ -0,0 +1,21 @@
+public final class foo/FooClass : java/lang/Object {
+    public void <init>()
+
+    public final java.lang.Object foo(java.lang.String s, int x)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_FORMAL_PARAMETER 1, null
+      @Lfoo/TypeAnn;([name="return"]) : METHOD_RETURN, null
+
+    public final java.lang.Object foo(java.lang.String s)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="return"]) : METHOD_RETURN, null
+
+    public final java.lang.Object foo()
+      @Lfoo/TypeAnn;([name="return"]) : METHOD_RETURN, null
+
+    public static java.lang.Object foo$default(foo.FooClass p0, java.lang.String p1, int p2, int p3, java.lang.Object p4)
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+    public abstract java.lang.String name()
+}

compiler/testData/codegen/asmLike/typeAnnotations/jvmStatic.kt

@@ -0,0 +1,28 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+class FooClass {
+
+    companion object {
+        @JvmStatic
+        fun foo(s: @TypeAnn("1") String, x: @TypeAnn("2") Int): @TypeAnn("return") Any? {
+            return null
+        }
+    }
+
+}
+
+object Foo {
+    @JvmStatic
+    fun foo(s: @TypeAnn("1") String , x: @TypeAnn("2") Int): @TypeAnn("return") Any? {
+        return null
+    }
+}

compiler/testData/codegen/asmLike/typeAnnotations/jvmStatic.txt

@@ -0,0 +1,40 @@
+public final class foo/Foo : java/lang/Object {
+    public final static foo.Foo INSTANCE
+
+    static void <clinit>()
+
+    private void <init>()
+
+    public final static java.lang.Object foo(java.lang.String s, int x)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_FORMAL_PARAMETER 1, null
+      @Lfoo/TypeAnn;([name="return"]) : METHOD_RETURN, null
+}
+
+public final class foo/FooClass$Companion : java/lang/Object {
+    private void <init>()
+
+    public void <init>(kotlin.jvm.internal.DefaultConstructorMarker $constructor_marker)
+
+    public final java.lang.Object foo(java.lang.String s, int x)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_FORMAL_PARAMETER 1, null
+      @Lfoo/TypeAnn;([name="return"]) : METHOD_RETURN, null
+}
+
+public final class foo/FooClass : java/lang/Object {
+    public final static foo.FooClass$Companion Companion
+
+    static void <clinit>()
+
+    public void <init>()
+
+    public final static java.lang.Object foo(java.lang.String s, int x)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_FORMAL_PARAMETER 1, null
+      @Lfoo/TypeAnn;([name="return"]) : METHOD_RETURN, null
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+    public abstract java.lang.String name()
+}

compiler/testData/codegen/asmLike/typeAnnotations/notYetSupported.kt

@@ -0,0 +1,57 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann2
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann3
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann4
+
+class Bar<T>
+
+class Outer {
+    inner class Inner<T>
+}
+
+class Kotlin {
+
+    fun foo(s: @Ann Outer.Inner<@Ann2 String>) {
+    }
+
+    fun foo(): @Ann Outer.Inner<@Ann2 String>? {
+        return null
+    }
+
+    fun fooArray(s: @Ann Array<@Ann2 Outer.Inner<@Ann3 String>>) {
+    }
+
+    fun fooArray(): @Ann Array<@Ann2 Outer.Inner<@Ann3 String>>? {
+        return null
+    }
+
+    fun fooArrayIn(s: @Ann Array<in @Ann2 Outer.Inner<@Ann3 String>>) {
+    }
+
+    fun fooArrayOut(): @Ann Array<out @Ann2 Outer.Inner<@Ann3 String>>? {
+        return null
+    }
+
+
+    fun <T> fooGenericIn(s: @Ann Bar<in @Ann2 T>) {
+    }
+
+    fun <T> fooGenericOut(s: @Ann Bar<out @Ann2 T>) {
+    }
+
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/notYetSupported.txt

@@ -0,0 +1,55 @@
+public abstract interface foo/Ann : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann2 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann3 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann4 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public final class foo/Bar : java/lang/Object {
+    public void <init>()
+}
+
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+
+    public final void foo(foo.Outer$Inner s)
+
+    public final foo.Outer$Inner foo()
+
+    public final void fooArray(foo.Outer$Inner[] s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+
+    public final foo.Outer$Inner[] fooArray()
+      @Lfoo/Ann;([]) : METHOD_RETURN, null
+
+    public final void fooArrayIn(java.lang.Object[] s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+
+    public final foo.Outer$Inner[] fooArrayOut()
+      @Lfoo/Ann;([]) : METHOD_RETURN, null
+
+    public final void fooGenericIn(foo.Bar s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+
+    public final void fooGenericOut(foo.Bar s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+}
+
+public final class foo/Outer$Inner : java/lang/Object {
+    final foo.Outer this$0
+
+    public void <init>(foo.Outer $outer)
+}
+
+public final class foo/Outer : java/lang/Object {
+    public void <init>()
+}

compiler/testData/codegen/asmLike/typeAnnotations/property.kt

@@ -0,0 +1,43 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+// WITH_RUNTIME
+// WITH_REFLECT
+// FULL_JDK
+package foo
+
+import java.lang.reflect.AnnotatedType
+import kotlin.reflect.jvm.javaMethod
+import kotlin.test.fail
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+@Target(AnnotationTarget.TYPE)
+@Retention(AnnotationRetention.BINARY)
+annotation class TypeAnnBinary
+
+@Target(AnnotationTarget.TYPE)
+@Retention(AnnotationRetention.SOURCE)
+annotation class TypeAnnSource
+
+class Kotlin {
+
+    val valProp: @TypeAnn("1") @TypeAnnBinary @TypeAnnSource String = "123"
+
+    var varProp: @TypeAnn("1") @TypeAnnBinary @TypeAnnSource String = "123"
+
+    var customSetter: @TypeAnn("1") @TypeAnnBinary @TypeAnnSource String = "123"
+        set(field: String) {}
+
+    @JvmField
+    var jvmField: @TypeAnn("1") @TypeAnnBinary @TypeAnnSource String = "123"
+
+    lateinit var lateinitProp: @TypeAnn("1") @TypeAnnBinary @TypeAnnSource String
+
+    companion object {
+        var companionVarProperty: @TypeAnn("1") @TypeAnnBinary @TypeAnnSource String = "123"
+    }
+}

compiler/testData/codegen/asmLike/typeAnnotations/simple.kt

@@ -0,0 +1,39 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+@Target(AnnotationTarget.TYPE)
+@Retention(AnnotationRetention.BINARY)
+annotation class TypeAnnBinary
+
+@Target(AnnotationTarget.TYPE)
+@Retention(AnnotationRetention.SOURCE)
+annotation class TypeAnnSource
+
+class Kotlin {
+
+    private fun foo(s: @TypeAnn("1") @TypeAnnBinary @TypeAnnSource String) {
+    }
+
+    fun foo2(): @TypeAnn("2") @TypeAnnBinary @TypeAnnSource String {
+        return "OK"
+    }
+
+    fun fooArray(s: Array<@TypeAnn("3") @TypeAnnBinary @TypeAnnSource String>) {
+    }
+
+    fun fooArray2(): Array<@TypeAnn("4") @TypeAnnBinary @TypeAnnSource String>? {
+        {
+            foo2()
+            foo("123")
+        }()
+        return null
+    }
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/simple.txt

@@ -0,0 +1,43 @@
+final class foo/Kotlin$fooArray2$1 : kotlin/jvm/internal/Lambda, kotlin/jvm/functions/Function0 {
+    final foo.Kotlin this$0
+
+    void <init>(foo.Kotlin p0)
+
+    public java.lang.Object invoke()
+
+    public final void invoke()
+}
+
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+
+    public final static void access$foo(foo.Kotlin $this, java.lang.String s)
+
+    private final void foo(java.lang.String s)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnnBinary;([]) : METHOD_FORMAL_PARAMETER 0, null // invisible
+
+    public final java.lang.String foo2()
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_RETURN, null
+      @Lfoo/TypeAnnBinary;([]) : METHOD_RETURN, null // invisible
+
+    public final void fooArray(java.lang.String[] s)
+      @Lfoo/TypeAnn;([name="3"]) : METHOD_FORMAL_PARAMETER 0, [
+      @Lfoo/TypeAnnBinary;([]) : METHOD_FORMAL_PARAMETER 0, [ // invisible
+
+    public final java.lang.String[] fooArray2()
+      @Lfoo/TypeAnn;([name="4"]) : METHOD_RETURN, [
+      @Lfoo/TypeAnnBinary;([]) : METHOD_RETURN, [ // invisible
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+    public abstract java.lang.String name()
+}
+
+public abstract interface foo/TypeAnnBinary : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/TypeAnnSource : java/lang/Object, java/lang/annotation/Annotation {
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/simple2Params.kt

@@ -0,0 +1,20 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn(val name: String)
+
+class Kotlin {
+
+    fun foo(s: @TypeAnn("1") String, x: @TypeAnn("2") Int) {
+    }
+
+
+    fun fooArray(s: Array<@TypeAnn("3") String>, i: Array<@TypeAnn("3") Int>) {
+    }
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/simple2Params.txt

@@ -0,0 +1,15 @@
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+
+    public final void foo(java.lang.String s, int x)
+      @Lfoo/TypeAnn;([name="1"]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/TypeAnn;([name="2"]) : METHOD_FORMAL_PARAMETER 1, null
+
+    public final void fooArray(java.lang.String[] s, java.lang.Integer[] i)
+      @Lfoo/TypeAnn;([name="3"]) : METHOD_FORMAL_PARAMETER 0, [
+      @Lfoo/TypeAnn;([name="3"]) : METHOD_FORMAL_PARAMETER 1, [
+}
+
+public abstract interface foo/TypeAnn : java/lang/Object, java/lang/annotation/Annotation {
+    public abstract java.lang.String name()
+}

compiler/testData/codegen/asmLike/typeAnnotations/staticNested.kt

@@ -0,0 +1,57 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TYPE_ANNOTATIONS
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// JVM_TARGET: 1.8
+package foo
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann2
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann3
+
+@Target(AnnotationTarget.TYPE)
+annotation class Ann4
+
+class Bar<T>
+
+class Outer {
+    class NestedStatic<T>
+}
+
+class Kotlin {
+
+    fun foo(s: @Ann Outer.NestedStatic<@Ann2 String>) {
+    }
+
+    fun foo(): @Ann Outer.NestedStatic<@Ann2 String>? {
+        return null
+    }
+
+    fun fooArray(s: @Ann Array<@Ann2 Outer.NestedStatic<@Ann3 String>>) {
+    }
+
+    fun fooArray(): @Ann Array<@Ann2 Outer.NestedStatic<@Ann3 String>>? {
+        return null
+    }
+
+    fun fooArrayIn(s: @Ann Array<in @Ann2 Outer.NestedStatic<@Ann3 String>>) {
+    }
+
+    fun fooArrayOut(): @Ann Array<out @Ann2 Outer.NestedStatic<@Ann3 String>>? {
+        return null
+    }
+
+
+    fun <T> fooGenericIn(s: @Ann Bar<in @Ann2 T>) {
+    }
+
+    fun <T> fooGenericOut(s: @Ann Bar<out @Ann2 T>) {
+    }
+
+
+}

compiler/testData/codegen/asmLike/typeAnnotations/staticNested.txt

@@ -0,0 +1,61 @@
+public abstract interface foo/Ann : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann2 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann3 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public abstract interface foo/Ann4 : java/lang/Object, java/lang/annotation/Annotation {
+
+}
+
+public final class foo/Bar : java/lang/Object {
+    public void <init>()
+}
+
+public final class foo/Kotlin : java/lang/Object {
+    public void <init>()
+
+    public final void foo(foo.Outer$NestedStatic s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/Ann2;([]) : METHOD_FORMAL_PARAMETER 0, 0;
+
+    public final foo.Outer$NestedStatic foo()
+      @Lfoo/Ann;([]) : METHOD_RETURN, null
+      @Lfoo/Ann2;([]) : METHOD_RETURN, 0;
+
+    public final void fooArray(foo.Outer$NestedStatic[] s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+      @Lfoo/Ann2;([]) : METHOD_FORMAL_PARAMETER 0, [
+      @Lfoo/Ann3;([]) : METHOD_FORMAL_PARAMETER 0, [0;
+
+    public final foo.Outer$NestedStatic[] fooArray()
+      @Lfoo/Ann;([]) : METHOD_RETURN, null
+      @Lfoo/Ann2;([]) : METHOD_RETURN, [
+      @Lfoo/Ann3;([]) : METHOD_RETURN, [0;
+
+    public final void fooArrayIn(java.lang.Object[] s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+
+    public final foo.Outer$NestedStatic[] fooArrayOut()
+      @Lfoo/Ann;([]) : METHOD_RETURN, null
+
+    public final void fooGenericIn(foo.Bar s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+
+    public final void fooGenericOut(foo.Bar s)
+      @Lfoo/Ann;([]) : METHOD_FORMAL_PARAMETER 0, null
+}
+
+public final class foo/Outer$NestedStatic : java/lang/Object {
+    public void <init>()
+}
+
+public final class foo/Outer : java/lang/Object {
+    public void <init>()
+}

compiler/testData/codegen/box/annotations/typeAnnotations/implicitReturn.kt

@@ -0,0 +1,76 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// IGNORE_BACKEND: JVM_IR
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+// FULL_JDK
+
+// FILE: ImplicitReturn.java
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+
+public class ImplicitReturn {
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.TYPE_USE)
+    public @ interface TypeAnn {}
+
+    @ImplicitReturn.TypeAnn
+    public String bar() {
+        return "OK";
+    }
+}
+
+
+// FILE: Kotlin.kt
+
+import java.lang.reflect.AnnotatedType
+import kotlin.reflect.jvm.javaMethod
+import kotlin.reflect.jvm.javaField
+import kotlin.test.fail
+
+class Kotlin {
+
+    fun foo() = ImplicitReturn().bar()
+
+    @JvmField
+    val field = ImplicitReturn().bar()
+}
+
+fun box(): String {
+
+    checkTypeAnnotation(
+        Kotlin::foo.javaMethod!!.annotatedReturnType,
+        "class java.lang.String",
+        "@ImplicitReturn\$TypeAnn()",
+        "foo"
+    )
+
+    checkTypeAnnotation(
+        Kotlin::field.javaField!!.annotatedType,
+        "class java.lang.String",
+        "@ImplicitReturn\$TypeAnn()",
+        "foo"
+    )
+
+    return Kotlin().foo()
+}
+
+fun checkTypeAnnotation(
+    annotatedType: AnnotatedType,
+    type: String,
+    annotations: String,
+    message: String
+) {
+    if (annotatedType.annotation() != annotations) fail("check $message (1): ${annotatedType.annotation()} != $annotations")
+
+    if (annotatedType.type.toString() != type) fail("check $message (2): ${annotatedType.type} != $type")
+}
+
+
+fun AnnotatedType.annotation() = annotations.joinToString()

compiler/testData/codegen/box/annotations/typeAnnotations/methodParameters.kt

@@ -0,0 +1,57 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// IGNORE_BACKEND: JVM_IR
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+// FULL_JDK
+package foo
+
+import java.lang.reflect.AnnotatedType
+import kotlin.reflect.jvm.javaMethod
+import kotlin.test.fail
+
+@Target(AnnotationTarget.TYPE)
+annotation class TypeAnn
+
+@Target(AnnotationTarget.TYPE)
+@Retention(AnnotationRetention.BINARY)
+annotation class TypeAnnBinary
+
+class Kotlin {
+
+    fun foo(s: @TypeAnn @TypeAnnBinary String) {
+    }
+
+    fun foo2(): @TypeAnn @TypeAnnBinary String {
+        return "OK"
+    }
+}
+
+fun box(): String {
+
+    checkTypeAnnotation(
+        Kotlin::foo.javaMethod!!.annotatedParameterTypes.single(),
+        "class java.lang.String",
+        "@foo.TypeAnn()",
+        "foo"
+    )
+
+    checkTypeAnnotation(Kotlin::foo2.javaMethod!!.annotatedReturnType, "class java.lang.String", "@foo.TypeAnn()", "foo2")
+
+    return "OK"
+}
+
+fun checkTypeAnnotation(
+    annotatedType: AnnotatedType,
+    type: String,
+    annotations: String,
+    message: String
+) {
+    if (annotatedType.annotation() != annotations) fail("check $message (1): ${annotatedType.annotation()} != $annotations")
+
+    if (annotatedType.type.toString() != type) fail("check $message (2): ${annotatedType.type} != $type")
+}
+
+
+fun AnnotatedType.annotation() = annotations.joinToString()

compiler/testData/codegen/box/annotations/typeAnnotations/typeUseAnnotation.kt

@@ -0,0 +1,65 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// IGNORE_BACKEND: JVM_IR
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+// FULL_JDK
+
+// FILE: foo/TypeAnn.java
+package foo;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE_USE)
+public @interface TypeAnn {}
+
+// FILE: test.kt
+package foo
+
+import java.lang.reflect.AnnotatedType
+import kotlin.reflect.jvm.javaMethod
+import kotlin.test.fail
+
+class Kotlin {
+
+    fun foo(s: @TypeAnn String) {
+    }
+
+    fun foo2(): @TypeAnn String {
+        return "OK"
+    }
+}
+
+fun box(): String {
+
+    checkTypeAnnotation(
+        Kotlin::foo.javaMethod!!.annotatedParameterTypes.single(),
+        "class java.lang.String",
+        "@foo.TypeAnn()",
+        "foo"
+    )
+
+    checkTypeAnnotation(Kotlin::foo2.javaMethod!!.annotatedReturnType, "class java.lang.String", "@foo.TypeAnn()", "foo2")
+
+    return "OK"
+}
+
+fun checkTypeAnnotation(
+    annotatedType: AnnotatedType,
+    type: String,
+    annotations: String,
+    message: String
+) {
+    if (annotatedType.annotation() != annotations) fail("check $message (1): ${annotatedType.annotation()} != $annotations")
+
+    if (annotatedType.type.toString() != type) fail("check $message (2): ${annotatedType.type} != $type")
+}
+
+
+fun AnnotatedType.annotation() = annotations.joinToString()

compiler/testData/codegen/boxAgainstJava/annotations/typeAnnotations/implicitReturn.kt

@@ -0,0 +1,76 @@
+// KOTLIN_CONFIGURATION_FLAGS: +JVM.EMIT_JVM_TYPE_ANNOTATIONS
+// TARGET_BACKEND: JVM
+// IGNORE_BACKEND_FIR: JVM_IR
+// IGNORE_BACKEND: JVM_IR
+// JVM_TARGET: 1.8
+// WITH_REFLECT
+// FULL_JDK
+
+// FILE: ImplicitReturn.java
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+
+public class ImplicitReturn {
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.TYPE_USE)
+    public @ interface TypeAnn {}
+
+    @ImplicitReturn.TypeAnn
+    public String bar() {
+        return "OK";
+    }
+}
+
+
+// FILE: Kotlin.kt
+
+import java.lang.reflect.AnnotatedType
+import kotlin.reflect.jvm.javaMethod
+import kotlin.reflect.jvm.javaField
+import kotlin.test.fail
+
+class Kotlin {
+
+    fun foo() = ImplicitReturn().bar()
+
+    @JvmField
+    val field = ImplicitReturn().bar()
+}
+
+fun box(): String {
+
+    checkTypeAnnotation(
+        Kotlin::foo.javaMethod!!.annotatedReturnType,
+        "class java.lang.String",
+        "@ImplicitReturn\$TypeAnn()",
+        "foo"
+    )
+
+    checkTypeAnnotation(
+        Kotlin::field.javaField!!.annotatedType,
+        "class java.lang.String",
+        "@ImplicitReturn\$TypeAnn()",
+        "foo"
+    )
+
+    return Kotlin().foo()
+}
+
+fun checkTypeAnnotation(
+    annotatedType: AnnotatedType,
+    type: String,
+    annotations: String,
+    message: String
+) {
+    if (annotatedType.annotation() != annotations) fail("check $message (1): ${annotatedType.annotation()} != $annotations")
+
+    if (annotatedType.type.toString() != type) fail("check $message (2): ${annotatedType.type} != $type")
+}
+
+
+fun AnnotatedType.annotation() = annotations.joinToString()