[FIR] Properly prohibit access to enum companion in enum entry initialization section

^KT-57456 Fixed
KT-57608

compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt

@@ -23,7 +23,7 @@ enum class Planet(val m: Double, internal val r: Double) {
         }
     };
 
-    val g: Double = <!UNINITIALIZED_VARIABLE!>G<!> * m / (r * r)
+    val g: Double = <!UNINITIALIZED_ENUM_COMPANION!>G<!> * m / (r * r)
 
     abstract fun sayHello()
 

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt

@@ -98,6 +98,7 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirSupertypesChecker,
             FirPrimaryConstructorSuperTypeChecker,
             FirDynamicSupertypeChecker,
+            FirEnumCompanionInEnumConstructorCallChecker,
         )
 
     override val regularClassCheckers: Set<FirRegularClassChecker>
@@ -166,11 +167,6 @@ object CommonDeclarationCheckers : DeclarationCheckers() {
             FirAnonymousInitializerInInterfaceChecker
         )
 
-    override val enumEntryCheckers: Set<FirEnumEntryChecker>
-        get() = setOf(
-            FirEnumCompanionInEnumConstructorCallChecker,
-        )
-
     override val valueParameterCheckers: Set<FirValueParameterChecker>
         get() = setOf()
 }

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

@@ -6,73 +6,94 @@
 package org.jetbrains.kotlin.fir.analysis.checkers.declaration
 
 import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.isEnumEntry
 import org.jetbrains.kotlin.diagnostics.DiagnosticReporter
 import org.jetbrains.kotlin.diagnostics.reportOn
-import org.jetbrains.kotlin.fir.FirElement
+import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.toRegularClassSymbol
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
-import org.jetbrains.kotlin.fir.declarations.FirEnumEntry
-import org.jetbrains.kotlin.fir.declarations.FirRegularClass
-import org.jetbrains.kotlin.fir.declarations.primaryConstructorIfAny
-import org.jetbrains.kotlin.fir.expressions.*
-import org.jetbrains.kotlin.fir.resolve.dfa.coneType
+import org.jetbrains.kotlin.fir.declarations.*
+import org.jetbrains.kotlin.fir.declarations.impl.FirPrimaryConstructor
+import org.jetbrains.kotlin.fir.expressions.FirExpression
+import org.jetbrains.kotlin.fir.expressions.FirResolvedQualifier
+import org.jetbrains.kotlin.fir.expressions.allReceiverExpressions
+import org.jetbrains.kotlin.fir.expressions.toReference
+import org.jetbrains.kotlin.fir.references.FirThisReference
+import org.jetbrains.kotlin.fir.resolve.dfa.cfg.CFGNodeWithSubgraphs
+import org.jetbrains.kotlin.fir.resolve.dfa.cfg.ControlFlowGraph
+import org.jetbrains.kotlin.fir.resolve.dfa.cfg.FunctionCallNode
+import org.jetbrains.kotlin.fir.resolve.dfa.cfg.QualifiedAccessNode
+import org.jetbrains.kotlin.fir.resolve.dfa.controlFlowGraph
 import org.jetbrains.kotlin.fir.symbols.impl.FirRegularClassSymbol
-import org.jetbrains.kotlin.fir.types.coneType
-import org.jetbrains.kotlin.fir.types.toRegularClassSymbol
-import org.jetbrains.kotlin.fir.visitors.FirVisitorVoid
+import org.jetbrains.kotlin.utils.addToStdlib.firstIsInstanceOrNull
 import org.jetbrains.kotlin.utils.addToStdlib.lastIsInstanceOrNull
 
