[FIR-TEST] Add tests with problems of fir resolve

compiler/fir/resolve/testData/resolve/problems/ambiguityOnExtensionFunctions.kt

@@ -0,0 +1,13 @@
+interface A
+
+interface B : A
+
+val A.name: String?
+    get() = ""
+
+val B?.name: String?
+    get() = ""
+
+fun test(b: B) {
+    val id = b.<!AMBIGUITY!>name<!>
+}

compiler/fir/resolve/testData/resolve/problems/ambiguityOnExtensionFunctions.txt

@@ -0,0 +1,16 @@
+FILE: ambiguityOnExtensionFunctions.kt
+    public abstract interface A : R|kotlin/Any| {
+    }
+    public abstract interface B : R|A| {
+    }
+    public final val R|A|.name: R|kotlin/String?|
+        public get(): R|kotlin/String?| {
+            ^ String()
+        }
+    public final val R|B?|.name: R|kotlin/String?|
+        public get(): R|kotlin/String?| {
+            ^ String()
+        }
+    public final fun test(b: R|B|): R|kotlin/Unit| {
+        lval id: <ERROR TYPE REF: Ambiguity: name, [/name, /name]> = R|<local>/b|.<Ambiguity: name, [/name, /name]>#
+    }

compiler/fir/resolve/testData/resolve/problems/bareTypes.kt

@@ -0,0 +1,9 @@
+interface A<out T>
+
+interface MutableA<T> : A<T> {
+    fun add(x: T)
+}
+
+fun test(a: A<String>) {
+    (a as MutableA).<!INAPPLICABLE_CANDIDATE!>add<!>("")
+}

compiler/fir/resolve/testData/resolve/problems/bareTypes.txt

@@ -0,0 +1,10 @@
+FILE: bareTypes.kt
+    public abstract interface A<out T> : R|kotlin/Any| {
+    }
+    public abstract interface MutableA<T> : R|A<T>| {
+        public abstract fun add(x: R|T|): R|kotlin/Unit|
+
+    }
+    public final fun test(a: R|A<kotlin/String>|): R|kotlin/Unit| {
+        (R|<local>/a| as R|MutableA|).<Inapplicable(INAPPLICABLE): [/MutableA.add]>#(String())
+    }

compiler/fir/resolve/testData/resolve/problems/callableReferenceOnInstance.kt

@@ -0,0 +1,13 @@
+interface KaptLogger {
+    val isVerbose: Boolean
+
+    fun warn(message: String)
+    fun error(message: String)
+}
+
+fun test(logger: KaptLogger) {
+    val func = if (logger.isVerbose)
+        <!UNRESOLVED_REFERENCE!>logger::warn<!>
+    else
+        <!UNRESOLVED_REFERENCE!>logger::error<!>
+}

compiler/fir/resolve/testData/resolve/problems/callableReferenceOnInstance.txt

@@ -0,0 +1,21 @@
+FILE: callableReferenceOnInstance.kt
+    public abstract interface KaptLogger : R|kotlin/Any| {
+        public abstract val isVerbose: R|kotlin/Boolean|
+            public get(): R|kotlin/Boolean|
+
+        public abstract fun warn(message: R|kotlin/String|): R|kotlin/Unit|
+
+        public abstract fun error(message: R|kotlin/String|): R|kotlin/Unit|
+
+    }
+    public final fun test(logger: R|KaptLogger|): R|kotlin/Unit| {
+        lval func: R|kotlin/Nothing| = when () {
+            R|<local>/logger|.R|/KaptLogger.isVerbose| ->  {
+                R|<local>/logger|::<Unresolved reference: warn>#
+            }
+            else ->  {
+                R|<local>/logger|::<Unresolved reference: error>#
+            }
+        }
+
+    }

compiler/fir/resolve/testData/resolve/problems/exhaustiveWhenAndFlexibleType.kt

