[DFA] Move base property stability cache to flow

This is an exploritory change to move the lazy PropertyStability value
from a RealVariable into a Flow. This makes RealVariable stateless, so
maintaining the same instance is no longer a performance optimization,
only a memory optimization (something we can tackle again later).

^KT-87944

Author: bnorm

analysis/low-level-api-fir/src/org/jetbrains/kotlin/analysis/low/level/api/fir/util/ContextCollector.kt

@@ -347,7 +347,7 @@ private class ContextCollectorVisitor(
         }
 
         if (flow != null) {
-            val realVariables = flow.knownVariables.filterIsInstance<RealVariable>()
+            val realVariables = flow.realVariables.keys.filterIsInstance<RealVariable>()
                 .sortedBy { it.symbol.memberDeclarationNameOrNull?.asString() }
 
             for (realVariable in realVariables) {
@@ -409,7 +409,7 @@ private class ContextCollectorVisitor(
 
     @OptIn(CfgInternals::class)
     private fun computeExpressionStability(fir: FirExpression, flow: Flow): SmartcastStability? {
-        val realVariable = flow.getVariable(fir) as? RealVariable ?: return null
+        val realVariable = flow.getVariableIfKnown(fir) as? RealVariable ?: return null
         val targetTypes = flow.getTypeStatement(realVariable)?.upperTypes
 
         return context(bodyHolder, context.dataFlowAnalyzerContext) {

compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/FirDataFlowAnalyzer.kt

@@ -127,7 +127,7 @@ class DataFlowAnalyzerContext private constructor(
 @CfgInternals
 context(holder: SessionHolder, context: DataFlowAnalyzerContext)
 fun RealVariable.computeEffectiveStability(flow: Flow, targetTypes: Set<ConeKotlinType>?): SmartcastStability {
-    val stability = getStability(flow, holder.session)
+    val stability = flow.getStability(this)
 
     if (stability == SmartcastStability.CAPTURED_VARIABLE) {
         if (!isUnstableLocalVariable(targetTypes)) {
@@ -1088,6 +1088,7 @@ abstract class FirDataFlowAnalyzer(
 
     fun exitQualifiedAccessExpression(qualifiedAccessExpression: FirQualifiedAccessExpression) {
         graphBuilder.exitQualifiedAccessExpression(qualifiedAccessExpression).mergeIncomingFlow { _, flow ->
+            flow.remember(qualifiedAccessExpression)
             processConditionalContract(flow, qualifiedAccessExpression, callArgsExit = null)
             processBackingFieldAccess(flow, qualifiedAccessExpression)
             processEqualsParameterAccess(flow, qualifiedAccessExpression)
@@ -1497,7 +1498,7 @@ abstract class FirDataFlowAnalyzer(
         }
         var needToAddInitializerStatement = isAssignment
 
-        val stability = propertyVariable.getStability(flow, components.session)
+        val stability = flow.getStability(propertyVariable)
         if (stability == SmartcastStability.STABLE_VALUE || stability == SmartcastStability.CAPTURED_VARIABLE) {
             val initializerVariable = flow.rememberVariableIfUsedOrReal(initializer)
             if (!hasExplicitType && initializerVariable is RealVariable &&

compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/DfaVariables.kt

@@ -100,31 +100,6 @@ sealed class DataFlowVariable {
     }
 }
 
-private enum class PropertyStability(
-    val inherentInstability: SmartcastStability?,
-    val checkModule: Boolean = false,
-    val checkReceiver: Boolean = false,
-) {
-    // Private vals can only be accessed from the same scope, so they're always safe to smart cast.
-    // Constant values (e.g. singleton objects) cannot be reassigned no matter what, so they're always safe
-    // to smart cast as well, although this is not very useful.
-    PRIVATE_OR_CONST_VAL(null),
-
-    // Public final vals can be accessed from different modules, which are not necessarily recompiled
-    // when the module declaring the property changes, so smart casting them there is unsafe.
-    PUBLIC_FINAL_VAL(null, checkModule = true),
-
-    // Public open vals can be overridden with custom getters, so smart casting them is only safe
-    // if the receiver is known to be of a final type that doesn't do that.
-    PUBLIC_OPEN_VAL(null, checkModule = true, checkReceiver = true),
-
-    CAPTURED_VARIABLE(SmartcastStability.CAPTURED_VARIABLE),
-    EXPECT_PROPERTY(SmartcastStability.EXPECT_PROPERTY),
-    PROPERTY_WITH_GETTER(SmartcastStability.PROPERTY_WITH_GETTER),
-    MUTABLE_PROPERTY(SmartcastStability.MUTABLE_PROPERTY),
-    DELEGATED_PROPERTY(SmartcastStability.DELEGATED_PROPERTY);
-}
-
 class RealVariable(
     val symbol: FirBasedSymbol<*>,
     val isImplicit: Boolean,
@@ -165,95 +140,12 @@ class RealVariable(
             append("(${dispatchReceiver ?: extensionReceiver})")
         }
     }
-
-    fun getStability(flow: Flow, session: FirSession): SmartcastStability {
-        if (!isImplicit) {
-            val stability = propertyStability
-
-            val isUnstableSmartcastOnDelegatedProperties =
-                session.languageVersionSettings.supportsFeature(LanguageFeature.UnstableSmartcastOnDelegatedProperties)
-            if (isUnstableSmartcastOnDelegatedProperties && (symbol.fir as? FirProperty)?.isDelegated == true) return SmartcastStability.DELEGATED_PROPERTY
-
-            stability.inherentInstability?.let { return it }
-            if (symbol is FirPropertySymbol && symbol.fir.isImplicitWhenSubjectVariable) {
-                flow.unwrapVariable(this).takeIf { it != this }?.let { return it.getStability(flow, session) }
-            }
-            if (stability.checkReceiver && dispatchReceiver?.hasFinalType(flow, session) == false)
-                return SmartcastStability.PROPERTY_WITH_GETTER
-            if (stability.checkModule && !(symbol.fir as FirVariable).isInCurrentOrFriendModule(session))
-                return SmartcastStability.ALIEN_PUBLIC_PROPERTY
-            // Members of unstable values should always be unstable, as the receiver could've changed.
-            dispatchReceiver?.getStability(flow, session)?.takeIf { it != SmartcastStability.STABLE_VALUE }?.let { return it }
-            // No need to check extension receiver, as properties with one cannot be stable by symbol stability.
-        }
-        return SmartcastStability.STABLE_VALUE
-    }
-
-    private fun hasFinalType(flow: Flow, session: FirSession): Boolean =
-        originalType.isFinal(session) || flow.getTypeStatement(this)?.upperTypes?.any { it.isFinal(session) } == true
-
-    private val propertyStability: PropertyStability by lazy {
-        when (val fir = symbol.fir) {
-            !is FirVariable -> PropertyStability.PRIVATE_OR_CONST_VAL // named object or containing class for a static field reference
-            is FirEnumEntry -> PropertyStability.PRIVATE_OR_CONST_VAL
-            is FirErrorProperty -> PropertyStability.PRIVATE_OR_CONST_VAL
-            is FirValueParameter -> PropertyStability.PRIVATE_OR_CONST_VAL
-            is FirBackingField -> when {
-                fir.isVal -> PropertyStability.PRIVATE_OR_CONST_VAL
-                else -> PropertyStability.MUTABLE_PROPERTY
-            }
-            is FirField -> when {
-                fir.isVal -> PropertyStability.PUBLIC_FINAL_VAL
-                else -> PropertyStability.MUTABLE_PROPERTY
-            }
-            is FirProperty -> when {
-                fir.isExpect -> PropertyStability.EXPECT_PROPERTY
-                fir.delegate != null -> PropertyStability.DELEGATED_PROPERTY
-                // Local vars are only *sometimes* unstable (when there are concurrent assignments). `FirDataFlowAnalyzer`
-                // will check that at each use site individually and mark the access as stable when possible.
-                fir.symbol is FirLocalPropertySymbol -> when {
-                    fir.isVal -> PropertyStability.PRIVATE_OR_CONST_VAL
-                    else -> PropertyStability.CAPTURED_VARIABLE
-                }
-                fir.isVar -> PropertyStability.MUTABLE_PROPERTY
-                fir.isInstanceExtension -> PropertyStability.PROPERTY_WITH_GETTER
-                fir.getter !is FirDefaultPropertyAccessor? -> PropertyStability.PROPERTY_WITH_GETTER
-                fir.visibility == Visibilities.Private -> PropertyStability.PRIVATE_OR_CONST_VAL
-                // REPL vals can be treated the same as local vals.
-                // TODO(???): allow REPL vars to be treated as local vars.
-                fir.isReplSnippetDeclaration == true -> PropertyStability.PRIVATE_OR_CONST_VAL
-                fir.isFinal -> PropertyStability.PUBLIC_FINAL_VAL
-                else -> PropertyStability.PUBLIC_OPEN_VAL
-            }
-        }
-    }
 }
 
 data class SyntheticVariable(val fir: FirExpression) : DataFlowVariable() {
     override val originalType: ConeKotlinType get() = fir.resolvedType
 }
 
-private fun ConeKotlinType.isFinal(session: FirSession): Boolean = when (this) {
-    is ConeFlexibleType -> lowerBound.isFinal(session)
-    is ConeDefinitelyNotNullType -> original.isFinal(session)
-    is ConeClassLikeType -> toSymbol(session)?.fullyExpandedClass(session)?.isFinal == true
-    is ConeTypeParameterType -> toTypeParameterSymbol(session)?.resolvedBounds?.any { it.coneType.isFinal(session) } == true
-
-    is ConeIntersectionType -> intersectedTypes.any { it.isFinal(session) }
-    is ConeCapturedType -> constructor.supertypes?.any { it.isFinal(session) } == true
-    is ConeIntegerLiteralType -> true
-
-    is ConeStubType,
-    is ConeTypeVariableType,
-        -> false
-}
-
-private fun FirVariable.isInCurrentOrFriendModule(session: FirSession): Boolean {
-    val propertyModuleData = originalOrSelf().moduleData
-    val currentModuleData = session.moduleData
-    return currentModuleData.canSeeInternalsOf(propertyModuleData)
-}
-
 private tailrec fun FirExpression.unwrapElement(): FirExpression? {
     return when (this) {
         is FirSmartCastExpression -> originalExpression.unwrapElement()