FIR: rename HIDDEN to INVISIBLE_REFERENCE

Some of them should be INVISIBLE_MEMBER though

compiler/fir/analysis-tests/testData/resolve/arguments/ambiguityOnJavaOverride.kt

@@ -15,5 +15,5 @@ class B : A() {
 }
 
 fun test(b: B) {
-    b.<!HIDDEN!>foo<!>("")
+    b.<!INVISIBLE_REFERENCE!>foo<!>("")
 }

compiler/fir/analysis-tests/testData/resolve/diagnostics/sealedClassConstructorCall.kt

@@ -1,3 +1,3 @@
 sealed class A
 
-val b = <!HIDDEN!>A<!>()
+val b = <!INVISIBLE_REFERENCE!>A<!>()

compiler/fir/analysis-tests/testData/resolve/expresssions/nestedVisibility.kt

@@ -11,8 +11,8 @@ open class Outer {
 
 class Derived : Outer() {
     fun foo() {
-        Outer.<!HIDDEN!>PrivateNested<!>()
+        Outer.<!INVISIBLE_REFERENCE!>PrivateNested<!>()
-        super.<!HIDDEN!>PrivateInner<!>()
+        super.<!INVISIBLE_REFERENCE!>PrivateInner<!>()
 
         Outer.ProtectedNested()
         super.ProtectedInner()
@@ -23,11 +23,11 @@ class Derived : Outer() {
 }
 
 fun foo() {
-    Outer.<!HIDDEN!>PrivateNested<!>()
+    Outer.<!INVISIBLE_REFERENCE!>PrivateNested<!>()
-    Outer().<!HIDDEN!>PrivateInner<!>()
+    Outer().<!INVISIBLE_REFERENCE!>PrivateInner<!>()
 
-    Outer.<!HIDDEN!>ProtectedNested<!>()
+    Outer.<!INVISIBLE_REFERENCE!>ProtectedNested<!>()
-    Outer().<!HIDDEN!>ProtectedInner<!>()
+    Outer().<!INVISIBLE_REFERENCE!>ProtectedInner<!>()
 
     Outer.PublicNested()
     Outer().PublicInner()

compiler/fir/analysis-tests/testData/resolve/expresssions/privateVisibility.kt

@@ -9,21 +9,21 @@ private class Private {
         bar()
         Nested()
         fromCompanion()
-        NotCompanion.<!HIDDEN!>foo<!>() // hidden
+        NotCompanion.<!INVISIBLE_REFERENCE!>foo<!>() // hidden
     }
 
     inner class Inner {
         fun foo() {
             bar()
             fromCompanion()
-            NotCompanion.<!HIDDEN!>foo<!>() // hidden
+            NotCompanion.<!INVISIBLE_REFERENCE!>foo<!>() // hidden
         }
     }
 
     private class Nested {
         fun foo() {
             fromCompanion()
-            NotCompanion.<!HIDDEN!>foo<!>() // hidden
+            NotCompanion.<!INVISIBLE_REFERENCE!>foo<!>() // hidden
         }
     }
 
@@ -54,7 +54,7 @@ fun withLocals() {
 
     Local().baz()
 
-    Local().<!HIDDEN!>bar<!>() // hidden
+    Local().<!INVISIBLE_REFERENCE!>bar<!>() // hidden
 }
 
 fun test() {
@@ -62,14 +62,14 @@ fun test() {
     Private().baz()
     Private().Inner()
 
-    Private().<!HIDDEN!>bar<!>() // hidden
+    Private().<!INVISIBLE_REFERENCE!>bar<!>() // hidden
-    Private.<!HIDDEN!>Nested<!>() // hidden
+    Private.<!INVISIBLE_REFERENCE!>Nested<!>() // hidden
-    Private.<!HIDDEN!>fromCompanion<!>() // hidden
+    Private.<!INVISIBLE_REFERENCE!>fromCompanion<!>() // hidden
 }
 
 // FILE: second.kt
 
 fun secondTest() {
-    <!HIDDEN!>foo<!>() // hidden
+    <!INVISIBLE_REFERENCE!>foo<!>() // hidden
-    <!HIDDEN!>Private<!>() // hidden
+    <!INVISIBLE_REFERENCE!>Private<!>() // hidden
 }

compiler/fir/analysis-tests/testData/resolve/expresssions/protectedVisibility.kt

@@ -31,7 +31,7 @@ class Derived : Protected() {
     fun foo() {
         bar()
         Nested().foo()
-        Nested().<!HIDDEN!>bar<!>() // hidden
+        Nested().<!INVISIBLE_REFERENCE!>bar<!>() // hidden
 
         fromCompanion()
         protectedFromCompanion()
@@ -48,8 +48,8 @@ fun test() {
     Protected().baz()
     Protected().Inner()
 
-    Protected().<!HIDDEN!>bar<!>() // hidden
+    Protected().<!INVISIBLE_REFERENCE!>bar<!>() // hidden
-    Protected.<!HIDDEN!>Nested<!>() // hidden
+    Protected.<!INVISIBLE_REFERENCE!>Nested<!>() // hidden
 }
 
 open class Generic<T>(val x: T) {

compiler/fir/analysis-tests/testData/resolve/visibility/singletonConstructors.kt

@@ -2,12 +2,12 @@ class A {
     companion object Comp {}
 
     fun foo() {
-        <!HIDDEN!>Comp<!>()
+        <!INVISIBLE_REFERENCE!>Comp<!>()
     }
 }
 
 object B {
-    private val x = <!HIDDEN!>B<!>()
+    private val x = <!INVISIBLE_REFERENCE!>B<!>()
 }
 
 class D {

compiler/fir/analysis-tests/testData/resolve/visibility/visibilityWithOverrides.kt

@@ -19,5 +19,5 @@ abstract class A {
 // FILE: main.kt
 
 fun test(b: B): String {
-    return b <!HIDDEN!>foo<!> "hello" // should be an error
+    return b <!INVISIBLE_REFERENCE!>foo<!> "hello" // should be an error
 }

compiler/fir/analysis-tests/testData/resolveWithStdlib/j+k/JavaVisibility2.kt

@@ -22,24 +22,24 @@ import j.JavaProtected
 import j.JavaPackageLocal
 
 class A {
-    val p1 = JavaPackageLocal.<!HIDDEN!>javaPPackage<!>
+    val p1 = JavaPackageLocal.<!INVISIBLE_REFERENCE!>javaPPackage<!>
-    val p2 = JavaProtected.<!HIDDEN!>javaPProtectedStatic<!>
+    val p2 = JavaProtected.<!INVISIBLE_REFERENCE!>javaPProtectedStatic<!>
-    val p3 = JavaProtected().<!HIDDEN!>javaPProtectedPackage<!>
+    val p3 = JavaProtected().<!INVISIBLE_REFERENCE!>javaPProtectedPackage<!>
 
     fun test() {
-        JavaProtected.<!HIDDEN!>javaMProtectedStatic<!>()
+        JavaProtected.<!INVISIBLE_REFERENCE!>javaMProtectedStatic<!>()
-        JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
+        JavaPackageLocal.<!INVISIBLE_REFERENCE!>javaMPackage<!>()
     }
 }
 
 class B : JavaProtected() {
-    val p1 = JavaPackageLocal.<!HIDDEN!>javaPPackage<!>
+    val p1 = JavaPackageLocal.<!INVISIBLE_REFERENCE!>javaPPackage<!>
     val p2 = JavaProtected.javaPProtectedStatic
     val p3 = javaPProtectedPackage
 
     fun test() {
         JavaProtected.javaMProtectedStatic()
-        JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
+        JavaPackageLocal.<!INVISIBLE_REFERENCE!>javaMPackage<!>()
     }
 }
 

compiler/fir/analysis-tests/testData/resolveWithStdlib/lowPriorityInResolution.kt

@@ -1,5 +1,5 @@
 <!CONFLICTING_OVERLOADS!>@Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-<!HIDDEN!>@kotlin.internal.LowPriorityInOverloadResolution<!>
+@kotlin.internal.LowPriorityInOverloadResolution
 fun foo(): Int<!> = 1
 
 <!CONFLICTING_OVERLOADS!>fun foo(): String<!> = ""

compiler/fir/checkers/checkers-component-generator/src/org/jetbrains/kotlin/fir/checkers/generator/diagnostics/FirDiagnosticsList.kt

@@ -69,8 +69,8 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
     }
 
     val UNRESOLVED by object : DiagnosticGroup("Unresolved") {
-        val HIDDEN by error<PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
+        val INVISIBLE_REFERENCE by error<PsiElement>(PositioningStrategy.REFERENCE_BY_QUALIFIED) {
-            parameter<AbstractFirBasedSymbol<*>>("hidden")
+            parameter<AbstractFirBasedSymbol<*>>("reference")
         }
         val UNRESOLVED_REFERENCE by error<PsiElement>(PositioningStrategy.REFERENCED_NAME_BY_QUALIFIED) {
             parameter<String>("reference")

compiler/fir/checkers/gen/org/jetbrains/kotlin/fir/analysis/diagnostics/FirErrors.kt

@@ -96,7 +96,7 @@ object FirErrors {
     val DIVISION_BY_ZERO by warning0<KtExpression>()
 
     // Unresolved
-    val HIDDEN by error1<PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
+    val INVISIBLE_REFERENCE by error1<PsiElement, AbstractFirBasedSymbol<*>>(SourceElementPositioningStrategies.REFERENCE_BY_QUALIFIED)
     val UNRESOLVED_REFERENCE by error1<PsiElement, String>(SourceElementPositioningStrategies.REFERENCED_NAME_BY_QUALIFIED)
     val UNRESOLVED_LABEL by error0<PsiElement>()
     val DESERIALIZATION_ERROR by error0<PsiElement>()

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/FirDefaultErrorMessages.kt

@@ -116,7 +116,6 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.FUN_INTERFACE_CON
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.GENERIC_THROWABLE_SUBCLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.GETTER_VISIBILITY_DIFFERS_FROM_PROPERTY_VISIBILITY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.HAS_NEXT_FUNCTION_AMBIGUITY
-import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.HIDDEN
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_CONST_EXPRESSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ILLEGAL_UNDERSCORE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INAPPLICABLE_CANDIDATE
@@ -140,6 +139,7 @@ import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INSTANCE_ACCESS_B
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INTERFACE_WITH_SUPERCLASS
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVALID_IF_AS_EXPRESSION
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVALID_TYPE_OF_ANNOTATION_MEMBER
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.INVISIBLE_REFERENCE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.ITERATOR_AMBIGUITY
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.KCLASS_WITH_NULLABLE_TYPE_PARAMETER_IN_SIGNATURE
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors.LEAKED_IN_PLACE_LAMBDA
@@ -320,7 +320,7 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             map.put(NESTED_CLASS_NOT_ALLOWED, "{0} is not allowed here", TO_STRING)
 
             // Unresolved
-            map.put(HIDDEN, "Symbol {0} is invisible", SYMBOL)
+            map.put(INVISIBLE_REFERENCE, "Symbol {0} is invisible", SYMBOL)
             map.put(UNRESOLVED_REFERENCE, "Unresolved reference: {0}", NULLABLE_STRING)
             map.put(UNRESOLVED_LABEL, "Unresolved label")
             map.put(DESERIALIZATION_ERROR, "Deserialization error")

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/diagnostics/coneDiagnosticToFirDiagnostic.kt

@@ -30,7 +30,7 @@ private fun ConeDiagnostic.toFirDiagnostic(
     is ConeUnresolvedSymbolError -> FirErrors.UNRESOLVED_REFERENCE.on(source, this.classId.asString())
     is ConeUnresolvedNameError -> FirErrors.UNRESOLVED_REFERENCE.on(source, this.name.asString())
     is ConeUnresolvedQualifierError -> FirErrors.UNRESOLVED_REFERENCE.on(source, this.qualifier)
-    is ConeHiddenCandidateError -> FirErrors.HIDDEN.on(source, this.candidateSymbol)
+    is ConeHiddenCandidateError -> FirErrors.INVISIBLE_REFERENCE.on(source, this.candidateSymbol)
     is ConeAmbiguityError -> if (this.applicability.isSuccess) {
         FirErrors.OVERLOAD_RESOLUTION_AMBIGUITY.on(source, this.candidates.map { it.symbol })
     } else if (this.applicability == CandidateApplicability.UNSAFE_CALL) {

compiler/testData/codegen/box/annotations/resolveWithLowPriorityAnnotation.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // WITH_RUNTIME
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvmPackageName.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 // WITH_STDLIB
 

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvmPackageNameInRootPackage.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 // WITH_STDLIB
 

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvmPackageNameMultifileClass.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 

compiler/testData/codegen/box/compileKotlinAgainstKotlin/jvmPackageNameWithJvmName.kt

@@ -1,4 +1,3 @@
-// IGNORE_BACKEND_FIR: JVM_IR
 // TARGET_BACKEND: JVM
 // MODULE: lib
 // WITH_STDLIB

compiler/testData/codegen/box/jvmPackageName/anonymousObject.kt

@@ -1,6 +1,5 @@
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
-// IGNORE_FIR_DIAGNOSTICS
 
 // FILE: anonymousObject.kt
 import x.*

compiler/testData/codegen/box/jvmPackageName/anonymousObjectInInheritedMultifilePart.kt

@@ -1,6 +1,5 @@
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
-// IGNORE_FIR_DIAGNOSTICS
 // IGNORE_LIGHT_ANALYSIS
 // !INHERIT_MULTIFILE_PARTS
 

compiler/testData/codegen/box/jvmPackageName/anonymousObjectInMultifilePart.kt

@@ -1,6 +1,5 @@
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
-// IGNORE_FIR_DIAGNOSTICS
 
 // FILE: anonymousObject.kt
 import x.*

compiler/testData/codegen/box/jvmPackageName/localClass.kt

@@ -1,6 +1,5 @@
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
-// IGNORE_FIR_DIAGNOSTICS
 
 // FILE: anonymousObject.kt
 import x.*

compiler/testData/codegen/box/jvmPackageName/metadataField.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 

compiler/testData/codegen/box/jvmPackageName/multifileClass.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 

compiler/testData/codegen/box/jvmPackageName/rootPackage.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 

compiler/testData/codegen/box/jvmPackageName/simple.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 

compiler/testData/codegen/box/jvmPackageName/withJvmName.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 

compiler/testData/codegen/boxInline/jvmPackageName/simple.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // TARGET_BACKEND: JVM
 // WITH_RUNTIME
 // FILE: 1.kt

compiler/testData/codegen/boxInline/smap/inlineOnly/noSmapWithProperty.kt

@@ -1,8 +1,8 @@
-// IGNORE_FIR_DIAGNOSTICS
 // WITH_RUNTIME
 // FILE: 1.kt
 
 package test
+
 inline fun stub() {
 
 }

compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnly.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // FILE: 1.kt
 package test
 

compiler/testData/codegen/boxInline/smap/inlineOnly/stdlibInlineOnlyOneLine.kt

@@ -1,5 +1,5 @@
-// IGNORE_FIR_DIAGNOSTICS
 // FILE: 1.kt
+
 package test
 
 @Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")

compiler/testData/codegen/boxInline/suspend/inlineUsedAsNoinline/inlineOnly.kt

@@ -1,4 +1,3 @@
-// IGNORE_FIR_DIAGNOSTICS
 // WITH_RUNTIME
 // WITH_COROUTINES
 // NO_CHECK_LAMBDA_INLINING

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

@@ -5,6 +5,6 @@ fun test() {
     Int(<!NO_VALUE_FOR_PARAMETER!>)<!>
     Short(<!NO_VALUE_FOR_PARAMETER!>)<!>
     Byte(<!NO_VALUE_FOR_PARAMETER!>)<!>
-    <!HIDDEN!>Char<!>()
+    <!INVISIBLE_REFERENCE!>Char<!>()
     Boolean(<!NO_VALUE_FOR_PARAMETER!>)<!>
 }

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

@@ -19,7 +19,7 @@ fun main() {
     java.lang.System = null
     java.lang.System!!
     System is Int
-    <!HIDDEN!>System<!>()
+    <!INVISIBLE_REFERENCE!>System<!>()
     (System)
     foo@ System
     null <!UNRESOLVED_REFERENCE!>in<!> System

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

@@ -10,8 +10,8 @@ package outer.p1
 import outer.a
 
 fun use() {
-    <!HIDDEN!>a<!>()
+    <!INVISIBLE_REFERENCE!>a<!>()
-    outer.<!HIDDEN!>B<!>()
+    outer.<!INVISIBLE_REFERENCE!>B<!>()
 }
 
 // FILE: c.kt
@@ -20,6 +20,6 @@ package outer.p1.p2
 import outer.a
 
 fun use() {
-    <!HIDDEN!>a<!>()
+    <!INVISIBLE_REFERENCE!>a<!>()
-    outer.<!HIDDEN!>B<!>()
+    outer.<!INVISIBLE_REFERENCE!>B<!>()
 }

compiler/testData/diagnostics/tests/annotations/illegalRequireKotlinValue.fir.kt

@@ -3,36 +3,36 @@ package test
 
 import kotlin.internal.RequireKotlin
 
-<!HIDDEN!>@RequireKotlin("")<!>
+@RequireKotlin("")
 fun f01() {}
 
-<!HIDDEN!>@RequireKotlin("x")<!>
+@RequireKotlin("x")
 fun f02() {}
 
-<!HIDDEN!>@RequireKotlin("1")<!>
+@RequireKotlin("1")
 fun f03() {}
 
-<!HIDDEN!>@RequireKotlin("1.0-beta")<!>
+@RequireKotlin("1.0-beta")
 fun f04() {}
 
-<!HIDDEN!>@RequireKotlin("1.1.0-dev-1111")<!>
+@RequireKotlin("1.1.0-dev-1111")
 fun f05() {}
 
-<!HIDDEN!>@RequireKotlin("1.5.3.7")<!>
+@RequireKotlin("1.5.3.7")
 fun f06() {}
 
-<!HIDDEN!>@RequireKotlin("1..0")<!>
+@RequireKotlin("1..0")
 fun f07() {}
 
-<!HIDDEN!>@RequireKotlin(" 1.0")<!>
+@RequireKotlin(" 1.0")
 fun f08() {}
 
 
-<!HIDDEN!>@RequireKotlin("1.1")<!>
+@RequireKotlin("1.1")
 fun ok1() {}
 
-<!HIDDEN!>@RequireKotlin("1.1.0")<!>
+@RequireKotlin("1.1.0")
 fun ok2() {}
 
-<!HIDDEN!>@RequireKotlin("0.0.0")<!>
+@RequireKotlin("0.0.0")
 fun ok3() {}

compiler/testData/diagnostics/tests/classObjects/ClassObjectVisibility.fir.kt

@@ -2,7 +2,7 @@ package foo
 
 fun test() {
   A.d
-  A.Companion.<!HIDDEN!>f<!>
+  A.Companion.<!INVISIBLE_REFERENCE!>f<!>
   B.D
   CCC
   CCC.classObjectVar

compiler/testData/diagnostics/tests/classObjects/invisibleClassObjects.fir.kt

@@ -35,14 +35,14 @@ import a.D
 
 fun test() {
     f(A)
-    f(<!HIDDEN!>B<!>)
+    f(<!INVISIBLE_REFERENCE!>B<!>)
     f(C)
-    f(<!HIDDEN!>D<!>)
+    f(<!INVISIBLE_REFERENCE!>D<!>)
 
     A.foo()
-    <!HIDDEN!>B<!>.bar()
+    <!INVISIBLE_REFERENCE!>B<!>.bar()
     C.baz()
-    <!HIDDEN!>D<!>.quux()
+    <!INVISIBLE_REFERENCE!>D<!>.quux()
 
     a.A.foo()
     a.C.baz()

compiler/testData/diagnostics/tests/dynamicTypes/withInvisibleSynthesized.fir.kt

@@ -21,15 +21,15 @@ import p.*
 
 class K: J.C() {
     fun dynamic.test() {
-        <!HIDDEN!>sam<!>(null)
+        <!INVISIBLE_REFERENCE!>sam<!>(null)
-        <!HIDDEN!>sam<!>(
+        <!INVISIBLE_REFERENCE!>sam<!>(
             name = null,
             name = null
         )
     }
 
     fun test() {
-        <!HIDDEN!>sam<!>(null)
+        <!INVISIBLE_REFERENCE!>sam<!>(null)
     }
 
 }

compiler/testData/diagnostics/tests/enum/ConstructorCallFromOutside.fir.kt

@@ -6,5 +6,5 @@ enum class A(val c: Int) {
 
 fun createA(): A {
     // Error should be here!
-    return <!HIDDEN!>A<!>(10)
+    return <!INVISIBLE_REFERENCE!>A<!>(10)
 }

compiler/testData/diagnostics/tests/enum/inheritanceFromEnum.fir.kt

@@ -8,6 +8,6 @@ open enum class MyEnum() {
 
 enum class MyEnum2() {}
 
-class MyClass(): <!HIDDEN!>MyEnum2<!>() {}
+class MyClass(): <!INVISIBLE_REFERENCE!>MyEnum2<!>() {}
 
 class MyClass2(): <!UNRESOLVED_REFERENCE!>MyJavaEnum<!>() {}

compiler/testData/diagnostics/tests/exposed/exceptionOnFakeInvisible.fir.kt

@@ -7,6 +7,6 @@ fun bar(arg: String) = arg
 class Derived : Base("123") {
 
     private inline fun foo() {
-        bar(<!HIDDEN!>v<!>)
+        bar(<!INVISIBLE_REFERENCE!>v<!>)
     }
 }

compiler/testData/diagnostics/tests/imports/CheckJavaVisibility2.fir.kt

@@ -22,24 +22,24 @@ import j.JavaProtected
 import j.JavaPackageLocal
 
 class A {
-    val p1 = JavaPackageLocal.<!HIDDEN!>javaPPackage<!>
+    val p1 = JavaPackageLocal.<!INVISIBLE_REFERENCE!>javaPPackage<!>
-    val p2 = JavaProtected.<!HIDDEN!>javaPProtectedStatic<!>
+    val p2 = JavaProtected.<!INVISIBLE_REFERENCE!>javaPProtectedStatic<!>
-    val p3 = JavaProtected().<!HIDDEN!>javaPProtectedPackage<!>
+    val p3 = JavaProtected().<!INVISIBLE_REFERENCE!>javaPProtectedPackage<!>
 
     fun test() {
-        JavaProtected.<!HIDDEN!>javaMProtectedStatic<!>()
+        JavaProtected.<!INVISIBLE_REFERENCE!>javaMProtectedStatic<!>()
-        JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
+        JavaPackageLocal.<!INVISIBLE_REFERENCE!>javaMPackage<!>()
     }
 }
 
 class B : JavaProtected() {
-    val p1 = JavaPackageLocal.<!HIDDEN!>javaPPackage<!>
+    val p1 = JavaPackageLocal.<!INVISIBLE_REFERENCE!>javaPPackage<!>
     val p2 = JavaProtected.javaPProtectedStatic
     val p3 = javaPProtectedPackage
 
     fun test() {
         JavaProtected.javaMProtectedStatic()
-        JavaPackageLocal.<!HIDDEN!>javaMPackage<!>()
+        JavaPackageLocal.<!INVISIBLE_REFERENCE!>javaMPackage<!>()
     }
 }
 

compiler/testData/diagnostics/tests/imports/ImportPrivateMember.fir.kt

@@ -29,7 +29,7 @@ private object TopLevelObject {
 }
 
 fun testAccess() {
-    <!HIDDEN!>NestedClass<!>()
+    <!INVISIBLE_REFERENCE!>NestedClass<!>()
     E1
     InNested()
     NestedEntry

compiler/testData/diagnostics/tests/imports/InaccessiblePrivateClass.fir.kt

@@ -15,4 +15,4 @@ package p1
 import p2.*
 
 val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = <!INITIALIZER_TYPE_MISMATCH!>X()<!>
-val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!HIDDEN!>Y<!>()
+val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!INVISIBLE_REFERENCE!>Y<!>()

compiler/testData/diagnostics/tests/imports/PackageLocalClassReferencedError.fir.kt

@@ -8,4 +8,4 @@ package a
 
 import pack1.*
 
-private class X : <!HIDDEN!>SomeClass<!>()
+private class X : <!INVISIBLE_REFERENCE!>SomeClass<!>()

compiler/testData/diagnostics/tests/imports/PrivateClassReferencedError.fir.kt

@@ -11,4 +11,4 @@ package a
 
 import pack1.SomeClass.*
 
-private class X : <!EXPOSED_SUPER_CLASS, HIDDEN!>N<!>()
+private class X : <!EXPOSED_SUPER_CLASS, INVISIBLE_REFERENCE!>N<!>()

compiler/testData/diagnostics/tests/imports/invisibleFakeReferenceInImport.fir.kt

@@ -3,7 +3,7 @@
 import B.foo
 
 fun test() {
-    <!HIDDEN!>foo<!>
+    <!INVISIBLE_REFERENCE!>foo<!>
 }
 
 // FILE: B.kt

compiler/testData/diagnostics/tests/incompleteCode/kt2014.fir.kt

@@ -14,7 +14,7 @@ fun x(f : Foo) {
 
     f.<!UNRESOLVED_REFERENCE!>a<!>()
     <!UNRESOLVED_REFERENCE!>c<!>()
-    <!HIDDEN!>R<!>()
+    <!INVISIBLE_REFERENCE!>R<!>()
 }
 
 object R {}

compiler/testData/diagnostics/tests/inference/completion/withExact.fir.kt

@@ -6,7 +6,7 @@
 import kotlin.internal.Exact
 
 class Inv<I>(val arg: I)
-class InvExact<E>(val arg: <!HIDDEN, HIDDEN!>@kotlin.internal.Exact<!> E)
+class InvExact<E>(val arg: @kotlin.internal.Exact E)
 
 interface Base
 class Derived : Base

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

@@ -1,15 +0,0 @@
-// WITH_RUNTIME
-// !DIAGNOSTICS: -UNUSED_PARAMETER
-
-@file:Suppress("INVISIBLE_MEMBER", "INVISIBLE_REFERENCE")
-
-import kotlin.internal.OnlyInputTypes
-
-fun <<!HIDDEN!>@OnlyInputTypes<!> T> assertEquals(expected: T, actual: T, message: String? = null) {}
-
-fun main() {
-    assertEquals(
-        mapOf(1 to "1", 2 to "2", 3 to "3"),
-        intArrayOf(1, 2, 3).associateWith { it.toString() }
-    )
-}

compiler/testData/diagnostics/tests/inference/onlyInputTypesWithMultilevelIncorporation.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // WITH_RUNTIME
 // !DIAGNOSTICS: -UNUSED_PARAMETER
 

compiler/testData/diagnostics/tests/inference/upperBounds/typeParameterAsUpperBound.fir.kt

@@ -1,7 +1,7 @@
 // !CHECK_TYPE
 
 
-<!HIDDEN!>@kotlin.internal.InlineOnly<!>
+<!INVISIBLE_REFERENCE!>@kotlin.internal.InlineOnly<!>
 public inline fun <C, R> C.ifEmpty(f: () -> R): R where C : Collection<*>, C : R = if (isEmpty()) f() else this
 
 public fun <T> listOf(t: T): List<T> = TODO()

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

@@ -11,8 +11,8 @@ open class Outer {
 
 class Derived : Outer() {
     fun foo() {
-        Outer.<!HIDDEN!>PrivateNested<!>()
+        Outer.<!INVISIBLE_REFERENCE!>PrivateNested<!>()
-        super.<!HIDDEN!>PrivateInner<!>()
+        super.<!INVISIBLE_REFERENCE!>PrivateInner<!>()
 
         Outer.ProtectedNested()
         super.ProtectedInner()
@@ -23,11 +23,11 @@ class Derived : Outer() {
 }
 
 fun foo() {
-    Outer.<!HIDDEN!>PrivateNested<!>()
+    Outer.<!INVISIBLE_REFERENCE!>PrivateNested<!>()
-    Outer().<!HIDDEN!>PrivateInner<!>()
+    Outer().<!INVISIBLE_REFERENCE!>PrivateInner<!>()
 
-    Outer.<!HIDDEN!>ProtectedNested<!>()
+    Outer.<!INVISIBLE_REFERENCE!>ProtectedNested<!>()
-    Outer().<!HIDDEN!>ProtectedInner<!>()
+    Outer().<!INVISIBLE_REFERENCE!>ProtectedInner<!>()
 
     Outer.PublicNested()
     Outer().PublicInner()

compiler/testData/diagnostics/tests/j+k/invisiblePackagePrivateInheritedMember.fir.kt

@@ -19,5 +19,5 @@ package c
 import b.F
 
 fun f() {
-    F().<!HIDDEN!>m<!>
+    F().<!INVISIBLE_REFERENCE!>m<!>
 }

compiler/testData/diagnostics/tests/j+k/packageVisibility.fir.kt

@@ -26,19 +26,19 @@ package b
 
 import a.MyJavaClass
 
-val <!EXPOSED_PROPERTY_TYPE!>mc1<!> = <!HIDDEN!>MyJavaClass<!>()
+val <!EXPOSED_PROPERTY_TYPE!>mc1<!> = <!INVISIBLE_REFERENCE!>MyJavaClass<!>()
 
-val x = <!HIDDEN!>MyJavaClass<!>.<!HIDDEN!>staticMethod<!>()
+val x = <!INVISIBLE_REFERENCE!>MyJavaClass<!>.<!INVISIBLE_REFERENCE!>staticMethod<!>()
-val y = MyJavaClass.<!HIDDEN!>NestedClass<!>.<!HIDDEN!>staticMethodOfNested<!>()
+val y = MyJavaClass.<!INVISIBLE_REFERENCE!>NestedClass<!>.<!INVISIBLE_REFERENCE!>staticMethodOfNested<!>()
-val <!EXPOSED_PROPERTY_TYPE!>z<!> = <!HIDDEN!>MyJavaClass<!>.<!HIDDEN!>NestedClass<!>()
+val <!EXPOSED_PROPERTY_TYPE!>z<!> = <!INVISIBLE_REFERENCE!>MyJavaClass<!>.<!INVISIBLE_REFERENCE!>NestedClass<!>()
 
 //FILE: c.kt
 package a.c
 
 import a.MyJavaClass
 
-val <!EXPOSED_PROPERTY_TYPE!>mc1<!> = <!HIDDEN!>MyJavaClass<!>()
+val <!EXPOSED_PROPERTY_TYPE!>mc1<!> = <!INVISIBLE_REFERENCE!>MyJavaClass<!>()
 
-val x = <!HIDDEN!>MyJavaClass<!>.<!HIDDEN!>staticMethod<!>()
+val x = <!INVISIBLE_REFERENCE!>MyJavaClass<!>.<!INVISIBLE_REFERENCE!>staticMethod<!>()
-val y = MyJavaClass.<!HIDDEN!>NestedClass<!>.<!HIDDEN!>staticMethodOfNested<!>()
+val y = MyJavaClass.<!INVISIBLE_REFERENCE!>NestedClass<!>.<!INVISIBLE_REFERENCE!>staticMethodOfNested<!>()
-val <!EXPOSED_PROPERTY_TYPE!>z<!> = <!HIDDEN!>MyJavaClass<!>.<!HIDDEN!>NestedClass<!>()
+val <!EXPOSED_PROPERTY_TYPE!>z<!> = <!INVISIBLE_REFERENCE!>MyJavaClass<!>.<!INVISIBLE_REFERENCE!>NestedClass<!>()

compiler/testData/diagnostics/tests/j+k/sam/privateCandidatesWithWrongArguments.fir.kt

@@ -17,5 +17,5 @@ public class A {
 package bar
 
 fun main() {
-    foo.A.<!HIDDEN!>f<!> {}
+    foo.A.<!INVISIBLE_REFERENCE!>f<!> {}
 }

compiler/testData/diagnostics/tests/javac/imports/PackagePrivateAndPublicNested.fir.kt

@@ -11,7 +11,7 @@ package a
 import p.Foo
 import p.Foo.Nested
 
-class Bar : <!EXPOSED_SUPER_CLASS, HIDDEN!>Foo<!>() {
+class Bar : <!EXPOSED_SUPER_CLASS, INVISIBLE_REFERENCE!>Foo<!>() {
     protected fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(): Nested? = null
 }
 

compiler/testData/diagnostics/tests/multimodule/internal.fir.kt

@@ -22,14 +22,14 @@ internal class B
 import p.*
 
 fun test() {
-    val _a = <!HIDDEN!>a<!>
+    val _a = <!INVISIBLE_REFERENCE!>a<!>
-    val _v = <!HIDDEN!>v<!>
+    val _v = <!INVISIBLE_REFERENCE!>v<!>
-    <!HIDDEN!>a<!>()
+    <!INVISIBLE_REFERENCE!>a<!>()
-    <!HIDDEN!>B<!>()
+    <!INVISIBLE_REFERENCE!>B<!>()
 
     val inst = A()
-    val ia = inst.<!HIDDEN!>a<!>
+    val ia = inst.<!INVISIBLE_REFERENCE!>a<!>
-    val iv = inst.<!HIDDEN!>v<!>
+    val iv = inst.<!INVISIBLE_REFERENCE!>v<!>
-    inst.<!HIDDEN!>a<!>()
+    inst.<!INVISIBLE_REFERENCE!>a<!>()
-    inst.<!HIDDEN!>B<!>()
+    inst.<!INVISIBLE_REFERENCE!>B<!>()
 }

compiler/testData/diagnostics/tests/multimodule/packagePrivate.fir.kt

@@ -9,11 +9,11 @@ private val a = 1
 
 package p
 
-val b = <!HIDDEN!>a<!> // same package, same module
+val b = <!INVISIBLE_REFERENCE!>a<!> // same package, same module
 
 // MODULE: m2(m1)
 // FILE: c.kt
 
 package p
 
-val c = <!HIDDEN!>a<!> // same package, another module
+val c = <!INVISIBLE_REFERENCE!>a<!> // same package, another module

compiler/testData/diagnostics/tests/multimodule/publishedApiInternal.fir.kt

@@ -30,27 +30,27 @@ internal class B
 import p.*
 
 fun test() {
-    val _a = <!HIDDEN!>a<!>
+    val _a = <!INVISIBLE_REFERENCE!>a<!>
-    val _v = <!HIDDEN!>v<!>
+    val _v = <!INVISIBLE_REFERENCE!>v<!>
-    <!HIDDEN!>a<!>()
+    <!INVISIBLE_REFERENCE!>a<!>()
-    <!HIDDEN!>B<!>()
+    <!INVISIBLE_REFERENCE!>B<!>()
 
     val inst = A()
-    val ia = inst.<!HIDDEN!>a<!>
+    val ia = inst.<!INVISIBLE_REFERENCE!>a<!>
-    val iv = inst.<!HIDDEN!>v<!>
+    val iv = inst.<!INVISIBLE_REFERENCE!>v<!>
-    inst.<!HIDDEN!>a<!>()
+    inst.<!INVISIBLE_REFERENCE!>a<!>()
-    inst.<!HIDDEN!>B<!>()
+    inst.<!INVISIBLE_REFERENCE!>B<!>()
 }
 
 inline fun testInline() {
-    val _a = <!HIDDEN!>a<!>
+    val _a = <!INVISIBLE_REFERENCE!>a<!>
-    val _v = <!HIDDEN!>v<!>
+    val _v = <!INVISIBLE_REFERENCE!>v<!>
-    <!HIDDEN!>a<!>()
+    <!INVISIBLE_REFERENCE!>a<!>()
-    <!HIDDEN!>B<!>()
+    <!INVISIBLE_REFERENCE!>B<!>()
 
     val inst = A()
-    val ia = inst.<!HIDDEN!>a<!>
+    val ia = inst.<!INVISIBLE_REFERENCE!>a<!>
-    val iv = inst.<!HIDDEN!>v<!>
+    val iv = inst.<!INVISIBLE_REFERENCE!>v<!>
-    inst.<!HIDDEN!>a<!>()
+    inst.<!INVISIBLE_REFERENCE!>a<!>()
-    inst.<!HIDDEN!>B<!>()
+    inst.<!INVISIBLE_REFERENCE!>B<!>()
 }

compiler/testData/diagnostics/tests/nullabilityAndSmartCasts/kt362.fir.kt

@@ -6,11 +6,11 @@ package example
 fun test() {
   val p = test.Public()
   if (p.public is Int) p.public + 1
-  if (p.<!HIDDEN!>protected<!> is Int) p.<!HIDDEN!>protected<!> <!UNSAFE_OPERATOR_CALL!>+<!> 1
+  if (p.<!INVISIBLE_REFERENCE!>protected<!> is Int) p.<!INVISIBLE_REFERENCE!>protected<!> <!UNSAFE_OPERATOR_CALL!>+<!> 1
   if (p.internal is Int) p.internal + 1
   val i = test.Internal()
   if (i.public is Int) i.public + 1
-  if (i.<!HIDDEN!>protected<!> is Int) i.<!HIDDEN!>protected<!> <!UNSAFE_OPERATOR_CALL!>+<!> 1
+  if (i.<!INVISIBLE_REFERENCE!>protected<!> is Int) i.<!INVISIBLE_REFERENCE!>protected<!> <!UNSAFE_OPERATOR_CALL!>+<!> 1
   if (i.internal is Int) i.internal + 1
 }
 

compiler/testData/diagnostics/tests/privateInFile/topLevelAnnotationCall.fir.kt

@@ -17,11 +17,11 @@ class C1
 // FILE: 2.kt
 package pp
 
-<!HIDDEN!>@A(<!HIDDEN!>foo<!>)<!>
+<!INVISIBLE_REFERENCE!>@A(<!INVISIBLE_REFERENCE!>foo<!>)<!>
 fun f2() {}
 
-<!HIDDEN!>@A(<!HIDDEN!>foo<!>)<!>
+<!INVISIBLE_REFERENCE!>@A(<!INVISIBLE_REFERENCE!>foo<!>)<!>
 val p2 = ""
 
-<!HIDDEN!>@A(<!HIDDEN!>foo<!>)<!>
+<!INVISIBLE_REFERENCE!>@A(<!INVISIBLE_REFERENCE!>foo<!>)<!>
 class C2

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

@@ -30,20 +30,20 @@ package a
 fun test() {
     val y = makeA()
     y.bar()
-    <!HIDDEN!>foo<!>()
+    <!INVISIBLE_REFERENCE!>foo<!>()
 
-    val u : A = <!HIDDEN!>A<!>()
+    val u : A = <!INVISIBLE_REFERENCE!>A<!>()
 
-    val z = <!HIDDEN!>x<!>
+    val z = <!INVISIBLE_REFERENCE!>x<!>
-    <!HIDDEN!>x<!> = 30
+    <!INVISIBLE_REFERENCE!>x<!> = 30
 
-    val po = <!HIDDEN!>PO<!>
+    val po = <!INVISIBLE_REFERENCE!>PO<!>
 
     val v = xx
     xx = 40
 }
 
-class B : <!EXPOSED_SUPER_CLASS, HIDDEN!>A<!>() {}
+class B : <!EXPOSED_SUPER_CLASS, INVISIBLE_REFERENCE!>A<!>() {}
 
 class Q {
     class W {

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

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

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

@@ -9,7 +9,7 @@ fun test() {
     val interface_as_fun = <!UNRESOLVED_REFERENCE!>A<!>()
     val interface_as_val = A
 
-    val object_as_fun = <!HIDDEN!>B<!>()
+    val object_as_fun = <!INVISIBLE_REFERENCE!>B<!>()
     val class_as_val = C
 }
 

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

@@ -11,7 +11,7 @@ fun testX() {
     val interface_as_fun = X.<!UNRESOLVED_REFERENCE!>A<!>()
     val interface_as_val = X.A
 
-    val object_as_fun = X.<!HIDDEN!>B<!>()
+    val object_as_fun = X.<!INVISIBLE_REFERENCE!>B<!>()
     val class_as_val = X.C
 }
 
@@ -26,7 +26,7 @@ fun testY() {
     val interface_as_fun = Y.<!UNRESOLVED_REFERENCE!>A<!>()
     val interface_as_val = Y.A
 
-    val object_as_fun = Y.<!HIDDEN!>B<!>()
+    val object_as_fun = Y.<!INVISIBLE_REFERENCE!>B<!>()
     val class_as_val = Y.C
 }
 

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

@@ -19,15 +19,15 @@ open class A {
 fun fromOutside() {
     devNull(A.internal_val)
     devNull(A.public_val)
-    devNull(A.<!HIDDEN!>private_val<!>)
+    devNull(A.<!INVISIBLE_REFERENCE!>private_val<!>)
-    devNull(A.<!HIDDEN!>protected_val<!>)
+    devNull(A.<!INVISIBLE_REFERENCE!>protected_val<!>)
 }
 
 class B: A() {
     fun fromSubclass() {
         devNull(A.internal_val)
         devNull(A.public_val)
-        devNull(A.<!HIDDEN!>private_val<!>)
+        devNull(A.<!INVISIBLE_REFERENCE!>private_val<!>)
         devNull(A.protected_val)
     }
 }

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

@@ -35,7 +35,7 @@ class G : F() {
 }
 
 fun test_fun_stays_protected(g: G) {
-    g.<!HIDDEN!>protected_fun<!>()
+    g.<!INVISIBLE_REFERENCE!>protected_fun<!>()
 }
 
 //------------

compiler/testData/diagnostics/tests/scopes/inheritance/statics/hidePrivateByPublic.fir.kt

@@ -23,8 +23,8 @@ class B extends A {
 // FILE: test.kt
 
 fun test() {
-    A.<!HIDDEN!>a<!>
+    A.<!INVISIBLE_REFERENCE!>a<!>
-    A.<!HIDDEN!>foo<!>()
+    A.<!INVISIBLE_REFERENCE!>foo<!>()
     A.b
     A.bar()
     B.a

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

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

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

@@ -10,7 +10,7 @@ class B : A() {
 }
 
 fun test(b: B) {
-    b.<!HIDDEN!>x<!>()
+    b.<!INVISIBLE_REFERENCE!>x<!>()
 }
 
 

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) {
-    a.<!HIDDEN, HIDDEN!>i<!>++
+    a.<!INVISIBLE_REFERENCE, INVISIBLE_REFERENCE!>i<!>++
     a.j++
 }

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

@@ -7,14 +7,14 @@ open class Some {
 
 class SomeSubclass : Some() {
     fun test() {
-        this.<!HIDDEN!>privateField<!> // 1. Unresolved reference
+        this.<!INVISIBLE_REFERENCE!>privateField<!> // 1. Unresolved reference
     }
 }
 
 fun test() {
     val s2 = Some()
-    s2.<!HIDDEN!>privateField<!> // 2. Can't access to 'privateField' in Some
+    s2.<!INVISIBLE_REFERENCE!>privateField<!> // 2. Can't access to 'privateField' in Some
 
     val s1 = SomeSubclass()
-    s1.<!HIDDEN!>privateField<!> // 3. Unresolved reference
+    s1.<!INVISIBLE_REFERENCE!>privateField<!> // 3. Unresolved reference
 }

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

@@ -8,7 +8,7 @@ object MyObject {
 
 fun test1() {
 
-    doSmth(MyObject.<!HIDDEN!>message<!>)
+    doSmth(MyObject.<!INVISIBLE_REFERENCE!>message<!>)
 }
 
 class Test {
@@ -17,7 +17,7 @@ class Test {
   }
 
   fun test2() {
-      doSmth(MyObject1.<!HIDDEN!>message<!>)
+      doSmth(MyObject1.<!INVISIBLE_REFERENCE!>message<!>)
   }
 }
 

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

@@ -14,6 +14,6 @@ import a.C
 
 class A : C() {
     fun test() {
-        val v = <!HIDDEN!>myValue<!>
+        val v = <!INVISIBLE_REFERENCE!>myValue<!>
     }
 }

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

@@ -11,6 +11,6 @@ class C() {
 
 fun box(): String {
     val c = C()
-    if (c.<!HIDDEN!>f<!> != 610) return "fail"
+    if (c.<!INVISIBLE_REFERENCE!>f<!> != 610) return "fail"
     return "OK"
 }

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

@@ -12,5 +12,5 @@ class C: A() {
 }
 
 class D {
-    fun qux() { B().<!HIDDEN!>foo<!>() }
+    fun qux() { B().<!INVISIBLE_REFERENCE!>foo<!>() }
 }

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

@@ -8,6 +8,6 @@ class Foo : BaseClass() {
     fun bar() {
         val f = foo()
         f.x
-        f.<!HIDDEN!>y<!>
+        f.<!INVISIBLE_REFERENCE!>y<!>
     }
 }

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

@@ -39,20 +39,20 @@ class KotlinClass2 : JavaClass() {
 }
 
 fun test(a: KotlinClass, b: KotlinClass2) {
-    a.<!HIDDEN!>foo<!>() // Error, protected_and_package declared in different package
+    a.<!INVISIBLE_REFERENCE!>foo<!>() // Error, protected_and_package declared in different package
-    b.<!HIDDEN!>foo<!>() // Error, protected visibility in same package (but could be protected_and_package)
+    b.<!INVISIBLE_REFERENCE!>foo<!>() // Error, protected visibility in same package (but could be protected_and_package)
 
-    a.<!HIDDEN!>field<!>
+    a.<!INVISIBLE_REFERENCE!>field<!>
 
-    JavaClass.<!HIDDEN!>bar1<!>()
+    JavaClass.<!INVISIBLE_REFERENCE!>bar1<!>()
-    JavaClass.<!HIDDEN!>CONST1<!>
+    JavaClass.<!INVISIBLE_REFERENCE!>CONST1<!>
 
     KotlinClass.<!UNRESOLVED_REFERENCE!>bar1<!>() // Currently it's unresolved, but it should be prohibited even in case it would be resolved
     KotlinClass.<!UNRESOLVED_REFERENCE!>CONST1<!>
 
-    JavaClassSamePackage.<!HIDDEN!>bar1<!>()
+    JavaClassSamePackage.<!INVISIBLE_REFERENCE!>bar1<!>()
     JavaClassSamePackage.bar2()
 
-    JavaClassSamePackage.<!HIDDEN!>CONST1<!>
+    JavaClassSamePackage.<!INVISIBLE_REFERENCE!>CONST1<!>
     JavaClassSamePackage.CONST2
 }

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

@@ -4,8 +4,8 @@ open class A {
 
     fun bar(x: B) {
         x.foo() // OK, foo declared in A
-        x.<!HIDDEN!>baz<!>() // Declared in B
+        x.<!INVISIBLE_REFERENCE!>baz<!>() // Declared in B
-        x.<!HIDDEN!>foobaz<!>() // Declared in B
+        x.<!INVISIBLE_REFERENCE!>foobaz<!>() // Declared in B
     }
 }
 

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

@@ -40,6 +40,6 @@ class B : A() {
 }
 
 fun baz(a: A) {
-    a.<!HIDDEN!>foo<!>
+    a.<!INVISIBLE_REFERENCE!>foo<!>
     a.bar = a.bar + ""
 }

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

@@ -27,5 +27,5 @@ class B : A() {
 }
 
 fun baz(a: A) {
-    a.<!HIDDEN!>foo<!> { }
+    a.<!INVISIBLE_REFERENCE!>foo<!> { }
 }

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

@@ -40,8 +40,8 @@ class B {
 }
 
 fun test3(a: A) {
-    a.<!HIDDEN!>v<!> //todo .bMethod()
+    a.<!INVISIBLE_REFERENCE!>v<!> //todo .bMethod()
-    a.<!HIDDEN!>f<!>(0, 1) //todo .bMethod()
+    a.<!INVISIBLE_REFERENCE!>f<!>(0, 1) //todo .bMethod()
 }
 
 interface T
@@ -54,7 +54,7 @@ open class C : T {
 }
 
 fun test4(c: C) {
-    c.<!HIDDEN, HIDDEN!>i<!>++
+    c.<!INVISIBLE_REFERENCE, INVISIBLE_REFERENCE!>i<!>++
 }
 
 class D : C() {
@@ -78,7 +78,7 @@ class F : C() {
 
 class G : T {
     fun test8(c: C) {
-        doSmth(c.<!HIDDEN!>i<!>)
+        doSmth(c.<!INVISIBLE_REFERENCE!>i<!>)
     }
 }
 
@@ -91,5 +91,5 @@ import test_visibility.*
 
 fun test() {
     internal_fun()
-    <!HIDDEN!>private_fun<!>()
+    <!INVISIBLE_REFERENCE!>private_fun<!>()
 }

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

@@ -25,15 +25,15 @@ import a.PO
 fun test() {
     val y = makeA()
     y.bar()
-    <!HIDDEN!>foo<!>()
+    <!INVISIBLE_REFERENCE!>foo<!>()
 
-    val u : A = <!HIDDEN!>A<!>()
+    val u : A = <!INVISIBLE_REFERENCE!>A<!>()
     val a : java.util.Arrays.ArrayList<Int>;
 
-    val po = <!HIDDEN!>PO<!>
+    val po = <!INVISIBLE_REFERENCE!>PO<!>
 }
 
-class B : <!EXPOSED_SUPER_CLASS, HIDDEN!>A<!>() {}
+class B : <!EXPOSED_SUPER_CLASS, INVISIBLE_REFERENCE!>A<!>() {}
 
 class Q {
     class W {

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

@@ -26,17 +26,17 @@ package a
 fun test() {
     val y = makeA()
     y.bar()
-    <!HIDDEN!>foo<!>()
+    <!INVISIBLE_REFERENCE!>foo<!>()
 
-    val u : A = <!HIDDEN!>A<!>()
+    val u : A = <!INVISIBLE_REFERENCE!>A<!>()
 
-    val z = <!HIDDEN!>x<!>
+    val z = <!INVISIBLE_REFERENCE!>x<!>
-    <!HIDDEN!>x<!> = 30
+    <!INVISIBLE_REFERENCE!>x<!> = 30
 
-    val po = <!HIDDEN!>PO<!>
+    val po = <!INVISIBLE_REFERENCE!>PO<!>
 }
 
-class B : <!EXPOSED_SUPER_CLASS, HIDDEN!>A<!>() {}
+class B : <!EXPOSED_SUPER_CLASS, INVISIBLE_REFERENCE!>A<!>() {}
 
 class Q {
     class W {

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

@@ -38,5 +38,5 @@ open class B3 {
 
 class A3 : B3 {
     constructor()
-    constructor(x: Int) : <!HIDDEN!>super<!>()
+    constructor(x: Int) : <!INVISIBLE_REFERENCE!>super<!>()
 }

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

@@ -5,9 +5,9 @@ import JavaClass
 
 fun foo(javaClass: JavaClass) {
     javaClass.somethingPublic
-    javaClass.<!HIDDEN!>somethingProtected<!>
+    javaClass.<!INVISIBLE_REFERENCE!>somethingProtected<!>
-    javaClass.<!HIDDEN!>somethingPrivate<!>
+    javaClass.<!INVISIBLE_REFERENCE!>somethingPrivate<!>
-    javaClass.<!HIDDEN!>somethingPackage<!>
+    javaClass.<!INVISIBLE_REFERENCE!>somethingPackage<!>
     javaClass.somethingPublic = 1
 }
 

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

@@ -4,9 +4,9 @@ package k
 import JavaClass
 
 fun foo(javaClass: JavaClass) {
-    val v = javaClass.<!HIDDEN!>something<!>
+    val v = javaClass.<!INVISIBLE_REFERENCE!>something<!>
-    javaClass.<!HIDDEN!>something<!> = 1
+    javaClass.<!INVISIBLE_REFERENCE!>something<!> = 1
-    javaClass.<!HIDDEN, HIDDEN!>something<!>++
+    javaClass.<!INVISIBLE_REFERENCE, INVISIBLE_REFERENCE!>something<!>++
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/PackageLocal.fir.kt

@@ -4,7 +4,7 @@ package k
 import JavaClass
 
 fun foo(javaClass: JavaClass) {
-    javaClass.<!HIDDEN!>doSomething<!> { }
+    javaClass.<!INVISIBLE_REFERENCE!>doSomething<!> { }
 }
 
 // FILE: KotlinFile2.kt

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Private.fir.kt

@@ -1,7 +1,7 @@
 // !WITH_NEW_INFERENCE
 // FILE: KotlinFile.kt
 fun foo(javaClass: JavaClass) {
-    javaClass.<!HIDDEN!>doSomething<!> { }
+    javaClass.<!INVISIBLE_REFERENCE!>doSomething<!> { }
 }
 
 // FILE: JavaClass.java

compiler/testData/diagnostics/tests/syntheticExtensions/samAdapters/Protected.fir.kt

@@ -4,7 +4,7 @@ package k
 import JavaClass
 
 fun foo(javaClass: JavaClass) {
-    javaClass.<!HIDDEN!>doSomething<!> {
+    javaClass.<!INVISIBLE_REFERENCE!>doSomething<!> {
         bar()
     }
 }

compiler/testData/diagnostics/tests/typealias/privateInFile.fir.kt

@@ -5,7 +5,7 @@ private class C {
 
 private typealias TA = C
 
-private val test1: C = <!HIDDEN!>C<!>()
+private val test1: C = <!INVISIBLE_REFERENCE!>C<!>()
 private val test1co: C.Companion = <!INITIALIZER_TYPE_MISMATCH!>C<!>
 
 private val test2: TA = <!INITIALIZER_TYPE_MISMATCH!>TA(<!NO_VALUE_FOR_PARAMETER!>)<!><!>

compiler/testData/diagnostics/tests/typealias/typeAliasConstructor.fir.kt

@@ -20,5 +20,5 @@ typealias TO = AnObject
 val test6 = <!UNRESOLVED_REFERENCE!>TI<!>()
 val test6a = <!UNRESOLVED_REFERENCE!>Interface<!>()
 
-val test7 = <!HIDDEN!>TO<!>()
+val test7 = <!INVISIBLE_REFERENCE!>TO<!>()
-val test7a = <!HIDDEN!>AnObject<!>()
+val test7a = <!INVISIBLE_REFERENCE!>AnObject<!>()

compiler/testData/diagnostics/tests/typealias/typeAliasConstructorWrongClass.fir.kt

@@ -12,13 +12,13 @@ val test2a = AnnotationClass()
 
 enum class EnumClass { VALUE1, VALUE2 }
 typealias Test3 = EnumClass
-val test3 = <!HIDDEN!>Test3<!>()
+val test3 = <!INVISIBLE_REFERENCE!>Test3<!>()
-val test3a = <!HIDDEN!>EnumClass<!>()
+val test3a = <!INVISIBLE_REFERENCE!>EnumClass<!>()
 
 sealed class SealedClass
 typealias Test4 = SealedClass
-val test4 = <!HIDDEN!>Test4<!>()
+val test4 = <!INVISIBLE_REFERENCE!>Test4<!>()
-val test4a = <!HIDDEN!>SealedClass<!>()
+val test4a = <!INVISIBLE_REFERENCE!>SealedClass<!>()
 
 class Outer {
     inner class Inner

compiler/testData/diagnostics/tests/unsignedTypes/callDefaultConstructorOfUnsignedType.fir.kt

@@ -1 +1 @@
-val foo = <!HIDDEN!>UInt<!>()
+val foo = <!INVISIBLE_REFERENCE!>UInt<!>()

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

@@ -33,5 +33,5 @@ class Test<in I> {
 }
 
 fun <I> test(t: Test<I>) {
-    t.apply(t.<!HIDDEN!>foo<!>())
+    t.apply(t.<!INVISIBLE_REFERENCE!>foo<!>())
 }

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

@@ -33,5 +33,5 @@ class Test<in I, out O> {
 }
 
 fun <I, O> test(t: Test<I, O>) {
-    t.apply(t.<!HIDDEN!>i<!>)
+    t.apply(t.<!INVISIBLE_REFERENCE!>i<!>)
 }

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

@@ -33,5 +33,5 @@ class Test<in I, out O> {
 }
 
 fun <I, O> test(t: Test<I, O>) {
-    t.<!HIDDEN!>i<!> = getT()
+    t.<!INVISIBLE_REFERENCE!>i<!> = getT()
 }

compiler/testData/diagnostics/testsWithStdLib/CallCompanionProtectedNonStatic.fir.kt

@@ -74,20 +74,20 @@ class Derived : Base() {
 
 class Other {
     fun test(base: Base, derived: Derived) {
-        base.<!HIDDEN!>foo<!>()
+        base.<!INVISIBLE_REFERENCE!>foo<!>()
         base.<!UNRESOLVED_REFERENCE!>gav<!>()
         base.<!UNRESOLVED_REFERENCE!>bar<!>()
-        derived.<!HIDDEN!>foo<!>()
+        derived.<!INVISIBLE_REFERENCE!>foo<!>()
         derived.<!UNRESOLVED_REFERENCE!>gav<!>()
         derived.<!UNRESOLVED_REFERENCE!>bar<!>()
     }
 }
 
 fun top(base: Base, derived: Derived) {
-    base.<!HIDDEN!>foo<!>()
+    base.<!INVISIBLE_REFERENCE!>foo<!>()
     base.<!UNRESOLVED_REFERENCE!>bar<!>()
     base.<!UNRESOLVED_REFERENCE!>gav<!>()
-    derived.<!HIDDEN!>foo<!>()
+    derived.<!INVISIBLE_REFERENCE!>foo<!>()
     derived.<!UNRESOLVED_REFERENCE!>bar<!>()
     derived.<!UNRESOLVED_REFERENCE!>gav<!>()
 }