Package com.intellij.psi.controlFlow

Class ControlFlowUtil

java.lang.Object

com.intellij.psi.controlFlow.ControlFlowUtil

public class ControlFlowUtil
extends java.lang.Object

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	ControlFlowUtil.ControlFlowEdge
static class	ControlFlowUtil.VariableInfo

Field Summary

Fields

Modifier and Type	Field and Description
static java.lang.Class<? extends PsiStatement>[]	DEFAULT_EXIT_STATEMENTS_CLASSES
static int	NORMAL_COMPLETION_REASON

Constructor Summary

Constructors

Constructor and Description
ControlFlowUtil()

Method Summary

Modifier and Type	Method and Description
static boolean	areVariablesUnmodifiedAtLocations(ControlFlow flow, int startOffset, int endOffset, java.util.Set<? extends PsiVariable> variables, java.lang.Iterable<? extends PsiElement> locations) Check that in the flow between startOffset and endOffset there are no writes to the variables or these writes aren't observable at the locations.
static boolean	canCompleteNormally(ControlFlow flow, int startOffset, int endOffset) returns true iff exists control flow path completing normally, i.e.
static boolean	collectOuterLocals(java.util.List<? super PsiVariable> array, PsiElement scope, PsiElement member, PsiElement targetClassMember) Checks possibility of extracting code fragment outside containing anonymous (local) class.
static PsiElement	findCodeFragment(PsiElement element)
static java.util.Collection<PsiStatement>	findExitPointsAndStatements(ControlFlow flow, int start, int end, IntArrayList exitPoints, java.lang.Class<? extends PsiStatement>... classesFilter)
static PsiReferenceExpression	findSingleReadOccurrence(ControlFlow flow, PsiElement element, PsiVariable variable) If the variable occurs only once in the element and it's read access return that occurrence
static int	getCompletionReasons(ControlFlow flow, int offset, int endOffset) return reasons.normalCompletion when block can complete normally reasons.returnCalled when block can complete abruptly because of return statement executed
static java.util.List<ControlFlowUtil.ControlFlowEdge>	getEdges(ControlFlow flow, int start) Returns control flow edges which are potentially reachable from start instruction
static java.util.Collection<ControlFlowUtil.VariableInfo>	getInitializedTwice(ControlFlow flow)
static java.util.Collection<ControlFlowUtil.VariableInfo>	getInitializedTwice(ControlFlow flow, int startOffset, int endOffset)
static java.util.List<PsiVariable>	getInputVariables(ControlFlow flow, int start, int end)
static int	getMinDefinitelyReachedOffset(ControlFlow flow, int sourceOffset, java.util.List<? extends PsiElement> references)
static PsiVariable []	getOutputVariables(ControlFlow flow, int start, int end, int [] exitPoints)
static java.util.List<PsiReferenceExpression>	getReadBeforeWrite(ControlFlow flow)
static java.util.List<PsiReferenceExpression>	getReadBeforeWriteLocals(ControlFlow flow)
static java.util.List<PsiVariable>	getSSAVariables(ControlFlow flow)
static java.util.List<PsiVariable>	getSSAVariables(ControlFlow flow, int from, int to, boolean reportVarsIfNonInitializingPathExists)
static PsiElement	getUnreachableStatement(ControlFlow flow)
static java.util.List<PsiVariable>	getUsedVariables(ControlFlow flow, int start, int end)
static boolean[]	getVariablePossiblyUnassignedOffsets(PsiVariable variable, ControlFlow flow) Returns offsets starting from which the variable could be unassigned
static java.util.Map<PsiElement,PsiVariable>	getWritesBeforeReads(ControlFlow flow, java.util.Set<? extends PsiVariable> writeVars, java.util.Set<? extends PsiVariable> readVars, int stopPoint) Find locations of writes of variables from writeVars that happened before one of reads of variables from readVars.
static java.util.Collection<PsiVariable>	getWrittenVariables(ControlFlow flow, int start, int end, boolean ignoreNotReachingWrites)
static void	getWrittenVariables(ControlFlow flow, int start, int end, boolean ignoreNotReachingWrites, java.util.Collection<? super PsiVariable> set)
static boolean	hasObservableThrowExitPoints(ControlFlow flow, int flowStart, int flowEnd, PsiElement [] elements, PsiElement enclosingCodeFragment) Detect throw instructions which might affect observable control flow via side effects with local variables.
static boolean	isDominator(ControlFlow flow, int maybeDominator, int target) Returns true of instruction at given offset is a dominator for target instruction (that is: execution from flow start to the target always goes through given offset).
static boolean	isInstructionReachable(ControlFlow flow, int instructionOffset, int startOffset)
static boolean	isValueUsedWithoutVisitingStop(ControlFlow flow, int start, int stop, PsiVariable variable) Returns true if the value the variable has at start is later referenced without going through stop instruction
static boolean	isVariableAccess(ControlFlow flow, int offset, PsiVariable variable) Checks if the control flow instruction at given offset accesses (reads or writes) given variable
static boolean	isVariableAssignedInLoop(PsiReferenceExpression expression, PsiElement resolved)
static boolean	isVariableDefinitelyAssigned(PsiVariable variable, ControlFlow flow)
static boolean	isVariableDefinitelyNotAssigned(PsiVariable variable, ControlFlow flow)
static boolean	isVariableReadInFinally(ControlFlow flow, PsiElement startElement, PsiElement enclosingCodeFragment, PsiVariable variable)
static boolean	isVariableUsed(ControlFlow flow, int start, int end, PsiVariable variable)
static boolean	needVariableValueAt(PsiVariable variable, ControlFlow flow, int offset)
static boolean	processReturns(ControlFlow flow, ReturnStatementsVisitor afterVisitor)
static boolean	returnPresent(ControlFlow flow)
static boolean	returnPresentBetween(ControlFlow flow, int startOffset, int endOffset)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

