[FIR] Resolve annotations as calls

compiler/testData/diagnostics/tests/annotations/AmbigiousAnnotationConstructor.fir.kt

@@ -1,6 +1,6 @@
 // !WITH_NEW_INFERENCE
 import java.util.ArrayList
 
-@ArrayList<Int>(1, 1) fun b() {}
-@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>) fun c() {}
-@java.lang.Deprecated(x) fun a() {}
+<!UNRESOLVED_REFERENCE!>@ArrayList<Int>(1, 1)<!> fun b() {}
+<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>Xoo<!>(<!UNRESOLVED_REFERENCE!>x<!>)<!> fun c() {}
+<!INAPPLICABLE_CANDIDATE!>@java.lang.Deprecated(<!UNRESOLVED_REFERENCE!>x<!>)<!> fun a() {}

compiler/testData/diagnostics/tests/annotations/AnnotationForClassTypeParameter.fir.kt

@@ -1,10 +1,10 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-class TopLevelClass<@A1 @A2(3) @A2 @A1(12) @A2("Test") T> {
-    class InnerClass<@A1 @A2(3) @A2 @A1(12) @A2("Test") T> {
+class TopLevelClass<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
+    class InnerClass<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> {
         fun test() {
-            class InFun<@A1 @A2(3) @A2 @A1(12) @A2("Test") T>
+            class InFun<@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T>
         }
     }
-}
+}

compiler/testData/diagnostics/tests/annotations/AnnotationForFunctionTypeParameter.fir.kt

@@ -1,12 +1,12 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-fun <@A1 @A2(3) @A2 @A1(12) @A2("Test")  T> topFun() = 12
+fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> topFun() = 12
 
 class SomeClass {
-    fun <@A1 @A2(3) @A2 @A1(12) @A2("Test") T> method() = 12
+    fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> method() = 12
 
     fun foo() {
-        fun <@A1 @A2(3) @A2 @A1(12) @A2("Test")  T> innerFun() = 12
+        fun <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> innerFun() = 12
     }
-}
+}

compiler/testData/diagnostics/tests/annotations/AnnotationIdentifier.fir.kt

@@ -6,7 +6,7 @@ annotation class annotation
 
 package test
 
-@test.annotation class annotation
+<!UNRESOLVED_REFERENCE!>@test.annotation<!> class annotation
 
 // FILE: other/c.kt
 
@@ -14,6 +14,6 @@ package other
 
 annotation class My
 
-@test.annotation class Your
+<!UNRESOLVED_REFERENCE!>@test.annotation<!> class Your
 
-@My class Our
+@My class Our

compiler/testData/diagnostics/tests/annotations/AnnotationsForPropertyTypeParameter.fir.kt

@@ -3,12 +3,12 @@
 annotation class A1
 annotation class A2(val some: Int = 12)
 
-val <@A1 @A2(3) @A2 @A1(12) @A2("Test")  T> T.topProp: Int get() = 12
+val <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!>  T> T.topProp: Int get() = 12
 
 class SomeClass {
-    val <@A1 @A2(3) @A2 @A1(12) @A2("Test") T> T.field: Int get() = 12
+    val <@A1 @A2(3) @A2 <!INAPPLICABLE_CANDIDATE!>@A1(12)<!> <!INAPPLICABLE_CANDIDATE!>@A2("Test")<!> T> T.field: Int get() = 12
 
     fun foo() {
         val <@A1 @A2(3) @A2 @A1(12) @A2("Test") T> localVal = 12
     }
-}
+}

compiler/testData/diagnostics/tests/annotations/BasicAnnotations.fir.kt

@@ -3,7 +3,7 @@ annotation class my1(val i : Int)
 annotation class my2(val i : Int = 0)
 
 @my fun foo() {}
-@my1 fun foo2() {}
+<!INAPPLICABLE_CANDIDATE!>@my1<!> fun foo2() {}
 @my1(2) fun foo3() {}
 @my2() fun foo4() {}
 @my2 fun foo41() {}

compiler/testData/diagnostics/tests/annotations/NonAnnotationClass.fir.kt

@@ -1,3 +1,3 @@
 class Foo
 
-@Foo class Bar
+<!UNRESOLVED_REFERENCE!>@Foo<!> class Bar

compiler/testData/diagnostics/tests/annotations/RecursivelyIncorrectlyAnnotatedParameter.fir.kt

@@ -1,2 +1,2 @@
 // Class constructor parameter CAN be recursively annotated
-class RecursivelyAnnotated(@RecursivelyAnnotated(1) val x: Int)
+class RecursivelyAnnotated(<!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>@RecursivelyAnnotated(1)<!> val x: Int)

compiler/testData/diagnostics/tests/annotations/WrongAnnotationArgsOnObject.fir.kt

@@ -1,8 +1,8 @@
 package test
 
-@BadAnnotation(1)
+<!INAPPLICABLE_CANDIDATE!>@BadAnnotation(1)<!>
 object SomeObject
 
 val some = SomeObject
 
-annotation class BadAnnotation(val s: String)
+annotation class BadAnnotation(val s: String)

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_after.fir.kt

@@ -11,5 +11,5 @@ enum class MyEnum {
     A
 }
 
-@AnnE(Test())
-class Test2
+<!INAPPLICABLE_CANDIDATE!>@AnnE(Test())<!>
+class Test2

compiler/testData/diagnostics/tests/annotations/annotationParameterMustBeConstant/enumConst_before.fir.kt

@@ -11,5 +11,5 @@ enum class MyEnum {
     A
 }
 
-@AnnE(Test())
-class Test2
+<!INAPPLICABLE_CANDIDATE!>@AnnE(Test())<!>
+class Test2

