azalea/kotlin-fork
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

PseudocodeVariablesData converted to Kotlin

Browse Source
This commit is contained in:
Mikhail Glukhikh
2015-12-25 20:13:29 +03:00
parent 7179b37d95
commit 4c4456c808
2 changed files with 223 additions and 294 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compiler/frontend/src/org/jetbrains/kotlin/cfg/ControlFlowInformationProvider.java
+1 -1
View File
@@ -478,7 +478,7 @@ public class ControlFlowInformationProvider {
} }
private boolean checkAssignmentBeforeDeclaration(@NotNull VariableInitContext ctxt, @NotNull KtExpression expression) { private boolean checkAssignmentBeforeDeclaration(@NotNull VariableInitContext ctxt, @NotNull KtExpression expression) {
if (!ctxt.enterInitState.isDeclared && !ctxt.exitInitState.isDeclared if (!ctxt.enterInitState.isDeclared() && !ctxt.exitInitState.isDeclared()
&& !ctxt.enterInitState.mayBeInitialized() && ctxt.exitInitState.mayBeInitialized()) { && !ctxt.enterInitState.mayBeInitialized() && ctxt.exitInitState.mayBeInitialized()) {
report(Errors.INITIALIZATION_BEFORE_DECLARATION.on(expression, ctxt.variableDescriptor), ctxt); report(Errors.INITIALIZATION_BEFORE_DECLARATION.on(expression, ctxt.variableDescriptor), ctxt);
return true; return true;
compiler/frontend/src/org/jetbrains/kotlin/cfg/PseudocodeVariablesData.kt
+222 -293
View File
@@ -14,287 +14,192 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.cfg; package org.jetbrains.kotlin.cfg
import com.google.common.collect.Maps; import com.google.common.collect.Maps
import com.google.common.collect.Sets; import com.google.common.collect.Sets
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeUtil
import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode; import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction
import org.jetbrains.kotlin.cfg.pseudocode.PseudocodeUtil; import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.MagicInstruction
import org.jetbrains.kotlin.cfg.pseudocode.instructions.Instruction; import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.MagicKind
import org.jetbrains.kotlin.cfg.pseudocode.instructions.LexicalScope; import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.ReadValueInstruction
import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.MagicInstruction; import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.WriteValueInstruction
import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.MagicKind; import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.VariableDeclarationInstruction
import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.ReadValueInstruction; import org.jetbrains.kotlin.cfg.pseudocodeTraverser.Edges
import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.WriteValueInstruction; import org.jetbrains.kotlin.cfg.pseudocodeTraverser.TraversalOrder
import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.LocalFunctionDeclarationInstruction; import org.jetbrains.kotlin.descriptors.VariableDescriptor
import org.jetbrains.kotlin.cfg.pseudocode.instructions.special.VariableDeclarationInstruction; import org.jetbrains.kotlin.psi.KtProperty
import org.jetbrains.kotlin.cfg.pseudocodeTraverser.Edges; import org.jetbrains.kotlin.resolve.BindingContext
import org.jetbrains.kotlin.cfg.pseudocodeTraverser.TraversalOrder; import java.util.Collections
import org.jetbrains.kotlin.descriptors.DeclarationDescriptor;
import org.jetbrains.kotlin.descriptors.VariableDescriptor;
import org.jetbrains.kotlin.psi.KtDeclaration;
import org.jetbrains.kotlin.psi.KtProperty;
import org.jetbrains.kotlin.resolve.BindingContext;
import java.util.Collection; class PseudocodeVariablesData(val pseudocode: Pseudocode, private val bindingContext: BindingContext) {
import java.util.Collections; private val pseudocodeVariableDataCollector: PseudocodeVariableDataCollector
import java.util.Map;
import java.util.Set;
public class PseudocodeVariablesData { private val declaredVariablesForDeclaration = Maps.newHashMap<Pseudocode, Set<VariableDescriptor>>()
private final Pseudocode pseudocode;
private final BindingContext bindingContext;
private final PseudocodeVariableDataCollector pseudocodeVariableDataCollector;
private final Map<Pseudocode, Set<VariableDescriptor>> declaredVariablesForDeclaration = Maps.newHashMap(); val variableInitializers: MutableMap<Instruction, Edges<MutableMap<VariableDescriptor, VariableControlFlowState>>> by lazy {
computeVariableInitializers()
private Map<Instruction, Edges<Map<VariableDescriptor, VariableControlFlowState>>> variableInitializers;
public PseudocodeVariablesData(@NotNull Pseudocode pseudocode, @NotNull BindingContext bindingContext) {
this.pseudocode = pseudocode;
this.bindingContext = bindingContext;
this.pseudocodeVariableDataCollector = new PseudocodeVariableDataCollector(bindingContext, pseudocode);
} }
@NotNull init {
public Pseudocode getPseudocode() { this.pseudocodeVariableDataCollector = PseudocodeVariableDataCollector(bindingContext, pseudocode)
return pseudocode;
} }
@NotNull val lexicalScopeVariableInfo: LexicalScopeVariableInfo
public LexicalScopeVariableInfo getLexicalScopeVariableInfo() { get() = pseudocodeVariableDataCollector.lexicalScopeVariableInfo
return pseudocodeVariableDataCollector.getLexicalScopeVariableInfo();
}
@NotNull fun getDeclaredVariables(pseudocode: Pseudocode, includeInsideLocalDeclarations: Boolean): Set<VariableDescriptor> {
public Set<VariableDescriptor> getDeclaredVariables(@NotNull Pseudocode pseudocode, boolean includeInsideLocalDeclarations) {
if (!includeInsideLocalDeclarations) { if (!includeInsideLocalDeclarations) {
return getUpperLevelDeclaredVariables(pseudocode); return getUpperLevelDeclaredVariables(pseudocode)
} }
Set<VariableDescriptor> declaredVariables = Sets.newHashSet(); val declaredVariables = Sets.newHashSet<VariableDescriptor>()
declaredVariables.addAll(getUpperLevelDeclaredVariables(pseudocode)); declaredVariables.addAll(getUpperLevelDeclaredVariables(pseudocode))
for (LocalFunctionDeclarationInstruction localFunctionDeclarationInstruction : pseudocode.getLocalDeclarations()) { for (localFunctionDeclarationInstruction in pseudocode.localDeclarations) {
Pseudocode localPseudocode = localFunctionDeclarationInstruction.getBody(); val localPseudocode = localFunctionDeclarationInstruction.body
declaredVariables.addAll(getUpperLevelDeclaredVariables(localPseudocode)); declaredVariables.addAll(getUpperLevelDeclaredVariables(localPseudocode))
} }
return declaredVariables; return declaredVariables
} }
@NotNull private fun getUpperLevelDeclaredVariables(pseudocode: Pseudocode): Set<VariableDescriptor> {
private Set<VariableDescriptor> getUpperLevelDeclaredVariables(@NotNull Pseudocode pseudocode) { var declaredVariables: Set<VariableDescriptor>? = declaredVariablesForDeclaration[pseudocode]
Set<VariableDescriptor> declaredVariables = declaredVariablesForDeclaration.get(pseudocode);
if (declaredVariables == null) { if (declaredVariables == null) {
declaredVariables = computeDeclaredVariablesForPseudocode(pseudocode); declaredVariables = computeDeclaredVariablesForPseudocode(pseudocode)
declaredVariablesForDeclaration.put(pseudocode, declaredVariables); declaredVariablesForDeclaration.put(pseudocode, declaredVariables)
} }
return declaredVariables; return declaredVariables
} }
@NotNull private fun computeDeclaredVariablesForPseudocode(pseudocode: Pseudocode): Set<VariableDescriptor> {
private Set<VariableDescriptor> computeDeclaredVariablesForPseudocode(Pseudocode pseudocode) { val declaredVariables = Sets.newHashSet<VariableDescriptor>()
Set<VariableDescriptor> declaredVariables = Sets.newHashSet(); for (instruction in pseudocode.instructions) {
for (Instruction instruction : pseudocode.getInstructions()) { if (instruction is VariableDeclarationInstruction) {
if (instruction instanceof VariableDeclarationInstruction) { val variableDeclarationElement = instruction.variableDeclarationElement
KtDeclaration variableDeclarationElement = ((VariableDeclarationInstruction) instruction).getVariableDeclarationElement(); val descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, variableDeclarationElement)
DeclarationDescriptor descriptor = bindingContext.get(BindingContext.DECLARATION_TO_DESCRIPTOR, variableDeclarationElement);
if (descriptor != null) { if (descriptor != null) {
assert descriptor instanceof VariableDescriptor; assert(descriptor is VariableDescriptor)
declaredVariables.add((VariableDescriptor) descriptor); declaredVariables.add(descriptor as VariableDescriptor?)
} }
} }
} }
return Collections.unmodifiableSet(declaredVariables); return Collections.unmodifiableSet(declaredVariables)
} }
// variable initializers // variable initializers
@NotNull private fun computeVariableInitializers(): MutableMap<Instruction, Edges<MutableMap<VariableDescriptor, VariableControlFlowState>>> {
public Map<Instruction, Edges<Map<VariableDescriptor, VariableControlFlowState>>> getVariableInitializers() {
if (variableInitializers == null) {
variableInitializers = computeVariableInitializers();
}
return variableInitializers; val lexicalScopeVariableInfo = pseudocodeVariableDataCollector.lexicalScopeVariableInfo
}
@NotNull
private Map<Instruction, Edges<Map<VariableDescriptor, VariableControlFlowState>>> computeVariableInitializers() {
final LexicalScopeVariableInfo lexicalScopeVariableInfo = pseudocodeVariableDataCollector.getLexicalScopeVariableInfo();
return pseudocodeVariableDataCollector.collectData( return pseudocodeVariableDataCollector.collectData(
TraversalOrder.FORWARD, /*mergeDataWithLocalDeclarations=*/ true, TraversalOrder.FORWARD, /*mergeDataWithLocalDeclarations=*/ true,
new InstructionDataMergeStrategy<VariableControlFlowState>() { object : InstructionDataMergeStrategy<VariableControlFlowState> {
@NotNull override operator fun invoke(
@Override instruction: Instruction,
public Edges<Map<VariableDescriptor, VariableControlFlowState>> invoke( incomingEdgesData: Collection<MutableMap<VariableDescriptor, VariableControlFlowState>>
@NotNull Instruction instruction, ): Edges<MutableMap<VariableDescriptor, VariableControlFlowState>> {
@NotNull Collection<? extends Map<VariableDescriptor, VariableControlFlowState>> incomingEdgesData
) {
Map<VariableDescriptor, VariableControlFlowState> enterInstructionData = val enterInstructionData = mergeIncomingEdgesDataForInitializers(incomingEdgesData)
mergeIncomingEdgesDataForInitializers(incomingEdgesData); val exitInstructionData = addVariableInitStateFromCurrentInstructionIfAny(
Map<VariableDescriptor, VariableControlFlowState> exitInstructionData = addVariableInitStateFromCurrentInstructionIfAny( instruction, enterInstructionData, lexicalScopeVariableInfo)
instruction, enterInstructionData, lexicalScopeVariableInfo); return Edges(enterInstructionData, exitInstructionData)
return new Edges<Map<VariableDescriptor, VariableControlFlowState>>(enterInstructionData, exitInstructionData);
} }
} })
);
} }
public static VariableControlFlowState getDefaultValueForInitializers( private fun addVariableInitStateFromCurrentInstructionIfAny(
@NotNull VariableDescriptor variable, instruction: Instruction,
@NotNull Instruction instruction, enterInstructionData: MutableMap<VariableDescriptor, VariableControlFlowState>,
@NotNull LexicalScopeVariableInfo lexicalScopeVariableInfo lexicalScopeVariableInfo: LexicalScopeVariableInfo
) { ): MutableMap<VariableDescriptor, VariableControlFlowState> {
//todo: think of replacing it with "MapWithDefaultValue" if (instruction is MagicInstruction) {
LexicalScope declaredIn = lexicalScopeVariableInfo.getDeclaredIn().get(variable); if (instruction.kind === MagicKind.EXHAUSTIVE_WHEN_ELSE) {
boolean declaredOutsideThisDeclaration = val exitInstructionData = Maps.newHashMap(enterInstructionData)
declaredIn == null //declared outside this pseudocode for (entry in enterInstructionData.entries) {
|| declaredIn.getLexicalScopeForContainingDeclaration() != instruction.getLexicalScope().getLexicalScopeForContainingDeclaration(); if (!entry.value.definitelyInitialized()) {
return VariableControlFlowState.create(/*initState=*/declaredOutsideThisDeclaration); exitInstructionData.put(entry.key,
} VariableControlFlowState.createInitializedExhaustively(entry.value.isDeclared))
@NotNull
private static Map<VariableDescriptor, VariableControlFlowState> mergeIncomingEdgesDataForInitializers(
@NotNull Collection<? extends Map<VariableDescriptor, VariableControlFlowState>> incomingEdgesData
) {
Set<VariableDescriptor> variablesInScope = Sets.newHashSet();
for (Map<VariableDescriptor, VariableControlFlowState> edgeData : incomingEdgesData) {
variablesInScope.addAll(edgeData.keySet());
}
Map<VariableDescriptor, VariableControlFlowState> enterInstructionData = Maps.newHashMap();
for (VariableDescriptor variable : variablesInScope) {
InitState initState = null;
boolean isDeclared = true;
for (Map<VariableDescriptor, VariableControlFlowState> edgeData : incomingEdgesData) {
VariableControlFlowState varControlFlowState = edgeData.get(variable);
if (varControlFlowState != null) {
initState = initState != null ? initState.merge(varControlFlowState.initState) : varControlFlowState.initState;
if (!varControlFlowState.isDeclared) {
isDeclared = false;
} }
} }
} return exitInstructionData
if (initState == null) {
throw new AssertionError("An empty set of incoming edges data");
}
enterInstructionData.put(variable, VariableControlFlowState.create(initState, isDeclared));
}
return enterInstructionData;
}
@NotNull
private Map<VariableDescriptor, VariableControlFlowState> addVariableInitStateFromCurrentInstructionIfAny(
@NotNull Instruction instruction,
@NotNull Map<VariableDescriptor, VariableControlFlowState> enterInstructionData,
@NotNull LexicalScopeVariableInfo lexicalScopeVariableInfo
) {
if (instruction instanceof MagicInstruction) {
MagicInstruction magicInstruction = (MagicInstruction) instruction;
if (magicInstruction.getKind() == MagicKind.EXHAUSTIVE_WHEN_ELSE) {
Map<VariableDescriptor, VariableControlFlowState> exitInstructionData = Maps.newHashMap(enterInstructionData);
for (Map.Entry<VariableDescriptor, VariableControlFlowState> entry: enterInstructionData.entrySet()) {
if (!entry.getValue().definitelyInitialized()) {
exitInstructionData.put(entry.getKey(),
VariableControlFlowState.createInitializedExhaustively(entry.getValue().isDeclared));
}
}
return exitInstructionData;
} }
} }
if (!(instruction instanceof WriteValueInstruction) && !(instruction instanceof VariableDeclarationInstruction)) { if (instruction !is WriteValueInstruction && instruction !is VariableDeclarationInstruction) {
return enterInstructionData; return enterInstructionData
} }
VariableDescriptor variable = PseudocodeUtil.extractVariableDescriptorIfAny(instruction, false, bindingContext); val variable = PseudocodeUtil.extractVariableDescriptorIfAny(instruction, false, bindingContext) ?: return enterInstructionData
if (variable == null) { val exitInstructionData = Maps.newHashMap(enterInstructionData)
return enterInstructionData; if (instruction is WriteValueInstruction) {
}
Map<VariableDescriptor, VariableControlFlowState> exitInstructionData = Maps.newHashMap(enterInstructionData);
if (instruction instanceof WriteValueInstruction) {
// if writing to already initialized object // if writing to already initialized object
if (!PseudocodeUtil.isThisOrNoDispatchReceiver((WriteValueInstruction) instruction, bindingContext)) { if (!PseudocodeUtil.isThisOrNoDispatchReceiver(instruction, bindingContext)) {
return enterInstructionData; return enterInstructionData
} }
VariableControlFlowState enterInitState = enterInstructionData.get(variable); val enterInitState = enterInstructionData[variable]
VariableControlFlowState initializationAtThisElement = val initializationAtThisElement = VariableControlFlowState.create(instruction.element is KtProperty, enterInitState)
VariableControlFlowState exitInstructionData.put(variable, initializationAtThisElement)
.create(((WriteValueInstruction) instruction).getElement() instanceof KtProperty, enterInitState);
exitInstructionData.put(variable, initializationAtThisElement);
} }
else { // instruction instanceof VariableDeclarationInstruction else {
VariableControlFlowState enterInitState = enterInstructionData.get(variable); // instruction instanceof VariableDeclarationInstruction
var enterInitState: VariableControlFlowState? = enterInstructionData[variable]
if (enterInitState == null) { if (enterInitState == null) {
enterInitState = getDefaultValueForInitializers(variable, instruction, lexicalScopeVariableInfo); enterInitState = getDefaultValueForInitializers(variable, instruction, lexicalScopeVariableInfo)
} }
if (enterInitState == null || !enterInitState.mayBeInitialized() || !enterInitState.isDeclared) { if (!enterInitState.mayBeInitialized() || !enterInitState.isDeclared) {
boolean isInitialized = enterInitState != null && enterInitState.mayBeInitialized(); val isInitialized = enterInitState.mayBeInitialized()
VariableControlFlowState variableDeclarationInfo = VariableControlFlowState.create(isInitialized, true); val variableDeclarationInfo = VariableControlFlowState.create(isInitialized, true)
exitInstructionData.put(variable, variableDeclarationInfo); exitInstructionData.put(variable, variableDeclarationInfo)
} }
} }
return exitInstructionData; return exitInstructionData
} }
// variable use // variable use
@NotNull /*mergeDataWithLocalDeclarations=*///instruction instanceof WriteValueInstruction
public Map<Instruction, Edges<Map<VariableDescriptor, VariableUseState>>> getVariableUseStatusData() { val variableUseStatusData: MutableMap<Instruction, Edges<MutableMap<VariableDescriptor, VariableUseState>>>
return pseudocodeVariableDataCollector.collectData( get() = pseudocodeVariableDataCollector.collectData(
TraversalOrder.BACKWARD, /*mergeDataWithLocalDeclarations=*/ true, TraversalOrder.BACKWARD, true,
new InstructionDataMergeStrategy<VariableUseState>() { object : InstructionDataMergeStrategy<VariableUseState> {
@NotNull override operator fun invoke(
@Override instruction: Instruction,
public Edges<Map<VariableDescriptor, VariableUseState>> invoke( incomingEdgesData: Collection<MutableMap<VariableDescriptor, VariableUseState>>
@NotNull Instruction instruction, ): Edges<MutableMap<VariableDescriptor, VariableUseState>> {
@NotNull Collection<? extends Map<VariableDescriptor, VariableUseState>> incomingEdgesData
) {
Map<VariableDescriptor, VariableUseState> enterResult = Maps.newHashMap(); val enterResult = Maps.newHashMap<VariableDescriptor, VariableUseState>()
for (Map<VariableDescriptor, VariableUseState> edgeData : incomingEdgesData) { for (edgeData in incomingEdgesData) {
for (Map.Entry<VariableDescriptor, VariableUseState> entry : edgeData.entrySet()) { for (entry in edgeData.entries) {
VariableDescriptor variableDescriptor = entry.getKey(); val variableDescriptor = entry.key
VariableUseState variableUseState = entry.getValue(); val variableUseState = entry.value
enterResult.put(variableDescriptor, variableUseState.merge(enterResult.get(variableDescriptor))); enterResult.put(variableDescriptor, variableUseState.merge(enterResult[variableDescriptor]))
} }
} }
VariableDescriptor variableDescriptor = PseudocodeUtil.extractVariableDescriptorIfAny( val variableDescriptor = PseudocodeUtil.extractVariableDescriptorIfAny(
instruction, true, bindingContext); instruction, true, bindingContext)
if (variableDescriptor == null || if (variableDescriptor == null || instruction !is ReadValueInstruction && instruction !is WriteValueInstruction) {
(!(instruction instanceof ReadValueInstruction) && !(instruction instanceof WriteValueInstruction))) { return Edges(enterResult, enterResult)
return new Edges<Map<VariableDescriptor, VariableUseState>>(enterResult, enterResult);
} }
Map<VariableDescriptor, VariableUseState> exitResult = Maps.newHashMap(enterResult); val exitResult = Maps.newHashMap(enterResult)
if (instruction instanceof ReadValueInstruction) { if (instruction is ReadValueInstruction) {
exitResult.put(variableDescriptor, VariableUseState.READ); exitResult.put(variableDescriptor, VariableUseState.READ)
} }
else { //instruction instanceof WriteValueInstruction else {
VariableUseState variableUseState = enterResult.get(variableDescriptor); var variableUseState: VariableUseState? = enterResult[variableDescriptor]
if (variableUseState == null) { if (variableUseState == null) {
variableUseState = VariableUseState.UNUSED; variableUseState = VariableUseState.UNUSED
} }
switch (variableUseState) { when (variableUseState) {
case UNUSED: PseudocodeVariablesData.VariableUseState.UNUSED, PseudocodeVariablesData.VariableUseState.ONLY_WRITTEN_NEVER_READ -> exitResult.put(variableDescriptor, VariableUseState.ONLY_WRITTEN_NEVER_READ)
case ONLY_WRITTEN_NEVER_READ: PseudocodeVariablesData.VariableUseState.WRITTEN_AFTER_READ, PseudocodeVariablesData.VariableUseState.READ -> exitResult.put(variableDescriptor, VariableUseState.WRITTEN_AFTER_READ)
exitResult.put(variableDescriptor, VariableUseState.ONLY_WRITTEN_NEVER_READ);
break;
case WRITTEN_AFTER_READ:
case READ:
exitResult.put(variableDescriptor, VariableUseState.WRITTEN_AFTER_READ);
} }
} }
return new Edges<Map<VariableDescriptor, VariableUseState>>(enterResult, exitResult); return Edges(enterResult, exitResult)
} }
} })
);
}
private enum InitState { private enum class InitState private constructor(private val s: String) {
// Definitely initialized // Definitely initialized
INITIALIZED("I"), INITIALIZED("I"),
// Fake initializer in else branch of "exhaustive when without else", see MagicKind.EXHAUSTIVE_WHEN_ELSE // Fake initializer in else branch of "exhaustive when without else", see MagicKind.EXHAUSTIVE_WHEN_ELSE
@@ -304,106 +209,130 @@ public class PseudocodeVariablesData {
// Definitely not initialized // Definitely not initialized
NOT_INITIALIZED(""); NOT_INITIALIZED("");
private final String s; fun merge(other: InitState): InitState {
InitState(String s) {
this.s = s;
}
private InitState merge(@NotNull InitState other) {
// X merge X = X // X merge X = X
// X merge IE = IE merge X = X // X merge IE = IE merge X = X
// else X merge Y = I? // else X merge Y = I?
if (this == other || other == INITIALIZED_EXHAUSTIVELY) return this; if (this == other || other == INITIALIZED_EXHAUSTIVELY) return this
if (this == INITIALIZED_EXHAUSTIVELY) return other; if (this == INITIALIZED_EXHAUSTIVELY) return other
return UNKNOWN; return UNKNOWN
} }
@Override override fun toString(): String {
public String toString() { return s
return s;
} }
} }
public static class VariableControlFlowState { class VariableControlFlowState private constructor(val initState: InitState, val isDeclared: Boolean) {
public final InitState initState; fun definitelyInitialized(): Boolean {
public final boolean isDeclared; return initState == InitState.INITIALIZED
private VariableControlFlowState(InitState initState, boolean isDeclared) {
this.initState = initState;
this.isDeclared = isDeclared;
} }
private static final VariableControlFlowState VS_IT = new VariableControlFlowState(InitState.INITIALIZED, true); fun mayBeInitialized(): Boolean {
private static final VariableControlFlowState VS_IF = new VariableControlFlowState(InitState.INITIALIZED, false); return initState != InitState.NOT_INITIALIZED
private static final VariableControlFlowState VS_ET = new VariableControlFlowState(InitState.INITIALIZED_EXHAUSTIVELY, true); }
private static final VariableControlFlowState VS_EF = new VariableControlFlowState(InitState.INITIALIZED_EXHAUSTIVELY, false);
private static final VariableControlFlowState VS_UT = new VariableControlFlowState(InitState.UNKNOWN, true);
private static final VariableControlFlowState VS_UF = new VariableControlFlowState(InitState.UNKNOWN, false);
private static final VariableControlFlowState VS_NT = new VariableControlFlowState(InitState.NOT_INITIALIZED, true);
private static final VariableControlFlowState VS_NF = new VariableControlFlowState(InitState.NOT_INITIALIZED, false);
override fun toString(): String {
if (initState == InitState.NOT_INITIALIZED && !isDeclared) return "-"
return "$initState${if (isDeclared) "D" else ""}"
}
private static VariableControlFlowState create(InitState initState, boolean isDeclared) { companion object {
switch (initState) {
case INITIALIZED: return isDeclared ? VS_IT : VS_IF; private val VS_IT = VariableControlFlowState(InitState.INITIALIZED, true)
case INITIALIZED_EXHAUSTIVELY: return isDeclared ? VS_ET : VS_EF; private val VS_IF = VariableControlFlowState(InitState.INITIALIZED, false)
case UNKNOWN: return isDeclared ? VS_UT : VS_UF; private val VS_ET = VariableControlFlowState(InitState.INITIALIZED_EXHAUSTIVELY, true)
default: return isDeclared ? VS_NT : VS_NF; private val VS_EF = VariableControlFlowState(InitState.INITIALIZED_EXHAUSTIVELY, false)
private val VS_UT = VariableControlFlowState(InitState.UNKNOWN, true)
private val VS_UF = VariableControlFlowState(InitState.UNKNOWN, false)
private val VS_NT = VariableControlFlowState(InitState.NOT_INITIALIZED, true)
private val VS_NF = VariableControlFlowState(InitState.NOT_INITIALIZED, false)
fun create(initState: InitState, isDeclared: Boolean): VariableControlFlowState {
when (initState) {
PseudocodeVariablesData.InitState.INITIALIZED -> return if (isDeclared) VS_IT else VS_IF
PseudocodeVariablesData.InitState.INITIALIZED_EXHAUSTIVELY -> return if (isDeclared) VS_ET else VS_EF
PseudocodeVariablesData.InitState.UNKNOWN -> return if (isDeclared) VS_UT else VS_UF
else -> return if (isDeclared) VS_NT else VS_NF
}
}
fun createInitializedExhaustively(isDeclared: Boolean): VariableControlFlowState {
return create(InitState.INITIALIZED_EXHAUSTIVELY, isDeclared)
}
fun create(isInitialized: Boolean, isDeclared: Boolean = false): VariableControlFlowState {
return create(if (isInitialized) InitState.INITIALIZED else InitState.NOT_INITIALIZED, isDeclared)
}
fun create(isDeclaredHere: Boolean, mergedEdgesData: VariableControlFlowState?): VariableControlFlowState {
return create(true, isDeclaredHere || mergedEdgesData != null && mergedEdgesData.isDeclared)
} }
} }
private static VariableControlFlowState createInitializedExhaustively(boolean isDeclared) {
return create(InitState.INITIALIZED_EXHAUSTIVELY, isDeclared);
}
private static VariableControlFlowState create(boolean isInitialized, boolean isDeclared) {
return create(isInitialized ? InitState.INITIALIZED : InitState.NOT_INITIALIZED, isDeclared);
}
private static VariableControlFlowState create(boolean isInitialized) {
return create(isInitialized, false);
}
private static VariableControlFlowState create(boolean isDeclaredHere, @Nullable VariableControlFlowState mergedEdgesData) {
return create(true, isDeclaredHere || (mergedEdgesData != null && mergedEdgesData.isDeclared));
}
public boolean definitelyInitialized() {
return initState == InitState.INITIALIZED;
}
public boolean mayBeInitialized() {
return initState != InitState.NOT_INITIALIZED;
}
@Override
public String toString() {
if (initState == InitState.NOT_INITIALIZED && !isDeclared) return "-";
return initState + (isDeclared ? "D" : "");
}
} }
public enum VariableUseState { enum class VariableUseState private constructor(private val priority: Int) {
READ(3), READ(3),
WRITTEN_AFTER_READ(2), WRITTEN_AFTER_READ(2),
ONLY_WRITTEN_NEVER_READ(1), ONLY_WRITTEN_NEVER_READ(1),
UNUSED(0); UNUSED(0);
private final int priority; fun merge(variableUseState: VariableUseState?): VariableUseState {
if (variableUseState == null || priority > variableUseState.priority) return this
VariableUseState(int priority) { return variableUseState
this.priority = priority;
} }
private VariableUseState merge(@Nullable VariableUseState variableUseState) { companion object {
if (variableUseState == null || priority > variableUseState.priority) return this;
return variableUseState; @JvmStatic
fun isUsed(variableUseState: VariableUseState?): Boolean {
return variableUseState != null && variableUseState != UNUSED
}
}
}
companion object {
@JvmStatic
fun getDefaultValueForInitializers(
variable: VariableDescriptor,
instruction: Instruction,
lexicalScopeVariableInfo: LexicalScopeVariableInfo): VariableControlFlowState {
//todo: think of replacing it with "MapWithDefaultValue"
val declaredIn = lexicalScopeVariableInfo.declaredIn[variable]
val declaredOutsideThisDeclaration = declaredIn == null //declared outside this pseudocode
|| declaredIn.lexicalScopeForContainingDeclaration != instruction.lexicalScope.lexicalScopeForContainingDeclaration
return VariableControlFlowState.create(/*initState=*/declaredOutsideThisDeclaration)
} }
public static boolean isUsed(@Nullable VariableUseState variableUseState) { private fun mergeIncomingEdgesDataForInitializers(
return variableUseState != null && variableUseState != UNUSED; incomingEdgesData: Collection<MutableMap<VariableDescriptor, VariableControlFlowState>>
): MutableMap<VariableDescriptor, VariableControlFlowState> {
val variablesInScope = Sets.newHashSet<VariableDescriptor>()
for (edgeData in incomingEdgesData) {
variablesInScope.addAll(edgeData.keys)
}
val enterInstructionData = Maps.newHashMap<VariableDescriptor, VariableControlFlowState>()
for (variable in variablesInScope) {
var initState: InitState? = null
var isDeclared = true
for (edgeData in incomingEdgesData) {
val varControlFlowState = edgeData[variable]
if (varControlFlowState != null) {
initState = if (initState != null) initState.merge(varControlFlowState.initState) else varControlFlowState.initState
if (!varControlFlowState.isDeclared) {
isDeclared = false
}
}
}
if (initState == null) {
throw AssertionError("An empty set of incoming edges data")
}
enterInstructionData.put(variable, VariableControlFlowState.create(initState, isDeclared))
}
return enterInstructionData
} }
} }
} }