Use OPT_IN instead of EXPERIMENTAL in diagnostic names

2021-09-02 13:33:43 +03:00
parent 2f07589b42
commit 3febabe977
150 changed files with 514 additions and 514 deletions
@@ -1,7 +1,7 @@
 // DONT_TARGET_EXACT_BACKEND: WASM
 // WASM_MUTE_REASON: STDLIB_COLLECTIONS
 // !LANGUAGE: +NewInference
-// !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION
 // WITH_RUNTIME

@OptIn(ExperimentalStdlibApi::class)
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME
 // TARGET_BACKEND: JVM

@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME
 // TARGET_BACKEND: JVM
 // DONT_TARGET_EXACT_BACKEND: WASM
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME
 // DONT_TARGET_EXACT_BACKEND: WASM
 // TARGET_BACKEND: JVM
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME
 // TARGET_BACKEND: JVM
 // DONT_TARGET_EXACT_BACKEND: WASM
@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -UNCHECKED_CAST -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -UNCHECKED_CAST -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME
 // DONT_TARGET_EXACT_BACKEND: WASM

@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -DEPRECATION -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME
 // IGNORE_BACKEND_FIR: JVM_IR
 // DONT_TARGET_EXACT_BACKEND: WASM
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -DEPRECATION -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME
 // DONT_TARGET_EXACT_BACKEND: WASM

@@ -14,7 +14,7 @@ fun <T> materialize() = null as T

 interface FlowCollector<in T> {}

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR")
 fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)

 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION
 // DONT_TARGET_EXACT_BACKEND: WASM

 import kotlin.experimental.ExperimentalTypeInference
@@ -14,7 +14,7 @@ fun <T> materialize() = null as T

 interface FlowCollector<in T> {}

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR")
 fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)

 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
@@ -5,7 +5,7 @@ import kotlin.experimental.ExperimentalTypeInference

 interface FlowCollector<in T> {}

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR")
 fun <L> flow(@BuilderInference block: suspend FlowCollector<L>.() -> Unit) = Flow(block)

 class Flow<out R>(private val block: suspend FlowCollector<R>.() -> Unit)
