[FIR] KT-49265: Fix implicit visibility checks

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

@@ -442,10 +442,17 @@ abstract class AbstractFirStatusResolveTransformer(
     private fun transformPropertyAccessor(
         propertyAccessor: FirPropertyAccessor,
         containingProperty: FirProperty,
+        overriddenStatuses: List<FirResolvedDeclarationStatus> = emptyList(),
     ) {
         propertyAccessor.transformStatus(
             this,
-            statusResolver.resolveStatus(propertyAccessor, containingClass, containingProperty, isLocal = false)
+            statusResolver.resolveStatus(
+                propertyAccessor,
+                containingClass,
+                containingProperty,
+                isLocal = false,
+                overriddenStatuses,
+            )
         )
 
         propertyAccessor.transformValueParameters(this, null)
@@ -474,10 +481,25 @@ abstract class AbstractFirStatusResolveTransformer(
         property: FirProperty,
         data: FirResolvedDeclarationStatus?
     ): FirStatement {
-        property.transformStatus(this, statusResolver.resolveStatus(property, containingClass, isLocal = false))
+        val overridden = statusResolver.getOverriddenProperties(property, containingClass)
+
+        val overriddenProperties = overridden.map {
+            it.ensureResolved(FirResolvePhase.STATUS)
+            it.status as FirResolvedDeclarationStatus
+        }
+
+        val overriddenSetters = overridden.mapNotNull {
+            it.setter?.ensureResolved(FirResolvePhase.STATUS)
+            it.setter?.status as? FirResolvedDeclarationStatus
+        }
+
+        property.transformStatus(
+            this,
+            statusResolver.resolveStatus(property, containingClass, false, overriddenProperties)
+        )
 
         property.getter?.let { transformPropertyAccessor(it, property) }
-        property.setter?.let { transformPropertyAccessor(it, property) }
+        property.setter?.let { transformPropertyAccessor(it, property, overriddenSetters) }
 
         property.backingField?.let {
             it.transformStatus(

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

@@ -6,7 +6,7 @@
 package org.jetbrains.kotlin.fir.resolve.transformers
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.fir.FirSession
+import org.jetbrains.kotlin.fir.*
 import org.jetbrains.kotlin.fir.declarations.*
 import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl
 import org.jetbrains.kotlin.fir.declarations.impl.FirResolvedDeclarationStatusImpl
@@ -14,9 +14,7 @@ import org.jetbrains.kotlin.fir.declarations.utils.effectiveVisibility
 import org.jetbrains.kotlin.fir.declarations.utils.isExpect
 import org.jetbrains.kotlin.fir.declarations.utils.isOverride
 import org.jetbrains.kotlin.fir.declarations.utils.visibility
-import org.jetbrains.kotlin.fir.extensions.FirStatusTransformerExtension
-import org.jetbrains.kotlin.fir.extensions.extensionService
-import org.jetbrains.kotlin.fir.extensions.statusTransformerExtensions
+import org.jetbrains.kotlin.fir.extensions.*
 import org.jetbrains.kotlin.fir.render
 import org.jetbrains.kotlin.fir.resolve.ScopeSession
 import org.jetbrains.kotlin.fir.scopes.ProcessorAction
@@ -83,43 +81,69 @@ class FirStatusResolver(
     }
 
     @OptIn(ExperimentalStdlibApi::class)
-    fun resolveStatus(property: FirProperty, containingClass: FirClass?, isLocal: Boolean): FirResolvedDeclarationStatus {
-        val status = property.applyExtensionTransformers { transformStatus(it, property, containingClass, isLocal) }
-        return resolveStatus(property, status, containingClass, null, isLocal) l@{
-            if (containingClass == null) return@l emptyList()
-            @Suppress("RemoveExplicitTypeArguments") // Workaround for KT-42175
-            buildList<FirProperty> {
-                val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
-                scope.processPropertiesByName(property.name) {}
-                scope.processDirectOverriddenPropertiesWithBaseScope(property.symbol) { symbol, _ ->
-                    this += symbol.fir
-                    ProcessorAction.NEXT
-                }
-            }.map {
+    fun getOverriddenProperties(
+        property: FirProperty,
+        containingClass: FirClass?,
+    ): List<FirProperty> {
+        if (containingClass == null) {
+            return emptyList()
+        }
+
+        val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
+
+        return buildList {
+            scope.processPropertiesByName(property.name) {}
+            scope.processDirectOverriddenPropertiesWithBaseScope(property.symbol) { symbol, _ ->
+                this += symbol.fir
+                ProcessorAction.NEXT
+            }
+        }
+    }
+
+    @OptIn(ExperimentalStdlibApi::class)
+    fun resolveStatus(
+        property: FirProperty,
+        containingClass: FirClass?,
+        isLocal: Boolean,
+        overriddenStatuses: List<FirResolvedDeclarationStatus>? = null,
+    ): FirResolvedDeclarationStatus {
+        val statuses = overriddenStatuses ?: getOverriddenProperties(property, containingClass)
+            .map {
                 it.ensureResolved(FirResolvePhase.STATUS)
                 it.status as FirResolvedDeclarationStatus
             }
+
+        val status = property.applyExtensionTransformers { transformStatus(it, property, containingClass, isLocal) }
+        return resolveStatus(property, status, containingClass, null, isLocal, statuses)
+    }
+
+    private fun getOverriddenStatuses(
+        function: FirSimpleFunction,
+        containingClass: FirClass?
+    ): List<FirResolvedDeclarationStatus> {
+        if (containingClass == null) {
+            return emptyList()
+        }
+
+        @Suppress("RemoveExplicitTypeArguments") // Workaround for KT-42175
+        return buildList<FirCallableDeclaration> {
+            val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
+            val symbol = function.symbol
+            scope.processFunctionsByName(function.name) {}
+            scope.processDirectOverriddenFunctionsWithBaseScope(symbol) { overriddenSymbol, _ ->
+                this += overriddenSymbol.fir
+                ProcessorAction.NEXT
+            }
+        }.mapNotNull {
+            it.status as? FirResolvedDeclarationStatus
         }
     }
 
     @OptIn(ExperimentalStdlibApi::class)
     fun resolveStatus(function: FirSimpleFunction, containingClass: FirClass?, isLocal: Boolean): FirResolvedDeclarationStatus {
         val status = function.applyExtensionTransformers { transformStatus(it, function, containingClass, isLocal) }
-        return resolveStatus(function, status, containingClass, null, isLocal) l@{
-            if (containingClass == null) return@l emptyList()
-            @Suppress("RemoveExplicitTypeArguments") // Workaround for KT-42175
-            buildList<FirCallableDeclaration> {
-                val scope = containingClass.unsubstitutedScope(session, scopeSession, withForcedTypeCalculator = false)
-                val symbol = function.symbol
-                scope.processFunctionsByName(function.name) {}
-                scope.processDirectOverriddenFunctionsWithBaseScope(symbol) { overriddenSymbol, _ ->
-                    this += overriddenSymbol.fir
-                    ProcessorAction.NEXT
-                }
-            }.mapNotNull {
-                it.status as? FirResolvedDeclarationStatus
-            }
-        }
+        val overriddenStatuses = getOverriddenStatuses(function, containingClass)
+        return resolveStatus(function, status, containingClass, null, isLocal, overriddenStatuses)
     }
 
     fun resolveStatus(
@@ -128,7 +152,7 @@ class FirStatusResolver(
         isLocal: Boolean
     ): FirResolvedDeclarationStatus {
         val status = regularClass.applyExtensionTransformers { transformStatus(it, regularClass, containingClass, isLocal) }
-        return resolveStatus(regularClass, status, containingClass, null, isLocal) { emptyList() }
+        return resolveStatus(regularClass, status, containingClass, null, isLocal, emptyList())
     }
 
     fun resolveStatus(
@@ -137,28 +161,29 @@ class FirStatusResolver(
         isLocal: Boolean
     ): FirResolvedDeclarationStatus {
         val status = typeAlias.applyExtensionTransformers { transformStatus(it, typeAlias, containingClass, isLocal) }
-        return resolveStatus(typeAlias, status, containingClass, null, isLocal) { emptyList() }
+        return resolveStatus(typeAlias, status, containingClass, null, isLocal, emptyList())
     }
 
     fun resolveStatus(
         propertyAccessor: FirPropertyAccessor,
         containingClass: FirClass?,
         containingProperty: FirProperty?,
-        isLocal: Boolean
+        isLocal: Boolean,
+        overriddenStatuses: List<FirResolvedDeclarationStatus> = emptyList(),
     ): FirResolvedDeclarationStatus {
         val status = propertyAccessor.applyExtensionTransformers {
             transformStatus(it, propertyAccessor, containingClass, containingProperty, isLocal)
         }
-        return resolveStatus(propertyAccessor, status, containingClass, containingProperty, isLocal) { emptyList() }
+        return resolveStatus(propertyAccessor, status, containingClass, containingProperty, isLocal, overriddenStatuses)
     }
 
     fun resolveStatus(constructor: FirConstructor, containingClass: FirClass?, isLocal: Boolean): FirResolvedDeclarationStatus {
         val status = constructor.applyExtensionTransformers { transformStatus(it, constructor, containingClass, isLocal) }
-        return resolveStatus(constructor, status, containingClass, null, isLocal) { emptyList() }
+        return resolveStatus(constructor, status, containingClass, null, isLocal, emptyList())
     }
 
     fun resolveStatus(field: FirField, containingClass: FirClass?, isLocal: Boolean): FirResolvedDeclarationStatus {
-        return resolveStatus(field, field.status, containingClass, null, isLocal) { emptyList() }
+        return resolveStatus(field, field.status, containingClass, null, isLocal, emptyList())
     }
 
     fun resolveStatus(
@@ -167,27 +192,27 @@ class FirStatusResolver(
         isLocal: Boolean
     ): FirResolvedDeclarationStatus {
         val status = backingField.applyExtensionTransformers { transformStatus(it, backingField, containingClass, isLocal) }
-        return resolveStatus(backingField, status, containingClass, null, isLocal) { emptyList() }
+        return resolveStatus(backingField, status, containingClass, null, isLocal, emptyList())
     }
 
     fun resolveStatus(enumEntry: FirEnumEntry, containingClass: FirClass?, isLocal: Boolean): FirResolvedDeclarationStatus {
         val status = enumEntry.applyExtensionTransformers { transformStatus(it, enumEntry, containingClass, isLocal) }
-        return resolveStatus(enumEntry, status, containingClass, null, isLocal) { emptyList() }
+        return resolveStatus(enumEntry, status, containingClass, null, isLocal, emptyList())
     }
 
-    private inline fun resolveStatus(
+    private fun resolveStatus(
         declaration: FirDeclaration,
         status: FirDeclarationStatus,
         containingClass: FirClass?,
         containingProperty: FirProperty?,
         isLocal: Boolean,
-        overriddenExtractor: () -> List<FirResolvedDeclarationStatus>
+        overriddenStatuses: List<FirResolvedDeclarationStatus>
     ): FirResolvedDeclarationStatus {
         if (status is FirResolvedDeclarationStatus) return status
         require(status is FirDeclarationStatusImpl)
 
         @Suppress("UNCHECKED_CAST")
-        val overriddenStatuses = overriddenExtractor() as List<FirResolvedDeclarationStatusImpl>
+        overriddenStatuses as List<FirResolvedDeclarationStatusImpl>
         val visibility = when (status.visibility) {
             Visibilities.Unknown -> when {
                 isLocal -> Visibilities.Local