From 0e8c43f8c0ec6e3fbaefebf746e02442cfbbb7cd Mon Sep 17 00:00:00 2001 From: Dmitriy Novozhilov Date: Mon, 24 Sep 2018 14:39:27 +0300 Subject: [PATCH] Generify key type parameter of `ControlFlowInfo` Previously only `VariableDescriptor` was key of `ControlFlowInfo`. Now it's generic parameter `K: Any`, so there is a possibility of using different object's inside CFA --- .../jetbrains/kotlin/cfg/ControlFlowInfo.kt | 25 +++++------ .../cfg/ControlFlowInformationProvider.kt | 20 ++++----- .../kotlin/cfg/PseudocodeTraverser.kt | 6 +-- .../PseudocodeVariableDataCollector.kt | 5 +-- .../cfg/variable/PseudocodeVariablesData.kt | 44 +++++++++---------- .../cfg/variable/VariableControlFlowInfo.kt | 33 +++++++++----- .../kotlin/cfg/AbstractDataFlowTest.java | 20 ++++----- 7 files changed, 79 insertions(+), 74 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInfo.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInfo.kt index 988d0023184..99e4ea4b9b3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInfo.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInfo.kt @@ -16,41 +16,40 @@ package org.jetbrains.kotlin.cfg -import org.jetbrains.kotlin.descriptors.VariableDescriptor import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap import org.jetbrains.kotlin.util.javaslang.ImmutableMap -interface ReadOnlyControlFlowInfo { - fun getOrNull(variableDescriptor: VariableDescriptor): D? +interface ReadOnlyControlFlowInfo { + fun getOrNull(key: K): D? // Only used in tests - fun asMap(): ImmutableMap + fun asMap(): ImmutableMap } -abstract class ControlFlowInfo, D : Any> +abstract class ControlFlowInfo, K : Any, D : Any> internal constructor( - protected val map: ImmutableMap = ImmutableHashMap.empty() -) : ImmutableMap by map, ReadOnlyControlFlowInfo { - protected abstract fun copy(newMap: ImmutableMap): S + protected val map: ImmutableMap = ImmutableHashMap.empty() +) : ImmutableMap by map, ReadOnlyControlFlowInfo { + protected abstract fun copy(newMap: ImmutableMap): S - override fun put(key: VariableDescriptor, value: D): S = put(key, value, this[key].getOrElse(null as D?)) + override fun put(key: K, value: D): S = put(key, value, this[key].getOrElse(null as D?)) /** * This overload exists just for sake of optimizations: in some cases we've just retrieved the old value, * so we don't need to scan through the persistent hashmap again */ - fun put(key: VariableDescriptor, value: D, oldValue: D?): S { + fun put(key: K, value: D, oldValue: D?): S { @Suppress("UNCHECKED_CAST") // Avoid a copy instance creation if new value is the same if (value == oldValue) return this as S return copy(map.put(key, value)) } - override fun getOrNull(variableDescriptor: VariableDescriptor): D? = this[variableDescriptor].getOrElse(null as D?) + override fun getOrNull(key: K): D? = this[key].getOrElse(null as D?) override fun asMap() = this - fun retainAll(predicate: (VariableDescriptor) -> Boolean): S = copy(map.removeAll(map.keySet().filterNot(predicate))) + fun retainAll(predicate: (K) -> Boolean): S = copy(map.removeAll(map.keySet().filterNot(predicate))) - override fun equals(other: Any?) = map == (other as? ControlFlowInfo<*, *>)?.map + override fun equals(other: Any?) = map == (other as? ControlFlowInfo<*, *, *>)?.map override fun hashCode() = map.hashCode() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt index a4ca6d79271..5f0aef8951f 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.kt @@ -1,5 +1,5 @@ /* - * Copyright 2000-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license + * Copyright 2010-2018 JetBrains s.r.o. Use of this source code is governed by the Apache 2.0 license * that can be found in the license/LICENSE.txt file. */ @@ -10,7 +10,6 @@ import org.jetbrains.kotlin.builtins.KotlinBuiltIns import org.jetbrains.kotlin.cfg.TailRecursionKind.* import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeUtil -import org.jetbrains.kotlin.cfg.pseudocode.containingDeclarationForPseudocode import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction import org.jetbrains.kotlin.cfg.pseudocode.instructions.InstructionVisitor import org.jetbrains.kotlin.cfg.pseudocode.instructions.KtElementInstruction @@ -32,7 +31,6 @@ import org.jetbrains.kotlin.diagnostics.Errors.* import org.jetbrains.kotlin.idea.MainFunctionDetector import org.jetbrains.kotlin.lexer.KtTokens import org.jetbrains.kotlin.psi.* -import org.jetbrains.kotlin.psi.psiUtil.getStrictParentOfType import org.jetbrains.kotlin.resolve.* import org.jetbrains.kotlin.resolve.BindingContext.* import org.jetbrains.kotlin.resolve.bindingContextUtil.isUsedAsExpression @@ -326,8 +324,8 @@ class ControlFlowInformationProvider private constructor( val reportedDiagnosticMap = hashMapOf>() pseudocode.traverse(TraversalOrder.FORWARD, initializers) { instruction: Instruction, - enterData: ReadOnlyInitControlFlowInfo, - exitData: ReadOnlyInitControlFlowInfo -> + enterData: VariableInitReadOnlyControlFlowInfo, + exitData: VariableInitReadOnlyControlFlowInfo -> val ctxt = VariableInitContext(instruction, reportedDiagnosticMap, enterData, exitData, blockScopeVariableInfo) if (ctxt.variableDescriptor == null) return@traverse @@ -603,7 +601,7 @@ class ControlFlowInformationProvider private constructor( private fun recordInitializedVariables( pseudocode: Pseudocode, - initializersMap: Map> + initializersMap: Map> ) { val initializers = initializersMap[pseudocode.exitInstruction] ?: return val declaredVariables = pseudocodeVariablesData.getDeclaredVariables(pseudocode, false) @@ -624,8 +622,8 @@ class ControlFlowInformationProvider private constructor( val unusedValueExpressions = hashMapOf>() val usedValueExpressions = hashSetOf() pseudocode.traverse(TraversalOrder.BACKWARD, variableStatusData) { instruction: Instruction, - enterData: ReadOnlyUseControlFlowInfo, - _: ReadOnlyUseControlFlowInfo -> + enterData: VariableUsageReadOnlyControlInfo, + _: VariableUsageReadOnlyControlInfo -> val ctxt = VariableUseContext(instruction, reportedDiagnosticMap) val declaredVariables = pseudocodeVariablesData.getDeclaredVariables(instruction.owner, false) @@ -1071,8 +1069,8 @@ class ControlFlowInformationProvider private constructor( private inner class VariableInitContext( instruction: Instruction, map: MutableMap>, - `in`: ReadOnlyInitControlFlowInfo, - out: ReadOnlyInitControlFlowInfo, + `in`: VariableInitReadOnlyControlFlowInfo, + out: VariableInitReadOnlyControlFlowInfo, blockScopeVariableInfo: BlockScopeVariableInfo ) : VariableContext(instruction, map) { internal val enterInitState = initialize(variableDescriptor, blockScopeVariableInfo, `in`) @@ -1081,7 +1079,7 @@ class ControlFlowInformationProvider private constructor( private fun initialize( variableDescriptor: VariableDescriptor?, blockScopeVariableInfo: BlockScopeVariableInfo, - map: ReadOnlyInitControlFlowInfo + map: VariableInitReadOnlyControlFlowInfo ): VariableControlFlowState? { val state = map.getOrNull(variableDescriptor ?: return null) if (state != null) return state diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeTraverser.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeTraverser.kt index 536656a2ecc..1fb527543c3 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeTraverser.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeTraverser.kt @@ -56,7 +56,7 @@ fun Pseudocode.traverse( } } -fun > Pseudocode.collectData( +fun > Pseudocode.collectData( traversalOrder: TraversalOrder, mergeEdges: (Instruction, Collection) -> Edges, updateEdge: (Instruction, Instruction, I) -> I, @@ -76,7 +76,7 @@ fun > Pseudocode.collectData( return edgesMap } -private fun > Pseudocode.collectDataFromSubgraph( +private fun > Pseudocode.collectDataFromSubgraph( traversalOrder: TraversalOrder, edgesMap: MutableMap>, mergeEdges: (Instruction, Collection) -> Edges, @@ -154,7 +154,7 @@ private fun getPreviousIncludingSubGraphInstructions( return result } -private fun > updateEdgeDataForInstruction( +private fun > updateEdgeDataForInstruction( instruction: Instruction, previousValue: Edges?, newValue: Edges?, diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/PseudocodeVariableDataCollector.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/PseudocodeVariableDataCollector.kt index 19d9b4060a0..c976ade77a0 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/PseudocodeVariableDataCollector.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/PseudocodeVariableDataCollector.kt @@ -5,7 +5,6 @@ package org.jetbrains.kotlin.cfg.variable -import org.jetbrains.kotlin.cfg.ControlFlowInfo import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode import org.jetbrains.kotlin.cfg.pseudocode.instructions.BlockScope import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction @@ -24,7 +23,7 @@ class PseudocodeVariableDataCollector( ) { val blockScopeVariableInfo = computeBlockScopeVariableInfo(pseudocode) - fun > collectData( + fun > collectData( traversalOrder: TraversalOrder, initialInfo: I, instructionDataMergeStrategy: (Instruction, Collection) -> Edges @@ -37,7 +36,7 @@ class PseudocodeVariableDataCollector( ) } - private fun > filterOutVariablesOutOfScope( + private fun > filterOutVariablesOutOfScope( from: Instruction, to: Instruction, info: I diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/PseudocodeVariablesData.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/PseudocodeVariablesData.kt index e4cd00f113c..6ad04f0ce04 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/PseudocodeVariablesData.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/PseudocodeVariablesData.kt @@ -45,7 +45,7 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon getAllDeclaredVariables(pseudocode, includeInsideLocalDeclarations = true) } - val variableInitializers: Map> by lazy { + val variableInitializers: Map> by lazy { computeVariableInitializers() } @@ -133,7 +133,7 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon // variable initializers - private fun computeVariableInitializers(): Map> { + private fun computeVariableInitializers(): Map> { val blockScopeVariableInfo = pseudocodeVariableDataCollector.blockScopeVariableInfo @@ -143,8 +143,8 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon return pseudocodeVariableDataCollector.collectData( TraversalOrder.FORWARD, - InitVariableControlFlowInfo() - ) { instruction: Instruction, incomingEdgesData: Collection -> + VariableInitControlFlowInfo() + ) { instruction: Instruction, incomingEdgesData: Collection -> val enterInstructionData = mergeIncomingEdgesDataForInitializers( @@ -197,8 +197,8 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon private inner class ReadOnlyInitVariableControlFlowInfoImpl( val declaredSet: ImmutableSet, val initSet: ImmutableSet, - private val delegate: ReadOnlyInitVariableControlFlowInfo? - ) : ReadOnlyInitVariableControlFlowInfo { + private val delegate: VariableInitReadOnlyControlFlowInfo? + ) : VariableInitReadOnlyControlFlowInfo { override fun getOrNull(key: VariableDescriptor): VariableControlFlowState? { if (key in declaredSet) { return VariableControlFlowState.create(isInitialized = key in initSet, isDeclared = true) @@ -206,10 +206,10 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon return delegate?.getOrNull(key) } - override fun checkDefiniteInitializationInWhen(merge: ReadOnlyInitVariableControlFlowInfo): Boolean = + override fun checkDefiniteInitializationInWhen(merge: VariableInitReadOnlyControlFlowInfo): Boolean = delegate?.checkDefiniteInitializationInWhen(merge) ?: false - fun replaceDelegate(newDelegate: ReadOnlyInitVariableControlFlowInfo): ReadOnlyInitVariableControlFlowInfo = + fun replaceDelegate(newDelegate: VariableInitReadOnlyControlFlowInfo): VariableInitReadOnlyControlFlowInfo = ReadOnlyInitVariableControlFlowInfoImpl(declaredSet, initSet, newDelegate) override fun asMap(): ImmutableMap { @@ -243,9 +243,9 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon private fun addVariableInitStateFromCurrentInstructionIfAny( instruction: Instruction, - enterInstructionData: InitVariableControlFlowInfo, + enterInstructionData: VariableInitControlFlowInfo, blockScopeVariableInfo: BlockScopeVariableInfo - ): InitVariableControlFlowInfo { + ): VariableInitControlFlowInfo { if (instruction is MagicInstruction) { if (instruction.kind === MagicKind.EXHAUSTIVE_WHEN_ELSE) { return enterInstructionData.iterator().fold(enterInstructionData) { result, (key, value) -> @@ -297,11 +297,11 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon // variable use - val variableUseStatusData: Map> + val variableUseStatusData: Map> get() { val edgesForTrivialVals = computeUseInfoForTrivialVals() if (rootVariables.nonTrivialVariables.isEmpty()) { - return hashMapOf>().apply { + return hashMapOf>().apply { pseudocode.traverse(TraversalOrder.FORWARD) { instruction -> put(instruction, edgesForTrivialVals) } @@ -310,13 +310,13 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon return pseudocodeVariableDataCollector.collectData( TraversalOrder.BACKWARD, - UseVariableControlFlowInfo() - ) { instruction: Instruction, incomingEdgesData: Collection -> + UsageVariableControlFlowInfo() + ) { instruction: Instruction, incomingEdgesData: Collection -> - val enterResult: UseVariableControlFlowInfo = if (incomingEdgesData.size == 1) { + val enterResult: UsageVariableControlFlowInfo = if (incomingEdgesData.size == 1) { incomingEdgesData.single() } else { - incomingEdgesData.fold(UseVariableControlFlowInfo()) { result, edgeData -> + incomingEdgesData.fold(UsageVariableControlFlowInfo()) { result, edgeData -> edgeData.iterator().fold(result) { subResult, (variableDescriptor, variableUseState) -> subResult.put(variableDescriptor, variableUseState.merge(subResult.getOrNull(variableDescriptor))) } @@ -377,14 +377,14 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon private inner class ReadOnlyUseControlFlowInfoImpl( val used: Set, - val delegate: ReadOnlyUseVariableControlFlowInfo? - ) : ReadOnlyUseVariableControlFlowInfo { + val delegate: VariableUsageReadOnlyControlInfo? + ) : VariableUsageReadOnlyControlInfo { override fun getOrNull(key: VariableDescriptor): VariableUseState? { if (key in used) return VariableUseState.READ return delegate?.getOrNull(key) } - fun replaceDelegate(newDelegate: ReadOnlyUseVariableControlFlowInfo): ReadOnlyUseVariableControlFlowInfo = + fun replaceDelegate(newDelegate: VariableUsageReadOnlyControlInfo): VariableUsageReadOnlyControlInfo = ReadOnlyUseControlFlowInfoImpl(used, newDelegate) override fun asMap(): ImmutableMap { @@ -431,13 +431,13 @@ class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingCon return VariableControlFlowState.create(isInitialized = declaredOutsideThisDeclaration) } - private val EMPTY_INIT_CONTROL_FLOW_INFO = InitVariableControlFlowInfo() + private val EMPTY_INIT_CONTROL_FLOW_INFO = VariableInitControlFlowInfo() private fun mergeIncomingEdgesDataForInitializers( instruction: Instruction, - incomingEdgesData: Collection, + incomingEdgesData: Collection, blockScopeVariableInfo: BlockScopeVariableInfo - ): InitVariableControlFlowInfo { + ): VariableInitControlFlowInfo { if (incomingEdgesData.size == 1) return incomingEdgesData.single() if (incomingEdgesData.isEmpty()) return EMPTY_INIT_CONTROL_FLOW_INFO val variablesInScope = linkedSetOf() diff --git a/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/VariableControlFlowInfo.kt b/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/VariableControlFlowInfo.kt index c329c9f3d79..c078ce7949e 100644 --- a/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/VariableControlFlowInfo.kt +++ b/compiler/frontend/src/org/jetbrains/kotlin/cfg/variable/VariableControlFlowInfo.kt @@ -8,26 +8,33 @@ package org.jetbrains.kotlin.cfg.variable import org.jetbrains.kotlin.cfg.ControlFlowInfo import org.jetbrains.kotlin.cfg.ReadOnlyControlFlowInfo import org.jetbrains.kotlin.descriptors.VariableDescriptor +import org.jetbrains.kotlin.util.javaslang.ImmutableHashMap +import org.jetbrains.kotlin.util.javaslang.ImmutableMap import org.jetbrains.kotlin.util.javaslang.component1 import org.jetbrains.kotlin.util.javaslang.component2 -interface ReadOnlyInitControlFlowInfo : ReadOnlyControlFlowInfo { - fun checkDefiniteInitializationInWhen(merge: ReadOnlyInitControlFlowInfo): Boolean +typealias VariableUsageReadOnlyControlInfo = ReadOnlyControlFlowInfo +typealias VariableUsageControlFlowInfo = ControlFlowInfo + +interface VariableInitReadOnlyControlFlowInfo : + ReadOnlyControlFlowInfo { + fun checkDefiniteInitializationInWhen(merge: VariableInitReadOnlyControlFlowInfo): Boolean } -typealias ReadOnlyUseControlFlowInfo = ReadOnlyControlFlowInfo - -class InitControlFlowInfo(map: ImmutableMap = ImmutableHashMap.empty()) : - ControlFlowInfo(map), ReadOnlyInitControlFlowInfo { - override fun copy(newMap: ImmutableMap) = InitControlFlowInfo(newMap) +class VariableInitControlFlowInfo(map: ImmutableMap = ImmutableHashMap.empty()) : + VariableUsageControlFlowInfo(map), + VariableInitReadOnlyControlFlowInfo { + override fun copy(newMap: ImmutableMap) = + VariableInitControlFlowInfo(newMap) // this = output of EXHAUSTIVE_WHEN_ELSE instruction // merge = input of MergeInstruction // returns true if definite initialization in when happens here - override fun checkDefiniteInitializationInWhen(merge: ReadOnlyInitControlFlowInfo): Boolean { + override fun checkDefiniteInitializationInWhen(merge: VariableInitReadOnlyControlFlowInfo): Boolean { for ((key, value) in iterator()) { if (value.initState == InitState.INITIALIZED_EXHAUSTIVELY && - merge.getOrNull(key)?.initState == InitState.INITIALIZED) { + merge.getOrNull(key)?.initState == InitState.INITIALIZED + ) { return true } } @@ -35,9 +42,11 @@ class InitControlFlowInfo(map: ImmutableMap = ImmutableHashMap.empty()) : - ControlFlowInfo(map), ReadOnlyUseControlFlowInfo { - override fun copy(newMap: ImmutableMap) = UseControlFlowInfo(newMap) +class UsageVariableControlFlowInfo(map: ImmutableMap = ImmutableHashMap.empty()) : + VariableUsageControlFlowInfo(map), + VariableUsageReadOnlyControlInfo { + override fun copy(newMap: ImmutableMap) = + UsageVariableControlFlowInfo(newMap) } enum class InitState(private val s: String) { diff --git a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java index bfc5a430e88..265d8cf780b 100644 --- a/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java +++ b/compiler/tests-common/tests/org/jetbrains/kotlin/cfg/AbstractDataFlowTest.java @@ -24,7 +24,7 @@ import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeImpl; import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction; import org.jetbrains.kotlin.cfg.pseudocodeTraverser.Edges; import org.jetbrains.kotlin.cfg.variable.PseudocodeVariablesData; -import org.jetbrains.kotlin.cfg.variable.ReadOnlyInitControlFlowInfo; +import org.jetbrains.kotlin.cfg.variable.VariableInitReadOnlyControlFlowInfo; import org.jetbrains.kotlin.cfg.variable.VariableUseState; import org.jetbrains.kotlin.descriptors.VariableDescriptor; import org.jetbrains.kotlin.resolve.BindingContext; @@ -42,9 +42,9 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest { @NotNull BindingContext bindingContext ) { PseudocodeVariablesData pseudocodeVariablesData = new PseudocodeVariablesData(pseudocode.getRootPseudocode(), bindingContext); - Map> variableInitializers = + Map> variableInitializers = pseudocodeVariablesData.getVariableInitializers(); - Map>> useStatusData = + Map>> useStatusData = pseudocodeVariablesData.getVariableUseStatusData(); String initPrefix = " INIT:"; String usePrefix = " USE:"; @@ -53,16 +53,16 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest { dumpInstructions(pseudocode, out, (instruction, next, prev) -> { StringBuilder result = new StringBuilder(); - Edges initializersEdges = variableInitializers.get(instruction); - Edges previousInitializersEdges = variableInitializers.get(prev); + Edges initializersEdges = variableInitializers.get(instruction); + Edges previousInitializersEdges = variableInitializers.get(prev); String initializersData = ""; if (initializersEdges != null && !initializersEdges.equals(previousInitializersEdges)) { initializersData = dumpEdgesData(initPrefix, initializersEdges, pseudocodeVariablesData); } result.append(String.format("%1$-" + initializersColumnWidth + "s", initializersData)); - Edges> useStatusEdges = useStatusData.get(instruction); - Edges> nextUseStatusEdges = useStatusData.get(next); + Edges> useStatusEdges = useStatusData.get(instruction); + Edges> nextUseStatusEdges = useStatusData.get(next); if (useStatusEdges != null && !useStatusEdges.equals(nextUseStatusEdges)) { result.append(dumpEdgesData(usePrefix, useStatusEdges, pseudocodeVariablesData)); } @@ -73,12 +73,12 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest { private static int countDataColumnWidth( @NotNull String prefix, @NotNull List instructions, - @NotNull Map> data, + @NotNull Map> data, @NotNull PseudocodeVariablesData variablesData ) { int maxWidth = 0; for (Instruction instruction : instructions) { - Edges edges = data.get(instruction); + Edges edges = data.get(instruction); if (edges == null) continue; int length = dumpEdgesData(prefix, edges, variablesData).length(); if (maxWidth < length) { @@ -90,7 +90,7 @@ public abstract class AbstractDataFlowTest extends AbstractPseudocodeTest { } @NotNull - private static > String dumpEdgesData( + private static > String dumpEdgesData( String prefix, @NotNull Edges edges, @NotNull PseudocodeVariablesData variablesData