[FIR-TEST] Add new testdata generated after changes in previous commit

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

@@ -0,0 +1,12 @@
+//!DIAGNOSTICS: -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <T, U: T> List<@kotlin.internal.Exact T>.firstTyped(): U = throw Exception()
+
+fun test1(l: List<Number>) {
+
+    val i: Int = l.firstTyped()
+
+    val s: String = l.firstTyped()
+}

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

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -INVISIBLE_MEMBER -INVISIBLE_REFERENCE -UNUSED_PARAMETER
+
+interface Parent
+object ChildA : Parent
+object ChildB : Parent
+
+fun <@kotlin.internal.OnlyInputTypes T> select(a: T, b: T) {}
+
+fun test() {
+    select(ChildA, ChildB) // should be error
+    select<Any>(ChildA, ChildB) // should be ok
+}

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

@@ -0,0 +1,30 @@
+//!DIAGNOSTICS: -UNUSED_PARAMETER
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <R> Iterable<*>.filterIsInstance1(): List<@kotlin.internal.NoInfer R> = throw Exception()
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <R> List<*>.filterIsInstance2(): @kotlin.internal.NoInfer List<R> = throw Exception()
+
+fun test(list: List<Int>) {
+    list.filterIsInstance1<Int>().map { it * 2 }
+    list.filterIsInstance2<Int>().filter { it > 10 }
+}
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <R> foo(t: R): List<@kotlin.internal.NoInfer R> = throw Exception("$t")
+
+fun test() {
+    foo(1).map { it * 2 }
+}
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <R> List<R>.foo(): @kotlin.internal.NoInfer R = throw Exception()
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <R> bar(r: R, f: Function1<@kotlin.internal.NoInfer R, Unit>): Nothing = throw Exception()
+
+fun test1() {
+    listOf("").foo().length
+    bar(1) { x -> x + 1 }
+}

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

@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+open class Base()
+class CX : Base()
+class CY : Base()
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <@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) {}
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <@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/kt29307.fir.kt

@@ -0,0 +1,31 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+// ISSUE: KT-29307
+
+fun test_1(map: Map<String, String>) {
+    val x = map[42] // OK
+}
+
+open class A
+
+class B : A()
+
+fun test_2(map: Map<A, String>) {
+    val x = map[42]
+}
+
+fun test_3(m: Map<*, String>) {
+    val x = m[42] // should be ok
+}
+
+fun test_4(m: Map<out Number, String>) {
+    val x = m.get(42) // should be ok
+}
+
+fun test_5(map: Map<B, Int>, a: A) {
+    map.get(a)
+}
+
+fun test_6(map: Map<A, Int>, b: B) {
+    map.get(b)
+}

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

@@ -0,0 +1,16 @@
+//!DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@kotlin.jvm.JvmName("containsAny")
+@kotlin.internal.LowPriorityInOverloadResolution
+public fun <T> Iterable<T>.contains1(element: T): Int = null!!
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public fun <T> Iterable<T>.contains1(element: @kotlin.internal.NoInfer T): Boolean = null!!
+
+
+fun test() {
+    val a: Boolean = listOf(1).<!AMBIGUITY!>contains1<!>("")
+    val b: Boolean = listOf(1).<!AMBIGUITY!>contains1<!>(1)
+}

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

@@ -0,0 +1,33 @@
+//!DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <T> test1(t1: T, t2: @kotlin.internal.NoInfer T): T = t1
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <T> @kotlin.internal.NoInfer T.test2(t1: T): T = t1
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <T> test3(t1: @kotlin.internal.NoInfer T): T = t1
+
+fun usage() {
+    test1(1, "312")
+    1.test2("")
+    test3("")
+}
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <T> List<T>.contains1(e: @kotlin.internal.NoInfer T): Boolean = true
+
+fun test(i: Int?, a: Any, l: List<Int>) {
+    l.contains1(a)
+    l.contains1("")
+    l.contains1(i)
+}
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <T> assertEquals1(e1: T, e2: @kotlin.internal.NoInfer T): Boolean = true
+
+fun test(s: String) {
+    assertEquals1(s, 11)
+}

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

@@ -0,0 +1,26 @@
+// !LANGUAGE: +NewInference
+
+// FILE: SmartFMap.java
+
+public class SmartFMap<K, V> implements java.util.Map<K, V> {
+    public static < K, V> SmartFMap<K, V> emptyMap() {
+        return null;
+    }
+
+    public SmartFMap < K, V> plus(@org.jetbrains.annotations.NotNull K key, V value) {
+        return null;
+    }
+}
+
+// FILE: main.kt
+
+class KotlinType
+
+interface TypePredicate : (KotlinType) -> Boolean {
+    override fun invoke(typeToCheck: KotlinType): Boolean
+}
+
+fun <T : Any?> TypePredicate.expectedTypeFor(keys: Iterable<T>): Map<T, TypePredicate> =
+    keys.fold(SmartFMap.emptyMap<T, TypePredicate>()) { map, key ->
+        map.plus(key, this)
+    }

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