compiler/testData/diagnostics/tests/annotations/annotationsOnLambdaAsCallArgument.fir.kt

@@ -13,7 +13,7 @@ fun foo() {
         return@l1 103
     }
 
-    bar @Ann("") {
+    bar <!INAPPLICABLE_CANDIDATE!>@Ann("")<!> {
         104
     }
 }

compiler/testData/diagnostics/tests/annotations/atAnnotationResolve.fir.kt

@@ -8,7 +8,7 @@ annotation class Ann(val x: Int = 6)
 
 @Ann(1) @Ann(2) @Ann(3) private class A @Ann constructor() {
     @Ann(x = 5) fun foo() {
-        1 + @Ann(1) 1 * @Ann("") 6
+        1 + @Ann(1) 1 * <!INAPPLICABLE_CANDIDATE!>@Ann("")<!> 6
 
         @Ann fun local() {}
     }

compiler/testData/diagnostics/tests/annotations/deprecatedRepeatable.fir.kt

@@ -2,9 +2,9 @@
 
 import java.lang.annotation.Repeatable
 
-@java.lang.annotation.Repeatable(Annotations::class) annotation class RepAnn
+<!INAPPLICABLE_CANDIDATE!>@java.lang.annotation.Repeatable(Annotations::class)<!> annotation class RepAnn
 
-@Repeatable(OtherAnnotations::class) annotation class OtherAnn
+<!INAPPLICABLE_CANDIDATE!>@Repeatable(OtherAnnotations::class)<!> annotation class OtherAnn
 
 annotation class Annotations(vararg val value: RepAnn)
 

compiler/testData/diagnostics/tests/annotations/illegalRequireKotlinValue.fir.kt

@@ -3,36 +3,36 @@ package test
 
 import kotlin.internal.RequireKotlin
 
-@RequireKotlin("")
+<!HIDDEN!>@RequireKotlin("")<!>
 fun f01() {}
 
-@RequireKotlin("x")
+<!HIDDEN!>@RequireKotlin("x")<!>
 fun f02() {}
 
-@RequireKotlin("1")
+<!HIDDEN!>@RequireKotlin("1")<!>
 fun f03() {}
 
-@RequireKotlin("1.0-beta")
+<!HIDDEN!>@RequireKotlin("1.0-beta")<!>
 fun f04() {}
 
-@RequireKotlin("1.1.0-dev-1111")
+<!HIDDEN!>@RequireKotlin("1.1.0-dev-1111")<!>
 fun f05() {}
 
-@RequireKotlin("1.5.3.7")
+<!HIDDEN!>@RequireKotlin("1.5.3.7")<!>
 fun f06() {}
 
-@RequireKotlin("1..0")
+<!HIDDEN!>@RequireKotlin("1..0")<!>
 fun f07() {}
 
-@RequireKotlin(" 1.0")
+<!HIDDEN!>@RequireKotlin(" 1.0")<!>
 fun f08() {}
 
 
-@RequireKotlin("1.1")
+<!HIDDEN!>@RequireKotlin("1.1")<!>
 fun ok1() {}
 
-@RequireKotlin("1.1.0")
+<!HIDDEN!>@RequireKotlin("1.1.0")<!>
 fun ok2() {}
 
-@RequireKotlin("0.0.0")
+<!HIDDEN!>@RequireKotlin("0.0.0")<!>
 fun ok3() {}

compiler/testData/diagnostics/tests/annotations/kt1860-negative.fir.kt

@@ -1,10 +1,10 @@
 // !WITH_NEW_INFERENCE
-fun foo(@<!UNRESOLVED_REFERENCE!>varargs<!> f : Int) {}
+fun foo(<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>varargs<!> f : Int) {}
 
 var bar : Int = 1
-  set(@<!UNRESOLVED_REFERENCE!>varargs<!> v) {}
+  set(<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>varargs<!> v) {}
 
-val x : (Int) -> Int = {@<!UNRESOLVED_REFERENCE!>varargs<!> x <!SYNTAX!>: Int -> x<!>}
+val x : (Int) -> Int = {<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>varargs<!> x <!SYNTAX!>: Int -> x<!>}
 
-class Hello(@<!UNRESOLVED_REFERENCE!>varargs<!> args: Any) {
-}
+class Hello(<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>varargs<!> args: Any) {
+}

compiler/testData/diagnostics/tests/annotations/typeParameterAsAnnotation.fir.kt

@@ -1,9 +1,9 @@
 class Foo<T> {
-    @T
+    <!UNRESOLVED_REFERENCE!>@T<!>
     fun foo() = 0
 }
 
 class Bar<T : Annotation> {
-    @T
+    <!UNRESOLVED_REFERENCE!>@T<!>
     fun foo() = 0
-}
+}

compiler/testData/diagnostics/tests/annotations/unresolvedReferenceRange.fir.kt

@@ -1,5 +1,5 @@
-@<!UNRESOLVED_REFERENCE!>Ann<!> class A
-@<!UNRESOLVED_REFERENCE!>Ann<!> class B
-@<!UNRESOLVED_REFERENCE!>Ann<!>(1) class C
-@<!UNRESOLVED_REFERENCE!>kotlin.Ann<!>(1) class D
-@<!UNRESOLVED_REFERENCE!>kotlin.annotation.Ann<!>(1) class E
+<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>Ann<!> class A
+<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>Ann<!> class B
+<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>Ann<!>(1)<!> class C
+<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>kotlin.Ann<!>(1)<!> class D
+<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>kotlin.annotation.Ann<!>(1)<!> class E

compiler/testData/diagnostics/tests/collectionLiterals/collectionLiteralsWithVarargs.fir.kt