@@ -0,0 +1,23 @@
+// FILE: Utils.java
+
+public class Utils {
+    public static E getEnum() {
+        return null;
+    }
+}
+
+// FILE: main.kt
+
+enum class E {
+    A, B, C
+}
+
+fun test() {
+    val e = Utils.getEnum()
+    val s = when (e) {
+        E.A, null -> return
+        E.B -> ""
+        E.C -> ""
+    }
+    s.<!UNRESOLVED_REFERENCE!>length<!>
+}

compiler/fir/resolve/testData/resolve/problems/exhaustiveWhenAndFlexibleType.txt

@@ -0,0 +1,50 @@
+FILE: main.kt
+    public final enum class E : R|kotlin/Enum<E>| {
+        private constructor(): R|E| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final static enum entry A: R|E| = object : R|E| {
+            private constructor(): R|anonymous| {
+                super<R|E|>()
+            }
+
+        }
+
+        public final static enum entry B: R|E| = object : R|E| {
+            private constructor(): R|anonymous| {
+                super<R|E|>()
+            }
+
+        }
+
+        public final static enum entry C: R|E| = object : R|E| {
+            private constructor(): R|anonymous| {
+                super<R|E|>()
+            }
+
+        }
+
+        public final static fun values(): R|kotlin/Array<E>| {
+        }
+
+        public final static fun valueOf(value: R|kotlin/String|): R|E| {
+        }
+
+    }
+    public final fun test(): R|kotlin/Unit| {
+        lval e: R|ft<E, E?>!| = Q|Utils|.R|/Utils.getEnum|()
+        lval s: R|kotlin/Unit| = when (R|<local>/e|) {
+            ==($subj$, Q|E|.R|/E.A|) || ==($subj$, Null(null)) ->  {
+                ^test Unit
+            }
+            ==($subj$, Q|E|.R|/E.B|) ->  {
+                String()
+            }
+            ==($subj$, Q|E|.R|/E.C|) ->  {
+                String()
+            }
+        }
+
+        R|<local>/s|.<Unresolved name: length>#
+    }

compiler/fir/resolve/testData/resolve/problems/incorrectSuperCall.kt

@@ -0,0 +1,16 @@
+interface A {
+    fun bar() {}
+}
+open class B {
+    open fun foo() {}
+
+    open fun bar() {}
+}
+
+class C : A, B() {
+    override fun foo() {
+        super.<!UNRESOLVED_REFERENCE!>foo<!>()
+
+        super.bar() // should be ambiguity
+    }
+}

compiler/fir/resolve/testData/resolve/problems/incorrectSuperCall.txt

@@ -0,0 +1,29 @@
+FILE: incorrectSuperCall.kt
+    public abstract interface A : R|kotlin/Any| {
+        public open fun bar(): R|kotlin/Unit| {
+        }
+
+    }
+    public open class B : R|kotlin/Any| {
+        public constructor(): R|B| {
+            super<R|kotlin/Any|>()
+        }
+
+        public open fun foo(): R|kotlin/Unit| {
+        }
+
+        public open fun bar(): R|kotlin/Unit| {
+        }
+
+    }
+    public final class C : R|A|, R|B| {
+        public constructor(): R|C| {
+            super<R|B|>()
+        }
+
+        public final override fun foo(): R|kotlin/Unit| {
+            super<R|A|>.<Unresolved name: foo>#()
+            super<R|A|>.R|/A.bar|()
+        }
+
+    }

compiler/fir/resolve/testData/resolve/problems/iteratorOfVararg.kt

@@ -0,0 +1,13 @@
+class Foo(vararg val strings: String)
+
+fun test_1(foo: Foo) {
+    <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>for (s in foo.strings) {
+        s.<!UNRESOLVED_REFERENCE!>length<!>
+    }<!>
+}
+
+fun test_2(vararg strings: String) {
+    for (s in strings) {
+        s.length
+    }
+}