-object FirEnumCompanionInEnumConstructorCallChecker : FirEnumEntryChecker() {
-    override fun check(declaration: FirEnumEntry, context: CheckerContext, reporter: DiagnosticReporter) {
-        val enumClass = context.containingDeclarations.lastIsInstanceOrNull<FirRegularClass>() ?: return
-        if (enumClass.classKind != ClassKind.ENUM_CLASS) return
-        val companionOfEnumSymbol = enumClass.companionObjectSymbol ?: return
-        val initializerObject = (declaration.initializer as? FirAnonymousObjectExpression)?.anonymousObject ?: return
-        val delegatingConstructorCall = initializerObject.primaryConstructorIfAny(context.session)?.resolvedDelegatedConstructorCall ?: return
-        val visitor = Visitor(context, reporter, companionOfEnumSymbol)
-        delegatingConstructorCall.argumentList.acceptChildren(visitor)
+object FirEnumCompanionInEnumConstructorCallChecker : FirClassChecker() {
+    override fun check(declaration: FirClass, context: CheckerContext, reporter: DiagnosticReporter) {
+        val enumClass = when (declaration.classKind) {
+            ClassKind.ENUM_CLASS -> declaration as FirRegularClass
+            ClassKind.ENUM_ENTRY -> context.containingDeclarations.lastIsInstanceOrNull()
+            else -> null
+        } ?: return
+        val companionOfEnum = enumClass.companionObjectSymbol ?: return
+        val graph = declaration.controlFlowGraphReference?.controlFlowGraph ?: return
+        analyzeGraph(graph, companionOfEnum, context, reporter)
+        if (declaration.classKind.isEnumEntry) {
+            val constructor = declaration.declarations.firstIsInstanceOrNull<FirPrimaryConstructor>()
+            val constructorGraph = constructor?.controlFlowGraphReference?.controlFlowGraph
+            if (constructorGraph != null) {
+                analyzeGraph(constructorGraph, companionOfEnum, context, reporter)
+            }
+        }
     }
 
-    private class Visitor(
-        val context: CheckerContext,
-        val reporter: DiagnosticReporter,
-        val companionSymbol: FirRegularClassSymbol
-    ) : FirVisitorVoid() {
-        override fun visitElement(element: FirElement) {
-            element.acceptChildren(this)
-        }
-
-        override fun visitFunctionCall(functionCall: FirFunctionCall) {
-            val needVisitReceiver = checkQualifiedAccess(functionCall)
-            functionCall.argumentList.acceptChildren(this)
-            if (needVisitReceiver) {
-                functionCall.explicitReceiver?.accept(this)
+    private fun analyzeGraph(
+        graph: ControlFlowGraph,
+        companionSymbol: FirRegularClassSymbol,
+        context: CheckerContext,
+        reporter: DiagnosticReporter
+    ) {
+        for (node in graph.nodes) {
+            if (node is CFGNodeWithSubgraphs) {
+                for (subGraph in node.subGraphs) {
+                    when (subGraph.kind) {
+                        ControlFlowGraph.Kind.AnonymousFunctionCalledInPlace,
+                        ControlFlowGraph.Kind.PropertyInitializer,
+                        ControlFlowGraph.Kind.ClassInitializer -> analyzeGraph(subGraph, companionSymbol, context, reporter)
+                        ControlFlowGraph.Kind.Class -> {
+                            if (subGraph.declaration is FirAnonymousObject) {
+                                analyzeGraph(subGraph, companionSymbol, context, reporter)
+                            }
+                        }
+                        else -> {}
+                    }
+                }
+            }
+            val qualifiedAccess = when (node) {
+                is QualifiedAccessNode -> node.fir
+                is FunctionCallNode -> node.fir
+                else -> continue
+            }
+            val matchingReceiver = qualifiedAccess.allReceiverExpressions
+                .firstOrNull { it.getClassSymbol(context.session) == companionSymbol }
+            if (matchingReceiver != null) {
+                reporter.reportOn(
+                    matchingReceiver.source ?: qualifiedAccess.source,
+                    FirErrors.UNINITIALIZED_ENUM_COMPANION,
+                    companionSymbol,
+                    context
+                )
             }
         }
+    }
 
-        override fun visitPropertyAccessExpression(propertyAccessExpression: FirPropertyAccessExpression) {
-            val needVisitReceiver = checkQualifiedAccess(propertyAccessExpression)
-            if (needVisitReceiver) {
-                propertyAccessExpression.explicitReceiver?.accept(this)
+    private fun FirExpression.getClassSymbol(session: FirSession): FirRegularClassSymbol? {
+        return when (this) {
+            is FirResolvedQualifier -> {
+                this.typeRef.toRegularClassSymbol(session)
             }
-        }
-
-
-        private fun checkQualifiedAccess(expression: FirQualifiedAccessExpression): Boolean {
-            val companionReceiver = checkReceiver(expression.extensionReceiver)
-                ?: checkReceiver(expression.dispatchReceiver)
-                ?: return true
-
-            val source = companionReceiver.source ?: expression.source
-            reporter.reportOn(source, FirErrors.UNINITIALIZED_ENUM_COMPANION, companionSymbol, context)
-            return false
-        }
-
-        private fun checkReceiver(receiverExpression: FirExpression): FirExpression? {
-            if (receiverExpression !is FirResolvedQualifier && receiverExpression !is FirThisReceiverExpression) return null
-            val receiverSymbol = receiverExpression.typeRef.coneType.toRegularClassSymbol(context.session) ?: return null
-            return receiverExpression.takeIf { receiverSymbol == companionSymbol }
-        }
+            else -> (this.toReference() as? FirThisReference)?.boundSymbol
+        } as? FirRegularClassSymbol
     }
 }

compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt

@@ -13,11 +13,9 @@ import org.jetbrains.kotlin.fir.FirSession
 import org.jetbrains.kotlin.fir.analysis.checkers.classKind
 import org.jetbrains.kotlin.fir.analysis.checkers.context.CheckerContext
 import org.jetbrains.kotlin.fir.analysis.checkers.getContainingClassSymbol
-import org.jetbrains.kotlin.fir.analysis.checkers.outerClassSymbol
 import org.jetbrains.kotlin.fir.analysis.diagnostics.FirErrors
 import org.jetbrains.kotlin.fir.containingClassForStaticMemberAttr
 import org.jetbrains.kotlin.fir.declarations.*
-import org.jetbrains.kotlin.fir.declarations.utils.isCompanion
 import org.jetbrains.kotlin.fir.declarations.utils.isEnumClass
 import org.jetbrains.kotlin.fir.expressions.*
 import org.jetbrains.kotlin.fir.references.toResolvedBaseSymbol
@@ -77,16 +75,9 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() {
         if (source.kind is KtFakeSourceElementKind) return
 
         val calleeSymbol = expression.calleeReference.toResolvedBaseSymbol() ?: return
-        val calleeContainingClassSymbol = calleeSymbol.getContainingClassSymbol(context.session) as? FirRegularClassSymbol ?: return
+        val enumClassSymbol = calleeSymbol.getContainingClassSymbol(context.session) as? FirRegularClassSymbol ?: return
         // We're looking for members/entries/companion object in an enum class or members in companion object of an enum class.
-        val calleeIsInsideEnum = calleeContainingClassSymbol.isEnumClass
-        val calleeIsInsideEnumCompanion =
-            calleeContainingClassSymbol.isCompanion && (calleeContainingClassSymbol.outerClassSymbol(context) as? FirRegularClassSymbol)?.isEnumClass == true
-        if (!calleeIsInsideEnum && !calleeIsInsideEnumCompanion) return
-
-        val enumClassSymbol =
-            if (calleeIsInsideEnum) calleeContainingClassSymbol
-            else calleeContainingClassSymbol.outerClassSymbol(context) as? FirRegularClassSymbol ?: return
+        if (!enumClassSymbol.isEnumClass) return
 
         // An accessed context within the enum class of interest. We should look up until either enum members or enum entries are found,
         // not just last containing declaration. For example,
@@ -131,7 +122,9 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() {
         //           JVM_1_6 -> ...
         //     }
         //   }
-        val containingDeclarationForAccess = context.containingDeclarations.lastOrNull()
+        val containingDeclarationForAccess = context.containingDeclarations.lastOrNull {
+            !(it is FirAnonymousFunction && it.invocationKind != null)
+        }
         if (accessedContext in enumMemberProperties) {
             val lazyDelegation = (accessedContext as FirPropertySymbol).lazyDelegation
             if (lazyDelegation != null && lazyDelegation == containingDeclarationForAccess) {
@@ -153,24 +146,6 @@ object FirUninitializedEnumChecker : FirQualifiedAccessExpressionChecker() {
             return
         }
 
-        // Members inside the companion object of an enum class
-        if (calleeContainingClassSymbol == enumClassSymbol.companionObjectSymbol) {
-            // Uninitialized from the point of view of members or enum entries of that enum class
-            if (accessedContext in enumMemberProperties || accessedContext in enumEntries) {
-                if (calleeSymbol is FirPropertySymbol) {
-                    // From KT-11769
-                    // enum class Fruit(...) {
-                    //   APPLE(...);
-                    //   companion object {
-                    //     val common = ...
-                    //   }
-                    //   val score = ... <!>common<!>
-                    // }
-                    reporter.reportOn(source, FirErrors.UNINITIALIZED_VARIABLE, calleeSymbol, context)
-                }
-            }
-        }
-
         // The enum entries of an enum class
         if (calleeSymbol in enumEntries) {
             val calleeEnumEntry = calleeSymbol as FirEnumEntrySymbol

compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt

@@ -28,6 +28,7 @@ import org.jetbrains.kotlin.fir.visitors.TransformData
 import org.jetbrains.kotlin.fir.visitors.transformInplace
 import org.jetbrains.kotlin.name.ClassId
 import org.jetbrains.kotlin.types.ConstantValueKind
+import org.jetbrains.kotlin.utils.addIfNotNull
 
 inline val FirAnnotation.unexpandedConeClassLikeType: ConeClassLikeType?
     get() = ((annotationTypeRef as? FirResolvedTypeRef)?.type as? ConeClassLikeType)
@@ -169,3 +170,10 @@ fun FirExpression.unwrapSmartcastExpression(): FirExpression =
 val FirCallableReferenceAccess.isBound: Boolean
     get() = (dispatchReceiver != FirNoReceiverExpression || extensionReceiver != FirNoReceiverExpression) &&
             calleeReference.toResolvedCallableSymbol()?.isStatic != true
+
+val FirQualifiedAccessExpression.allReceiverExpressions: List<FirExpression>
+    get() = buildList {
+        addIfNotNull(dispatchReceiver)
+        addIfNotNull(extensionReceiver)
+        addAll(contextReceiverArguments)
+    }