FIR: introduce & use REFERENCE_BY_QUALIFIER positioning strategy

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

@@ -33,8 +33,8 @@ operator fun CustomDelegate3.setValue(thisRef: Any?, prop: KProperty<*>, value:
 
 class Example {
 
-    var a by <!INAPPLICABLE_CANDIDATE!>CustomDelegate()<!>
-    val aval by <!INAPPLICABLE_CANDIDATE!>CustomDelegate()<!>
+    var a by <!INAPPLICABLE_CANDIDATE!>CustomDelegate<!>()
+    val aval by <!INAPPLICABLE_CANDIDATE!>CustomDelegate<!>()
     var b by OkDelegate()
     var c by CustomDelegate2()
     var d by CustomDelegate3()

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

@@ -28,20 +28,20 @@ fun <T> fooT2() : (t : T) -> T {
 
 fun main(args : Array<String>) {
     args.foo()()
-    <!INAPPLICABLE_CANDIDATE!>args.foo1()()<!>
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()()<!>
+    args.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
+    <!UNRESOLVED_REFERENCE!>a<!>.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     args.foo1()(1)
-    <!INAPPLICABLE_CANDIDATE!>args.foo1()("1")<!>
-    <!INAPPLICABLE_CANDIDATE!><!UNRESOLVED_REFERENCE!>a<!>.foo1()("1")<!>
+    args.<!INAPPLICABLE_CANDIDATE!>foo1<!>()("1")
+    <!UNRESOLVED_REFERENCE!>a<!>.<!INAPPLICABLE_CANDIDATE!>foo1<!>()("1")
     <!UNRESOLVED_REFERENCE!>a<!>.foo1()(<!UNRESOLVED_REFERENCE!>a<!>)
 
     foo2()({})
     <!INAPPLICABLE_CANDIDATE!>foo2<!>(){}
     (foo2()){}
-    <!INAPPLICABLE_CANDIDATE!>(foo2()){x -> }<!>
-    <!INAPPLICABLE_CANDIDATE!>foo2()({x -> })<!>
+    <!INAPPLICABLE_CANDIDATE!>(foo2())<!>{x -> }
+    <!INAPPLICABLE_CANDIDATE!>foo2<!>()({x -> })
 
     val a = fooT1(1)()
     checkSubtype<Int>(a)
@@ -50,25 +50,25 @@ fun main(args : Array<String>) {
     checkSubtype<Int>(b)
     fooT2()(1) // : Any?
 
-    <!UNRESOLVED_REFERENCE!>1()<!>
-    <!UNRESOLVED_REFERENCE!>1{}<!>
-    <!UNRESOLVED_REFERENCE!>1(){}<!>
+    <!UNRESOLVED_REFERENCE!>1<!>()
+    <!UNRESOLVED_REFERENCE!>1<!>{}
+    <!UNRESOLVED_REFERENCE!>1<!>(){}
 }
 
 fun f() :  Int.() -> Unit = {}
 
 fun main1() {
-    1.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>;
+    1.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>();
     {1}();
     (fun (x : Int) = x)(1)
-    1.<!UNRESOLVED_REFERENCE!>(fun Int.(x : Int) = x)(1)<!>;
+    1.<!UNRESOLVED_REFERENCE!>(fun Int.(x : Int) = x)<!>(1);
     l@{1}()
-    1.<!UNRESOLVED_REFERENCE!>((fun Int.() = 1))()<!>
-    1.<!UNRESOLVED_REFERENCE!>(f())()<!>
-    1.<!UNRESOLVED_REFERENCE!>if(true){f()}else{f()}()<!>
-    1.<!UNRESOLVED_REFERENCE!>if(true)(fun Int.() {})else{f()}()<!>
+    1.<!UNRESOLVED_REFERENCE!>((fun Int.() = 1))<!>()
+    1.<!UNRESOLVED_REFERENCE!>(f())<!>()
+    1.<!UNRESOLVED_REFERENCE!>if(true){f()}else{f()}<!>()
+    1.<!UNRESOLVED_REFERENCE!>if(true)(fun Int.() {})else{f()}<!>()
 
-    1.<!UNRESOLVED_REFERENCE!>"sdf"()<!>
+    1.<!UNRESOLVED_REFERENCE!>"sdf"<!>()
 
     1."sdf"
     1.{}
@@ -76,12 +76,12 @@ fun main1() {
 }
 
 fun test() {
-    <!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}()<!>;
-    <!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)()<!>
-    "sd".<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>
+    <!INAPPLICABLE_CANDIDATE!>{x : Int -> 1}<!>();
+    <!INAPPLICABLE_CANDIDATE!>(fun Int.() = 1)<!>()
+    "sd".<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>()
     val i : Int? = null
-    i.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>;
-    <!INAPPLICABLE_CANDIDATE!>{}<Int>()<!>
-    1?.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)()<!>
-    1.<!UNRESOLVED_REFERENCE!>{}()<!>
+    i.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>();
+    <!INAPPLICABLE_CANDIDATE!>{}<!><Int>()
+    1?.<!UNRESOLVED_REFERENCE!>(fun Int.() = 1)<!>()
+    1.<!UNRESOLVED_REFERENCE!>{}<!>()
 }

compiler/testData/diagnostics/tests/annotations/options/targets/field.fir.kt

@@ -28,7 +28,7 @@ abstract class My(@Field arg: Int, @Field val w: Int) {
     fun foo() {}
 
     @Field
-    val v: Int by <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>Delegates<!>.<!UNRESOLVED_REFERENCE!>lazy<!> { 42 }<!>
+    val v: Int by <!UNRESOLVED_REFERENCE!>Delegates<!>.<!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>lazy<!> { 42 }
 }
 
 enum class Your {

compiler/testData/diagnostics/tests/callableReference/function/fakeOverrideType.fir.kt

@@ -13,5 +13,5 @@ class B : A() {
 fun test() {
     B::foo checkType { _<KFunction2<B, String, String>>() }
 
-    <!INAPPLICABLE_CANDIDATE!>(B::hashCode)("No.")<!>
+    <!INAPPLICABLE_CANDIDATE!>(B::hashCode)<!>("No.")
 }

compiler/testData/diagnostics/tests/controlFlowAnalysis/fieldAsClassDelegate.fir.kt

@@ -29,7 +29,7 @@ private fun <T> lazy(init: () -> T): <!UNRESOLVED_REFERENCE!>kotlin.Lazy<T><!> {
 }
 
 object DefaultHttpClientWithBy : HttpClient by client {
-    val client by <!UNRESOLVED_REFERENCE!>lazy { HttpClientImpl() }<!>
+    val client by <!UNRESOLVED_REFERENCE!>lazy<!> { HttpClientImpl() }
 }
 
 object DefaultFqHttpClient : HttpClient by DefaultFqHttpClient.client {

compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_3.fir.kt

@@ -11,7 +11,7 @@ fun test() {
     const val <T> a3 = 0
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
     val <T> a5 by Delegate<Int>()
-    val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
+    val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
 }
 
 class Delegate<F> {

compiler/testData/diagnostics/tests/declarationChecks/localVariablesWithTypeParameters_1_4.fir.kt

@@ -11,7 +11,7 @@ fun test() {
     const val <T> a3 = 0
     <!INAPPLICABLE_LATEINIT_MODIFIER!>lateinit<!> val <T> a4 = 0
     val <T> a5 by Delegate<Int>()
-    val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<<!UNRESOLVED_REFERENCE!>T<!>>()<!>
+    val <T> a6 by <!INAPPLICABLE_CANDIDATE!>Delegate<!><<!UNRESOLVED_REFERENCE!>T<!>>()
 }
 
 class Delegate<F> {

compiler/testData/diagnostics/tests/declarationChecks/namedFunAsLastExpressionInBlock.fir.kt

@@ -45,7 +45,7 @@ fun test() {
     x4 checkType { _<Function1<Int, Unit>>() }
 
     { y: Int -> fun named14(): Int {return 1} }
-    val b = <!UNRESOLVED_REFERENCE!>(<!EXPRESSION_REQUIRED!>fun named15(): Boolean { return true }<!>)()<!>
+    val b = <!UNRESOLVED_REFERENCE!>(<!EXPRESSION_REQUIRED!>fun named15(): Boolean { return true }<!>)<!>()
 
     baz(<!EXPRESSION_REQUIRED!>fun named16(){}<!>)
 }

compiler/testData/diagnostics/tests/delegatedProperty/incompleteTypeInference.fir.kt

@@ -5,10 +5,10 @@ import kotlin.reflect.KProperty
 class A
 
 class D {
-    val c: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<A>()<!>
+    val c: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<!><A>()
 }
 
-val cTopLevel: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<A>()<!>
+val cTopLevel: Int by <!UNRESOLVED_REFERENCE!>IncorrectThis<!><A>()
 
 class IncorrectThis<T> {
     fun <R> get(t: Any?, p: KProperty<*>): Int {

compiler/testData/diagnostics/tests/delegatedProperty/inference/extensionProperty.fir.kt

@@ -4,10 +4,10 @@ package foo
 import kotlin.reflect.KProperty
 
 open class A {
-    val B.w: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty()<!>
+    val B.w: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
 }
 
-val B.r: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty()<!>
+val B.r: Int by <!INAPPLICABLE_CANDIDATE!>MyProperty<!>()
 
 val A.e: Int by MyProperty()
 

compiler/testData/diagnostics/tests/delegatedProperty/inference/manyIncompleteCandidates.fir.kt

@@ -5,7 +5,7 @@ package test
 import first.*
 import second.*
 
-val a12 by <!AMBIGUITY!>A()<!>
+val a12 by <!AMBIGUITY!>A<!>()
 
 // FILE: first.kt
 package first

compiler/testData/diagnostics/tests/delegatedProperty/kt4640.fir.kt

@@ -8,4 +8,4 @@ class ValueWrapper()
     fun setValue(v: Int) { backingValue = v }
 }
 
-val foo by <!INAPPLICABLE_CANDIDATE!>ValueWrapper()<!>
+val foo by <!INAPPLICABLE_CANDIDATE!>ValueWrapper<!>()

compiler/testData/diagnostics/tests/delegatedProperty/missedGetter.fir.kt

@@ -1,3 +1,3 @@
-val a: Int by <!UNRESOLVED_REFERENCE!>A()<!>
+val a: Int by <!UNRESOLVED_REFERENCE!>A<!>()
 
 class A

compiler/testData/diagnostics/tests/delegatedProperty/propertyDefferedType.fir.kt

@@ -5,7 +5,7 @@
 import kotlin.reflect.KProperty
 
 class B {
-    val c by <!INAPPLICABLE_CANDIDATE!><!INAPPLICABLE_CANDIDATE!>Delegate<!>(<!UNRESOLVED_REFERENCE!>ag<!>)<!>
+    val c by <!INAPPLICABLE_CANDIDATE, INAPPLICABLE_CANDIDATE!>Delegate<!>(<!UNRESOLVED_REFERENCE!>ag<!>)
 }
 
 class Delegate<T: Any>(val init: T) {

compiler/testData/diagnostics/tests/delegatedProperty/provideDelegate/hostAndReceiver2.fir.kt

@@ -10,5 +10,5 @@ object T2 {
     operator fun <T> Foo<T>.getValue(receiver: String, p: Any?): T = TODO()
 
     val String.test1: String by delegate()
-    val test2: String by <!INAPPLICABLE_CANDIDATE!>delegate()<!>
+    val test2: String by <!INAPPLICABLE_CANDIDATE!>delegate<!>()
 }

compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingNullableType.fir.kt

@@ -4,7 +4,7 @@
 import kotlin.reflect.KProperty
 
 class A {
-  var a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+  var a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 }
 
 var aTopLevel: Int by Delegate()

compiler/testData/diagnostics/tests/delegatedProperty/thisOfNothingType.fir.kt

@@ -4,10 +4,10 @@
 import kotlin.reflect.KProperty
 
 class A {
-  var a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+  var a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 }
 
-var aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+var aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 
 class Delegate {
   fun getValue(t: Nothing, p: KProperty<*>): Int {

compiler/testData/diagnostics/tests/delegatedProperty/twoGetMethods.fir.kt

@@ -3,7 +3,7 @@
 import kotlin.reflect.KProperty
 
 class A {
-    val c: Int by <!NONE_APPLICABLE!>Delegate()<!>
+    val c: Int by <!NONE_APPLICABLE!>Delegate<!>()
 }
 
 class Delegate {

compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForGetWithGeneric.fir.kt

@@ -5,10 +5,10 @@ import kotlin.reflect.KProperty
 class A
 
 class B {
-  val b: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<A>()<!>
+  val b: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!><A>()
 }
 
-val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<A>()<!>
+val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!><A>()
 
 class C {
   val c: Int by Delegate<C>()

compiler/testData/diagnostics/tests/delegatedProperty/typeMismatchForThisGetParameter.fir.kt

@@ -4,10 +4,10 @@
 import kotlin.reflect.KProperty
 
 class B {
-  val b: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+  val b: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 }
 
-val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+val bTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 
 class A
 

compiler/testData/diagnostics/tests/delegatedProperty/wrongCountOfParametersInGet.fir.kt

@@ -3,10 +3,10 @@
 import kotlin.reflect.KProperty
 
 class A {
-  val a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+  val a: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 }
 
-val aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate()<!>
+val aTopLevel: Int by <!INAPPLICABLE_CANDIDATE!>Delegate<!>()
 
 class Delegate {
   fun getValue(t: Any?, p: KProperty<*>, a: Int): Int {

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

@@ -35,7 +35,7 @@ fun test4() {
 // should be an error on receiver, shouldn't be thrown away
 
 fun test5() {
-    1.<!UNRESOLVED_REFERENCE!>(fun String.()=1)()<!>
+    1.<!UNRESOLVED_REFERENCE!>(fun String.()=1)<!>()
 }
 
 fun <R: Any> R?.sure() : R = this!!

compiler/testData/diagnostics/tests/functionLiterals/DeprecatedSyntax.fir.kt

@@ -1,9 +1,9 @@
 // !WITH_NEW_INFERENCE
 val receiver = { Int.(<!SYNTAX!><!>) <!SYNTAX!>-><!> }
-val receiverWithParameter = { Int.(<!UNRESOLVED_REFERENCE!>a<!>) <!SYNTAX!>-><!> }
+val receiverWithParameter = { <!UNRESOLVED_REFERENCE!>Int.(a)<!> <!SYNTAX!>-><!> }
 
 val receiverAndReturnType = { Int.(<!SYNTAX!><!>)<!SYNTAX!>: Int ->  5<!> }
-val receiverAndReturnTypeWithParameter = { Int.(<!UNRESOLVED_REFERENCE!>a<!><!SYNTAX!><!SYNTAX!><!>: Int): Int ->  5<!> }
+val receiverAndReturnTypeWithParameter = { Int.(a<!SYNTAX!><!SYNTAX!><!>: Int): Int ->  5<!> }
 
 val returnType = { (<!SYNTAX!><!>): Int -> 5 }
 val returnTypeWithParameter = { <!COMPONENT_FUNCTION_MISSING!>(b: Int): Int<!> -> 5 }

compiler/testData/diagnostics/tests/functionLiterals/kt6541_extensionForExtensionFunction.fir.kt

@@ -7,4 +7,4 @@ object Z {
     infix fun add(b : Foo.() -> Unit) : Z = Z
 }
 
-val t2 = Z <!INAPPLICABLE_CANDIDATE!>add<!> <!INAPPLICABLE_CANDIDATE!>{ } { }<!>
+val t2 = Z <!INAPPLICABLE_CANDIDATE!>add<!> <!INAPPLICABLE_CANDIDATE!>{ }<!> { }

compiler/testData/diagnostics/tests/incompleteCode/diagnosticWithSyntaxError/valWithNoNameInBlock.fir.kt

@@ -40,7 +40,7 @@ fun foo() {
     property1 = 1
 
     val
-    propertyWithBy by <!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>lazy<!> { 1 }<!>
+    propertyWithBy by <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>lazy<!> { 1 }
 
     val
     propertyWithType: Int

compiler/testData/diagnostics/tests/inference/invokeLambdaAsFunction.fir.kt

@@ -2,6 +2,6 @@ fun test1(i: Int) = { i ->
     i
 }(i)
 
-fun test2() = <!INAPPLICABLE_CANDIDATE!>{ i -> i }()<!>
+fun test2() = <!INAPPLICABLE_CANDIDATE!>{ i -> i }<!>()
 
 fun test3() = { i -> i }(1)

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

@@ -3,5 +3,5 @@ fun Any.foo1() : (i : Int) -> Unit {
 }
 
 fun test(a : Any) {
-    <!INAPPLICABLE_CANDIDATE!>a.foo1()()<!>
+    a.<!INAPPLICABLE_CANDIDATE!>foo1<!>()()
 }

compiler/testData/diagnostics/tests/objects/Objects.fir.kt

@@ -6,13 +6,13 @@ package toplevelObjectDeclarations
 
   <!INAPPLICABLE_CANDIDATE!>class T : Foo {}<!>
 
-  <!INAPPLICABLE_CANDIDATE!>object A<!> : Foo {
+  <!INAPPLICABLE_CANDIDATE!>object A : Foo {
     val x : Int = 2
 
     fun test() : Int {
       return x + foo()
     }
-  }
+  }<!>
 
   object B : A {}
 

compiler/testData/diagnostics/tests/platformTypes/nullabilityWarnings/delegatedProperties.fir.kt

@@ -19,5 +19,5 @@ public class J {
 // FILE: k.kt
 
 var A by J.staticNN
-var B by <!UNSAFE_CALL!>J.staticN<!>
+var B by J<!UNSAFE_CALL!>.<!>staticN
 var C by J.staticJ

compiler/testData/diagnostics/tests/qualifiedExpression/calleeExpressionAsCallExpression.fir.kt

@@ -1,2 +1,2 @@
 // !WITH_NEW_INFERENCE
-val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!UNRESOLVED_REFERENCE!><<!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE!>sdf<!>()()<!><out Any><!>::unwrap<!>
+val unwrapped = <!UNRESOLVED_REFERENCE!>some<!><!UNRESOLVED_REFERENCE!><<!><!UNRESOLVED_REFERENCE!><!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>sdf<!>()()<out Any>::unwrap<!>

compiler/testData/diagnostics/tests/regressions/kt26303.fir.kt

@@ -14,5 +14,5 @@ import foo.foo as invoke
 import foo.invoke
 
 fun main(args: Array<String>) {
-    <!AMBIGUITY!>42()<!>
+    <!AMBIGUITY!>42<!>()
 }

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

@@ -7,5 +7,5 @@ fun Int.invoke(a: Any, i: Int) {}
 fun foo(i: Int) {
     <!AMBIGUITY!>i<!>(1, 1)
 
-    <!AMBIGUITY!>5(1, 2)<!>
+    <!AMBIGUITY!>5<!>(1, 2)
 }

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

@@ -6,5 +6,5 @@ class My {
 
 fun My.foo(i: Int) {
     <!HIDDEN!>i<!>("")
-    <!HIDDEN!>1("")<!>
+    <!HIDDEN!>1<!>("")
 }

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

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

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

@@ -10,5 +10,5 @@ fun foo(s: String, ai: A<Int>) {
 
     <!INAPPLICABLE_CANDIDATE!>s<!>(ai)
 
-    <!INAPPLICABLE_CANDIDATE!>""(ai)<!>
+    <!INAPPLICABLE_CANDIDATE!>""<!>(ai)
 }

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

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

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

@@ -6,5 +6,5 @@ operator fun String.invoke(i: Int) {}
 fun foo(s: String?) {
     <!UNSAFE_IMPLICIT_INVOKE_CALL!>s<!>(1)
 
-    <!UNSAFE_IMPLICIT_INVOKE_CALL!>(s ?: null)(1)<!>
+    <!UNSAFE_IMPLICIT_INVOKE_CALL!>(s ?: null)<!>(1)
 }

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

@@ -1,17 +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)<!>
+    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.(<!INAPPLICABLE_CANDIDATE!>f<!>)(1)
-    11.(<!INAPPLICABLE_CANDIDATE!>f<!>)()
+    11.<!INAPPLICABLE_CANDIDATE!>(f)<!>(1)
+    11.<!INAPPLICABLE_CANDIDATE!>(f)<!>()
 }
 
 fun test3() {
     fun foo(): String.(Int) -> Unit = {}
 
-    1.<!UNRESOLVED_REFERENCE!>(foo())(1)<!>
+    1.<!UNRESOLVED_REFERENCE!>(foo())<!>(1)
 }

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

@@ -6,5 +6,5 @@ fun String.invoke(i: Int) {}
 fun foo(i: Int) {
     <!INAPPLICABLE_CANDIDATE!>i<!>(1)
 
-    <!INAPPLICABLE_CANDIDATE!>1(1)<!>
+    <!INAPPLICABLE_CANDIDATE!>1<!>(1)
 }

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

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

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

@@ -8,7 +8,7 @@ class B
 val A.foo: B.() -> Unit get() = {}
 
 fun test(a: A, b: B) {
-    b.<!UNRESOLVED_REFERENCE!>(a.foo)()<!>
+    b.<!UNRESOLVED_REFERENCE!>(a.foo)<!>()
     (a.foo)(b)
     a.foo(b)
 
@@ -17,7 +17,7 @@ fun test(a: A, b: B) {
 
         b.(foo)()
 
-        <!INAPPLICABLE_CANDIDATE!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>)()<!>
+        <!INAPPLICABLE_CANDIDATE!>(b.<!INAPPLICABLE_CANDIDATE!>foo<!>)<!>()
 
         foo(b)
         (foo)(b)
@@ -25,7 +25,7 @@ fun test(a: A, b: B) {
 
     with(b) {
         a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
-        a.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
+        a.<!INAPPLICABLE_CANDIDATE!>(foo)<!>()
 
         (a.foo)()
 
@@ -50,7 +50,7 @@ class A {
 class B
 
 fun test(a: A, b: B) {
-    b.<!UNRESOLVED_REFERENCE!>(a.foo)()<!>
+    b.<!UNRESOLVED_REFERENCE!>(a.foo)<!>()
     (a.foo)(b)
     a.foo(b)
 
@@ -59,7 +59,7 @@ fun test(a: A, b: B) {
 
         b.(foo)()
 
-        <!UNRESOLVED_REFERENCE!>(b.<!UNRESOLVED_REFERENCE!>foo<!>)()<!>
+        <!UNRESOLVED_REFERENCE!>(b.<!UNRESOLVED_REFERENCE!>foo<!>)<!>()
 
         foo(b)
         (foo)(b)
@@ -67,7 +67,7 @@ fun test(a: A, b: B) {
 
     with(b) {
         a.<!INAPPLICABLE_CANDIDATE!>foo<!>()
-        a.(<!INAPPLICABLE_CANDIDATE!>foo<!>)()
+        a.<!INAPPLICABLE_CANDIDATE!>(foo)<!>()
 
         (a.foo)()
 

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

@@ -1,15 +0,0 @@
-// !WITH_NEW_INFERENCE
-
-fun f(s: String, action: (String.() -> Unit)?) {
-    s.foo().bar().<!UNSAFE_IMPLICIT_INVOKE_CALL!>action<!>()
-}
-
-fun String.foo() = ""
-
-fun String.bar() = ""
-
-// --------------------------------------------------------
-
-val functions: Map<String, () -> Any> = TODO()
-
-fun run(name: String) = <!UNSAFE_IMPLICIT_INVOKE_CALL!>functions[name]()<!>

compiler/testData/diagnostics/tests/safeCall.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !WITH_NEW_INFERENCE
 
 fun f(s: String, action: (String.() -> Unit)?) {

compiler/testData/diagnostics/tests/secondaryConstructors/headerCallChecker/operatorCall.fir.kt

@@ -5,7 +5,7 @@ class D : C {
             {
                 val s = ""
                 <!UNRESOLVED_REFERENCE!>s<!>()
-                <!UNRESOLVED_REFERENCE!>""()<!>
+                <!UNRESOLVED_REFERENCE!>""<!>()
                 42
             }())
 

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

@@ -2,6 +2,6 @@
 open class A(p1: String)
 
 class B() : A("") {
-    <!INAPPLICABLE_CANDIDATE, PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(s: String)<!> {
+    <!PRIMARY_CONSTRUCTOR_DELEGATION_CALL_EXPECTED!>constructor(s: String)<!><!INAPPLICABLE_CANDIDATE!><!> {
     }
 }

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

@@ -2,6 +2,6 @@ class A {
     open inner class Inner
 
     class Nested : Inner {
-        <!UNRESOLVED_REFERENCE!>constructor()<!>
+        constructor()<!UNRESOLVED_REFERENCE!><!>
     }
 }

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

@@ -2,5 +2,5 @@
 open class A(p1: String, p2: String, p3: String, p4: String, p5: String)
 
 class B : A {
-    <!INAPPLICABLE_CANDIDATE!>constructor(s: String)<!>
+    constructor(s: String)<!INAPPLICABLE_CANDIDATE!><!>
 }