compiler/fir/resolve/testData/resolve/problems/iteratorOfVararg.txt

@@ -0,0 +1,28 @@
+FILE: iteratorOfVararg.kt
+    public final class Foo : R|kotlin/Any| {
+        public constructor(vararg strings: R|kotlin/Array<kotlin/String>|): R|Foo| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final val strings: R|kotlin/String| = R|<local>/strings|
+            public get(): R|kotlin/String|
+
+    }
+    public final fun test_1(foo: R|Foo|): R|kotlin/Unit| {
+        lval <range>: R|kotlin/String| = R|<local>/foo|.R|/Foo.strings|
+        lval <iterator>: <ERROR TYPE REF: Unresolved name: iterator> = R|<local>/<range>|.<Unresolved name: iterator>#()
+        while(R|<local>/<iterator>|.<Unresolved name: hasNext>#()) {
+            lval s: <ERROR TYPE REF: Unresolved name: next> = R|<local>/<iterator>|.<Unresolved name: next>#()
+            R|<local>/s|.<Unresolved name: length>#
+        }
+
+    }
+    public final fun test_2(vararg strings: R|kotlin/Array<kotlin/String>|): R|kotlin/Unit| {
+        lval <range>: R|kotlin/Array<kotlin/String>| = R|<local>/strings|
+        lval <iterator>: R|kotlin/collections/Iterator<kotlin/String>| = R|<local>/<range>|.R|FakeOverride<kotlin/Array.iterator: R|kotlin/collections/Iterator<kotlin/String>|>|()
+        while(R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()) {
+            lval s: R|kotlin/String| = R|<local>/<iterator>|.R|FakeOverride<kotlin/collections/Iterator.next: R|kotlin/String|>|()
+            R|<local>/s|.R|kotlin/String.length|
+        }
+
+    }

compiler/fir/resolve/testData/resolve/problems/noBoundSmartcastAfterContinue.kt

@@ -0,0 +1,14 @@
+interface A {
+    val s: String
+}
+
+fun test(list: List<A>) {
+    var goodA: A? = null
+    for (a in list) {
+        if (goodA == null) {
+            goodA = a
+            continue
+        }
+        goodA.<!INAPPLICABLE_CANDIDATE!>s<!>
+    }
+}

compiler/fir/resolve/testData/resolve/problems/noBoundSmartcastAfterContinue.txt

@@ -0,0 +1,23 @@
+FILE: noBoundSmartcastAfterContinue.kt
+    public abstract interface A : R|kotlin/Any| {
+        public abstract val s: R|kotlin/String|
+            public get(): R|kotlin/String|
+
+    }
+    public final fun test(list: R|kotlin/collections/List<A>|): R|kotlin/Unit| {
+        lvar goodA: R|A?| = Null(null)
+        lval <range>: R|kotlin/collections/List<A>| = R|<local>/list|
+        lval <iterator>: R|kotlin/collections/Iterator<A>| = R|<local>/<range>|.R|FakeOverride<kotlin/collections/List.iterator: R|kotlin/collections/Iterator<A>|>|()
+        while(R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()) {
+            lval a: R|A| = R|<local>/<iterator>|.R|FakeOverride<kotlin/collections/Iterator.next: R|A|>|()
+            when () {
+                ==(R|<local>/goodA|, Null(null)) ->  {
+                    R|<local>/goodA| = R|<local>/a|
+                    continue@@@[R|<local>/<iterator>|.R|kotlin/collections/Iterator.hasNext|()]
+                }
+            }
+
+            R|<local>/goodA|.<Inapplicable(WRONG_RECEIVER): [/A.s]>#
+        }
+
+    }

compiler/fir/resolve/testData/resolve/stdlib/problems/arrayFilterCapturedType.kt

@@ -0,0 +1,3 @@
+fun test(elements: Array<out String?>) {
+    val filtered = elements.<!INAPPLICABLE_CANDIDATE("[kotlin/collections/filterNotNull]")!>filterNotNull<!>()
+}

