[FIR] Infer type arguments for captured parameters of inner classes

KT-38992

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClasses.fir.kt

@@ -19,8 +19,8 @@ class A : Outer<Double, Short>() {
 }
 
 fun foo() {
-    Derived().foo() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<String, Int>.Inner<Char>>() }
+    Derived().foo() checkType { _<Outer<String, Int>.Inner<Char>>() }
     Derived().baz() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Map<Char, String>>() }
-    A.B().bar() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Outer<Float, Long>.Inner<String>>() }
+    A.B().bar() checkType { _<Outer<Float, Long>.Inner<String>>() }
     A.B().x() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><Map<String, Float>>() }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocal.fir.kt

@@ -50,6 +50,6 @@ fun test() {
     var y = noParameters()
     y = noParameters()
 
-    y().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<Any, Double, Short, Long>>() }
+    y().foo().a() checkType { _<A<Any, Double, Short, Long>>() }
     y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!UNRESOLVED_REFERENCE!>_<!><A<Any, Double, Short, Char>>() }
 }

compiler/testData/diagnostics/tests/generics/innerClasses/implicitArguments/fromSuperClassesLocalInsideInner.fir.kt

@@ -52,7 +52,7 @@ class Outer<T> {
             var y = noParameters()
             y = noParameters()
 
-            y().foo().a() checkType { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Long>>() }
+            y().foo().a() checkType { _<A<T, F, Any, Double, Short, Long>>() }
             y().bar() <!INAPPLICABLE_CANDIDATE!>checkType<!> { <!INAPPLICABLE_CANDIDATE!>_<!><A<T, F, Any, Double, Short, Char>>() }
         }
     }

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

@@ -14,7 +14,7 @@ class Outer<E> {
     fun set(inner: Inner<out E>) {}
 
     fun inside() {
-        innerFactory().checkType { <!INAPPLICABLE_CANDIDATE!>_<!><Inner<String>>() }
+        innerFactory().checkType { _<Inner<String>>() }
     }
 }
 
@@ -34,9 +34,9 @@ fun main() {
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.bar())
     <!INAPPLICABLE_CANDIDATE!>checkSubtype<!><Outer<CharSequence>.Inner<CharSequence>>(outer.Inner())
 
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.bar())
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.Inner())
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
 
     val x: Outer<String>.Inner<String> = factoryString()
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(x)
+    outer.set(x)
 }

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

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

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

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

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

@@ -28,13 +28,13 @@ fun main() {
     checkSubtype<Outer<String>.Inner>(outer.bar())
     checkSubtype<Outer<String>.Inner>(outer.Inner())
 
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.bar())
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(outer.Inner())
+    outer.set(outer.bar())
+    outer.set(outer.Inner())
 
     val x: Outer<String>.Inner = factoryString()
     outer.<!INAPPLICABLE_CANDIDATE!>set<!>(x)
     val y: Outer<CharSequence>.Inner = infer<CharSequence>("")
-    outer.<!INAPPLICABLE_CANDIDATE!>set<!>(y)
+    outer.set(y)
 
     outer.set(infer<Any>(""))
 }

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

@@ -44,6 +44,6 @@ fun foo() {
 
     strInt.instance().Inner<Double>().checkType { _<Outer<String>.Inner<Double>>() }
 
-    Outer<String>().<!INAPPLICABLE_CANDIDATE!>setInner<!>(strInt)
+    Outer<String>().setInner(strInt)
     Outer<CharSequence>().<!INAPPLICABLE_CANDIDATE!>setInner<!>(strInt)
 }