[FIR] Apply GOOD testData changes after type parameters support

compiler/testData/diagnostics/tests/ObjectWithConstructor.fir.kt

@@ -11,7 +11,7 @@ object A2 public <!CONSTRUCTOR_IN_OBJECT!>constructor(private val prop: Int)<!>
 }
 
 val x = object <!CONSTRUCTOR_IN_OBJECT!>(val prop: Int)<!> {
-    <!CONSTRUCTOR_IN_OBJECT!>constructor()<!> : <!UNRESOLVED_REFERENCE!>this<!>(1) {
+    <!CONSTRUCTOR_IN_OBJECT!>constructor()<!> : this(1) {
         val x = 1
         x * x
     }

compiler/testData/diagnostics/tests/extensions/GenericIterator2.fir.kt

@@ -1,15 +0,0 @@
-// !CHECK_TYPE
-
-import java.util.Enumeration
-
-operator fun <T> java.util.Enumeration<T>.iterator() = object : Iterator<T> {
-  public override fun hasNext(): Boolean = hasMoreElements()
-
-  public override fun next() = nextElement()
-}
-
-fun a(e : java.util.Enumeration<Int>) {
-    for (i in e) {
-        <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Int>(i)
-    }
-}

compiler/testData/diagnostics/tests/extensions/GenericIterator2.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !CHECK_TYPE
 
 import java.util.Enumeration

compiler/testData/diagnostics/tests/generics/capturedParameters/objectLiteral.fir.kt

@@ -17,7 +17,7 @@ class Q {
         x = foo<CharSequence>()
         y = foo<String>()
 
-        x.prop.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><CharSequence>() }
-        y.prop.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+        x.prop.checkType { _<CharSequence>() }
+        y.prop.checkType { _<String>() }
     }
 }

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

@@ -27,12 +27,12 @@ fun main() {
     val outer = Outer<String>()
 
     checkSubtype<Outer<String>.Inner<String>>(outer.bar())
-    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<String>.Inner<Int>>(outer.Inner<Int>())
+    checkSubtype<Outer<String>.Inner<Int>>(outer.Inner<Int>())
     checkSubtype<Outer<*>.Inner<*>>(outer.bar())
     checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
 
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.bar())
-    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(outer.Inner())
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.Inner())
 
     outer.set(outer.bar())
     outer.set(outer.Inner())

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

@@ -15,12 +15,12 @@ class Outer<E> {
         if (y is Inner) return
 
         if (z is Inner) {
-            z.prop.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+            z.prop.checkType { _<Any?>() }
             return
         }
 
         if (y is Outer<*>.Inner<*>) {
-            y.prop.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Any?>() }
+            y.prop.checkType { _<Any?>() }
         }
     }
 

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

@@ -33,5 +33,5 @@ fun foo() {
 
     val csIt: Iterator<CharSequence> = A<String>().iterator()
 
-    commonSupertype(A<String>().iterator(), A<Int>().iterator()).checkType { _<A<out Any>.MyIt>() }
+    commonSupertype(A<String>().iterator(), A<Int>().iterator()).checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<out Any>.MyIt>() }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/j+k.fir.kt

@@ -23,6 +23,6 @@ fun main() {
     val strInt: Outer<String>.Inner<Int> = outerStr.Inner()
 
     strInt.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    strInt.bar().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    strInt.bar().checkType { _<Int>() }
     strInt.outer().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<String>>() }
 }

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

@@ -1,21 +0,0 @@
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
-
-class Outer<T> {
-    inner class Inner<R> {
-        fun <S> newInner(): Inner<S> = Inner()
-        //type mismatch
-        fun <U, S> newOuterInner(): Outer<U>.Inner<S> = Outer<U>().Inner<S>()
-        //^ U here is not analyzed
-        fun foo(t: T, r: R) {}
-    }
-}
-
-fun test0() {
-    val inner: Outer<Int>.Inner<String> = Outer<Int>().Inner<String>()
-    Outer<Int>().Inner<String>().foo(1, "") // type mismatch on second argument
-}
-
-
-fun test1() {
-    Outer<Int>().Inner<String>().newOuterInner<Double, Boolean>().<!UNRESOLVED_REFERENCE!>foo<!>(1.0, true) // type mismatch on 1.0
-}

