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

compiler/testData/diagnostics/tests/resolve/CycleInTypeArgs.fir.kt

@@ -0,0 +1,3 @@
+class Class1<T : Class2<Class1<X>>>
+
+class Class2<T : Class1<Class2<X>>>

compiler/testData/diagnostics/tests/resolve/HiddenDeclarations.fir.kt

@@ -0,0 +1,74 @@
+package test
+
+// imports should be resolved
+import test.topLevelFun
+import test.topLevelProperty
+
+@Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+fun topLevelFun(){}
+
+@Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+var topLevelProperty = 1
+
+@Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+fun String.topLevelExtensionFun(){}
+
+@Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+val String.topLevelExtensionProperty: Int get() = 1
+
+open class A {
+    constructor(p: Int) : this("") {}
+
+    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+    constructor(s: String){}
+
+    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+    open fun memberFun(){}
+
+    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+    val memberProperty = 1
+
+    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+    fun String.memberExtensionFun(){}
+
+    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+    val String.memberExtensionProperty: Int get() = 1
+
+    fun foo() {
+        topLevelFun()
+        topLevelProperty++
+        "".topLevelExtensionFun()
+        "".topLevelExtensionProperty
+
+        memberFun()
+        memberProperty
+        "".memberExtensionFun()
+        "".memberExtensionProperty
+
+        A("")
+    }
+}
+
+interface I {
+    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+    fun foo1()
+
+    @Deprecated("hidden", level = DeprecationLevel.HIDDEN)
+    fun foo2()
+}
+
+class X : I {
+    override fun foo1() {
+    }
+}
+
+class B : A("") {
+    // still can override it
+    override fun memberFun() {
+        super.memberFun() // but cannot call super :)
+    }
+}
+
+class C : A {
+    constructor() : <!INAPPLICABLE_CANDIDATE!>super<!>("")
+}

compiler/testData/diagnostics/tests/resolve/ambiguityOnPropertiesWithTheSamePackageName.fir.kt

@@ -0,0 +1,30 @@
+// FILE: a.kt
+package a
+
+class A
+
+// FILE: b.kt
+package b
+
+import a.A
+
+val A.d: Int get() = 1
+
+// FILE: c.kt
+package c
+
+import a.A
+
+val A.d: Int get() = 2
+
+// FILE: d.kt
+
+package d
+
+import a.A
+import b.d
+import c.d
+
+fun A.test() {
+    <!AMBIGUITY!>d<!>
+}

compiler/testData/diagnostics/tests/resolve/ambiguityWithTwoCorrespondingFunctionTypes.fir.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun foo(a: Any, f: ()->Int) = f()
+fun foo(a: Any, f: (Any)->Int) = f(a)
+fun foo(i: Int, f: Int.()->Int) = i.<!UNRESOLVED_REFERENCE!>f<!>()
+
+fun test1() {
+    <!AMBIGUITY!>foo<!>(1) { ->
+        this
+    }
+}

compiler/testData/diagnostics/tests/resolve/anonymousObjectFromTopLevelMember.fir.kt

@@ -0,0 +1,24 @@
+interface IFoo {
+    fun foo()
+}
+
+interface IBar
+
+private fun createAnonObject() =
+        object : IFoo, IBar {
+            override fun foo() {}
+            fun qux() {}
+        }
+
+private val propOfAnonObject = object : IFoo, IBar {
+            override fun foo() {}
+            fun qux() {}
+        }
+
+fun useAnonObject() {
+    createAnonObject().foo()
+    createAnonObject().qux()
+
+    propOfAnonObject.foo()
+    propOfAnonObject.qux()
+}

compiler/testData/diagnostics/tests/resolve/callableReferenceInCST.fir.kt

@@ -0,0 +1,36 @@
+// !LANGUAGE: +NewInference
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+fun testWhen(x: Any?) {
+    val y = when (x) {
+        null -> ""
+        else -> <!UNRESOLVED_REFERENCE!>::unresolved<!>
+    }
+}
+
+fun testWhenWithBraces(x: Any?) {
+    val z = when(x) {
+        null -> { "" }
+        else -> { <!UNRESOLVED_REFERENCE!>::unresolved<!> }
+    }
+}
+
+fun testIf(x: Any?) {
+    val y = if (x != null) <!UNRESOLVED_REFERENCE!>::unresolved<!> else null
+}
+
+fun testIfWithBraces(x: Any?) {
+    val z = if (x != null) { <!UNRESOLVED_REFERENCE!>::unresolved<!> } else { null }
+}
+
+fun testElvis(x: Any?) {
+    val y = x ?: <!UNRESOLVED_REFERENCE!>::unresolved<!>
+}
+
+fun testExclExcl() {
+    val y = <!UNRESOLVED_REFERENCE!>:: unresolved<!>!!
+}
+
+fun testTry() {
+    val v = try { <!UNRESOLVED_REFERENCE!>::unresolved<!> } catch (e: Exception) {}
+}

compiler/testData/diagnostics/tests/resolve/capturedTypesInLambdaParameter.fir.kt

@@ -0,0 +1,42 @@
+// !CHECK_TYPE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+class B<E>
+
+fun <T> B<T>.foo(f: (T) -> Unit) {}
+fun <T> B<T>.bar(f: (T, T) -> Unit, g: (T, T) -> Unit) {}
+fun <T> B<T>.baz(f: (B<T>) -> Unit) {}
+
+fun number(x: Number) {}
+fun Number.foobar() {}
+
+fun test(b: B<out Number>) {
+    b.foo {
+        it checkType { _<Number>() }
+        it.toInt()
+    }
+
+    b.foo { x ->
+        x checkType { _<Number>() }
+        x.toInt()
+    }
+
+    b.bar({ x, y ->
+        x checkType { _<Number>() }
+        y checkType { _<Number>() }
+        x.toInt()
+        y.toInt()
+    }) { u, w ->
+        u checkType { _<Number>() }
+        w checkType { _<Number>() }
+
+        u.toInt()
+        w.toInt()
+    }
+
+    b.foo(::number)
+    b.foo(Number::foobar)
+
+    b.baz {
+        b -> b checkType { _<B<out Number>>() }
+    }
+}

compiler/testData/diagnostics/tests/resolve/constructorVsCompanion.fir.kt

@@ -0,0 +1,23 @@
+class A private constructor()
+
+class B {
+    private companion object
+}
+
+class C(val x: Int)
+
+class D private constructor() {
+    companion object
+}
+
+class E private constructor() {
+    companion object {
+        operator fun invoke(x: Int) = x
+    }
+}
+
+val a = A
+val b = B
+val c = C
+val d = D
+val e = <!INAPPLICABLE_CANDIDATE!>E<!>(42)

compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedFunctionType.fir.kt

