FIR: Fix test data after making LHS of assignment an expression

KT-54648

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

@@ -45,8 +45,8 @@ fun cannotBe() {
     <!VARIABLE_EXPECTED!>""<!> = "";
     <!VARIABLE_EXPECTED!>foo()<!> = Unit;
 
-    (<!VARIABLE_EXPECTED!>i as Int<!>) = 34
-    (<!VARIABLE_EXPECTED!>i is Int<!>) = false
+    (<!VARIABLE_EXPECTED!>i <!USELESS_CAST!>as Int<!><!>) = 34
+    (<!USELESS_IS_CHECK, VARIABLE_EXPECTED!>i is Int<!>) = false
     <!VARIABLE_EXPECTED!>A()<!> = A()
     <!VARIABLE_EXPECTED!>5<!> = 34
 }

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

@@ -0,0 +1,29 @@
+public interface ITest {
+    public var prop : Int
+        get() = 12
+        set(value) {}
+}
+
+abstract class ATest {
+    protected open var prop2 : Int
+        get() = 13
+        set(value) {}
+}
+
+class Test: ATest(), ITest {
+    override var prop : Int
+        get() = 12
+        <!CANNOT_WEAKEN_ACCESS_PRIVILEGE!>private<!> set(value) {}
+
+    override var prop2 : Int
+        get() = 14
+        <!CANNOT_CHANGE_ACCESS_PRIVILEGE, SETTER_VISIBILITY_INCONSISTENT_WITH_PROPERTY_VISIBILITY!>internal<!> set(value) {}
+}
+
+fun main() {
+    val test = Test()
+    test.<!INVISIBLE_SETTER!>prop<!> = 12
+
+    val itest: ITest = test
+    itest.prop = 12 // No error here
+}

