[FIR] Cast error on the element name instead of the whole body

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

@@ -5,5 +5,5 @@ class A {
 }
 
 abstract class B {
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(str: String): A.InnerA<!>
+    fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(str: String): A.InnerA
 }

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

@@ -17,7 +17,7 @@ class Property {
     var var1: String
     var var2: String
     var var3: Int
-    <!EXPOSED_PROPERTY_TYPE!>var var4: A.AInnerPrivate<!>
+    var <!EXPOSED_PROPERTY_TYPE!>var4<!>: A.AInnerPrivate
     var var5: A.AInnerPublic
-    <!EXPOSED_PROPERTY_TYPE!>var var6: A.AInnerProtectedEnum<!>
+    var <!EXPOSED_PROPERTY_TYPE!>var6<!>: A.AInnerProtectedEnum
 }

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

@@ -2,7 +2,7 @@ class A {
     private inner class Inner
 }
 class B {
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias AInner = A.Inner<!>
+    typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>AInner<!> = A.Inner
     inner class Inner
 }
 
@@ -10,5 +10,5 @@ class C {
     typealias BInner = B.Inner
 }
 
-<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias AInner0 = A.Inner<!>
+typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>AInner0<!> = A.Inner
 typealias BInner0 = B.Inner

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirExposedVisibilityChecker.kt

@@ -5,7 +5,10 @@
 
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
+import com.intellij.lang.LighterASTNode
+import com.intellij.openapi.util.Ref
 import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiNameIdentifierOwner
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
@@ -15,6 +18,7 @@ import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
+import org.jetbrains.kotlin.lexer.KtTokens
 
 object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>() {
     override fun check(declaration: FirMemberDeclaration, context: CheckerContext, reporter: DiagnosticReporter) {
@@ -35,7 +39,7 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
                 restricting,
                 typeAliasVisibility,
                 restricting.firEffectiveVisibility(declaration.session),
-                declaration.source
+                declaration.source?.getIdentifierSource() ?: declaration.source
             )
         }
     }
@@ -51,7 +55,7 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
                     restricting,
                     functionVisibility,
                     restricting.firEffectiveVisibility(declaration.session),
-                    declaration.source
+                    declaration.source?.getIdentifierSource() ?: declaration.source
                 )
             }
         }
@@ -84,7 +88,7 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
                 restricting,
                 propertyVisibility,
                 restricting.firEffectiveVisibility(declaration.session),
-                declaration.source
+                declaration.source?.getIdentifierSource() ?: declaration.source
             )
         }
         checkMemberReceiver(declaration.receiverTypeRef, declaration, reporter)
@@ -127,4 +131,14 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
             )
         }
     }
+
+    private fun FirSourceElement.getIdentifierSource() = when (this) {
+        is FirPsiSourceElement<*> -> (this.psi as? PsiNameIdentifierOwner)?.nameIdentifier?.toFirPsiSourceElement()
+        is FirLightSourceElement -> {
+            val kidsRef = Ref<Array<LighterASTNode?>>()
+            this.tree.getChildren(this.element, kidsRef)
+            val identifier = kidsRef.get().find { it?.tokenType == KtTokens.IDENTIFIER }
+            identifier?.toFirLightSourceElement(this.tree.getStartOffset(identifier), this.tree.getEndOffset(identifier), this.tree)
+        }
+    }
 }

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