@@ -0,0 +1,57 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+@Target(AnnotationTarget.TYPE)
+@DslMarker
+annotation class MyDsl
+
+interface A {
+    fun foo()
+}
+
+interface B {
+    fun bar()
+}
+
+fun baz1(x: (@MyDsl A).() -> Unit) {}
+fun baz2(x: (@MyDsl B).() -> Unit) {}
+fun baz3(x: @MyDsl A.() -> Unit) {}
+fun baz4(x: @MyDsl B.() -> Unit) {}
+
+fun @MyDsl A.baz5() {
+    baz4 {
+        bar()
+        foo()
+    }
+}
+
+fun main() {
+    baz1 {
+        baz2 {
+            bar()
+            foo()
+        }
+    }
+
+    baz3 {
+        baz2 {
+            bar()
+            foo()
+        }
+    }
+
+    baz1 {
+        baz4 {
+            bar()
+            foo()
+        }
+    }
+
+    baz3 {
+        baz4 {
+            bar()
+            foo()
+        }
+    }
+
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedFunctionType_1_4.fir.kt

@@ -0,0 +1,58 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !LANGUAGE: +DslMarkerOnFunctionTypeReceiver
+// !WITH_NEW_INFERENCE
+
+@Target(AnnotationTarget.TYPE)
+@DslMarker
+annotation class MyDsl
+
+interface A {
+    fun foo()
+}
+
+interface B {
+    fun bar()
+}
+
+fun baz1(x: (@MyDsl A).() -> Unit) {}
+fun baz2(x: (@MyDsl B).() -> Unit) {}
+fun baz3(x: @MyDsl A.() -> Unit) {}
+fun baz4(x: @MyDsl B.() -> Unit) {}
+
+fun @MyDsl A.baz5() {
+    baz4 {
+        bar()
+        foo()
+    }
+}
+
+fun main() {
+    baz1 {
+        baz2 {
+            bar()
+            foo()
+        }
+    }
+
+    baz3 {
+        baz2 {
+            bar()
+            foo()
+        }
+    }
+
+    baz1 {
+        baz4 {
+            bar()
+            foo()
+        }
+    }
+
+    baz3 {
+        baz4 {
+            bar()
+            foo()
+        }
+    }
+
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/annotatedTypeArgument.fir.kt

@@ -0,0 +1,26 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+class A {
+    fun a() = 1
+}
+
+class B {
+    fun b() = 2
+}
+
+fun <T> foo(x: T.() -> Unit) {}
+fun <E> bar(x: E.() -> Unit) {}
+
+fun test() {
+    foo<@Ann A> {
+        a()
+        bar<@Ann B> {
+            a()
+            this@foo.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerOnTypealias.fir.kt

@@ -0,0 +1,28 @@
+@DslMarker
+@Target(AnnotationTarget.CLASS, AnnotationTarget.TYPEALIAS)
+annotation class XMarker
+
+@XMarker
+class Foo
+
+class Bar
+
+@XMarker
+typealias XBar = Bar
+
+typealias XXBar = XBar
+
+fun Foo.foo(body: Foo.() -> Unit) = <!INAPPLICABLE_CANDIDATE!>body<!>()
+fun Foo.xbar(body: XBar.() -> Unit) = Bar().<!UNRESOLVED_REFERENCE!>body<!>()
+fun Foo.xxbar(body: XXBar.() -> Unit) = Bar().<!UNRESOLVED_REFERENCE!>body<!>()
+
+fun test() {
+    Foo().foo {
+        <!UNRESOLVED_REFERENCE!>xbar<!> {
+            <!UNRESOLVED_REFERENCE!>foo<!> {}
+        }
+        <!UNRESOLVED_REFERENCE!>xxbar<!> {
+            <!UNRESOLVED_REFERENCE!>foo<!> {}
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/dslMarkerWithTypealiasRecursion.fir.kt

@@ -0,0 +1,24 @@
+// !WITH_NEW_INFERENCE
+// NI_EXPECTED_FILE
+@DslMarker
+@Target(AnnotationTarget.CLASS, AnnotationTarget.TYPEALIAS)
+annotation class XMarker
+
+@XMarker
+class Foo
+
+class Bar
+
+typealias YBar = ZBar
+typealias ZBar = <!OTHER_ERROR!>YBar<!>
+
+fun Foo.foo(body: Foo.() -> Unit) = <!INAPPLICABLE_CANDIDATE!>body<!>()
+fun Foo.zbar(body: ZBar.() -> Unit) = Bar().<!UNRESOLVED_REFERENCE!>body<!>()
+
+fun test() {
+    Foo().foo {
+        <!UNRESOLVED_REFERENCE!>zbar<!> {
+            <!UNRESOLVED_REFERENCE!>foo<!> {}
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/inheritedMarker.fir.kt

@@ -0,0 +1,30 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+annotation class Ann
+
+@Ann
+interface Common
+interface C : Common
+interface D : C
+
+class A : C {
+    fun a() = 1
+}
+
+class B : D {
+    fun b() = 2
+}
+
+fun foo(x: A.() -> Unit) {}
+fun bar(x: B.() -> Unit) {}
+
+fun test() {
+    foo {
+        a()
+        bar {
+            a()
+            this@foo.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtension.fir.kt

@@ -0,0 +1,23 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+annotation class Ann
+
+@Ann
+class A {
+    fun a() = 1
+}
+
+@Ann
+class B {
+    fun b() = 2
+}
+
+fun bar(x: B.() -> Unit) {}
+
+fun A.test() {
+    bar {
+        a()
+        this@test.a()
+        b()
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/insideTopLevelExtensionAnnotatedType.fir.kt

@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+class A {
+    fun a() = 1
+}
+
+class B {
+    fun b() = 2
+}
+
+fun bar(x: (@Ann B).() -> Unit) {}
+
+fun @Ann A.test() {
+    bar {
+        a()
+        this@test.a()
+        b()
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/kt29948.fir.kt

@@ -0,0 +1,19 @@
+@DslMarker
+annotation class MyDsl
+
+@MyDsl
+interface Foo<T> {
+    val x: Int
+}
+
+val Foo<*>.bad: Int get() = x
+
+fun Foo<*>.badFun(): Int = x
+
+val Foo<Int>.good: Int get() = x
+
+fun test(foo: Foo<*>) {
+    foo.apply {
+        x
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/kt31360.fir.kt

@@ -0,0 +1,25 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+@DslMarker
+annotation class MyDsl
+
+@MyDsl
+interface Scope<A, B> {
+    val something: A
+    val value: B
+}
+fun scoped1(block: Scope<Int, String>.() -> Unit) {}
+fun scoped2(block: Scope<*, String>.() -> Unit) {}
+
+val <T> Scope<*, T>.property: T get() = value
+
+fun f() {
+    scoped1 {
+        value
+        property
+    }
+    scoped2 {
+        value
+        property
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/markedReceiverWithCapturedTypeArgument.fir.kt

@@ -0,0 +1,11 @@
+@DslMarker
+annotation class AnnMarker
+
+@AnnMarker
+class Inv<T> {
+    fun bar() {}
+}
+
+fun Inv<*>.foo() {
+    bar()
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/markersIntersection.fir.kt

@@ -0,0 +1,93 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class L1
+
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class L2
+
+class A {
+    fun a() = 1
+}
+
+class B {
+    fun b() = 2
+}
+
+fun foo1(x: (@L1 A).() -> Unit) {}
+fun foo2(x: (@L2 A).() -> Unit) {}
+
+fun foo12(x: (@L1 @L2 A).() -> Unit) {}
+
+fun bar1(x: (@L1 B).() -> Unit) {}
+fun bar2(x: (@L2 B).() -> Unit) {}
+
+fun <T> bar1t(q: T, x: (@L1 T).() -> Unit) {}
+
+fun test() {
+    foo12 {
+        a()
+        bar1 {
+            a()
+            b()
+        }
+
+        bar2 {
+            a()
+            b()
+        }
+    }
+
+    bar1 {
+        b()
+        foo12 {
+            a()
+            b()
+        }
+    }
+
+    bar2 {
+        b()
+        foo12 {
+            a()
+            b()
+        }
+    }
+
+    foo2 {
+        bar1t(this) {
+            a()
+            bar1 {
+                a()
+                b()
+            }
+
+            bar2 {
+                a()
+                b()
+            }
+        }
+    }
+
+    bar1 {
+        b()
+        foo2 {
+            bar1t(this) {
+                a()
+                b()
+            }
+        }
+    }
+
+    bar2 {
+        b()
+        foo2 {
+            bar1t(this) {
+                a()
+                b()
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/nestedWithSameReceiver.fir.kt

@@ -0,0 +1,40 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+class A {
+    fun a() = 1
+}
+
+class B {
+    fun b() = 2
+}
+
+fun foo(x: (@Ann A).() -> Unit) {}
+fun bar(x: (@Ann B).() -> Unit) {}
+
+fun test() {
+    foo {
+        a()
+        foo l1@{
+            a()
+            bar l2@{
+                a()
+                this@l1.a()
+                b()
+
+                foo l3@{
+                    a()
+                    b()
+                    this@l2.b()
+                    bar {
+                        a()
+                        this@l3.a()
+                        b()
+                    }
+                }
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/properties.fir.kt

@@ -0,0 +1,62 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+annotation class Ann
+
+@Ann
+class A {
+    var a = 1
+}
+
+var A.a1: Int
+    get() = 1
+    set(value) {}
+
+@Ann
+class B {
+    var b = 2
+}
+
+var B.b1: Int
+    get() = 1
+    set(value) {}
+
+fun foo(x: A.() -> Unit) {}
+fun bar(x: B.() -> Unit) {}
+
+fun test() {
+    foo {
+        a + 1
+        a += a + 1
+        a++
+
+        a1 + 1
+        a1 += a1 + 1
+        a1++
+
+        bar {
+            a + 1
+            a += a + 1
+            a++
+
+            a1 + 1
+            a1 += a1 + 1
+            a1++
+
+            this@foo.a + 1
+            this@foo.a += this@foo.a + 1
+            this@foo.a++
+
+            this@foo.a1 + 1
+            this@foo.a1 += this@foo.a1 + 1
+            this@foo.a1++
+
+            b + 1
+            b += b + 1
+            b++
+
+            b1 + 1
+            b1 += b1 + 1
+            b1++
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedClasses.fir.kt

@@ -0,0 +1,27 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+annotation class Ann
+
+@Ann
+class A {
+    fun a() = 1
+}
+
+@Ann
+class B {
+    fun b() = 2
+}
+
+fun foo(x: A.() -> Unit) {}
+fun bar(x: B.() -> Unit) {}
+
+fun test() {
+    foo {
+        a()
+        bar {
+            a()
+            this@foo.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/simpleAnnotatedTypes.fir.kt

@@ -0,0 +1,26 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+class A {
+    fun a() = 1
+}
+
+class B {
+    fun b() = 2
+}
+
+fun foo(x: (@Ann A).() -> Unit) {}
+fun bar(x: (@Ann B).() -> Unit) {}
+
+fun test() {
+    foo {
+        a()
+        bar {
+            a()
+            this@foo.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedClasses.fir.kt

@@ -0,0 +1,27 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+annotation class Ann
+
+@Ann
+class A {
+    fun a() = 1
+}
+
+@Ann
+class B {
+    fun b() = 2
+}
+
+fun <T> foo(x: T.() -> Unit) {}
+fun <E> bar(x: E.() -> Unit) {}
+
+fun test() {
+    foo<A> {
+        a()
+        bar<B> {
+            a()
+            this@foo.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/substitutedReceiverAnnotatedType.fir.kt

@@ -0,0 +1,27 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+class A {
+    fun a() = 1
+}
+
+class B {
+    fun b() = 2
+}
+
+fun <T> foo(x: (@Ann T).() -> Unit) {}
+fun <E> bar(x: (@Ann E).() -> Unit) {}
+
+fun test() {
+    foo<A> {
+        a()
+        bar<B> {
+            a()
+            this@foo.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers.fir.kt

@@ -0,0 +1,111 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann1
+
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann2
+
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann3
+
+class A {
+    operator fun B.invoke() {}
+
+    val B.y: D get() = D()
+}
+
+class B
+
+class C {
+    operator fun D.invoke() {}
+
+    val D.x: B get() = B()
+}
+
+class D
+
+fun foo(x: (@Ann1 A).() -> Unit) {}
+fun bar(x: (@Ann2 B).() -> Unit) {}
+fun baz(x: (@Ann3 C).() -> Unit) {}
+fun foo1(x: (@Ann1 D).() -> Unit) {}
+fun foo2(x: (@Ann2 D).() -> Unit) {}
+fun foo3(x: (@Ann3 D).() -> Unit) {}
+
+fun test() {
+    foo {
+        bar {
+            baz {
+                y()
+
+                <!UNRESOLVED_REFERENCE!>x<!>()
+
+                with(D()) {
+                    x()
+                }
+                D().x()
+
+                foo1 {
+                    x()
+                    y()
+
+                    with(A()) {
+                        x()
+                        y()
+                    }
+
+                    with(D()) {
+                        x()
+                    }
+                    D().x()
+                }
+
+                foo2 {
+                    x()
+                    y()
+                }
+
+                foo3 {
+                    x()
+                    y()
+                }
+            }
+        }
+    }
+
+    foo1 {
+        foo {
+            baz {
+                bar {
+                    x()
+                    y()
+                }
+            }
+        }
+    }
+
+    foo2 {
+        foo {
+            baz {
+                bar {
+                    x()
+                    y()
+                }
+            }
+        }
+    }
+
+    foo3 {
+        foo {
+            baz {
+                bar {
+                    x()
+                    y()
+                }
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/threeImplicitReceivers2.fir.kt

@@ -0,0 +1,106 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann1
+
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann2
+
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann3
+
+class A {
+    val B.y: (C.() -> Unit) get() = null!!
+}
+
+class B
+
+class C {
+    val D.x: (A.() -> Unit) get() = null!!
+}
+
+class D
+
+fun foo(x: (@Ann1 A).() -> Unit) {}
+fun bar(x: (@Ann2 B).() -> Unit) {}
+fun baz(x: (@Ann3 C).() -> Unit) {}
+fun foo1(x: (@Ann1 D).() -> Unit) {}
+fun foo2(x: (@Ann2 D).() -> Unit) {}
+fun foo3(x: (@Ann3 D).() -> Unit) {}
+
+fun test() {
+    foo {
+        bar {
+            baz {
+                <!INAPPLICABLE_CANDIDATE!>y<!>()
+
+                <!UNRESOLVED_REFERENCE!>x<!>()
+
+                with(D()) {
+                    <!INAPPLICABLE_CANDIDATE!>x<!>()
+                }
+
+                foo1 {
+                    <!INAPPLICABLE_CANDIDATE!>x<!>()
+                    <!INAPPLICABLE_CANDIDATE!>y<!>()
+
+                    with(A()) {
+                        <!INAPPLICABLE_CANDIDATE!>x<!>()
+                        <!INAPPLICABLE_CANDIDATE!>y<!>()
+                    }
+
+                    with(D()) {
+                        <!INAPPLICABLE_CANDIDATE!>x<!>()
+                    }
+                    A().<!UNRESOLVED_REFERENCE!>x<!>()
+                }
+
+                foo2 {
+                    <!INAPPLICABLE_CANDIDATE!>x<!>()
+                    <!INAPPLICABLE_CANDIDATE!>y<!>()
+                }
+
+                foo3 {
+                    <!INAPPLICABLE_CANDIDATE!>x<!>()
+                    <!INAPPLICABLE_CANDIDATE!>y<!>()
+                }
+            }
+        }
+    }
+
+    foo1 {
+        foo {
+            baz {
+                bar {
+                    <!INAPPLICABLE_CANDIDATE!>x<!>()
+                    <!INAPPLICABLE_CANDIDATE!>y<!>()
+                }
+            }
+        }
+    }
+
+    foo2 {
+        foo {
+            baz {
+                bar {
+                    <!INAPPLICABLE_CANDIDATE!>x<!>()
+                    <!INAPPLICABLE_CANDIDATE!>y<!>()
+                }
+            }
+        }
+    }
+
+    foo3 {
+        foo {
+            baz {
+                bar {
+                    <!INAPPLICABLE_CANDIDATE!>x<!>()
+                    <!INAPPLICABLE_CANDIDATE!>y<!>()
+                }
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/twoImplicitReceivers.fir.kt

@@ -0,0 +1,102 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann1
+
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann2
+
+class A {
+    fun D.extA() {}
+}
+
+class B {
+    fun D.extB() {}
+}
+
+class D
+
+fun foo(x: (@Ann1 A).() -> Unit) {}
+fun bar(x: (@Ann2 B).() -> Unit) {}
+fun baz(x: (@Ann1 D).() -> Unit) {}
+
+fun test() {
+    foo {
+        bar {
+            baz {
+                extA()
+                extB()
+
+                D().extA()
+                D().extB()
+
+                with(D()) {
+                    extA()
+                    extB()
+                }
+            }
+        }
+    }
+
+    foo {
+        baz {
+            extA()
+            D().extA()
+
+            bar {
+                extA()
+                extB()
+
+                D().extA()
+                D().extB()
+
+                with(D()) {
+                    extA()
+                    extB()
+                }
+            }
+        }
+    }
+
+    baz {
+        foo {
+            extA()
+            D().extA()
+
+            bar {
+                extA()
+                extB()
+
+                D().extA()
+                D().extB()
+
+                with(D()) {
+                    extA()
+                    extB()
+                }
+            }
+        }
+    }
+
+    baz {
+        bar {
+            extB()
+
+            D().extB()
+
+            foo {
+                extA()
+                extB()
+
+                D().extA()
+                D().extB()
+
+                with(D()) {
+                    extA()
+                    extB()
+                }
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/twoLanguages.fir.kt

@@ -0,0 +1,104 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class L1
+
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class L2
+
+class A {
+    fun a() = 1
+}
+
+class B {
+    fun b() = 2
+}
+
+fun foo1(x: (@L1 A).() -> Unit) {}
+fun foo2(x: (@L2 A).() -> Unit) {}
+fun bar1(x: (@L1 B).() -> Unit) {}
+fun bar2(x: (@L2 B).() -> Unit) {}
+
+fun test() {
+    foo1 {
+        a()
+
+        foo2 {
+            a()
+
+            bar1 {
+                a()
+                b()
+                bar2 {
+                    a()
+                    b()
+                }
+            }
+
+            bar2 {
+                a()
+                b()
+            }
+        }
+
+        bar1 {
+            a()
+            b()
+            bar2 {
+                a()
+                b()
+            }
+        }
+
+        bar2 {
+            a()
+            b()
+        }
+    }
+
+    foo2 {
+        a()
+
+        bar1 {
+            a()
+            b()
+            bar2 {
+                a()
+                b()
+            }
+        }
+
+        bar2 {
+            a()
+            b()
+        }
+    }
+
+    bar1 {
+        b()
+        bar2 {
+            b()
+        }
+    }
+
+    bar2 {
+        b()
+    }
+
+    foo1 {
+        bar1 {
+            a()
+            b()
+            foo2 {
+                a()
+                b()
+
+                bar2 {
+                    a()
+                    b()
+                }
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/unsupportedFeature.fir.kt

@@ -0,0 +1,28 @@
+// !LANGUAGE: -DslMarkersSupport
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+annotation class Ann
+
+@Ann
+class A {
+    fun a() = 1
+}
+
+@Ann
+class B {
+    fun b() = 2
+}
+
+fun foo(x: A.() -> Unit) {}
+fun bar(x: B.() -> Unit) {}
+
+fun test() {
+    foo {
+        a()
+        bar {
+            a()
+            this@foo.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/useOfExtensions.fir.kt

@@ -0,0 +1,27 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+annotation class Ann
+
+@Ann
+class A
+
+fun A.a() = 1
+
+@Ann
+class B
+
+fun B.b() = 2
+
+fun foo(x: A.() -> Unit) {}
+fun bar(x: B.() -> Unit) {}
+
+fun test() {
+    foo {
+        a()
+        bar {
+            a()
+            this@foo.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/usingWith.fir.kt

@@ -0,0 +1,24 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+annotation class Ann
+
+@Ann
+class A {
+    fun a() = 1
+}
+
+@Ann
+class B {
+    fun b() = 2
+}
+
+fun test(a: A, b: B) {
+    with(a) l1@{
+        a()
+        with(b) {
+            a()
+            this@l1.a()
+            b()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/dslMarker/usingWithThis.fir.kt

@@ -0,0 +1,30 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+@DslMarker
+@Target(AnnotationTarget.TYPE)
+annotation class Ann
+
+class A {
+    fun a() = 1
+}
+
+class B {
+    fun b() = 2
+}
+
+fun foo(x: (@Ann A).() -> Unit) {}
+fun bar(x: (@Ann B).() -> Unit) {}
+
+fun test() {
+    foo {
+        with(this) l1@{
+            a()
+            bar {
+                with(this) {
+                    a()
+                    this@l1.a()
+                    b()
+                }
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/implicitReceiverProperty.fir.kt

@@ -0,0 +1,33 @@
+// FILE: a.kt
+package a
+
+class A(val b: String) {
+    companion object {
+        val c: String = ""
+    }
+
+    fun mtd() = c.length
+}
+
+// FILE: b.kt
+package b
+
+// FILE: c.kt
+package c
+
+// FILE: test.kt
+package test
+
+import a.A
+
+fun <T, R> T.with(f: T.() -> R) = <!INAPPLICABLE_CANDIDATE!>f<!>()
+
+fun A.extFun1() = b.length
+
+// fun A.extFun2() = c.length // TODO fix KT-9953
+
+val x1 = A("").with { b.<!UNRESOLVED_REFERENCE!>length<!> }
+
+// val x2 = A("").with { c.length } // TODO fix KT-9953
+
+val x3 = A.with { c.<!UNRESOLVED_REFERENCE!>length<!> }

compiler/testData/diagnostics/tests/resolve/incompleteConstructorInvocation.fir.kt

@@ -0,0 +1,10 @@
+package p
+
+class X<V>(provider: () -> V, trackValue: Boolean) {
+}
+
+class B {
+    val c = <!INAPPLICABLE_CANDIDATE!>X<!><String> {
+        "e"
+    }
+}

compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdas.fir.kt

@@ -0,0 +1,8 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !CHECK_TYPE
+
+fun <T, R> foo(first: () -> T, second: (T) -> R): R = throw Exception()
+fun test() {
+    val r = foo( { 4 }, { "${it + 1}" } )
+    r checkType { <!UNRESOLVED_REFERENCE!>_<!><String>() }
+}

compiler/testData/diagnostics/tests/resolve/inferenceInLinkedLambdasDependentOnExpectedType.fir.kt

@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun <T> foo(f: () -> Collection<T>, p: (T) -> Boolean): Collection<T> = throw Exception()
+
+fun <T> emptyList(): List<T> = throw Exception()
+
+fun test(): Collection<Int> = foo({ emptyList<Int>() }, { x -> x > 0 })

compiler/testData/diagnostics/tests/resolve/invoke/KT-4372.fir.kt

@@ -0,0 +1,22 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+//KT-4372 Invalid error position and failing to resolve invoke with receiver from other module
+
+class Foo<TInner, TOuter> {
+    fun invoke(content: TInner.() -> Unit) {
+    }
+}
+
+// comment this function to fix the error below
+fun <TInner, TOuter> Foo<TInner, TOuter>.invoke(name: String, content: TInner.() -> Unit) {}
+
+enum class EnumClass(val x: String) {}
+object Y {
+    val x = javaClass<EnumClass>() // javaClass unresolved in any file in this module
+}
+
+//declarations from library
+val <T> T.javaClass : Class<T>
+    get() = throw Exception()
+
+fun <reified T> javaClass() : Class<T> = throw Exception()

compiler/testData/diagnostics/tests/resolve/invoke/errors/ambiguityForInvoke.fir.kt

@@ -0,0 +1,11 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+        
+fun Int.invoke(i: Int, a: Any) {}
+fun Int.invoke(a: Any, i: Int) {}
+
+fun foo(i: Int) {
+    <!AMBIGUITY!>i<!>(1, 1)
+
+    <!AMBIGUITY!>5(1, 2)<!>
+}

compiler/testData/diagnostics/tests/resolve/invoke/errors/invisibleInvoke.fir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class My {
+    private operator fun Int.invoke(s: String) {}
+}
+
+fun My.foo(i: Int) {
+    <!INAPPLICABLE_CANDIDATE!>i<!>("")
+    <!INAPPLICABLE_CANDIDATE!>1("")<!>
+}

compiler/testData/diagnostics/tests/resolve/invoke/errors/receiverPresenceErrorForInvoke.fir.kt

@@ -0,0 +1,11 @@
+fun test1(f: String.() -> Unit) {
+    <!INAPPLICABLE_CANDIDATE!>(f)()<!>
+
+    <!INAPPLICABLE_CANDIDATE!>f<!>()
+}
+
+fun test2(f: (Int) -> Int) {
+    1.<!UNRESOLVED_REFERENCE!>f<!>(2)
+
+    2.<!UNRESOLVED_REFERENCE!>(f)(2)<!>
+}

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

@@ -0,0 +1,14 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A<T>
+
+operator fun <T> T.invoke(a: A<T>) {}
+
+fun foo(s: String, ai: A<Int>) {
+    1(ai)
+
+    <!INAPPLICABLE_CANDIDATE!>s<!>(ai)
+
+    <!INAPPLICABLE_CANDIDATE!>""(ai)<!>
+}

compiler/testData/diagnostics/tests/resolve/invoke/errors/unresolvedInvoke.fir.kt

@@ -0,0 +1,5 @@
+// !DIAGNOSTICS: -UNUSED_EXPRESSION
+fun foo(i: Int) {
+    <!UNRESOLVED_REFERENCE!>i<!>()
+    <!UNRESOLVED_REFERENCE!>1()<!>
+}

compiler/testData/diagnostics/tests/resolve/invoke/errors/unsafeCallWithInvoke.fir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+operator fun String.invoke(i: Int) {}
+
+fun foo(s: String?) {
+    <!INAPPLICABLE_CANDIDATE!>s<!>(1)
+
+    <!INAPPLICABLE_CANDIDATE!>(s ?: null)(1)<!>
+}

compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverForInvokeOnExpression.fir.kt

@@ -0,0 +1,17 @@
+// !WITH_NEW_INFERENCE
+
+fun test1() {
+    1. <!UNRESOLVED_REFERENCE!>(fun String.(i: Int) = i )(1)<!>
+    1.<!UNRESOLVED_REFERENCE!>(label@ fun String.(i: Int) = i )(1)<!>
+}
+
+fun test2(f: String.(Int) -> Unit) {
+    11.<!UNRESOLVED_REFERENCE!>(f)(1)<!>
+    11.<!UNRESOLVED_REFERENCE!>(f)()<!>
+}
+
+fun test3() {
+    fun foo(): String.(Int) -> Unit = {}
+
+    1.<!UNRESOLVED_REFERENCE!>(foo())(1)<!>
+}

compiler/testData/diagnostics/tests/resolve/invoke/errors/wrongReceiverTypeForInvoke.fir.kt

@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun String.invoke(i: Int) {}
+
+fun foo(i: Int) {
+    <!INAPPLICABLE_CANDIDATE!>i<!>(1)
+
+    <!INAPPLICABLE_CANDIDATE!>1(1)<!>
+}

compiler/testData/diagnostics/tests/resolve/invoke/extensionValueAsNonExtension.fir.kt

@@ -0,0 +1,23 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_EXPRESSION -UNUSED_PARAMETER -UNUSED_VARIABLE
+class A
+
+fun test(foo: A.() -> Int, a: A) {
+    val b: Int = foo(a)
+    val c: Int = (foo)(a)
+}
+
+class B {
+    val foo: A.() -> Int = null!!
+
+    init {
+        val b: Int = foo(A())
+    }
+}
+
+fun foo(): A.() -> Int {
+    val b: Int = foo()(A())
+    val c: Int = (foo())(A())
+
+    return null!!
+}

compiler/testData/diagnostics/tests/resolve/invoke/functionExpectedWhenSeveralInvokesExist.fir.kt

@@ -0,0 +1,14 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun Int.invoke(a: Int) {}
+fun Int.invoke(a: Int, b: Int) {}
+
+class SomeClass
+
+fun test(identifier: SomeClass, fn: String.() -> Unit) {
+    <!INAPPLICABLE_CANDIDATE!>identifier<!>()
+    <!INAPPLICABLE_CANDIDATE!>identifier<!>(123)
+    <!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
+    1.<!UNRESOLVED_REFERENCE!>fn<!>()
+}

compiler/testData/diagnostics/tests/resolve/invoke/implicitInvoke.fir.kt

@@ -0,0 +1,33 @@
+class B
+
+class A {
+    operator fun B.invoke() = 4
+}
+
+class X {
+    operator fun invoke() = 3
+}
+
+fun test(a: A, b: B) {
+    with (a) {
+        b()
+        (b)()
+    }
+
+    X()()
+    val x = X()
+    x()
+    (x)()
+}
+
+fun test(c: () -> String, e: Int.() -> String) {
+    c()
+    (c)()
+
+    3.<!UNRESOLVED_REFERENCE!>e<!>()
+    3.<!UNRESOLVED_REFERENCE!>(e)()<!>
+    with(3) {
+        <!INAPPLICABLE_CANDIDATE!>e<!>()
+        <!INAPPLICABLE_CANDIDATE!>(e)()<!>
+    }
+}

compiler/testData/diagnostics/tests/resolve/invoke/invokeAndSmartCast.fir.kt

@@ -0,0 +1,22 @@
+// !WITH_NEW_INFERENCE
+class A(val x: (String.() -> Unit)?)
+
+fun test(a: A) {
+    if (a.x != null) {
+        "".<!UNRESOLVED_REFERENCE!>(a.x)()<!>
+        a.x("") // todo
+        (a.x)("")
+    }
+    "".<!UNRESOLVED_REFERENCE!>(a.x)()<!>
+    a.<!INAPPLICABLE_CANDIDATE!>x<!>("")
+    <!INAPPLICABLE_CANDIDATE!>(a.x)("")<!>
+
+    with("") {
+        a.<!INAPPLICABLE_CANDIDATE!>x<!>()
+        <!INAPPLICABLE_CANDIDATE!>(a.x)()<!>
+        if (a.x != null) {
+            a.<!INAPPLICABLE_CANDIDATE!>x<!>() // todo
+            <!INAPPLICABLE_CANDIDATE!>(a.x)()<!>
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsExtension.fir.kt

@@ -0,0 +1,61 @@
+class Foo {}
+
+operator fun Foo.invoke() {}
+
+//no variable
+fun test(foo: Foo) {
+    foo()
+}
+
+//variable as member
+interface A {
+    val foo: Foo
+}
+
+
+fun test(a: A) {
+    a.foo()
+
+    with (a) {
+        foo()
+    }
+}
+
+//variable as extension
+interface B {
+}
+val B.foo: Foo
+    get() = Foo()
+
+fun test(b: B) {
+    b.foo()
+
+    with (b) {
+        foo()
+    }
+}
+
+//variable as member extension
+interface C
+
+interface D {
+    val C.foo: Foo
+
+    fun test(c: C) {
+        c.foo()
+
+        with (c) {
+            foo()
+        }
+    }
+}
+
+fun test(d: D, c: C) {
+    with (d) {
+        c.foo()
+
+        with (c) {
+            foo()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMember.fir.kt

@@ -0,0 +1,60 @@
+class Foo {
+    operator fun invoke() {}
+}
+
+//no variable
+fun test(foo: Foo) {
+    foo()
+}
+
+//variable as member
+interface A {
+    val foo: Foo
+}
+
+fun test(a: A) {
+    a.foo()
+
+    with (a) {
+        foo()
+    }
+}
+
+//variable as extension
+interface B {}
+val B.foo: Foo
+    get() = Foo()
+
+
+fun test(b: B) {
+    b.foo()
+
+    with (b) {
+        foo()
+    }
+}
+
+//variable as member extension
+interface C
+
+interface D {
+    val C.foo: Foo
+
+    fun test(c: C) {
+        c.foo()
+
+        with (c) {
+            foo()
+        }
+    }
+}
+
+fun test(d: D, c: C) {
+    with (d) {
+        c.foo()
+
+        with (c) {
+            foo()
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtension.fir.kt

@@ -0,0 +1,123 @@
+class Foo
+
+//no variable
+interface A {
+    operator fun Foo.invoke() {}
+
+    fun test(foo: Foo) {
+        foo()
+    }
+}
+
+//variable as member
+interface B {
+    val foo: Foo
+}
+
+class C {
+    operator fun Foo.invoke() {}
+
+    fun test(b: B) {
+        b.foo()
+
+        with (b) {
+            foo()
+        }
+    }
+}
+
+fun test(c: C, b: B) {
+    with (c) {
+        b.foo()
+
+        with (b) {
+            foo()
+        }
+    }
+}
+
+
+//variable as extension,
+interface D {
+}
+val D.foo: Foo
+    get() = Foo()
+
+class E {
+    operator fun Foo.invoke() {}
+
+    fun test(d: D) {
+        d.foo()
+
+        with (d) {
+            foo()
+        }
+    }
+}
+
+fun test(e: E, d: D) {
+    with (e) {
+        d.foo()
+
+        with (d) {
+            foo()
+        }
+    }
+}
+
+//variable as member extension
+interface F
+
+interface G {
+    val F.foo: Foo
+    operator fun Foo.invoke()
+
+    fun test(f: F) {
+        f.foo()
+
+        with (f) {
+            foo()
+        }
+    }
+}
+
+fun test(g: G, f: F) {
+    with (g) {
+        f.foo()
+
+        with (f) {
+            foo()
+        }
+    }
+}
+
+//variable as member extension (2)
+interface X
+
+interface U {
+    val X.foo: Foo
+}
+
+interface V {
+    operator fun Foo.invoke() {}
+
+    fun U.test(x: X) {
+        x.foo()
+
+        with (x) {
+            foo()
+        }
+    }
+}
+
+fun test(u: U, v: V, x: X) {
+    with (v) {
+        with (u) {
+            x.foo()
+
+            with (x) {
+                foo()
+            }
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/invoke/invokeAsMemberExtensionToExplicitReceiver.fir.kt

@@ -0,0 +1,12 @@
+interface A
+interface Foo {
+    operator fun A.invoke()
+}
+
+fun test(a: A, foo: Foo) {
+    a.<!UNRESOLVED_REFERENCE!>foo<!>()
+}
+
+fun test(a: Int, foo: Int.()->Unit) {
+    a.<!UNRESOLVED_REFERENCE!>foo<!>()
+}

compiler/testData/diagnostics/tests/resolve/invoke/invokeNonExtensionLambdaInContext.fir.kt

@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -UNUSED_ANONYMOUS_PARAMETER
+
+class C {
+    fun f() {}
+}
+
+fun C.g(f: (String) -> Unit = { s -> f() }) {}

compiler/testData/diagnostics/tests/resolve/invoke/invokeOnVariableWithExtensionFunctionType.fir.kt

@@ -0,0 +1,84 @@
+// !WITH_NEW_INFERENCE
+// FILE: 1.kt
+package fooIsExtension
+
+class A
+class B
+
+val A.foo: B.() -> Unit get() = {}
+
+fun test(a: A, b: B) {
+    b.<!UNRESOLVED_REFERENCE!>(a.foo)()<!>
+    (a.foo)(b)
+    a.foo(b)
+
+    with(a) {
+        b.<!UNRESOLVED_REFERENCE!>foo<!>()
+
+        b.<!UNRESOLVED_REFERENCE!>(foo)()<!>
+
+        <!UNRESOLVED_REFERENCE!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>)()<!>
+
+        foo(b)
+        (foo)(b)
+    }
+
+    with(b) {
+        a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        a.<!UNRESOLVED_REFERENCE!>(foo)()<!>
+
+        <!INAPPLICABLE_CANDIDATE!>(a.foo)()<!>
+
+        (a.foo)(this)
+        a.foo(this)
+    }
+
+    with(a) {
+        with(b) {
+            <!INAPPLICABLE_CANDIDATE!>foo<!>()
+            <!INAPPLICABLE_CANDIDATE!>(foo)()<!>
+        }
+    }
+}
+
+// FILE: 1.kt
+package fooIsMember
+
+class A {
+    val foo: B.() -> Unit get() = {}
+}
+class B
+
+fun test(a: A, b: B) {
+    b.<!UNRESOLVED_REFERENCE!>(a.foo)()<!>
+    (a.foo)(b)
+    a.foo(b)
+
+    with(a) {
+        b.<!UNRESOLVED_REFERENCE!>foo<!>()
+
+        b.<!UNRESOLVED_REFERENCE!>(foo)()<!>
+
+        <!UNRESOLVED_REFERENCE!>(b.<!UNRESOLVED_REFERENCE!>foo<!>)()<!>
+
+        foo(b)
+        (foo)(b)
+    }
+
+    with(b) {
+        a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
+        a.<!UNRESOLVED_REFERENCE!>(foo)()<!>
+
+        <!INAPPLICABLE_CANDIDATE!>(a.foo)()<!>
+
+        (a.foo)(this)
+        a.foo(this)
+    }
+
+    with(a) {
+        with(b) {
+            <!INAPPLICABLE_CANDIDATE!>foo<!>()
+            <!INAPPLICABLE_CANDIDATE!>(foo)()<!>
+        }
+    }
+}

compiler/testData/diagnostics/tests/resolve/invoke/kt3772.fir.kt

@@ -0,0 +1,27 @@
+//KT-3772 Invoke and overload resolution ambiguity
+package bar
+
+open class A {
+    public operator fun invoke(f: A.() -> Unit) {}
+}
+
+class B {
+    public operator fun invoke(f: B.() -> Unit) {}
+}
+
+open class C
+val C.attr: A
+    get() = A()
+
+open class D: C()
+val D.attr: B
+    get() = B()
+
+
+fun main() {
+    val b =  D()
+    b.attr {} // overload resolution ambiguity
+
+    val d = b.attr
+    d {}      // no error
+}

compiler/testData/diagnostics/tests/resolve/invoke/kt3833-invokeInsideNestedClass.fir.kt

@@ -0,0 +1,35 @@
+//KT-3833 Invoke method not working inside companion object?
+package m
+
+class Either1 {
+    class Left() {
+        fun match(left: () -> Unit) {
+            left()
+        }
+    }
+
+    inner class Right() {
+        fun match(right: () -> Unit) {
+            right()
+        }
+    }
+}
+
+
+class X {
+    operator fun invoke() {
+    }
+}
+
+object Foo{
+    val v : X = X()
+}
+
+class C{
+    companion object {
+        fun f(){
+            Foo.v()
+        }
+    }
+}
+

compiler/testData/diagnostics/tests/resolve/invoke/kt4204-completeNestedCallsForInvoke.fir.kt

@@ -0,0 +1,24 @@
+//KT-4204 ConstraintSystem erased after resolution completion
+package c
+
+public abstract class TestBug1() {
+
+    public fun m3(position: Int) {
+        position(m1().second!!)
+    }
+
+    public fun m4(position: (Int)->Int) {
+        position(m1().second)
+    }
+
+    private abstract fun m1(): Pair<Int, Int>
+
+    private fun position(p: Int) {}
+
+}
+
+//from library
+public class Pair<out A, out B> (
+        public val first: A,
+        public val second: B
+)

compiler/testData/diagnostics/tests/resolve/invoke/kt4321InvokeOnEnum.fir.kt

@@ -0,0 +1,35 @@
+//KT-4321 invoke() on enum doesn't work
+
+import DOMElementTestClasses.cls2
+
+// use case 1
+enum class DOMElementTestClasses {
+    cls1, cls2;
+
+    operator fun invoke() {}
+}
+
+
+// use case 2
+interface EnumStyleClass {
+    operator fun invoke() {}
+}
+enum class TestClasses : EnumStyleClass {
+    cls
+}
+
+// example
+fun main() {
+    // Kotlin: Expression 'cls1' of type 'DOMElementTestClasses' cannot be invoked as a function
+    DOMElementTestClasses.cls1()
+
+    // Kotlin: Expression 'cls2' of type 'DOMElementTestClasses' cannot be invoked as a function
+    cls2()
+
+    // Kotlin: Expression 'cls' of type 'TestClasses' cannot be invoked as a function
+    TestClasses.cls()
+
+    // All ok
+    val cls = DOMElementTestClasses.cls2
+    cls()
+}

compiler/testData/diagnostics/tests/resolve/invoke/kt9517.fir.kt

@@ -0,0 +1,16 @@
+
+//KT-9517 Wrong resolve for invoke convention after smart cast
+open class A {
+    open val foo: () -> Number = null!!
+}
+
+class B: A() {
+    override val foo: () -> Int
+        get() = null!!
+}
+
+fun test(a: A) {
+    if (a is B) {
+        val foo: Int = a.foo() // B::foo + invoke()
+    }
+}

compiler/testData/diagnostics/tests/resolve/invoke/kt9805.fir.kt

@@ -0,0 +1,17 @@
+class A {
+    val foo: B.() -> Unit get() = null!!
+}
+
+class B
+
+fun test(a: A, b: B) {
+    with(b) {
+        a.<!INAPPLICABLE_CANDIDATE!>foo<!>() // here must be error, because a is not extension receiver
+
+        a.foo(this)
+
+        <!INAPPLICABLE_CANDIDATE!>(a.foo)()<!>
+
+        (a.foo)(this)
+    }
+}

compiler/testData/diagnostics/tests/resolve/invoke/reportFunctionExpectedWhenOneInvokeExist.fir.kt

@@ -0,0 +1,13 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun Int.invoke() {}
+
+class SomeClass
+
+fun test(identifier: SomeClass, fn: String.() -> Unit) {
+    <!INAPPLICABLE_CANDIDATE!>identifier<!>()
+    <!INAPPLICABLE_CANDIDATE!>identifier<!>(123)
+    <!INAPPLICABLE_CANDIDATE!>identifier<!>(1, 2)
+    1.<!UNRESOLVED_REFERENCE!>fn<!>()
+}

compiler/testData/diagnostics/tests/resolve/invoke/valNamedInvoke.fir.kt

@@ -0,0 +1,9 @@
+interface A
+
+fun foo(invoke: A.()->Unit, a: A) {
+    a.<!UNRESOLVED_REFERENCE!>invoke<!>()
+}
+
+fun bar(invoke: Any.()->Any, a: Any) {
+    a.<!UNRESOLVED_REFERENCE!>invoke<!>()
+}

compiler/testData/diagnostics/tests/resolve/invoke/wrongInvokeExtension.fir.kt

@@ -0,0 +1,18 @@
+class B
+
+class A {
+    operator fun B.invoke() {}
+}
+
+val B.a: () -> Int  get() = { 5 }
+
+fun test(a: A, b: B) {
+    val x: Int = b.a()
+
+    b.<!UNRESOLVED_REFERENCE!>(a)()<!>
+
+    with(b) {
+        val y: Int = <!UNRESOLVED_REFERENCE!>a<!>()
+        <!UNRESOLVED_REFERENCE!>(a)()<!>
+    }
+}

compiler/testData/diagnostics/tests/resolve/localObject.fir.kt

@@ -0,0 +1,4 @@
+fun foo(): Any {
+    object Bar
+    return Bar
+}

compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeArgsInFreeExpressionPosition.fir.kt

@@ -0,0 +1,12 @@
+class A {
+    companion object {
+
+    }
+}
+
+fun use(vararg a: Any?) = a
+
+fun test() {
+    use(use(A, null).toString())
+}
+

compiler/testData/diagnostics/tests/resolve/nestedCalls/analyzeUnmappedArguments.fir.kt

@@ -0,0 +1,9 @@
+package c
+
+fun test() {
+    with (1) l@ {
+        <!INAPPLICABLE_CANDIDATE!>foo<!>(1, zz = { this@l } )
+    }
+}
+
+fun foo(x: Int) = x

compiler/testData/diagnostics/tests/resolve/nestedCalls/argumentsInParentheses.fir.kt

@@ -0,0 +1,20 @@
+interface Foo<T>
+
+class Bar {
+    operator fun <T> invoke(): Foo<T> = throw Exception()
+}
+
+class A {
+    val bar = Bar()
+}
+
+fun fooInt(l: Foo<Int>) = l
+
+fun test(bar: Bar, a: A) {
+    // no elements with error types
+    fooInt((bar()))
+    fooInt(if (true) bar() else bar())
+    fooInt(label@ bar())
+    fooInt(a.bar())
+    fooInt(((label@ if (true) (a.bar()) else bar())))
+}

compiler/testData/diagnostics/tests/resolve/nestedCalls/completeTypeInferenceForNestedInNoneApplicable.fir.kt

@@ -0,0 +1,11 @@
+// !WITH_NEW_INFERENCE
+package h
+
+fun foo(i: Int) = i
+fun foo(s: String) = s
+
+fun test() {
+    <!INAPPLICABLE_CANDIDATE!>foo<!>(emptyList())
+}
+
+fun <T> emptyList(): List<T> {throw Exception()}

compiler/testData/diagnostics/tests/resolve/nestedCalls/completeUnmappedArguments.fir.kt

@@ -0,0 +1,14 @@
+package c
+
+fun zzz(i: Int, f: (Int) -> Int) { throw Exception("$i $f")}
+
+fun test() {
+    fun foo(): Int = 42
+
+    fun bar(i: Int) = i
+
+    bar(<!INAPPLICABLE_CANDIDATE!>foo<!>(xx = zzz(11) { j: Int -> j + 7 }))
+
+    <!INAPPLICABLE_CANDIDATE!>bar<!>(zz = <!INAPPLICABLE_CANDIDATE!>foo<!>(
+      xx = zzz(12) { i: Int -> i + i }))
+}

compiler/testData/diagnostics/tests/resolve/nestedCalls/kt5971NestedSafeCall.fir.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+//KT-5971 Missing error when fun argument is safe call
+
+fun foo(i: Int) {}
+
+fun test(s: String?) {
+    foo(s?.length)
+}

compiler/testData/diagnostics/tests/resolve/nestedCalls/kt7597.fir.kt

@@ -0,0 +1,8 @@
+interface Inv<I>
+
+fun <S, T: S> Inv<T>.reduce2(): S = null!!
+
+fun test(a: Inv<Int>): Int {
+    val b = 1 + a.reduce2()
+    return b
+}

compiler/testData/diagnostics/tests/resolve/nestedCalls/manyInapplicableCandidatesWithLambdas.fir.kt

@@ -0,0 +1,53 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+class A
+class B
+class C
+class D
+
+fun A.bar(x: Int = 0) = ""
+fun A.bar(x: Int = 0, y: D.() -> Unit) = ""
+
+fun B.bar(x: Int = 0) = ""
+fun B.bar(x: Int = 0, y: D.() -> Unit) = ""
+
+fun C.bar(x: Int = 0) = ""
+fun C.bar(x: Int = 0, y: D.() -> Unit) = ""
+
+class E {
+    fun foo() {
+        // `bar` calls are inapplicable since both E nor D aren't proper receivers
+        // But prior to this change, every lambda was analyzed repeatedly for every candidate
+        // Thus, the resulting time was exponential
+        <!INAPPLICABLE_CANDIDATE!>bar<!> {
+            <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                    <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                        <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                            <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                                <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                                    <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                                        <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                                            <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                                                <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                                                    <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                                                        <!INAPPLICABLE_CANDIDATE!>bar<!> {
+                                                            <!INAPPLICABLE_CANDIDATE!>bar<!> {
+
+                                                            }
+                                                        }
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+

compiler/testData/diagnostics/tests/resolve/nestedCalls/twoTypeParameters.fir.kt

@@ -0,0 +1,17 @@
+// !WITH_NEW_INFERENCE
+class ResolutionCandidate<A>
+
+class ResolutionTask<B, C : B>(val candidate: ResolutionCandidate<B>)
+
+fun <D, E : D> List<ResolutionTask<D, E>>.bar(t: ResolutionTask<D, E>) = t
+
+public class ResolutionTaskHolder<F, G : F> {
+    fun test(candidate: ResolutionCandidate<F>, tasks: MutableList<ResolutionTask<F, G>>) {
+        tasks.bar(ResolutionTask<F, G>(candidate))
+        tasks.add(ResolutionTask<F, G>(candidate))
+
+        //todo the problem is the type of ResolutionTask is inferred as ResolutionTask<F, F> too early
+        tasks.bar(ResolutionTask(candidate))
+        tasks.add(ResolutionTask(candidate))
+    }
+}

compiler/testData/diagnostics/tests/resolve/newLineLambda.fir.kt

@@ -0,0 +1,118 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+fun noArgs() {}
+fun oneLambdaArg(fn: () -> Unit) {}
+fun twoLambdaArgs(f1: () -> Unit, f2: () -> Unit) {}
+fun varargFn(vararg args: Int) {}
+
+fun testNoArgs() {
+    noArgs()
+    <!INAPPLICABLE_CANDIDATE!>noArgs<!> {}
+    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() {}
+    noArgs() // {}
+    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() /* */ {}
+    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() /*
+        block comment, no new line
+    */ {}
+    <!INAPPLICABLE_CANDIDATE!>noArgs<!>()
+    /*
+        block comment with new line
+    */
+    {}
+    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() // comment
+    // comment
+    {}
+    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() {} {}
+    <!INAPPLICABLE_CANDIDATE!>noArgs<!>() {}
+    {}
+}
+
+fun testLambdaArg() {
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>()
+    oneLambdaArg {}
+    oneLambdaArg()
+    {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>()
+    {}
+    {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>(
+        {},
+        {}
+    )
+    oneLambdaArg() {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() // {}
+    oneLambdaArg() /* */ {}
+    oneLambdaArg() /*
+        block
+        comment
+    */ {}
+    oneLambdaArg() // comment
+    // comment
+    {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {}/*
+        block comment, no new line
+    */ {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {}/*
+        block comment with new line
+    */
+    {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {}// comment
+    // comment
+    {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {} {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {}
+    {}
+    <!INAPPLICABLE_CANDIDATE!>oneLambdaArg<!>() {} // comment
+    {}
+}
+
+fun testVararg() {
+    varargFn(1,2,3)
+    <!INAPPLICABLE_CANDIDATE!>varargFn<!> {}
+    <!INAPPLICABLE_CANDIDATE!>varargFn<!>(1,2,3) {}
+    varargFn(1,2,3) // {}
+    <!INAPPLICABLE_CANDIDATE!>varargFn<!>(1,2,3) /* */ {}
+    <!INAPPLICABLE_CANDIDATE!>varargFn<!>(1,2,3) /*
+        block comment, no new line
+    */ {}
+    <!INAPPLICABLE_CANDIDATE!>varargFn<!>(1,2,3)
+    /*
+        block comment with new line
+    */ {}
+    <!INAPPLICABLE_CANDIDATE!>varargFn<!>(1,2,3) // comment
+    // comment
+    {}
+    <!INAPPLICABLE_CANDIDATE!>varargFn<!>(1,2,3) {} {}
+    <!INAPPLICABLE_CANDIDATE!>varargFn<!>(1,2,3) {}
+    {}
+}
+
+fun testTwoLambdas() {
+    twoLambdaArgs(
+        f1 = {},
+        f2 =
+        {}
+    )
+
+    fun bar(): () -> Unit {
+        <!INAPPLICABLE_CANDIDATE!>twoLambdaArgs<!>()
+        {}
+        {}
+
+        return if (true) {
+            <!INAPPLICABLE_CANDIDATE!>twoLambdaArgs<!>({})
+            {}
+            {}
+        } else {
+            {}
+        }
+    }
+}
+
+fun f1(): (() -> Unit) -> (() -> Unit) -> Unit {
+    return { l1 ->
+        <!INAPPLICABLE_CANDIDATE!>l1<!>()
+        { l2 -> <!UNRESOLVED_REFERENCE!>l2<!>() }
+    }
+}

compiler/testData/diagnostics/tests/resolve/noCandidates/kt2787.fir.kt

@@ -0,0 +1,6 @@
+interface MutableMatrix<T> {
+}
+
+fun <T> toMutableMatrix(): MutableMatrix<T> {
+    return <!UNRESOLVED_REFERENCE!>MutableMatrix<!><T>()
+}

compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifier.fir.kt

@@ -0,0 +1,19 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+interface A
+
+object B
+class C
+
+fun test() {
+    val interface_as_fun = <!UNRESOLVED_REFERENCE!>A<!>()
+    val interface_as_val = A
+
+    val object_as_fun = <!INAPPLICABLE_CANDIDATE!>B<!>()
+    val class_as_val = C
+}
+
+fun <T> bar() {
+    val typeParameter_as_val = <!OTHER_ERROR, OTHER_ERROR!>T<!>
+    val typeParameter_as_fun = <!UNRESOLVED_REFERENCE!>T<!>()
+}

compiler/testData/diagnostics/tests/resolve/noCandidates/resolvedToClassifierWithReceiver.fir.kt

@@ -0,0 +1,39 @@
+// !DIAGNOSTICS: -UNUSED_VARIABLE
+
+object X {
+    interface A
+
+    object B
+    class C
+}
+
+fun testX() {
+    val interface_as_fun = X.<!UNRESOLVED_REFERENCE!>A<!>()
+    val interface_as_val = X.A
+
+    val object_as_fun = X.<!INAPPLICABLE_CANDIDATE!>B<!>()
+    val class_as_val = X.C
+}
+
+class Y {
+    interface A
+
+    object B
+    class C
+}
+
+fun testY() {
+    val interface_as_fun = Y.<!UNRESOLVED_REFERENCE!>A<!>()
+    val interface_as_val = Y.A
+
+    val object_as_fun = Y.<!INAPPLICABLE_CANDIDATE!>B<!>()
+    val class_as_val = Y.C
+}
+
+fun test(x: X) {
+    val interface_as_fun = x.<!UNRESOLVED_REFERENCE!>A<!>()
+    val interface_as_val = x.A
+
+    val object_as_fun = x.<!INAPPLICABLE_CANDIDATE!>B<!>()
+    val class_as_val = x.C
+}

compiler/testData/diagnostics/tests/resolve/objectLiteralAsArgument.fir.kt

@@ -0,0 +1,36 @@
+//If this test hangs, it means something is broken.
+object A {
+    val iii = 42
+}
+
+//inappropriate but participating in resolve functions
+fun foo(s: String, a: Any) = s + a
+
+fun foo(a: Any, s: String) = s + a
+fun foo(i: Int, j: Int) = i + j
+fun foo(a: Any, i: Int) = "$a$i"
+fun foo(f: (Int) -> Int, i: Int) = f(i)
+fun foo(f: (String) -> Int, s: String) = f(s)
+fun foo(f: (Any) -> Int, a: Any) = f(a)
+fun foo(s: String, f: (String) -> Int) = f(s)
+fun foo(a: Any, f: (Any) -> Int) = f(a)
+//appropriate function
+fun foo(i: Int, f: (Int) -> Int) = f(i)
+
+fun test() {
+    foo(1, object : (Int) -> Int {
+        override fun invoke(x1: Int) = foo(
+                2, object : (Int) -> Int {
+            override fun invoke(x2: Int) = foo(
+                    3, object : (Int) -> Int {
+                override fun invoke(x3: Int): Int = foo(
+                        4, object : (Int) -> Int {
+                    override fun invoke(x4: Int): Int = foo(
+                            5, object : (Int) -> Int {
+                        override fun invoke(x5: Int): Int = x1 + x2 + x3 + x4 + x5 + A.iii
+                    })
+                })
+            })
+        })
+    })
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/allLambdas.fir.kt

@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object X1
+object X2
+
+fun <T1> foo(x: T1, f: (T1) -> T1) = X1
+fun <T2> foo(xf: () -> T2, f: (T2) -> T2) = X2
+
+val test: X2 = <!AMBIGUITY!>foo<!>({ 0 }, { it -> it + 1 })

compiler/testData/diagnostics/tests/resolve/overloadConflicts/extensionReceiverAndVarargs.fir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+interface IA
+interface IB : IA
+fun IA.foo(vararg x: Int) = Wrong
+fun IB.foo(vararg x: Int) = Right
+class CC : IB
+
+val test7 = CC().foo(1, 2, 3)

compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericClash.fir.kt

@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// !WITH_NEW_INFERENCE
+
+interface A<T> {
+    fun foo(x: T)
+    fun foo(x: String)
+
+    fun <E> baz(x: E, y: String)
+    fun <E> baz(x: String, y: E)
+}
+
+fun <E> baz(x: E, y: String) {}
+fun <E> baz(x: String, y: E) {}
+
+fun bar(x: A<String>) {
+    x.<!AMBIGUITY!>foo<!>("")
+
+    x.<!AMBIGUITY!>baz<!>("", "")
+    <!AMBIGUITY!>baz<!>("", "")
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/genericWithProjection.fir.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER -REDUNDANT_PROJECTION
+
+class In<in T>() {
+    fun f(t : T) {}
+    fun f(t : Int) = t
+}
+
+fun test1(x: In<String>): Unit = x.f("1")
+fun test2(x: In<in String>): Unit = x.f("1")
+fun test3(x: In<out String>): Unit = x.f("1")
+fun test4(x: In<*>): Unit = x.f("1")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10472.fir.kt

@@ -0,0 +1,13 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+interface A<T>
+interface B<T> : A<T>
+
+fun <T> foo(vararg t: T) = Wrong
+fun <T> foo(t: A<T>) = Wrong
+fun <T> foo(t: B<T>) = Right
+
+fun test(b: B<Int>): Right = foo(b)

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt10640.fir.kt

@@ -0,0 +1,10 @@
+// !WITH_NEW_INFERENCE
+interface AutoCloseable
+interface Closeable : AutoCloseable
+
+fun <T1 : AutoCloseable, R1> T1.myUse(f: (T1) -> R1): R1 = f(this)
+fun <T2 : Closeable, R2> T2.myUse(f: (T2) -> R2): R2 = f(this)
+
+fun test1(x: Closeable) = x.myUse { 42 }
+fun test2(x: Closeable) = x.myUse<Closeable, Int> { 42 }
+fun test3(x: Closeable) = x.myUse<AutoCloseable, Int> { 42 } // TODO KT-10681

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670.fir.kt

@@ -0,0 +1,16 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_NEW_INFERENCE
+
+open class A<T>(val value: T)
+class B<T>(value: T) : A<T>(value)
+
+fun <T> A<T>.foo(block: (T?) -> Unit) {
+    block(value)
+}
+fun <T> B<T>.foo(block: (T) -> Unit) {
+    block(value)
+}
+
+fun main() {
+    B("string").<!AMBIGUITY!>foo<!> {  }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31670_compat.fir.kt

@@ -0,0 +1,16 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_OLD_INFERENCE
+
+open class A<T>(val value: T)
+class B<T>(value: T) : A<T>(value)
+
+fun <T> A<T>.foo(block: (T?) -> Unit) {
+    block(value)
+}
+fun <T> B<T>.foo(block: (T) -> Unit) {
+    block(value)
+}
+
+fun main() {
+    B("string").<!AMBIGUITY!>foo<!> {  }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758.fir.kt

@@ -0,0 +1,26 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: a.kt
+
+package a
+
+enum class A { A1 }
+
+fun <T : Enum<T>> foo(arg: T.() -> Unit) = 1
+
+// FILE: b.kt
+
+package b
+
+fun <T : Any> foo(arg: T.() -> Unit) = 2
+
+// FILE: test.kt
+
+import a.*
+import b.*
+
+fun test() {
+    <!AMBIGUITY!>foo<!><A> { }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/kt31758_compat.fir.kt

@@ -0,0 +1,26 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_OLD_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: a.kt
+
+package a
+
+enum class A { A1 }
+
+fun <T : Enum<T>> foo(arg: T.() -> Unit) = 1
+
+// FILE: b.kt
+
+package b
+
+fun <T : Any> foo(arg: T.() -> Unit) = 2
+
+// FILE: test.kt
+
+import a.*
+import b.*
+
+fun test() {
+    <!AMBIGUITY!>foo<!><A> { }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/numberOfDefaults.fir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+fun overloadedFun(c: Any = "", b: String = "", f: Any = "") = Right
+fun overloadedFun(b: Any = "", c: Any = "", e: String = "", x: String = "", y: String = "") = Wrong
+
+val test: Right = overloadedFun(b = "")
+

compiler/testData/diagnostics/tests/resolve/overloadConflicts/originalExamples.fir.kt

@@ -0,0 +1,21 @@
+// !WITH_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+fun overloadedFun1(c: Any = "", b: String = "", f: Any = "") = Right
+fun overloadedFun1(b: Any = "", c: Any = "", e: String = "") = Wrong
+
+val test1: Right = overloadedFun1(b = "")
+val test1a: Wrong = overloadedFun1(b = "")
+
+fun overloadedFun2(a: String, b: Any = "") = Right
+fun overloadedFun2(a: Any, b: String = "") = Wrong
+
+val test2: Right = overloadedFun2("")
+
+fun overloadedFun2a(a: Any, b: String = "") = Wrong
+fun overloadedFun2a(a: String, b: Any = "") = Right
+
+val test2a: Right = overloadedFun2a("")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter.fir.kt

@@ -0,0 +1,24 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_NEW_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: a.kt
+
+package a
+
+fun <T> foo(block: (T?) -> Unit) {}
+
+// FILE: b.kt
+
+package b
+
+fun <K> foo(block: (K) -> Unit) {}
+
+// FILE: test.kt
+
+import a.*
+import b.*
+
+fun main() {
+    foo<String> {  }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/overloadResolutionOnNullableContravariantParameter_compat.fir.kt

@@ -0,0 +1,24 @@
+// !WITH_NEW_INFERENCE
+// !CONSTRAINT_SYSTEM_FOR_OVERLOAD_RESOLUTION: CONSTRAINT_SYSTEM_FOR_OLD_INFERENCE
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+// FILE: a.kt
+
+package a
+
+fun <T> foo(block: (T?) -> Unit) {}
+
+// FILE: b.kt
+
+package b
+
+fun <K> foo(block: (K) -> Unit) {}
+
+// FILE: test.kt
+
+import a.*
+import b.*
+
+fun main() {
+    foo<String> {  }
+}

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargWithMoreSpecificSignature.fir.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Foo1
+object Foo2
+
+fun foo(vararg ss: String) = Foo1
+fun foo(x: Any) = Foo2
+
+val test1: Foo1 = foo("")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargs.fir.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object Right
+object Wrong
+
+fun overloadedFun6(s1: String) = Right
+fun overloadedFun6(s1: String, s2: String) = Wrong
+fun overloadedFun6(s1: String, s2: String, s3: String) = Wrong
+fun overloadedFun6(s: String, vararg ss: String) = Wrong
+
+val test6: Right = overloadedFun6("")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsInDifferentPositions.fir.kt

@@ -0,0 +1,13 @@
+// !LANGUAGE: +ProhibitAssigningSingleElementsToVarargsInNamedForm
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object X1
+object X2
+
+fun overloadedFun(arg: String, vararg args: String) = X1
+fun overloadedFun(arg: String, vararg args: String, flag: Boolean = true) = X2
+
+val test1a: X1 = overloadedFun("", "")
+val test1b: X1 = overloadedFun("", args = "")
+val test1c: X2 = overloadedFun("", "", "", flag = true)
+

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsMixed.fir.kt

@@ -0,0 +1,13 @@
+// !LANGUAGE: +ProhibitAssigningSingleElementsToVarargsInNamedForm
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+
+object X1
+object X2
+
+fun overloadedFun5(vararg ss: String) = X1
+fun overloadedFun5(s: String, vararg ss: String) = X2
+
+val test1 = overloadedFun5("")
+val test2 = overloadedFun5("", "")
+val test3: X2 = overloadedFun5(s = "", ss = "")
+val test4: X1 = overloadedFun5(ss = "")

compiler/testData/diagnostics/tests/resolve/overloadConflicts/varargsWithRecursiveGenerics.fir.kt

@@ -0,0 +1,21 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER
+// FILE: J.java
+import java.util.*;
+
+public class J {
+    public static <E1 extends Enum<E1>> String foo(E1 e) { return ""; }
+    public static <E2 extends Enum<E2>> String foo(E2 e1, E2 e2) { return ""; }
+    public static <E3 extends Enum<E3>> String foo(E3 s1, E3 s2, E3 s3) { return ""; }
+    public static <E4 extends Enum<E4>> int foo(E4... ss) { return 0; }
+}
+
+// FILE: test.kt
+enum class X { A }
+val a = X.A
+
+val test0: Int = J.foo<X>()
+val test1: String = J.foo(a)
+val test2: String = J.foo(a, a)
+val test3: String = J.foo(a, a, a)
+val test4: Int = J.foo(a, a, a, a)
+val test5: Int = J.foo(a, a, a, a, a)