[FIR] Add effective visibility to resolved status

This commit includes:
- introduce FirResolvedDeclarationStatus.effectiveVisibility
- replace FirEffectiveVisibility with EffectiveVisibility
- move calculation of effective visibility from FirEffectiveVisibilityResolver
  (which is deleted) to FirStatusResolver and FirDeserializer

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

@@ -11,9 +11,9 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
-import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.PrivateForInline
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
@@ -390,7 +390,7 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
         val CONFLICTING_OVERLOADS by error<FirSourceElement, PsiElement>(PositioningStrategy.DECLARATION_SIGNATURE_OR_DEFAULT) {
             parameter<Collection<AbstractFirBasedSymbol<*>>>("conflictingOverloads")
         }
-        val REDECLARATION by error<FirSourceElement, PsiElement>() {
+        val REDECLARATION by error<FirSourceElement, PsiElement> {
             parameter<Collection<AbstractFirBasedSymbol<*>>>("conflictingDeclarations")
         }
         val METHOD_OF_ANY_IMPLEMENTED_IN_INTERFACE by error<FirSourceElement, PsiElement>()
@@ -603,9 +603,9 @@ object DIAGNOSTICS_LIST : DiagnosticList() {
 }
 
 private val exposedVisibilityDiagnosticInit: DiagnosticBuilder.() -> Unit = {
-    parameter<FirEffectiveVisibility>("elementVisibility")
+    parameter<EffectiveVisibility>("elementVisibility")
     parameter<FirMemberDeclaration>("restrictingDeclaration")
-    parameter<FirEffectiveVisibility>("restrictingVisibility")
+    parameter<EffectiveVisibility>("restrictingVisibility")
 }
 
 private inline fun <reified P : PsiElement> DiagnosticGroup.exposedVisibilityError(

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

@@ -11,9 +11,9 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
-import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.FirSourceElement
 import org.jetbrains.kotlin.fir.analysis.diagnostics.SourceElementPositioningStrategies
 import org.jetbrains.kotlin.fir.declarations.FirCallableDeclaration
@@ -143,15 +143,15 @@ object FirErrors {
     val SUPERTYPES_FOR_ANNOTATION_CLASS by error0<FirSourceElement, KtClass>(SourceElementPositioningStrategies.SUPERTYPES_LIST)
 
     // Exposed visibility
-    val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<FirSourceElement, KtNamedDeclaration, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_TYPEALIAS_EXPANDED_TYPE by error3<FirSourceElement, KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_FUNCTION_RETURN_TYPE by error3<FirSourceElement, KtNamedDeclaration, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_FUNCTION_RETURN_TYPE by error3<FirSourceElement, KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_RECEIVER_TYPE by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
+    val EXPOSED_RECEIVER_TYPE by error3<FirSourceElement, KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
-    val EXPOSED_PROPERTY_TYPE by error3<FirSourceElement, KtNamedDeclaration, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_PROPERTY_TYPE by error3<FirSourceElement, KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR by warning3<FirSourceElement, KtNamedDeclaration, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
+    val EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR by warning3<FirSourceElement, KtNamedDeclaration, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>(SourceElementPositioningStrategies.DECLARATION_NAME)
-    val EXPOSED_PARAMETER_TYPE by error3<FirSourceElement, KtParameter, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
+    val EXPOSED_PARAMETER_TYPE by error3<FirSourceElement, KtParameter, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
-    val EXPOSED_SUPER_INTERFACE by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
+    val EXPOSED_SUPER_INTERFACE by error3<FirSourceElement, KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
-    val EXPOSED_SUPER_CLASS by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
+    val EXPOSED_SUPER_CLASS by error3<FirSourceElement, KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
-    val EXPOSED_TYPE_PARAMETER_BOUND by error3<FirSourceElement, KtTypeReference, FirEffectiveVisibility, FirMemberDeclaration, FirEffectiveVisibility>()
+    val EXPOSED_TYPE_PARAMETER_BOUND by error3<FirSourceElement, KtTypeReference, EffectiveVisibility, FirMemberDeclaration, EffectiveVisibility>()
 
     // Modifiers
     val INAPPLICABLE_INFIX_MODIFIER by error0<FirSourceElement, PsiElement>()

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

@@ -6,18 +6,17 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
 import org.jetbrains.kotlin.descriptors.ClassKind
-import org.jetbrains.kotlin.fir.FirEffectiveVisibility
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
-import org.jetbrains.kotlin.fir.FirEffectiveVisibilityImpl
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClass
 import org.jetbrains.kotlin.fir.analysis.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.analysis.diagnostics.reportOn
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.getEffectiveVisibility
 import org.jetbrains.kotlin.fir.resolve.fullyExpandedType
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.ensureResolved
+import org.jetbrains.kotlin.fir.typeContext
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
 
@@ -38,9 +37,9 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
     }
 
     private fun checkSupertypes(declaration: FirRegularClass, reporter: DiagnosticReporter, context: CheckerContext) {
-        val classVisibility = declaration.getEffectiveVisibility(context)
+        val classVisibility = declaration.effectiveVisibility
 
-        if (classVisibility == FirEffectiveVisibilityImpl.Local) return
+        if (classVisibility == EffectiveVisibility.Local) return
         val supertypes = declaration.superTypeRefs
         val isInterface = declaration.classKind == ClassKind.INTERFACE
         for (supertypeRef in supertypes) {
@@ -57,7 +56,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
                     if (isInterface) FirErrors.EXPOSED_SUPER_INTERFACE else FirErrors.EXPOSED_SUPER_CLASS,
                     classVisibility,
                     restricting,
-                    restricting.getEffectiveVisibility(context),
+                    restricting.effectiveVisibility,
                     context
                 )
             }
@@ -65,9 +64,9 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
     }
 
     private fun checkParameterBounds(declaration: FirRegularClass, reporter: DiagnosticReporter, context: CheckerContext) {
-        val classVisibility = declaration.getEffectiveVisibility(context)
+        val classVisibility = declaration.effectiveVisibility
 
-        if (classVisibility == FirEffectiveVisibilityImpl.Local) return
+        if (classVisibility == EffectiveVisibility.Local) return
         for (parameter in declaration.typeParameters) {
             for (bound in parameter.symbol.fir.bounds) {
                 val restricting = bound.coneType.findVisibilityExposure(context, classVisibility)
@@ -77,7 +76,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
                         FirErrors.EXPOSED_TYPE_PARAMETER_BOUND,
                         classVisibility,
                         restricting,
-                        restricting.getEffectiveVisibility(context),
+                        restricting.effectiveVisibility,
                         context
                     )
                 }
@@ -87,9 +86,9 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
 
     private fun checkTypeAlias(declaration: FirTypeAlias, reporter: DiagnosticReporter, context: CheckerContext) {
         val expandedType = declaration.expandedConeType
-        val typeAliasVisibility = declaration.getEffectiveVisibility(context)
+        val typeAliasVisibility = declaration.effectiveVisibility
 
-        if (typeAliasVisibility == FirEffectiveVisibilityImpl.Local) return
+        if (typeAliasVisibility == EffectiveVisibility.Local) return
         val restricting = expandedType?.findVisibilityExposure(context, typeAliasVisibility)
         if (restricting != null) {
             reporter.reportOn(
@@ -97,16 +96,16 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
                 FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE,
                 typeAliasVisibility,
                 restricting,
-                restricting.getEffectiveVisibility(context),
+                restricting.effectiveVisibility,
                 context
             )
         }
     }
 
     private fun checkFunction(declaration: FirFunction<*>, reporter: DiagnosticReporter, context: CheckerContext) {
-        val functionVisibility = (declaration as FirMemberDeclaration).getEffectiveVisibility(context)
+        val functionVisibility = (declaration as FirMemberDeclaration).effectiveVisibility
 
-        if (functionVisibility == FirEffectiveVisibilityImpl.Local) return
+        if (functionVisibility == EffectiveVisibility.Local) return
         if (declaration !is FirConstructor) {
             val restricting = declaration.returnTypeRef.coneTypeSafe<ConeKotlinType>()
                 ?.findVisibilityExposure(context, functionVisibility)
@@ -116,7 +115,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
                     FirErrors.EXPOSED_FUNCTION_RETURN_TYPE,
                     functionVisibility,
                     restricting,
-                    restricting.getEffectiveVisibility(context),
+                    restricting.effectiveVisibility,
                     context
                 )
             }
@@ -132,7 +131,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
                         FirErrors.EXPOSED_PARAMETER_TYPE,
                         functionVisibility,
                         restricting,
-                        restricting.getEffectiveVisibility(context),
+                        restricting.effectiveVisibility,
                         context
                     )
                 }
@@ -142,9 +141,10 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
     }
 
     private fun checkProperty(declaration: FirProperty, reporter: DiagnosticReporter, context: CheckerContext) {
-        val propertyVisibility = declaration.getEffectiveVisibility(context)
+        if (declaration.isLocal) return
+        val propertyVisibility = declaration.effectiveVisibility
 
-        if (propertyVisibility == FirEffectiveVisibilityImpl.Local) return
+        if (propertyVisibility == EffectiveVisibility.Local) return
         val restricting =
             declaration.returnTypeRef.coneTypeSafe<ConeKotlinType>()
                 ?.findVisibilityExposure(context, propertyVisibility)
@@ -159,7 +159,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
                 diagnostic,
                 propertyVisibility,
                 restricting,
-                restricting.getEffectiveVisibility(context),
+                restricting.effectiveVisibility,
                 context
             )
         }
