[FIR] Fix effective visibility calculation & relevant test data

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

@@ -15,7 +15,7 @@ fun test(e: MyException, stream: PrintStream) {
     val result = e.getLocalizedMessage()
 }
 
-fun test(e: YourException, stream: PrintStream) {
+fun test(<!EXPOSED_PARAMETER_TYPE!>e: YourException<!>, stream: PrintStream) {
     e.printStackTrace()
     e.printStackTrace(stream)
     val result = e.getLocalizedMessage()

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

@@ -6,14 +6,12 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
 import com.intellij.psi.PsiElement
-import org.jetbrains.kotlin.diagnostics.DiagnosticFactory3
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
+import org.jetbrains.kotlin.fir.analysis.diagnostics.FirDiagnosticFactory3
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.analysis.diagnostics.onSource
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.fir.types.FirTypeRef
 import org.jetbrains.kotlin.fir.types.coneTypeSafe
@@ -111,8 +109,8 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
         }
     }
 
-    private inline fun <reified E : PsiElement> DiagnosticReporter.reportExposure(
+    private inline fun <reified E : FirSourceElement, P : PsiElement> DiagnosticReporter.reportExposure(
-        error: DiagnosticFactory3<E, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>,
+        error: FirDiagnosticFactory3<E, P, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>,
         restrictingDeclaration: DeclarationWithRelation,
         elementVisibility: FirEffectiveVisibility,
         restrictingVisibility: FirEffectiveVisibility,
@@ -120,8 +118,8 @@ object FirExposedVisibilityChecker : FirDeclarationChecker<FirMemberDeclaration>
     ) {
         source?.let {
             report(
-                error.onSource(
+                error.on(
-                    it,
+                    it as E,
                     elementVisibility,
                     restrictingDeclaration,
                     restrictingVisibility

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

@@ -71,5 +71,6 @@ class FirDefaultErrorMessages : DefaultErrorMessages.Extension {
             map.put(EXPOSED_FUNCTION_RETURN_TYPE, "{0} function exposes its {2} return type{1}", TO_STRING, TO_STRING, TO_STRING)
             map.put(EXPOSED_RECEIVER_TYPE, "{0} member exposes its {2} receiver type{1}", TO_STRING, TO_STRING, TO_STRING)
             map.put(EXPOSED_PARAMETER_TYPE, "{0} function exposes its {2} parameter type{1}", TO_STRING, TO_STRING, TO_STRING)
+        }
     }
 }

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

@@ -14,6 +14,8 @@ import org.jetbrains.kotlin.fir.symbols.AbstractFirBasedSymbol
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
 import org.jetbrains.kotlin.psi.KtDeclaration
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
+import org.jetbrains.kotlin.psi.KtParameter
+import org.jetbrains.kotlin.psi.KtTypeReference
 
 object FirErrors {
     val UNRESOLVED_REFERENCE by error1<FirSourceElement, PsiElement, String?>()
@@ -49,11 +51,11 @@ object FirErrors {
     val NON_PRIVATE_CONSTRUCTOR_IN_SEALED by existing<FirSourceElement, PsiElement>(Errors.NON_PRIVATE_CONSTRUCTOR_IN_SEALED)
 
     // Exposed visibility group
-    val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<FirSourceElement, PsiElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
-    val EXPOSED_FUNCTION_RETURN_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_FUNCTION_RETURN_TYPE by error3<FirSourceElement, PsiElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
-    val EXPOSED_RECEIVER_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_RECEIVER_TYPE by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
-    val EXPOSED_PROPERTY_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_PROPERTY_TYPE by error3<FirSourceElement, PsiElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
-    val EXPOSED_PARAMETER_TYPE by error3<FirSourceElement, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
+    val EXPOSED_PARAMETER_TYPE by error3<FirSourceElement, KtParameter, FirEffectiveVisibility, DeclarationWithRelation, FirEffectiveVisibility>()
 
     val REPEATED_MODIFIER by error1<FirSourceElement, PsiElement, KtModifierKeywordToken>()
     val REDUNDANT_MODIFIER by error2<FirSourceElement, PsiElement, KtModifierKeywordToken, KtModifierKeywordToken>()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/FirEffectiveVisibilityUtils.kt

@@ -10,6 +10,8 @@ import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirEffectiveVisibility.*
 import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.resolve.declaredMemberScopeProvider
+import org.jetbrains.kotlin.fir.resolve.firProvider
 import org.jetbrains.kotlin.fir.resolve.firSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
@@ -34,14 +36,27 @@ fun ConeKotlinType.leastPermissiveDescriptor(session: FirSession, base: FirEffec
 
 fun FirMemberDeclaration.firEffectiveVisibility(
     session: FirSession, visibility: Visibility = this.visibility, checkPublishedApi: Boolean = false
-): FirEffectiveVisibility =
+): FirEffectiveVisibility {
-    lowerBound(
+    val containing = this.containingClass(session)
+    return lowerBound(
         visibility.firEffectiveVisibility(session, this),
-        this.containingClass(session)?.firEffectiveVisibility(session, checkPublishedApi) ?: Public
+        this.effectiveVisibility,
+        containing?.firEffectiveVisibility(session, checkPublishedApi) ?: Public,
+        containing?.effectiveVisibility ?: Public
     )
+}
 
-private fun lowerBound(first: FirEffectiveVisibility, second: FirEffectiveVisibility) =
+
-    first.lowerBound(second)
+private fun lowerBound(vararg elements: FirEffectiveVisibility): FirEffectiveVisibility {
+    if (elements.size < 2) {
+        throw IllegalArgumentException("Number of elements must be greater than 1")
+    }
+    var result = elements[0]
+    for (el in elements) {
+        result = result.lowerBound(el)
+    }
+    return result
+}
 
 private fun FirMemberDeclaration.containingClass(session: FirSession): FirRegularClass? {
     val classId = when (this) {
@@ -50,7 +65,9 @@ private fun FirMemberDeclaration.containingClass(session: FirSession): FirRegula
         else -> null
     } ?: return null
     if (classId.isLocal) return null
-    return session.firSymbolProvider.getClassLikeSymbolByFqName(classId)?.fir as? FirRegularClass
+    val buffer = session.declaredMemberScopeProvider.getClassByClassId(classId)
+    return (session.firSymbolProvider.getClassLikeSymbolByFqName(classId)?.fir as? FirRegularClass)
+        ?: (session.declaredMemberScopeProvider.getClassByClassId(classId) as? FirRegularClass)
 }
 
 private fun Visibility.forVisibility(
@@ -63,7 +80,8 @@ private fun Visibility.forVisibility(
         Visibilities.PUBLIC -> Public
         Visibilities.LOCAL -> Local
         // NB: visibility must be already normalized here, so e.g. no JavaVisibilities are possible at this point
-        else -> throw AssertionError("Visibility $name is not allowed in forVisibility")
+        // TODO: else -> throw AssertionError("Visibility $name is not allowed in forVisibility")
+        else -> Private
     }
 
 class DeclarationWithRelation internal constructor(val declaration: FirMemberDeclaration, private val relation: RelationToType) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/scopes/impl/FirDeclaredMemberScopeProvider.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.fir.scopes.impl
 
 import org.jetbrains.kotlin.fir.FirSessionComponent
 import org.jetbrains.kotlin.fir.declarations.FirClass
+import org.jetbrains.kotlin.fir.declarations.classId
 import org.jetbrains.kotlin.fir.resolve.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.declaredMemberScopeProvider
 import org.jetbrains.kotlin.fir.scopes.FirScope
@@ -18,6 +19,24 @@ class FirDeclaredMemberScopeProvider : FirSessionComponent {
     private val declaredMemberCache = mutableMapOf<FirClass<*>, FirScope>()
     private val nestedClassifierCache = mutableMapOf<FirClass<*>, FirNestedClassifierScope>()
 
+    fun getClassByClassId(classId: ClassId): FirClass<*>? {
+        for ((clazz, _) in declaredMemberCache) {
+            if (clazz.classId.packageFqName == classId.packageFqName
+                && clazz.classId.relativeClassName == classId.relativeClassName
+            ) {
+                return clazz
+            }
+        }
+        for ((clazz, _) in nestedClassifierCache) {
+            if (clazz.classId.packageFqName == classId.packageFqName
+                && clazz.classId.relativeClassName == classId.relativeClassName
+            ) {
+                return clazz
+            }
+        }
+        return null
+    }
+
     fun declaredMemberScope(
         klass: FirClass<*>,
         useLazyNestedClassifierScope: Boolean,

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
-fun quux() = E
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun quux() = E<!>

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

@@ -3,10 +3,10 @@ internal class My
 class Your
 
 // Both arguments should be exposed
-fun foo(my: My, f: (My) -> Unit) = f(my)
+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
-fun gav(f: () -> My) = f()
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun gav(<!EXPOSED_PARAMETER_TYPE!>f: () -> My<!>) = f()<!>

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
-    val x = My()
+    <!EXPOSED_PROPERTY_TYPE!>val x = My()<!>
     // valid, private from internal
     private fun bar() = My()
     // valid, internal from internal
     internal var y: My? = null
     // error, protected from internal
-    protected fun baz() = Your()
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun baz() = Your()<!>
 }
 
 internal class Their: His() {

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

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

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

@@ -1,14 +1,14 @@
 // invalid, depends on local class
-fun foo() = run {
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = run {
     class A
     A()
-}
+}<!>
 
 // invalid, depends on local class
-fun gav() = {
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun gav() = {
     class B
     B()
-}
+}<!>
 
 abstract class My
 

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

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

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

@@ -4,9 +4,9 @@ class Something {
     internal val internalVal1 = object { override fun toString() = "!" }
     private val privateVal1 = object { override fun toString() = "!" }
 
-    public val publicVal2 = run { class A; A() }
+    <!EXPOSED_PROPERTY_TYPE!>public val publicVal2 = run { class A; A() }<!>
-    protected val protectedVal2 = run { class A; A() }
+    <!EXPOSED_PROPERTY_TYPE!>protected val protectedVal2 = run { class A; A() }<!>
-    internal val internalVal2 = 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() = "!" }
@@ -14,8 +14,8 @@ class Something {
     internal fun internalFun1() = object { override fun toString() = "!" }
     private fun privateFun1() = object { override fun toString() = "!" }
 
-    public fun publicFun2() = run { class A; A() }
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>public fun publicFun2() = run { class A; A() }<!>
-    protected fun protectedFun2() = run { class A; A() }
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun protectedFun2() = run { class A; A() }<!>
-    internal fun internalFun2() = 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/localInPropertyType.fir.kt

@@ -2,27 +2,27 @@ class My<T>(val value: T)
 
 open class Base
 
-val invalid1 = run {
+<!EXPOSED_PROPERTY_TYPE!>val invalid1 = run {
     class Local
     My(Local())
-}
+}<!>
 
 val invalid2 = My(object {})
 
 val invalid3 = My(object : Base() {})
 
-val invalid4 = run {
+<!EXPOSED_PROPERTY_TYPE!>val invalid4 = run {
     class Local
     My(My(Local()))
-}
+}<!>
 
-val invalid5 = run {
+<!EXPOSED_PROPERTY_TYPE!>val 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() {
-    fun foo(arg: Inter): Inter = arg
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>arg: Inter<!>): Inter = arg<!>
-    val x: Inter? = null
+    <!EXPOSED_PROPERTY_TYPE!>val x: Inter? = null<!>
 }
 
 internal open class Inter
@@ -10,21 +10,21 @@ internal open class Inter
 open class Test {
     protected class Protected
 
-    fun foo(x: Protected) = x
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
 
     interface NestedInterface {
-        fun create(x: Protected)
+        fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>)
     }
 
     class NestedClass {
-        fun create(x: Protected) = x
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
     }
 
     object NestedObject {
-        fun create(x: Protected) = x
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun create(<!EXPOSED_PARAMETER_TYPE!>x: Protected<!>) = x<!>
     }
 
     companion object {
-        fun create(x: Protected) = x
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun 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(val foo: Foo)
+class Bar private constructor(<!EXPOSED_PROPERTY_TYPE!>val foo: Foo<!>)

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

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

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>(val x: My): Base() {
+public class Derived<T: My>(<!EXPOSED_PARAMETER_TYPE, EXPOSED_PROPERTY_TYPE!>val x: My<!>): Base() {
 
-    constructor(xx: My?, x: My): this(xx ?: x)
+    constructor(<!EXPOSED_PARAMETER_TYPE!>xx: My?<!>, <!EXPOSED_PARAMETER_TYPE!>x: My<!>): this(xx ?: x)
 
-    val y: Base? = null
+    <!EXPOSED_PROPERTY_TYPE!>val y: Base? = null<!>
 
-    val My.z: Int
+    val <!EXPOSED_RECEIVER_TYPE!>My<!>.z: Int
         get() = 42
 
-    fun foo(m: My): My = m
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo(<!EXPOSED_PARAMETER_TYPE!>m: My<!>): My = m<!>
 
-    fun My.bar(): My = this
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>fun <!EXPOSED_RECEIVER_TYPE!>My<!>.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
-    abstract fun give(): List<My>
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>abstract fun give(): List<My><!>
 }
 
 // invalid, List<My> is effectively internal

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

@@ -16,7 +16,7 @@ private class TopLevelClass {
     }
 }
 
-private enum class TopLevelEnum(private val e: NestedEnum) {
+<!EXPOSED_FUNCTION_RETURN_TYPE, EXPOSED_FUNCTION_RETURN_TYPE!>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() {
-    protected fun foo(): Nested? = null
+    <!EXPOSED_FUNCTION_RETURN_TYPE!>protected fun foo(): Nested? = null<!>
 }
 
 private fun foo(): Nested? = null

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

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

compiler/testData/diagnostics/tests/inline/nonPublicMember/publishedApi.fir.kt

@@ -1,7 +1,7 @@
 // !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE -NOTHING_TO_INLINE
 
 
-inline fun call(a: A) {
+inline fun call(<!EXPOSED_PARAMETER_TYPE!>a: A<!>) {
     a.test()
 
     privateFun()

compiler/testData/diagnostics/tests/inline/privateClass.fir.kt

@@ -6,7 +6,7 @@ private class S public constructor() {
     }
 }
 
-internal inline fun x(s: S, z: () -> Unit) {
+internal inline fun x(<!EXPOSED_PARAMETER_TYPE!>s: S<!>, z: () -> Unit) {
     z()
     S()
     s.a()

compiler/testData/diagnostics/tests/inline/publishedApi.fir.kt

@@ -1,5 +1,5 @@
 // !DIAGNOSTICS: -EXPOSED_PARAMETER_TYPE -NOTHING_TO_INLINE
-inline fun call(a: A) {
+inline fun call(<!EXPOSED_PARAMETER_TYPE!>a: A<!>) {
     a.test()
     publishedTopLevel()
     

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

@@ -16,10 +16,10 @@ class MyJavaClass {
 //FILE:a.kt
 package a
 
-val mc = MyJavaClass()
+<!EXPOSED_PROPERTY_TYPE!>val mc = MyJavaClass()<!>
 val x = MyJavaClass.staticMethod()
 val y = MyJavaClass.NestedClass.staticMethodOfNested()
-val z = MyJavaClass.NestedClass()
+<!EXPOSED_PROPERTY_TYPE!>val 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
 }
 
-fun makeA() = A()
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>
 
 private object PO {}
 

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

@@ -17,7 +17,7 @@ class E private constructor() {
 }
 
 val a = A
-val b = B
+<!EXPOSED_PROPERTY_TYPE!>val 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() {}
 
-fun makeA() = A()
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun makeA() = A()<!>
 
 private object PO {}
 

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

@@ -16,7 +16,7 @@ private fun bar() {
     x = 20
 }
 
-fun makeA() = A()
+<!EXPOSED_FUNCTION_RETURN_TYPE!>fun 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
-        fun foo() = A()
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = A()<!>
     }.foo()
 }
 
 private fun foo() = run {
     object {
         inner class A
-        fun foo() = A()
+        <!EXPOSED_FUNCTION_RETURN_TYPE!>fun foo() = A()<!>
     }.foo()
 }
 

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

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

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

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

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

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