compiler/fir/resolve/testData/resolve/stdlib/problems/arrayFilterCapturedType.txt

@@ -0,0 +1,4 @@
+FILE: arrayFilterCapturedType.kt
+    public final fun test(elements: R|kotlin/Array<out kotlin/String?>|): R|kotlin/Unit| {
+        lval filtered: <ERROR TYPE REF: Inapplicable(WRONG_RECEIVER): [kotlin/collections/filterNotNull]> = R|<local>/elements|.<Inapplicable(WRONG_RECEIVER): [kotlin/collections/filterNotNull]>#()
+    }

compiler/fir/resolve/testData/resolve/stdlib/problems/delegateTypeMismatch.kt

@@ -0,0 +1,26 @@
+import kotlin.properties.Delegates
+import kotlin.properties.ReadWriteProperty
+
+interface ClassifierNamePolicy {
+    object SOURCE_CODE_QUALIFIED : ClassifierNamePolicy
+}
+
+interface KotlinType
+
+class A(val isLocked: Boolean) {
+    private fun <T> property(initialValue: T): ReadWriteProperty<A, T> {
+        return Delegates.vetoable(initialValue) { _, _, _ ->
+            if (isLocked) {
+                throw IllegalStateException("Cannot modify readonly DescriptorRendererOptions")
+            }
+            else {
+                true
+            }
+        }
+    }
+
+    var classifierNamePolicy: ClassifierNamePolicy by property(ClassifierNamePolicy.SOURCE_CODE_QUALIFIED)
+    // getter has INAPPLICABLE diagnostic, see dump
+
+    var typeNormalizer by <!INAPPLICABLE_CANDIDATE!>property<!><(KotlinType) -> KotlinType>({ <!UNRESOLVED_REFERENCE!>it<!> })
+}

compiler/fir/resolve/testData/resolve/stdlib/problems/delegateTypeMismatch.txt

@@ -0,0 +1,55 @@
+FILE: delegateTypeMismatch.kt
+    public abstract interface ClassifierNamePolicy : R|kotlin/Any| {
+        public final object SOURCE_CODE_QUALIFIED : R|ClassifierNamePolicy| {
+            private constructor(): R|ClassifierNamePolicy.SOURCE_CODE_QUALIFIED| {
+                super<R|kotlin/Any|>()
+            }
+
+        }
+
+    }
+    public abstract interface KotlinType : R|kotlin/Any| {
+    }
+    public final class A : R|kotlin/Any| {
+        public constructor(isLocked: R|kotlin/Boolean|): R|A| {
+            super<R|kotlin/Any|>()
+        }
+
+        public final val isLocked: R|kotlin/Boolean| = R|<local>/isLocked|
+            public get(): R|kotlin/Boolean|
+
+        private final fun <T> property(initialValue: R|T|): R|kotlin/properties/ReadWriteProperty<A, T>| {
+            ^property Q|kotlin/properties/Delegates|.R|kotlin/properties/Delegates.vetoable|<R|T|>(R|<local>/initialValue|, <L> = vetoable@fun <anonymous>(_: R|kotlin/reflect/KProperty<*>|, _: R|T|, _: R|T|): R|kotlin/Boolean| <kind=UNKNOWN>  {
+                when () {
+                    this@R|/A|.R|/A.isLocked| ->  {
+                        throw R|java/lang/IllegalStateException.IllegalStateException|(String(Cannot modify readonly DescriptorRendererOptions))
+                    }
+                    else ->  {
+                        Boolean(true)
+                    }
+                }
+
+            }
+            )
+        }
+
+        public final var classifierNamePolicy: R|ClassifierNamePolicy|by this@R|/A|.R|/A.property|<R|ClassifierNamePolicy.SOURCE_CODE_QUALIFIED|>(Q|ClassifierNamePolicy.SOURCE_CODE_QUALIFIED|)
+            public get(): R|ClassifierNamePolicy| {
+                ^ D|/A.classifierNamePolicy|.R|FakeOverride<kotlin/properties/ReadWriteProperty.getValue: R|ClassifierNamePolicy.SOURCE_CODE_QUALIFIED|>|(this@R|/A|, ::R|/A.classifierNamePolicy|)
+            }
+            public set(<set-?>: R|ClassifierNamePolicy|): R|kotlin/Unit| {
+                D|/A.classifierNamePolicy|.<Inapplicable(INAPPLICABLE): [kotlin/properties/ReadWriteProperty.setValue]>#(this@R|/A|, ::R|/A.classifierNamePolicy|, R|<local>/classifierNamePolicy|)
+            }
+
+        public final var typeNormalizer: <ERROR TYPE REF: Ambiguity: getValue, [kotlin/getValue, kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>by <Inapplicable(INAPPLICABLE): [/A.property]>#<R|(KotlinType) -> KotlinType|>(property@fun <anonymous>(): R|class error: Unresolved name: it| {
+            <Unresolved name: it>#
+        }
+        )
+            public get(): <ERROR TYPE REF: Ambiguity: getValue, [kotlin/getValue, kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]> {
+                ^ D|/A.typeNormalizer|.<Ambiguity: getValue, [kotlin/getValue, kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>#(this@R|/A|, ::R|/A.typeNormalizer|)
+            }
+            public set(<set-?>: <ERROR TYPE REF: Ambiguity: getValue, [kotlin/getValue, kotlin/collections/getValue, kotlin/collections/getValue, kotlin/collections/getValue]>): R|kotlin/Unit| {
+                D|/A.typeNormalizer|.<Inapplicable(INAPPLICABLE): [kotlin/collections/setValue]>#(this@R|/A|, ::R|/A.typeNormalizer|, R|<local>/typeNormalizer|)
+            }
+
+    }