@@ -0,0 +1,47 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public fun <@kotlin.internal.OnlyInputTypes T> Iterable<T>.contains1(element: T): Boolean = null!!
+
+class In<in T>
+
+class Out<out T>
+
+class Inv<T>
+
+fun test_1(list: List<In<Number>>, x: In<Number>, y: In<Int>, z: In<Any>) {
+    list.contains1(x)
+    list.contains1(y)
+    list.contains1(z)
+}
+
+fun test_2(list: List<In<Int>>, x: In<Int>, y: In<Number>, z: In<Any>) {
+    list.contains1(x)
+    list.contains1(y)
+    list.contains1(z)
+}
+
+fun test_3(list: List<Out<Number>>, x: Out<Number>, y: Out<Int>, z: Out<Any>) {
+    list.contains1(x)
+    list.contains1(y)
+    list.contains1(z)
+}
+
+fun test_4(list: List<Out<Int>>, x: Out<Int>, y: Out<Number>, z: Out<Any>) {
+    list.contains1(x)
+    list.contains1(y)
+    list.contains1(z)
+}
+
+fun test_5(list: List<Inv<Number>>, x: Inv<Number>, y: Inv<Int>, z: Inv<Any>) {
+    list.contains1(x)
+    list.contains1(y)
+    list.contains1(z)
+}
+
+fun test_6(list: List<Inv<Int>>, x: Inv<Int>, y: Inv<Number>, z: Inv<Any>) {
+    list.contains1(x)
+    list.contains1(y)
+    list.contains1(z)
+}

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

@@ -0,0 +1,26 @@
+//!DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@kotlin.jvm.JvmName("containsAny")
+@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!!
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+@JvmName("getAny")
+@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!!
+
+fun test(map: Map<Int, String>) {
+    val a: Int = listOf(1).<!AMBIGUITY!>contains1<!>("")
+    val b: Boolean = listOf(1).<!AMBIGUITY!>contains1<!>(1)
+
+    val c: String? = map.get1("")
+    val d: String? = map.get1(1)
+}

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

