FIR: Support checking PRIVATE_TO_THIS visibility #KT-49875 Fixed

compiler/testData/diagnostics/tests/callableReference/bound/privateToThis.fir.kt

@@ -9,7 +9,7 @@ class Foo<out T>(name: T) {
         val ok2 = this@Foo::prop
         val ok3 = object { val y: Any = this@Foo::prop }
 
-        val fail1 = Foo(prop)::prop
+        val fail1 = Foo(prop)::<!UNRESOLVED_REFERENCE!>prop<!>
     }
 
     fun testFunc() {
@@ -17,7 +17,7 @@ class Foo<out T>(name: T) {
         val ok2 = this@Foo::func
         val ok3 = object { val y: Any = this@Foo::func }
 
-        val fail1 = Foo(prop)::func
+        val fail1 = Foo(prop)::<!UNRESOLVED_REFERENCE!>func<!>
     }
 
     private fun func(t: T): T = t

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

@@ -15,19 +15,19 @@ class Test<in I> {
         apply(this.foo())
         with(Test<I>()) {
             apply(foo()) // resolved to this@Test.foo
-            apply(this.foo())
-            apply(this@with.foo())
+            apply(this.<!INVISIBLE_REFERENCE!>foo<!>())
+            apply(this@with.<!INVISIBLE_REFERENCE!>foo<!>())
             apply(this@Test.foo())
         }
     }
 
     fun <I> test(t: Test<I>) {
-        t.apply(t.foo())
+        t.apply(t.<!INVISIBLE_REFERENCE!>foo<!>())
     }
 
     companion object {
         fun <I> test(t: Test<I>) {
-            t.apply(t.foo())
+            t.apply(t.<!INVISIBLE_REFERENCE!>foo<!>())
         }
     }
 }

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

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

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

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

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

@@ -9,6 +9,6 @@ class A<in T>(t: T) {
     }
 
     fun foo(a: A<String>) {
-        val x: String = a.t // Invisible!
+        val x: String = a.<!INVISIBLE_REFERENCE!>t<!> // Invisible!
     }
 }

compiler/testData/diagnostics/tests/visibility/privateToThis.fir.txt

@@ -13,7 +13,7 @@ FILE: privateToThis.fir.kt
         }
 
         public final fun foo(a: R|A<kotlin/String>|): R|kotlin/Unit| {
-            lval x: R|kotlin/String| = R|<local>/a|.R|SubstitutionOverride</A.t: R|kotlin/String|>|
+            lval x: R|kotlin/String| = R|<local>/a|.<HIDDEN: /A.t is invisible>#
         }
 
     }