Stop subtyping constraint search if equality constraints for...

all not fixed type vars are found
#KT-35626 fixed

compiler/fir/resolve/tests/org/jetbrains/kotlin/fir/FirOldFrontendDiagnosticsTestGenerated.java

@@ -18074,6 +18074,16 @@ public class FirOldFrontendDiagnosticsTestGenerated extends AbstractFirOldFronte
             runTest("compiler/testData/diagnostics/tests/regressions/kt3535.kt");
         }
 
+        @TestMetadata("kt35626.kt")
+        public void testKt35626() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/regressions/kt35626.kt");
+        }
+
+        @TestMetadata("kt35626small.kt")
+        public void testKt35626small() throws Exception {
+            runTest("compiler/testData/diagnostics/tests/regressions/kt35626small.kt");
+        }
+
         @TestMetadata("kt35668.kt")
         public void testKt35668() throws Exception {
             runTest("compiler/testData/diagnostics/tests/regressions/kt35668.kt");

compiler/resolution/src/org/jetbrains/kotlin/resolve/calls/inference/components/ConstraintInjector.kt

@@ -17,6 +17,7 @@
 package org.jetbrains.kotlin.resolve.calls.inference.components
 
 
+import org.jetbrains.kotlin.resolve.calls.inference.ConstraintSystemOperation
 import org.jetbrains.kotlin.resolve.calls.inference.model.*
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintKind.LOWER
 import org.jetbrains.kotlin.resolve.calls.inference.model.ConstraintKind.UPPER
@@ -26,6 +27,7 @@ import org.jetbrains.kotlin.types.checker.KotlinTypeRefiner
 import org.jetbrains.kotlin.types.model.*
 import org.jetbrains.kotlin.types.refinement.TypeRefinement
 import java.util.*
+import kotlin.collections.ArrayList
 import kotlin.math.max
 
 class ConstraintInjector(
@@ -69,23 +71,38 @@ class ConstraintInjector(
         upperType: KotlinTypeMarker,
         incorporatePosition: IncorporationConstraintPosition
     ) {
-        val possibleNewConstraints = Stack<Pair<TypeVariableMarker, Constraint>>()
+        val possibleNewConstraints = ArrayList<Pair<TypeVariableMarker, Constraint>>()
         val typeCheckerContext = TypeCheckerContext(c, incorporatePosition, lowerType, upperType, possibleNewConstraints)
         typeCheckerContext.runIsSubtypeOf(lowerType, upperType)
 
         while (possibleNewConstraints.isNotEmpty()) {
-            val (typeVariable, constraint) = possibleNewConstraints.pop()
-            if (c.shouldWeSkipConstraint(typeVariable, constraint)) continue
 
-            val constraints =
+            val constraintsToProcess = possibleNewConstraints.toTypedArray()
-                c.notFixedTypeVariables[typeVariable.freshTypeConstructor(c)] ?: typeCheckerContext.fixedTypeVariable(typeVariable)
+            possibleNewConstraints.clear()
+            for ((typeVariable, constraint) in constraintsToProcess) {
+                if (c.shouldWeSkipConstraint(typeVariable, constraint)) continue
 
-            // it is important, that we add constraint here(not inside TypeCheckerContext), because inside incorporation we read constraints
+                val constraints =
-            constraints.addConstraint(constraint)?.let {
+                    c.notFixedTypeVariables[typeVariable.freshTypeConstructor(c)] ?: typeCheckerContext.fixedTypeVariable(typeVariable)
-                if (!constraint.isNullabilityConstraint) {
+
-                    constraintIncorporator.incorporate(typeCheckerContext, typeVariable, it)
+                // it is important, that we add constraint here(not inside TypeCheckerContext), because inside incorporation we read constraints
+                constraints.addConstraint(constraint)?.let {
+                    if (!constraint.isNullabilityConstraint) {
+                        constraintIncorporator.incorporate(typeCheckerContext, typeVariable, it)
+                    }
                 }
             }
+
+            val contextOps = c as? ConstraintSystemOperation
+            if (possibleNewConstraints == null ||
+                (contextOps != null && c.notFixedTypeVariables.all { typeVariable ->
+                    typeVariable.value.constraints.any { constraint ->
+                        constraint.kind == ConstraintKind.EQUALITY && contextOps.isProperType(constraint.type)
+                    }
+                })
+            ) {
+                break
+            }
         }
     }
 
@@ -122,7 +139,7 @@ class ConstraintInjector(
         val position: IncorporationConstraintPosition,
         val baseLowerType: KotlinTypeMarker,
         val baseUpperType: KotlinTypeMarker,
-        val possibleNewConstraints: MutableList<Pair<TypeVariableMarker, Constraint>>
+        val possibleNewConstraints: MutableCollection<Pair<TypeVariableMarker, Constraint>>
     ) : AbstractTypeCheckerContextForConstraintSystem(), ConstraintIncorporator.Context, TypeSystemInferenceExtensionContext by c {
 
         val baseContext: AbstractTypeCheckerContext = newBaseTypeCheckerContext(isErrorTypeEqualsToAnything, isStubTypeEqualsToAnything)

compiler/testData/diagnostics/tests/Bounds.kt

@@ -7,12 +7,12 @@ package boundsWithSubstitutors
     class C : A<C>()
 
     val a = B<C>()
-    val a1 = B<<!NI;UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Int<!>>()
+    val a1 = B<<!UPPER_BOUND_VIOLATED!>Int<!>>()
 
     class X<A, B : A>()
 
     val b = X<Any, X<A<C>, C>>()
-    val b0 = X<Any, <!NI;UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>Any?<!>>()
+    val b0 = X<Any, <!UPPER_BOUND_VIOLATED!>Any?<!>>()
     val b1 = X<Any, X<A<C>, <!UPPER_BOUND_VIOLATED!>String<!>>>()
 
 // FILE: b.kt

compiler/testData/diagnostics/tests/annotations/annotationRenderingInTypes.kt

@@ -13,7 +13,7 @@ annotation class Ann
 fun <@Ann R : @Ann Any> f3(a: Array<@Ann R>): Array<@Ann R?> =  null!!
 
 fun test2(a: @Ann Array<in @Ann Int>) {
-    val r: Array<in Int?> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!NI;TYPE_MISMATCH("Any", "Int")!>a<!>)
+    val r: Array<in Int?> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES("'R' cannot capture 'in Int'. Type parameter has an upper bound 'Any' that cannot be satisfied capturing 'in' projection")!>f3<!>(<!NI;TYPE_MISMATCH("Any", "Int"), NI;TYPE_MISMATCH("Any", "Int")!>a<!>)
 }
 
 

compiler/testData/diagnostics/tests/callableReference/generic/genericFunctionsWithNullableTypes.kt

@@ -29,7 +29,7 @@ fun <T> test(x: T) {
     <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(1, null, ::foo)
     <!REIFIED_TYPE_FORBIDDEN_SUBSTITUTION, REIFIED_TYPE_FORBIDDEN_SUBSTITUTION!>baz<!>(null, null, ::foo)
 
-    val s3: Pair<Int, String?> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
+    val s3: Pair<Int, String?> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
     val s4: Pair<Int?, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(null, null, ::<!NI;IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION, OI;TYPE_INFERENCE_NO_INFORMATION_FOR_PARAMETER!>foo<!>)<!>
 
     val s5: Pair<Int, String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>bar(1, "", ::foo)<!>

compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotation.kt

@@ -9,7 +9,7 @@ fun test1() {}
 @Foo([], [], [])
 fun test2() {}
 
-@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
+@Foo([<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1f<!>], <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>, [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>])
 fun test3() {}
 
 @Foo(c = [1f], b = [""], a = [1])

compiler/testData/diagnostics/tests/collectionLiterals/argumentsOfAnnotationWithKClass.kt

@@ -21,10 +21,10 @@ fun test3() {}
 @Foo([<!CLASS_LITERAL_LHS_NOT_A_CLASS!>Gen<Int>::class<!>])
 fun test4() {}
 
-@Foo(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[""]<!>)
+@Foo(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[""]<!>)
 fun test5() {}
 
-@Foo(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[Int::class, 1]<!>)
+@Foo(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[Int::class, 1]<!>)
 fun test6() {}
 
 @Bar

compiler/testData/diagnostics/tests/collectionLiterals/basicCollectionLiterals.kt

@@ -7,7 +7,7 @@ fun test() {
     val b: Array<Int> = []
     val c = [1, 2]
     val d: Array<Int> = [1, 2]
-    val e: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
+    val e: Array<String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
 
     val f: IntArray = [1, 2]
     val g = [f]

compiler/testData/diagnostics/tests/collectionLiterals/defaultValuesInAnnotation.kt

@@ -8,9 +8,9 @@ annotation class Foo(
 )
 
 annotation class Bar(
-        val a: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>,
+        val a: Array<String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[' ']<!>,
         val b: Array<String> = <!ANNOTATION_PARAMETER_DEFAULT_VALUE_MUST_BE_CONSTANT, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>["", <!EMPTY_CHARACTER_LITERAL!>''<!>]<!>,
-        val c: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
+        val c: Array<String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
 )
 
 annotation class Base(
@@ -22,5 +22,5 @@ annotation class Base(
 
 annotation class Err(
         val a: IntArray = [<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1L<!>],
-        val b: Array<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
+        val b: Array<String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>[1]<!>
 )

compiler/testData/diagnostics/tests/delegation/DelegationExpectedType.kt

@@ -21,6 +21,6 @@ class D : A<Int> by baz({ it + 1 })
 
 fun <T> boo(t: T): A<T> = AImpl()
 
-class E : A<Int> by <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>boo("")<!>
+class E : A<Int> by <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>boo("")<!>
 
 class F : A<Int> by <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>AImpl<String>()<!>

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

@@ -32,7 +32,7 @@ fun main() {
     checkSubtype<Outer<*>.Inner<*>>(outer.Inner<Int>())
 
     checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!TYPE_MISMATCH!>outer.bar()<!>)
-    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>outer.<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>Inner()<!><!>)
+    checkSubtype<Outer<CharSequence>.Inner<CharSequence>>(<!NI;TYPE_MISMATCH!>outer.<!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>Inner()<!><!>)
 
     outer.set(outer.bar())
     outer.set(outer.Inner())

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

@@ -5,13 +5,13 @@
 fun <T: Any> bar(a: Array<T>): Array<T?> =  null!!
 
 fun test1(a: Array<in Int>) {
-    val r: Array<in Int?> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>bar<!>(<!NI;TYPE_MISMATCH!>a<!>)
+    val r: Array<in Int?> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>bar<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>a<!>)
-    <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>bar<!>(<!NI;TYPE_MISMATCH!>a<!>)
+    <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>bar<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>a<!>)
 }
 
 fun <T: Any> foo(l: Array<T>): Array<Array<T?>> = null!!
 
 fun test2(a: Array<in Int>) {
-    val r: Array<out Array<in Int?>> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>foo<!>(<!NI;TYPE_MISMATCH!>a<!>)
+    val r: Array<out Array<in Int?>> = <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>foo<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>a<!>)
-    <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>foo<!>(<!NI;TYPE_MISMATCH!>a<!>)
+    <!OI;TYPE_INFERENCE_CANNOT_CAPTURE_TYPES!>foo<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>a<!>)
 }

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

@@ -4,7 +4,7 @@
 fun <T> foo(array: Array<Array<T>>): Array<Array<T>> = array
 
 fun test(array: Array<Array<out Int>>) {
-    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!NI;TYPE_MISMATCH!>array<!>)
+    <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>array<!>)
 
-    val f: Array<out Array<out Int>> = <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!TYPE_MISMATCH!>array<!>)
+    val f: Array<out Array<out Int>> = <!OI;TYPE_INFERENCE_PARAMETER_CONSTRAINT_ERROR!>foo<!>(<!NI;TYPE_MISMATCH, TYPE_MISMATCH!>array<!>)
 }

