Introduce Experimental and UseExperimental annotations

#KT-22759 In Progress

compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.kt

@@ -0,0 +1,136 @@
+// !API_VERSION: 1.3
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS,
+        AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
+annotation class ExperimentalAPI
+
+@ExperimentalAPI
+@Target(AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS,
+        AnnotationTarget.VALUE_PARAMETER)
+annotation class EAnno
+
+// FILE: usage-propagate.kt
+
+package usage1
+
+import api.*
+
+@ExperimentalAPI
+@EAnno fun function() {}
+
+@ExperimentalAPI
+fun parameter(@EAnno p: String) {}
+
+@ExperimentalAPI
+fun parameterType(p: @EAnno String) {}
+
+@ExperimentalAPI
+fun returnType(): @EAnno Unit {}
+
+@ExperimentalAPI
+@EAnno val property = ""
+
+@ExperimentalAPI
+@EAnno typealias Typealias = Unit
+
+@ExperimentalAPI
+@EAnno class Klass
+
+@ExperimentalAPI
+annotation class AnnotationArgument(val p: EAnno)
+
+@ExperimentalAPI
+fun insideBody() {
+    @EAnno fun local() {}
+}
+
+@ExperimentalAPI
+fun inDefaultArgument(f: () -> Unit = @EAnno fun() {}) {}
+
+@ExperimentalAPI
+val inProperty = @EAnno fun() {}
+
+@ExperimentalAPI
+val inPropertyAccessor: () -> Unit
+    get() = @EAnno fun() {}
+
+// FILE: usage-use.kt
+
+package usage2
+
+import api.*
+
+@UseExperimental(ExperimentalAPI::class)
+@<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun function() {}
+
+@UseExperimental(ExperimentalAPI::class)
+fun parameter(@<!EXPERIMENTAL_API_USAGE!>EAnno<!> p: String) {}
+
+@UseExperimental(ExperimentalAPI::class)
+fun parameterType(p: @<!EXPERIMENTAL_API_USAGE!>EAnno<!> String) {}
+
+@UseExperimental(ExperimentalAPI::class)
+fun returnType(): @<!EXPERIMENTAL_API_USAGE!>EAnno<!> Unit {}
+
+@UseExperimental(ExperimentalAPI::class)
+@<!EXPERIMENTAL_API_USAGE!>EAnno<!> val property = ""
+
+<!WRONG_ANNOTATION_TARGET!>@UseExperimental(ExperimentalAPI::class)<!>
+@<!EXPERIMENTAL_API_USAGE!>EAnno<!> typealias Typealias = Unit
+
+@UseExperimental(ExperimentalAPI::class)
+@<!EXPERIMENTAL_API_USAGE!>EAnno<!> class Klass
+
+@UseExperimental(ExperimentalAPI::class)
+annotation class AnnotationArgument(val p: <!EXPERIMENTAL_API_USAGE!>EAnno<!>)
+
+fun insideBody() {
+    @UseExperimental(ExperimentalAPI::class) @EAnno fun local() {}
+}
+
+fun inDefaultArgument(@UseExperimental(ExperimentalAPI::class) f: () -> Unit = @EAnno fun() {}) {}
+
+@UseExperimental(ExperimentalAPI::class)
+val inProperty = @EAnno fun() {}
+
+val inPropertyAccessor: () -> Unit
+    @UseExperimental(ExperimentalAPI::class)
+    get() = @EAnno fun() {}
+
+// FILE: usage-none.kt
+
+package usage3
+
+import api.*
+
+@<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun function() {}
+
+fun parameter(@<!EXPERIMENTAL_API_USAGE!>EAnno<!> p: String) {}
+
+fun parameterType(p: @<!EXPERIMENTAL_API_USAGE!>EAnno<!> String) {}
+
+fun returnType(): @<!EXPERIMENTAL_API_USAGE!>EAnno<!> Unit {}
+
+@<!EXPERIMENTAL_API_USAGE!>EAnno<!> val property = ""
+
+@<!EXPERIMENTAL_API_USAGE!>EAnno<!> typealias Typealias = Unit
+
+@<!EXPERIMENTAL_API_USAGE!>EAnno<!> class Klass
+
+annotation class AnnotationArgument(val p: <!EXPERIMENTAL_API_USAGE!>EAnno<!>)
+
+fun insideBody() {
+    @<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun local() {}
+}
+
+fun inDefaultArgument(f: () -> Unit = @<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun() {}) {}
+
+val inProperty = @<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun() {}
+
+val inPropertyAccessor: () -> Unit
+    get() = @<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun() {}