compiler/fir/resolve/testData/resolve/stdlib/problems/functionAndFunctionN.kt

@@ -0,0 +1,5 @@
+fun takeAnyFun(function: Function<*>) {}
+
+fun test(block: () -> Unit) {
+    <!INAPPLICABLE_CANDIDATE!>takeAnyFun<!>(block)
+}

compiler/fir/resolve/testData/resolve/stdlib/problems/functionAndFunctionN.txt

@@ -0,0 +1,6 @@
+FILE: functionAndFunctionN.kt
+    public final fun takeAnyFun(function: R|kotlin/Function<*>|): R|kotlin/Unit| {
+    }
+    public final fun test(block: R|() -> kotlin/Unit|): R|kotlin/Unit| {
+        <Inapplicable(INAPPLICABLE): [/takeAnyFun]>#(R|<local>/block|)
+    }

compiler/fir/resolve/testData/resolve/stdlib/problems/inapplicableRemoveAll.kt

@@ -0,0 +1,5 @@
+fun test(list: MutableList<String>) {
+    list.<!AMBIGUITY!>removeAll<!> {
+        <!UNRESOLVED_REFERENCE!>it<!>.<!AMBIGUITY!>isEmpty<!>()
+    }
+}

compiler/fir/resolve/testData/resolve/stdlib/problems/inapplicableRemoveAll.txt

@@ -0,0 +1,7 @@
+FILE: inapplicableRemoveAll.kt
+    public final fun test(list: R|kotlin/collections/MutableList<kotlin/String>|): R|kotlin/Unit| {
+        R|<local>/list|.<Ambiguity: removeAll, [kotlin/collections/removeAll, kotlin/collections/removeAll, kotlin/collections/removeAll, kotlin/collections/removeAll]>#(<L> = removeAll@fun <anonymous>(): R|class error: Ambiguity: isEmpty, [kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/text/isEmpty]| {
+            <Unresolved name: it>#.<Ambiguity: isEmpty, [kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/collections/isEmpty, kotlin/text/isEmpty]>#()
+        }
+        )
+    }