compiler/testData/diagnostics/tests/inference/completion/kt33166.kt

@@ -31,7 +31,7 @@ fun f1(future: OurFuture<String>, e: Either.Left<String>) {
             true -> OurFuture.createOurFuture(e)
             else -> throw Exception()
         }
-        <!TYPE_MISMATCH, TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
+        <!TYPE_MISMATCH, TYPE_MISMATCH!>x<!>
     }
 }
 

compiler/testData/diagnostics/tests/inference/constraints/kt6320.kt

@@ -16,6 +16,6 @@ class C<X, Z, Y : X>
 
 class D<X, Z, Y : X>(<!UNUSED_PARAMETER!>foo<!>: C<X, Z, Y>) {
     fun test(a: C<Y, Y, Y>) {
-        val d: D<X, Y, Y> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>D(a)<!>
+        val d: D<X, Y, Y> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>D(a)<!>
     }
 }

compiler/testData/diagnostics/tests/inference/dependantOnVariance.kt

@@ -14,7 +14,7 @@ fun <T> readFromMyList(<!UNUSED_PARAMETER!>l<!>: MyList<out T>, <!UNUSED_PARAMET
 fun test1(int: Int, any: Any) {
     val a0 : MyList<Any> = getMyList(int)
 
-    val a1 : MyList<Int> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>getMyList(any)<!>
+    val a1 : MyList<Int> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>getMyList(any)<!>
 
     val a2 : MyList<out Any> = getMyList(int)
 

compiler/testData/diagnostics/tests/inference/typeInferenceExpectedTypeMismatch.kt

@@ -26,7 +26,7 @@ fun <T, R> foo(o: Out<T>, i: In<R>): Two<T, R> = throw Exception("$o $i")
 fun test1(outA: Out<A>, inB: In<B>) {
     foo(outA, inB)
 
-    val b: Two<A, C> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo(outA, inB)<!>
+    val b: Two<A, C> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>foo(outA, inB)<!>
     use(b)
 }
 
@@ -35,7 +35,7 @@ fun <T> bar(o: Out<T>, i: In<T>): Two<T, T> = throw Exception("$o $i")
 fun test2(outA: Out<A>, inC: In<C>) {
     <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>bar<!>(outA, <!NI;TYPE_MISMATCH!>inC<!>)
 
-    val b: Two<A, B> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>bar<!>(outA, <!NI;TYPE_MISMATCH!>inC<!>)<!>
+    val b: Two<A, B> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>bar<!>(outA, <!NI;TYPE_MISMATCH!>inC<!>)<!>
     use(b)
 }
 

compiler/testData/diagnostics/tests/inference/upperBounds/useBoundsToInferTypeParamsSimple.kt

@@ -16,7 +16,7 @@ fun <T> checkItIsExactlyAny(<!UNUSED_PARAMETER!>t<!>: T, <!UNUSED_PARAMETER!>l<!
 fun <V : U, U> baz(<!UNUSED_PARAMETER!>v<!>: V, u: MutableSet<U>) = u
 
 fun test(a: Any, s: MutableSet<String>) {
-    <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>baz<!>(a, <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>s<!>)
+    <!OI;TYPE_INFERENCE_UPPER_BOUND_VIOLATED!>baz<!>(a, <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>s<!>)
 }
 
 //from standard library

compiler/testData/diagnostics/tests/j+k/genericConstructor/classTypeParameterInferredFromArgument.kt

@@ -12,6 +12,6 @@ fun test(x: List<Int>, y: List<String>) {
     A("", x) checkType { <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><A<Any?>>() }
     A("", y) checkType { _<A<String?>>() }
 
-    A<CharSequence, String>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
+    A<CharSequence, String>("", <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
     A<CharSequence, String>("", y)
 }

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

@@ -14,5 +14,5 @@ fun test(x: List<Int>, y: List<String>) {
     Outer<Int>().Inner<CharSequence, String, Int>("", y, 1) checkType { _<Outer<Int>.Inner<CharSequence>>() }
 
     Outer<Int>().Inner("", x, 1) checkType { <!NI;UNRESOLVED_REFERENCE_WRONG_RECEIVER!>_<!><Outer<Int>.Inner<Any>>() }
-    Outer<Int>().Inner<CharSequence, String, Int>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>, 1)
+    Outer<Int>().Inner<CharSequence, String, Int>("", <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>, 1)
 }

compiler/testData/diagnostics/tests/j+k/genericConstructor/noClassTypeParametersInvParameter.kt

@@ -10,12 +10,12 @@ public class A {
 class Inv<T>
 
 fun test(x: Inv<Int>, y: Inv<String>) {
-    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>A<!>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>x<!>)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>A<!>("", <!NI;TYPE_MISMATCH!>x<!>)
     A("", y)
 
     A<String>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
 
-    A<Any>("", <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
+    A<Any>("", <!NI;TYPE_MISMATCH, TYPE_MISMATCH!>x<!>)
     A<String>("", y)
     A<CharSequence>("", <!TYPE_MISMATCH!>y<!>)
 }

compiler/testData/diagnostics/tests/numbers/numbersInSimpleConstraints.kt

@@ -44,7 +44,7 @@ interface Inv<T>
 fun <T> exactBound(t: T, l: Inv<T>): T = throw Exception("$t $l")
 
 fun testExactBound(invS: Inv<String>, invI: Inv<Int>, invB: Inv<Byte>) {
-    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>exactBound<!>(1, <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>invS<!>)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>exactBound<!>(1, <!NI;TYPE_MISMATCH!>invS<!>)
     exactBound(1, invI)
 
     val b = exactBound(1, invB)

compiler/testData/diagnostics/tests/regressions/kt35626.kt

@@ -0,0 +1,24 @@
+// FIR_IDENTICAL
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Result<T> {
+    fun <R> map(transform: (T) -> R): Result<R> = TODO()
+}
+
+class Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(
+    val _1: T1, val _2: T2, val _3: T3, val _4: T4, val _5: T5, val _6: T6,
+    val _7: T7, val _8: T8, val _9: T9, val _10: T10, val _11: T11, val _12: T12, val _13: T13
+)
+
+fun <T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> rules12(res: Result<Any>):
+        Result<Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>> {
+    return res.map {
+        @Suppress("UNCHECKED_CAST")
+        Tuple12(
+            it as T1, it as T2, it as T3, it as T4, it as T5, it as T6,
+            it as T7, it as T8, it as T9, it as T10, it as T11, it as T12, it as T13
+        )
+    }
+}
+

compiler/testData/diagnostics/tests/regressions/kt35626.txt

@@ -0,0 +1,31 @@
+package
+
+public fun </*0*/ T1, /*1*/ T2, /*2*/ T3, /*3*/ T4, /*4*/ T5, /*5*/ T6, /*6*/ T7, /*7*/ T8, /*8*/ T9, /*9*/ T10, /*10*/ T11, /*11*/ T12, /*12*/ T13> rules12(/*0*/ res: Result<kotlin.Any>): Result<Tuple12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>>
+
+public final class Result</*0*/ T> {
+    public constructor Result</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun </*0*/ R> map(/*0*/ transform: (T) -> R): Result<R>
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class Tuple12</*0*/ T1, /*1*/ T2, /*2*/ T3, /*3*/ T4, /*4*/ T5, /*5*/ T6, /*6*/ T7, /*7*/ T8, /*8*/ T9, /*9*/ T10, /*10*/ T11, /*11*/ T12, /*12*/ T13> {
+    public constructor Tuple12</*0*/ T1, /*1*/ T2, /*2*/ T3, /*3*/ T4, /*4*/ T5, /*5*/ T6, /*6*/ T7, /*7*/ T8, /*8*/ T9, /*9*/ T10, /*10*/ T11, /*11*/ T12, /*12*/ T13>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4, /*4*/ _5: T5, /*5*/ _6: T6, /*6*/ _7: T7, /*7*/ _8: T8, /*8*/ _9: T9, /*9*/ _10: T10, /*10*/ _11: T11, /*11*/ _12: T12, /*12*/ _13: T13)
+    public final val _1: T1
+    public final val _10: T10
+    public final val _11: T11
+    public final val _12: T12
+    public final val _13: T13
+    public final val _2: T2
+    public final val _3: T3
+    public final val _4: T4
+    public final val _5: T5
+    public final val _6: T6
+    public final val _7: T7
+    public final val _8: T8
+    public final val _9: T9
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/regressions/kt35626small.kt

@@ -0,0 +1,22 @@
+// FIR_IDENTICAL
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class Result<T> {
+    fun <R> map(transform: (T) -> R): Result<R> = TODO()
+}
+
+class TupleX<T1, T2, T3, T4>(
+    val _1: T1, val _2: T2, val _3: T3, val _4: T4
+)
+
+fun <K1, K2, K3, K4> rules(res: Result<Any>):
+        Result<TupleX<K1, K2, K3, K4>> {
+    return res.map {
+        @Suppress("UNCHECKED_CAST")
+        TupleX(
+            it as K1, it as K2, it as K3, it as K4
+        )
+    }
+}
+

compiler/testData/diagnostics/tests/regressions/kt35626small.txt

@@ -0,0 +1,22 @@
+package
+
+public fun </*0*/ K1, /*1*/ K2, /*2*/ K3, /*3*/ K4> rules(/*0*/ res: Result<kotlin.Any>): Result<TupleX<K1, K2, K3, K4>>
+
+public final class Result</*0*/ T> {
+    public constructor Result</*0*/ T>()
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public final fun </*0*/ R> map(/*0*/ transform: (T) -> R): Result<R>
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
+
+public final class TupleX</*0*/ T1, /*1*/ T2, /*2*/ T3, /*3*/ T4> {
+    public constructor TupleX</*0*/ T1, /*1*/ T2, /*2*/ T3, /*3*/ T4>(/*0*/ _1: T1, /*1*/ _2: T2, /*2*/ _3: T3, /*3*/ _4: T4)
+    public final val _1: T1
+    public final val _2: T2
+    public final val _3: T3
+    public final val _4: T4
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

compiler/testData/diagnostics/tests/resolve/invoke/errors/typeInferenceErrorForInvoke.kt

@@ -8,7 +8,7 @@ operator fun <T> T.invoke(a: A<T>) {}
 fun foo(s: String, ai: A<Int>) {
     1(ai)
 
-    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>s<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>ai<!>)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>s<!>(<!NI;TYPE_MISMATCH!>ai<!>)
 
-    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>""<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>ai<!>)
+    <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>""<!>(<!NI;TYPE_MISMATCH!>ai<!>)
 }

compiler/testData/diagnostics/tests/resolve/specialConstructions/constantsInIf.kt

@@ -8,7 +8,7 @@ fun test() {
         <!OI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!>
     }<!>)
 
-    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
+    bar(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!> ?: <!CONSTANT_EXPECTED_TYPE_MISMATCH, NI;CONSTANT_EXPECTED_TYPE_MISMATCH!>2<!><!>)
 }
 
 fun bar(s: String) = s

compiler/testData/diagnostics/tests/secondaryConstructors/constructorCallType.kt

@@ -21,7 +21,7 @@ val y4: B<Int> = B<Int>("")
 
 val y5: B<String> = B<String>(<!CONSTANT_EXPECTED_TYPE_MISMATCH!>1<!>)
 val y6: B<String> = B<String>("")
-val y7: B<String> = <!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>B(1)<!>
+val y7: B<String> = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>B(1)<!>
 val y8: B<String> = B("")
 
 val y9 = B(1)

compiler/testData/diagnostics/tests/smartCasts/inference/intersectionTypes.kt

@@ -39,11 +39,11 @@ fun <T> foo(t: T, <!UNUSED_PARAMETER!>l<!>: MutableList<T>): T = t
 
 fun testErrorMessages(a: A, ml: MutableList<String>) {
     if (a is B && a is C) {
-        <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo<!>(a, <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>ml<!>)
+        <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo<!>(a, <!NI;TYPE_MISMATCH!>ml<!>)
     }
 
     if(a is C) {
-        <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo<!>(a, <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>ml<!>)
+        <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo<!>(a, <!NI;TYPE_MISMATCH!>ml<!>)
     }
 }
 

compiler/testData/diagnostics/tests/typeParameters/implicitNothingInReturnPosition.kt

@@ -40,7 +40,7 @@ class Context<T>
 fun <T> Any.decodeIn(typeFrom: Context<in T>): T = something()
 
 fun <T> Any?.decodeOut1(typeFrom: Context<out T>): T {
-    return <!NI;TYPE_MISMATCH!>this?.<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>decodeIn<!>(typeFrom) ?: <!OI;TYPE_MISMATCH!>kotlin.Unit<!><!>
+    return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>this?.<!IMPLICIT_NOTHING_TYPE_ARGUMENT_IN_RETURN_POSITION!>decodeIn<!>(typeFrom) ?: <!OI;TYPE_MISMATCH!>kotlin.Unit<!><!>
 }
 
 fun <T> Any.decodeOut2(typeFrom: Context<out T>): T {

compiler/testData/diagnostics/tests/typealias/boundsViolationInDeepTypeAliasExpansion.kt

@@ -14,4 +14,4 @@ fun test4(x: <!UPPER_BOUND_VIOLATED_IN_TYPEALIAS_EXPANSION!>TC2<Number, List<Any
 val test5 = TC2<Number, Collection<Number>>()
 val test6 = TC2<Number, Collection<Int>>()
 val test7 = TC2<Number, List<Int>>()
-val test8 = TC2<Number, <!NI;UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>List<Any><!>>()
+val test8 = TC2<Number, <!UPPER_BOUND_VIOLATED!>List<Any><!>>()

compiler/testData/diagnostics/tests/typealias/boundsViolationInTypeAliasExpansion.kt

@@ -27,4 +27,4 @@ fun test12(x: TC<Number, <!UPPER_BOUND_VIOLATED!>List<Any><!>>) {}
 val test13 = TC<Number, Collection<Number>>()
 val test14 = TC<Number, Collection<Int>>()
 val test15 = TC<Number, List<Int>>()
-val test16 = TC<Number, <!NI;UPPER_BOUND_VIOLATED, UPPER_BOUND_VIOLATED!>List<Any><!>>()
+val test16 = TC<Number, <!UPPER_BOUND_VIOLATED!>List<Any><!>>()

compiler/testData/diagnostics/tests/typealias/noApproximationInTypeAliasArgumentSubstitution.kt

@@ -14,4 +14,4 @@ typealias TMap<T> = Map<T, T>
 fun <T> foo2(m: TMap<T>) = m
 
 fun bar2(m: TMap<*>) =
-        <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo2<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>m<!>)
+        <!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>foo2<!>(<!NI;TYPE_MISMATCH!>m<!>)

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInference.ni.txt

@@ -6,9 +6,9 @@ public val test2: C<kotlin.Int> /* = Cons<kotlin.Int> */
 public val test3: [ERROR : Type for CC(1, 2)]
 public val test4: CC<kotlin.Int> /* = Cons<Cons<kotlin.Int>> */
 public val test5: PL<kotlin.Int> /* = Pair<kotlin.Int, kotlin.collections.List<kotlin.Int>> */
-public fun testProjections1(/*0*/ x: Pair<in kotlin.Int, out kotlin.String>): Foo<out kotlin.String>
+public fun testProjections1(/*0*/ x: Pair<in kotlin.Int, out kotlin.String>): Foo<in kotlin.Int>
-public fun testProjections2(/*0*/ x: Pair<in kotlin.Int, out kotlin.Number>): Foo<out kotlin.Number>
+public fun testProjections2(/*0*/ x: Pair<in kotlin.Int, out kotlin.Number>): Foo<in kotlin.Int>
-public fun testProjections3(/*0*/ x: Pair<in kotlin.Number, out kotlin.Int>): Foo<out kotlin.Int>
+public fun testProjections3(/*0*/ x: Pair<in kotlin.Number, out kotlin.Int>): Foo<in kotlin.Number>
 public fun testProjections4(/*0*/ x: Pair<in kotlin.Int, in kotlin.Int>): Foo<in kotlin.Int>
 
 public final class Cons</*0*/ T> {

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorTypeArgumentsInferenceWithNestedCalls.kt

@@ -5,4 +5,4 @@ class Cons<T : Number>(val head: T, val tail: Cons<T>?)
 typealias C<T> = Cons<T>
 
 val test1 = C(1, C(2, null))
-val test2 = C(1, <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>C<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>""<!>, null)<!>)
+val test2 = C(1, <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!><!OI;TYPE_INFERENCE_CONFLICTING_SUBSTITUTIONS!>C<!>(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>""<!>, null)<!>)

compiler/testData/diagnostics/tests/when/kt9972.kt

@@ -10,7 +10,7 @@ fun test1(): Int {
 }
 
 fun test2(): Int {
-    val x: String = <!NI;TYPE_MISMATCH!>when {
+    val x: String = <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>when {
                         true -> <!OI;TYPE_MISMATCH!>Any()<!>
                         else -> null
                     } ?: return 0<!>

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsInVariance.kt

@@ -14,7 +14,7 @@ class MyClass1
 @Ann1(arrayOf(Any::class))
 class MyClass1a
 
-@Ann1(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B1::class<!>)<!>)
+@Ann1(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B1::class<!>)<!>)
 class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<in B1>>)
@@ -25,5 +25,5 @@ class MyClass3
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B2::class<!>)<!>)
+@Ann2(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B2::class<!>)<!>)
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/annotations/kClass/kClassArrayInAnnotationsOutVariance.kt

@@ -11,7 +11,7 @@ annotation class Ann1(val arg: Array<KClass<out A>>)
 @Ann1(arrayOf(A::class))
 class MyClass1
 
-@Ann1(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Any::class<!>)<!>)
+@Ann1(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>Any::class<!>)<!>)
 class MyClass1a
 
 @Ann1(arrayOf(B1::class))
