From 60662663be8ede894160505b53aca020da54f242 Mon Sep 17 00:00:00 2001 From: pyos Date: Sun, 11 Dec 2022 22:27:30 +0100 Subject: [PATCH] FIR CFA: remove the `id` parameter from nodes --- .../dfa/cfg/ControlFlowGraphBuilder.kt | 2 +- .../dfa/cfg/ControlFlowGraphNodeBuilder.kt | 171 ++++++++------- .../kotlin/fir/resolve/dfa/cfg/CFGNode.kt | 199 +++++++++--------- 3 files changed, 186 insertions(+), 186 deletions(-) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt index 56bb08ce701..f88da9be02d 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphBuilder.kt @@ -1035,7 +1035,7 @@ class ControlFlowGraphBuilder { // it would be much easier if we could build calls after full completion only, at least for Nothing calls private fun completeFunctionCall(node: FunctionCallNode) { if (!node.fir.resultType.isNothing) return - val stub = StubNode(node.owner, node.level, node.owner.nodeCount++) + val stub = StubNode(node.owner, node.level) val edges = node.followingNodes.map { it to node.edgeTo(it) } CFGNode.removeAllOutgoingEdges(node) CFGNode.addEdge(node, stub, EdgeKind.DeadForward, propagateDeadness = false) diff --git a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt index b06edfa9172..2b919242ab5 100644 --- a/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt +++ b/compiler/fir/resolve/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/ControlFlowGraphNodeBuilder.kt @@ -9,252 +9,249 @@ import org.jetbrains.kotlin.fir.FirElement import org.jetbrains.kotlin.fir.declarations.* import org.jetbrains.kotlin.fir.expressions.* -@OptIn(CfgInternals::class) -private fun ControlFlowGraphBuilder.createId(): Int = currentGraph.nodeCount++ - -fun ControlFlowGraphBuilder.createStubNode(): StubNode = StubNode(currentGraph, levelCounter, createId()) +fun ControlFlowGraphBuilder.createStubNode(): StubNode = StubNode(currentGraph, levelCounter) fun ControlFlowGraphBuilder.createFakeExpressionEnterNode(): FakeExpressionEnterNode = - FakeExpressionEnterNode(currentGraph, levelCounter, createId()) + FakeExpressionEnterNode(currentGraph, levelCounter) -fun ControlFlowGraphBuilder.createLoopExitNode(fir: FirLoop): LoopExitNode = LoopExitNode(currentGraph, fir, levelCounter, createId()) +fun ControlFlowGraphBuilder.createLoopExitNode(fir: FirLoop): LoopExitNode = LoopExitNode(currentGraph, fir, levelCounter) -fun ControlFlowGraphBuilder.createLoopEnterNode(fir: FirLoop): LoopEnterNode = LoopEnterNode(currentGraph, fir, levelCounter, createId()) +fun ControlFlowGraphBuilder.createLoopEnterNode(fir: FirLoop): LoopEnterNode = LoopEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createInitBlockEnterNode(fir: FirAnonymousInitializer): InitBlockEnterNode = - InitBlockEnterNode(currentGraph, fir, levelCounter, createId()) + InitBlockEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createInitBlockExitNode(fir: FirAnonymousInitializer): InitBlockExitNode = - InitBlockExitNode(currentGraph, fir, levelCounter, createId()) + InitBlockExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createTypeOperatorCallNode(fir: FirTypeOperatorCall): TypeOperatorCallNode = - TypeOperatorCallNode(currentGraph, fir, levelCounter, createId()) + TypeOperatorCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createEqualityOperatorCallNode(fir: FirEqualityOperatorCall): EqualityOperatorCallNode = - EqualityOperatorCallNode(currentGraph, fir, levelCounter, createId()) + EqualityOperatorCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createWhenBranchConditionExitNode(fir: FirWhenBranch): WhenBranchConditionExitNode = - WhenBranchConditionExitNode(currentGraph, fir, levelCounter, createId()) + WhenBranchConditionExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createJumpNode(fir: FirJump<*>): JumpNode = - JumpNode(currentGraph, fir, levelCounter, createId()) + JumpNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createCheckNotNullCallNode(fir: FirCheckNotNullCall): CheckNotNullCallNode = - CheckNotNullCallNode(currentGraph, fir, levelCounter, createId()) + CheckNotNullCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createQualifiedAccessNode(fir: FirQualifiedAccessExpression): QualifiedAccessNode = - QualifiedAccessNode(currentGraph, fir, levelCounter, createId()) + QualifiedAccessNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createResolvedQualifierNode(fir: FirResolvedQualifier): ResolvedQualifierNode = - ResolvedQualifierNode(currentGraph, fir, levelCounter, createId()) + ResolvedQualifierNode(currentGraph, fir, levelCounter) -fun ControlFlowGraphBuilder.createBlockEnterNode(fir: FirBlock): BlockEnterNode = BlockEnterNode(currentGraph, fir, levelCounter, createId()) +fun ControlFlowGraphBuilder.createBlockEnterNode(fir: FirBlock): BlockEnterNode = BlockEnterNode(currentGraph, fir, levelCounter) -fun ControlFlowGraphBuilder.createBlockExitNode(fir: FirBlock): BlockExitNode = BlockExitNode(currentGraph, fir, levelCounter, createId()) +fun ControlFlowGraphBuilder.createBlockExitNode(fir: FirBlock): BlockExitNode = BlockExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createPropertyInitializerExitNode(fir: FirProperty): PropertyInitializerExitNode = - PropertyInitializerExitNode(currentGraph, fir, levelCounter, createId()) + PropertyInitializerExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createPropertyInitializerEnterNode(fir: FirProperty): PropertyInitializerEnterNode = - PropertyInitializerEnterNode(currentGraph, fir, levelCounter, createId()) + PropertyInitializerEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createDelegateExpressionExitNode(fir: FirExpression): DelegateExpressionExitNode = - DelegateExpressionExitNode(currentGraph, fir, levelCounter, createId()) + DelegateExpressionExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFieldInitializerExitNode(fir: FirField): FieldInitializerExitNode = - FieldInitializerExitNode(currentGraph, fir, levelCounter, createId()) + FieldInitializerExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFieldInitializerEnterNode(fir: FirField): FieldInitializerEnterNode = - FieldInitializerEnterNode(currentGraph, fir, levelCounter, createId()) + FieldInitializerEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFunctionEnterNode(fir: FirFunction): FunctionEnterNode = - FunctionEnterNode(currentGraph, fir, levelCounter, createId()) + FunctionEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFunctionExitNode(fir: FirFunction): FunctionExitNode = - FunctionExitNode(currentGraph, fir, levelCounter, createId()) + FunctionExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createLocalFunctionDeclarationNode(fir: FirFunction): LocalFunctionDeclarationNode = - LocalFunctionDeclarationNode(currentGraph, fir, levelCounter, createId()) + LocalFunctionDeclarationNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createBinaryOrEnterNode(fir: FirBinaryLogicExpression): BinaryOrEnterNode = - BinaryOrEnterNode(currentGraph, fir, levelCounter, createId()) + BinaryOrEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createBinaryOrExitLeftOperandNode(fir: FirBinaryLogicExpression): BinaryOrExitLeftOperandNode = - BinaryOrExitLeftOperandNode(currentGraph, fir, levelCounter, createId()) + BinaryOrExitLeftOperandNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createBinaryOrExitNode(fir: FirBinaryLogicExpression): BinaryOrExitNode = - BinaryOrExitNode(currentGraph, fir, levelCounter, createId()) + BinaryOrExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createBinaryAndExitNode(fir: FirBinaryLogicExpression): BinaryAndExitNode = - BinaryAndExitNode(currentGraph, fir, levelCounter, createId()) + BinaryAndExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createBinaryAndEnterNode(fir: FirBinaryLogicExpression): BinaryAndEnterNode = - BinaryAndEnterNode(currentGraph, fir, levelCounter, createId()) + BinaryAndEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createWhenBranchConditionEnterNode(fir: FirWhenBranch): WhenBranchConditionEnterNode = - WhenBranchConditionEnterNode(currentGraph, fir, levelCounter, createId()) + WhenBranchConditionEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createWhenEnterNode(fir: FirWhenExpression): WhenEnterNode = - WhenEnterNode(currentGraph, fir, levelCounter, createId()) + WhenEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createWhenExitNode(fir: FirWhenExpression): WhenExitNode = - WhenExitNode(currentGraph, fir, levelCounter, createId()) + WhenExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createWhenBranchResultExitNode(fir: FirWhenBranch): WhenBranchResultExitNode = - WhenBranchResultExitNode(currentGraph, fir, levelCounter, createId()) + WhenBranchResultExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createWhenSyntheticElseBranchNode(fir: FirWhenExpression): WhenSyntheticElseBranchNode = - WhenSyntheticElseBranchNode(currentGraph, fir, levelCounter, createId()) + WhenSyntheticElseBranchNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createWhenBranchResultEnterNode(fir: FirWhenBranch): WhenBranchResultEnterNode = - WhenBranchResultEnterNode(currentGraph, fir, levelCounter, createId()) + WhenBranchResultEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createLoopConditionExitNode(fir: FirExpression): LoopConditionExitNode = - LoopConditionExitNode(currentGraph, fir, levelCounter, createId()) + LoopConditionExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createLoopConditionEnterNode(fir: FirExpression, loop: FirLoop): LoopConditionEnterNode = - LoopConditionEnterNode(currentGraph, fir, loop, levelCounter, createId()) + LoopConditionEnterNode(currentGraph, fir, loop, levelCounter) fun ControlFlowGraphBuilder.createLoopBlockEnterNode(fir: FirLoop): LoopBlockEnterNode = - LoopBlockEnterNode(currentGraph, fir, levelCounter, createId()) + LoopBlockEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createLoopBlockExitNode(fir: FirLoop): LoopBlockExitNode = - LoopBlockExitNode(currentGraph, fir, levelCounter, createId()) + LoopBlockExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFunctionCallNode(fir: FirFunctionCall): FunctionCallNode = - FunctionCallNode(currentGraph, fir, levelCounter, createId()) + FunctionCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createCallableReferenceNode(fir: FirCallableReferenceAccess): CallableReferenceNode = - CallableReferenceNode(currentGraph, fir, levelCounter, createId()) + CallableReferenceNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createGetClassCallNode(fir: FirGetClassCall): GetClassCallNode = - GetClassCallNode(currentGraph, fir, levelCounter, createId()) + GetClassCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createDelegatedConstructorCallNode(fir: FirDelegatedConstructorCall): DelegatedConstructorCallNode = - DelegatedConstructorCallNode(currentGraph, fir, levelCounter, createId()) + DelegatedConstructorCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createStringConcatenationCallNode(fir: FirStringConcatenationCall): StringConcatenationCallNode = - StringConcatenationCallNode(currentGraph, fir, levelCounter, createId()) + StringConcatenationCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createVariableAssignmentNode(fir: FirVariableAssignment): VariableAssignmentNode = - VariableAssignmentNode(currentGraph, fir, levelCounter, createId()) + VariableAssignmentNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createElvisLhsIsNotNullNode(fir: FirElvisExpression): ElvisLhsIsNotNullNode = - ElvisLhsIsNotNullNode(currentGraph, fir, levelCounter, createId()) + ElvisLhsIsNotNullNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createElvisRhsEnterNode(fir: FirElvisExpression): ElvisRhsEnterNode = - ElvisRhsEnterNode(currentGraph, fir, levelCounter, createId()) + ElvisRhsEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createElvisLhsExitNode(fir: FirElvisExpression): ElvisLhsExitNode = - ElvisLhsExitNode(currentGraph, fir, levelCounter, createId()) + ElvisLhsExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createWhenSubjectExpressionExitNode(fir: FirWhenSubjectExpression): WhenSubjectExpressionExitNode = - WhenSubjectExpressionExitNode(currentGraph, fir, levelCounter, createId()) + WhenSubjectExpressionExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createElvisExitNode(fir: FirElvisExpression): ElvisExitNode = - ElvisExitNode(currentGraph, fir, levelCounter, createId()) + ElvisExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createVariableDeclarationNode(fir: FirProperty): VariableDeclarationNode = - VariableDeclarationNode(currentGraph, fir, levelCounter, createId()) + VariableDeclarationNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createConstExpressionNode(fir: FirConstExpression<*>): ConstExpressionNode = - ConstExpressionNode(currentGraph, fir, levelCounter, createId()) + ConstExpressionNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createThrowExceptionNode(fir: FirThrowExpression): ThrowExceptionNode = - ThrowExceptionNode(currentGraph, fir, levelCounter, createId()) + ThrowExceptionNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFinallyProxyExitNode(fir: FirTryExpression): FinallyProxyExitNode = - FinallyProxyExitNode(currentGraph, fir, levelCounter, createId()) + FinallyProxyExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFinallyProxyEnterNode(fir: FirTryExpression): FinallyProxyEnterNode = - FinallyProxyEnterNode(currentGraph, fir, levelCounter, createId()) + FinallyProxyEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFinallyBlockExitNode(fir: FirTryExpression): FinallyBlockExitNode = - FinallyBlockExitNode(currentGraph, fir, levelCounter, createId()) + FinallyBlockExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createFinallyBlockEnterNode(fir: FirTryExpression): FinallyBlockEnterNode = - FinallyBlockEnterNode(currentGraph, fir, levelCounter, createId()) + FinallyBlockEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createCatchClauseExitNode(fir: FirCatch): CatchClauseExitNode = - CatchClauseExitNode(currentGraph, fir, levelCounter, createId()) + CatchClauseExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createTryMainBlockExitNode(fir: FirTryExpression): TryMainBlockExitNode = - TryMainBlockExitNode(currentGraph, fir, levelCounter, createId()) + TryMainBlockExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createTryMainBlockEnterNode(fir: FirTryExpression): TryMainBlockEnterNode = - TryMainBlockEnterNode(currentGraph, fir, levelCounter, createId()) + TryMainBlockEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createCatchClauseEnterNode(fir: FirCatch): CatchClauseEnterNode = - CatchClauseEnterNode(currentGraph, fir, levelCounter, createId()) + CatchClauseEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createTryExpressionEnterNode(fir: FirTryExpression): TryExpressionEnterNode = - TryExpressionEnterNode(currentGraph, fir, levelCounter, createId()) + TryExpressionEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createTryExpressionExitNode(fir: FirTryExpression): TryExpressionExitNode = - TryExpressionExitNode(currentGraph, fir, levelCounter, createId()) + TryExpressionExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createBinaryAndExitLeftOperandNode(fir: FirBinaryLogicExpression): BinaryAndExitLeftOperandNode = - BinaryAndExitLeftOperandNode(currentGraph, fir, levelCounter, createId()) + BinaryAndExitLeftOperandNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createBinaryAndEnterRightOperandNode(fir: FirBinaryLogicExpression): BinaryAndEnterRightOperandNode = - BinaryAndEnterRightOperandNode(currentGraph, fir, levelCounter, createId()) + BinaryAndEnterRightOperandNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createBinaryOrEnterRightOperandNode(fir: FirBinaryLogicExpression): BinaryOrEnterRightOperandNode = - BinaryOrEnterRightOperandNode(currentGraph, fir, levelCounter, createId()) + BinaryOrEnterRightOperandNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createExitSafeCallNode(fir: FirSafeCallExpression): ExitSafeCallNode = - ExitSafeCallNode(currentGraph, fir, levelCounter, createId()) + ExitSafeCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createEnterSafeCallNode(fir: FirSafeCallExpression): EnterSafeCallNode = - EnterSafeCallNode(currentGraph, fir, levelCounter, createId()) + EnterSafeCallNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createPostponedLambdaExitNode(fir: FirAnonymousFunctionExpression): PostponedLambdaExitNode = - PostponedLambdaExitNode(currentGraph, fir, levelCounter, createId()) + PostponedLambdaExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createSplitPostponedLambdasNode(fir: FirStatement, lambdas: List): SplitPostponedLambdasNode = - SplitPostponedLambdasNode(currentGraph, fir, lambdas, levelCounter, createId()) + SplitPostponedLambdasNode(currentGraph, fir, lambdas, levelCounter) fun ControlFlowGraphBuilder.createMergePostponedLambdaExitsNode(fir: FirElement): MergePostponedLambdaExitsNode = - MergePostponedLambdaExitsNode(currentGraph, fir, levelCounter, createId()) + MergePostponedLambdaExitsNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createAnonymousFunctionExpressionNode(fir: FirAnonymousFunctionExpression): AnonymousFunctionExpressionNode = - AnonymousFunctionExpressionNode(currentGraph, fir, levelCounter, createId()) + AnonymousFunctionExpressionNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createAnonymousObjectEnterNode(fir: FirAnonymousObject): AnonymousObjectEnterNode = - AnonymousObjectEnterNode(currentGraph, fir, levelCounter, createId()) + AnonymousObjectEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createAnonymousObjectExpressionExitNode(fir: FirAnonymousObjectExpression): AnonymousObjectExpressionExitNode = - AnonymousObjectExpressionExitNode(currentGraph, fir, levelCounter, createId()) + AnonymousObjectExpressionExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createScriptEnterNode(fir: FirScript): ScriptEnterNode = - ScriptEnterNode(currentGraph, fir, levelCounter, createId()) + ScriptEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createScriptExitNode(fir: FirScript): ScriptExitNode = - ScriptExitNode(currentGraph, fir, levelCounter, createId()) + ScriptExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createClassEnterNode(fir: FirClass): ClassEnterNode = - ClassEnterNode(currentGraph, fir, levelCounter, createId()) + ClassEnterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createClassExitNode(fir: FirClass): ClassExitNode = - ClassExitNode(currentGraph, fir, levelCounter, createId()) + ClassExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createLocalClassExitNode(fir: FirRegularClass): LocalClassExitNode = - LocalClassExitNode(currentGraph, fir, levelCounter, createId()) + LocalClassExitNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createEnterValueParameterNode(fir: FirValueParameter): EnterValueParameterNode = - EnterValueParameterNode(currentGraph, fir, levelCounter, createId()) + EnterValueParameterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createEnterDefaultArgumentsNode(fir: FirValueParameter): EnterDefaultArgumentsNode = - EnterDefaultArgumentsNode(currentGraph, fir, levelCounter, createId()) + EnterDefaultArgumentsNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createExitDefaultArgumentsNode(fir: FirValueParameter): ExitDefaultArgumentsNode = - ExitDefaultArgumentsNode(currentGraph, fir, levelCounter, createId()) + ExitDefaultArgumentsNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createExitValueParameterNode(fir: FirValueParameter): ExitValueParameterNode = - ExitValueParameterNode(currentGraph, fir, levelCounter, createId()) + ExitValueParameterNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createComparisonExpressionNode(fir: FirComparisonExpression): ComparisonExpressionNode = - ComparisonExpressionNode(currentGraph, fir, levelCounter, createId()) + ComparisonExpressionNode(currentGraph, fir, levelCounter) fun ControlFlowGraphBuilder.createSmartCastExitNode(fir: FirSmartCastExpression): SmartCastExpressionExitNode = - SmartCastExpressionExitNode(currentGraph, fir, levelCounter, createId()) \ No newline at end of file + SmartCastExpressionExitNode(currentGraph, fir, levelCounter) \ No newline at end of file diff --git a/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt b/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt index 303b95c2feb..db308974202 100644 --- a/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt +++ b/compiler/fir/semantics/src/org/jetbrains/kotlin/fir/resolve/dfa/cfg/CFGNode.kt @@ -23,7 +23,10 @@ import org.jetbrains.kotlin.utils.SmartList @RequiresOptIn annotation class CfgInternals -sealed class CFGNode(val owner: ControlFlowGraph, val level: Int, val id: Int) { +sealed class CFGNode(val owner: ControlFlowGraph, val level: Int) { + @OptIn(CfgInternals::class) + val id = owner.nodeCount++ + companion object { @CfgInternals fun addEdge( @@ -129,32 +132,32 @@ interface UnionNodeMarker // ----------------------------------- EnterNode for declaration with CFG ----------------------------------- -sealed class CFGNodeWithSubgraphs(owner: ControlFlowGraph, level: Int, id: Int) : CFGNode(owner, level, id) { +sealed class CFGNodeWithSubgraphs(owner: ControlFlowGraph, level: Int) : CFGNode(owner, level) { abstract val subGraphs: List } -sealed class CFGNodeWithCfgOwner(owner: ControlFlowGraph, level: Int, id: Int) : CFGNodeWithSubgraphs(owner, level, id) { +sealed class CFGNodeWithCfgOwner(owner: ControlFlowGraph, level: Int) : CFGNodeWithSubgraphs(owner, level) { final override val subGraphs: List get() = listOfNotNull(fir.controlFlowGraphReference?.controlFlowGraph) } // ----------------------------------- Named function ----------------------------------- -class FunctionEnterNode(owner: ControlFlowGraph, override val fir: FirFunction, level: Int, id: Int) : CFGNode(owner, level, id), +class FunctionEnterNode(owner: ControlFlowGraph, override val fir: FirFunction, level: Int) : CFGNode(owner, level), GraphEnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFunctionEnterNode(this, data) } } -class FunctionExitNode(owner: ControlFlowGraph, override val fir: FirFunction, level: Int, id: Int) : CFGNode(owner, level, id), +class FunctionExitNode(owner: ControlFlowGraph, override val fir: FirFunction, level: Int) : CFGNode(owner, level), GraphExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFunctionExitNode(this, data) } } -class LocalFunctionDeclarationNode(owner: ControlFlowGraph, override val fir: FirFunction, level: Int, id: Int) : CFGNodeWithCfgOwner(owner, level, id) { +class LocalFunctionDeclarationNode(owner: ControlFlowGraph, override val fir: FirFunction, level: Int) : CFGNodeWithCfgOwner(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitLocalFunctionDeclarationNode(this, data) } @@ -162,27 +165,27 @@ class LocalFunctionDeclarationNode(owner: ControlFlowGraph, override val fir: Fi // ----------------------------------- Default arguments ----------------------------------- -class EnterValueParameterNode(owner: ControlFlowGraph, override val fir: FirValueParameter, level: Int, id: Int) : CFGNodeWithCfgOwner(owner, level, id) { +class EnterValueParameterNode(owner: ControlFlowGraph, override val fir: FirValueParameter, level: Int) : CFGNodeWithCfgOwner(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitEnterValueParameterNode(this, data) } } -class EnterDefaultArgumentsNode(owner: ControlFlowGraph, override val fir: FirValueParameter, level: Int, id: Int) : CFGNode(owner, level, id), +class EnterDefaultArgumentsNode(owner: ControlFlowGraph, override val fir: FirValueParameter, level: Int) : CFGNode(owner, level), GraphEnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitEnterDefaultArgumentsNode(this, data) } } -class ExitDefaultArgumentsNode(owner: ControlFlowGraph, override val fir: FirValueParameter, level: Int, id: Int) : CFGNode(owner, level, id), +class ExitDefaultArgumentsNode(owner: ControlFlowGraph, override val fir: FirValueParameter, level: Int) : CFGNode(owner, level), GraphExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitExitDefaultArgumentsNode(this, data) } } -class ExitValueParameterNode(owner: ControlFlowGraph, override val fir: FirValueParameter, level: Int, id: Int) : CFGNode(owner, level, id) { +class ExitValueParameterNode(owner: ControlFlowGraph, override val fir: FirValueParameter, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitExitValueParameterNode(this, data) } @@ -190,8 +193,8 @@ class ExitValueParameterNode(owner: ControlFlowGraph, override val fir: FirValue // ----------------------------------- Anonymous function ----------------------------------- -class SplitPostponedLambdasNode(owner: ControlFlowGraph, override val fir: FirStatement, val lambdas: List, level: Int, id: Int) - : CFGNodeWithSubgraphs(owner, level, id) { +class SplitPostponedLambdasNode(owner: ControlFlowGraph, override val fir: FirStatement, val lambdas: List, level: Int) + : CFGNodeWithSubgraphs(owner, level) { override val subGraphs: List get() = lambdas.mapNotNull { it.controlFlowGraphReference?.controlFlowGraph } @@ -201,19 +204,19 @@ class SplitPostponedLambdasNode(owner: ControlFlowGraph, override val fir: FirSt } } -class PostponedLambdaExitNode(owner: ControlFlowGraph, override val fir: FirAnonymousFunctionExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class PostponedLambdaExitNode(owner: ControlFlowGraph, override val fir: FirAnonymousFunctionExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitPostponedLambdaExitNode(this, data) } } -class MergePostponedLambdaExitsNode(owner: ControlFlowGraph, override val fir: FirElement, level: Int, id: Int) : CFGNode(owner, level, id) { +class MergePostponedLambdaExitsNode(owner: ControlFlowGraph, override val fir: FirElement, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitMergePostponedLambdaExitsNode(this, data) } } -class AnonymousFunctionExpressionNode(owner: ControlFlowGraph, override val fir: FirAnonymousFunctionExpression, level: Int, id: Int) : CFGNodeWithSubgraphs(owner, level, id) { +class AnonymousFunctionExpressionNode(owner: ControlFlowGraph, override val fir: FirAnonymousFunctionExpression, level: Int) : CFGNodeWithSubgraphs(owner, level) { override val subGraphs: List get() = listOfNotNull(fir.anonymousFunction.controlFlowGraphReference?.controlFlowGraph) @@ -224,7 +227,7 @@ class AnonymousFunctionExpressionNode(owner: ControlFlowGraph, override val fir: // ----------------------------------- Classes ----------------------------------- -class ClassEnterNode(owner: ControlFlowGraph, override val fir: FirClass, level: Int, id: Int) : CFGNodeWithSubgraphs(owner, level, id), +class ClassEnterNode(owner: ControlFlowGraph, override val fir: FirClass, level: Int) : CFGNodeWithSubgraphs(owner, level), GraphEnterNodeMarker { override lateinit var subGraphs: List @@ -233,7 +236,7 @@ class ClassEnterNode(owner: ControlFlowGraph, override val fir: FirClass, level: } } -class ClassExitNode(owner: ControlFlowGraph, override val fir: FirClass, level: Int, id: Int) : CFGNodeWithSubgraphs(owner, level, id), +class ClassExitNode(owner: ControlFlowGraph, override val fir: FirClass, level: Int) : CFGNodeWithSubgraphs(owner, level), GraphExitNodeMarker, UnionNodeMarker { lateinit override var subGraphs: List @@ -243,19 +246,19 @@ class ClassExitNode(owner: ControlFlowGraph, override val fir: FirClass, level: } } -class LocalClassExitNode(owner: ControlFlowGraph, override val fir: FirRegularClass, level: Int, id: Int) : CFGNodeWithCfgOwner(owner, level, id) { +class LocalClassExitNode(owner: ControlFlowGraph, override val fir: FirRegularClass, level: Int) : CFGNodeWithCfgOwner(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitLocalClassExitNode(this, data) } } -class AnonymousObjectEnterNode(owner: ControlFlowGraph, override val fir: FirAnonymousObject, level: Int, id: Int) : CFGNodeWithCfgOwner(owner, level, id) { +class AnonymousObjectEnterNode(owner: ControlFlowGraph, override val fir: FirAnonymousObject, level: Int) : CFGNodeWithCfgOwner(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitAnonymousObjectEnterNode(this, data) } } -class AnonymousObjectExpressionExitNode(owner: ControlFlowGraph, override val fir: FirAnonymousObjectExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class AnonymousObjectExpressionExitNode(owner: ControlFlowGraph, override val fir: FirAnonymousObjectExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitAnonymousObjectExpressionExitNode(this, data) } @@ -263,13 +266,13 @@ class AnonymousObjectExpressionExitNode(owner: ControlFlowGraph, override val fi // ----------------------------------- Scripts ------------------------------------------ -class ScriptEnterNode(owner: ControlFlowGraph, override val fir: FirScript, level: Int, id: Int) : CFGNode(owner, level, id), GraphEnterNodeMarker { +class ScriptEnterNode(owner: ControlFlowGraph, override val fir: FirScript, level: Int) : CFGNode(owner, level), GraphEnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitScriptEnterNode(this, data) } } -class ScriptExitNode(owner: ControlFlowGraph, override val fir: FirScript, level: Int, id: Int) : CFGNode(owner, level, id), GraphExitNodeMarker { +class ScriptExitNode(owner: ControlFlowGraph, override val fir: FirScript, level: Int) : CFGNode(owner, level), GraphExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitScriptExitNode(this, data) } @@ -277,14 +280,14 @@ class ScriptExitNode(owner: ControlFlowGraph, override val fir: FirScript, level // ----------------------------------- Property ----------------------------------- -class PropertyInitializerEnterNode(owner: ControlFlowGraph, override val fir: FirProperty, level: Int, id: Int) : CFGNode(owner, level, id), +class PropertyInitializerEnterNode(owner: ControlFlowGraph, override val fir: FirProperty, level: Int) : CFGNode(owner, level), GraphEnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitPropertyInitializerEnterNode(this, data) } } -class PropertyInitializerExitNode(owner: ControlFlowGraph, override val fir: FirProperty, level: Int, id: Int) : CFGNode(owner, level, id), +class PropertyInitializerExitNode(owner: ControlFlowGraph, override val fir: FirProperty, level: Int) : CFGNode(owner, level), GraphExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitPropertyInitializerExitNode(this, data) @@ -292,8 +295,8 @@ class PropertyInitializerExitNode(owner: ControlFlowGraph, override val fir: Fir } -class DelegateExpressionExitNode(owner: ControlFlowGraph, override val fir: FirExpression, level: Int, id: Int) - : CFGNode(owner, level, id), UnionNodeMarker { +class DelegateExpressionExitNode(owner: ControlFlowGraph, override val fir: FirExpression, level: Int) + : CFGNode(owner, level), UnionNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitDelegateExpressionExitNode(this, data) } @@ -301,14 +304,14 @@ class DelegateExpressionExitNode(owner: ControlFlowGraph, override val fir: FirE // ----------------------------------- Field ----------------------------------- -class FieldInitializerEnterNode(owner: ControlFlowGraph, override val fir: FirField, level: Int, id: Int) : CFGNode(owner, level, id), +class FieldInitializerEnterNode(owner: ControlFlowGraph, override val fir: FirField, level: Int) : CFGNode(owner, level), GraphEnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFieldInitializerEnterNode(this, data) } } -class FieldInitializerExitNode(owner: ControlFlowGraph, override val fir: FirField, level: Int, id: Int) : CFGNode(owner, level, id), +class FieldInitializerExitNode(owner: ControlFlowGraph, override val fir: FirField, level: Int) : CFGNode(owner, level), GraphExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFieldInitializerExitNode(this, data) @@ -317,14 +320,14 @@ class FieldInitializerExitNode(owner: ControlFlowGraph, override val fir: FirFie // ----------------------------------- Init ----------------------------------- -class InitBlockEnterNode(owner: ControlFlowGraph, override val fir: FirAnonymousInitializer, level: Int, id: Int) : CFGNode(owner, level, id), +class InitBlockEnterNode(owner: ControlFlowGraph, override val fir: FirAnonymousInitializer, level: Int) : CFGNode(owner, level), GraphEnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitInitBlockEnterNode(this, data) } } -class InitBlockExitNode(owner: ControlFlowGraph, override val fir: FirAnonymousInitializer, level: Int, id: Int) : CFGNode(owner, level, id), +class InitBlockExitNode(owner: ControlFlowGraph, override val fir: FirAnonymousInitializer, level: Int) : CFGNode(owner, level), GraphExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitInitBlockExitNode(this, data) @@ -333,13 +336,13 @@ class InitBlockExitNode(owner: ControlFlowGraph, override val fir: FirAnonymousI // ----------------------------------- Block ----------------------------------- -class BlockEnterNode(owner: ControlFlowGraph, override val fir: FirBlock, level: Int, id: Int) : CFGNode(owner, level, id), +class BlockEnterNode(owner: ControlFlowGraph, override val fir: FirBlock, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBlockEnterNode(this, data) } } -class BlockExitNode(owner: ControlFlowGraph, override val fir: FirBlock, level: Int, id: Int) : CFGNode(owner, level, id), +class BlockExitNode(owner: ControlFlowGraph, override val fir: FirBlock, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBlockExitNode(this, data) @@ -348,41 +351,41 @@ class BlockExitNode(owner: ControlFlowGraph, override val fir: FirBlock, level: // ----------------------------------- When ----------------------------------- -class WhenEnterNode(owner: ControlFlowGraph, override val fir: FirWhenExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class WhenEnterNode(owner: ControlFlowGraph, override val fir: FirWhenExpression, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitWhenEnterNode(this, data) } } -class WhenExitNode(owner: ControlFlowGraph, override val fir: FirWhenExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class WhenExitNode(owner: ControlFlowGraph, override val fir: FirWhenExpression, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitWhenExitNode(this, data) } } -class WhenBranchConditionEnterNode(owner: ControlFlowGraph, override val fir: FirWhenBranch, level: Int, id: Int) : CFGNode(owner, level, id), +class WhenBranchConditionEnterNode(owner: ControlFlowGraph, override val fir: FirWhenBranch, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitWhenBranchConditionEnterNode(this, data) } } -class WhenBranchConditionExitNode(owner: ControlFlowGraph, override val fir: FirWhenBranch, level: Int, id: Int) : CFGNode(owner, level, id), +class WhenBranchConditionExitNode(owner: ControlFlowGraph, override val fir: FirWhenBranch, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitWhenBranchConditionExitNode(this, data) } } -class WhenBranchResultEnterNode(owner: ControlFlowGraph, override val fir: FirWhenBranch, level: Int, id: Int) : CFGNode(owner, level, id) { +class WhenBranchResultEnterNode(owner: ControlFlowGraph, override val fir: FirWhenBranch, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitWhenBranchResultEnterNode(this, data) } } -class WhenBranchResultExitNode(owner: ControlFlowGraph, override val fir: FirWhenBranch, level: Int, id: Int) : CFGNode(owner, level, id) { +class WhenBranchResultExitNode(owner: ControlFlowGraph, override val fir: FirWhenBranch, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitWhenBranchResultExitNode(this, data) } } -class WhenSyntheticElseBranchNode(owner: ControlFlowGraph, override val fir: FirWhenExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class WhenSyntheticElseBranchNode(owner: ControlFlowGraph, override val fir: FirWhenExpression, level: Int) : CFGNode(owner, level) { init { assert(!fir.isProperlyExhaustive) } @@ -394,37 +397,37 @@ class WhenSyntheticElseBranchNode(owner: ControlFlowGraph, override val fir: Fir // ----------------------------------- Loop ----------------------------------- -class LoopEnterNode(owner: ControlFlowGraph, override val fir: FirLoop, level: Int, id: Int) : CFGNode(owner, level, id), +class LoopEnterNode(owner: ControlFlowGraph, override val fir: FirLoop, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitLoopEnterNode(this, data) } } -class LoopBlockEnterNode(owner: ControlFlowGraph, override val fir: FirLoop, level: Int, id: Int) : CFGNode(owner, level, id), +class LoopBlockEnterNode(owner: ControlFlowGraph, override val fir: FirLoop, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitLoopBlockEnterNode(this, data) } } -class LoopBlockExitNode(owner: ControlFlowGraph, override val fir: FirLoop, level: Int, id: Int) : CFGNode(owner, level, id), +class LoopBlockExitNode(owner: ControlFlowGraph, override val fir: FirLoop, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitLoopBlockExitNode(this, data) } } -class LoopConditionEnterNode(owner: ControlFlowGraph, override val fir: FirExpression, val loop: FirLoop, level: Int, id: Int) : CFGNode(owner, level, id), +class LoopConditionEnterNode(owner: ControlFlowGraph, override val fir: FirExpression, val loop: FirLoop, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitLoopConditionEnterNode(this, data) } } -class LoopConditionExitNode(owner: ControlFlowGraph, override val fir: FirExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class LoopConditionExitNode(owner: ControlFlowGraph, override val fir: FirExpression, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitLoopConditionExitNode(this, data) } } -class LoopExitNode(owner: ControlFlowGraph, override val fir: FirLoop, level: Int, id: Int) : CFGNode(owner, level, id), +class LoopExitNode(owner: ControlFlowGraph, override val fir: FirLoop, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitLoopExitNode(this, data) @@ -433,61 +436,61 @@ class LoopExitNode(owner: ControlFlowGraph, override val fir: FirLoop, level: In // ----------------------------------- Try-catch-finally ----------------------------------- -class TryExpressionEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class TryExpressionEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitTryExpressionEnterNode(this, data) } } -class TryMainBlockEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class TryMainBlockEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitTryMainBlockEnterNode(this, data) } } -class TryMainBlockExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class TryMainBlockExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitTryMainBlockExitNode(this, data) } } -class CatchClauseEnterNode(owner: ControlFlowGraph, override val fir: FirCatch, level: Int, id: Int) : CFGNode(owner, level, id), +class CatchClauseEnterNode(owner: ControlFlowGraph, override val fir: FirCatch, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitCatchClauseEnterNode(this, data) } } -class CatchClauseExitNode(owner: ControlFlowGraph, override val fir: FirCatch, level: Int, id: Int) : CFGNode(owner, level, id), +class CatchClauseExitNode(owner: ControlFlowGraph, override val fir: FirCatch, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitCatchClauseExitNode(this, data) } } -class FinallyBlockEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class FinallyBlockEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFinallyBlockEnterNode(this, data) } } -class FinallyBlockExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class FinallyBlockExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFinallyBlockExitNode(this, data) } } -class FinallyProxyEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class FinallyProxyEnterNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFinallyProxyEnterNode(this, data) } } -class FinallyProxyExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class FinallyProxyExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFinallyProxyExitNode(this, data) } } -class TryExpressionExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class TryExpressionExitNode(owner: ControlFlowGraph, override val fir: FirTryExpression, level: Int) : CFGNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitTryExpressionExitNode(this, data) @@ -496,51 +499,51 @@ class TryExpressionExitNode(owner: ControlFlowGraph, override val fir: FirTryExp // ----------------------------------- Boolean operators ----------------------------------- -abstract class AbstractBinaryExitNode(owner: ControlFlowGraph, level: Int, id: Int) : CFGNode(owner, level, id) { +abstract class AbstractBinaryExitNode(owner: ControlFlowGraph, level: Int) : CFGNode(owner, level) { val leftOperandNode: CFGNode<*> get() = previousNodes[0] val rightOperandNode: CFGNode<*> get() = previousNodes[1] } -class BinaryAndEnterNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class BinaryAndEnterNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBinaryAndEnterNode(this, data) } } -class BinaryAndExitLeftOperandNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class BinaryAndExitLeftOperandNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBinaryAndExitLeftOperandNode(this, data) } } -class BinaryAndEnterRightOperandNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class BinaryAndEnterRightOperandNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBinaryAndEnterRightOperandNode(this, data) } } -class BinaryAndExitNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int, id: Int) : AbstractBinaryExitNode(owner, level, id), +class BinaryAndExitNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int) : AbstractBinaryExitNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBinaryAndExitNode(this, data) } } -class BinaryOrEnterNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int, id: Int) : CFGNode(owner, level, id), +class BinaryOrEnterNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int) : CFGNode(owner, level), EnterNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBinaryOrEnterNode(this, data) } } -class BinaryOrExitLeftOperandNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class BinaryOrExitLeftOperandNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBinaryOrExitLeftOperandNode(this, data) } } -class BinaryOrEnterRightOperandNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class BinaryOrEnterRightOperandNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBinaryOrEnterRightOperandNode(this, data) } } -class BinaryOrExitNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int, id: Int) : AbstractBinaryExitNode(owner, level, id), +class BinaryOrExitNode(owner: ControlFlowGraph, override val fir: FirBinaryLogicExpression, level: Int) : AbstractBinaryExitNode(owner, level), ExitNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitBinaryOrExitNode(this, data) @@ -549,19 +552,19 @@ class BinaryOrExitNode(owner: ControlFlowGraph, override val fir: FirBinaryLogic // ----------------------------------- Operator call ----------------------------------- -class TypeOperatorCallNode(owner: ControlFlowGraph, override val fir: FirTypeOperatorCall, level: Int, id: Int) : CFGNode(owner, level, id) { +class TypeOperatorCallNode(owner: ControlFlowGraph, override val fir: FirTypeOperatorCall, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitTypeOperatorCallNode(this, data) } } -class ComparisonExpressionNode(owner: ControlFlowGraph, override val fir: FirComparisonExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class ComparisonExpressionNode(owner: ControlFlowGraph, override val fir: FirComparisonExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitComparisonExpressionNode(this, data) } } -class EqualityOperatorCallNode(owner: ControlFlowGraph, override val fir: FirEqualityOperatorCall, level: Int, id: Int) : AbstractBinaryExitNode(owner, level, id) { +class EqualityOperatorCallNode(owner: ControlFlowGraph, override val fir: FirEqualityOperatorCall, level: Int) : AbstractBinaryExitNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitEqualityOperatorCallNode(this, data) } @@ -569,12 +572,12 @@ class EqualityOperatorCallNode(owner: ControlFlowGraph, override val fir: FirEqu // ----------------------------------- Jump ----------------------------------- -class JumpNode(owner: ControlFlowGraph, override val fir: FirJump<*>, level: Int, id: Int) : CFGNode>(owner, level, id) { +class JumpNode(owner: ControlFlowGraph, override val fir: FirJump<*>, level: Int) : CFGNode>(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitJumpNode(this, data) } } -class ConstExpressionNode(owner: ControlFlowGraph, override val fir: FirConstExpression<*>, level: Int, id: Int) : CFGNode>(owner, level, id) { +class ConstExpressionNode(owner: ControlFlowGraph, override val fir: FirConstExpression<*>, level: Int) : CFGNode>(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitConstExpressionNode(this, data) } @@ -582,8 +585,8 @@ class ConstExpressionNode(owner: ControlFlowGraph, override val fir: FirConstExp // ----------------------------------- Check not null call ----------------------------------- -class CheckNotNullCallNode(owner: ControlFlowGraph, override val fir: FirCheckNotNullCall, level: Int, id: Int) - : CFGNode(owner, level, id), UnionNodeMarker { +class CheckNotNullCallNode(owner: ControlFlowGraph, override val fir: FirCheckNotNullCall, level: Int) + : CFGNode(owner, level), UnionNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitCheckNotNullCallNode(this, data) } @@ -594,8 +597,8 @@ class CheckNotNullCallNode(owner: ControlFlowGraph, override val fir: FirCheckNo class QualifiedAccessNode( owner: ControlFlowGraph, override val fir: FirQualifiedAccessExpression, - level: Int, id: Int -) : CFGNode(owner, level, id) { + level: Int +) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitQualifiedAccessNode(this, data) } @@ -604,15 +607,15 @@ class QualifiedAccessNode( class ResolvedQualifierNode( owner: ControlFlowGraph, override val fir: FirResolvedQualifier, - level: Int, id: Int -) : CFGNode(owner, level, id) { + level: Int +) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitResolvedQualifierNode(this, data) } } -class FunctionCallNode(owner: ControlFlowGraph, override val fir: FirFunctionCall, level: Int, id: Int) - : CFGNode(owner, level, id), UnionNodeMarker { +class FunctionCallNode(owner: ControlFlowGraph, override val fir: FirFunctionCall, level: Int) + : CFGNode(owner, level), UnionNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitFunctionCallNode(this, data) } @@ -621,28 +624,28 @@ class FunctionCallNode(owner: ControlFlowGraph, override val fir: FirFunctionCal class CallableReferenceNode( owner: ControlFlowGraph, override val fir: FirCallableReferenceAccess, - level: Int, id: Int -) : CFGNode(owner, level, id) { + level: Int +) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitCallableReferenceNode(this, data) } } -class GetClassCallNode(owner: ControlFlowGraph, override val fir: FirGetClassCall, level: Int, id: Int) : CFGNode(owner, level, id) { +class GetClassCallNode(owner: ControlFlowGraph, override val fir: FirGetClassCall, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitGetClassCallNode(this, data) } } -class DelegatedConstructorCallNode(owner: ControlFlowGraph, override val fir: FirDelegatedConstructorCall, level: Int, id: Int) - : CFGNode(owner, level, id), UnionNodeMarker { +class DelegatedConstructorCallNode(owner: ControlFlowGraph, override val fir: FirDelegatedConstructorCall, level: Int) + : CFGNode(owner, level), UnionNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitDelegatedConstructorCallNode(this, data) } } -class StringConcatenationCallNode(owner: ControlFlowGraph, override val fir: FirStringConcatenationCall, level: Int, id: Int) - : CFGNode(owner, level, id), UnionNodeMarker { +class StringConcatenationCallNode(owner: ControlFlowGraph, override val fir: FirStringConcatenationCall, level: Int) + : CFGNode(owner, level), UnionNodeMarker { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitStringConcatenationCallNode(this, data) } @@ -651,14 +654,14 @@ class StringConcatenationCallNode(owner: ControlFlowGraph, override val fir: Fir class ThrowExceptionNode( owner: ControlFlowGraph, override val fir: FirThrowExpression, - level: Int, id: Int -) : CFGNode(owner, level, id) { + level: Int +) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitThrowExceptionNode(this, data) } } -class StubNode(owner: ControlFlowGraph, level: Int, id: Int) : CFGNode(owner, level, id) { +class StubNode(owner: ControlFlowGraph, level: Int) : CFGNode(owner, level) { init { isDead = true } @@ -675,23 +678,23 @@ class StubNode(owner: ControlFlowGraph, level: Int, id: Int) : CFGNode( } } -class VariableDeclarationNode(owner: ControlFlowGraph, override val fir: FirProperty, level: Int, id: Int) : CFGNode(owner, level, id) { +class VariableDeclarationNode(owner: ControlFlowGraph, override val fir: FirProperty, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitVariableDeclarationNode(this, data) } } -class VariableAssignmentNode(owner: ControlFlowGraph, override val fir: FirVariableAssignment, level: Int, id: Int) : CFGNode(owner, level, id) { +class VariableAssignmentNode(owner: ControlFlowGraph, override val fir: FirVariableAssignment, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitVariableAssignmentNode(this, data) } } -class EnterSafeCallNode(owner: ControlFlowGraph, override val fir: FirSafeCallExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class EnterSafeCallNode(owner: ControlFlowGraph, override val fir: FirSafeCallExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitEnterSafeCallNode(this, data) } } -class ExitSafeCallNode(owner: ControlFlowGraph, override val fir: FirSafeCallExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class ExitSafeCallNode(owner: ControlFlowGraph, override val fir: FirSafeCallExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitExitSafeCallNode(this, data) } @@ -699,31 +702,31 @@ class ExitSafeCallNode(owner: ControlFlowGraph, override val fir: FirSafeCallExp // ----------------------------------- Elvis ----------------------------------- -class ElvisLhsExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class ElvisLhsExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitElvisLhsExitNode(this, data) } } -class ElvisLhsIsNotNullNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class ElvisLhsIsNotNullNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitElvisLhsIsNotNullNode(this, data) } } -class ElvisRhsEnterNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class ElvisRhsEnterNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitElvisRhsEnterNode(this, data) } } -class ElvisExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int, id: Int) : AbstractBinaryExitNode(owner, level, id) { +class ElvisExitNode(owner: ControlFlowGraph, override val fir: FirElvisExpression, level: Int) : AbstractBinaryExitNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitElvisExitNode(this, data) } } -class WhenSubjectExpressionExitNode(owner: ControlFlowGraph, override val fir: FirWhenSubjectExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class WhenSubjectExpressionExitNode(owner: ControlFlowGraph, override val fir: FirWhenSubjectExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitWhenSubjectExpressionExitNode(this, data) } @@ -743,7 +746,7 @@ object FirStub : FirExpression() { override fun replaceTypeRef(newTypeRef: FirTypeRef) { assert(newTypeRef.isNothing) } } -class FakeExpressionEnterNode(owner: ControlFlowGraph, level: Int, id: Int) : CFGNode(owner, level, id) { +class FakeExpressionEnterNode(owner: ControlFlowGraph, level: Int) : CFGNode(owner, level) { init { isDead = true } override val fir: FirStub = FirStub @@ -755,7 +758,7 @@ class FakeExpressionEnterNode(owner: ControlFlowGraph, level: Int, id: Int) : CF // ----------------------------------- Smart-cast node ----------------------------------- -class SmartCastExpressionExitNode(owner: ControlFlowGraph, override val fir: FirSmartCastExpression, level: Int, id: Int) : CFGNode(owner, level, id) { +class SmartCastExpressionExitNode(owner: ControlFlowGraph, override val fir: FirSmartCastExpression, level: Int) : CFGNode(owner, level) { override fun accept(visitor: ControlFlowGraphVisitor, data: D): R { return visitor.visitSmartCastExpressionExitNode(this, data) }