DEFAULT_EXIT_STATEMENTS_CLASSES

public static final java.lang.Class<? extends PsiStatement>[] DEFAULT_EXIT_STATEMENTS_CLASSES

NORMAL_COMPLETION_REASON

public static final int NORMAL_COMPLETION_REASON

See Also:

Constant Field Values

Constructor Detail

ControlFlowUtil

public ControlFlowUtil()

Method Detail

getSSAVariables

public static java.util.List<PsiVariable> getSSAVariables(ControlFlow flow)

getSSAVariables

public static java.util.List<PsiVariable> getSSAVariables(ControlFlow flow,
                                                          int from,
                                                          int to,
                                                          boolean reportVarsIfNonInitializingPathExists)

needVariableValueAt

public static boolean needVariableValueAt(PsiVariable variable,
                                          ControlFlow flow,
                                          int offset)

getWrittenVariables

public static java.util.Collection<PsiVariable> getWrittenVariables(ControlFlow flow,
                                                                    int start,
                                                                    int end,
                                                                    boolean ignoreNotReachingWrites)

getWrittenVariables

public static void getWrittenVariables(ControlFlow flow,
                                       int start,
                                       int end,
                                       boolean ignoreNotReachingWrites,
                                       java.util.Collection<? super PsiVariable> set)

getUsedVariables

public static java.util.List<PsiVariable> getUsedVariables(ControlFlow flow,
                                                           int start,
                                                           int end)

isVariableUsed

public static boolean isVariableUsed(ControlFlow flow,
                                     int start,
                                     int end,
                                     PsiVariable variable)

findSingleReadOccurrence

public static PsiReferenceExpression findSingleReadOccurrence(ControlFlow flow,
                                                              PsiElement element,
                                                              PsiVariable variable)

If the variable occurs only once in the element and it's read access return that occurrence

isVariableReadInFinally

public static boolean isVariableReadInFinally(ControlFlow flow,
                                              PsiElement startElement,
                                              PsiElement enclosingCodeFragment,
                                              PsiVariable variable)

getInputVariables