compiler/testData/diagnostics/tests/OverridenSetterVisibility.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 public interface ITest {
     public var prop : Int
         get() = 12

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

@@ -14,10 +14,10 @@ val xssss = <!EXPRESSION_EXPECTED_PACKAGE_FOUND!>foo<!>
 val f = { <!NO_COMPANION_OBJECT!>System<!> }
 
 fun main() {
-    <!EXPRESSION_EXPECTED_PACKAGE_FOUND!>java<!> = null
-    <!NO_COMPANION_OBJECT!>System<!> = null
+    <!EXPRESSION_EXPECTED_PACKAGE_FOUND, VARIABLE_EXPECTED!>java<!> = <!NULL_FOR_NONNULL_TYPE!>null<!>
+    <!NO_COMPANION_OBJECT, VARIABLE_EXPECTED!>System<!> = <!NULL_FOR_NONNULL_TYPE!>null<!>
     <!NO_COMPANION_OBJECT!>System<!>!!
-    <!NO_COMPANION_OBJECT{LT}!>java.lang.<!NO_COMPANION_OBJECT{PSI}!>System<!><!> = null
+    java.lang.<!NO_COMPANION_OBJECT, VARIABLE_EXPECTED!>System<!> = <!NULL_FOR_NONNULL_TYPE!>null<!>
     java.lang.<!NO_COMPANION_OBJECT!>System<!>!!
     <!NO_COMPANION_OBJECT!>System<!> is Int
     <!INVISIBLE_REFERENCE!>System<!>()

compiler/testData/diagnostics/tests/callableReference/unsupported/localVariableWithSubstitution.fir.kt

@@ -9,6 +9,6 @@ class Foo {
 fun main() {
     val f = Foo()
     val a: Int
-    <!VARIABLE_EXPECTED!>get()<!> = f.<!INAPPLICABLE_CANDIDATE!>getValue<!>(null, ::<!UNSUPPORTED!>a<!>) // no exception after fix
+    <!VARIABLE_EXPECTED!><!UNRESOLVED_REFERENCE!>get<!>()<!> = f.<!INAPPLICABLE_CANDIDATE!>getValue<!>(null, ::<!UNSUPPORTED!>a<!>) // no exception after fix
     <!UNRESOLVED_REFERENCE!>print<!>(<!UNINITIALIZED_VARIABLE!>a<!>)
 }

compiler/testData/diagnostics/tests/callableReference/unsupported/parameterWithSubstitution.fir.kt

@@ -9,6 +9,6 @@ class Foo {
 fun main(x: Int) {
     val f = Foo()
     val a: Int
-    <!VARIABLE_EXPECTED!>get()<!> = f.<!INAPPLICABLE_CANDIDATE!>getValue<!>(null, ::<!UNSUPPORTED!>x<!>) // no exception after fix
+    <!VARIABLE_EXPECTED!><!UNRESOLVED_REFERENCE!>get<!>()<!> = f.<!INAPPLICABLE_CANDIDATE!>getValue<!>(null, ::<!UNSUPPORTED!>x<!>) // no exception after fix
     <!UNRESOLVED_REFERENCE!>print<!>(<!UNINITIALIZED_VARIABLE!>a<!>)
 }

compiler/testData/diagnostics/tests/cast/AsInCompoundAssignment.kt

@@ -0,0 +1,8 @@
+// FIR_IDENTICAL
+class A {
+    var b = 1
+}
+
+fun Any.test() {
+    (this as A).b += 1 <!USELESS_CAST!>as Int<!>
+}

compiler/testData/diagnostics/tests/cast/AsInCompoundAssignment.txt

@@ -0,0 +1,11 @@
+package
+
+public fun kotlin.Any.test(): kotlin.Unit
+
+public final class A {
+    public constructor A()
+    public final var b: kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}

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

@@ -104,6 +104,21 @@ fun t5() {
     }
 }
 
+fun t6() {
+    val i = 0
+    fun t5() {
+        <!VAL_REASSIGNMENT!>i<!> += 3
+    }
+}
+
+fun t7() {
+    for (i in 0..2) {
+        fun t5() {
+            <!VAL_REASSIGNMENT!>i<!> = 3
+        }
+    }
+}
+
 // ------------------------------------------------
 // backing fields
 

compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.kt

@@ -104,6 +104,21 @@ fun t5() {
     }
 }
 
+fun t6() {
+    val i = 0
+    fun t5() {
+        <!VAL_REASSIGNMENT!>i<!> += 3
+    }
+}
+
+fun t7() {
+    for (i in 0..2) {
+        fun t5() {
+            <!VAL_REASSIGNMENT!>i<!> = 3
+        }
+    }
+}
+
 // ------------------------------------------------
 // backing fields
 

compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedOrReassignedVariables.txt

@@ -16,6 +16,8 @@ package uninitialized_reassigned_variables {
     public fun t4(): kotlin.Unit
     public fun t4(/*0*/ a: uninitialized_reassigned_variables.A): kotlin.Unit
     public fun t5(): kotlin.Unit
+    public fun t6(): kotlin.Unit
+    public fun t7(): kotlin.Unit
     public fun test(/*0*/ m: uninitialized_reassigned_variables.M): kotlin.Unit
     public fun test1(/*0*/ m: uninitialized_reassigned_variables.M): kotlin.Unit
 

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

@@ -23,23 +23,23 @@ class P {
 
 fun foo() {
     val p = P()
-    <!INVISIBLE_SETTER!>p.x<!> = 34 //should be an error here
+    p.<!INVISIBLE_SETTER!>x<!> = 34 //should be an error here
     p.y = 23
 
     fun inner() {
-        <!INVISIBLE_SETTER!>p.x<!> = 44
+        p.<!INVISIBLE_SETTER!>x<!> = 44
     }
 }
 
 class R {
     val p = P();
     init {
-        <!INVISIBLE_SETTER!>p.x<!> = 42
+        p.<!INVISIBLE_SETTER!>x<!> = 42
     }
 
     val testInGetterInOtherClass : Int
         get() {
-            <!INVISIBLE_SETTER!>p.x<!> = 33
+            p.<!INVISIBLE_SETTER!>x<!> = 33
             return 3
         }
 }

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

@@ -0,0 +1,36 @@
+//KT-2960 Perform control flow checks for package property initializers
+
+package b
+
+class P {
+    var x : Int = 0
+        private set
+}
+
+val p = P()
+var f = { -> p.<!INVISIBLE_SETTER!>x<!> = 32 }
+
+val o = object {
+    fun run() {
+        p.<!INVISIBLE_SETTER!>x<!> = 4
+
+        val z : Int
+        doSmth(<!UNINITIALIZED_VARIABLE!>z<!>)
+    }
+}
+
+val g = { ->
+    val x: Int
+    doSmth(<!UNINITIALIZED_VARIABLE!>x<!>)
+}
+
+class A {
+    val a : Int = 1
+      get() {
+          val x : Int
+          doSmth(<!UNINITIALIZED_VARIABLE!>x<!>)
+          return field
+      }
+}
+
+fun doSmth(i: Int) = i

compiler/testData/diagnostics/tests/controlFlowAnalysis/kt2960.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 //KT-2960 Perform control flow checks for package property initializers
 
 package b
@@ -34,4 +33,4 @@ class A {
       }
 }
 
-fun doSmth(i: Int) = i
+fun doSmth(i: Int) = i

compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.fir.kt

@@ -0,0 +1,30 @@
+// !DIAGNOSTICS: -UNREACHABLE_CODE -UNUSED_PARAMETER
+// !CHECK_TYPE
+// t is unused due to KT-4233
+
+// FILE: test.kt
+
+interface Tr<T> {
+    var v: T
+}
+
+fun test(t: Tr<*>) {
+    t.v = null!!
+    t.v = <!ASSIGNMENT_TYPE_MISMATCH!>""<!>
+    t.v = <!NULL_FOR_NONNULL_TYPE!>null<!>
+    t.v checkType { _<Any?>() }
+}
+
+fun test2(t: JavaClass<*>) {
+    t.v = null!!
+    t.v = <!ASSIGNMENT_TYPE_MISMATCH!>""<!>
+    t.v = null
+    t.v checkType { _<Any?>() }
+}
+
+// FILE: JavaClass.java
+
+public interface JavaClass<T> {
+    public T getV();
+    public void setV(T v);
+}

compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.kt

@@ -1,7 +1,9 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNREACHABLE_CODE -UNUSED_PARAMETER
 // !CHECK_TYPE
 // t is unused due to KT-4233
+
+// FILE: test.kt
+
 interface Tr<T> {
     var v: T
 }
@@ -11,4 +13,18 @@ fun test(t: Tr<*>) {
     <!SETTER_PROJECTED_OUT!>t.v<!> = ""
     <!SETTER_PROJECTED_OUT!>t.v<!> = null
     t.v checkType { _<Any?>() }
-}
+}
+
+fun test2(t: JavaClass<*>) {
+    t.v = null!!
+    t.v = ""
+    t.v = null
+    t.v checkType { _<Any?>() }
+}
+
+// FILE: JavaClass.java
+
+public interface JavaClass<T> {
+    public T getV();
+    public void setV(T v);
+}

compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutAssign.txt

@@ -1,6 +1,15 @@
 package
 
 public fun test(/*0*/ t: Tr<*>): kotlin.Unit
+public fun test2(/*0*/ t: JavaClass<*>): kotlin.Unit
+
+public interface JavaClass</*0*/ T : kotlin.Any!> {
+    public open override /*1*/ /*fake_override*/ fun equals(/*0*/ other: kotlin.Any?): kotlin.Boolean
+    public abstract fun getV(): T!
+    public open override /*1*/ /*fake_override*/ fun hashCode(): kotlin.Int
+    public abstract fun setV(/*0*/ v: T!): kotlin.Unit
+    public open override /*1*/ /*fake_override*/ fun toString(): kotlin.String
+}
 
 public interface Tr</*0*/ T> {
     public abstract var v: T

compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.fir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNREACHABLE_CODE
+interface Tr<T> {
+    var v: T
+}
+
+fun test(t: Tr<out String>) {
+    // resolved as t.v = t.v + null!!, where type of right operand is String,
+    // so TYPE_MISMATCH: String is not <: of Captured(out String)
+    <!ASSIGNMENT_TYPE_MISMATCH!>t.v += null!!<!>
+}

compiler/testData/diagnostics/tests/generics/varProjection/setterProjectedOutNoPlusAssign.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNREACHABLE_CODE
 interface Tr<T> {
     var v: T
@@ -8,4 +7,4 @@ fun test(t: Tr<out String>) {
     // resolved as t.v = t.v + null!!, where type of right operand is String,
     // so TYPE_MISMATCH: String is not <: of Captured(out String)
     <!SETTER_PROJECTED_OUT!>t.v<!> += null!!
-}
+}

compiler/testData/diagnostics/tests/inference/capturedTypes/kt46727.fir.kt

@@ -43,7 +43,7 @@ public class Bar<T> {
 }
 
 fun takeStarBar(x: Bar<*>) {
-    <!SETTER_PROJECTED_OUT!>x.value<!> = "test"
+    x.value = <!ASSIGNMENT_TYPE_MISMATCH!>"test"<!>
     x.value <!UNRESOLVED_REFERENCE!>+=<!> "test"
 }
 
@@ -74,7 +74,7 @@ public class Bar2<T> {
 }
 
 fun takeStarBar2(x: Bar2<*>) {
-    <!SETTER_PROJECTED_OUT!>x.value<!> = "test"
+    x.value = <!ASSIGNMENT_TYPE_MISMATCH!>"test"<!>
     x.value <!UNRESOLVED_REFERENCE!>+=<!> "test"
 }
 
@@ -106,7 +106,7 @@ class Bar3<T> {
 }
 
 fun takeStarBar3(x: Bar3<*>) {
-    <!SETTER_PROJECTED_OUT!>x.value<!> = "test"
+    x.value = <!ASSIGNMENT_TYPE_MISMATCH!>"test"<!>
     x.value <!UNRESOLVED_REFERENCE!>+=<!> "test"
 }
 

compiler/testData/diagnostics/tests/inference/capturedTypes/kt46727Warnings.fir.kt

@@ -43,7 +43,7 @@ public class Bar<T> {
 }
 
 fun takeStarBar(x: Bar<*>) {
-    <!SETTER_PROJECTED_OUT!>x.value<!> = "test"
+    x.value = <!ASSIGNMENT_TYPE_MISMATCH!>"test"<!>
     x.value <!UNRESOLVED_REFERENCE!>+=<!> "test"
 }
 
@@ -74,7 +74,7 @@ public class Bar2<T> {
 }
 
 fun takeStarBar2(x: Bar2<*>) {
-    <!SETTER_PROJECTED_OUT!>x.value<!> = "test"
+    x.value = <!ASSIGNMENT_TYPE_MISMATCH!>"test"<!>
     x.value <!UNRESOLVED_REFERENCE!>+=<!> "test"
 }
 
@@ -106,7 +106,7 @@ class Bar3<T> {
 }
 
 fun takeStarBar3(x: Bar3<*>) {
-    <!SETTER_PROJECTED_OUT!>x.value<!> = "test"
+    x.value = <!ASSIGNMENT_TYPE_MISMATCH!>"test"<!>
     x.value <!UNRESOLVED_REFERENCE!>+=<!> "test"
 }
 

compiler/testData/diagnostics/tests/properties/kt47621.fir.kt

@@ -1,23 +0,0 @@
-// WITH_STDLIB
-
-// FILE: j/J.java
-package j;
-
-public class J {
-    public int getX() { return 1; }
-    protected void setX(int value) { throw new RuntimeException(); }
-}
-
-// FILE: main.kt
-import j.*
-
-class C : J() {
-    fun foo() {
-        <!INVISIBLE_SETTER!>J()<!UNNECESSARY_SAFE_CALL!>?.<!>x<!> = 1
-    }
-}
-
-fun box(): String {
-    C().foo()
-    return "OK"
-}

compiler/testData/diagnostics/tests/properties/kt47621.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // WITH_STDLIB
 
 // FILE: j/J.java

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

@@ -26,9 +26,9 @@ package foo
 
 fun test(s: bar.Sub<String>) {
     s.<!INVISIBLE_REFERENCE!>name<!>
-    <!INVISIBLE_SETTER!>s.<!INVISIBLE_REFERENCE!>name<!><!> = ""
+    s.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>name<!> = ""
     s.name2
-    <!INVISIBLE_SETTER!>s.name2<!> = ""
+    s.<!INVISIBLE_SETTER!>name2<!> = ""
     s.<!INVISIBLE_REFERENCE!>doSomething<!>()
     s.doSomething2()
     val s2: Super<String> = s

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

@@ -41,7 +41,7 @@ open class A {
     fun foo() {
         <!UNRESOLVED_REFERENCE!>topLevelFun<!>()
         <!UNRESOLVED_REFERENCE!>topLevelFun<!>(1)
-        <!UNRESOLVED_REFERENCE, UNRESOLVED_REFERENCE!>topLevelProperty<!><!UNRESOLVED_REFERENCE!>++<!>
+        <!UNRESOLVED_REFERENCE!>topLevelProperty<!><!UNRESOLVED_REFERENCE!>++<!>
         "".<!UNRESOLVED_REFERENCE!>topLevelExtensionFun<!>()
         1.<!UNRESOLVED_REFERENCE!>topLevelExtensionFun<!>()
         "".<!UNRESOLVED_REFERENCE!>topLevelExtensionProperty<!>

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

@@ -35,12 +35,12 @@ fun test() {
 
         bar {
             <!DSL_SCOPE_VIOLATION!>a<!> + 1
-            <!DSL_SCOPE_VIOLATION, DSL_SCOPE_VIOLATION!>a<!> += <!DSL_SCOPE_VIOLATION!>a<!> + 1
-            <!DSL_SCOPE_VIOLATION, DSL_SCOPE_VIOLATION!>a<!>++
+            <!DSL_SCOPE_VIOLATION!>a<!> += <!DSL_SCOPE_VIOLATION!>a<!> + 1
+            <!DSL_SCOPE_VIOLATION!>a<!>++
 
             <!DSL_SCOPE_VIOLATION!>a1<!> + 1
-            <!DSL_SCOPE_VIOLATION, DSL_SCOPE_VIOLATION!>a1<!> += <!DSL_SCOPE_VIOLATION!>a1<!> + 1
-            <!DSL_SCOPE_VIOLATION, DSL_SCOPE_VIOLATION!>a1<!>++
+            <!DSL_SCOPE_VIOLATION!>a1<!> += <!DSL_SCOPE_VIOLATION!>a1<!> + 1
+            <!DSL_SCOPE_VIOLATION!>a1<!>++
 
             this@foo.a + 1
             this@foo.a += this@foo.a + 1

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

@@ -24,7 +24,7 @@ fun <T> bar() {
 
     B::class.equals(<!TYPE_PARAMETER_IS_NOT_AN_EXPRESSION!>T<!>)
 
-    T = ""
+    <!TYPE_PARAMETER_IS_NOT_AN_EXPRESSION, VARIABLE_EXPECTED!>T<!> = ""
 }
 
 fun baz(a: Any) {}

compiler/testData/diagnostics/tests/scopes/invisibleSetter.fir.kt

@@ -0,0 +1,9 @@
+class A<T> {
+    public var x: Int = 0
+        private set
+}
+
+fun main() {
+    val a = A<Any>()
+    a.<!INVISIBLE_SETTER!>x<!> = 1
+}

compiler/testData/diagnostics/tests/scopes/invisibleSetter.kt

@@ -1,4 +1,3 @@
-// FIR_IDENTICAL
 class A<T> {
     public var x: Int = 0
         private set
@@ -7,4 +6,4 @@ class A<T> {
 fun main() {
     val a = A<Any>()
     <!INVISIBLE_SETTER!>a.x<!> = 1
-}
+}

compiler/testData/diagnostics/tests/scopes/kt1244.fir.kt

@@ -8,6 +8,6 @@ class A {
 
 class B() {
     init {
-        <!INVISIBLE_SETTER!>A().<!INVISIBLE_REFERENCE!>a<!><!> = "Hello"
+        A().<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>a<!> = "Hello"
     }
 }

compiler/testData/diagnostics/tests/scopes/kt1738.fir.kt

@@ -6,6 +6,6 @@ class A(private var i: Int, var j: Int) {
 }
 
 fun test(a: A) {
-    <!INVISIBLE_SETTER!>a.<!INVISIBLE_REFERENCE, INVISIBLE_REFERENCE!>i<!><!>++
+    a.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>i<!>++
     a.j++
 }

compiler/testData/diagnostics/tests/scopes/protectedVisibility/syntheticPropertyExtensions.fir.kt

@@ -22,7 +22,7 @@ class B : A() {
         b.bar = b.bar + ""
 
         a.<!INVISIBLE_REFERENCE!>foo<!>
-        <!INVISIBLE_SETTER!>a.bar<!> = a.bar + ""
+        a.<!INVISIBLE_SETTER!>bar<!> = a.bar + ""
 
         if (a is B) {
             a.foo
@@ -32,12 +32,12 @@ class B : A() {
         if (d.x is B) {
             d.x.abc // Ok
             d.x.<!INVISIBLE_REFERENCE!>foo<!>
-            <!INVISIBLE_SETTER!>d.x.bar<!> = d.x.bar + ""
+            d.x.<!INVISIBLE_SETTER!>bar<!> = d.x.bar + ""
         }
     }
 }
 
 fun baz(a: A) {
     a.<!INVISIBLE_REFERENCE!>foo<!>
-    <!INVISIBLE_SETTER!>a.bar<!> = a.bar + ""
+    a.<!INVISIBLE_SETTER!>bar<!> = a.bar + ""
 }

compiler/testData/diagnostics/tests/scopes/protectedVisibility/withSmartcast.fir.kt

@@ -14,8 +14,8 @@ class Derived : Base() {
         x.<!INVISIBLE_REFERENCE!>foo<!>()
         x.<!INVISIBLE_REFERENCE!>bar<!>()
 
-        <!INVISIBLE_SETTER!>x.<!INVISIBLE_REFERENCE!>x<!><!> = x.<!INVISIBLE_REFERENCE!>x<!> + 1
-        <!INVISIBLE_SETTER!>x.y<!> = x.y + 1
+        x.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>x<!> = x.<!INVISIBLE_REFERENCE!>x<!> + 1
+        x.<!INVISIBLE_SETTER!>y<!> = x.y + 1
 
         if (x is Derived) {
             x.foo()

compiler/testData/diagnostics/tests/scopes/visibility.fir.kt

@@ -54,7 +54,7 @@ open class C : T {
 }
 
 fun test4(c: C) {
-    <!INVISIBLE_SETTER!>c.<!INVISIBLE_REFERENCE, INVISIBLE_REFERENCE!>i<!><!>++
+    c.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>i<!>++
 }
 
 class D : C() {

compiler/testData/diagnostics/tests/script/topLevelPropertiesWithGetSet.fir.kts

@@ -17,10 +17,10 @@ val testValLineBreakNoType
 get() = 42
 
 <!MUST_BE_INITIALIZED!>val testValLineBreakSemi: Int<!>;
-<!VARIABLE_EXPECTED!>get()<!> = 42
+<!VARIABLE_EXPECTED!><!UNRESOLVED_REFERENCE!>get<!>()<!> = 42
 
 <!MUST_BE_INITIALIZED!>val testValLineBreakSemiNoType<!>;
-<!VARIABLE_EXPECTED!>get()<!> = 42
+<!VARIABLE_EXPECTED!><!UNRESOLVED_REFERENCE!>get<!>()<!> = 42
 
 var testVarLineBreak: Int
 get() = 42
@@ -31,9 +31,9 @@ get() = 42
 set(value) {}
 
 <!MUST_BE_INITIALIZED!>var testVarLineBreakSemi: Int<!>;
-<!VARIABLE_EXPECTED!>get()<!> = 42
+<!VARIABLE_EXPECTED!><!UNRESOLVED_REFERENCE!>get<!>()<!> = 42
 <!UNRESOLVED_REFERENCE!>set<!>(<!UNRESOLVED_REFERENCE!>value<!>) {}
 
 <!EXTENSION_PROPERTY_MUST_HAVE_ACCESSORS_OR_BE_ABSTRACT!>var String.testExtVarLineBreakSemi: Int<!>;
-<!VARIABLE_EXPECTED!>get()<!> = 42
+<!VARIABLE_EXPECTED!><!UNRESOLVED_REFERENCE!>get<!>()<!> = 42
 <!UNRESOLVED_REFERENCE!>set<!>(<!UNRESOLVED_REFERENCE!>value<!>) {}

compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/OnlyPublic.fir.kt

@@ -8,7 +8,7 @@ fun foo(javaClass: JavaClass) {
     javaClass.<!INVISIBLE_REFERENCE!>somethingProtected<!>
     javaClass.<!INVISIBLE_REFERENCE!>somethingPrivate<!>
     javaClass.<!INVISIBLE_REFERENCE!>somethingPackage<!>
-    <!INVISIBLE_SETTER!>javaClass.somethingPublic<!> = 1
+    javaClass.<!INVISIBLE_SETTER!>somethingPublic<!> = 1
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/syntheticExtensions/javaProperties/SetterHasHigherAccess.fir.kt

@@ -6,7 +6,7 @@ import JavaClass
 fun foo(javaClass: JavaClass) {
     val v = javaClass.<!INVISIBLE_REFERENCE!>something<!>
     javaClass.<!INVISIBLE_REFERENCE!>something<!> = 1
-    javaClass.<!INVISIBLE_REFERENCE, INVISIBLE_REFERENCE!>something<!>++
+    javaClass.<!INVISIBLE_REFERENCE!>something<!>++
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/variance/privateToThis/SetVar.fir.kt

@@ -15,23 +15,23 @@ class Test<in I, out O> {
         this.i = getT()
         with(Test<I, O>()) {
             i = getT() // resolved to this@Test.i
-            <!INVISIBLE_SETTER!>this.<!INVISIBLE_REFERENCE!>i<!><!> = getT()
-            <!INVISIBLE_SETTER!>this@with.<!INVISIBLE_REFERENCE!>i<!><!> = getT()
+            this.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>i<!> = getT()
+            this@with.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>i<!> = getT()
             this@Test.i  = getT()
         }
     }
 
     fun <I, O> test(t: Test<I, O>) {
-        <!INVISIBLE_SETTER!>t.<!INVISIBLE_REFERENCE!>i<!><!> = getT()
+        t.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>i<!> = getT()
     }
 
     companion object {
         fun <I, O> test(t: Test<I, O>) {
-            <!INVISIBLE_SETTER!>t.<!INVISIBLE_REFERENCE!>i<!><!> = getT()
+            t.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>i<!> = getT()
         }
     }
 }
 
 fun <I, O> test(t: Test<I, O>) {
-    <!INVISIBLE_SETTER!>t.<!INVISIBLE_REFERENCE!>i<!><!> = getT()
+    t.<!INVISIBLE_REFERENCE, INVISIBLE_SETTER!>i<!> = getT()
 }

compiler/testData/diagnostics/tests/visibility/invisibleSetterOfJavaClass.fir.kt

@@ -18,12 +18,12 @@ class Data(var x: Foo)
 
 class B : Foo() {
     fun baz(a: Foo, t: Foo, d: Data) {
-        <!INVISIBLE_SETTER!>a.bar<!> = t.bar
-        <!INVISIBLE_SETTER!>a.foo<!> = t.foo
+        a.<!INVISIBLE_SETTER!>bar<!> = t.bar
+        a.<!INVISIBLE_SETTER!>foo<!> = t.foo
 
         if (d.x is B) {
-            <!INVISIBLE_SETTER!>d.x.bar<!> = d.x.bar + ""
-            <!INVISIBLE_SETTER!>d.x.foo<!> = d.x.foo + ""
+            d.x.<!INVISIBLE_SETTER!>bar<!> = d.x.bar + ""
+            d.x.<!INVISIBLE_SETTER!>foo<!> = d.x.foo + ""
         }
     }
 }

compiler/testData/diagnostics/tests/visibility/invisibleSetterOfJavaClassWithDisabledFeature.fir.kt

@@ -19,11 +19,11 @@ class Data(var x: Foo)
 class B : Foo() {
     fun baz(a: Foo, t: Foo, d: Data) {
         a.bar = t.bar
-        <!INVISIBLE_SETTER!>a.foo<!> = t.foo
+        a.<!INVISIBLE_SETTER!>foo<!> = t.foo
 
         if (d.x is B) {
             d.x.bar = d.x.bar + ""
-            <!INVISIBLE_SETTER!>d.x.foo<!> = d.x.foo + ""
+            d.x.<!INVISIBLE_SETTER!>foo<!> = d.x.foo + ""
         }
     }
 }

compiler/testData/diagnostics/tests/visibility/lackOfInvisibleSetterOfJavaClassInSamePackage.fir.kt

@@ -13,11 +13,11 @@ class Data(var x: Foo)
 class B : Foo() {
     fun baz(a: Foo, t: Foo, d: Data) {
         a.bar = t.bar
-        <!INVISIBLE_SETTER!>a.foo<!> = t.foo
+        a.<!INVISIBLE_SETTER!>foo<!> = t.foo
 
         if (d.x is B) {
             d.x.bar = d.x.bar + ""
-            <!INVISIBLE_SETTER!>d.x.foo<!> = d.x.foo + ""
+            d.x.<!INVISIBLE_SETTER!>foo<!> = d.x.foo + ""
         }
     }
 }

compiler/testData/diagnostics/testsWithStdLib/builderInference/unsafeAssignment.fir.kt

@@ -12,10 +12,10 @@ fun main(arg: Any) {
         run { a; this }.a = <!ASSIGNMENT_TYPE_MISMATCH!>10<!>
         a += 1
         this.a = <!ASSIGNMENT_TYPE_MISMATCH!>57<!>
-        this.(a) = 57
+        this.<!ILLEGAL_SELECTOR, VARIABLE_EXPECTED!>(a)<!> = 57
         a = <!ASSIGNMENT_TYPE_MISMATCH!>x<!>
         (a) = <!ASSIGNMENT_TYPE_MISMATCH!>x<!>
-        a.<!FUNCTION_CALL_EXPECTED!>hashCode<!> = 99
+        a.<!FUNCTION_CALL_EXPECTED, VARIABLE_EXPECTED!>hashCode<!> = 99
         if (arg is String) {
             a = arg
         }