@@ -11,7 +11,7 @@ interface FlowCollector<T> {
    fun emit(value: T)
 }

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR")
 fun <I> flow(@BuilderInference block: FlowCollector<I>.() -> Unit): I = null as I

 fun adapt(): Unit = flow {
@@ -1,5 +1,5 @@
 // DONT_TARGET_EXACT_BACKEND: WASM
-// !DIAGNOSTICS: -UNUSED_PARAMETER -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -UNUSED_PARAMETER -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // DONT_TARGET_EXACT_BACKEND: WASM
-// !DIAGNOSTICS: -UNUSED_PARAMETER -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -UNUSED_PARAMETER -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // DONT_TARGET_EXACT_BACKEND: WASM
-// !DIAGNOSTICS: -UNUSED_PARAMETER -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -UNUSED_PARAMETER -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // DONT_TARGET_EXACT_BACKEND: WASM
-// !DIAGNOSTICS: -UNUSED_PARAMETER -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -UNUSED_PARAMETER -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,6 +1,6 @@
 // !LANGUAGE: +UnrestrictedBuilderInference -UseBuilderInferenceOnlyIfNeeded
 // WITH_RUNTIME
-// !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -CAST_NEVER_SUCCEEDS
+// !DIAGNOSTICS: -OPT_IN_USAGE_ERROR -CAST_NEVER_SUCCEEDS
 // IGNORE_BACKEND_FIR: JVM_IR
 // DONT_TARGET_EXACT_BACKEND: WASM

@@ -1,5 +1,5 @@
 // WITH_RUNTIME
-// !DIAGNOSTICS: -EXPERIMENTAL_IS_NOT_ENABLED -DEPRECATION -EXPERIMENTAL_API_USAGE_ERROR
+// !DIAGNOSTICS: -OPT_IN_IS_NOT_ENABLED -DEPRECATION -OPT_IN_USAGE_ERROR
 // DONT_TARGET_EXACT_BACKEND: WASM

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // WITH_RUNTIME
-// !DIAGNOSTICS: -EXPERIMENTAL_IS_NOT_ENABLED -DEPRECATION -EXPERIMENTAL_API_USAGE_ERROR
+// !DIAGNOSTICS: -OPT_IN_IS_NOT_ENABLED -DEPRECATION -OPT_IN_USAGE_ERROR
 // DONT_TARGET_EXACT_BACKEND: WASM

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // !LANGUAGE: -UnrestrictedBuilderInference
-// !DIAGNOSTICS: -EXPERIMENTAL_IS_NOT_ENABLED -UNCHECKED_CAST
+// !DIAGNOSTICS: -OPT_IN_IS_NOT_ENABLED -UNCHECKED_CAST
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // !LANGUAGE: -UnrestrictedBuilderInference
-// !DIAGNOSTICS: -EXPERIMENTAL_IS_NOT_ENABLED -UNCHECKED_CAST
+// !DIAGNOSTICS: -OPT_IN_IS_NOT_ENABLED -UNCHECKED_CAST
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // FIR_IDENTICAL
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -UNCHECKED_CAST -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -UNCHECKED_CAST -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: main.kt
@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // FIR_IDENTICAL
-// !DIAGNOSTICS: -UNUSED_PARAMETER -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -UNUSED_PARAMETER -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,7 +1,7 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,7 +1,7 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,7 +1,7 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION
 // KT-47797

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,7 +1,7 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION
 // KT-47797

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNUSED_LAMBDA_EXPRESSION -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNUSED_LAMBDA_EXPRESSION -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNUSED_LAMBDA_EXPRESSION -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNUSED_LAMBDA_EXPRESSION -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -DEPRECATION -UNCHECKED_CAST -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -DEPRECATION -UNCHECKED_CAST -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 // FILE: main.kt
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -DEPRECATION -UNCHECKED_CAST -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -DEPRECATION -UNCHECKED_CAST -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 // FILE: main.kt
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference

@UseExperimental(ExperimentalTypeInference::class)
-fun <R> build(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R>.() -> Unit): R = TODO()

@UseExperimental(ExperimentalTypeInference::class)
-fun <R> build2(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build2(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R>.() -> Unit): R = TODO()

 class Inv<K>

@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -12,10 +12,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference

@UseExperimental(ExperimentalTypeInference::class)
-fun <R1> build(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R1>.() -> Unit): R1 = TODO()
+fun <R1> build(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R1>.() -> Unit): R1 = TODO()

@UseExperimental(ExperimentalTypeInference::class)
-fun <R2> build2(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R2>.() -> Unit): R2 = TODO()
+fun <R2> build2(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R2>.() -> Unit): R2 = TODO()

 class Out<out K>

@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -15,10 +15,10 @@ class Test {
 import kotlin.experimental.ExperimentalTypeInference

@UseExperimental(ExperimentalTypeInference::class)
-fun <R> build(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R>.() -> Unit): R = TODO()

@UseExperimental(ExperimentalTypeInference::class)
-fun <R> build2(@<!EXPERIMENTAL_API_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R>.() -> Unit): R = TODO()
+fun <R> build2(@<!OPT_IN_USAGE_ERROR!>BuilderInference<!> block: TestInterface<R>.() -> Unit): R = TODO()

 class Inv<K>

@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNCHECKED_CAST -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNCHECKED_CAST -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -UNCHECKED_CAST -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNCHECKED_CAST -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 // FILE: Test.java
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -DEPRECATION -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 // FILE: main.kt
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -DEPRECATION -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 // FILE: main.kt
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -DEPRECATION -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 // FILE: main.kt
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -DEPRECATION -OPT_IN_IS_NOT_ENABLED
 // WITH_RUNTIME

 // FILE: main.kt
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // !LANGUAGE: +UnrestrictedBuilderInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -EXPERIMENTAL_IS_NOT_ENABLED -UNUSED_VARIABLE
+// !DIAGNOSTICS: -UNUSED_PARAMETER -DEPRECATION -OPT_IN_IS_NOT_ENABLED -UNUSED_VARIABLE
 // WITH_RUNTIME

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,6 +1,6 @@
 // WITH_RUNTIME
 // SKIP_TXT
-// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -CAST_NEVER_SUCCEEDS -UNCHECKED_CAST -UNUSED_PARAMETER -UNUSED_VARIABLE -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 import kotlin.experimental.ExperimentalTypeInference

@@ -1,5 +1,5 @@
 // !LANGUAGE: +NewInference
-// !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -EXPERIMENTAL_API_USAGE_FUTURE_ERROR -UNUSED_PARAMETER
+// !DIAGNOSTICS: -OPT_IN_USAGE_ERROR -OPT_IN_USAGE_FUTURE_ERROR -UNUSED_PARAMETER

 import kotlin.contracts.*

@@ -1,5 +1,5 @@
 // !LANGUAGE: +NewInference
-// !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -EXPERIMENTAL_API_USAGE_FUTURE_ERROR -UNUSED_PARAMETER
+// !DIAGNOSTICS: -OPT_IN_USAGE_ERROR -OPT_IN_USAGE_FUTURE_ERROR -UNUSED_PARAMETER

 import kotlin.contracts.*

@@ -1,6 +1,6 @@
 import kotlin.contracts.*

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR")
 inline fun atLeastOnce(block: () -> Unit) {
    contract {
        callsInPlace(block, InvocationKind.AT_LEAST_ONCE)
@@ -8,7 +8,7 @@ inline fun atLeastOnce(block: () -> Unit) {
    block()
 }

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR")
 inline fun atMostOnce(block: () -> Unit) {
    contract {
        callsInPlace(block, InvocationKind.AT_MOST_ONCE)
@@ -16,7 +16,7 @@ inline fun atMostOnce(block: () -> Unit) {
    block()
 }

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR")
 inline fun exactlyOnce(block: () -> Unit) {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
@@ -1,6 +1,6 @@
 import kotlin.contracts.*

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR")
 inline fun atLeastOnce(block: () -> Unit) {
    contract {
        callsInPlace(block, InvocationKind.AT_LEAST_ONCE)
@@ -8,7 +8,7 @@ inline fun atLeastOnce(block: () -> Unit) {
    block()
 }

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR")
 inline fun atMostOnce(block: () -> Unit) {
    contract {
        callsInPlace(block, InvocationKind.AT_MOST_ONCE)
@@ -16,7 +16,7 @@ inline fun atMostOnce(block: () -> Unit) {
    block()
 }

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR")
 inline fun exactlyOnce(block: () -> Unit) {
    contract {
        callsInPlace(block, InvocationKind.EXACTLY_ONCE)
@@ -1,12 +1,12 @@
 package

-@kotlin.Suppress(names = {"EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR"}) public inline fun atLeastOnce(/*0*/ block: () -> kotlin.Unit): kotlin.Unit
+@kotlin.Suppress(names = {"OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR"}) public inline fun atLeastOnce(/*0*/ block: () -> kotlin.Unit): kotlin.Unit
    CallsInPlace(block, AT_LEAST_ONCE)

-@kotlin.Suppress(names = {"EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR"}) public inline fun atMostOnce(/*0*/ block: () -> kotlin.Unit): kotlin.Unit
+@kotlin.Suppress(names = {"OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR"}) public inline fun atMostOnce(/*0*/ block: () -> kotlin.Unit): kotlin.Unit
    CallsInPlace(block, AT_MOST_ONCE)

-@kotlin.Suppress(names = {"EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR"}) public inline fun exactlyOnce(/*0*/ block: () -> kotlin.Unit): kotlin.Unit
+@kotlin.Suppress(names = {"OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR"}) public inline fun exactlyOnce(/*0*/ block: () -> kotlin.Unit): kotlin.Unit
    CallsInPlace(block, EXACTLY_ONCE)

 public fun test(): kotlin.Unit
@@ -1,6 +1,6 @@
 import kotlin.contracts.*

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR")
 fun foo(f1: () -> Unit, f2: () -> Unit) {
    contract {
        callsInPlace(f1, InvocationKind.EXACTLY_ONCE)
@@ -1,6 +1,6 @@
 import kotlin.contracts.*

-@Suppress("EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR")
+@Suppress("OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR")
 fun foo(f1: () -> Unit, f2: () -> Unit) {
    contract {
        callsInPlace(f1, InvocationKind.EXACTLY_ONCE)
@@ -1,6 +1,6 @@
 package

-@kotlin.Suppress(names = {"EXPERIMENTAL_API_USAGE_ERROR", "EXPERIMENTAL_API_USAGE_FUTURE_ERROR"}) public fun foo(/*0*/ f1: () -> kotlin.Unit, /*1*/ f2: () -> kotlin.Unit): kotlin.Unit
+@kotlin.Suppress(names = {"OPT_IN_USAGE_ERROR", "OPT_IN_USAGE_FUTURE_ERROR"}) public fun foo(/*0*/ f1: () -> kotlin.Unit, /*1*/ f2: () -> kotlin.Unit): kotlin.Unit
    CallsInPlace(f1, EXACTLY_ONCE)
    CallsInPlace(f2, EXACTLY_ONCE)

@@ -1,12 +1,12 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER

-fun ubyte(vararg a: <!EXPERIMENTAL_API_USAGE!>UByte<!>) {}
-fun ushort(vararg a: <!EXPERIMENTAL_API_USAGE!>UShort<!>) {}
-fun uint(vararg a: <!EXPERIMENTAL_API_USAGE!>UInt<!>) {}
-fun ulong(vararg a: <!EXPERIMENTAL_API_USAGE!>ULong<!>) {}
+fun ubyte(vararg a: <!OPT_IN_USAGE!>UByte<!>) {}
+fun ushort(vararg a: <!OPT_IN_USAGE!>UShort<!>) {}
+fun uint(vararg a: <!OPT_IN_USAGE!>UInt<!>) {}
+fun ulong(vararg a: <!OPT_IN_USAGE!>ULong<!>) {}

-class ValueParam(vararg val a: <!EXPERIMENTAL_API_USAGE!>ULong<!>)
+class ValueParam(vararg val a: <!OPT_IN_USAGE!>ULong<!>)

-annotation class Ann(vararg val a: <!EXPERIMENTAL_API_USAGE!>UInt<!>)
+annotation class Ann(vararg val a: <!OPT_IN_USAGE!>UInt<!>)

-fun array(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> a: <!EXPERIMENTAL_API_USAGE!>UIntArray<!>) {}
+fun array(<!FORBIDDEN_VARARG_PARAMETER_TYPE!>vararg<!> a: <!OPT_IN_USAGE!>UIntArray<!>) {}
@@ -33,7 +33,7 @@ fun takeUShort(@ImplicitIntegerCoercion u: UShort) {}
 fun takeUInt(@ImplicitIntegerCoercion u: UInt) {}
 fun takeULong(@ImplicitIntegerCoercion u: ULong) {}

-fun takeUBytes(@ImplicitIntegerCoercion vararg u: <!EXPERIMENTAL_API_USAGE!>UByte<!>) {}
+fun takeUBytes(@ImplicitIntegerCoercion vararg u: <!OPT_IN_USAGE!>UByte<!>) {}

 fun takeLong(@ImplicitIntegerCoercion l: Long) {}

@@ -5,7 +5,7 @@ fun takeUShort(u: UShort) {}
 fun takeUInt(u: UInt) {}
 fun takeULong(u: ULong) {}

-fun takeUBytes(vararg u: <!EXPERIMENTAL_API_USAGE!>UByte<!>) {}
+fun takeUBytes(vararg u: <!OPT_IN_USAGE!>UByte<!>) {}

 fun takeNullableUInt(u: UInt?) {}

@@ -1,7 +1,7 @@

-fun ubyte(vararg a: <!EXPERIMENTAL_API_USAGE!>UByte<!>): <!EXPERIMENTAL_API_USAGE!>UByteArray<!> = <!EXPERIMENTAL_API_USAGE!>a<!>
-fun ushort(vararg a: <!EXPERIMENTAL_API_USAGE!>UShort<!>): <!EXPERIMENTAL_API_USAGE!>UShortArray<!> = <!EXPERIMENTAL_API_USAGE!>a<!>
-fun uint(vararg a: <!EXPERIMENTAL_API_USAGE!>UInt<!>): <!EXPERIMENTAL_API_USAGE!>UIntArray<!> = <!EXPERIMENTAL_API_USAGE!>a<!>
-fun ulong(vararg a: <!EXPERIMENTAL_API_USAGE!>ULong<!>): <!EXPERIMENTAL_API_USAGE!>ULongArray<!> = <!EXPERIMENTAL_API_USAGE!>a<!>
+fun ubyte(vararg a: <!OPT_IN_USAGE!>UByte<!>): <!OPT_IN_USAGE!>UByteArray<!> = <!OPT_IN_USAGE!>a<!>
+fun ushort(vararg a: <!OPT_IN_USAGE!>UShort<!>): <!OPT_IN_USAGE!>UShortArray<!> = <!OPT_IN_USAGE!>a<!>
+fun uint(vararg a: <!OPT_IN_USAGE!>UInt<!>): <!OPT_IN_USAGE!>UIntArray<!> = <!OPT_IN_USAGE!>a<!>
+fun ulong(vararg a: <!OPT_IN_USAGE!>ULong<!>): <!OPT_IN_USAGE!>ULongArray<!> = <!OPT_IN_USAGE!>a<!>

-fun rawUInt(vararg a: <!EXPERIMENTAL_API_USAGE!>UInt<!>): IntArray = <!EXPERIMENTAL_API_USAGE, RETURN_TYPE_MISMATCH!>a<!>
+fun rawUInt(vararg a: <!OPT_IN_USAGE!>UInt<!>): IntArray = <!OPT_IN_USAGE, RETURN_TYPE_MISMATCH!>a<!>
@@ -1,5 +1,5 @@
 // FIR_IDENTICAL
-// !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_EXPRESSION
+// !DIAGNOSTICS: -OPT_IN_USAGE_ERROR -UNUSED_EXPRESSION

 fun test(s: String?) {
    val list = buildList {
@@ -1,5 +1,5 @@
 // !LANGUAGE: +NewInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -UNUSED_PARAMETER -OPT_IN_IS_NOT_ENABLED
 // ISSUE: KT-41164

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // !LANGUAGE: +NewInference
-// !DIAGNOSTICS: -UNUSED_PARAMETER -EXPERIMENTAL_IS_NOT_ENABLED
+// !DIAGNOSTICS: -UNUSED_PARAMETER -OPT_IN_IS_NOT_ENABLED
 // ISSUE: KT-41164

 import kotlin.experimental.ExperimentalTypeInference
@@ -1,5 +1,5 @@
 // FIR_IDENTICAL
-// !DIAGNOSTICS: -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_PARAMETER -CAST_NEVER_SUCCEEDS
+// !DIAGNOSTICS: -OPT_IN_USAGE_ERROR -UNUSED_PARAMETER -CAST_NEVER_SUCCEEDS

 fun <T, R> Flow<T>.transformLatest(@BuilderInference transform: suspend FlowCollector<R>.(value: T) -> Unit) = null as Flow<R>

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNCHECKED_CAST -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNCHECKED_CAST -OPT_IN_USAGE_ERROR -UNUSED_PARAMETER

 class Bar

@@ -1,4 +1,4 @@
-// !DIAGNOSTICS: -UNCHECKED_CAST -EXPERIMENTAL_API_USAGE_ERROR -UNUSED_PARAMETER
+// !DIAGNOSTICS: -UNCHECKED_CAST -OPT_IN_USAGE_ERROR -UNUSED_PARAMETER

 class Bar

@@ -111,29 +111,29 @@ package usage3

 import api.*

-@<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun function() {}
+@<!OPT_IN_USAGE!>EAnno<!> fun function() {}

-fun parameter(@<!EXPERIMENTAL_API_USAGE!>EAnno<!> p: String) {}
+fun parameter(@<!OPT_IN_USAGE!>EAnno<!> p: String) {}

-fun parameterType(p: <!WRONG_ANNOTATION_TARGET!>@<!EXPERIMENTAL_API_USAGE!>EAnno<!><!> String) {}
+fun parameterType(p: <!WRONG_ANNOTATION_TARGET!>@<!OPT_IN_USAGE!>EAnno<!><!> String) {}

-fun returnType(): <!WRONG_ANNOTATION_TARGET!>@<!EXPERIMENTAL_API_USAGE!>EAnno<!><!> Unit {}
+fun returnType(): <!WRONG_ANNOTATION_TARGET!>@<!OPT_IN_USAGE!>EAnno<!><!> Unit {}

-@<!EXPERIMENTAL_API_USAGE!>EAnno<!> val property = ""
+@<!OPT_IN_USAGE!>EAnno<!> val property = ""

-@<!EXPERIMENTAL_API_USAGE!>EAnno<!> typealias Typealias = Unit
+@<!OPT_IN_USAGE!>EAnno<!> typealias Typealias = Unit

-@<!EXPERIMENTAL_API_USAGE!>EAnno<!> class Klass
+@<!OPT_IN_USAGE!>EAnno<!> class Klass

-annotation class AnnotationArgument(val p: <!EXPERIMENTAL_API_USAGE!>EAnno<!>)
+annotation class AnnotationArgument(val p: <!OPT_IN_USAGE!>EAnno<!>)

 fun insideBody() {
-    @<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun local() {}
+    @<!OPT_IN_USAGE!>EAnno<!> fun local() {}
 }

-fun inDefaultArgument(f: () -> Unit = @<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun() {}) {}
+fun inDefaultArgument(f: () -> Unit = @<!OPT_IN_USAGE!>EAnno<!> fun() {}) {}

-val inProperty = @<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun() {}
+val inProperty = @<!OPT_IN_USAGE!>EAnno<!> fun() {}

 val inPropertyAccessor: () -> Unit
-    get() = @<!EXPERIMENTAL_API_USAGE!>EAnno<!> fun() {}
+    get() = @<!OPT_IN_USAGE!>EAnno<!> fun() {}
@@ -19,10 +19,10 @@ package usage
 import api.*

 fun use1() {
-    <!EXPERIMENTAL_API_USAGE!>f<!>()
+    <!OPT_IN_USAGE!>f<!>()
 }

-val use2 = <!EXPERIMENTAL_API_USAGE!>f<!>()
+val use2 = <!OPT_IN_USAGE!>f<!>()

 // FILE: inline-usage.kt

@@ -31,20 +31,20 @@ package usage
 import api.*

 inline fun inlineUse1() {
-    <!EXPERIMENTAL_API_USAGE!>f<!>()
+    <!OPT_IN_USAGE!>f<!>()
 }

 inline var inlineUse2: Unit
    get() {
-        <!EXPERIMENTAL_API_USAGE!>f<!>()
+        <!OPT_IN_USAGE!>f<!>()
    }
    set(value) {
-        <!EXPERIMENTAL_API_USAGE!>f<!>()
+        <!OPT_IN_USAGE!>f<!>()
    }

 var inlineUse3: Unit
    inline get() {
-        <!EXPERIMENTAL_API_USAGE!>f<!>()
+        <!OPT_IN_USAGE!>f<!>()
    }
    @API
    inline set(value) {
@@ -63,23 +63,23 @@ package usage
 import api.*

 private inline fun privateInline1() {
-    <!EXPERIMENTAL_API_USAGE!>f<!>()
+    <!OPT_IN_USAGE!>f<!>()
 }

 internal inline fun privateInline2() {
-    <!EXPERIMENTAL_API_USAGE!>f<!>()
+    <!OPT_IN_USAGE!>f<!>()
 }

 private inline var privateInline3: Unit
    get() {
-        <!EXPERIMENTAL_API_USAGE!>f<!>()
+        <!OPT_IN_USAGE!>f<!>()
    }
    set(value) {
-        <!EXPERIMENTAL_API_USAGE!>f<!>()
+        <!OPT_IN_USAGE!>f<!>()
    }

 internal class InternalClass {
    inline fun privateInline4() {
-        <!EXPERIMENTAL_API_USAGE!>f<!>()
+        <!OPT_IN_USAGE!>f<!>()
    }
 }
@@ -80,10 +80,10 @@ package usage3
 import api.*

 fun use() {
-    val c: <!EXPERIMENTAL_API_USAGE!>C<!> = <!EXPERIMENTAL_API_USAGE!>C<!>()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.<!EXPERIMENTAL_API_USAGE!>function<!>()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.<!EXPERIMENTAL_API_USAGE!>property<!>
-    <!EXPERIMENTAL_API_USAGE!>C<!>.<!EXPERIMENTAL_API_USAGE!>Nested<!>()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.<!EXPERIMENTAL_API_USAGE!>Inner<!>()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.<!EXPERIMENTAL_API_USAGE!>extension<!>()
+    val c: <!OPT_IN_USAGE!>C<!> = <!OPT_IN_USAGE!>C<!>()
+    <!OPT_IN_USAGE!>c<!>.<!OPT_IN_USAGE!>function<!>()
+    <!OPT_IN_USAGE!>c<!>.<!OPT_IN_USAGE!>property<!>
+    <!OPT_IN_USAGE!>C<!>.<!OPT_IN_USAGE!>Nested<!>()
+    <!OPT_IN_USAGE!>c<!>.<!OPT_IN_USAGE!>Inner<!>()
+    <!OPT_IN_USAGE!>c<!>.<!OPT_IN_USAGE!>extension<!>()
 }
@@ -80,10 +80,10 @@ package usage3
 import api.*

 fun use() {
-    val c: <!EXPERIMENTAL_API_USAGE!>C<!> = <!EXPERIMENTAL_API_USAGE!>C<!>()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.function()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.property
-    <!EXPERIMENTAL_API_USAGE!>C<!>.Nested()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.Inner()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.<!EXPERIMENTAL_API_USAGE!>extension<!>()
+    val c: <!OPT_IN_USAGE!>C<!> = <!OPT_IN_USAGE!>C<!>()
+    <!OPT_IN_USAGE!>c<!>.function()
+    <!OPT_IN_USAGE!>c<!>.property
+    <!OPT_IN_USAGE!>C<!>.Nested()
+    <!OPT_IN_USAGE!>c<!>.Inner()
+    <!OPT_IN_USAGE!>c<!>.<!OPT_IN_USAGE!>extension<!>()
 }
@@ -31,8 +31,8 @@ package usage
 import api.*

 fun use() {
-    val c: <!EXPERIMENTAL_API_USAGE!>C<!> = <!EXPERIMENTAL_API_USAGE!>C<!>()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.<!EXPERIMENTAL_API_USAGE!>function<!>()
-    <!EXPERIMENTAL_API_USAGE!>c<!>.<!EXPERIMENTAL_API_USAGE!>property<!>
-    <!EXPERIMENTAL_API_USAGE!>C<!>.<!EXPERIMENTAL_API_USAGE!>Nested<!>().<!EXPERIMENTAL_API_USAGE!>nestedFunction<!>()
+    val c: <!OPT_IN_USAGE!>C<!> = <!OPT_IN_USAGE!>C<!>()
+    <!OPT_IN_USAGE!>c<!>.<!OPT_IN_USAGE!>function<!>()
+    <!OPT_IN_USAGE!>c<!>.<!OPT_IN_USAGE!>property<!>
+    <!OPT_IN_USAGE!>C<!>.<!OPT_IN_USAGE!>Nested<!>().<!OPT_IN_USAGE!>nestedFunction<!>()
 }
@@ -40,5 +40,5 @@ package usage3

 import api.*

-@Anno(<!EXPERIMENTAL_API_USAGE!>MEANING<!>)
+@Anno(<!OPT_IN_USAGE!>MEANING<!>)
 fun usage() {}
@@ -31,7 +31,7 @@ package usage2
 import api.*

 // TODO: there should be no warning here
-@Anno(<!EXPERIMENTAL_API_USAGE!>MEANING<!>)
+@Anno(<!OPT_IN_USAGE!>MEANING<!>)
 fun usage() {}

 // FILE: usage-none.kt
@@ -40,5 +40,5 @@ package usage3

 import api.*

-@Anno(<!EXPERIMENTAL_API_USAGE!>MEANING<!>)
+@Anno(<!OPT_IN_USAGE!>MEANING<!>)
 fun usage() {}
@@ -52,7 +52,7 @@ package usage3
 import api.*

 fun use1() {
-    C.D.<!EXPERIMENTAL_API_USAGE!>E<!>.<!EXPERIMENTAL_API_USAGE!>F<!>()
+    C.D.<!OPT_IN_USAGE!>E<!>.<!OPT_IN_USAGE!>F<!>()
 }

-fun use2(f: <!EXPERIMENTAL_API_USAGE!>C.D.E.F<!>) = <!EXPERIMENTAL_API_USAGE!>f<!>.hashCode()
+fun use2(f: <!OPT_IN_USAGE!>C.D.E.F<!>) = <!OPT_IN_USAGE!>f<!>.hashCode()
@@ -52,7 +52,7 @@ package usage3
 import api.*

 fun use1() {
-    <!EXPERIMENTAL_API_USAGE!>C<!>.D.E.F()
+    <!OPT_IN_USAGE!>C<!>.D.E.F()
 }

-fun use2(f: <!EXPERIMENTAL_API_USAGE!>C<!>.D.E.F) = f.hashCode()
+fun use2(f: <!OPT_IN_USAGE!>C<!>.D.E.F) = f.hashCode()
@@ -23,5 +23,5 @@ class Derived : Base() {
 }

 fun test(b: Base) {
-    b.<!EXPERIMENTAL_API_USAGE_ERROR!>foo<!>()
+    b.<!OPT_IN_USAGE_ERROR!>foo<!>()
 }
@@ -19,9 +19,9 @@ package usage
 import api.*

 class Derived : Base() {
-    override fun <!EXPERIMENTAL_OVERRIDE_ERROR!>foo<!>() {}
+    override fun <!OPT_IN_OVERRIDE_ERROR!>foo<!>() {}
 }

 fun test(b: Base) {
-    b.<!EXPERIMENTAL_API_USAGE_ERROR!>foo<!>()
+    b.<!OPT_IN_USAGE_ERROR!>foo<!>()
 }
@@ -1,7 +1,7 @@
 // FIR_IDENTICAL
 // FILE: api.kt

-@<!EXPERIMENTAL_IS_NOT_ENABLED!>RequiresOptIn<!>
+@<!OPT_IN_IS_NOT_ENABLED!>RequiresOptIn<!>
@Retention(AnnotationRetention.BINARY)
 annotation class Marker

@@ -11,7 +11,7 @@ fun f() {}
 // FILE: usage.kt

 fun use1() {
-    <!EXPERIMENTAL_API_USAGE_ERROR!>f<!>()
+    <!OPT_IN_USAGE_ERROR!>f<!>()
 }

@Marker
@@ -19,7 +19,7 @@ fun use2() {
    f()
 }

-@<!EXPERIMENTAL_IS_NOT_ENABLED!>OptIn<!>(Marker::class)
+@<!OPT_IN_IS_NOT_ENABLED!>OptIn<!>(Marker::class)
 fun use3() {
    f()
 }
@@ -6,7 +6,7 @@
 annotation class E

 class My {
-    <!EXPERIMENTAL_ANNOTATION_ON_OVERRIDE_WARNING!>@E<!>
+    <!OPT_IN_MARKER_ON_OVERRIDE_WARNING!>@E<!>
    override fun hashCode() = 0
 }

@@ -17,8 +17,8 @@ var z: Int = 44
    }

 fun user(): Int {
-    <!EXPERIMENTAL_API_USAGE_ERROR!>x<!> = 10
-    <!EXPERIMENTAL_API_USAGE_ERROR!>y<!> = 5
-    <!EXPERIMENTAL_API_USAGE_ERROR!>x<!> = 15
-    return x + <!EXPERIMENTAL_API_USAGE_ERROR!>y<!> + z
+    <!OPT_IN_USAGE_ERROR!>x<!> = 10
+    <!OPT_IN_USAGE_ERROR!>y<!> = 5
+    <!OPT_IN_USAGE_ERROR!>x<!> = 15
+    return x + <!OPT_IN_USAGE_ERROR!>y<!> + z
 }
@@ -10,15 +10,15 @@ annotation class Marker
 interface Some

 abstract class User {
-    abstract fun createSome(): <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>
-    fun <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>?.onSome() {}
-    fun withSome(some: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>? = null) {}
+    abstract fun createSome(): <!OPT_IN_USAGE_ERROR!>Some<!>
+    fun <!OPT_IN_USAGE_ERROR!>Some<!>?.onSome() {}
+    fun withSome(some: <!OPT_IN_USAGE_ERROR!>Some<!>? = null) {}

    fun use() {
-        val something = <!EXPERIMENTAL_API_USAGE_ERROR!>createSome<!>()
-        val somethingOther: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!> = <!EXPERIMENTAL_API_USAGE_ERROR!>createSome<!>()
-        null.<!EXPERIMENTAL_API_USAGE_ERROR!>onSome<!>()
-        <!EXPERIMENTAL_API_USAGE_ERROR!>withSome<!>()
+        val something = <!OPT_IN_USAGE_ERROR!>createSome<!>()
+        val somethingOther: <!OPT_IN_USAGE_ERROR!>Some<!> = <!OPT_IN_USAGE_ERROR!>createSome<!>()
+        null.<!OPT_IN_USAGE_ERROR!>onSome<!>()
+        <!OPT_IN_USAGE_ERROR!>withSome<!>()
    }
 }

@@ -26,15 +26,15 @@ data class DataClass(@property:Marker val x: Int)

 fun useDataClass(d: DataClass) {
    // Should have error in both
-    d.<!EXPERIMENTAL_API_USAGE_ERROR!>x<!>
+    d.<!OPT_IN_USAGE_ERROR!>x<!>
    val (x) = d
 }

-typealias My = <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>
+typealias My = <!OPT_IN_USAGE_ERROR!>Some<!>

-fun my(my: <!EXPERIMENTAL_API_USAGE_ERROR!>My<!>) {}
+fun my(my: <!OPT_IN_USAGE_ERROR!>My<!>) {}

-fun your(my: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>) {}
+fun your(my: <!OPT_IN_USAGE_ERROR!>Some<!>) {}

@Marker
 interface ExperimentalType {
@@ -49,7 +49,7 @@ interface NotExperimentalExtension : ExperimentalType {

 fun use(arg: NotExperimentalExtension) {
    arg.foo()
-    arg.<!EXPERIMENTAL_API_USAGE_ERROR!>bar<!>()
+    arg.<!OPT_IN_USAGE_ERROR!>bar<!>()
 }

@Marker
@@ -68,7 +68,7 @@ typealias MyList = ArrayList<I>
 typealias YourList = ArrayList<String>

 fun main() {
-    val x = <!EXPERIMENTAL_API_USAGE_ERROR!>listOf<!>(A(), B())
+    val x = <!OPT_IN_USAGE_ERROR!>listOf<!>(A(), B())
    val y = MyList()
    val z = YourList()
    YourList().add("")
@@ -84,7 +84,7 @@ object O {
    operator fun provideDelegate(x: Any?, y: Any?): C = C()
 }

-val x: String by <!EXPERIMENTAL_API_USAGE_ERROR!>O<!>
+val x: String by <!OPT_IN_USAGE_ERROR!>O<!>

@Marker
 class OperatorContainer : Comparable<OperatorContainer> {
@@ -117,8 +117,8 @@ operator fun String.minus(s: String) = OperatorContainer()
 operator fun String.invoke() = OperatorContainer()

 fun operatorContainerUsage(s: String, a: AnotherContainer) {
-    val res1 = s <!EXPERIMENTAL_API_USAGE_ERROR!>-<!> s
-    val res2 = <!EXPERIMENTAL_API_USAGE_ERROR!>s<!>()
-    val res3 = <!EXPERIMENTAL_API_USAGE_ERROR!>res1<!> <!EXPERIMENTAL_API_USAGE_ERROR!>><!> <!EXPERIMENTAL_API_USAGE_ERROR!>res2<!>
-    <!EXPERIMENTAL_API_USAGE_ERROR, EXPERIMENTAL_API_USAGE_ERROR, EXPERIMENTAL_API_USAGE_ERROR, EXPERIMENTAL_API_USAGE_ERROR!>for (c in a) {}<!>
+    val res1 = s <!OPT_IN_USAGE_ERROR!>-<!> s
+    val res2 = <!OPT_IN_USAGE_ERROR!>s<!>()
+    val res3 = <!OPT_IN_USAGE_ERROR!>res1<!> <!OPT_IN_USAGE_ERROR!>><!> <!OPT_IN_USAGE_ERROR!>res2<!>
+    <!OPT_IN_USAGE_ERROR, OPT_IN_USAGE_ERROR, OPT_IN_USAGE_ERROR, OPT_IN_USAGE_ERROR!>for (c in a) {}<!>
 }
@@ -10,15 +10,15 @@ annotation class Marker
 interface Some

 abstract class User {
-    abstract fun createSome(): <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>
-    fun <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>?.onSome() {}
-    fun withSome(some: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>? = null) {}
+    abstract fun createSome(): <!OPT_IN_USAGE_ERROR!>Some<!>
+    fun <!OPT_IN_USAGE_ERROR!>Some<!>?.onSome() {}
+    fun withSome(some: <!OPT_IN_USAGE_ERROR!>Some<!>? = null) {}

    fun use() {
-        val something = <!EXPERIMENTAL_API_USAGE_ERROR!>createSome<!>()
-        val somethingOther: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!> = <!EXPERIMENTAL_API_USAGE_ERROR!>createSome<!>()
-        null.<!EXPERIMENTAL_API_USAGE_ERROR!>onSome<!>()
-        <!EXPERIMENTAL_API_USAGE_ERROR!>withSome<!>()
+        val something = <!OPT_IN_USAGE_ERROR!>createSome<!>()
+        val somethingOther: <!OPT_IN_USAGE_ERROR!>Some<!> = <!OPT_IN_USAGE_ERROR!>createSome<!>()
+        null.<!OPT_IN_USAGE_ERROR!>onSome<!>()
+        <!OPT_IN_USAGE_ERROR!>withSome<!>()
    }
 }

@@ -26,15 +26,15 @@ data class DataClass(@property:Marker val x: Int)

 fun useDataClass(d: DataClass) {
    // Should have error in both
-    d.<!EXPERIMENTAL_API_USAGE_ERROR!>x<!>
-    val (<!EXPERIMENTAL_API_USAGE_ERROR!>x<!>) = d
+    d.<!OPT_IN_USAGE_ERROR!>x<!>
+    val (<!OPT_IN_USAGE_ERROR!>x<!>) = d
 }

-typealias My = <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>
+typealias My = <!OPT_IN_USAGE_ERROR!>Some<!>

-fun my(my: <!EXPERIMENTAL_API_USAGE_ERROR!>My<!>) {}
+fun my(my: <!OPT_IN_USAGE_ERROR!>My<!>) {}

-fun your(my: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>) {}
+fun your(my: <!OPT_IN_USAGE_ERROR!>Some<!>) {}

@Marker
 interface ExperimentalType {
@@ -68,10 +68,10 @@ typealias MyList = ArrayList<I>
 typealias YourList = ArrayList<String>

 fun main() {
-    val x = <!EXPERIMENTAL_API_USAGE_ERROR!>listOf<!>(A(), B())
-    val y = <!EXPERIMENTAL_API_USAGE_ERROR!>MyList<!>()
-    val z = <!EXPERIMENTAL_API_USAGE_ERROR!>YourList<!>()
-    <!EXPERIMENTAL_API_USAGE_ERROR!>YourList<!>().add("")
+    val x = <!OPT_IN_USAGE_ERROR!>listOf<!>(A(), B())
+    val y = <!OPT_IN_USAGE_ERROR!>MyList<!>()
+    val z = <!OPT_IN_USAGE_ERROR!>YourList<!>()
+    <!OPT_IN_USAGE_ERROR!>YourList<!>().add("")
 }

@Marker
@@ -84,7 +84,7 @@ object O {
    operator fun provideDelegate(x: Any?, y: Any?): C = C()
 }

-val x: String by <!EXPERIMENTAL_API_USAGE_ERROR!>O<!>
+val x: String by <!OPT_IN_USAGE_ERROR!>O<!>

@Marker
 class OperatorContainer : Comparable<OperatorContainer> {
@@ -117,8 +117,8 @@ operator fun String.minus(s: String) = OperatorContainer()
 operator fun String.invoke() = OperatorContainer()

 fun operatorContainerUsage(s: String, a: AnotherContainer) {
-    val res1 = s <!EXPERIMENTAL_API_USAGE_ERROR!>-<!> s
-    val res2 = <!EXPERIMENTAL_API_USAGE_ERROR!>s<!>()
-    val res3 = <!EXPERIMENTAL_API_USAGE_ERROR!>res1<!> <!EXPERIMENTAL_API_USAGE_ERROR!>><!> <!EXPERIMENTAL_API_USAGE_ERROR!>res2<!>
-    for (c in <!EXPERIMENTAL_API_USAGE_ERROR!>a<!>) {}
+    val res1 = s <!OPT_IN_USAGE_ERROR!>-<!> s
+    val res2 = <!OPT_IN_USAGE_ERROR!>s<!>()
+    val res3 = <!OPT_IN_USAGE_ERROR!>res1<!> <!OPT_IN_USAGE_ERROR!>><!> <!OPT_IN_USAGE_ERROR!>res2<!>
+    for (c in <!OPT_IN_USAGE_ERROR!>a<!>) {}
 }
@@ -10,15 +10,15 @@ annotation class Marker
 interface Some

 abstract class User {
-    abstract fun createSome(): <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>
-    fun <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>?.onSome() {}
-    fun withSome(some: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>? = null) {}
+    abstract fun createSome(): <!OPT_IN_USAGE_ERROR!>Some<!>
+    fun <!OPT_IN_USAGE_ERROR!>Some<!>?.onSome() {}
+    fun withSome(some: <!OPT_IN_USAGE_ERROR!>Some<!>? = null) {}

    fun use() {
-        val something = <!EXPERIMENTAL_API_USAGE_ERROR!>createSome<!>()
-        val somethingOther: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!> = <!EXPERIMENTAL_API_USAGE_ERROR!>createSome<!>()
-        null.<!EXPERIMENTAL_API_USAGE_ERROR!>onSome<!>()
-        <!EXPERIMENTAL_API_USAGE_ERROR!>withSome<!>()
+        val something = <!OPT_IN_USAGE_ERROR!>createSome<!>()
+        val somethingOther: <!OPT_IN_USAGE_ERROR!>Some<!> = <!OPT_IN_USAGE_ERROR!>createSome<!>()
+        null.<!OPT_IN_USAGE_ERROR!>onSome<!>()
+        <!OPT_IN_USAGE_ERROR!>withSome<!>()
    }
 }

@@ -26,15 +26,15 @@ data class DataClass(@property:Marker val x: Int)

 fun useDataClass(d: DataClass) {
    // Should have error in both
-    d.<!EXPERIMENTAL_API_USAGE_ERROR!>x<!>
+    d.<!OPT_IN_USAGE_ERROR!>x<!>
    val (x) = d
 }

-typealias My = <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>
+typealias My = <!OPT_IN_USAGE_ERROR!>Some<!>

-fun my(my: <!EXPERIMENTAL_API_USAGE_ERROR!>My<!>) {}
+fun my(my: <!OPT_IN_USAGE_ERROR!>My<!>) {}

-fun your(my: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>) {}
+fun your(my: <!OPT_IN_USAGE_ERROR!>Some<!>) {}

@Marker
 interface ExperimentalType {
@@ -49,7 +49,7 @@ interface NotExperimentalExtension : ExperimentalType {

 fun use(arg: NotExperimentalExtension) {
    arg.foo()
-    arg.<!EXPERIMENTAL_API_USAGE_ERROR!>bar<!>()
+    arg.<!OPT_IN_USAGE_ERROR!>bar<!>()
 }

@Marker
@@ -68,7 +68,7 @@ typealias MyList = ArrayList<I>
 typealias YourList = ArrayList<String>

 fun main() {
-    val x = <!EXPERIMENTAL_API_USAGE_ERROR!>listOf<!>(A(), B())
+    val x = <!OPT_IN_USAGE_ERROR!>listOf<!>(A(), B())
    val y = MyList()
    val z = YourList()
    YourList().add("")
@@ -84,7 +84,7 @@ object O {
    operator fun provideDelegate(x: Any?, y: Any?): C = C()
 }

-val x: String by <!EXPERIMENTAL_API_USAGE_ERROR!>O<!>
+val x: String by <!OPT_IN_USAGE_ERROR!>O<!>

@Marker
 class OperatorContainer : Comparable<OperatorContainer> {
@@ -117,8 +117,8 @@ operator fun String.minus(s: String) = OperatorContainer()
 operator fun String.invoke() = OperatorContainer()

 fun operatorContainerUsage(s: String, a: AnotherContainer) {
-    val res1 = s <!EXPERIMENTAL_API_USAGE_ERROR!>-<!> s
-    val res2 = <!EXPERIMENTAL_API_USAGE_ERROR!>s<!>()
-    val res3 = <!EXPERIMENTAL_API_USAGE_ERROR!>res1<!> <!EXPERIMENTAL_API_USAGE_ERROR!>><!> <!EXPERIMENTAL_API_USAGE_ERROR!>res2<!>
-    <!EXPERIMENTAL_API_USAGE_ERROR, EXPERIMENTAL_API_USAGE_ERROR, EXPERIMENTAL_API_USAGE_ERROR, EXPERIMENTAL_API_USAGE_ERROR!>for (c in a) {}<!>
+    val res1 = s <!OPT_IN_USAGE_ERROR!>-<!> s
+    val res2 = <!OPT_IN_USAGE_ERROR!>s<!>()
+    val res3 = <!OPT_IN_USAGE_ERROR!>res1<!> <!OPT_IN_USAGE_ERROR!>><!> <!OPT_IN_USAGE_ERROR!>res2<!>
+    <!OPT_IN_USAGE_ERROR, OPT_IN_USAGE_ERROR, OPT_IN_USAGE_ERROR, OPT_IN_USAGE_ERROR!>for (c in a) {}<!>
 }
@@ -10,15 +10,15 @@ annotation class Marker
 interface Some

 abstract class User {
-    abstract fun createSome(): <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>
-    fun <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>?.onSome() {}
-    fun withSome(some: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>? = null) {}
+    abstract fun createSome(): <!OPT_IN_USAGE_ERROR!>Some<!>
+    fun <!OPT_IN_USAGE_ERROR!>Some<!>?.onSome() {}
+    fun withSome(some: <!OPT_IN_USAGE_ERROR!>Some<!>? = null) {}

    fun use() {
-        val something = <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>createSome<!>()
-        val somethingOther: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!> = <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>createSome<!>()
-        null.<!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>onSome<!>()
-        <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>withSome<!>()
+        val something = <!OPT_IN_USAGE_FUTURE_ERROR!>createSome<!>()
+        val somethingOther: <!OPT_IN_USAGE_ERROR!>Some<!> = <!OPT_IN_USAGE_FUTURE_ERROR!>createSome<!>()
+        null.<!OPT_IN_USAGE_FUTURE_ERROR!>onSome<!>()
+        <!OPT_IN_USAGE_FUTURE_ERROR!>withSome<!>()
    }
 }

@@ -26,15 +26,15 @@ data class DataClass(@property:Marker val x: Int)

 fun useDataClass(d: DataClass) {
    // Should have error in both
-    d.<!EXPERIMENTAL_API_USAGE_ERROR!>x<!>
-    val (<!EXPERIMENTAL_API_USAGE_ERROR!>x<!>) = d
+    d.<!OPT_IN_USAGE_ERROR!>x<!>
+    val (<!OPT_IN_USAGE_ERROR!>x<!>) = d
 }

-typealias My = <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>
+typealias My = <!OPT_IN_USAGE_ERROR!>Some<!>

-fun my(my: <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>My<!>) {}
+fun my(my: <!OPT_IN_USAGE_FUTURE_ERROR!>My<!>) {}

-fun your(my: <!EXPERIMENTAL_API_USAGE_ERROR!>Some<!>) {}
+fun your(my: <!OPT_IN_USAGE_ERROR!>Some<!>) {}

@Marker
 interface ExperimentalType {
@@ -68,10 +68,10 @@ typealias MyList = ArrayList<I>
 typealias YourList = ArrayList<String>

 fun main() {
-    val x = <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>listOf<!>(A(), B())
-    val y = <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>MyList<!>()
-    val z = <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>YourList<!>()
-    <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>YourList<!>().add("")
+    val x = <!OPT_IN_USAGE_FUTURE_ERROR!>listOf<!>(A(), B())
+    val y = <!OPT_IN_USAGE_FUTURE_ERROR!>MyList<!>()
+    val z = <!OPT_IN_USAGE_FUTURE_ERROR!>YourList<!>()
+    <!OPT_IN_USAGE_FUTURE_ERROR!>YourList<!>().add("")
 }

@Marker
@@ -84,7 +84,7 @@ object O {
    operator fun provideDelegate(x: Any?, y: Any?): C = C()
 }

-val x: String by <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>O<!>
+val x: String by <!OPT_IN_USAGE_FUTURE_ERROR!>O<!>

@Marker
 class OperatorContainer : Comparable<OperatorContainer> {
@@ -117,8 +117,8 @@ operator fun String.minus(s: String) = OperatorContainer()
 operator fun String.invoke() = OperatorContainer()

 fun operatorContainerUsage(s: String, a: AnotherContainer) {
-    val res1 = s <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>-<!> s
-    val res2 = <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>s<!>()
-    val res3 = <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>res1<!> <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>><!> <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>res2<!>
-    for (c in <!EXPERIMENTAL_API_USAGE_FUTURE_ERROR!>a<!>) {}
+    val res1 = s <!OPT_IN_USAGE_FUTURE_ERROR!>-<!> s
+    val res2 = <!OPT_IN_USAGE_FUTURE_ERROR!>s<!>()
+    val res3 = <!OPT_IN_USAGE_FUTURE_ERROR!>res1<!> <!OPT_IN_USAGE_FUTURE_ERROR!>><!> <!OPT_IN_USAGE_FUTURE_ERROR!>res2<!>
+    for (c in <!OPT_IN_USAGE_FUTURE_ERROR!>a<!>) {}
 }
--- a/Show More
+++ b/Show More