@@ -19,11 +19,11 @@ class MyClass2
 
 annotation class Ann2(val arg: Array<KClass<out B1>>)
 
-@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>A::class<!>)<!>)
+@Ann2(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>A::class<!>)<!>)
 class MyClass3
 
 @Ann2(arrayOf(B1::class))
 class MyClass4
 
-@Ann2(<!NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B2::class<!>)<!>)
+@Ann2(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>arrayOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>B2::class<!>)<!>)
 class MyClass5

compiler/testData/diagnostics/testsWithStdLib/elvisOnJavaList.kt

@@ -15,5 +15,5 @@ public class P {
 
 fun foo(c: P): MutableList<Int> {
     // Error should be here: see KT-8168 Typechecker fails for platform collection type
-    return <!NI;TYPE_MISMATCH!>c.getList() ?: <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, OI;TYPE_MISMATCH!>listOf()<!><!>
+    return <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>c.getList() ?: <!OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH, OI;TYPE_MISMATCH!>listOf()<!><!>
 }

compiler/testData/diagnostics/testsWithStdLib/tryCatch/tryExpression.kt

@@ -27,7 +27,7 @@ fun test1(): Map<Int, Int> = run {
 }
 
 fun test2(): Map<Int, Int> = run {
-    <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>try {
+    <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>try {
         emptyMap()
     } catch (e: ExcA) {
         <!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH, OI;TYPE_INFERENCE_EXPECTED_TYPE_MISMATCH!>mapOf(<!NI;TYPE_MISMATCH, NI;TYPE_MISMATCH!>"" to ""<!>)<!>

compiler/tests/org/jetbrains/kotlin/checkers/DiagnosticsTestGenerated.java

@@ -18086,6 +18086,16 @@ public class DiagnosticsTestGenerated extends AbstractDiagnosticsTestWithFirVali
                 runTest("compiler/testData/diagnostics/tests/regressions/kt3535.kt");
             }
 
+            @TestMetadata("kt35626.kt")
+            public void testKt35626() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/regressions/kt35626.kt");
+            }
+
+            @TestMetadata("kt35626small.kt")
+            public void testKt35626small() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/regressions/kt35626small.kt");
+            }
+
             @TestMetadata("kt35668.kt")
             public void testKt35668() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/regressions/kt35668.kt");

compiler/tests/org/jetbrains/kotlin/checkers/javac/DiagnosticsUsingJavacTestGenerated.java

@@ -18076,6 +18076,16 @@ public class DiagnosticsUsingJavacTestGenerated extends AbstractDiagnosticsUsing
                 runTest("compiler/testData/diagnostics/tests/regressions/kt3535.kt");
             }
 