public static java.util.List<PsiVariable> getInputVariables(ControlFlow flow,
                                                            int start,
                                                            int end)

getOutputVariables

public static PsiVariable [] getOutputVariables(ControlFlow flow,
                                                int start,
                                                int end,
                                                int [] exitPoints)

findExitPointsAndStatements

@SafeVarargs
public static java.util.Collection<PsiStatement> findExitPointsAndStatements(ControlFlow flow,
                                                                             int start,
                                                                             int end,
                                                                             IntArrayList exitPoints,
                                                                             java.lang.Class<? extends PsiStatement>... classesFilter)

hasObservableThrowExitPoints

public static boolean hasObservableThrowExitPoints(ControlFlow flow,
                                                   int flowStart,
                                                   int flowEnd,
                                                   PsiElement [] elements,
                                                   PsiElement enclosingCodeFragment)

Detect throw instructions which might affect observable control flow via side effects with local variables. The side effect of exception thrown occurs when a local variable is written in the try block, and then accessed in the finally section or in/after a catch section. Example:

 { // --- start of theOuterBlock ---
   Status status = STARTED;
   try { // --- start of theTryBlock ---
     status = PREPARING;
     doPrepare(); // may throw exception
     status = WORKING;
     doWork(); // may throw exception
     status = FINISHED;
   } // --- end of theTryBlock ---
   catch (Exception e) {
      LOG.error("Failed when " + status, e); // can get PREPARING or WORKING here
   }
   if (status == FINISHED) LOG.info("Finished"); // can get PREPARING or WORKING here in the case of exception
 } // --- end of theOuterBlock ---
 

In the example above hasObservableThrowExitPoints(theTryBlock) == true, because the resulting value of the "status" variable depends on the exceptions being thrown. In the same example hasObservableThrowExitPoints(theOuterBlock) == false, because no outgoing variables here depend on the exceptions being thrown.

findCodeFragment

public static PsiElement findCodeFragment(PsiElement element)

collectOuterLocals

public static boolean collectOuterLocals(java.util.List<? super PsiVariable> array,
                                         PsiElement scope,
                                         PsiElement member,
                                         PsiElement targetClassMember)

Checks possibility of extracting code fragment outside containing anonymous (local) class. Also collects variables to be passed as additional parameters.

Parameters:

array - Vector to collect variables to be passed as additional parameters

scope - scope to be scanned (part of code fragment to be extracted)

member - member containing the code to be extracted

targetClassMember - member in target class containing code fragment

Returns:

true if code fragment can be extracted outside

returnPresent

public static boolean returnPresent(ControlFlow flow)

Returns:

true if each control flow path results in return statement or exception thrown

processReturns

public static boolean processReturns(ControlFlow flow,
                                     ReturnStatementsVisitor afterVisitor)
                              throws IncorrectOperationException

Throws:

IncorrectOperationException

returnPresentBetween

public static boolean returnPresentBetween(ControlFlow flow,
                                           int startOffset,
                                           int endOffset)

canCompleteNormally

public static boolean canCompleteNormally(ControlFlow flow,
                                          int startOffset,
                                          int endOffset)

returns true iff exists control flow path completing normally, i.e. not resulting in return,break,continue or exception thrown. In other words, if we add instruction after controlflow specified, it should be reachable

getUnreachableStatement

public static PsiElement getUnreachableStatement(ControlFlow flow)

Returns:

any unreachable statement or null

isDominator

public static boolean isDominator(ControlFlow flow,
                                  int maybeDominator,
                                  int target)

Returns true of instruction at given offset is a dominator for target instruction (that is: execution from flow start to the target always goes through given offset).

Parameters:

flow - control flow to analyze

maybeDominator - a dominator candidate offset

target - a target instruction offset

Returns:

true if instruction at maybeDominator offset is actually a dominator.

isVariableDefinitelyAssigned

public static boolean isVariableDefinitelyAssigned(PsiVariable variable,
                                                   ControlFlow flow)

getVariablePossiblyUnassignedOffsets