@@ -7,4 +7,4 @@ enum class E {
 fun foo() = E.values()
 fun bar() = E.valueOf("ENTRY")
 fun baz() = E.ENTRY
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun quux() = E<!>
+fun <!EXPOSED_FUNCTION_RETURN_TYPE!>quux<!>() = E

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

@@ -1,12 +0,0 @@
-internal class My
-
-class Your
-
-// Both arguments should be exposed
-fun foo(<!EXPOSED_PARAMETER_TYPE!>my: My<!>, <!EXPOSED_PARAMETER_TYPE!>f: (My) -> Unit<!>) = f(my)
-
-// Ok
-fun bar(your: Your, f: (Your) -> Unit) = f(your)
-
-// Exposed, returns My
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun gav(<!EXPOSED_PARAMETER_TYPE!>f: () -> My<!>) = f()<!>

compiler/testData/diagnostics/tests/exposed/functional.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 internal class My
 
 class Your

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

@@ -10,13 +10,13 @@ internal open class Your: My() {
 open class His: Your() {
     protected open class Nested
     // error, public from internal
-    <!EXPOSED_PROPERTY_TYPE!>val x = My()<!>
+    val <!EXPOSED_PROPERTY_TYPE!>x<!> = My()
     // valid, private from internal
     private fun bar() = My()
     // valid, internal from internal
     internal var y: My? = null
     // error, protected from internal
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun baz() = Your()<!>
+    protected fun <!EXPOSED_FUNCTION_RETURN_TYPE!>baz<!>() = Your()
 }
 
 internal class Their: His() {

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

@@ -1,10 +0,0 @@
-interface Your
-
-class My {
-    internal val x = object : Your {}
-
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>internal fun foo() = {
-        class Local
-        Local()
-    }()<!>
-}

compiler/testData/diagnostics/tests/exposed/internalFromLocal.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 interface Your
 
 class My {

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

@@ -1,18 +0,0 @@
-// invalid, depends on local class
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = run {
-    class A
-    A()
-}<!>
-
-// invalid, depends on local class
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun gav() = {
-    class B
-    B()
-}<!>
-
-abstract class My
-
-// valid, object literal here is effectively My
-fun bar() = run {
-    object: My() {}
-}

compiler/testData/diagnostics/tests/exposed/local.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // invalid, depends on local class
 fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>() = run {
     class A

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

@@ -2,27 +2,27 @@ class My<T>(val value: T)
 
 open class Base
 
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid1() = run {
+fun <!EXPOSED_FUNCTION_RETURN_TYPE!>invalid1<!>() = run {
     class Local
     My(Local())
-}<!>
+}
 
 fun invalid2() = My(object {})
 
 fun invalid3() = My(object : Base() {})
 
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid4() = run {
+fun <!EXPOSED_FUNCTION_RETURN_TYPE!>invalid4<!>() = run {
     class Local
     My(My(Local()))
-}<!>
+}
 
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun invalid5() = run {
+fun <!EXPOSED_FUNCTION_RETURN_TYPE!>invalid5<!>() = run {
     fun invalid5a() = run {
         class Local
         Local()
     }
     My(invalid5a())
-}<!>
+}
 
 // Valid: effectively Any
 fun valid1() = object {}

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

@@ -1,21 +0,0 @@
-class Something {
-    public val publicVal1 = object { override fun toString() = "!" }
-    protected val protectedVal1 = object { override fun toString() = "!" }
-    internal val internalVal1 = object { override fun toString() = "!" }
-    private val privateVal1 = object { override fun toString() = "!" }
-
-    <!EXPOSED_PROPERTY_TYPE!>public val publicVal2 = run { class A; A() }<!>
-    <!EXPOSED_PROPERTY_TYPE!>protected val protectedVal2 = run { class A; A() }<!>
-    <!EXPOSED_PROPERTY_TYPE!>internal val internalVal2 = run { class A; A() }<!>
-    private val privateVal2 = run { class A; A() }
-
-    public fun publicFun1() = object { override fun toString() = "!" }
-    protected fun protectedFun1() = object { override fun toString() = "!" }
-    internal fun internalFun1() = object { override fun toString() = "!" }
-    private fun privateFun1() = object { override fun toString() = "!" }
-
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>public fun publicFun2() = run { class A; A() }<!>
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun protectedFun2() = run { class A; A() }<!>
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>internal fun internalFun2() = run { class A; A() }<!>
-    private fun privateFun2() = run { class A; A() }
-}

compiler/testData/diagnostics/tests/exposed/localInMemberType.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 class Something {
     public val publicVal1 = object { override fun toString() = "!" }
     protected val protectedVal1 = object { override fun toString() = "!" }

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

@@ -2,27 +2,27 @@ class My<T>(val value: T)
 
 open class Base
 
-<!EXPOSED_PROPERTY_TYPE!>val invalid1 = run {
+val <!EXPOSED_PROPERTY_TYPE!>invalid1<!> = run {
     class Local
     My(Local())
-}<!>
+}
 
 val invalid2 = My(object {})
 
 val invalid3 = My(object : Base() {})
 
-<!EXPOSED_PROPERTY_TYPE!>val invalid4 = run {
+val <!EXPOSED_PROPERTY_TYPE!>invalid4<!> = run {
     class Local
     My(My(Local()))
-}<!>
+}
 
-<!EXPOSED_PROPERTY_TYPE!>val invalid5 = run {
+val <!EXPOSED_PROPERTY_TYPE!>invalid5<!> = run {
     fun invalid5a() = run {
         class Local
         Local()
     }
     My(invalid5a())
-}<!>
+}
 
 // Valid: effectively Any
 val valid1 = object {}

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

@@ -1,7 +1,7 @@
 // From KT-10753
 object My : Inter() {
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>arg: Inter<!>): Inter = arg<!>
+    fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>arg: Inter<!>): Inter = arg
-    <!EXPOSED_PROPERTY_TYPE!>val x: Inter? = null<!>
+    val <!EXPOSED_PROPERTY_TYPE!>x<!>: Inter? = null
 }
 
 internal open class Inter
@@ -10,21 +10,21 @@ internal open class Inter
 open class Test {
     protected class Protected
 
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
+    fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x
 
     interface NestedInterface {
         fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>)
     }
 
     class NestedClass {
-        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
+        fun <!EXPOSED_FUNCTION_RETURN_TYPE!>create<!>(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x
     }
 
     object NestedObject {
-        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
+        fun <!EXPOSED_FUNCTION_RETURN_TYPE!>create<!>(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x
     }
 
     companion object {
-        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
+        fun <!EXPOSED_FUNCTION_RETURN_TYPE!>create<!>(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x
     }
 }

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

@@ -1,3 +1,3 @@
 private enum class Foo { A, B }
 
-class Bar private constructor(<!EXPOSED_PROPERTY_TYPE!>val foo: Foo<!>)
+class Bar private constructor(val <!EXPOSED_PROPERTY_TYPE!>foo<!>: Foo)

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

@@ -1,3 +1,3 @@
 private enum class Foo { A, B }
 
-class Bar(<!EXPOSED_PARAMETER_TYPE, EXPOSED_PROPERTY_TYPE!>val foo: Foo<!>)
+class Bar(<!EXPOSED_PARAMETER_TYPE!>val <!EXPOSED_PROPERTY_TYPE!>foo<!>: Foo<!>)

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

@@ -12,5 +12,5 @@ class OuterDerived: Outer() {
     // valid, My has better visibility
     protected class His: Outer.My()
     // valid, My and Your have better visibility
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>override fun foo(<!EXPOSED_PARAMETER_TYPE!>my: Outer.My<!>) = Outer.Your()<!>
+    override fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>my: Outer.My<!>) = Outer.Your()
 }

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

@@ -9,5 +9,5 @@ class OuterDerived: Outer() {
     // valid, My has better visibility
     protected class His: Outer.My()
     // valid, My and Your have better visibility
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>override fun foo(<!EXPOSED_PARAMETER_TYPE!>my: Outer.My<!>) = Outer.Your()<!>
+    override fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>my: Outer.My<!>) = Outer.Your()
 }

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

@@ -6,18 +6,18 @@ public interface Your: My {
     fun <T: Base> foo(): T
 }
 
-public class Derived<T: My>(<!EXPOSED_PARAMETER_TYPE, EXPOSED_PROPERTY_TYPE!>val x: My<!>): Base() {
+public class Derived<T: My>(<!EXPOSED_PARAMETER_TYPE!>val <!EXPOSED_PROPERTY_TYPE!>x<!>: My<!>): Base() {
 
     constructor(<!EXPOSED_PARAMETER_TYPE!>xx: My?<!>, <!EXPOSED_PARAMETER_TYPE!>x: My<!>): this(xx ?: x)
 
-    <!EXPOSED_PROPERTY_TYPE!>val y: Base? = null<!>
+    val <!EXPOSED_PROPERTY_TYPE!>y<!>: Base? = null
 
     val <!EXPOSED_RECEIVER_TYPE!>My<!>.z: Int
         get() = 42
 
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>m: My<!>): My = m<!>
+    fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(<!EXPOSED_PARAMETER_TYPE!>m: My<!>): My = m
 
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun <!EXPOSED_RECEIVER_TYPE!>My<!>.bar(): My = this<!>
+    fun <!EXPOSED_RECEIVER_TYPE!>My<!>.<!EXPOSED_FUNCTION_RETURN_TYPE!>bar<!>(): My = this
 }
 
 

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

@@ -2,7 +2,7 @@ internal open class My
 
 abstract class Your {
     // invalid, List<My> is effectively internal
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>abstract fun give(): List<My><!>
+    abstract fun <!EXPOSED_FUNCTION_RETURN_TYPE!>give<!>(): List<My>
 }
 
 // invalid, List<My> is effectively internal

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

@@ -16,7 +16,7 @@ private class TopLevelClass {
     }
 }
 
-<!EXPOSED_FUNCTION_RETURN_TYPE, EXPOSED_FUNCTION_RETURN_TYPE!>private enum class TopLevelEnum(private val e: NestedEnum) {
+private enum class TopLevelEnum(private val e: NestedEnum) {
     E1(NestedEntry);
 
     private enum class NestedEnum {

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

@@ -7,7 +7,7 @@ open class Foo {
 }
 
 class Bar: Foo() {
-    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun foo(): Nested? = null<!>
+    protected fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>(): Nested? = null
 }
 
 private fun foo(): Nested? = null

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

@@ -14,5 +14,5 @@ package p1
 
 import p2.*
 
-<!EXPOSED_PROPERTY_TYPE!>val x: X = X()<!>
+val <!EXPOSED_PROPERTY_TYPE!>x<!>: X = X()
-<!EXPOSED_PROPERTY_TYPE!>val y: Y = <!INAPPLICABLE_CANDIDATE!>Y<!>()<!>
+val <!EXPOSED_PROPERTY_TYPE!>y<!>: Y = <!INAPPLICABLE_CANDIDATE!>Y<!>()

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

@@ -16,10 +16,10 @@ class MyJavaClass {
 //FILE:a.kt
 package a
 
-<!EXPOSED_PROPERTY_TYPE!>val mc = MyJavaClass()<!>
+val <!EXPOSED_PROPERTY_TYPE!>mc<!> = MyJavaClass()
 val x = MyJavaClass.staticMethod()
 val y = MyJavaClass.NestedClass.staticMethodOfNested()
-<!EXPOSED_PROPERTY_TYPE!>val z = MyJavaClass.NestedClass()<!>
+val <!EXPOSED_PROPERTY_TYPE!>z<!> = MyJavaClass.NestedClass()
 
 //FILE: b.kt
 package b

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

@@ -20,7 +20,7 @@ private fun bar() {
     xx = 30
 }
 
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>
+fun <!EXPOSED_FUNCTION_RETURN_TYPE!>makeA<!>() = A()
 
 private object PO {}
 

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

@@ -17,7 +17,7 @@ class E private constructor() {
 }
 
 val a = A
-<!EXPOSED_PROPERTY_TYPE!>val b = B<!>
+val <!EXPOSED_PROPERTY_TYPE!>b<!> = B
 val c = C
 val d = D
 val e = E(42)

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

@@ -9,7 +9,7 @@ private open class A {
 
 private fun foo() {}
 
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>
+fun <!EXPOSED_FUNCTION_RETURN_TYPE!>makeA<!>() = A()
 
 private object PO {}
 

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

@@ -16,7 +16,7 @@ private fun bar() {
     x = 20
 }
 
-<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>
+fun <!EXPOSED_FUNCTION_RETURN_TYPE!>makeA<!>() = A()
 
 private object PO {}
 

compiler/testData/diagnostics/tests/subtyping/nestedIntoLocalClasses.fir.kt

@@ -6,14 +6,14 @@ package p
 private fun foo(a: Int) = run {
     object {
         inner class A
-        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = A()<!>
+        fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>() = A()
     }.foo()
 }
 
 private fun foo() = run {
     object {
         inner class A
-        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = A()<!>
+        fun <!EXPOSED_FUNCTION_RETURN_TYPE!>foo<!>() = A()
     }.foo()
 }
 

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

@@ -7,39 +7,39 @@ class Outer {
     protected class Protected
     internal class Internal
 
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate1 = Private<!>
+    typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate1<!> = Private
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>protected typealias TestPrivate2 = Private<!>
+    protected typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate2<!> = Private
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestPrivate3 = Private<!>
+    internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate3<!> = Private
     private typealias TestPrivate4 = Private
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate5 = L<Private><!>
+    typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate5<!> = L<Private>
     typealias TestPrivate6 = L<TestPrivate1>
 
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestProtected1 = Protected<!>
+    typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected1<!> = Protected
     protected typealias TestProtected2 = Protected
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestProtected3 = Protected<!>
+    internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected3<!> = Protected
     private typealias TestProtected4 = Protected
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestProtected5 = L<Protected><!>
+    typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestProtected5<!> = L<Protected>
     typealias TestProtected6 = L<TestProtected1>
 
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal1 = Internal<!>
+    typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal1<!> = Internal
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>protected typealias TestInternal2 = Internal<!>
+    protected typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal2<!> = Internal
     internal typealias TestInternal3 = Internal
     private typealias TestInternal4 = Internal
-    <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal5 = L<Internal><!>
+    typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal5<!> = L<Internal>
     typealias TestInternal6 = L<TestInternal1>
 }
 
 private class Private
 internal class Internal
 
-<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate1 = Private<!>
+typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate1<!> = Private
-<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>internal typealias TestPrivate2 = Private<!>
+internal typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate2<!> = Private
 private typealias TestPrivate3 = Private
-<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestPrivate4 = L<Private><!>
+typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestPrivate4<!> = L<Private>
 typealias TestPrivate5 = L<TestPrivate1>
 
-<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal1 = Internal<!>
+typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal1<!> = Internal
 internal typealias TestInternal2 = Internal
 private typealias TestInternal3 = Internal
-<!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>typealias TestInternal4 = L<Internal><!>
+typealias <!EXPOSED_TYPEALIAS_EXPANDED_TYPE!>TestInternal4<!> = L<Internal>
 typealias TestInternal5 = L<TestInternal1>

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

@@ -4,5 +4,5 @@ class C {
 
 typealias CAlias = C
 
-<!EXPOSED_PROPERTY_TYPE!>val test1 = CAlias<!>
+val <!EXPOSED_PROPERTY_TYPE!>test1<!> = CAlias
-<!EXPOSED_PROPERTY_TYPE!>val test1a = C<!>
+val <!EXPOSED_PROPERTY_TYPE!>test1a<!> = C

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

@@ -10,6 +10,6 @@ package kotlin.sequences
 import p.*
 
 interface I {
-    <!EXPOSED_PROPERTY_TYPE!>val v1: FilteringSequence<!>
+    val <!EXPOSED_PROPERTY_TYPE!>v1<!>: FilteringSequence
-    <!EXPOSED_PROPERTY_TYPE!>val v2: IndexingSequence<String><!>
+    val <!EXPOSED_PROPERTY_TYPE!>v2<!>: IndexingSequence<String>
 }