From c2b10dc2744dca653174cabc54816b7d2c333a36 Mon Sep 17 00:00:00 2001 From: Svetlana Isakova Date: Sun, 23 Feb 2014 13:25:26 +0400 Subject: [PATCH] removed initial map for start instruction --- .../lang/cfg/JetFlowInformationProvider.java | 20 +++- .../jet/lang/cfg/PseudocodeVariablesData.java | 104 +++++++----------- 2 files changed, 55 insertions(+), 69 deletions(-) diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java index d6449a019b8..79543d84c4c 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/JetFlowInformationProvider.java @@ -268,7 +268,7 @@ public class JetFlowInformationProvider { @Nullable Map in, @Nullable Map out) { assert in != null && out != null; - VariableInitContext ctxt = new VariableInitContext(instruction, reportedDiagnosticMap, in, out); + VariableInitContext ctxt = new VariableInitContext(instruction, reportedDiagnosticMap, in, out, declaredVariables); if (ctxt.variableDescriptor == null) return; if (instruction instanceof ReadValueInstruction) { JetElement element = ((ReadValueInstruction) instruction).getElement(); @@ -843,11 +843,23 @@ public class JetFlowInformationProvider { @NotNull Instruction instruction, @NotNull Map map, @NotNull Map in, - @NotNull Map out + @NotNull Map out, + @NotNull Set declaredVariables ) { super(instruction, map); - enterInitState = variableDescriptor != null ? in.get(variableDescriptor) : null; - exitInitState = variableDescriptor != null ? out.get(variableDescriptor) : null; + enterInitState = initialize(variableDescriptor, declaredVariables, in); + exitInitState = initialize(variableDescriptor, declaredVariables, out); + } + + private VariableInitState initialize( + VariableDescriptor variableDescriptor, + Set declaredVariables, + Map map + ) { + if (variableDescriptor == null) return null; + VariableInitState state = map.get(variableDescriptor); + if (state != null) return state; + return PseudocodeVariablesData.getDefaultValueForInitializers(declaredVariables, variableDescriptor); } } diff --git a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/PseudocodeVariablesData.java b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/PseudocodeVariablesData.java index 3cc2ff38068..f9e533c1ff4 100644 --- a/compiler/frontend/src/org/jetbrains/jet/lang/cfg/PseudocodeVariablesData.java +++ b/compiler/frontend/src/org/jetbrains/jet/lang/cfg/PseudocodeVariablesData.java @@ -22,19 +22,14 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.cfg.PseudocodeTraverser.*; import org.jetbrains.jet.lang.cfg.pseudocode.*; -import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; -import org.jetbrains.jet.lang.descriptors.VariableDescriptor; +import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.psi.JetDeclaration; import org.jetbrains.jet.lang.psi.JetProperty; import org.jetbrains.jet.lang.resolve.BindingContext; -import java.util.Collection; -import java.util.Collections; -import java.util.Map; -import java.util.Set; +import java.util.*; import static org.jetbrains.jet.lang.cfg.PseudocodeTraverser.LookInsideStrategy.ANALYSE_LOCAL_DECLARATIONS; -import static org.jetbrains.jet.lang.cfg.PseudocodeTraverser.LookInsideStrategy.SKIP_LOCAL_DECLARATIONS; import static org.jetbrains.jet.lang.cfg.PseudocodeTraverser.TraversalOrder.BACKWARD; import static org.jetbrains.jet.lang.cfg.PseudocodeTraverser.TraversalOrder.FORWARD; @@ -133,66 +128,43 @@ public class PseudocodeVariablesData { @NotNull private Map>> getVariableInitializers(@NotNull Pseudocode pseudocode) { - Set usedVariables = getUsedVariables(pseudocode); - Set declaredVariables = getDeclaredVariables(pseudocode, false); + final Set declaredVariables = getDeclaredVariables(pseudocode, true); Map initialMap = Collections.emptyMap(); - Map initialMapForStartInstruction = prepareInitializersMapForStartInstruction( - usedVariables, declaredVariables); - Map>> variableInitializersMap = PseudocodeTraverser.collectData( - pseudocode, FORWARD, SKIP_LOCAL_DECLARATIONS, - initialMap, initialMapForStartInstruction, new PseudocodeTraverser.InstructionDataMergeStrategy>() { - @Override - public Edges> execute( - @NotNull Instruction instruction, @NotNull Collection> incomingEdgesData) { + InstructionDataMergeStrategy> instructionDataMergeStrategy = + new InstructionDataMergeStrategy>() { + @Override + public Edges> execute( + @NotNull Instruction instruction, + @NotNull Collection> incomingEdgesData + ) { - Map enterInstructionData = mergeIncomingEdgesDataForInitializers(incomingEdgesData); - Map exitInstructionData = - addVariableInitStateFromCurrentInstructionIfAny(instruction, enterInstructionData); - return Edges.create(enterInstructionData, exitInstructionData); - } - }); + Map enterInstructionData = + mergeIncomingEdgesDataForInitializers(incomingEdgesData); + Map exitInstructionData = + addVariableInitStateFromCurrentInstructionIfAny(instruction, enterInstructionData, declaredVariables); + return Edges.create(enterInstructionData, exitInstructionData); + } + }; - - for (LocalFunctionDeclarationInstruction localFunctionDeclarationInstruction : pseudocode.getLocalDeclarations()) { - Pseudocode localPseudocode = localFunctionDeclarationInstruction.getBody(); - Map>> initializersForLocalDeclaration = getVariableInitializers(localPseudocode); - - for (Instruction instruction : initializersForLocalDeclaration.keySet()) { - //todo - if (!variableInitializersMap.containsKey(instruction)) { - variableInitializersMap.put(instruction, initializersForLocalDeclaration.get(instruction)); - } - } - variableInitializersMap.putAll(initializersForLocalDeclaration); - } - return variableInitializersMap; + return PseudocodeTraverser.collectData( + pseudocode, FORWARD, ANALYSE_LOCAL_DECLARATIONS, + initialMap, initialMap, instructionDataMergeStrategy); } - @NotNull - private static Map prepareInitializersMapForStartInstruction( - @NotNull Collection usedVariables, - @NotNull Collection declaredVariables) { - - Map initialMapForStartInstruction = Maps.newHashMap(); - VariableInitState initializedForExternalVariable = VariableInitState.create(true); - VariableInitState notInitializedForDeclaredVariable = VariableInitState.create(false); - - for (VariableDescriptor variable : usedVariables) { - if (declaredVariables.contains(variable)) { - initialMapForStartInstruction.put(variable, notInitializedForDeclaredVariable); - } - else { - initialMapForStartInstruction.put(variable, initializedForExternalVariable); - } - } - return initialMapForStartInstruction; + public static VariableInitState getDefaultValueForInitializers( + @NotNull Set declaredVariables, + @NotNull VariableDescriptor variable + ) { + //todo: think of replacing it with "MapWithDefaultValue" + boolean isInitialized = !declaredVariables.contains(variable); + return VariableInitState.create(isInitialized); } @NotNull private static Map mergeIncomingEdgesDataForInitializers( - @NotNull Collection> incomingEdgesData) { - + @NotNull Collection> incomingEdgesData + ) { Set variablesInScope = Sets.newHashSet(); for (Map edgeData : incomingEdgesData) { variablesInScope.addAll(edgeData.keySet()); @@ -220,8 +192,10 @@ public class PseudocodeVariablesData { @NotNull private Map addVariableInitStateFromCurrentInstructionIfAny( - @NotNull Instruction instruction, @NotNull Map enterInstructionData) { - + @NotNull Instruction instruction, + @NotNull Map enterInstructionData, + @NotNull Set declaredVariables + ) { if (!(instruction instanceof WriteValueInstruction) && !(instruction instanceof VariableDeclarationInstruction)) { return enterInstructionData; } @@ -238,6 +212,9 @@ public class PseudocodeVariablesData { } else { // instruction instanceof VariableDeclarationInstruction VariableInitState enterInitState = enterInstructionData.get(variable); + if (enterInitState == null) { + enterInitState = getDefaultValueForInitializers(declaredVariables, variable); + } if (enterInitState == null || !enterInitState.isInitialized || !enterInitState.isDeclared) { boolean isInitialized = enterInitState != null && enterInitState.isInitialized; VariableInitState variableDeclarationInfo = VariableInitState.create(isInitialized, true); @@ -252,9 +229,6 @@ public class PseudocodeVariablesData { @NotNull public Map>> getVariableUseStatusData() { Map sinkInstructionData = Maps.newHashMap(); - for (VariableDescriptor usedVariable : getUsedVariables(pseudocode)) { - sinkInstructionData.put(usedVariable, VariableUseState.UNUSED); - } InstructionDataMergeStrategy> collectVariableUseStatusStrategy = new InstructionDataMergeStrategy>() { @Override @@ -299,9 +273,9 @@ public class PseudocodeVariablesData { return Edges.create(enterResult, exitResult); } }; - return PseudocodeTraverser.collectData(pseudocode, BACKWARD, ANALYSE_LOCAL_DECLARATIONS, - Collections.emptyMap(), - sinkInstructionData, collectVariableUseStatusStrategy); + return PseudocodeTraverser.collectData( + pseudocode, BACKWARD, ANALYSE_LOCAL_DECLARATIONS, Collections.emptyMap(), + sinkInstructionData, collectVariableUseStatusStrategy); } public static class VariableInitState {