@@ -34,8 +34,8 @@ fun test6() {}
 
 annotation class AnnArray(val a: Array<String>)
 
-@AnnArray(*["/"])
+<!INAPPLICABLE_CANDIDATE!>@AnnArray(*["/"])<!>
 fun testArray() {}
 
 @Ann1([""])
-fun testVararg() {}
+fun testVararg() {}

compiler/testData/diagnostics/tests/deprecated/javaDeprecated.fir.kt

@@ -11,6 +11,6 @@ public class A {
 
 // FILE: B.kt
 
-class B(private @property:Deprecated val foo: String) : A() {
+class B(private <!INAPPLICABLE_CANDIDATE, INAPPLICABLE_CANDIDATE!>@property:Deprecated<!> val foo: String) : A() {
     override fun getFoo(text: String): String = super.getFoo(text + foo)
 }

compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.fir.kt

@@ -1,7 +1,7 @@
 // !CHECK_TYPE
 
 
-@kotlin.internal.InlineOnly
+<!HIDDEN!>@kotlin.internal.InlineOnly<!>
 public inline fun <C, R> C.ifEmpty(f: () -> R): R where C : Collection<*>, C : R = if (isEmpty()) f() else this
 
 public fun <T> listOf(t: T): List<T> = TODO()
@@ -13,4 +13,4 @@ fun usage(c: List<String>) {
 
     val cs = c.ifEmpty { listOf("x") }
     cs checkType { _<List<String>>() }
-}
+}

compiler/testData/diagnostics/tests/localClasses/localAnnotationClass.fir.kt

@@ -3,7 +3,7 @@
 fun f() {
     <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Anno<!>
 
-    @Anno class Local {
+    <!UNRESOLVED_REFERENCE!>@Anno<!> class Local {
         <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Nested<!>
     }
 }

compiler/testData/diagnostics/tests/localClasses/localAnnotationClassError.fir.kt

@@ -3,7 +3,7 @@
 fun f() {
     <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Anno<!>
 
-    @Anno class Local {
+    <!UNRESOLVED_REFERENCE!>@Anno<!> class Local {
         <!LOCAL_ANNOTATION_CLASS_ERROR!>annotation class Nested<!>
     }
 }

compiler/testData/diagnostics/tests/modifiers/IllegalModifiers.fir.kt

@@ -1,4 +1,4 @@
-@<!UNRESOLVED_REFERENCE!><!SYNTAX!><!>myAnnotation<!> public
+<!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!><!SYNTAX!><!>myAnnotation<!> public
 package illegal_modifiers
 
 abstract class A() {

compiler/testData/diagnostics/tests/objects/kt21515/annotationConstructor.fir.kt

@@ -8,6 +8,6 @@ open class Base {
 
 class Derived : Base() {
 
-    @<!UNRESOLVED_REFERENCE!>Foo<!>
+    <!UNRESOLVED_REFERENCE!>@<!UNRESOLVED_REFERENCE!>Foo<!>
     fun foo() = 42
-}
+}

compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.fir.kt

@@ -17,11 +17,11 @@ class C1
 // FILE: 2.kt
 package pp
 
-@A(<!HIDDEN!>foo<!>)
+<!HIDDEN!>@A(<!HIDDEN!>foo<!>)<!>
 fun f2() {}
 
-@A(<!HIDDEN!>foo<!>)
+<!HIDDEN!>@A(<!HIDDEN!>foo<!>)<!>
 val p2 = ""
 
-@A(<!HIDDEN!>foo<!>)
+<!HIDDEN!>@A(<!HIDDEN!>foo<!>)<!>
 class C2

compiler/testData/diagnostics/tests/secondaryConstructors/ctrsAnnotationResolve.fir.kt

@@ -5,8 +5,8 @@ annotation class Ann2(val x: Int)
 class A {
     @Ann1
     constructor()
-    @Ann2
+    <!INAPPLICABLE_CANDIDATE!>@Ann2<!>
     constructor(x1: Int)
     @Ann2(2)
     constructor(x1: Int, x2: Int)
-}
+}

compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_3.fir.kt

@@ -31,6 +31,6 @@ fun test_ann(s: String, arr: Array<String>) {
 
     @Ann("", x = 1)
     foo()
-    @Ann(s = "", x = 1)
+    <!INAPPLICABLE_CANDIDATE!>@Ann(s = "", x = 1)<!>
     foo()
-}
+}

compiler/testData/diagnostics/tests/varargs/assignArrayToVararagInNamedForm_1_4.fir.kt

@@ -31,6 +31,6 @@ fun test_ann(s: String, arr: Array<String>) {
 
     @Ann("", x = 1)
     foo()
-    @Ann(s = "", x = 1)
+    <!INAPPLICABLE_CANDIDATE!>@Ann(s = "", x = 1)<!>
     foo()
 }

compiler/testData/diagnostics/tests/varargs/assigningArraysToVarargsInAnnotations.fir.kt

@@ -15,10 +15,10 @@ annotation class Ann(vararg val s: String)
 @Ann(s = arrayOf())
 fun test1() {}
 
-@Ann(s = intArrayOf())
+<!INAPPLICABLE_CANDIDATE!>@Ann(s = intArrayOf())<!>
 fun test2() {}
 
-@Ann(s = arrayOf(1))
+<!INAPPLICABLE_CANDIDATE!>@Ann(s = arrayOf(1))<!>
 fun test3() {}
 
 @Ann("value1", "value2")
@@ -43,4 +43,4 @@ annotation class IntAnn(vararg val i: Int)
 fun foo1() {}
 
 @IntAnn(i = intArrayOf(0))
-fun foo2() {}
+fun foo2() {}

compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_after.fir.kt

@@ -11,7 +11,7 @@
 
 annotation class Ann(vararg val s: String)
 
-@Ann(s = "value")
+<!INAPPLICABLE_CANDIDATE!>@Ann(s = "value")<!>
 fun test1() {}
 
 @Ann(s = *arrayOf("value"))
@@ -20,11 +20,11 @@ fun test2() {}
 @Ann(s = *["value"])
 fun test3() {}
 
-@JavaAnn(value = "value")
+<!INAPPLICABLE_CANDIDATE!>@JavaAnn(value = "value")<!>
 fun test4() {}
 
 @JavaAnn("value", path = arrayOf("path"))
 fun test5() {}
 
 @JavaAnn("value", path = ["path"])
-fun test6() {}
+fun test6() {}

compiler/testData/diagnostics/tests/varargs/assigningSingleElementsInNamedFormAnnDeprecation_before.fir.kt

@@ -11,7 +11,7 @@
 
 annotation class Ann(vararg val s: String)
 
-@Ann(s = "value")
+<!INAPPLICABLE_CANDIDATE!>@Ann(s = "value")<!>
 fun test1() {}
 
 @Ann(s = *arrayOf("value"))
@@ -20,11 +20,11 @@ fun test2() {}
 @Ann(s = *["value"])
 fun test3() {}
 
-@JavaAnn(value = "value")
+<!INAPPLICABLE_CANDIDATE!>@JavaAnn(value = "value")<!>
 fun test4() {}
 
 @JavaAnn("value", path = arrayOf("path"))
 fun test5() {}
 
 @JavaAnn("value", path = ["path"])
-fun test6() {}
+fun test6() {}

compiler/testData/diagnostics/tests/varargs/noAssigningArraysToVarargsFeature.fir.kt

@@ -15,10 +15,10 @@ annotation class Ann(vararg val s: String)
 @Ann(s = arrayOf())
 fun test1() {}
 
-@Ann(s = intArrayOf())
+<!INAPPLICABLE_CANDIDATE!>@Ann(s = intArrayOf())<!>
 fun test2() {}
 
-@Ann(s = arrayOf(1))
+<!INAPPLICABLE_CANDIDATE!>@Ann(s = arrayOf(1))<!>
 fun test3() {}
 
 @Ann(s = ["value"])
@@ -43,7 +43,7 @@ fun foo2() {}
 
 fun foo(vararg i: Int) {}
 
-@Ann(s = "value")
+<!INAPPLICABLE_CANDIDATE!>@Ann(s = "value")<!>
 fun dep1() {
     <!INAPPLICABLE_CANDIDATE!>foo<!>(i = 1)
-}
+}

compiler/testData/diagnostics/tests/varargs/prohibitAssigningSingleElementsInNamedForm.fir.kt

@@ -4,7 +4,7 @@
 annotation class Anno1(vararg val s: String)
 annotation class Anno2(vararg val i: Int)
 
-@Anno1(s = "foo")
+<!INAPPLICABLE_CANDIDATE!>@Anno1(s = "foo")<!>
 @Anno2(i = *intArrayOf(1))
 fun f1() {}
 

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArray.fir.kt

@@ -12,12 +12,12 @@ public @interface A {
 
 @A(*arrayOf("5", "6"), "7", y = 3) fun test3() {}
 
-@A("1", "2", "3", x = String::class, y = 4) fun test4() {}
+<!INAPPLICABLE_CANDIDATE!>@A("1", "2", "3", x = String::class, y = 4)<!> fun test4() {}
 
 @A("4", y = 5) fun test5() {}
 
-@A(*arrayOf("5", "6"), "7", x = Any::class, y = 6) fun test6() {}
+<!INAPPLICABLE_CANDIDATE!>@A(*arrayOf("5", "6"), "7", x = Any::class, y = 6)<!> fun test6() {}
 
 @A(y = 7) fun test7() {}
 
-@A("8", "9", "10") fun test8() {}
+<!INAPPLICABLE_CANDIDATE!>@A("8", "9", "10")<!> fun test8() {}

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationParameters/valueArrayAndOtherDefault.fir.kt

@@ -15,16 +15,16 @@ public @interface A {
 
 @A(*arrayOf("5", "6"), "7") fun test3() {}
 
-@A("1", "2", "3", x = String::class) fun test4() {}
+<!INAPPLICABLE_CANDIDATE!>@A("1", "2", "3", x = String::class)<!> fun test4() {}
 
 @A("4", y = 2) fun test5() {}
 
-@A(*arrayOf("5", "6"), "7", x = Any::class, y = 3) fun test6() {}
+<!INAPPLICABLE_CANDIDATE!>@A(*arrayOf("5", "6"), "7", x = Any::class, y = 3)<!> fun test6() {}
 
 @A() fun test7() {}
 
 @A fun test8() {}
 
-@A(x = Any::class, *arrayOf("5", "6"), "7", y = 3) fun test9() {}
-@A(x = Any::class, value = ["5", "6"], "7", y = 3) fun test10() {}
-@A(x = Any::class, value = ["5", "6", "7"], y = 3) fun test11() {}
+<!INAPPLICABLE_CANDIDATE!>@A(x = Any::class, *arrayOf("5", "6"), "7", y = 3)<!> fun test9() {}
+<!INAPPLICABLE_CANDIDATE!>@A(x = Any::class, value = ["5", "6"], "7", y = 3)<!> fun test10() {}
+<!INAPPLICABLE_CANDIDATE!>@A(x = Any::class, value = ["5", "6", "7"], y = 3)<!> fun test11() {}

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/javaAnnotationWithVarargArgument.fir.kt

@@ -6,6 +6,6 @@ public @interface A {
 }
 
 // FILE: b.kt
-@A(*arrayOf(1, "b"))
+<!INAPPLICABLE_CANDIDATE!>@A(*arrayOf(1, "b"))<!>
 fun test() {
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/annotationWithVarargParameter/kotlinAnnotationWithVarargArgument.fir.kt

@@ -2,6 +2,6 @@
 
 annotation class B(vararg val args: String)
 
-@B(*arrayOf(1, "b"))
+<!INAPPLICABLE_CANDIDATE!>@B(*arrayOf(1, "b"))<!>
 fun test() {
 }

compiler/testData/diagnostics/testsWithStdLib/annotations/jvmPackageName/incorrectJvmPackageName.fir.kt

@@ -1,27 +1,27 @@
 // !DIAGNOSTICS: -INVISIBLE_MEMBER -INVISIBLE_REFERENCE
 
 // FILE: b.kt
-@file:JvmPackageName("")
+<!HIDDEN!>@file:JvmPackageName("")<!>
 package b
 fun b() {}
 
 // FILE: c.kt
-@file:JvmPackageName("invalid-fq-name")
+<!HIDDEN!>@file:JvmPackageName("invalid-fq-name")<!>
 package c
 fun c() {}
 
 // FILE: d.kt
-@file:JvmPackageName("d")
+<!HIDDEN!>@file:JvmPackageName("d")<!>
 package d
 class D
 fun d() {}
 
 // FILE: e.kt
-@file:JvmPackageName(42)
+<!HIDDEN!>@file:JvmPackageName(42)<!>
 package e
 fun e() {}
 
 // FILE: f.kt
-@file:JvmPackageName(f)
+<!HIDDEN!>@file:JvmPackageName(f)<!>
 package f
 const val name = "f"

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.fir.kt

@@ -14,7 +14,7 @@ class MyClass1
 @Ann1(arrayOf(Any::class))
 class MyClass1a
 
-@Ann1(arrayOf(B1::class))
+<!INAPPLICABLE_CANDIDATE!>@Ann1(arrayOf(B1::class))<!>
 class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -25,5 +25,5 @@ class MyClass3
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-@Ann2(arrayOf(B2::class))
+<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(B2::class))<!>
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.fir.kt

@@ -11,7 +11,7 @@ annotation class Ann1(val arg: Array<KClass<out A>>)
 @Ann1(arrayOf(A::class))
 class MyClass1
 
-@Ann1(arrayOf(Any::class))
+<!INAPPLICABLE_CANDIDATE!>@Ann1(arrayOf(Any::class))<!>
 class MyClass1a
 
 @Ann1(arrayOf(B1::class))
@@ -19,11 +19,11 @@ class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<out B1>>)
 
-@Ann2(arrayOf(A::class))
+<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(A::class))<!>
 class MyClass3
 
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-@Ann2(arrayOf(B2::class))
+<!INAPPLICABLE_CANDIDATE!>@Ann2(arrayOf(B2::class))<!>
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsInVariance.fir.kt

@@ -12,7 +12,7 @@ class MyClass1
 @Ann1(Any::class)
 class MyClass1a
 
-@Ann1(B1::class)
+<!INAPPLICABLE_CANDIDATE!>@Ann1(B1::class)<!>
 class MyClass2
 
 annotation class Ann2(val arg: KClass<in B1>)
@@ -23,5 +23,5 @@ class MyClass3
 @Ann2(B1::class)
 class MyClass4
 
-@Ann2(B2::class)
+<!INAPPLICABLE_CANDIDATE!>@Ann2(B2::class)<!>
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInAnnotationsOutVariance.fir.kt

@@ -9,7 +9,7 @@ annotation class Ann1(val arg: KClass<out A>)
 @Ann1(A::class)
 class MyClass1
 
-@Ann1(Any::class)
+<!INAPPLICABLE_CANDIDATE!>@Ann1(Any::class)<!>
 class MyClass1a
 
 @Ann1(B1::class)
@@ -17,11 +17,11 @@ class MyClass2
 
 annotation class Ann2(val arg: KClass<out B1>)
 
-@Ann2(A::class)
+<!INAPPLICABLE_CANDIDATE!>@Ann2(A::class)<!>
 class MyClass3
 
 @Ann2(B1::class)
 class MyClass4
 
-@Ann2(B2::class)
+<!INAPPLICABLE_CANDIDATE!>@Ann2(B2::class)<!>
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassInvariantTP.fir.kt

@@ -8,15 +8,15 @@ annotation class Ann1(val arg: KClass<A>)
 @Ann1(A::class)
 class MyClass1
 
-@Ann1(Any::class)
+<!INAPPLICABLE_CANDIDATE!>@Ann1(Any::class)<!>
 class MyClass1a
 
-@Ann1(B::class)
+<!INAPPLICABLE_CANDIDATE!>@Ann1(B::class)<!>
 class MyClass2
 
 annotation class Ann2(val arg: KClass<B>)
 
-@Ann2(A::class)
+<!INAPPLICABLE_CANDIDATE!>@Ann2(A::class)<!>
 class MyClass3
 
 @Ann2(B::class)

compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/tooManyArgs.fir.kt

@@ -6,6 +6,6 @@ public @interface A {
 }
 
 // FILE: b.kt
-@A(false,
+<!INAPPLICABLE_CANDIDATE!>@A(false,
 1.0,
-false, 1, 2) fun foo1() {}
+false, 1, 2)<!> fun foo1() {}

compiler/testData/diagnostics/testsWithStdLib/annotations/prohibitPositionedArgument/typeMismatch.fir.kt

@@ -6,8 +6,8 @@ public @interface A {
 }
 
 // FILE: b.kt
-@A(false,
+<!INAPPLICABLE_CANDIDATE!>@A(false,
 1.0,
-false) fun foo1() {}
+false)<!> fun foo1() {}
 
-@A(2.0, x = true, b = 2.0) fun foo2() {}
+<!INAPPLICABLE_CANDIDATE!>@A(2.0, x = true, b = 2.0)<!> fun foo2() {}

compiler/testData/diagnostics/testsWithStdLib/experimental/wasExperimental.fir.kt

@@ -10,19 +10,19 @@ fun newPublishedFun() {}
 annotation class Marker
 
 @SinceKotlin("1.4")
-@WasExperimental(Marker::class)
+<!HIDDEN!>@WasExperimental(Marker::class)<!>
 fun newFunExperimentalInThePast() {}
 
 @SinceKotlin("1.4")
-@WasExperimental(Marker::class)
+<!HIDDEN!>@WasExperimental(Marker::class)<!>
 val newValExperimentalInThePast = ""
 
 @SinceKotlin("1.4")
-@WasExperimental(Marker::class)
+<!HIDDEN!>@WasExperimental(Marker::class)<!>
 class NewClassExperimentalInThePast
 
 @SinceKotlin("1.4")
-@WasExperimental(Marker::class)
+<!HIDDEN!>@WasExperimental(Marker::class)<!>
 typealias TypeAliasToNewClass = NewClassExperimentalInThePast
 
 

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/checkLowPriorityIsResolvedSuccessfully.fir.kt

@@ -1,6 +1,6 @@
 class Foo {
     @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-    @kotlin.internal.LowPriorityInOverloadResolution
+    <!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
     val test: Bar = Bar()
 }
 

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/exactAnnotationWithUpperBoundConstraint.fir.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER -DEBUG_INFO_CONSTANT -UNUSED_EXPRESSION
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes K, V, V1 : V?>
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K, V, V1 : V?>
     Map<out K, @kotlin.internal.Exact V>.getOrDefault_Exact(key: K, defaultValue: V1): V1 = TODO()
 
 fun test() {
@@ -14,4 +14,4 @@ fun test() {
     <!DEBUG_INFO_EXPRESSION_TYPE("kotlin.Int?")!>r2<!>
 
     map.getOrDefault_Exact("y", "string")
-}
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/explicitTypeArgumentAsValidInputType.fir.kt

@@ -5,7 +5,7 @@ interface Parent
 object ChildA : Parent
 object ChildB : Parent
 
-fun <@kotlin.internal.OnlyInputTypes T> select(a: T, b: T) {}
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> select(a: T, b: T) {}
 
 fun test() {
     select(ChildA, ChildB) // should be error

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt26698.fir.kt

@@ -7,17 +7,17 @@ class CX : Base()
 class CY : Base()
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes T> foo(a: T, b: T) {}
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> foo(a: T, b: T) {}
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes T : Any> fooA(a: T, b: T) {}
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T : Any> fooA(a: T, b: T) {}
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes T : Base> fooB(a: T, b: T) {}
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T : Base> fooB(a: T, b: T) {}
 
 
 fun usage(x: CX, y: CY) {
     foo(x, y) // expected err, got err
     fooA(x, y) // expected err, got ok
     fooB(x, y) // expected err, got ok
-}
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt35210.fir.kt

@@ -0,0 +1,12 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
+annotation class Anno
+
+fun test(a: List<Class<Anno>>) {
+    strictSelect(a, emptyList<Anno>().map { it.annotationClass.java })
+}
+
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> S> strictSelect(arg1: S, arg2: S): S = TODO()

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/kt35210.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !LANGUAGE: +NewInference
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
@@ -10,4 +9,4 @@ fun test(a: List<Class<Anno>>) {
     strictSelect(a, emptyList<Anno>().map { it.annotationClass.java })
 }
 
-fun <@kotlin.internal.OnlyInputTypes S> strictSelect(arg1: S, arg2: S): S = TODO()
+fun <@kotlin.internal.OnlyInputTypes S> strictSelect(arg1: S, arg2: S): S = TODO()

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/noInferAndLowPriority.fir.kt

@@ -3,7 +3,7 @@
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 @kotlin.jvm.JvmName("containsAny")
-@kotlin.internal.LowPriorityInOverloadResolution
+<!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
 public fun <T> Iterable<T>.contains1(element: T): Int = null!!
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
@@ -13,4 +13,4 @@ public fun <T> Iterable<T>.contains1(element: @kotlin.internal.NoInfer T): Boole
 fun test() {
     val a: Boolean = listOf(1).contains1("")
     val b: Boolean = listOf(1).contains1(1)
-}
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeAndJava.fir.kt

@@ -0,0 +1,18 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: TestBase.java
+
+public class TestBase<T> { }
+
+// FILE: Test.java
+
+public class Test<K> extends TestBase<K> { }
+
+// FILE: main.kt
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K> TestBase<out K>.foo(key: K) = null
+fun foo(result: Test<*>) {
+    result.foo("sd") // Type inference failed (NI), OK in OI
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeAndJava.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !LANGUAGE: +NewInference
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
@@ -16,4 +15,4 @@ public class Test<K> extends TestBase<K> { }
 fun <@kotlin.internal.OnlyInputTypes K> TestBase<out K>.foo(key: K) = null
 fun foo(result: Test<*>) {
     result.foo("sd") // Type inference failed (NI), OK in OI
-}
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeRecursiveBoundAndProjections.fir.kt

@@ -0,0 +1,24 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+
+interface IFace<K, out V>
+
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K, V> IFace<out K, V>.get(key: K): V? = TODO()
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> I> id(arg: I): I = arg
+
+interface InvBase<B>
+class DerivedInv : InvBase<DerivedInv>
+class InvRecursive<E : InvBase<E>>
+
+fun test1(argument: InvRecursive<*>, receiver: IFace<InvRecursive<DerivedInv>, Any>) {
+    receiver.get(argument)
+}
+
+fun test2(arg: InvRecursive<out DerivedInv>) {
+    id(arg)
+}
+
+fun test3(arg: InvRecursive<in DerivedInv>) {
+    id(arg)
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypeRecursiveBoundAndProjections.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 @file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypes.fir.kt

@@ -3,7 +3,7 @@
 // !WITH_NEW_INFERENCE
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-public fun <@kotlin.internal.OnlyInputTypes T> Iterable<T>.contains1(element: T): Boolean = null!!
+public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> Iterable<T>.contains1(element: T): Boolean = null!!
 
 class In<in T>
 

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndLowPriority.fir.kt

@@ -4,19 +4,19 @@
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 @kotlin.jvm.JvmName("containsAny")
-@kotlin.internal.LowPriorityInOverloadResolution
+<!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
 public fun <T> Iterable<T>.contains1(element: T): Int = null!!
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-public fun <@kotlin.internal.OnlyInputTypes T> Iterable<T>.contains1(element: T): Boolean = null!!
+public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> Iterable<T>.contains1(element: T): Boolean = null!!
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
 @JvmName("getAny")
-@kotlin.internal.LowPriorityInOverloadResolution
+<!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
 public fun <K, V> Map<K, V>.get1(key: Any?): Int = null!!
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-public fun <@kotlin.internal.OnlyInputTypes K, V> Map<out K, V>.get1(key: K): V? = null!!
+public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K, V> Map<out K, V>.get1(key: K): V? = null!!
 
 fun test(map: Map<Int, String>) {
     val a: Int = listOf(1).contains1("")
@@ -24,4 +24,4 @@ fun test(map: Map<Int, String>) {
 
     val c: String? = map.get1("")
     val d: String? = map.get1(1)
-}
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAndTopLevelCapturedTypes.fir.kt

@@ -5,13 +5,13 @@
 class Inv<T>
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes K> Inv<out K>.onlyOut(e: K) {}
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K> Inv<out K>.onlyOut(e: K) {}
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes K : Number> Inv<out K>.onlyOutUB(e: K) {}
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K : Number> Inv<out K>.onlyOutUB(e: K) {}
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes K> Inv<in K>.onlyIn(e: K) {}
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K> Inv<in K>.onlyIn(e: K) {}
 
 fun test(
     invStar: Inv<*>,
@@ -71,4 +71,4 @@ class Test5 {
             }
             field = value
         }
-}
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAnnotationWithPlatformTypes.fir.kt

@@ -0,0 +1,19 @@
+//!DIAGNOSTICS: -UNUSED_PARAMETER
+
+//FILE:Foo.java
+
+public class Foo {
+    public static String foo() {
+        return null;
+    }
+}
+
+//FILE:Bar.kt
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> assertEquals1(t1: T, t2: T) {}
+
+fun test() {
+    assertEquals1(null, Foo.foo())
+    assertEquals1("", Foo.foo())
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesAnnotationWithPlatformTypes.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 //!DIAGNOSTICS: -UNUSED_PARAMETER
 
 //FILE:Foo.java
@@ -17,4 +16,4 @@ fun <@kotlin.internal.OnlyInputTypes T> assertEquals1(t1: T, t2: T) {}
 fun test() {
     assertEquals1(null, Foo.foo())
     assertEquals1("", Foo.foo())
-}
+}

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCaptured.fir.kt

@@ -4,10 +4,10 @@
 // Issue: KT-26698
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-public fun <@kotlin.internal.OnlyInputTypes T> Iterable<T>.contains1(element: T): Boolean = null!!
+public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> Iterable<T>.contains1(element: T): Boolean = null!!
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-public fun <@kotlin.internal.OnlyInputTypes T> Iterable<T>.foo(element: T): T = null!!
+public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> Iterable<T>.foo(element: T): T = null!!
 
 class Inv<T>
 class Inv2<T, R>

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesCommonConstraintSystem.fir.kt

@@ -16,8 +16,8 @@ class InB<in C : Bound>(v: C)
 class Out<out O>(val v: O)
 class OutB<out O : Bound>(val v: O)
 
-fun <@OnlyInputTypes M> strictId(arg: M): M = arg
-fun <@OnlyInputTypes S> strictSelect(arg1: S, arg2: S): S = arg1
+fun <<!HIDDEN!>@OnlyInputTypes<!> M> strictId(arg: M): M = arg
+fun <<!HIDDEN!>@OnlyInputTypes<!> S> strictSelect(arg1: S, arg2: S): S = arg1
 
 fun testOK(first: First, bound: Bound, second: Second) {
     strictId(Inv(15))

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesUpperBound.fir.kt

@@ -10,4 +10,4 @@ fun <T> foo(i: Inv<in T>, o: Out<T>) {
     bar(i, o)
 }
 
-fun <@kotlin.internal.OnlyInputTypes K> bar(r: Inv<out K>, o: Out<K>): K = TODO()
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> K> bar(r: Inv<out K>, o: Out<K>): K = TODO()

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/onlyInputTypesWarning.fir.kt

@@ -2,7 +2,7 @@
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes S> select(a1: S, a2: S): S = TODO()
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> S> select(a1: S, a2: S): S = TODO()
 
 interface Common
 class First : Common

compiler/testData/diagnostics/testsWithStdLib/inference/annotationsForResolve/resolveWithOnlyInputTypesAnnotation.fir.kt

@@ -3,7 +3,7 @@
 // !WITH_NEW_INFERENCE
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-fun <@kotlin.internal.OnlyInputTypes T> assertEquals1(t1: T, t2: T) {}
+fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> assertEquals1(t1: T, t2: T) {}
 
 open class A
 class B: A()
@@ -19,8 +19,8 @@ fun test1(a: A, b: B, c: C) {
 }
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-public fun <@kotlin.internal.OnlyInputTypes T> expect1(expected: T, block: () -> T) {}
+public fun <<!HIDDEN!>@kotlin.internal.OnlyInputTypes<!> T> expect1(expected: T, block: () -> T) {}
 
 fun test() {
     expect1(2) { byteArrayOf(1, 2, 3).indexOf(3) }
-}
+}

compiler/testData/diagnostics/testsWithStdLib/inline/inlineOnlySuppressesNothingToInline.fir.kt

@@ -0,0 +1,31 @@
+// !DIAGNOSTICS: -INVISIBLE_MEMBER -INVISIBLE_REFERENCE -UNUSED_PARAMETER -NULLABLE_INLINE_PARAMETER
+
+<!HIDDEN!>@kotlin.internal.InlineOnly<!>
+inline fun test() {
+
+}
+
+<!HIDDEN!>@kotlin.internal.InlineOnly<!>
+inline fun test3(noinline s : (Int) -> Int) {
+
+}
+
+<!HIDDEN!>@kotlin.internal.InlineOnly<!>
+inline fun test4(noinline s : Int.() -> Int) {
+
+}
+
+<!HIDDEN!>@kotlin.internal.InlineOnly<!>
+inline fun Function1<Int, Int>?.test5() {
+
+}
+
+<!HIDDEN!>@kotlin.internal.InlineOnly<!>
+inline fun Function1<Int, Int>?.test6() {
+
+}
+
+<!HIDDEN!>@kotlin.internal.InlineOnly<!>
+inline fun test2(s : ((Int) -> Int)?) {
+
+}

compiler/testData/diagnostics/testsWithStdLib/inline/inlineOnlySuppressesNothingToInline.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -INVISIBLE_MEMBER -INVISIBLE_REFERENCE -UNUSED_PARAMETER -NULLABLE_INLINE_PARAMETER
 
 @kotlin.internal.InlineOnly
@@ -29,4 +28,4 @@ inline fun Function1<Int, Int>?.test6() {
 @kotlin.internal.InlineOnly
 inline fun test2(s : ((Int) -> Int)?) {
 
-}
+}

compiler/testData/diagnostics/testsWithStdLib/pureReifiable.fir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+inline fun <reified <!HIDDEN!>@kotlin.internal.PureReifiable<!> T> foo(x: T) {}
+
+fun test() {
+    foo<List<String>>(listOf(""))
+    foo(listOf(""))
+
+    foo<Array<String>>(arrayOf(""))
+    foo(arrayOf(""))
+}

compiler/testData/diagnostics/testsWithStdLib/pureReifiable.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")

compiler/testData/diagnostics/testsWithStdLib/regression/ea70880_illegalJvmName.fir.kt

@@ -1,8 +1,8 @@
-@JvmName()
+<!INAPPLICABLE_CANDIDATE!>@JvmName()<!>
 fun foo() {}
 
-@JvmName(42)
+<!INAPPLICABLE_CANDIDATE!>@JvmName(42)<!>
 fun bar() {}
 
-@JvmName("a", "b")
+<!INAPPLICABLE_CANDIDATE!>@JvmName("a", "b")<!>
 fun baz() {}

compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers.fir.kt

@@ -8,11 +8,11 @@ package b
 import a.A
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-@kotlin.internal.HidesMembers
+<!HIDDEN!>@kotlin.internal.HidesMembers<!>
 fun A.forEach(i: Int) = i
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-@kotlin.internal.HidesMembers
+<!HIDDEN!>@kotlin.internal.HidesMembers<!>
 fun A.forEach(s: String) {}
 
 
@@ -28,11 +28,11 @@ class A {
 }
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-@kotlin.internal.HidesMembers
+<!HIDDEN!>@kotlin.internal.HidesMembers<!>
 fun A.forEach() = ""
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-@kotlin.internal.HidesMembers
+<!HIDDEN!>@kotlin.internal.HidesMembers<!>
 fun A.forEach(s: String) {}
 
 fun test(a: A) {

compiler/testData/diagnostics/testsWithStdLib/resolve/hidesMembers2.fir.kt

@@ -8,12 +8,12 @@ class A {
 }
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-@kotlin.internal.HidesMembers
+<!HIDDEN!>@kotlin.internal.HidesMembers<!>
 fun A.forEach(i: Int) = i
 
 class B {
     @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-    @kotlin.internal.HidesMembers
+    <!HIDDEN!>@kotlin.internal.HidesMembers<!>
     fun A.forEach() = this@B
 
     fun test(a: A) {
@@ -27,11 +27,11 @@ class B {
 
 fun test2(a: A) {
     @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-    @kotlin.internal.HidesMembers
+    <!HIDDEN!>@kotlin.internal.HidesMembers<!>
     fun A.forEach() = ""
 
     @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-    @kotlin.internal.HidesMembers
+    <!HIDDEN!>@kotlin.internal.HidesMembers<!>
     fun A.forEach(i: Int) = ""
 
     a.forEach() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
@@ -41,4 +41,4 @@ fun test2(a: A) {
         forEach() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
         forEach(1)
     }
-}
+}