compiler/fir/resolve/testData/resolve/stdlib/problems/toSortedMapWithComparator.kt

@@ -0,0 +1,3 @@
+fun test(map: Map<String?, List<String>>) {
+    val sortedMap = map.<!INAPPLICABLE_CANDIDATE!>toSortedMap<!>(nullsLast())
+}

compiler/fir/resolve/testData/resolve/stdlib/problems/toSortedMapWithComparator.txt

@@ -0,0 +1,4 @@
+FILE: toSortedMapWithComparator.kt
+    public final fun test(map: R|kotlin/collections/Map<kotlin/String?, kotlin/collections/List<kotlin/String>>|): R|kotlin/Unit| {
+        lval sortedMap: <ERROR TYPE REF: Inapplicable(INAPPLICABLE): [kotlin/collections/toSortedMap]> = R|<local>/map|.<Inapplicable(INAPPLICABLE): [kotlin/collections/toSortedMap]>#(R|kotlin/comparisons/nullsLast|<R|kotlin/Any?|>())
+    }

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

@@ -1001,11 +1001,26 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/resolve/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("ambiguityOnExtensionFunctions.kt")
+        public void testAmbiguityOnExtensionFunctions() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/ambiguityOnExtensionFunctions.kt");
+        }
+
         @TestMetadata("asImports.kt")
         public void testAsImports() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/asImports.kt");
         }
 
+        @TestMetadata("bareTypes.kt")
+        public void testBareTypes() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/bareTypes.kt");
+        }
+
+        @TestMetadata("callableReferenceOnInstance.kt")
+        public void testCallableReferenceOnInstance() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/callableReferenceOnInstance.kt");
+        }
+
         @TestMetadata("covariantArrayAsReceiver.kt")
         public void testCovariantArrayAsReceiver() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/covariantArrayAsReceiver.kt");
@@ -1021,11 +1036,26 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
             runTest("compiler/fir/resolve/testData/resolve/problems/definitelyNotNullAmbiguity.kt");
         }
 
+        @TestMetadata("exhaustiveWhenAndFlexibleType.kt")
+        public void testExhaustiveWhenAndFlexibleType() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/exhaustiveWhenAndFlexibleType.kt");
+        }
+
+        @TestMetadata("incorrectSuperCall.kt")
+        public void testIncorrectSuperCall() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/incorrectSuperCall.kt");
+        }
+
         @TestMetadata("invokeOfLambdaWithReceiver.kt")
         public void testInvokeOfLambdaWithReceiver() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/invokeOfLambdaWithReceiver.kt");
         }
 
+        @TestMetadata("iteratorOfVararg.kt")
+        public void testIteratorOfVararg() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/iteratorOfVararg.kt");
+        }
+
         @TestMetadata("javaAccessorConversion.kt")
         public void testJavaAccessorConversion() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/javaAccessorConversion.kt");
@@ -1051,6 +1081,11 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest {
             runTest("compiler/fir/resolve/testData/resolve/problems/nestedClassContructor.kt");
         }
 
+        @TestMetadata("noBoundSmartcastAfterContinue.kt")
+        public void testNoBoundSmartcastAfterContinue() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/noBoundSmartcastAfterContinue.kt");
+        }
+
         @TestMetadata("propertyFromJavaPlusAssign.kt")
         public void testPropertyFromJavaPlusAssign() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/propertyFromJavaPlusAssign.kt");

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

@@ -1001,11 +1001,26 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/resolve/testData/resolve/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("ambiguityOnExtensionFunctions.kt")
+        public void testAmbiguityOnExtensionFunctions() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/ambiguityOnExtensionFunctions.kt");
+        }
+
         @TestMetadata("asImports.kt")
         public void testAsImports() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/asImports.kt");
         }
 
