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

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/blockBodyGetter.fir.kt

@@ -0,0 +1,3 @@
+val x get() {
+    return 1
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/cantBeInferred.fir.kt

@@ -0,0 +1,7 @@
+// !WITH_NEW_INFERENCE
+// NI_EXPECTED_FILE
+val x get() = foo()
+val y get() = bar()
+
+fun <E> foo(): E = null!!
+fun <E> bar(): List<E> = null!!

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/explicitGetterType.fir.kt

@@ -0,0 +1,18 @@
+// !CHECK_TYPE
+val x get(): String = foo()
+val y get(): List<Int> = bar()
+val z get(): List<Int> {
+    return bar()
+}
+
+val u get(): String = field
+
+fun <E> foo(): E = null!!
+fun <E> bar(): List<E> = null!!
+
+
+fun baz() {
+    x checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    y checkType { <!UNRESOLVED_REFERENCE!>_<!><List<Int>>() }
+    z checkType { <!UNRESOLVED_REFERENCE!>_<!><List<Int>>() }
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/members.fir.kt

@@ -0,0 +1,24 @@
+// !CHECK_TYPE
+class A {
+    val x get() = 1
+    val y get() = id(1)
+    val y2 get() = id(id(2))
+    val z get() = l("")
+    val z2 get() = l(id(l("")))
+
+    val <T> T.u get() = id(this)
+}
+fun <E> id(x: E) = x
+fun <E> l(x: E): List<E> = null!!
+
+fun foo(a: A) {
+    a.x checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.y checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.y2 checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    a.z checkType { <!UNRESOLVED_REFERENCE!>_<!><List<String>>() }
+    a.z2 checkType { <!UNRESOLVED_REFERENCE!>_<!><List<List<String>>>() }
+
+    with(a) {
+        1.u checkType { _<Int>() }
+    }
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/nullAsNothing.fir.kt

@@ -0,0 +1,9 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+val x get() = null
+val y get() = null!!
+
+fun foo() {
+    x checkType { <!UNRESOLVED_REFERENCE!>_<!><Nothing?>() }
+    y checkType { <!UNRESOLVED_REFERENCE!>_<!><Nothing>() }
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/objectExpression.fir.kt

@@ -0,0 +1,36 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+object Outer {
+    private var x
+        get() = object : CharSequence {
+            override val length: Int
+                get() = 0
+
+            override fun get(index: Int): Char {
+                <!UNRESOLVED_REFERENCE!>checkSubtype<!><CharSequence>(x)
+                return ' '
+            }
+
+            override fun subSequence(startIndex: Int, endIndex: Int) = ""
+
+            fun bar() {
+            }
+        }
+        set(q) {
+            <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><CharSequence>(x)
+            y = q
+            x = q
+        }
+
+    private var y = x
+
+    fun foo() {
+        x = y
+
+        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><CharSequence>(x)
+        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><CharSequence>(y)
+
+        x.<!UNRESOLVED_REFERENCE!>bar<!>()
+        y.<!UNRESOLVED_REFERENCE!>bar<!>()
+    }
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/overrides.fir.kt

@@ -0,0 +1,41 @@
+// !CHECK_TYPE
+interface A {
+    val x: Int
+
+    val z: Comparable<*>
+}
+
+open class B {
+    open var y = ""
+
+    open val z: CharSequence = ""
+}
+
+class C : B(), A {
+    override val x
+        get() = 1
+
+    override var y
+        get() = super.y
+        set(value) {
+            value checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        }
+
+    override var z
+        get() = ""
+        set(value) {
+            value checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        }
+}
+
+fun foo(c: C) {
+    c.x checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    c.y checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+    c.z checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+
+    c.y = ""
+    c.y = 1
+
+    c.z = ""
+    c.z = 1
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/primaryConstructorParameter.fir.kt

@@ -0,0 +1,23 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Delegate {
+    operator fun getValue(x: Any?, y: Any?): String = ""
+}
+
+fun <T> delegateFactory(p: Any) = Delegate
+
+class C(p: Any, val v: Any) {
+
+    val test1 get() = p
+
+    val test2 get() = v
+
+    // NB here we can use both 'T' (property type parameter) and 'p' (primary constructor parameter)
+    val <T> List<T>.test3 by delegateFactory<T>(p)
+
+    val test4 get() { return p }
+
+    var test5
+        get() { return p }
+        set(nv) { p.let {} }
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/recursiveGetter.fir.kt

@@ -0,0 +1,20 @@
+// !WITH_NEW_INFERENCE
+// !CHECK_TYPE
+// NI_EXPECTED_FILE
+
+val x get() = x
+
+class A {
+    val y get() = y
+
+    val a get() = b
+    val b get() = a
+
+    val z1 get() = <!UNRESOLVED_REFERENCE!>id<!>(z1)
+    val z2 get() = <!UNRESOLVED_REFERENCE!>l<!>(z2)
+
+    val u get() = field
+}
+
+fun <E> id(x: E) = x
+fun <E> l(x: E): List<E> = null!!

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/topLevel.fir.kt

@@ -0,0 +1,21 @@
+// !CHECK_TYPE
+val x get() = 1
+val y get() = id(1)
+val y2 get() = id(id(2))
+val z get() = l("")
+val z2 get() = l(id(l("")))
+
+val <T> T.u get() = id(this)
+
+fun <E> id(x: E) = x
+fun <E> l(x: E): List<E> = null!!
+
+fun foo() {
+    x checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    y checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    y2 checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    z checkType { <!UNRESOLVED_REFERENCE!>_<!><List<String>>() }
+    z2 checkType { <!UNRESOLVED_REFERENCE!>_<!><List<List<String>>>() }
+
+    1.u checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/unsupportedInferenceFromGetters.fir.kt

@@ -0,0 +1,71 @@
+// !WITH_NEW_INFERENCE
+// !LANGUAGE: -ShortSyntaxForPropertyGetters
+// NI_EXPECTED_FILE
+
+// blockBodyGetter.kt
+val x get() {
+    return 1
+}
+
+// cantBeInferred.kt
+val x1 get() = foo()
+val y1 get() = bar()
+
+fun <E> foo(): E = null!!
+fun <E> bar(): List<E> = null!!
+
+// explicitGetterType.kt
+val x2 get(): String = foo()
+val y2 get(): List<Int> = bar()
+val z2 get(): List<Int> {
+    return bar()
+}
+
+val u get(): String = field
+
+// members.kt
+class A {
+    val x get() = 1
+    val y get() = id(1)
+    val y2 get() = id(id(2))
+    val z get() = l("")
+    val z2 get() = l(id(l("")))
+
+    val <T> T.u get() = id(this)
+}
+fun <E> id(x: E) = x
+fun <E> l(x: E): List<E> = null!!
+
+// vars
+var x3
+    get() = 1
+    set(q) {
+    }
+
+// recursive
+val x4 get() = x4
+
+// null as nothing
+val x5 get() = null
+val y5 get() = null!!
+
+// objectExpression.kt
+object Outer {
+    private var x
+        get() = object : CharSequence {
+            override val length: Int
+                get() = 0
+
+            override fun get(index: Int): Char {
+                return ' '
+            }
+
+            override fun subSequence(startIndex: Int, endIndex: Int) = ""
+
+            fun bar() {
+            }
+        }
+        set(q) {
+            x = q
+        }
+}

compiler/testData/diagnostics/tests/properties/inferenceFromGetters/vars.fir.kt

@@ -0,0 +1,21 @@
+// !CHECK_TYPE
+var x
+    get() = 1
+    set(q) {
+        q checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    }
+
+var noSetter
+    get() = 1
+
+
+fun foo() {
+    x checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+    noSetter checkType { <!UNRESOLVED_REFERENCE!>_<!><Int>() }
+
+    x = 1
+    x = ""
+
+    noSetter = 2
+    noSetter = ""
+}