@@ -174,9 +174,9 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
     ) {
         if (typeRef == null || memberDeclaration == null) return
         val receiverParameterType = typeRef.coneType
-        val memberVisibility = memberDeclaration.getEffectiveVisibility(context)
+        val memberVisibility = memberDeclaration.effectiveVisibility
 
-        if (memberVisibility == FirEffectiveVisibilityImpl.Local) return
+        if (memberVisibility == EffectiveVisibility.Local) return
         val restricting = receiverParameterType.findVisibilityExposure(context, memberVisibility)
         if (restricting != null) {
             reporter.reportOn(
@@ -184,7 +184,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
                 FirErrors.EXPOSED_RECEIVER_TYPE,
                 memberVisibility,
                 restricting,
-                restricting.getEffectiveVisibility(context),
+                restricting.effectiveVisibility,
                 context
             )
         }
@@ -192,7 +192,7 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
 
     private fun ConeKotlinType.findVisibilityExposure(
         context: CheckerContext,
-        base: FirEffectiveVisibility
+        base: EffectiveVisibility
     ): FirMemberDeclaration? {
         val type = this as? ConeClassLikeType ?: return null
         val fir = type.fullyExpandedType(context.session).lookupTag.toSymbol(context.session)?.let { firSymbol ->
@@ -201,9 +201,10 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
         } ?: return null
 
         if (fir is FirMemberDeclaration) {
-            when (fir.getEffectiveVisibility(context).relation(base)) {
+            val effectiveVisibility = fir.effectiveVisibility
-                FirEffectiveVisibility.Permissiveness.LESS,
+            when (effectiveVisibility.relation(base, context.session.typeContext)) {
-                FirEffectiveVisibility.Permissiveness.UNKNOWN -> {
+                EffectiveVisibility.Permissiveness.LESS,
+                EffectiveVisibility.Permissiveness.UNKNOWN -> {
                     return fir
                 }
                 else -> {
@@ -219,7 +220,4 @@ object FirExposedVisibilityDeclarationChecker : FirMemberDeclarationChecker() {
 
         return null
     }
-
-    private fun FirMemberDeclaration.getEffectiveVisibility(context: CheckerContext) =
-        getEffectiveVisibility(context.session, context.containingDeclarations, context.sessionHolder.scopeSession)
 }

compiler/fir/entrypoint/src/org/jetbrains/kotlin/fir/session/ComponentsContainers.kt

@@ -91,7 +91,6 @@ fun FirSession.registerJavaSpecificResolveComponents() {
     register(FirVisibilityChecker::class, FirJavaVisibilityChecker)
     register(FirModuleVisibilityChecker::class, FirJvmModuleVisibilityChecker(this))
     register(ConeCallConflictResolverFactory::class, JvmCallConflictResolverFactory)
-    register(FirEffectiveVisibilityResolver::class, FirJvmEffectiveVisibilityResolver(this))
     register(FirPlatformClassMapper::class, FirJavaClassMapper(this))
     register(FirSyntheticNamesProvider::class, FirJavaSyntheticNamesProvider)
     register(FirJsr305StateContainer::class, FirJsr305StateContainer.Default)

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/ClassDeserialization.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlin.fir.deserialization
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.jvm.JvmBuiltInsSignatures
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
@@ -18,7 +19,6 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONE
 import org.jetbrains.kotlin.fir.resolve.providers.impl.FirCloneableSymbolProvider.Companion.CLONEABLE_CLASS_ID
 import org.jetbrains.kotlin.fir.scopes.FirScopeProvider
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.symbols.ConeTypeParameterLookupTag
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
@@ -35,6 +35,7 @@ import org.jetbrains.kotlin.metadata.deserialization.Flags
 import org.jetbrains.kotlin.metadata.deserialization.NameResolver
 import org.jetbrains.kotlin.metadata.deserialization.TypeTable
 import org.jetbrains.kotlin.metadata.deserialization.supertypes
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -58,9 +59,11 @@ fun deserializeClassToSymbol(
     val flags = classProto.flags
     val kind = Flags.CLASS_KIND.get(flags)
     val modality = ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
+    val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags))
     val status = FirResolvedDeclarationStatusImpl(
-        ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+        visibility,
-        modality
+        modality,
+        visibility.toEffectiveVisibility(parentContext?.outerClassSymbol)
     ).apply {
         isExpect = Flags.IS_EXPECT_CLASS.get(flags)
         isActual = false
@@ -80,13 +83,18 @@ fun deserializeClassToSymbol(
             TypeTable(classProto.typeTable),
             classId.relativeClassName,
             containerSource,
+            symbol,
             annotationDeserializer,
             status.isInner
         ) ?: FirDeserializationContext.createForClass(
-            classId, classProto, nameResolver, session,
+            classId,
+            classProto,
+            nameResolver,
+            session,
             annotationDeserializer,
             FirConstDeserializer(session, (containerSource as? KotlinJvmBinarySourceElement)?.binaryClass),
-            containerSource
+            containerSource,
+            symbol
         )
     if (status.isCompanion) {
         parentContext?.let {
@@ -122,13 +130,13 @@ fun deserializeClassToSymbol(
 
         addDeclarations(
             classProto.functionList.map {
-                classDeserializer.loadFunction(it, classProto)
+                classDeserializer.loadFunction(it, classProto, symbol)
             }
         )
 
         addDeclarations(
             classProto.propertyList.map {
-                classDeserializer.loadProperty(it, classProto)
+                classDeserializer.loadProperty(it, classProto, symbol)
             }
         )
 
@@ -158,7 +166,8 @@ fun deserializeClassToSymbol(
                     this.symbol = FirVariableSymbol(CallableId(classId, enumEntryName))
                     this.status = FirResolvedDeclarationStatusImpl(
                         Visibilities.Public,
-                        Modality.FINAL
+                        Modality.FINAL,
+                        EffectiveVisibility.Public
                     ).apply {
                         isStatic = true
                     }
@@ -265,7 +274,7 @@ private fun FirRegularClassBuilder.addCloneForArrayIfNeeded(classId: ClassId, di
                 isNullable = false
             )
         }
-        status = FirResolvedDeclarationStatusImpl(Visibilities.Public, Modality.FINAL).apply {
+        status = FirResolvedDeclarationStatusImpl(Visibilities.Public, Modality.FINAL, EffectiveVisibility.Public).apply {
             isOverride = true
         }
         name = CLONE

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/deserialization/FirMemberDeserializer.kt

@@ -15,9 +15,9 @@ import org.jetbrains.kotlin.fir.expressions.FirAnnotationCall
 import org.jetbrains.kotlin.fir.expressions.FirExpression
 import org.jetbrains.kotlin.fir.expressions.builder.buildExpressionStub
 import org.jetbrains.kotlin.fir.resolve.defaultType
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.*
+import org.jetbrains.kotlin.fir.toEffectiveVisibility
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
@@ -25,6 +25,7 @@ import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.fir.types.impl.FirImplicitUnitTypeRef
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.deserialization.*
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.protobuf.MessageLite
@@ -43,6 +44,7 @@ class FirDeserializationContext(
     val annotationDeserializer: AbstractAnnotationDeserializer,
     val constDeserializer: FirConstDeserializer,
     val containerSource: DeserializedContainerSource?,
+    val outerClassSymbol: FirRegularClassSymbol?,
     outerTypeParameters: List<FirTypeParameterSymbol>
 ) {
     val allTypeParameters: List<FirTypeParameterSymbol> =
@@ -54,14 +56,21 @@ class FirDeserializationContext(
         typeTable: TypeTable = this.typeTable,
         relativeClassName: FqName? = this.relativeClassName,
         containerSource: DeserializedContainerSource? = this.containerSource,
+        outerClassSymbol: FirRegularClassSymbol? = this.outerClassSymbol,
         annotationDeserializer: AbstractAnnotationDeserializer = this.annotationDeserializer,
         capturesTypeParameters: Boolean = true
     ): FirDeserializationContext = FirDeserializationContext(
-        nameResolver, typeTable, versionRequirementTable, session, packageFqName, relativeClassName,
+        nameResolver,
-        FirTypeDeserializer(
+        typeTable,
-            session, nameResolver, typeTable, annotationDeserializer, typeParameterProtos, typeDeserializer
+        versionRequirementTable,
-        ),
+        session,
-        annotationDeserializer, constDeserializer, containerSource,
+        packageFqName,
+        relativeClassName,
+        FirTypeDeserializer(session, nameResolver, typeTable, annotationDeserializer, typeParameterProtos, typeDeserializer),
+        annotationDeserializer,
+        constDeserializer,
+        containerSource,
+        outerClassSymbol,
         if (capturesTypeParameters) allTypeParameters else emptyList()
     )
 
@@ -87,7 +96,8 @@ class FirDeserializationContext(
             fqName,
             relativeClassName = null,
             typeParameterProtos = emptyList(),
-            containerSource
+            containerSource,
+            outerClassSymbol = null
         )
 
         fun createForClass(
@@ -97,7 +107,8 @@ class FirDeserializationContext(
             session: FirSession,
             annotationDeserializer: AbstractAnnotationDeserializer,
             constDeserializer: FirConstDeserializer,
-            containerSource: DeserializedContainerSource?
+            containerSource: DeserializedContainerSource?,
+            outerClassSymbol: FirRegularClassSymbol
         ): FirDeserializationContext = createRootContext(
             nameResolver,
             TypeTable(classProto.typeTable),
@@ -108,7 +119,8 @@ class FirDeserializationContext(
             classId.packageFqName,
             classId.relativeClassName,
             classProto.typeParameterList,
-            containerSource
+            containerSource,
+            outerClassSymbol
         )
 
         private fun createRootContext(
@@ -121,7 +133,8 @@ class FirDeserializationContext(
             packageFqName: FqName,
             relativeClassName: FqName?,
             typeParameterProtos: List<ProtoBuf.TypeParameter>,
-            containerSource: DeserializedContainerSource?
+            containerSource: DeserializedContainerSource?,
+            outerClassSymbol: FirRegularClassSymbol?,
         ): FirDeserializationContext {
             return FirDeserializationContext(
                 nameResolver, typeTable,
@@ -140,6 +153,7 @@ class FirDeserializationContext(
                 annotationDeserializer,
                 constDeserializer,
                 containerSource,
+                outerClassSymbol,
                 emptyList()
             )
         }
@@ -164,9 +178,11 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             session = c.session
             origin = FirDeclarationOrigin.Library
             this.name = name
+            val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags))
             status = FirResolvedDeclarationStatusImpl(
-                ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                visibility,
-                Modality.FINAL
+                Modality.FINAL,
+                visibility.toEffectiveVisibility(owner = null)
             ).apply {
                 isExpect = Flags.IS_EXPECT_CLASS.get(flags)
                 isActual = false
@@ -185,7 +201,8 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
 
     fun loadProperty(
         proto: ProtoBuf.Property,
-        classProto: ProtoBuf.Class? = null
+        classProto: ProtoBuf.Class? = null,
+        classSymbol: FirClassSymbol<*>? = null
     ): FirProperty {
         val flags = if (proto.hasFlags()) proto.flags else loadOldFlags(proto.oldFlags)
         val callableName = c.nameResolver.getName(proto.name)
@@ -224,7 +241,11 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
                     this.returnTypeRef = returnTypeRef
                     resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
                     isGetter = true
-                    status = FirResolvedDeclarationStatusImpl(visibility, modality).apply {
+                    status = FirResolvedDeclarationStatusImpl(
+                        visibility,
+                        modality,
+                        visibility.toEffectiveVisibility(classSymbol)
+                    ).apply {
                         isInline = Flags.IS_INLINE_ACCESSOR.get(getterFlags)
                         isExternal = Flags.IS_EXTERNAL_ACCESSOR.get(getterFlags)
                     }
@@ -256,7 +277,11 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
                     this.returnTypeRef = FirImplicitUnitTypeRef(source)
                     resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES
                     isGetter = false
-                    status = FirResolvedDeclarationStatusImpl(visibility, modality).apply {
+                    status = FirResolvedDeclarationStatusImpl(
+                        visibility,
+                        modality,
+                        visibility.toEffectiveVisibility(classSymbol)
+                    ).apply {
                         isInline = Flags.IS_INLINE_ACCESSOR.get(setterFlags)
                         isExternal = Flags.IS_EXTERNAL_ACCESSOR.get(setterFlags)
                     }
@@ -296,9 +321,11 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             this.symbol = symbol
             dispatchReceiverType = c.dispatchReceiver
             isLocal = false
+            val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags))
             status = FirResolvedDeclarationStatusImpl(
-                ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                visibility,
-                ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
+                ProtoEnumFlags.modality(Flags.MODALITY.get(flags)),
+                visibility.toEffectiveVisibility(classSymbol)
             ).apply {
                 isExpect = Flags.IS_EXPECT_PROPERTY.get(flags)
                 isActual = false
@@ -332,7 +359,8 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
 
     fun loadFunction(
         proto: ProtoBuf.Function,
-        classProto: ProtoBuf.Class? = null
+        classProto: ProtoBuf.Class? = null,
+        classSymbol: FirClassSymbol<*>? = null
     ): FirSimpleFunction {
         val flags = if (proto.hasFlags()) proto.flags else loadOldFlags(proto.oldFlags)
 
@@ -357,9 +385,11 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
                 annotations += receiverAnnotations
             }
             name = callableName
+            val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags))
             status = FirResolvedDeclarationStatusImpl(
-                ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags)),
+                visibility,
-                ProtoEnumFlags.modality(Flags.MODALITY.get(flags))
+                ProtoEnumFlags.modality(Flags.MODALITY.get(flags)),
+                visibility.toEffectiveVisibility(classSymbol)
             ).apply {
                 isExpect = Flags.IS_EXPECT_FUNCTION.get(flags)
                 isActual = false
@@ -429,7 +459,8 @@ class FirMemberDeserializer(private val c: FirDeserializationContext) {
             val visibility = ProtoEnumFlags.visibility(Flags.VISIBILITY.get(flags))
             status = FirResolvedDeclarationStatusImpl(
                 visibility,
-                Modality.FINAL
+                Modality.FINAL,
+                visibility.toEffectiveVisibility(classBuilder.symbol)
             ).apply {
                 isExpect = Flags.IS_EXPECT_FUNCTION.get(flags)
                 isActual = false

compiler/fir/fir-deserialization/src/org/jetbrains/kotlin/fir/resolve/providers/impl/FirBuiltinSymbolProvider.kt

@@ -7,10 +7,7 @@ package org.jetbrains.kotlin.fir.resolve.providers.impl
 
 import org.jetbrains.kotlin.builtins.StandardNames
 import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
-import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.SourceElement
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.buildRegularClass
@@ -26,7 +23,6 @@ import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals
 import org.jetbrains.kotlin.fir.scopes.KotlinScopeProvider
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.FirResolvedTypeRef
@@ -36,6 +32,7 @@ import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl
 import org.jetbrains.kotlin.metadata.ProtoBuf
 import org.jetbrains.kotlin.metadata.builtins.BuiltInsBinaryVersion
 import org.jetbrains.kotlin.metadata.deserialization.NameResolverImpl
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
@@ -94,7 +91,8 @@ open class FirBuiltinSymbolProvider(session: FirSession, val kotlinScopeProvider
                         name = relativeClassName.shortName()
                         status = FirResolvedDeclarationStatusImpl(
                             Visibilities.Public,
-                            Modality.ABSTRACT
+                            Modality.ABSTRACT,
+                            EffectiveVisibility.Public
                         ).apply {
                             isExpect = false
                             isActual = false
@@ -136,7 +134,8 @@ open class FirBuiltinSymbolProvider(session: FirSession, val kotlinScopeProvider
                         val name = OperatorNameConventions.INVOKE
                         val functionStatus = FirResolvedDeclarationStatusImpl(
                             Visibilities.Public,
-                            Modality.ABSTRACT
+                            Modality.ABSTRACT,
+                            EffectiveVisibility.Public
                         ).apply {
                             isExpect = false
                             isActual = false

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt

@@ -10,6 +10,7 @@ import com.intellij.openapi.project.Project
 import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.*
@@ -24,7 +25,6 @@ import org.jetbrains.kotlin.fir.resolve.constructType
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProviderInternals
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.ConeClassLikeType
 import org.jetbrains.kotlin.fir.types.ConeKotlinType
@@ -35,13 +35,13 @@ import org.jetbrains.kotlin.load.java.JvmAnnotationNames
 import org.jetbrains.kotlin.load.java.structure.*
 import org.jetbrains.kotlin.load.java.structure.impl.JavaElementImpl
 import org.jetbrains.kotlin.load.kotlin.KotlinClassFinder
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.FqName
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.jvm.KotlinJavaPsiFacade
 import org.jetbrains.kotlin.types.Variance.INVARIANT
 import org.jetbrains.kotlin.util.OperatorNameConventions
-import org.jetbrains.kotlin.utils.addIfNotNull
 
 @ThreadSafeMutableState
 class JavaSymbolProvider(
@@ -56,7 +56,7 @@ class JavaSymbolProvider(
     private val classCache =
         session.firCachesFactory.createCacheWithPostCompute(
             createValue = ::findAndConvertJavaClass,
-            postCompute = { _, classSymbol, javaClass, ->
+            postCompute = { _, classSymbol, javaClass ->
                 if (classSymbol != null && javaClass != null) {
                     convertJavaClassToFir(classSymbol, javaClass)
                 }
@@ -69,6 +69,7 @@ class JavaSymbolProvider(
 
     private val facade: KotlinJavaPsiFacade get() = KotlinJavaPsiFacade.getInstance(project)
     private val parentClassTypeParameterStackCache = mutableMapOf<FirRegularClassSymbol, JavaTypeParameterStack>()
+    private val parentClassEffectiveVisibilityCache = mutableMapOf<FirRegularClassSymbol, EffectiveVisibility>()
 
     private fun findClass(
         classId: ClassId,
@@ -149,7 +150,10 @@ class JavaSymbolProvider(
         return classCache.getValue(classId, content)
     }
 
-    private fun findAndConvertJavaClass(classId: ClassId, content: KotlinClassFinder.Result.ClassFileContent?): Pair<FirRegularClassSymbol?, JavaClass?> {
+    private fun findAndConvertJavaClass(
+        classId: ClassId,
+        content: KotlinClassFinder.Result.ClassFileContent?
+    ): Pair<FirRegularClassSymbol?, JavaClass?> {
         val foundClass = findClass(classId, content)
         return if (foundClass == null ||
             foundClass.hasDifferentRelativeClassName(classId) ||
@@ -202,6 +206,7 @@ class JavaSymbolProvider(
         parentClassTypeParameterStackCache[classSymbol] = javaTypeParameterStack
         val firJavaClass = createFirJavaClass(javaClass, classSymbol, outerClassId, parentClassSymbol, classId, javaTypeParameterStack)
         parentClassTypeParameterStackCache.remove(classSymbol)
+        parentClassEffectiveVisibilityCache.remove(classSymbol)
         firJavaClass.convertSuperTypes(javaClass, javaTypeParameterStack)
         firJavaClass.addAnnotationsFrom(this@JavaSymbolProvider.session, javaClass, javaTypeParameterStack)
         return firJavaClass
@@ -233,7 +238,8 @@ class JavaSymbolProvider(
             session = this@JavaSymbolProvider.session
             symbol = classSymbol
             name = javaClass.name
-            visibility = javaClass.visibility
+            val visibility = javaClass.visibility
+            this@buildJavaClass.visibility = visibility
             modality = javaClass.modality
             classKind = javaClass.classKind
             this.isTopLevel = outerClassId == null
@@ -241,6 +247,14 @@ class JavaSymbolProvider(
             this.javaTypeParameterStack = javaTypeParameterStack
             existingNestedClassifierNames += javaClass.innerClassNames
             scopeProvider = this@JavaSymbolProvider.scopeProvider
+
+            val selfEffectiveVisibility = visibility.toEffectiveVisibility(parentClassSymbol?.toLookupTag())
+            val parentEffectiveVisibility = parentClassSymbol?.let {
+                parentClassEffectiveVisibilityCache[it] ?: it.fir.effectiveVisibility
+            } ?: EffectiveVisibility.Public
+            val effectiveVisibility = parentEffectiveVisibility.lowerBound(selfEffectiveVisibility, session.typeContext)
+            parentClassEffectiveVisibilityCache[classSymbol] = effectiveVisibility
+
             val classTypeParameters = javaClass.typeParameters.convertTypeParameters(javaTypeParameterStack)
             typeParameters += classTypeParameters
             if (!isStatic && parentClassSymbol != null) {
@@ -252,8 +266,9 @@ class JavaSymbolProvider(
             val dispatchReceiver = classId.defaultType(typeParameters.map { it.symbol })
 
             status = FirResolvedDeclarationStatusImpl(
-                javaClass.visibility,
+                visibility,
-                javaClass.modality
+                javaClass.modality,
+                effectiveVisibility
             ).apply {
                 this.isInner = !isTopLevel && !this@buildJavaClass.isStatic
                 isCompanion = false
@@ -368,7 +383,8 @@ class JavaSymbolProvider(
                 name = fieldName
                 status = FirResolvedDeclarationStatusImpl(
                     javaField.visibility,
-                    javaField.modality
+                    javaField.modality,
+                    javaField.visibility.toEffectiveVisibility(dispatchReceiver.lookupTag)
                 ).apply {
                     isStatic = javaField.isStatic
                     isExpect = false
@@ -389,7 +405,8 @@ class JavaSymbolProvider(
                 name = fieldName
                 status = FirResolvedDeclarationStatusImpl(
                     javaField.visibility,
-                    javaField.modality
+                    javaField.modality,
+                    javaField.visibility.toEffectiveVisibility(dispatchReceiver.lookupTag)
                 ).apply {
                     isStatic = javaField.isStatic
                     isExpect = false
@@ -448,7 +465,8 @@ class JavaSymbolProvider(
             annotationBuilder = { javaMethod.annotations.map { it.toFirAnnotationCall(session, javaTypeParameterStack) } }
             status = FirResolvedDeclarationStatusImpl(
                 javaMethod.visibility,
-                javaMethod.modality
+                javaMethod.modality,
+                javaMethod.visibility.toEffectiveVisibility(dispatchReceiver.lookupTag)
             ).apply {
                 isStatic = javaMethod.isStatic
                 isExpect = false
@@ -476,7 +494,8 @@ class JavaSymbolProvider(
 
     private fun convertJavaAnnotationMethodToValueParameter(javaMethod: JavaMethod, firJavaMethod: FirJavaMethod): FirJavaValueParameter =
         buildJavaValueParameter {
-            source = (javaMethod as? JavaElementImpl<*>)?.psi?.toFirPsiSourceElement(FirFakeSourceElementKind.ImplicitJavaAnnotationConstructor)
+            source = (javaMethod as? JavaElementImpl<*>)?.psi
+                ?.toFirPsiSourceElement(FirFakeSourceElementKind.ImplicitJavaAnnotationConstructor)
             session = this@JavaSymbolProvider.session
             returnTypeRef = firJavaMethod.returnTypeRef
             name = javaMethod.name
@@ -502,7 +521,8 @@ class JavaSymbolProvider(
             val visibility = javaConstructor?.visibility ?: ownerClassBuilder.visibility
             status = FirResolvedDeclarationStatusImpl(
                 visibility,
-                Modality.FINAL
+                Modality.FINAL,
+                visibility.toEffectiveVisibility(ownerClassBuilder.symbol)
             ).apply {
                 isExpect = false
                 isActual = false
@@ -542,7 +562,7 @@ class JavaSymbolProvider(
             source = classSource
             session = this@JavaSymbolProvider.session
             symbol = FirConstructorSymbol(constructorId)
-            status = FirResolvedDeclarationStatusImpl(Visibilities.Public, Modality.FINAL)
+            status = FirResolvedDeclarationStatusImpl(Visibilities.Public, Modality.FINAL, EffectiveVisibility.Public)
             returnTypeRef = buildResolvedTypeRef {
                 type = ownerClassBuilder.buildSelfTypeRef()
             }

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaUtils.kt

@@ -25,11 +25,12 @@ import org.jetbrains.kotlin.fir.references.impl.FirReferencePlaceholderForResolv
 import org.jetbrains.kotlin.fir.resolve.bindSymbolToLookupTag
 import org.jetbrains.kotlin.fir.resolve.defaultType
 import org.jetbrains.kotlin.fir.resolve.diagnostics.ConeUnresolvedReferenceError
-import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.providers.getClassDeclaredPropertySymbols
+import org.jetbrains.kotlin.fir.resolve.symbolProvider
 import org.jetbrains.kotlin.fir.resolve.toSymbol
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.expectedConeType
 import org.jetbrains.kotlin.fir.resolve.transformers.body.resolve.firUnsafe
+import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
 import org.jetbrains.kotlin.fir.symbols.StandardClassIds
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -79,13 +80,16 @@ internal val JavaClass.classKind: ClassKind
         else -> ClassKind.CLASS
     }
 
+internal fun ClassId.toLookupTag(): ConeClassLikeLookupTag {
+    return ConeClassLikeLookupTagImpl(this)
+}
+
 internal fun ClassId.toConeKotlinType(
     typeArguments: Array<ConeTypeProjection>,
     isNullable: Boolean,
     attributes: ConeAttributes = ConeAttributes.Empty
 ): ConeLookupTagBasedType {
-    val lookupTag = ConeClassLikeLookupTagImpl(this)
+    return ConeClassLikeTypeImpl(toLookupTag(), typeArguments, isNullable, attributes)
-    return ConeClassLikeTypeImpl(lookupTag, typeArguments, isNullable, attributes)
 }
 
 internal fun FirTypeRef.toConeKotlinTypeProbablyFlexible(

compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.java.enhancement
 
-import org.jetbrains.kotlin.builtins.jvm.JavaToKotlinClassMap
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.fir.*
@@ -22,13 +21,13 @@ import org.jetbrains.kotlin.fir.java.JavaTypeParameterStack
 import org.jetbrains.kotlin.fir.java.declarations.*
 import org.jetbrains.kotlin.fir.java.toConeKotlinTypeProbablyFlexible
 import org.jetbrains.kotlin.fir.scopes.jvm.computeJvmDescriptor
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.*
 import org.jetbrains.kotlin.fir.types.*
 import org.jetbrains.kotlin.fir.types.jvm.FirJavaTypeRef
 import org.jetbrains.kotlin.load.java.AnnotationQualifierApplicabilityType
 import org.jetbrains.kotlin.load.java.typeEnhancement.*
 import org.jetbrains.kotlin.load.kotlin.SignatureBuildingComponents
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.utils.JavaTypeEnhancementState
 import org.jetbrains.kotlin.utils.addToStdlib.safeAs
@@ -230,8 +229,9 @@ class FirSignatureEnhancement(
                         val resolvedStatus = firMethod.status.safeAs<FirResolvedDeclarationStatus>()
                         status = if (resolvedStatus != null) {
                             FirResolvedDeclarationStatusImpl(
-                                firMethod.visibility,
+                                resolvedStatus.visibility,
-                                Modality.FINAL
+                                Modality.FINAL,
+                                resolvedStatus.effectiveVisibility
                             )
                         } else {
                             FirDeclarationStatusImpl(firMethod.visibility, Modality.FINAL)

compiler/fir/jvm/src/org/jetbrains/kotlin/fir/FirJvmEffectiveVisibilityResolver.kt

@@ -1,20 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir
-
-import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.descriptors.java.JavaVisibilities
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-
-@NoMutableState
-class FirJvmEffectiveVisibilityResolver(session: FirSession) : FirEffectiveVisibilityResolverImpl(session) {
-    override fun computeEffectiveVisibility(visibility: Visibility, containerSymbol: FirClassLikeSymbol<*>?): FirEffectiveVisibility {
-        return when (visibility) {
-            JavaVisibilities.PackageVisibility -> FirEffectiveVisibilityImpl.PackagePrivate
-            else -> super.computeEffectiveVisibility(visibility, containerSymbol)
-        }
-    }
-}

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

@@ -6,6 +6,7 @@
 package org.jetbrains.kotlin.fir
 
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.*
@@ -171,12 +172,17 @@ fun FirDeclarationStatus.copy(
     isExpect: Boolean = this.isExpect,
     newModality: Modality? = null,
     newVisibility: Visibility? = null,
+    newEffectiveVisibility: EffectiveVisibility? = null
 ): FirDeclarationStatus {
     return if (this.isExpect == isExpect && newModality == null && newVisibility == null) {
         this
     } else {
         require(this is FirDeclarationStatusImpl) { "Unexpected class ${this::class}" }
-        this.resolved(newVisibility ?: visibility, newModality ?: modality!!).apply {
+        this.resolved(
+            newVisibility ?: visibility,
+            newModality ?: modality!!,
+            newEffectiveVisibility ?: EffectiveVisibility.Public
+        ).apply {
             this.isExpect = isExpect
         }
     }

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

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2021 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlin.fir
+
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
+import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.fir.symbols.ConeClassLikeLookupTag
+import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
+
+fun Visibility.toEffectiveVisibility(
+    ownerSymbol: FirClassLikeSymbol<*>?,
+    checkPublishedApi: Boolean = false
+): EffectiveVisibility {
+    return toEffectiveVisibility(ownerSymbol?.toLookupTag(), checkPublishedApi)
+}
+
+fun Visibility.toEffectiveVisibility(
+    owner: ConeClassLikeLookupTag?,
+    checkPublishedApi: Boolean = false
+): EffectiveVisibility {
+    customEffectiveVisibility()?.let { return it }
+    return when (this.normalize()) {
+        Visibilities.Private, Visibilities.PrivateToThis, Visibilities.InvisibleFake -> EffectiveVisibility.Private
+        Visibilities.Protected -> EffectiveVisibility.Protected(owner)
+        Visibilities.Internal -> when (!checkPublishedApi /*|| !owner.isPublishedApi()*/) { // TODO
+            true -> EffectiveVisibility.Internal
+            false -> EffectiveVisibility.Public
+        }
+        Visibilities.Public -> EffectiveVisibility.Public
+        Visibilities.Local -> EffectiveVisibility.Local
+        else -> error("Unknown visibility: $this")
+    }
+}

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

@@ -1,234 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir
-
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.fir.FirEffectiveVisibility.Permissiveness
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.effectiveVisibilityResolver
-import org.jetbrains.kotlin.fir.resolve.lookupSuperTypes
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassifierSymbol
-import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.fir.types.classId
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-
-sealed class FirEffectiveVisibilityImpl(
-    override val name: String,
-    override val publicApi: Boolean = false,
-    override val privateApi: Boolean = false
-) : FirEffectiveVisibility {
-
-    override fun toString() = name
-
-    //                    Public
-    //                /--/   |  \-------------\
-    // Protected(Base)       |                 \
-    //       |         Protected(Other)        Internal = PackagePrivate
-    // Protected(Derived) |                   /     \
-    //             |      |                  /    InternalProtected(Base)
-    //       ProtectedBound                 /        \
-    //                    \                /       /InternalProtected(Derived)
-    //                     \InternalProtectedBound/
-    //                              |
-    //                           Private = Local
-
-
-    object Private : FirEffectiveVisibilityImpl("private", privateApi = true) {
-        override fun relation(other: FirEffectiveVisibility) =
-            if (this == other || Local == other) Permissiveness.SAME else Permissiveness.LESS
-
-        override fun toVisibility() = Visibilities.Private
-    }
-
-    // Effectively same as Private
-    object Local : FirEffectiveVisibilityImpl("local") {
-        override fun relation(other: FirEffectiveVisibility) =
-            if (this == other || Private == other) Permissiveness.SAME else Permissiveness.LESS
-
-        override fun toVisibility() = Visibilities.Local
-    }
-
-    object Public : FirEffectiveVisibilityImpl("public", publicApi = true) {
-        override fun relation(other: FirEffectiveVisibility) =
-            if (this == other) Permissiveness.SAME else Permissiveness.MORE
-
-        override fun toVisibility() = Visibilities.Public
-    }
-
-    abstract class InternalOrPackage protected constructor(internal: Boolean) : FirEffectiveVisibilityImpl(
-        if (internal) "internal" else "public/*package*/"
-    ) {
-        override fun relation(other: FirEffectiveVisibility) = when (other as FirEffectiveVisibilityImpl) {
-            Public -> Permissiveness.LESS
-            Private, Local, InternalProtectedBound, is InternalProtected -> Permissiveness.MORE
-            is InternalOrPackage -> Permissiveness.SAME
-            ProtectedBound, is Protected -> Permissiveness.UNKNOWN
-        }
-
-        override fun lowerBound(other: FirEffectiveVisibility) = when (val o = other as FirEffectiveVisibilityImpl) {
-            Public -> this
-            Private, Local, InternalProtectedBound, is InternalOrPackage, is InternalProtected -> other
-            is Protected -> InternalProtected(o.containerSymbol, o.session)
-            ProtectedBound -> InternalProtectedBound
-        }
-    }
-
-    object Internal : InternalOrPackage(true) {
-        override fun toVisibility() = Visibilities.Internal
-    }
-
-    object PackagePrivate : InternalOrPackage(false) {
-        override fun toVisibility() = Visibilities.Private
-    }
-
-    class Protected(
-        val containerSymbol: FirClassLikeSymbol<*>?,
-        internal val session: FirSession
-    ) : FirEffectiveVisibilityImpl("protected", publicApi = true) {
-
-        override fun equals(other: Any?) = (other is Protected && containerSymbol == other.containerSymbol)
-
-        override fun hashCode() = containerSymbol?.hashCode() ?: 0
-
-        override fun toString() = "${super.toString()} (in ${containerSymbol.safeAs<FirRegularClassSymbol>()?.fir?.name ?: '?'})"
-
-        override fun relation(other: FirEffectiveVisibility) = when (val o = other as FirEffectiveVisibilityImpl) {
-            Public -> Permissiveness.LESS
-            Private, Local, ProtectedBound, InternalProtectedBound -> Permissiveness.MORE
-            is Protected -> containerRelation(containerSymbol, o.containerSymbol, session)
-            is InternalProtected -> when (containerRelation(containerSymbol, o.containerSymbol, session)) {
-                // Protected never can be less permissive than internal & protected
-                Permissiveness.SAME, Permissiveness.MORE -> Permissiveness.MORE
-                Permissiveness.UNKNOWN, Permissiveness.LESS -> Permissiveness.UNKNOWN
-            }
-            is InternalOrPackage -> Permissiveness.UNKNOWN
-        }
-
-        override fun lowerBound(other: FirEffectiveVisibility) = when (other as FirEffectiveVisibilityImpl) {
-            Public -> this
-            Private, Local, ProtectedBound, InternalProtectedBound -> other
-            is Protected -> when (relation(other)) {
-                Permissiveness.SAME, Permissiveness.MORE -> this
-                Permissiveness.LESS -> other
-                Permissiveness.UNKNOWN -> ProtectedBound
-            }
-            is InternalProtected -> when (relation(other)) {
-                Permissiveness.LESS -> other
-                else -> InternalProtectedBound
-            }
-            is InternalOrPackage -> InternalProtected(containerSymbol, session)
-        }
-
-        override fun toVisibility() = Visibilities.Protected
-    }
-
-    // Lower bound for all protected visibilities
-    object ProtectedBound : FirEffectiveVisibilityImpl("protected (in different classes)", publicApi = true) {
-        override fun relation(other: FirEffectiveVisibility) = when (other as FirEffectiveVisibilityImpl) {
-            Public, is Protected -> Permissiveness.LESS
-            Private, Local, InternalProtectedBound -> Permissiveness.MORE
-            ProtectedBound -> Permissiveness.SAME
-            is InternalOrPackage, is InternalProtected -> Permissiveness.UNKNOWN
-        }
-
-        override fun lowerBound(other: FirEffectiveVisibility) = when (other as FirEffectiveVisibilityImpl) {
-            Public, is Protected -> this
-            Private, Local, ProtectedBound, InternalProtectedBound -> other
-            is InternalOrPackage, is InternalProtected -> InternalProtectedBound
-        }
-
-        override fun toVisibility() = Visibilities.Protected
-    }
-
-    // Lower bound for internal and protected(C)
-    class InternalProtected(
-        val containerSymbol: FirClassLikeSymbol<*>?,
-        private val session: FirSession
-    ) : FirEffectiveVisibilityImpl("internal & protected") {
-
-        override fun equals(other: Any?) = (other is InternalProtected && containerSymbol == other.containerSymbol)
-
-        override fun hashCode() = containerSymbol?.hashCode() ?: 0
-
-        override fun toString() = "${super.toString()} (in ${containerSymbol.safeAs<FirRegularClassSymbol>()?.fir?.name ?: '?'})"
-
-        override fun relation(other: FirEffectiveVisibility) = when (val o = other as FirEffectiveVisibilityImpl) {
-            Public, is InternalOrPackage -> Permissiveness.LESS
-            Private, Local, InternalProtectedBound -> Permissiveness.MORE
-            is InternalProtected -> containerRelation(containerSymbol, o.containerSymbol, session)
-            is Protected -> when (containerRelation(containerSymbol, o.containerSymbol, session)) {
-                // Internal & protected never can be more permissive than just protected
-                Permissiveness.SAME, Permissiveness.LESS -> Permissiveness.LESS
-                Permissiveness.UNKNOWN, Permissiveness.MORE -> Permissiveness.UNKNOWN
-            }
-            ProtectedBound -> Permissiveness.UNKNOWN
-        }
-
-        override fun lowerBound(other: FirEffectiveVisibility) = when (other as FirEffectiveVisibilityImpl) {
-            Public, is InternalOrPackage -> this
-            Private, Local, InternalProtectedBound -> other
-            is Protected, is InternalProtected -> when (relation(other)) {
-                Permissiveness.SAME, Permissiveness.MORE -> this
-                Permissiveness.LESS -> other
-                Permissiveness.UNKNOWN -> InternalProtectedBound
-            }
-            ProtectedBound -> InternalProtectedBound
-        }
-
-        override fun toVisibility() = Visibilities.Private
-    }
-
-    // Lower bound for internal and protected lower bound
-    object InternalProtectedBound : FirEffectiveVisibilityImpl("internal & protected (in different classes)") {
-        override fun relation(other: FirEffectiveVisibility) = when (other as FirEffectiveVisibilityImpl) {
-            Public, is Protected, is InternalProtected, ProtectedBound, is InternalOrPackage -> Permissiveness.LESS
-            Private, Local -> Permissiveness.MORE
-            InternalProtectedBound -> Permissiveness.SAME
-        }
-
-        override fun toVisibility() = Visibilities.Private
-    }
-
-    override fun lowerBound(other: FirEffectiveVisibility): FirEffectiveVisibility {
-        if (this == Local || other == Local) return Local
-        return when (relation(other)) {
-            Permissiveness.SAME, Permissiveness.LESS -> this
-            Permissiveness.MORE -> other
-            Permissiveness.UNKNOWN -> Private
-        }
-    }
-
-    companion object {
-        private fun containerRelation(first: FirClassLikeSymbol<*>?, second: FirClassLikeSymbol<*>?, session: FirSession): Permissiveness =
-            if (first == null || second == null) {
-                Permissiveness.UNKNOWN
-            } else if (first == second) {
-                Permissiveness.SAME
-            } else {
-                when {
-                    first.collectSupertypes(session).any { it.classId == second.classId } -> Permissiveness.LESS
-                    second.collectSupertypes(session).any { it.classId == first.classId } -> Permissiveness.MORE
-                    else -> Permissiveness.UNKNOWN
-                }
-            }
-
-        private fun FirClassifierSymbol<*>.collectSupertypes(session: FirSession) = lookupSuperTypes(
-            this,
-            lookupInterfaces = true,
-            deep = true,
-            useSiteSession = session
-        )
-    }
-}
-
-fun FirMemberDeclaration.getEffectiveVisibility(
-    session: FirSession,
-    containingDeclarations: List<FirDeclaration>,
-    scopeSession: ScopeSession
-): FirEffectiveVisibility = session.effectiveVisibilityResolver.resolveFor(this, containingDeclarations, scopeSession)

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

@@ -1,156 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir
-
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.Visibility
-import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-import org.jetbrains.kotlin.fir.resolve.symbolProvider
-import org.jetbrains.kotlin.fir.symbols.impl.FirClassLikeSymbol
-import org.jetbrains.kotlin.name.ClassId
-import org.jetbrains.kotlin.utils.addToStdlib.safeAs
-
-@ThreadSafeMutableState
-open class FirEffectiveVisibilityResolverImpl(private val session: FirSession) : FirEffectiveVisibilityResolver() {
-    private val cache = mutableMapOf<FirSourceElement, FirEffectiveVisibility>()
-
-    final override fun resolveFor(
-        declaration: FirMemberDeclaration,
-        containingDeclarations: List<FirDeclaration>?,
-        scopeSession: ScopeSession
-    ): FirEffectiveVisibility {
-        if (declaration.source != null) {
-            cache[declaration.source]?.let {
-                return it
-            }
-        }
-
-        val (parentSymbol, parentEffectiveVisibility) =
-            declaration.getParentInfo(containingDeclarations, scopeSession)
-        var visibility = declaration.visibility
-
-        // this is a temporary solution until
-        // visibility starts to understand
-        // overrides itself.
-        if (declaration is FirSimpleFunction) {
-            parentSymbol?.fir.safeAs<FirClass<*>>()?.let {
-                visibility = declaration.lowestVisibilityAmongOverrides(it, session, scopeSession)
-            }
-        }
-
-        var selfEffectiveVisibility = computeEffectiveVisibility(visibility, parentSymbol)
-        selfEffectiveVisibility = parentEffectiveVisibility.lowerBound(selfEffectiveVisibility)
-        return declaration.remember(selfEffectiveVisibility)
-    }
-
-    protected open fun computeEffectiveVisibility(visibility: Visibility, containerSymbol: FirClassLikeSymbol<*>?): FirEffectiveVisibility {
-        return visibility.normalize().forVisibility(containerSymbol)
-    }
-
-    protected fun Visibility.forVisibility(
-        containerSymbol: FirClassLikeSymbol<*>?
-    ): FirEffectiveVisibility =
-        when (this) {
-            Visibilities.Private, Visibilities.PrivateToThis, Visibilities.InvisibleFake -> FirEffectiveVisibilityImpl.Private
-            Visibilities.Protected -> FirEffectiveVisibilityImpl.Protected(containerSymbol, session)
-            Visibilities.Internal -> FirEffectiveVisibilityImpl.Internal
-            Visibilities.Public -> FirEffectiveVisibilityImpl.Public
-            Visibilities.Local -> FirEffectiveVisibilityImpl.Local
-            Visibilities.Unknown -> FirEffectiveVisibilityImpl.Private
-            // NB: visibility must be already normalized here, so e.g. no JavaVisibilities are possible at this point
-            else -> error("Visibility $name is not allowed in forVisibility")
-        }
-
-    private fun FirElement.remember(effectiveVisibility: FirEffectiveVisibility): FirEffectiveVisibility {
-        val source = source
-        if (source != null) {
-            cache[source] = effectiveVisibility
-        }
-        return effectiveVisibility
-    }
-
-    private fun FirMemberDeclaration.getParentInfo(
-        containingDeclarations: List<FirDeclaration>?,
-        scopeSession: ScopeSession
-    ): Pair<FirClassLikeSymbol<*>?, FirEffectiveVisibility> {
-        var parentEffectiveVisibility: FirEffectiveVisibility = FirEffectiveVisibilityImpl.Public
-        // because for now effective visibility
-        // only works with FirClassLikeSymbol's
-        var parentSymbol: FirClassLikeSymbol<*>? = null
-        val parentClassId = this.getParentClassId()
-
-        // for some reason ClassId for "/<anonymous>"
-        // has local = false but still returns
-        // null instead of a symbol
-        // TODO: fix
-        var succeededToGetSymbol = false
-
-        // look for the containing class
-        // in the containingDeclarations or
-        // try using the firSymbolProvider
-        if (parentClassId != null && containingDeclarations != null) {
-            parentClassId.findOuterContainerInfo(containingDeclarations, scopeSession)?.let {
-                parentSymbol = it.first
-                parentEffectiveVisibility = it.second
-                succeededToGetSymbol = true
-            }
-        }
-
-        if (!succeededToGetSymbol) {
-            if (parentClassId?.isLocal == false) {
-                // ?: is needed to get enum from enum entry
-                parentSymbol = session.symbolProvider.getClassLikeSymbolByFqName(parentClassId)
-                    ?: parentClassId.outerClassId?.let { session.symbolProvider.getClassLikeSymbolByFqName(it) }
-                parentSymbol?.fir.safeAs<FirMemberDeclaration>()?.let {
-                    parentEffectiveVisibility = resolveFor(it, null, scopeSession)
-                }
-            } else if (parentClassId?.isLocal == true) {
-                parentEffectiveVisibility = FirEffectiveVisibilityImpl.Local
-            }
-        }
-
-        return parentSymbol to parentEffectiveVisibility
-    }
-
-    private fun FirDeclaration.getParentClassId(): ClassId? = when (this) {
-        is FirCallableMemberDeclaration<*> -> this.containingClass()?.classId
-        is FirClassLikeDeclaration<*> -> this.symbol.classId.outerClassId
-        else -> null
-    }
-
-    private fun FirDeclaration.getClassId(): ClassId? = when (this) {
-        is FirCallableMemberDeclaration<*> -> this.containingClass()?.classId
-        is FirClassLikeDeclaration<*> -> this.symbol.classId
-        else -> null
-    }
-
-    private fun ClassId.findOuterContainerInfo(
-        containingDeclarations: List<FirDeclaration>,
-        scopeSession: ScopeSession
-    ): Pair<FirClassLikeSymbol<*>, FirEffectiveVisibility>? {
-        for (index in containingDeclarations.indices) {
-            val declaration = containingDeclarations[index]
-            val declarationClassId = declaration.getClassId()
-
-            if (this.relativeClassName == declarationClassId?.relativeClassName) {
-                return when (declaration) {
-                    is FirRegularClass -> {
-                        declaration.symbol to resolveFor(declaration, containingDeclarations.subList(0, index), scopeSession)
-                    }
-                    is FirAnonymousObject -> {
-                        declaration.symbol to declaration.remember(FirEffectiveVisibilityImpl.Local)
-                    }
-                    else -> {
-                        null
-                    }
-                }
-            }
-        }
-
-        return null
-    }
-}

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

@@ -5,7 +5,6 @@
 
 package org.jetbrains.kotlin.fir.resolve
 
-import org.jetbrains.kotlin.fir.FirEffectiveVisibilityResolver
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.resolve.providers.FirProvider
 import org.jetbrains.kotlin.fir.resolve.providers.FirSymbolProvider
@@ -18,4 +17,3 @@ val FirSession.correspondingSupertypesCache: FirCorrespondingSupertypesCache by
 val FirSession.declaredMemberScopeProvider: FirDeclaredMemberScopeProvider by FirSession.sessionComponentAccessor()
 val FirSession.qualifierResolver: FirQualifierResolver by FirSession.sessionComponentAccessor()
 val FirSession.typeResolver: FirTypeResolver by FirSession.sessionComponentAccessor()
-val FirSession.effectiveVisibilityResolver: FirEffectiveVisibilityResolver by FirSession.sessionComponentAccessor()

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/transformers/FirStatusResolver.kt

@@ -5,10 +5,7 @@
 
 package org.jetbrains.kotlin.fir.resolve.transformers
 
-import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.Visibilities
-import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
@@ -17,6 +14,8 @@ import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
 import org.jetbrains.kotlin.fir.scopes.unsubstitutedScope
+import org.jetbrains.kotlin.fir.toEffectiveVisibility
+import org.jetbrains.kotlin.fir.typeContext
 
 class FirStatusResolver(
     val session: FirSession,
@@ -162,7 +161,16 @@ class FirStatusResolver(
                 }
             }
         }
-        return status.resolved(visibility, modality)
+
+        val parentEffectiveVisibility = when {
+            containingProperty != null -> containingProperty.effectiveVisibility
+            containingClass is FirRegularClass -> containingClass.effectiveVisibility
+            containingClass is FirAnonymousObject -> EffectiveVisibility.Local
+            else -> EffectiveVisibility.Public
+        }
+        val selfEffectiveVisibility = visibility.toEffectiveVisibility(containingClass?.symbol?.toLookupTag())
+        val effectiveVisibility = parentEffectiveVisibility.lowerBound(selfEffectiveVisibility, session.typeContext)
+        return status.resolved(visibility, modality, effectiveVisibility)
     }
 
     private fun resolveVisibility(

compiler/fir/tree/gen/org/jetbrains/kotlin/fir/declarations/FirResolvedDeclarationStatus.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirSourceElement
@@ -37,6 +38,7 @@ interface FirResolvedDeclarationStatus : FirDeclarationStatus {
     override val isFromSealedClass: Boolean
     override val isFromEnumClass: Boolean
     override val isFun: Boolean
+    val effectiveVisibility: EffectiveVisibility
 
     override fun <R, D> accept(visitor: FirVisitor<R, D>, data: D): R = visitor.visitResolvedDeclarationStatus(this, data)
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirEffectiveVisibility.kt

@@ -1,52 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir
-
-import org.jetbrains.kotlin.descriptors.Visibility
-
-interface FirEffectiveVisibility {
-
-    val name: String
-
-    val publicApi: Boolean
-
-    val privateApi: Boolean
-
-    enum class Permissiveness {
-        LESS,
-        SAME,
-        MORE,
-        UNKNOWN
-    }
-
-    fun relation(other: FirEffectiveVisibility): Permissiveness
-
-    fun toVisibility(): Visibility
-
-    fun lowerBound(other: FirEffectiveVisibility): FirEffectiveVisibility
-
-    object Default : FirEffectiveVisibility {
-        override val name: String
-            get() = "???"
-        override val publicApi: Boolean
-            get() = false
-        override val privateApi: Boolean
-            get() = false
-
-        override fun relation(other: FirEffectiveVisibility): Permissiveness {
-            throw AssertionError("Should not be called")
-        }
-
-        override fun toVisibility(): Visibility {
-            throw AssertionError("Should not be called")
-        }
-
-        override fun lowerBound(other: FirEffectiveVisibility): FirEffectiveVisibility {
-            throw AssertionError("Should not be called")
-        }
-    }
-}
-

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirEffectiveVisibilityResolver.kt

@@ -1,19 +0,0 @@
-/*
- * Copyright 2010-2020 JetBrains s.r.o. and Kotlin Programming Language contributors.
- * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
- */
-
-package org.jetbrains.kotlin.fir
-
-import org.jetbrains.kotlin.fir.declarations.FirDeclaration
-import org.jetbrains.kotlin.fir.declarations.FirMemberDeclaration
-import org.jetbrains.kotlin.fir.resolve.ScopeSession
-
-@NoMutableState
-abstract class FirEffectiveVisibilityResolver : FirSessionComponent {
-    abstract fun resolveFor(
-        declaration: FirMemberDeclaration,
-        containingDeclarations: List<FirDeclaration>?,
-        scopeSession: ScopeSession
-    ): FirEffectiveVisibility
-}

compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt

@@ -5,7 +5,7 @@
 
 package org.jetbrains.kotlin.fir
 
-import org.jetbrains.kotlin.builtins.functions.FunctionClassKind
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
@@ -249,12 +249,12 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM
         popIndent()
     }
 
-    private fun Visibility.asString(effectiveVisibility: FirEffectiveVisibility? = null): String {
+    private fun Visibility.asString(effectiveVisibility: EffectiveVisibility? = null): String {
         val itself = when (this) {
             Visibilities.Unknown -> return "public?"
             else -> toString()
         }
-        if (effectiveVisibility == null || effectiveVisibility == FirEffectiveVisibility.Default) return itself
+        if (effectiveVisibility == null) return itself
         val effectiveAsVisibility = effectiveVisibility.toVisibility()
         if (effectiveAsVisibility == this) return itself
         if (effectiveAsVisibility == Visibilities.Private && this == Visibilities.PrivateToThis) return itself

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/FirDeclarationUtil.kt

@@ -5,15 +5,14 @@
 
 package org.jetbrains.kotlin.fir.declarations
 
-import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.fir.FirRenderer
-import org.jetbrains.kotlin.descriptors.SourceElement
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.fir.declarations.builder.FirRegularClassBuilder
 import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder
 import org.jetbrains.kotlin.fir.declarations.impl.FirFileImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirRegularClassImpl
 import org.jetbrains.kotlin.fir.references.FirResolvedNamedReference
+import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.symbols.impl.FirAnonymousObjectSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirClassSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
@@ -59,7 +58,11 @@ inline val FirMemberDeclaration.modality get() = status.modality
 inline val FirMemberDeclaration.isAbstract get() = status.modality == Modality.ABSTRACT
 inline val FirMemberDeclaration.isOpen get() = status.modality == Modality.OPEN
 
-inline val FirMemberDeclaration.visibility get() = status.visibility
+inline val FirMemberDeclaration.visibility: Visibility get() = status.visibility
+inline val FirMemberDeclaration.effectiveVisibility: EffectiveVisibility
+    get() = (status as? FirResolvedDeclarationStatus)?.effectiveVisibility
+        ?: error("Effective visibility for ${render(FirRenderer.RenderMode.NoBodies)} must be resolved")
+
 inline val FirMemberDeclaration.allowsToHaveFakeOverride: Boolean
     get() = !Visibilities.isPrivate(visibility) && visibility != Visibilities.InvisibleFake
 

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirDeclarationStatusImpl.kt

@@ -5,12 +5,12 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.FirPureAbstractElement
 import org.jetbrains.kotlin.fir.FirSourceElement
-import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.FirDeclarationStatus
-import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl.Modifier.*
 import org.jetbrains.kotlin.fir.visitors.FirTransformer
 import org.jetbrains.kotlin.fir.visitors.FirVisitor
@@ -167,7 +167,11 @@ open class FirDeclarationStatusImpl(
         return this
     }
 
-    fun resolved(visibility: Visibility, modality: Modality): FirResolvedDeclarationStatusImpl {
+    fun resolved(
-        return FirResolvedDeclarationStatusImpl(visibility, modality, flags)
+        visibility: Visibility,
+        modality: Modality,
+        effectiveVisibility: EffectiveVisibility
+    ): FirResolvedDeclarationStatusImpl {
+        return FirResolvedDeclarationStatusImpl(visibility, modality, effectiveVisibility, flags)
     }
 }

compiler/fir/tree/src/org/jetbrains/kotlin/fir/declarations/impl/FirResolvedDeclarationStatusImpl.kt

@@ -5,20 +5,23 @@
 
 package org.jetbrains.kotlin.fir.declarations.impl
 
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.fir.declarations.FirResolvedDeclarationStatus
 
 class FirResolvedDeclarationStatusImpl(
     visibility: Visibility,
-    modality: Modality
+    modality: Modality,
+    override val effectiveVisibility: EffectiveVisibility
 ) : FirDeclarationStatusImpl(visibility, modality), FirResolvedDeclarationStatus {
 
     internal constructor(
         visibility: Visibility,
         modality: Modality,
+        effectiveVisibility: EffectiveVisibility,
         flags: Int
-    ) : this(visibility, modality) {
+    ) : this(visibility, modality, effectiveVisibility) {
         this.flags = flags
     }
 

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/NodeConfigurator.kt

@@ -12,6 +12,7 @@ import org.jetbrains.kotlin.fir.tree.generator.FieldSets.calleeReference
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.classKind
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.controlFlowGraphReferenceField
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.declarations
+import org.jetbrains.kotlin.fir.tree.generator.FieldSets.effectiveVisibility
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.initializer
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.modality
 import org.jetbrains.kotlin.fir.tree.generator.FieldSets.name
@@ -342,6 +343,7 @@ object NodeConfigurator : AbstractFieldConfigurator<FirTreeBuilder>(FirTreeBuild
         }
 
         resolvedDeclarationStatus.configure {
+            +effectiveVisibility
             shouldBeAnInterface()
         }
 

compiler/fir/tree/tree-generator/src/org/jetbrains/kotlin/fir/tree/generator/Types.kt

@@ -8,9 +8,8 @@ package org.jetbrains.kotlin.fir.tree.generator
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
-import org.jetbrains.kotlin.descriptors.Visibilities
 import org.jetbrains.kotlin.descriptors.Visibility
+import org.jetbrains.kotlin.descriptors.annotations.AnnotationUseSiteTarget
 import org.jetbrains.kotlin.fir.tree.generator.context.generatedType
 import org.jetbrains.kotlin.fir.tree.generator.context.type
 import org.jetbrains.kotlin.fir.types.ConeClassErrorType
@@ -30,8 +29,7 @@ val inlineStatusType = type("fir.declarations", "InlineStatus")
 val varianceType = type(Variance::class)
 val nameType = type(Name::class)
 val visibilityType = type(Visibility::class)
-val effectiveVisibilityType = type("fir", "FirEffectiveVisibility")
+val effectiveVisibilityType = type("descriptors", "EffectiveVisibility")
-val visibilitiesType = type(Visibilities::class)
 val modalityType = type(Modality::class)
 val fqNameType = type(FqName::class)
 val classIdType = type(ClassId::class)

idea/idea-frontend-fir/idea-frontend-fir-generator/src/org/jetbrains/kotlin/idea/frontend/api/fir/generator/HLDiagnosticConverter.kt

@@ -9,10 +9,9 @@ import com.intellij.psi.PsiElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
-import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
-import org.jetbrains.kotlin.fir.FirEffectiveVisibility
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticData
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticList
 import org.jetbrains.kotlin.fir.checkers.generator.diagnostics.DiagnosticParameter
@@ -33,6 +32,7 @@ import org.jetbrains.kotlin.idea.frontend.api.types.KtType
 import org.jetbrains.kotlin.lexer.KtModifierKeywordToken
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.psi.KtExpression
+import org.jetbrains.kotlin.resolve.ForbiddenNamedArgumentsTarget
 import org.jetbrains.kotlin.psi.KtParameter
 import kotlin.reflect.KClass
 import kotlin.reflect.KType
@@ -165,10 +165,6 @@ private object FirToKtConversionCreator {
             KtTypeParameterSymbol::class.createType(),
             importsToAdd = listOf("org.jetbrains.kotlin.fir.declarations.FirTypeParameter")
         ),
-        FirEffectiveVisibility::class to HLFunctionCallConversion(
-            "{0}.toVisibility()",
-            Visibility::class.createType()
-        ),
         ConeKotlinType::class to HLFunctionCallConversion(
             "firSymbolBuilder.typeBuilder.buildKtType({0})",
             KtType::class.createType()
@@ -196,6 +192,7 @@ private object FirToKtConversionCreator {
         EventOccurrencesRange::class,
         KtModifierKeywordToken::class,
         Visibility::class,
+        EffectiveVisibility::class,
         WhenMissingCase::class,
         ForbiddenNamedArgumentsTarget::class,
         LanguageFeature::class,

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDataClassConverters.kt

@@ -444,81 +444,81 @@ internal val KT_DIAGNOSTIC_CONVERTER = KtDiagnosticConverterBuilder.buildConvert
     }
     add(FirErrors.EXPOSED_TYPEALIAS_EXPANDED_TYPE) { firDiagnostic ->
         ExposedTypealiasExpandedTypeImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )
     }
     add(FirErrors.EXPOSED_FUNCTION_RETURN_TYPE) { firDiagnostic ->
         ExposedFunctionReturnTypeImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )
     }
     add(FirErrors.EXPOSED_RECEIVER_TYPE) { firDiagnostic ->
         ExposedReceiverTypeImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )
     }
     add(FirErrors.EXPOSED_PROPERTY_TYPE) { firDiagnostic ->
         ExposedPropertyTypeImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )
     }
     add(FirErrors.EXPOSED_PROPERTY_TYPE_IN_CONSTRUCTOR) { firDiagnostic ->
         ExposedPropertyTypeInConstructorImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )
     }
     add(FirErrors.EXPOSED_PARAMETER_TYPE) { firDiagnostic ->
         ExposedParameterTypeImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )
     }
     add(FirErrors.EXPOSED_SUPER_INTERFACE) { firDiagnostic ->
         ExposedSuperInterfaceImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )
     }
     add(FirErrors.EXPOSED_SUPER_CLASS) { firDiagnostic ->
         ExposedSuperClassImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )
     }
     add(FirErrors.EXPOSED_TYPE_PARAMETER_BOUND) { firDiagnostic ->
         ExposedTypeParameterBoundImpl(
-            firDiagnostic.a.toVisibility(),
+            firDiagnostic.a,
             firSymbolBuilder.buildSymbol(firDiagnostic.b as FirDeclaration),
-            firDiagnostic.c.toVisibility(),
+            firDiagnostic.c,
             firDiagnostic as FirPsiDiagnostic<*>,
             token,
         )

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnostics.kt

@@ -11,6 +11,7 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
 import org.jetbrains.kotlin.idea.frontend.api.diagnostics.KtDiagnosticWithPsi
@@ -323,65 +324,65 @@ sealed class KtFirDiagnostic<PSI: PsiElement> : KtDiagnosticWithPsi<PSI> {
 
     abstract class ExposedTypealiasExpandedType : KtFirDiagnostic<KtNamedDeclaration>() {
         override val diagnosticClass get() = ExposedTypealiasExpandedType::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class ExposedFunctionReturnType : KtFirDiagnostic<KtNamedDeclaration>() {
         override val diagnosticClass get() = ExposedFunctionReturnType::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class ExposedReceiverType : KtFirDiagnostic<KtTypeReference>() {
         override val diagnosticClass get() = ExposedReceiverType::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class ExposedPropertyType : KtFirDiagnostic<KtNamedDeclaration>() {
         override val diagnosticClass get() = ExposedPropertyType::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class ExposedPropertyTypeInConstructor : KtFirDiagnostic<KtNamedDeclaration>() {
         override val diagnosticClass get() = ExposedPropertyTypeInConstructor::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class ExposedParameterType : KtFirDiagnostic<KtParameter>() {
         override val diagnosticClass get() = ExposedParameterType::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class ExposedSuperInterface : KtFirDiagnostic<KtTypeReference>() {
         override val diagnosticClass get() = ExposedSuperInterface::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class ExposedSuperClass : KtFirDiagnostic<KtTypeReference>() {
         override val diagnosticClass get() = ExposedSuperClass::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class ExposedTypeParameterBound : KtFirDiagnostic<KtTypeReference>() {
         override val diagnosticClass get() = ExposedTypeParameterBound::class
-        abstract val elementVisibility: Visibility
+        abstract val elementVisibility: EffectiveVisibility
         abstract val restrictingDeclaration: KtSymbol
-        abstract val restrictingVisibility: Visibility
+        abstract val restrictingVisibility: EffectiveVisibility
     }
 
     abstract class InapplicableInfixModifier : KtFirDiagnostic<PsiElement>() {

idea/idea-frontend-fir/src/org/jetbrains/kotlin/idea/frontend/api/fir/diagnostics/KtFirDiagnosticsImpl.kt

@@ -11,6 +11,7 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement
 import org.jetbrains.kotlin.config.LanguageFeature
 import org.jetbrains.kotlin.config.LanguageVersionSettings
 import org.jetbrains.kotlin.contracts.description.EventOccurrencesRange
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Visibility
 import org.jetbrains.kotlin.diagnostics.WhenMissingCase
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirPsiDiagnostic
@@ -515,9 +516,9 @@ internal class SupertypesForAnnotationClassImpl(
 }
 
 internal class ExposedTypealiasExpandedTypeImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedTypealiasExpandedType(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
@@ -525,9 +526,9 @@ internal class ExposedTypealiasExpandedTypeImpl(
 }
 
 internal class ExposedFunctionReturnTypeImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedFunctionReturnType(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
@@ -535,9 +536,9 @@ internal class ExposedFunctionReturnTypeImpl(
 }
 
 internal class ExposedReceiverTypeImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedReceiverType(), KtAbstractFirDiagnostic<KtTypeReference> {
@@ -545,9 +546,9 @@ internal class ExposedReceiverTypeImpl(
 }
 
 internal class ExposedPropertyTypeImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedPropertyType(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
@@ -555,9 +556,9 @@ internal class ExposedPropertyTypeImpl(
 }
 
 internal class ExposedPropertyTypeInConstructorImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedPropertyTypeInConstructor(), KtAbstractFirDiagnostic<KtNamedDeclaration> {
@@ -565,9 +566,9 @@ internal class ExposedPropertyTypeInConstructorImpl(
 }
 
 internal class ExposedParameterTypeImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedParameterType(), KtAbstractFirDiagnostic<KtParameter> {
@@ -575,9 +576,9 @@ internal class ExposedParameterTypeImpl(
 }
 
 internal class ExposedSuperInterfaceImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedSuperInterface(), KtAbstractFirDiagnostic<KtTypeReference> {
@@ -585,9 +586,9 @@ internal class ExposedSuperInterfaceImpl(
 }
 
 internal class ExposedSuperClassImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedSuperClass(), KtAbstractFirDiagnostic<KtTypeReference> {
@@ -595,9 +596,9 @@ internal class ExposedSuperClassImpl(
 }
 
 internal class ExposedTypeParameterBoundImpl(
-    override val elementVisibility: Visibility,
+    override val elementVisibility: EffectiveVisibility,
     override val restrictingDeclaration: KtSymbol,
-    override val restrictingVisibility: Visibility,
+    override val restrictingVisibility: EffectiveVisibility,
     firDiagnostic: FirPsiDiagnostic<*>,
     override val token: ValidityToken,
 ) : KtFirDiagnostic.ExposedTypeParameterBound(), KtAbstractFirDiagnostic<KtTypeReference> {

plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AllOpenNestedClassGenerator.kt

@@ -6,9 +6,10 @@
 package org.jetbrains.kotlin.fir.plugin.generators
 
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.buildConstructor
 import org.jetbrains.kotlin.fir.declarations.builder.buildRegularClass
@@ -20,13 +21,13 @@ import org.jetbrains.kotlin.fir.extensions.predicate.has
 import org.jetbrains.kotlin.fir.plugin.AllOpenPluginKey
 import org.jetbrains.kotlin.fir.plugin.fqn
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedClass
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.ConeClassLikeLookupTagImpl
 import org.jetbrains.kotlin.fir.symbols.impl.FirConstructorSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
 import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef
 import org.jetbrains.kotlin.fir.types.impl.ConeClassLikeTypeImpl
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.Name
 
 class AllOpenNestedClassGenerator(session: FirSession) : FirDeclarationGenerationExtension(session) {
@@ -41,7 +42,8 @@ class AllOpenNestedClassGenerator(session: FirSession) : FirDeclarationGeneratio
             origin = FirDeclarationOrigin.Plugin(key)
             status = FirResolvedDeclarationStatusImpl(
                 Visibilities.Private,
-                Modality.FINAL
+                Modality.FINAL,
+                EffectiveVisibility.Private
             ).apply {
                 isInner = true
             }
@@ -66,7 +68,8 @@ class AllOpenNestedClassGenerator(session: FirSession) : FirDeclarationGeneratio
             }
             status = FirResolvedDeclarationStatusImpl(
                 Visibilities.Public,
-                Modality.FINAL
+                Modality.FINAL,
+                EffectiveVisibility.Public
             )
             symbol = FirConstructorSymbol(CallableId(classId, classId.shortClassName))
         }
@@ -78,7 +81,8 @@ class AllOpenNestedClassGenerator(session: FirSession) : FirDeclarationGeneratio
             returnTypeRef = session.builtinTypes.intType
             status = FirResolvedDeclarationStatusImpl(
                 Visibilities.Public,
-                Modality.FINAL
+                Modality.FINAL,
+                EffectiveVisibility.Public
             )
             name = Name.identifier("hello")
             symbol = FirNamedFunctionSymbol(CallableId(classId, name))

plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AllOpenRecursiveNestedClassGenerator.kt

@@ -6,9 +6,10 @@
 package org.jetbrains.kotlin.fir.plugin.generators
 
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.buildRegularClass
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
@@ -39,7 +40,8 @@ class AllOpenRecursiveNestedClassGenerator(session: FirSession) : FirDeclaration
             origin = FirDeclarationOrigin.Plugin(key)
             status = FirResolvedDeclarationStatusImpl(
                 Visibilities.Public,
-                Modality.FINAL
+                Modality.FINAL,
+                EffectiveVisibility.Public
             )
             classKind = ClassKind.CLASS
             name = Name.identifier("Nested")

plugins/fir/fir-plugin-prototype/src/org/jetbrains/kotlin/fir/plugin/generators/AllOpenTopLevelDeclarationsGenerator.kt

@@ -6,9 +6,10 @@
 package org.jetbrains.kotlin.fir.plugin.generators
 
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.EffectiveVisibility
 import org.jetbrains.kotlin.descriptors.Modality
-import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.descriptors.Visibilities
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.builder.buildRegularClass
 import org.jetbrains.kotlin.fir.declarations.builder.buildSimpleFunction
@@ -18,9 +19,9 @@ import org.jetbrains.kotlin.fir.extensions.predicate.DeclarationPredicate
 import org.jetbrains.kotlin.fir.extensions.predicate.has
 import org.jetbrains.kotlin.fir.plugin.fqn
 import org.jetbrains.kotlin.fir.resolve.transformers.plugin.GeneratedClass
-import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.fir.symbols.impl.FirNamedFunctionSymbol
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
+import org.jetbrains.kotlin.name.CallableId
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.name.Name
 
@@ -37,7 +38,8 @@ class AllOpenTopLevelDeclarationsGenerator(session: FirSession) : FirDeclaration
             origin = FirDeclarationOrigin.Plugin(key)
             status = FirResolvedDeclarationStatusImpl(
                 Visibilities.Public,
-                Modality.FINAL
+                Modality.FINAL,
+                EffectiveVisibility.Public
             )
             classKind = ClassKind.OBJECT
             name = Name.identifier("TopLevel${klass.name}")
@@ -56,7 +58,8 @@ class AllOpenTopLevelDeclarationsGenerator(session: FirSession) : FirDeclaration
             returnTypeRef = session.builtinTypes.intType
             status = FirResolvedDeclarationStatusImpl(
                 Visibilities.Public,
-                Modality.FINAL
+                Modality.FINAL,
+                EffectiveVisibility.Public
             )
             name = Name.identifier("hello")
             symbol = FirNamedFunctionSymbol(CallableId(klass.symbol.classId, name))