compiler/testData/diagnostics/tests/generics/innerClasses/kt6325.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
 
 class Outer<T> {

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

@@ -1,18 +0,0 @@
-// !CHECK_TYPE
-// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER
-
-class Outer<E> {
-    inner class Inner<E> {
-        fun foo(): E = null!!
-        fun outerE() = baz()
-    }
-
-    fun baz(): E = null!!
-}
-
-fun main() {
-    val inner = Outer<String>().Inner<Int>()
-
-    inner.foo().checkType { _<Int>() }
-    inner.outerE().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-}

compiler/testData/diagnostics/tests/generics/innerClasses/parameterShadowing.kt

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

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

@@ -7,7 +7,7 @@ class Outer<T> {
     fun foo(x: Outer<String>.Inner, y: Outer.Inner, z: Inner) {
         var inner = Inner()
         x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Inner>() }
-        x.checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<String>.Inner>() }
+        x.checkType { _<Outer<String>.Inner>() }
         z.checkType { _<Inner>() }
         z.checkType { _<Outer<T>.Inner>() }
 

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

@@ -25,8 +25,8 @@ fun main() {
     checkSubtype<Outer<*>.Inner>(outer.bar())
     checkSubtype<Outer<*>.Inner>(outer.Inner())
 
-    checkSubtype<Outer<CharSequence>.Inner>(outer.bar())
-    checkSubtype<Outer<CharSequence>.Inner>(outer.Inner())
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner>(outer.bar())
+    <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner>(outer.Inner())
 
     outer.set(outer.bar())
     outer.set(outer.Inner())

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.set(outer.Inner())
+    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.bar())
+    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/innerClasses/substitutedMemberScope.fir.kt

@@ -36,13 +36,13 @@ fun topLevel(): Outer<String> = null!!
 fun foo() {
     val strInt: Outer<String>.Inner<Int> = Outer<String>().Inner()
 
-    strInt.foo().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
-    strInt.baz().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Int>() }
+    strInt.foo().checkType { _<String>() }
+    strInt.baz().checkType { _<Int>() }
 
-    strInt.instance().<!INAPPLICABLE_CANDIDATE!>setE<!>("")
-    strInt.instance().outerE().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><String>() }
+    strInt.instance().setE("")
+    strInt.instance().outerE().checkType { _<String>() }
 
-    strInt.instance().Inner<Double>().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<String>.Inner<Double>>() }
+    strInt.instance().Inner<Double>().checkType { _<Outer<String>.Inner<Double>>() }
 
     Outer<String>().<!INAPPLICABLE_CANDIDATE!>setInner<!>(strInt)
     Outer<CharSequence>().<!INAPPLICABLE_CANDIDATE!>setInner<!>(strInt)

compiler/testData/diagnostics/tests/inference/substitutions/substitutionIntoAnonymousClass.fir.kt

@@ -5,7 +5,7 @@ class Test {
         }
     }
     fun test() {
-        1.self().bar() <!INAPPLICABLE_CANDIDATE!>+<!> 1
+        1.self().bar() + 1
     }
 }
 

compiler/testData/diagnostics/tests/j+k/genericConstructor/innerClass.fir.kt

@@ -10,8 +10,8 @@ public class Outer<T> {
 
 // FILE: main.kt
 fun test(x: List<Int>, y: List<String>) {
-    Outer<Int>().Inner("", y, 1) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<Int>.Inner<String>>() }
-    Outer<Int>().<!INAPPLICABLE_CANDIDATE!>Inner<!><CharSequence, String, Int>("", y, 1) <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Outer<Int>.Inner<CharSequence>>() }
+    Outer<Int>().Inner("", y, 1) checkType { _<Outer<Int>.Inner<String>>() }
+    Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }
 
     Outer<Int>().Inner("", x, 1) checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<Int>.Inner<Any>>() }
     Outer<Int>().<!INAPPLICABLE_CANDIDATE!>Inner<!><CharSequence, String, Int>("", x, 1)

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

@@ -5,7 +5,7 @@ object A {
 
 enum class B {
     X() {
-        <!CONSTRUCTOR_IN_OBJECT, UNRESOLVED_REFERENCE!>constructor()<!>
+        <!CONSTRUCTOR_IN_OBJECT, INAPPLICABLE_CANDIDATE!>constructor()<!>
     }
 }