+            @TestMetadata("kt35626.kt")
+            public void testKt35626() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/regressions/kt35626.kt");
+            }
+
+            @TestMetadata("kt35626small.kt")
+            public void testKt35626small() throws Exception {
+                runTest("compiler/testData/diagnostics/tests/regressions/kt35626small.kt");
+            }
+
             @TestMetadata("kt35668.kt")
             public void testKt35668() throws Exception {
                 runTest("compiler/testData/diagnostics/tests/regressions/kt35668.kt");

j2k/testData/fileOrElement/typeParameters/rawTypeCast.kt

@@ -1,5 +1,6 @@
 // ERROR: Type mismatch: inferred type is (Any?..Any?) but String! was expected
 // ERROR: Type mismatch: inferred type is (Any?..Any?) but String! was expected
+// ERROR: Type mismatch: inferred type is (Any?..Any?) but String! was expected
 // ERROR: Type mismatch: inferred type is HashMap<String, Any?> but Map<String, String> was expected
 import java.util.*
 

nj2k/testData/newJ2k/toArray/toArray.kt

@@ -1,5 +1,4 @@
 // ERROR: Type mismatch: inferred type is Any but String was expected
-// ERROR: Type mismatch: inferred type is Any but String was expected
 // ERROR: Type mismatch: inferred type is Array<String> but Array<Any> was expected
 import java.util.Arrays
 

nj2k/testData/newJ2k/typeParameters/rawTypeCast.kt

@@ -2,6 +2,8 @@
 // ERROR: Type mismatch: inferred type is (Any?..Any?) but String? was expected
 // ERROR: Type mismatch: inferred type is Any! but String? was expected
 // ERROR: Type mismatch: inferred type is (Any?..Any?) but String? was expected
+// ERROR: Type mismatch: inferred type is Any! but String? was expected
+// ERROR: Type mismatch: inferred type is (Any?..Any?) but String? was expected
 // ERROR: Type mismatch: inferred type is HashMap<Any?, Any?> but Map<String?, String?> was expected
 import java.util.HashMap
 import java.util.Properties