+        @TestMetadata("bareTypes.kt")
+        public void testBareTypes() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/bareTypes.kt");
+        }
+
+        @TestMetadata("callableReferenceOnInstance.kt")
+        public void testCallableReferenceOnInstance() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/callableReferenceOnInstance.kt");
+        }
+
         @TestMetadata("covariantArrayAsReceiver.kt")
         public void testCovariantArrayAsReceiver() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/covariantArrayAsReceiver.kt");
@@ -1021,11 +1036,26 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
             runTest("compiler/fir/resolve/testData/resolve/problems/definitelyNotNullAmbiguity.kt");
         }
 
+        @TestMetadata("exhaustiveWhenAndFlexibleType.kt")
+        public void testExhaustiveWhenAndFlexibleType() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/exhaustiveWhenAndFlexibleType.kt");
+        }
+
+        @TestMetadata("incorrectSuperCall.kt")
+        public void testIncorrectSuperCall() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/incorrectSuperCall.kt");
+        }
+
         @TestMetadata("invokeOfLambdaWithReceiver.kt")
         public void testInvokeOfLambdaWithReceiver() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/invokeOfLambdaWithReceiver.kt");
         }
 
+        @TestMetadata("iteratorOfVararg.kt")
+        public void testIteratorOfVararg() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/iteratorOfVararg.kt");
+        }
+
         @TestMetadata("javaAccessorConversion.kt")
         public void testJavaAccessorConversion() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/javaAccessorConversion.kt");
@@ -1051,6 +1081,11 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos
             runTest("compiler/fir/resolve/testData/resolve/problems/nestedClassContructor.kt");
         }
 
+        @TestMetadata("noBoundSmartcastAfterContinue.kt")
+        public void testNoBoundSmartcastAfterContinue() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/problems/noBoundSmartcastAfterContinue.kt");
+        }
+
         @TestMetadata("propertyFromJavaPlusAssign.kt")
         public void testPropertyFromJavaPlusAssign() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/problems/propertyFromJavaPlusAssign.kt");

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

@@ -587,6 +587,11 @@ public class FirDiagnosticsWithStdlibTestGenerated extends AbstractFirDiagnostic
             KotlinTestUtils.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/fir/resolve/testData/resolve/stdlib/problems"), Pattern.compile("^([^.]+)\\.kt$"), null, true);
         }
 
+        @TestMetadata("arrayFilterCapturedType.kt")
+        public void testArrayFilterCapturedType() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/stdlib/problems/arrayFilterCapturedType.kt");
+        }
+
         @TestMetadata("classLiteralForParameter.kt")
         public void testClassLiteralForParameter() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/stdlib/problems/classLiteralForParameter.kt");
@@ -597,6 +602,26 @@ public class FirDiagnosticsWithStdlibTestGenerated extends AbstractFirDiagnostic
             runTest("compiler/fir/resolve/testData/resolve/stdlib/problems/cloneArray.kt");
         }
 
+        @TestMetadata("delegateTypeMismatch.kt")
+        public void testDelegateTypeMismatch() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/stdlib/problems/delegateTypeMismatch.kt");
+        }
+
+        @TestMetadata("functionAndFunctionN.kt")
+        public void testFunctionAndFunctionN() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/stdlib/problems/functionAndFunctionN.kt");
+        }
+
+        @TestMetadata("inapplicableRemoveAll.kt")
+        public void testInapplicableRemoveAll() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/stdlib/problems/inapplicableRemoveAll.kt");
+        }
+
+        @TestMetadata("toSortedMapWithComparator.kt")
+        public void testToSortedMapWithComparator() throws Exception {
+            runTest("compiler/fir/resolve/testData/resolve/stdlib/problems/toSortedMapWithComparator.kt");
+        }
+
         @TestMetadata("tryWithLambdaInside.kt")
         public void testTryWithLambdaInside() throws Exception {
             runTest("compiler/fir/resolve/testData/resolve/stdlib/problems/tryWithLambdaInside.kt");