@@ -0,0 +1,73 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_VARIABLE
+// !WITH_NEW_INFERENCE
+
+class Inv<T>
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <@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) {}
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+fun <@kotlin.internal.OnlyInputTypes K> Inv<in K>.onlyIn(e: K) {}
+
+fun test(
+    invStar: Inv<*>,
+    invOut: Inv<out Number>,
+    invIn: Inv<in Number>
+) {
+    invStar.onlyOut("str")
+    invOut.onlyOut(42)
+    invOut.onlyOut(1L)
+
+    invOut.<!INAPPLICABLE_CANDIDATE!>onlyOutUB<!>("str")
+    invStar.<!INAPPLICABLE_CANDIDATE!>onlyOutUB<!>(0)
+    invOut.onlyOutUB(42)
+    invOut.onlyOutUB(1L)
+
+    invIn.<!INAPPLICABLE_CANDIDATE!>onlyIn<!>("str")
+    invIn.onlyIn(42)
+    invIn.onlyIn(1L)
+}
+
+// From KT-32157
+fun test2(value: Any?) {
+    val result = (value as? Map<*, *>)?.get("result")
+}
+
+// From KT-32116
+fun test3(h: HashMap<*, *>) {
+    val a = <!AMBIGUITY!>h["str"]<!>
+    val b = <!AMBIGUITY!>h[1]<!>
+    val c = <!AMBIGUITY!>h["other"]<!> as? Double
+}
+
+// From KT-32218
+fun test4() {
+    val map: Map<out Any, Any> = mapOf(
+        true to true,
+        1L to 1L
+    )
+    val test = map[1L]
+}
+
+// From KT-32235
+
+class A<T> {
+    val children = mutableListOf<B<T>>()
+}
+
+class B<T>
+
+class Test5 {
+    var a: A<*>? = null
+    var b: B<*>? = null
+        set(value) {
+            if (value != null) {
+                val a = a
+                require(a != null && value in a.children)
+            }
+            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 <@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

@@ -0,0 +1,113 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_VARIABLE -UNUSED_PARAMETER
+// Issue: KT-26698
+
+@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+public fun <@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!!
+
+class Inv<T>
+class Inv2<T, R>
+
+class In<in T>
+class Out<out T>
+
+// -------------------------------------------------------
+
+fun test_0(x: Inv2<in Number, out Number>, list: List<Inv2<Any, Int>>) {
+    list.foo(x)
+}
+
+// ------------------------- Inv -------------------------
+
+fun test_1(x: Inv<Number>, list: List<Inv<Number>>) {
+    list.contains1(x)
+}
+
+fun test_2(x: Inv<Number>, list: List<Inv<Int>>) {
+    list.contains1(x)
+}
+
+fun test_3(x: Inv<Number>, list: List<Inv<Any>>) {
+    list.contains1(x)
+}
+
+fun test_4(x: Inv<in Number>, list: List<Inv<Any>>) {
+    list.contains1(x)
+}
+
+fun test_5(x: Inv<in Number>, list: List<Inv<Number>>) {
+    list.contains1(x)
+}
+
+fun test_6(x: Inv<in Number>, list: List<Inv<Int>>) {
+    list.contains1(x)
+}
+
+fun test_7(x: Inv<out Number>, list: List<Inv<Any>>) {
+    list.contains1(x)
+}
+
+fun test_8(x: Inv<out Number>, list: List<Inv<Number>>) {
+    list.contains1(x)
+}
+
+fun test_9(x: Inv<out Number>, list: List<Inv<Int>>) {
+    list.contains1(x)
+}
+
+// ------------------------- In -------------------------
+
+fun test_11(x: In<Number>, list: List<In<Number>>) {
+    list.contains1(x)
+}
+
+fun test_12(x: In<Number>, list: List<In<Int>>) {
+    list.contains1(x)
+}
+
+fun test_13(x: In<Number>, list: List<In<Any>>) {
+    list.contains1(x)
+}
+
+// ------------------------- Out -------------------------
+
+fun test_21(x: Out<Number>, list: List<Out<Number>>) {
+    list.contains1(x)
+}
+
+fun test_22(x: Out<Number>, list: List<Out<Int>>) {
+    list.contains1(x)
+}
+
+fun test_23(x: Out<Number>, list: List<Out<Any>>) {
+    list.contains1(x)
+}
+
+// --------------------------------------------------------
+
+fun test_31(x: Inv<Number>, list: List<Inv<in Number>>) {
+    list.contains1(x)
+}
+
+fun test_32(x: Inv<Number>, list: List<Inv<in Int>>) {
+    list.contains1(x)
+}
+
+fun test_33(x: Inv<Number>, list: List<Inv<in Any>>) {
+    list.contains1(x)
+}
+
+fun test_34(x: Inv<Number>, list: List<Inv<out Number>>) {
+    list.contains1(x)
+}
+
+fun test_35(x: Inv<Number>, list: List<Inv<out Int>>) {
+    list.contains1(x)
+}
+
+fun test_36(x: Inv<Number>, list: List<Inv<out Any>>) {
+    list.contains1(x)
+}

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

@@ -0,0 +1,26 @@
+fun test1(ns: String?, vararg nullableStrs: String?) {
+    nullableStrs.contains("x")
+    nullableStrs.contains(ns)
+    "x" in nullableStrs
+    ns in nullableStrs
+}
+
+fun test2(ns: String?, vararg nonNullableStrs: String) {
+    nonNullableStrs.contains("x")
+    nonNullableStrs.contains(ns)
+    "x" in nonNullableStrs
+    ns in nonNullableStrs
+}
+
+fun test3(ns: String?, nullableStrs: Array<out String?>, nonNullableStrs: Array<out String>) {
+    nullableStrs.contains("x")
+    nonNullableStrs.contains("x")
+
+    nullableStrs.contains(ns)
+    nonNullableStrs.contains(ns)
+
+    "x" in nullableStrs
+    "x" in nonNullableStrs
+    ns in nullableStrs
+    ns in nonNullableStrs
+}

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

@@ -0,0 +1,25 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+private object TopLevelTypeVariable {
+    @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+    fun <T> foo(): @kotlin.internal.NoInfer T = TODO()
+
+    fun <K> bar(k: K) {}
+
+    fun test() {
+        bar(foo<Int>())
+    }
+}
+
+private object NestedTypeVariable {
+    class Inv<T>
+
+    @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
+    fun <T> foo(): Inv<@kotlin.internal.NoInfer T> = TODO()
+
+    fun <K> bar(p: Inv<K>) {}
+
+    fun test() {
+        bar(foo<String>())
+    }
+}

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

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