public static boolean[] getVariablePossiblyUnassignedOffsets(PsiVariable variable,
                                                             ControlFlow flow)

Returns offsets starting from which the variable could be unassigned

Parameters:

variable - variable to check

flow - control flow

Returns:

a boolean array which values correspond to control flow offset. True value means that variable could be unassigned when execution starts from given offset.

isVariableDefinitelyNotAssigned

public static boolean isVariableDefinitelyNotAssigned(PsiVariable variable,
                                                      ControlFlow flow)

isValueUsedWithoutVisitingStop

public static boolean isValueUsedWithoutVisitingStop(ControlFlow flow,
                                                     int start,
                                                     int stop,
                                                     PsiVariable variable)

Returns true if the value the variable has at start is later referenced without going through stop instruction

Parameters:

flow - ControlFlow to analyze

start - the point at which variable value is created

stop - the stop-point

variable - the variable to examine

Returns:

true if the value the variable has at start is later referenced without going through stop instruction

isVariableAccess

public static boolean isVariableAccess(ControlFlow flow,
                                       int offset,
                                       PsiVariable variable)

Checks if the control flow instruction at given offset accesses (reads or writes) given variable

Parameters:

flow - control flow

offset - offset inside given control flow

variable - a variable the access to which is to be checked

Returns:

true if the given instruction is actually a variable access

getEdges

public static java.util.List<ControlFlowUtil.ControlFlowEdge> getEdges(ControlFlow flow,
                                                                       int start)

Returns control flow edges which are potentially reachable from start instruction

Parameters:

flow - control flow to analyze

start - starting instruction offset

Returns:

a list of edges

getMinDefinitelyReachedOffset

public static int getMinDefinitelyReachedOffset(ControlFlow flow,
                                                int sourceOffset,
                                                java.util.List<? extends PsiElement> references)

Returns:

min offset after sourceOffset which is definitely reachable from all references

getReadBeforeWriteLocals

public static java.util.List<PsiReferenceExpression> getReadBeforeWriteLocals(ControlFlow flow)

Returns:

list of PsiReferenceExpression of usages of non-initialized local variables

getReadBeforeWrite

public static java.util.List<PsiReferenceExpression> getReadBeforeWrite(ControlFlow flow)

getCompletionReasons

public static int getCompletionReasons(ControlFlow flow,
                                       int offset,
                                       int endOffset)

return reasons.normalCompletion when block can complete normally reasons.returnCalled when block can complete abruptly because of return statement executed

getInitializedTwice

public static java.util.Collection<ControlFlowUtil.VariableInfo> getInitializedTwice(ControlFlow flow)

getInitializedTwice

public static java.util.Collection<ControlFlowUtil.VariableInfo> getInitializedTwice(ControlFlow flow,
                                                                                     int startOffset,
                                                                                     int endOffset)

getWritesBeforeReads

public static java.util.Map<PsiElement,PsiVariable> getWritesBeforeReads(ControlFlow flow,
                                                                         java.util.Set<? extends PsiVariable> writeVars,
                                                                         java.util.Set<? extends PsiVariable> readVars,
                                                                         int stopPoint)

Find locations of writes of variables from writeVars that happened before one of reads of variables from readVars.

Parameters:

stopPoint - point until which reads are considered

Returns:

locations of writes

isInstructionReachable

public static boolean isInstructionReachable(ControlFlow flow,
                                             int instructionOffset,
                                             int startOffset)

Returns:

true if instruction at 'instructionOffset' is reachable from offset 'startOffset'

isVariableAssignedInLoop

public static boolean isVariableAssignedInLoop(PsiReferenceExpression expression,
                                               PsiElement resolved)

areVariablesUnmodifiedAtLocations

public static boolean areVariablesUnmodifiedAtLocations(ControlFlow flow,
                                                        int startOffset,
                                                        int endOffset,
                                                        java.util.Set<? extends PsiVariable> variables,
                                                        java.lang.Iterable<? extends PsiElement> locations)

Check that in the flow between startOffset and endOffset there are no writes to the variables or these writes aren't observable at the locations.