diff --git a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt b/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt index 739c7a263e3..e810ef2ef1b 100644 --- a/compiler/fir/analysis-tests/testData/resolve/fromBuilder/enums.kt +++ b/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 = G * m / (r * r) + val g: Double = G * m / (r * r) abstract fun sayHello() diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt index 84a1fefe1ab..fa4d5f91a61 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/CommonDeclarationCheckers.kt +++ b/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 @@ -166,11 +167,6 @@ object CommonDeclarationCheckers : DeclarationCheckers() { FirAnonymousInitializerInInterfaceChecker ) - override val enumEntryCheckers: Set - get() = setOf( - FirEnumCompanionInEnumConstructorCallChecker, - ) - override val valueParameterCheckers: Set get() = setOf() } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt index 1d40ab46181..80d70710918 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/declaration/FirEnumCompanionInEnumConstructorCallChecker.kt +++ b/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() ?: 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() + 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 } } diff --git a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt b/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt index eafc44ea727..350e10f3909 100644 --- a/compiler/fir/checkers/src/org/jetbrains/kotlin/fir/analysis/checkers/expression/FirUninitializedEnumChecker.kt +++ b/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 diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt index 108369a1146..d9a18da11b9 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/expressions/FirExpressionUtil.kt +++ b/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 + get() = buildList { + addIfNotNull(dispatchReceiver) + addIfNotNull(extensionReceiver) + addAll(contextReceiverArguments) + } diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedEnumCompanionVals.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedEnumCompanionVals.fir.kt index e59692764df..879c48c5a1a 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedEnumCompanionVals.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/UninitializedEnumCompanionVals.fir.kt @@ -1,7 +1,7 @@ // SKIP_TXT enum class A(val z: Any) { - Y(x); + Y(x); companion object { val x = A.Y.ordinal @@ -9,7 +9,7 @@ enum class A(val z: Any) { } enum class B(val z: Any) { - Y(B.x); + Y(B.x); companion object { val x = B.Y.ordinal diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/accessToCompanionInBaseEnumInitSection_function.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/accessToCompanionInBaseEnumInitSection_function.fir.kt index 50f67742efe..9d1993c4fa5 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/accessToCompanionInBaseEnumInitSection_function.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/accessToCompanionInBaseEnumInitSection_function.fir.kt @@ -10,22 +10,22 @@ import kotlin.reflect.KProperty enum class Enum { A { - val aInside = foo() - val bInside = inPlaceRun { foo() } + val aInside = foo() + val bInside = inPlaceRun { foo() } val cInside = nonInPlaceRun { foo() } - val dInside by foo() - val eInside by inPlaceDelegate { foo() } + val dInside by foo() + val eInside by inPlaceDelegate { foo() } val fInside by nonInPlaceDelegate { foo() } }, B { init { - val aInit = foo() - val bInit = inPlaceRun { foo() } + val aInit = foo() + val bInit = inPlaceRun { foo() } val cInit = nonInPlaceRun { foo() } - val dInit by foo() - val eInit by inPlaceDelegate { foo() } + val dInit by foo() + val eInit by inPlaceDelegate { foo() } val fInit by nonInPlaceDelegate { foo() } } }, @@ -65,21 +65,21 @@ enum class Enum { D { init { val someObj = object { - val aInside = foo() - val bInside = inPlaceRun { foo() } + val aInside = foo() + val bInside = inPlaceRun { foo() } val cInside = nonInPlaceRun { foo() } - val dInside by foo() - val eInside by inPlaceDelegate { foo() } + val dInside by foo() + val eInside by inPlaceDelegate { foo() } val fInside by nonInPlaceDelegate { foo() } init { - val aInit = foo() - val bInit = inPlaceRun { foo() } + val aInit = foo() + val bInit = inPlaceRun { foo() } val cInit = nonInPlaceRun { foo() } - val dInit by foo() - val eInit by inPlaceDelegate { foo() } + val dInit by foo() + val eInit by inPlaceDelegate { foo() } val fInit by nonInPlaceDelegate { foo() } } @@ -97,12 +97,12 @@ enum class Enum { } ; - val a = foo() - val b = inPlaceRun { foo() } + val a = foo() + val b = inPlaceRun { foo() } val c = nonInPlaceRun { foo() } - val d by foo() - val e by inPlaceDelegate { foo() } + val d by foo() + val e by inPlaceDelegate { foo() } val f by nonInPlaceDelegate { foo() } companion object { @@ -114,7 +114,7 @@ enum class EnumWithConstructor(val a: String, val b: String, val c: String) { A( a = foo(), b = inPlaceRun { foo() }, - c = nonInPlaceRun { foo() } + c = nonInPlaceRun { foo() } ); companion object { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/accessToCompanionInBaseEnumInitSection_property.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/accessToCompanionInBaseEnumInitSection_property.fir.kt index 42e4f84fc31..c7f7431ee17 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/accessToCompanionInBaseEnumInitSection_property.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/accessToCompanionInBaseEnumInitSection_property.fir.kt @@ -10,22 +10,22 @@ import kotlin.reflect.KProperty enum class Enum { A { - val aInside = value - val bInside = inPlaceRun { value } + val aInside = value + val bInside = inPlaceRun { value } val cInside = nonInPlaceRun { value } - val dInside by value - val eInside by inPlaceDelegate { value } + val dInside by value + val eInside by inPlaceDelegate { value } val fInside by nonInPlaceDelegate { value } }, B { init { - val aInit = value - val bInit = inPlaceRun { value } + val aInit = value + val bInit = inPlaceRun { value } val cInit = nonInPlaceRun { value } - val dInit by value - val eInit by inPlaceDelegate { value } + val dInit by value + val eInit by inPlaceDelegate { value } val fInit by nonInPlaceDelegate { value } } }, @@ -65,21 +65,21 @@ enum class Enum { D { init { val someObj = object { - val aInside = value - val bInside = inPlaceRun { value } + val aInside = value + val bInside = inPlaceRun { value } val cInside = nonInPlaceRun { value } - val dInside by value - val eInside by inPlaceDelegate { value } + val dInside by value + val eInside by inPlaceDelegate { value } val fInside by nonInPlaceDelegate { value } init { - val aInit = value - val bInit = inPlaceRun { value } + val aInit = value + val bInit = inPlaceRun { value } val cInit = nonInPlaceRun { value } - val dInit by value - val eInit by inPlaceDelegate { value } + val dInit by value + val eInit by inPlaceDelegate { value } val fInit by nonInPlaceDelegate { value } } @@ -97,13 +97,13 @@ enum class Enum { } ; - val a = value - val b = inPlaceRun { value } - val c = nonInPlaceRun { value } + val a = value + val b = inPlaceRun { value } + val c = nonInPlaceRun { value } - val d by value - val e by inPlaceDelegate { value } - val f by nonInPlaceDelegate { value } + val d by value + val e by inPlaceDelegate { value } + val f by nonInPlaceDelegate { value } companion object { val value = "value" @@ -112,9 +112,9 @@ enum class Enum { enum class EnumWithConstructor(val a: String, val b: String, val c: String) { A( - a = value, - b = inPlaceRun { value }, - c = nonInPlaceRun { value } + a = value, + b = inPlaceRun { value }, + c = nonInPlaceRun { value } ); companion object { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/enumCompanionInterdependence.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/enumCompanionInterdependence.fir.kt index 621bbd0bd31..ce119af11c8 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/enumCompanionInterdependence.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/enumCompanionInterdependence.fir.kt @@ -9,7 +9,7 @@ enum class B(val x: Int) { } enum class C(val x: Int) { - C1(SUM), + C1(SUM), C2(1); companion object { @@ -26,8 +26,8 @@ enum class Fruit(personal: Int) { val common = 20 } - val score = personal + common - val score2 = { personal + common }() + val score = personal + common + val score2 = { personal + common }() } // Another example from KT-11769 diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_after.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_after.fir.kt index 0727d4e6832..26295035352 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_after.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_after.fir.kt @@ -3,13 +3,13 @@ enum class SomeEnum(val x: Int) { A(companionFun().length),// UNINITIALIZED_ENUM_COMPANION - B(companionProp.length), // UNINITIALIZED_VARIABLE + B(companionProp.length), // UNINITIALIZED_VARIABLE C(SomeEnum.companionFun().length), - D(SomeEnum.companionProp.length), + D(SomeEnum.companionProp.length), E(SomeEnum.Companion.companionFun().length), - F(SomeEnum.Companion.companionProp.length); // UNINITIALIZED_VARIABLE + F(SomeEnum.Companion.companionProp.length); // UNINITIALIZED_VARIABLE companion object { val companionProp = "someString" @@ -39,17 +39,17 @@ val OtherEnum.Companion.extensionProp: String enum class EnumWithLambda(val lambda: () -> Unit) { M({ - companionFun().length - companionProp.length + companionFun().length + companionProp.length - EnumWithLambda.companionFun().length - EnumWithLambda.companionProp.length + EnumWithLambda.companionFun().length + EnumWithLambda.companionProp.length - extensionFun().length - extensionProp.length + extensionFun().length + extensionProp.length - EnumWithLambda.extensionFun().length - EnumWithLambda.extensionProp.length + EnumWithLambda.extensionFun().length + EnumWithLambda.extensionProp.length }); companion object { diff --git a/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_before.fir.kt b/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_before.fir.kt index c94d1876f35..ef45d3cef75 100644 --- a/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_before.fir.kt +++ b/compiler/testData/diagnostics/tests/controlFlowAnalysis/uninitializedCompanionOfEnum_before.fir.kt @@ -3,13 +3,13 @@ enum class SomeEnum(val x: Int) { A(companionFun().length),// UNINITIALIZED_ENUM_COMPANION - B(companionProp.length), // UNINITIALIZED_VARIABLE + B(companionProp.length), // UNINITIALIZED_VARIABLE C(SomeEnum.companionFun().length), - D(SomeEnum.companionProp.length), + D(SomeEnum.companionProp.length), E(SomeEnum.Companion.companionFun().length), - F(SomeEnum.Companion.companionProp.length); // UNINITIALIZED_VARIABLE + F(SomeEnum.Companion.companionProp.length); // UNINITIALIZED_VARIABLE companion object { val companionProp = "someString" @@ -39,17 +39,17 @@ val OtherEnum.Companion.extensionProp: String enum class EnumWithLambda(val lambda: () -> Unit) { M({ - companionFun().length - companionProp.length + companionFun().length + companionProp.length - EnumWithLambda.companionFun().length - EnumWithLambda.companionProp.length + EnumWithLambda.companionFun().length + EnumWithLambda.companionProp.length - extensionFun().length - extensionProp.length + extensionFun().length + extensionProp.length - EnumWithLambda.extensionFun().length - EnumWithLambda.extensionProp.length + EnumWithLambda.extensionFun().length + EnumWithLambda.extensionProp.length }); companion object {