compiler/testData/diagnostics/testsWithStdLib/experimental/annotation.txt

@@ -0,0 +1,102 @@
+package
+
+package api {
+
+    @api.ExperimentalAPI @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS, AnnotationTarget.VALUE_PARAMETER}) public final annotation class EAnno : kotlin.Annotation {
+        public constructor EAnno()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION}) public final annotation class ExperimentalAPI : kotlin.Annotation {
+        public constructor ExperimentalAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+package usage1 {
+    @api.ExperimentalAPI public val inProperty: () -> kotlin.Unit
+    @api.ExperimentalAPI public val inPropertyAccessor: () -> kotlin.Unit
+    @api.ExperimentalAPI @api.EAnno public val property: kotlin.String = ""
+    @api.ExperimentalAPI @api.EAnno public fun function(): kotlin.Unit
+    @api.ExperimentalAPI public fun inDefaultArgument(/*0*/ f: () -> kotlin.Unit = ...): kotlin.Unit
+    @api.ExperimentalAPI public fun insideBody(): kotlin.Unit
+    @api.ExperimentalAPI public fun parameter(/*0*/ @api.EAnno p: kotlin.String): kotlin.Unit
+    @api.ExperimentalAPI public fun parameterType(/*0*/ p: @api.EAnno kotlin.String): kotlin.Unit
+    @api.ExperimentalAPI public fun returnType(): @api.EAnno kotlin.Unit
+
+    @api.ExperimentalAPI public final annotation class AnnotationArgument : kotlin.Annotation {
+        public constructor AnnotationArgument(/*0*/ p: api.EAnno)
+        public final val p: api.EAnno
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @api.ExperimentalAPI @api.EAnno public final class Klass {
+        public constructor Klass()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+    @api.ExperimentalAPI @api.EAnno public typealias Typealias = kotlin.Unit
+}
+
+package usage2 {
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) public val inProperty: () -> kotlin.Unit
+    public val inPropertyAccessor: () -> kotlin.Unit
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) @api.EAnno public val property: kotlin.String = ""
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) @api.EAnno public fun function(): kotlin.Unit
+    public fun inDefaultArgument(/*0*/ @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) f: () -> kotlin.Unit = ...): kotlin.Unit
+    public fun insideBody(): kotlin.Unit
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) public fun parameter(/*0*/ @api.EAnno p: kotlin.String): kotlin.Unit
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) public fun parameterType(/*0*/ p: @api.EAnno kotlin.String): kotlin.Unit
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) public fun returnType(): @api.EAnno kotlin.Unit
+
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) public final annotation class AnnotationArgument : kotlin.Annotation {
+        public constructor AnnotationArgument(/*0*/ p: api.EAnno)
+        public final val p: api.EAnno
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) @api.EAnno public final class Klass {
+        public constructor Klass()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) @api.EAnno public typealias Typealias = kotlin.Unit
+}
+
+package usage3 {
+    public val inProperty: () -> kotlin.Unit
+    public val inPropertyAccessor: () -> kotlin.Unit
+    @api.EAnno public val property: kotlin.String = ""
+    @api.EAnno public fun function(): kotlin.Unit
+    public fun inDefaultArgument(/*0*/ f: () -> kotlin.Unit = ...): kotlin.Unit
+    public fun insideBody(): kotlin.Unit
+    public fun parameter(/*0*/ @api.EAnno p: kotlin.String): kotlin.Unit
+    public fun parameterType(/*0*/ p: @api.EAnno kotlin.String): kotlin.Unit
+    public fun returnType(): @api.EAnno kotlin.Unit
+
+    public final annotation class AnnotationArgument : kotlin.Annotation {
+        public constructor AnnotationArgument(/*0*/ p: api.EAnno)
+        public final val p: api.EAnno
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @api.EAnno public final class Klass {
+        public constructor Klass()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+    @api.EAnno public typealias Typealias = kotlin.Unit
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsages.kt

@@ -0,0 +1,30 @@
+// !API_VERSION: 1.3
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+annotation class ExperimentalCompilationAPI
+
+interface I
+
+@ExperimentalCompilationAPI
+class Impl : I
+
+// FILE: usage.kt
+
+package usage
+
+import api.*
+
+open class Base(val i: I)
+
+@UseExperimental(ExperimentalCompilationAPI::class)
+class Derived : Base(Impl())
+
+@UseExperimental(ExperimentalCompilationAPI::class)
+class Delegated : I by Impl()
+
+@UseExperimental(ExperimentalCompilationAPI::class)
+val delegatedProperty by Impl()
+operator fun I.getValue(x: Any?, y: Any?) = null

compiler/testData/diagnostics/testsWithStdLib/experimental/bodyUsages.txt

@@ -0,0 +1,52 @@
+package
+
+package api {
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) public final annotation class ExperimentalCompilationAPI : kotlin.Annotation {
+        public constructor ExperimentalCompilationAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    public interface I {
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @api.ExperimentalCompilationAPI public final class Impl : api.I {
+        public constructor Impl()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+package usage {
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalCompilationAPI::class}) public val delegatedProperty: kotlin.Nothing?
+    public operator fun api.I.getValue(/*0*/ x: kotlin.Any?, /*1*/ y: kotlin.Any?): kotlin.Nothing?
+
+    public open class Base {
+        public constructor Base(/*0*/ i: api.I)
+        public final val i: api.I
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalCompilationAPI::class}) public final class Delegated : api.I {
+        public constructor Delegated()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalCompilationAPI::class}) public final class Derived : usage.Base {
+        public constructor Derived()
+        public final override /*1*/ /*fake_override*/ val i: api.I
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.kt

@@ -0,0 +1,88 @@
+// !API_VERSION: 1.3
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
+annotation class ExperimentalAPI
+
+@ExperimentalAPI
+class C {
+    fun function(): String = ""
+    val property: String = ""
+    class Nested
+    inner class Inner
+}
+
+@ExperimentalAPI
+fun C.extension() {}
+
+// FILE: usage-propagate.kt
+
+package usage1
+
+import api.*
+
+@ExperimentalAPI
+fun useAll() {
+    val c: C = C()
+    c.function()
+    c.property
+    C.Nested()
+    c.Inner()
+    c.extension()
+}
+
+@ExperimentalAPI
+class Use {
+    fun useAll(c: C) {
+        c.function()
+        c.property
+        C.Nested()
+        c.Inner()
+        c.extension()
+    }
+}
+
+// FILE: usage-use.kt
+
+package usage2
+
+import api.*
+
+@UseExperimental(ExperimentalAPI::class)
+fun useAll() {
+    val c: C = C()
+    c.function()
+    c.property
+    C.Nested()
+    c.Inner()
+    c.extension()
+}
+
+@UseExperimental(ExperimentalAPI::class)
+class Use {
+    fun useAll(c: <!EXPERIMENTAL_API_USAGE!>C<!>) {
+        c.function()
+        c.property
+        C.Nested()
+        c.Inner()
+        c.extension()
+    }
+}
+
+// FILE: usage-none.kt
+
+package usage3
+
+import api.*
+
+fun use() {
+    val c: <!EXPERIMENTAL_API_USAGE!>C<!> = <!EXPERIMENTAL_API_USAGE!>C<!>()
+    c.<!EXPERIMENTAL_API_USAGE!>function<!>()
+    c.<!EXPERIMENTAL_API_USAGE!>property<!>
+    <!EXPERIMENTAL_API_USAGE!>C<!>.<!EXPERIMENTAL_API_USAGE!>Nested<!>()
+    c.<!EXPERIMENTAL_API_USAGE!>Inner<!>()
+    c.<!EXPERIMENTAL_API_USAGE!>extension<!>()
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/classMembers.txt

@@ -0,0 +1,63 @@
+package
+
+package api {
+    @api.ExperimentalAPI public fun api.C.extension(): kotlin.Unit
+
+    @api.ExperimentalAPI public final class C {
+        public constructor C()
+        public final val property: kotlin.String = ""
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public final fun function(): kotlin.String
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        public final inner class Inner {
+            public constructor Inner()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+
+        public final class Nested {
+            public constructor Nested()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FUNCTION}) public final annotation class ExperimentalAPI : kotlin.Annotation {
+        public constructor ExperimentalAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+package usage1 {
+    @api.ExperimentalAPI public fun useAll(): kotlin.Unit
+
+    @api.ExperimentalAPI public final class Use {
+        public constructor Use()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public final fun useAll(/*0*/ c: api.C): kotlin.Unit
+    }
+}
+
+package usage2 {
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) public fun useAll(): kotlin.Unit
+
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) public final class Use {
+        public constructor Use()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public final fun useAll(/*0*/ c: api.C): kotlin.Unit
+    }
+}
+
+package usage3 {
+    public fun use(): kotlin.Unit
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.kt

@@ -0,0 +1,36 @@
+// !API_VERSION: 1.3
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY)
+annotation class ExperimentalAPI
+
+@ExperimentalAPI
+class C {
+    @ExperimentalAPI
+    fun function() {}
+
+    @ExperimentalAPI
+    val property: String = ""
+
+    @ExperimentalAPI
+    class Nested {
+        @ExperimentalAPI
+        fun nestedFunction() {}
+    }
+}
+
+// FILE: usage.kt
+
+package usage
+
+import api.*
+
+fun use() {
+    val c: <!EXPERIMENTAL_API_USAGE!>C<!> = <!EXPERIMENTAL_API_USAGE!>C<!>()
+    c.<!EXPERIMENTAL_API_USAGE!>function<!>()
+    c.<!EXPERIMENTAL_API_USAGE!>property<!>
+    <!EXPERIMENTAL_API_USAGE!>C<!>.<!EXPERIMENTAL_API_USAGE!>Nested<!>().<!EXPERIMENTAL_API_USAGE!>nestedFunction<!>()
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/classMembersOverlyExperimental.txt

@@ -0,0 +1,32 @@
+package
+
+package api {
+
+    @api.ExperimentalAPI public final class C {
+        public constructor C()
+        @api.ExperimentalAPI public final val property: kotlin.String = ""
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        @api.ExperimentalAPI public final fun function(): kotlin.Unit
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+
+        @api.ExperimentalAPI public final class Nested {
+            public constructor Nested()
+            public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+            public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+            @api.ExperimentalAPI public final fun nestedFunction(): kotlin.Unit
+            public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        }
+    }
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY}) public final annotation class ExperimentalAPI : kotlin.Annotation {
+        public constructor ExperimentalAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+package usage {
+    public fun use(): kotlin.Unit
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/compilationVsLinkageVsRuntime.kt

@@ -0,0 +1,73 @@
+// !API_VERSION: 1.3
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+annotation class ExperimentalCompilationAPI
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.LINKAGE])
+annotation class ExperimentalLinkageAPI
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.RUNTIME])
+annotation class ExperimentalRuntimeAPI
+
+@ExperimentalCompilationAPI
+fun compilation() {}
+
+@ExperimentalLinkageAPI
+fun linkage() {}
+
+@ExperimentalRuntimeAPI
+fun runtime() {}
+
+// FILE: usage.kt
+
+package usage1
+
+import api.*
+
+@UseExperimental(ExperimentalCompilationAPI::class)
+@ExperimentalLinkageAPI
+@ExperimentalRuntimeAPI
+fun use() {
+    compilation()
+    linkage()
+    runtime()
+}
+
+@ExperimentalLinkageAPI
+@ExperimentalRuntimeAPI
+fun useUse() {
+    use()
+}
+
+@ExperimentalCompilationAPI
+@ExperimentalLinkageAPI
+@ExperimentalRuntimeAPI
+fun recursiveUse() {
+    compilation()
+    linkage()
+    runtime()
+    recursiveUse()
+}
+
+// FILE: usage-no-annotation.txt
+
+package usage2
+
+import api.*
+
+fun use1() {
+    usage1.<!EXPERIMENTAL_API_USAGE, EXPERIMENTAL_API_USAGE!>use<!>()
+}
+
+@ExperimentalLinkageAPI
+fun use2() {
+    usage1.<!EXPERIMENTAL_API_USAGE!>use<!>()
+}
+
+@ExperimentalRuntimeAPI
+fun use3() {
+    usage1.<!EXPERIMENTAL_API_USAGE!>use<!>()
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/compilationVsLinkageVsRuntime.txt

@@ -0,0 +1,40 @@
+package
+
+package api {
+    @api.ExperimentalCompilationAPI public fun compilation(): kotlin.Unit
+    @api.ExperimentalLinkageAPI public fun linkage(): kotlin.Unit
+    @api.ExperimentalRuntimeAPI public fun runtime(): kotlin.Unit
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) public final annotation class ExperimentalCompilationAPI : kotlin.Annotation {
+        public constructor ExperimentalCompilationAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.Experimental(changesMayBreak = {Impact.LINKAGE}, level = Level.WARNING) public final annotation class ExperimentalLinkageAPI : kotlin.Annotation {
+        public constructor ExperimentalLinkageAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.Experimental(changesMayBreak = {Impact.RUNTIME}, level = Level.WARNING) public final annotation class ExperimentalRuntimeAPI : kotlin.Annotation {
+        public constructor ExperimentalRuntimeAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+package usage1 {
+    @api.ExperimentalCompilationAPI @api.ExperimentalLinkageAPI @api.ExperimentalRuntimeAPI public fun recursiveUse(): kotlin.Unit
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalCompilationAPI::class}) @api.ExperimentalLinkageAPI @api.ExperimentalRuntimeAPI public fun use(): kotlin.Unit
+    @api.ExperimentalLinkageAPI @api.ExperimentalRuntimeAPI public fun useUse(): kotlin.Unit
+}
+
+package usage2 {
+    public fun use1(): kotlin.Unit
+    @api.ExperimentalLinkageAPI public fun use2(): kotlin.Unit
+    @api.ExperimentalRuntimeAPI public fun use3(): kotlin.Unit
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.kt

@@ -0,0 +1,78 @@
+// !API_VERSION: 1.3
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS,
+        AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION)
+annotation class ExperimentalAPI
+
+@ExperimentalAPI
+fun function(): String = ""
+
+@ExperimentalAPI
+val property: String = ""
+
+@ExperimentalAPI
+typealias Typealias = String
+
+// FILE: usage-propagate.kt
+
+package usage1
+
+import api.*
+
+@ExperimentalAPI
+fun useAll() {
+    function()
+    property
+    val s: Typealias = ""
+}
+
+@ExperimentalAPI
+class Use {
+    fun useAll() {
+        function()
+        property
+        val s: Typealias = ""
+    }
+}
+
+// FILE: usage-use.kt
+
+package usage2
+
+import api.*
+
+fun useAll() {
+    @UseExperimental(ExperimentalAPI::class)
+    {
+        function()
+        property
+        val s: Typealias = ""
+    }()
+}
+
+@UseExperimental(ExperimentalAPI::class)
+class Use {
+    fun useAll() {
+        function()
+        property
+        val s: Typealias = ""
+    }
+}
+
+// FILE: usage-none.kt
+
+package usage3
+
+import api.*
+
+fun use() {
+    <!EXPERIMENTAL_API_USAGE!>function<!>()
+    <!EXPERIMENTAL_API_USAGE!>property<!>
+    val s: <!EXPERIMENTAL_API_USAGE!>Typealias<!> = ""
+    s.hashCode()
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/topLevel.txt

@@ -0,0 +1,42 @@
+package
+
+package api {
+    @api.ExperimentalAPI public val property: kotlin.String = ""
+    @api.ExperimentalAPI public fun function(): kotlin.String
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.TYPE, AnnotationTarget.CLASS, AnnotationTarget.FUNCTION, AnnotationTarget.PROPERTY, AnnotationTarget.TYPEALIAS, AnnotationTarget.VALUE_PARAMETER, AnnotationTarget.EXPRESSION}) public final annotation class ExperimentalAPI : kotlin.Annotation {
+        public constructor ExperimentalAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+    @api.ExperimentalAPI public typealias Typealias = kotlin.String
+}
+
+package usage1 {
+    @api.ExperimentalAPI public fun useAll(): kotlin.Unit
+
+    @api.ExperimentalAPI public final class Use {
+        public constructor Use()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public final fun useAll(): kotlin.Unit
+    }
+}
+
+package usage2 {
+    public fun useAll(): kotlin.Unit
+
+    @kotlin.UseExperimental(markerClass = {api.ExperimentalAPI::class}) public final class Use {
+        public constructor Use()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public final fun useAll(): kotlin.Unit
+    }
+}
+
+package usage3 {
+    public fun use(): kotlin.Unit
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.kt

@@ -0,0 +1,13 @@
+// !API_VERSION: 1.3
+// FILE: api.kt
+
+package api
+
+@Experimental
+@Target(AnnotationTarget.CLASS)
+annotation class ExperimentalAPI
+
+@ExperimentalAPI
+class Foo
+
+typealias Bar = <!EXPERIMENTAL_API_USAGE_ERROR!>Foo<!>

compiler/testData/diagnostics/testsWithStdLib/experimental/typealias.txt

@@ -0,0 +1,19 @@
+package
+
+package api {
+
+    @kotlin.Experimental @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class ExperimentalAPI : kotlin.Annotation {
+        public constructor ExperimentalAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @api.ExperimentalAPI public final class Foo {
+        public constructor Foo()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+    public typealias Bar = api.Foo
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.kt

@@ -0,0 +1,37 @@
+// !API_VERSION: 1.3
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.FUNCTION)
+annotation class CompilationExperimentalAPI
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.RUNTIME])
+@Target(AnnotationTarget.FUNCTION)
+annotation class RuntimeExperimentalAPI
+
+@CompilationExperimentalAPI
+fun compilation() {}
+
+@RuntimeExperimentalAPI
+fun runtime() {}
+
+// FILE: usage.kt
+
+@file:UseExperimental(CompilationExperimentalAPI::class)
+package usage
+
+import api.*
+
+fun use() {
+    compilation()
+    <!EXPERIMENTAL_API_USAGE!>runtime<!>()
+}
+
+class Use {
+    fun use() {
+        compilation()
+        <!EXPERIMENTAL_API_USAGE!>runtime<!>()
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalOnFile.txt

@@ -0,0 +1,32 @@
+package
+
+package api {
+    @api.CompilationExperimentalAPI public fun compilation(): kotlin.Unit
+    @api.RuntimeExperimentalAPI public fun runtime(): kotlin.Unit
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class CompilationExperimentalAPI : kotlin.Annotation {
+        public constructor CompilationExperimentalAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.Experimental(changesMayBreak = {Impact.RUNTIME}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class RuntimeExperimentalAPI : kotlin.Annotation {
+        public constructor RuntimeExperimentalAPI()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+package usage {
+    public fun use(): kotlin.Unit
+
+    public final class Use {
+        public constructor Use()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+        public final fun use(): kotlin.Unit
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalTargets.kt

@@ -0,0 +1,54 @@
+// !API_VERSION: 1.3
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.CLASS)
+annotation class E
+
+@E
+open class Foo(val s: String = "")
+
+// FILE: usage.kt
+
+import api.*
+
+@UseExperimental(E::class)
+class Klass {
+    init {
+        Foo()
+    }
+}
+
+class Constructor {
+    @UseExperimental(E::class) constructor() {
+        Foo()
+    }
+}
+
+@UseExperimental(E::class)
+val property = Foo().s
+
+@UseExperimental(E::class)
+fun function() {
+    Foo()
+}
+
+fun valueParameter(@UseExperimental(E::class) p: String = Foo().s): String {
+    @UseExperimental(E::class)
+    val localVariable: String = Foo().s
+    return localVariable
+}
+
+var propertyAccessors: String
+    @UseExperimental(E::class)
+    get() = Foo().s
+    @UseExperimental(E::class)
+    set(value) { Foo() }
+
+fun expression(): String {
+    val s = @UseExperimental(E::class) Foo().s
+    return s
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalTargets.txt

@@ -0,0 +1,39 @@
+package
+
+@kotlin.UseExperimental(markerClass = {api.E::class}) public val property: kotlin.String
+public var propertyAccessors: kotlin.String
+public fun expression(): kotlin.String
+@kotlin.UseExperimental(markerClass = {api.E::class}) public fun function(): kotlin.Unit
+public fun valueParameter(/*0*/ @kotlin.UseExperimental(markerClass = {api.E::class}) p: kotlin.String = ...): kotlin.String
+
+public final class Constructor {
+    @kotlin.UseExperimental(markerClass = {api.E::class}) public constructor Constructor()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+@kotlin.UseExperimental(markerClass = {api.E::class}) public final class Klass {
+    public constructor Klass()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+package api {
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.CLASS}) public final annotation class E : kotlin.Annotation {
+        public constructor E()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @api.E public open class Foo {
+        public constructor Foo(/*0*/ s: kotlin.String = ...)
+        public final val s: kotlin.String
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.kt

@@ -0,0 +1,52 @@
+// !API_VERSION: 1.3
+// FILE: api.kt
+
+package api
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.FUNCTION)
+annotation class E1
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.FUNCTION)
+annotation class E2
+
+@Experimental(Experimental.Level.WARNING, [Experimental.Impact.COMPILATION])
+@Target(AnnotationTarget.FUNCTION)
+annotation class E3
+
+@E1
+fun e1() {}
+
+@E2
+fun e2() {}
+
+@E3
+fun e3() {}
+
+// FILE: usage.kt
+
+package usage
+
+import api.*
+
+@UseExperimental(E1::class, E2::class, E3::class)
+fun use1() {
+    e1()
+    e2()
+    e3()
+}
+
+@UseExperimental(E1::class, E3::class)
+fun use2() {
+    e1()
+    @UseExperimental(E2::class) e2()
+    e3()
+}
+
+@UseExperimental(E1::class, E2::class)
+fun use3() {
+    e1()
+    e2()
+    <!EXPERIMENTAL_API_USAGE!>e3<!>()
+}

compiler/testData/diagnostics/testsWithStdLib/experimental/useExperimentalWithSeveralAnnotations.txt

@@ -0,0 +1,34 @@
+package
+
+package api {
+    @api.E1 public fun e1(): kotlin.Unit
+    @api.E2 public fun e2(): kotlin.Unit
+    @api.E3 public fun e3(): kotlin.Unit
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class E1 : kotlin.Annotation {
+        public constructor E1()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class E2 : kotlin.Annotation {
+        public constructor E2()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+
+    @kotlin.Experimental(changesMayBreak = {Impact.COMPILATION}, level = Level.WARNING) @kotlin.annotation.Target(allowedTargets = {AnnotationTarget.FUNCTION}) public final annotation class E3 : kotlin.Annotation {
+        public constructor E3()
+        public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+        public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+        public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+    }
+}
+
+package usage {
+    @kotlin.UseExperimental(markerClass = {api.E1::class, api.E2::class, api.E3::class}) public fun use1(): kotlin.Unit
+    @kotlin.UseExperimental(markerClass = {api.E1::class, api.E3::class}) public fun use2(): kotlin.Unit
+    @kotlin.UseExperimental(markerClass = {api.E1::class, api.E2::class}) public fun use3(): kotlin.Unit
+}