[FIR] Good test data fixes (around captured types)

compiler/fir/analysis-tests/testData/resolve/references/referenceToExtension.txt

@@ -35,8 +35,8 @@ FILE: referenceToExtension.kt
         }
 
         public final fun test_1(): R|kotlin/Unit| {
-            lval memberValRef: R|kotlin/reflect/KProperty1<GenericTest.B<*>, GenericTest.A<kotlin/Any?>>| = Q|GenericTest.B|::R|FakeOverride</GenericTest.B.memberVal: R|GenericTest.A<kotlin/Any?>|>|
+            lval memberValRef: R|kotlin/reflect/KProperty1<GenericTest.B<*>, GenericTest.A<out kotlin/Any?>>| = Q|GenericTest.B|::R|FakeOverride</GenericTest.B.memberVal: R|GenericTest.A<out kotlin/Any?>|>|
-            lval memberFunRef: R|kotlin/reflect/KFunction1<GenericTest.B<*>, GenericTest.A<kotlin/Any?>>| = Q|GenericTest.B|::R|FakeOverride</GenericTest.B.memberFun: R|GenericTest.A<kotlin/Any?>|>|
+            lval memberFunRef: R|kotlin/reflect/KFunction1<GenericTest.B<*>, GenericTest.A<out kotlin/Any?>>| = Q|GenericTest.B|::R|FakeOverride</GenericTest.B.memberFun: R|GenericTest.A<out kotlin/Any?>|>|
         }
 
         public final fun test_2(): R|kotlin/Unit| {

compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.kt

@@ -74,21 +74,21 @@ typealias Invariant1<X> = Invariant<X>
 fun test_5(a: A, in1: In1<A>, in2: In1<in A>, in3: In1<out A>) {
     in1.take(a)
     in2.take(a)
-    in3.take(a)
+    in3.<!INAPPLICABLE_CANDIDATE!>take<!>(a)
 }
 
 fun test_6(a: A, out1: Out1<A>, out2: Out1<in A>, out3: Out1<out A>) {
     out1.value().foo()
-    out2.value().foo()
+    out2.value().<!UNRESOLVED_REFERENCE!>foo<!>()
     out3.value().foo()
 }
 
 fun test_7(a: A, inv1: Invariant1<A>, inv2: Invariant1<in A>, inv3: Invariant1<out A>) {
     inv1.value().foo()
-    inv2.value().foo()
+    inv2.value().<!UNRESOLVED_REFERENCE!>foo<!>()
     inv3.value().foo()
 
     inv1.take(a)
     inv2.take(a)
-    inv3.take(a)
+    inv3.<!INAPPLICABLE_CANDIDATE!>take<!>(a)
 }

compiler/fir/analysis-tests/testData/resolve/typeAliasWithTypeArguments.txt

@@ -68,18 +68,18 @@ FILE: typeAliasWithTypeArguments.kt
     public final fun test_5(a: R|A|, in1: R|In1<A>|, in2: R|In1<in A>|, in3: R|In1<out A>|): R|kotlin/Unit| {
         R|<local>/in1|.R|FakeOverride</In.take: R|kotlin/Unit|>|(R|<local>/a|)
         R|<local>/in2|.R|FakeOverride</In.take: R|kotlin/Unit|>|(R|<local>/a|)
-        R|<local>/in3|.R|FakeOverride</In.take: R|kotlin/Unit|>|(R|<local>/a|)
+        R|<local>/in3|.<Inapplicable(INAPPLICABLE): /In.take>#(R|<local>/a|)
     }
     public final fun test_6(a: R|A|, out1: R|Out1<A>|, out2: R|Out1<in A>|, out3: R|Out1<out A>|): R|kotlin/Unit| {
         R|<local>/out1|.R|FakeOverride</Out.value: R|A|>|().R|/A.foo|()
-        R|<local>/out2|.R|FakeOverride</Out.value: R|A|>|().R|/A.foo|()
+        R|<local>/out2|.R|FakeOverride</Out.value: R|kotlin/Any?|>|().<Unresolved name: foo>#()
         R|<local>/out3|.R|FakeOverride</Out.value: R|A|>|().R|/A.foo|()
     }
     public final fun test_7(a: R|A|, inv1: R|Invariant1<A>|, inv2: R|Invariant1<in A>|, inv3: R|Invariant1<out A>|): R|kotlin/Unit| {
         R|<local>/inv1|.R|FakeOverride</Invariant.value: R|A|>|().R|/A.foo|()
-        R|<local>/inv2|.R|FakeOverride</Invariant.value: R|A|>|().R|/A.foo|()
+        R|<local>/inv2|.R|FakeOverride</Invariant.value: R|kotlin/Any?|>|().<Unresolved name: foo>#()
         R|<local>/inv3|.R|FakeOverride</Invariant.value: R|A|>|().R|/A.foo|()
         R|<local>/inv1|.R|FakeOverride</Invariant.take: R|kotlin/Unit|>|(R|<local>/a|)
         R|<local>/inv2|.R|FakeOverride</Invariant.take: R|kotlin/Unit|>|(R|<local>/a|)
-        R|<local>/inv3|.R|FakeOverride</Invariant.take: R|kotlin/Unit|>|(R|<local>/a|)
+        R|<local>/inv3|.<Inapplicable(INAPPLICABLE): /Invariant.take>#(R|<local>/a|)
     }

compiler/testData/codegen/box/reflection/methodsFromAny/builtinFunctionsToString.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // SKIP_JDK6
 // TARGET_BACKEND: JVM
 // FULL_JDK

compiler/testData/diagnostics/tests/annotations/rendering/typeMismatchDueToTypeProjections.fir.kt

@@ -14,5 +14,5 @@ class C<T> {
 class Out<out F>
 
 fun test(a: C<out CharSequence>, y: Out<CharSequence>) {
-    a + y
+    a <!INAPPLICABLE_CANDIDATE!>+<!> y
 }

compiler/testData/diagnostics/tests/functionLiterals/kt7383_starProjectedFunction.fir.kt

@@ -3,5 +3,5 @@
 
 fun foo() {
     val f : Function1<*, *> = { x -> x.toString() }
-    f(1)
+    <!INAPPLICABLE_CANDIDATE!>f<!>(1)
 }

compiler/testData/diagnostics/tests/generics/Projections.fir.kt

@@ -21,7 +21,7 @@ class Inv<T>() {
 fun testInOut() {
     In<String>().f("1");
     (null as In<in String>).f("1")
-    (null as In<*>).f("1") // Wrong Arg
+    (null as In<*>).<!NONE_APPLICABLE!>f<!>("1") // Wrong Arg
 
     In<String>().f(1);
     (null as In<in String>).f(1)
@@ -37,16 +37,16 @@ fun testInOut() {
 
     Inv<Int>().f(1)
     (null as Inv<in Int>).f(1)
-    (null as Inv<out Int>).f(1) // !!
+    (null as Inv<out Int>).<!INAPPLICABLE_CANDIDATE!>f<!>(1) // !!
-    (null as Inv<*>).f(1) // !!
+    (null as Inv<*>).<!INAPPLICABLE_CANDIDATE!>f<!>(1) // !!
 
     Inv<Int>().inf(1)
     (null as Inv<in Int>).inf(1)
-    (null as Inv<out Int>).inf(1) // !!
+    (null as Inv<out Int>).<!INAPPLICABLE_CANDIDATE!>inf<!>(1) // !!
-    (null as Inv<*>).inf(1) // !!
+    (null as Inv<*>).<!INAPPLICABLE_CANDIDATE!>inf<!>(1) // !!
 
     Inv<Int>().outf()
-    checkSubtype<Int>((null as Inv<in Int>).outf()) // Type mismatch
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>((null as Inv<in Int>).outf()) // Type mismatch
     (null as Inv<out Int>).outf()
     (null as Inv<*>).outf()
 

compiler/testData/diagnostics/tests/generics/innerClasses/simpleOutUseSite.fir.kt

@@ -29,9 +29,9 @@ fun main() {
     checkSubtype<Outer<out CharSequence>.Inner>(outer.bar())
     checkSubtype<Outer<out CharSequence>.Inner>(outer.Inner())
 
-    outer.set(outer.bar())
+    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.bar())
-    outer.set(outer.Inner())
+    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.Inner())
 
     val x: Outer<String>.Inner = factoryString()
-    outer.set(x)
+    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(x)
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/addAll.fir.kt

@@ -15,18 +15,18 @@ fun <T> mc(): MC<T> = null!!
 fun <T> c(): C<T> = null!!
 
 fun foo(x: MC<out Open>) {
-    x.addAll(x)
+    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(x)
-    x.addAllMC(x)
+    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(x)
 
-    x.addAll(mc<Open>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(mc<Open>())
-    x.addAllMC(mc<Open>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(mc<Open>())
 
-    x.addAll(mc<Derived>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(mc<Derived>())
-    x.addAllMC(mc<Derived>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAllMC<!>(mc<Derived>())
 
     x.addAll(c())
     x.addAll(c<Nothing>())
 
-    x.addAllInv(mc<Open>())
+    x.<!INAPPLICABLE_CANDIDATE!>addAllInv<!>(mc<Open>())
     x.<!INAPPLICABLE_CANDIDATE!>addAll<!>(1)
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/extensionReceiverTypeMismatch.fir.kt

@@ -8,11 +8,11 @@ class Out<out E>
 fun test(x: A<out CharSequence>, y: Out<CharSequence>) {
     with(x) {
         // TODO: this diagnostic could be replaced with TYPE_MISMATCH_DUE_TO_TYPE_PROJECTION
-        "".foo()
+        "".<!INAPPLICABLE_CANDIDATE!>foo<!>()
-        y.bar()
+        y.<!INAPPLICABLE_CANDIDATE!>bar<!>()
 
         with(y) {
-            bar()
+            <!INAPPLICABLE_CANDIDATE!>bar<!>()
         }
     }
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/inValueParameter.fir.kt

@@ -5,5 +5,5 @@ interface B<E> {
 }
 
 fun foo(x: B<in CharSequence>, y: A<CharSequence>) {
-    x.foo(y)
+    x.<!INAPPLICABLE_CANDIDATE!>foo<!>(y)
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/lambdaArgument.fir.kt

@@ -1,16 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-// !CHECK_TYPE
-
-class A<T> {
-    fun foo(f: (T) -> Unit) {}
-}
-
-fun test(a: A<out Number>, b: A<in Number>) {
-    a.foo {
-        it checkType { _<Number>() }
-    }
-
-    b.foo {
-        it checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
-    }
-}

compiler/testData/diagnostics/tests/generics/projectionsScope/lambdaArgument.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // !CHECK_TYPE
 

compiler/testData/diagnostics/tests/generics/projectionsScope/leakedApproximatedType.fir.kt

@@ -14,6 +14,6 @@ fun test(a: A<out CharSequence>, y: Out<CharSequence>) {
     val i = a.foo()
     // TODO: These diagnostic are wrong, type of 'i' --- 'In<Nothing>' is not projected itself,
     // but it's approximation result caused by 'a' projection
-    i.invoke1("")
+    i.<!INAPPLICABLE_CANDIDATE!>invoke1<!>("")
-    i.invoke2(y)
+    i.<!INAPPLICABLE_CANDIDATE!>invoke2<!>(y)
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/multipleArgumentProjectedOut.fir.kt

@@ -6,5 +6,5 @@ class A<T> {
 }
 
 fun test(a: A<out CharSequence>) {
-    a.foo("", "")
+    a.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "")
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/projectedOutConventions.fir.kt

@@ -8,7 +8,7 @@ class A<T> {
 }
 
 fun test(a: A<out CharSequence>) {
-    a + ""
+    a <!INAPPLICABLE_CANDIDATE!>+<!> ""
-    a[1] = ""
+    <!INAPPLICABLE_CANDIDATE!>a[1] = ""<!>
-    a[""]
+    <!INAPPLICABLE_CANDIDATE!>a[""]<!>
 }

compiler/testData/diagnostics/tests/generics/projectionsScope/starNullabilityRecursive.fir.kt

@@ -1,9 +0,0 @@
-// !WITH_NEW_INFERENCE
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-// !CHECK_TYPE
-interface A<T : A<T?>?> {
-    fun foo(): T?
-}
-fun testA(a: A<*>) {
-    a.foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<*>?>() }
-}

compiler/testData/diagnostics/tests/generics/projectionsScope/starNullabilityRecursive.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 // !CHECK_TYPE

compiler/testData/diagnostics/tests/generics/projectionsScope/superClass.fir.kt

@@ -1,12 +0,0 @@
-// !CHECK_TYPE
-
-interface Clazz<T> {
-    val t: T
-    fun getSuperClass(): Clazz<in T>
-}
-
-fun test(clazz: Clazz<*>) {
-    clazz.t checkType { _<Any?>() }
-    clazz.getSuperClass() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Clazz<*>>() }
-    clazz.getSuperClass().t checkType { _<Any?>() }
-}

compiler/testData/diagnostics/tests/generics/projectionsScope/superClass.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 
 interface Clazz<T> {

compiler/testData/diagnostics/tests/generics/projectionsScope/typeMismatchConventions.fir.kt

@@ -10,9 +10,9 @@ class A<T> {
 class Out<out F>
 
 fun test(a: A<out CharSequence>, y: Out<CharSequence>) {
-    a + y
+    a <!INAPPLICABLE_CANDIDATE!>+<!> y
-    a[1] = y
+    <!INAPPLICABLE_CANDIDATE!>a[1] = y<!>
-    a[y]
+    <!INAPPLICABLE_CANDIDATE!>a[y]<!>
 
     a + Out<Nothing>()
     a[1] = Out<Nothing>()

compiler/testData/diagnostics/tests/generics/projectionsScope/typeParameterBounds.fir.kt

@@ -13,15 +13,15 @@ class A<T> {
 }
 
 fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
-    a.foo1(Out<CharSequence>())
+    a.<!INAPPLICABLE_CANDIDATE!>foo1<!>(Out<CharSequence>())
-    a.foo1<Out<CharSequence>>(Out())
+    a.<!INAPPLICABLE_CANDIDATE!>foo1<!><Out<CharSequence>>(Out())
 
     a.foo1(Out())
     a.foo1(Out<Nothing>())
 
-    a.foo2(Inv())
+    a.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv())
-    a.foo2(Inv<CharSequence>())
+    a.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv<CharSequence>())
-    a.foo2<Inv<CharSequence>>(Inv())
+    a.<!INAPPLICABLE_CANDIDATE!>foo2<!><Inv<CharSequence>>(Inv())
 
     a.foo3(In())
     a.foo3(In<CharSequence>())
@@ -31,13 +31,13 @@ fun foo2(a: A<out CharSequence>, b: A<in CharSequence>) {
     b.foo1(Out<CharSequence>())
     b.foo1<Out<CharSequence>>(Out())
 
-    b.foo2(Inv())
+    b.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv())
-    b.foo2(Inv<CharSequence>())
+    b.<!INAPPLICABLE_CANDIDATE!>foo2<!>(Inv<CharSequence>())
-    b.foo2<Inv<CharSequence>>(Inv())
+    b.<!INAPPLICABLE_CANDIDATE!>foo2<!><Inv<CharSequence>>(Inv())
 
 
-    b.foo3(In<CharSequence>())
+    b.<!INAPPLICABLE_CANDIDATE!>foo3<!>(In<CharSequence>())
-    b.foo3<In<CharSequence>>(In())
+    b.<!INAPPLICABLE_CANDIDATE!>foo3<!><In<CharSequence>>(In())
 
     b.foo3(In<Any?>())
     b.foo3(In())

compiler/testData/diagnostics/tests/generics/projectionsScope/varargs.fir.kt

@@ -6,8 +6,8 @@ class A<T> {
 }
 
 fun test(a: A<out CharSequence>, y: Array<out CharSequence>) {
-    a.foo("", "", "")
+    a.<!INAPPLICABLE_CANDIDATE!>foo<!>("", "", "")
-    a.foo(*y)
+    a.<!INAPPLICABLE_CANDIDATE!>foo<!>(*y)
     // TODO: TYPE_MISMATCH_DUE_TO_TYPE_PROJECTIONS probably redundant
-    a.foo(*y, "")
+    a.<!INAPPLICABLE_CANDIDATE!>foo<!>(*y, "")
 }

compiler/testData/diagnostics/tests/generics/varProjection/setterNotProjectedOutAssign.fir.kt

@@ -6,5 +6,5 @@ interface Tr<T> {
 
 fun test(t: Tr<*>) {
     t.v = t
-    t.v checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Tr<*>>() }
+    t.v checkType { _<Tr<*>>() }
 }

compiler/testData/diagnostics/tests/inference/capturedTypes/memberScopeOfCaptured.fir.kt

@@ -1,12 +0,0 @@
-// !CHECK_TYPE
-
-class A<T> {
-    fun foo(): T = null!!
-}
-
-fun <E> A<E>.bar(): A<in E> = this
-
-fun baz(x: A<out CharSequence>) {
-    x.bar() checkType { _<A<*>>() }
-    x.bar().foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() } // See KT-10448
-}

compiler/testData/diagnostics/tests/inference/capturedTypes/memberScopeOfCaptured.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 
 class A<T> {

compiler/testData/diagnostics/tests/j+k/arrayOfStarParametrized.fir.kt

@@ -1,14 +0,0 @@
-// !CHECK_TYPE
-
-// FILE: A.java
-public class A<T> {
-    public A<T>[] baz() { return null; }
-}
-
-
-// FILE: main.kt
-
-fun foo1(x: A<*>) = x.baz()
-fun foo2(x: A<*>) {
-    x.baz() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Array<out A<*>>>() }
-}

compiler/testData/diagnostics/tests/j+k/arrayOfStarParametrized.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 
 // FILE: A.java

compiler/testData/diagnostics/tests/j+k/wrongVarianceInJava.fir.kt

@@ -19,6 +19,6 @@ class In<in F> {
 }
 
 fun test() {
-    A.foo().x() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+    A.foo().x() checkType { _<Any?>() }
-    A.bar().y(null)
+    A.bar().<!INAPPLICABLE_CANDIDATE!>y<!>(null)
 }

compiler/testData/diagnostics/tests/regressions/kt12898.fir.kt

@@ -10,7 +10,7 @@ class C(override val t: Any?) : B<Any?, Any>
 fun f(b: B<*, Any>) {
     val y = b.t
     if (y is String?) {
-        y.length
+        y.<!INAPPLICABLE_CANDIDATE!>length<!>
     }
 }
 

compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericWithProjection.fir.kt

@@ -7,5 +7,5 @@ class In<in T>() {
 
 fun test1(x: In<String>): Unit = x.f("1")
 fun test2(x: In<in String>): Unit = x.f("1")
-fun test3(x: <!CONFLICTING_PROJECTION!>In<out String><!>): Unit = x.f("1")
+fun test3(x: <!CONFLICTING_PROJECTION!>In<out String><!>): Unit = x.<!NONE_APPLICABLE!>f<!>("1")
-fun test4(x: In<*>): Unit = x.f("1")
+fun test4(x: In<*>): Unit = x.<!NONE_APPLICABLE!>f<!>("1")

compiler/testData/diagnostics/tests/substitutions/starProjections.fir.kt

@@ -8,7 +8,7 @@ interface A<R, T: A<R, T>> {
 
 fun testA(a: A<*, *>) {
     a.r().checkType { _<Any?>() }
-    a.t().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<*, *>>() }
+    a.t().checkType { _<A<*, *>>() }
 }
 
 interface B<R, T: B<List<R>, T>> {

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericClass.fir.kt

@@ -1,7 +1,7 @@
 // JAVAC_EXPECTED_FILE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<String>): String {
-    return javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething<!>("", 1) { s: String -> "" }
+    return javaClass.doSomething("", 1) { s: String -> "" }
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/GenericMethodInGenericClass.fir.kt

@@ -2,7 +2,7 @@
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass<Int>) {
     val a: String = javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething1<!>("", 1) { p: String -> p }
-    val b: String = javaClass.<!INAPPLICABLE_CANDIDATE!>doSomething2<!>("", 1, true) { p: Int -> p }
+    val b: String = javaClass.doSomething2("", 1, true) { p: Int -> p }
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/typealias/starProjection.fir.kt

@@ -10,6 +10,6 @@ fun test2(x: Map<String, Int>) = check(x)
 
 fun test3(x: Map<Int, String>) = check(x).size
 
-fun test4(x: Map<Int, String>) = check(x)["42"]
+fun test4(x: Map<Int, String>) = <!INAPPLICABLE_CANDIDATE!>check(x)["42"]<!>
 
-fun test5(x: Map<Int, String>) = check(x)[42]
+fun test5(x: Map<Int, String>) = <!INAPPLICABLE_CANDIDATE!>check(x)[42]<!>

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorCrazyProjections.fir.kt

@@ -11,6 +11,6 @@ fun <T> listOf(): List<T> = null!!
 // Unresolved reference is ok here:
 // we can't create a substituted signature for type alias constructor
 // since it has 'out' type projection in 'in' position.
-val test1 = BOutIn(listOf(), null!!)
+val test1 = <!INAPPLICABLE_CANDIDATE!>BOutIn<!>(listOf(), null!!)
 
 val test2 = BInIn(listOf(), null!!)

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

@@ -3,12 +3,12 @@
 fun test(mc: MutableCollection<out CharSequence>) {
     mc.addAll(mc)
 
-    mc.addAll(arrayListOf<CharSequence>())
+    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(arrayListOf<CharSequence>())
     mc.addAll(arrayListOf())
 
-    mc.addAll(listOf(""))
+    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf(""))
-    mc.addAll(listOf<String>(""))
+    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf<String>(""))
-    mc.addAll(listOf<CharSequence>(""))
+    mc.<!INAPPLICABLE_CANDIDATE!>addAll<!>(listOf<CharSequence>(""))
 
     mc.addAll(emptyList())
     mc.addAll(emptyList<Nothing>())

compiler/tests-spec/testData/diagnostics/notLinked/dfa/pos/58.fir.kt

@@ -74,7 +74,7 @@ fun case_6() {
     var y: Inv<out Number> = Inv<Int>()
     if (true)
         y = x
-    y.put(0)
+    y.<!INAPPLICABLE_CANDIDATE!>put<!>(0)
     val z: Inv<out Number> = x
     z.put(0)
 }