public DfaInstructionState[] visitMethodCall(
MethodCallInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
//noinspection UnusedDeclaration
for (PsiExpression arg : instruction.getArgs()) {
memState.pop();
}
memState.pop(); // qualifier
memState.push(DfaUnknownValue.getInstance());
return nextInstruction(instruction, runner, memState);
}
public DfaInstructionState[] visitBinop(
BinopInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
memState.pop();
memState.pop();
memState.push(DfaUnknownValue.getInstance());
return nextInstruction(instruction, runner, memState);
}
@Override
public DfaInstructionState[] visitAssign(
AssignInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
final Instruction nextInstruction = runner.getInstruction(instruction.getIndex() + 1);
final DfaValue dfaSource = memState.pop();
final DfaValue dfaDest = memState.pop();
if (dfaDest instanceof DfaVariableValue) {
DfaVariableValue var = (DfaVariableValue) dfaDest;
final PsiExpression rightValue = instruction.getRExpression();
final PsiElement parent = rightValue == null ? null : rightValue.getParent();
final IElementType type =
parent instanceof PsiAssignmentExpression
? ((PsiAssignmentExpression) parent).getOperationTokenType()
: JavaTokenType.EQ;
// store current value - to use in case of '+='
final PsiExpression prevValue =
((ValuableDataFlowRunner.ValuableDfaVariableState)
((ValuableDataFlowRunner.MyDfaMemoryState) memState).getVariableState(var))
.myExpression;
memState.setVarValue(var, dfaSource);
// state may have been changed so re-retrieve it
final ValuableDataFlowRunner.ValuableDfaVariableState curState =
(ValuableDataFlowRunner.ValuableDfaVariableState)
((ValuableDataFlowRunner.MyDfaMemoryState) memState).getVariableState(var);
final PsiExpression curValue = curState.myExpression;
final PsiExpression nextValue;
if (type == JavaTokenType.PLUSEQ && prevValue != null) {
PsiExpression tmpExpression;
try {
tmpExpression =
JavaPsiFacade.getElementFactory(myContext.getProject())
.createExpressionFromText(
prevValue.getText() + "+" + rightValue.getText(), rightValue);
} catch (Exception e) {
tmpExpression = curValue == null ? rightValue : curValue;
}
nextValue = tmpExpression;
} else {
nextValue = curValue == null ? rightValue : curValue;
}
curState.myExpression = nextValue;
}
memState.push(dfaDest);
return new DfaInstructionState[] {new DfaInstructionState(nextInstruction, memState)};
}
@Override
public DfaInstructionState[] visitCheckReturnValue(
CheckReturnValueInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
final DfaValue retValue = memState.pop();
checkNotNullable(
memState, retValue, NullabilityProblem.nullableReturn, instruction.getReturn());
return nextInstruction(instruction, runner, memState);
}
public DfaInstructionState[] visitNot(
NotInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
DfaValue dfaValue = memState.pop();
dfaValue = dfaValue.createNegated();
memState.push(dfaValue);
return nextInstruction(instruction, runner, memState);
}
@Override
public DfaInstructionState[] visitFieldReference(
FieldReferenceInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
final DfaValue qualifier = memState.pop();
if (!checkNotNullable(
memState, qualifier, NullabilityProblem.fieldAccessNPE, instruction.getElementToAssert())) {
forceNotNull(runner, memState, qualifier);
}
return nextInstruction(instruction, runner, memState);
}
private DfaValue popQualifier(
MethodCallInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
@NotNull final DfaValue qualifier = memState.pop();
boolean unboxing = instruction.getMethodType() == MethodCallInstruction.MethodType.UNBOXING;
NullabilityProblem problem =
unboxing ? NullabilityProblem.unboxingNullable : NullabilityProblem.callNPE;
PsiExpression anchor = unboxing ? instruction.getContext() : instruction.getCallExpression();
if (!checkNotNullable(memState, qualifier, problem, anchor)) {
forceNotNull(runner, memState, qualifier);
}
return qualifier;
}
@Override
public DfaInstructionState[] visitInstanceof(
InstanceofInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
memState.pop();
memState.pop();
memState.push(
new DfaInstanceofValue(
runner.getFactory(), instruction.getLeft(), instruction.getCastType()));
return new DfaInstructionState[] {
new DfaInstructionState(runner.getInstruction(instruction.getIndex() + 1), memState)
};
}
@Override
public DfaInstructionState[] visitAssign(
AssignInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
DfaValue dfaSource = memState.pop();
DfaValue dfaDest = memState.pop();
if (dfaDest instanceof DfaVariableValue) {
DfaVariableValue var = (DfaVariableValue) dfaDest;
DfaValueFactory factory = runner.getFactory();
if (dfaSource instanceof DfaVariableValue
&& factory.getVarFactory().getAllQualifiedBy(var).contains(dfaSource)) {
Nullness nullability =
memState.isNotNull(dfaSource)
? Nullness.NOT_NULL
: ((DfaVariableValue) dfaSource).getInherentNullability();
dfaSource =
factory.createTypeValue(((DfaVariableValue) dfaSource).getVariableType(), nullability);
}
if (var.getInherentNullability() == Nullness.NOT_NULL) {
checkNotNullable(
memState,
dfaSource,
NullabilityProblem.assigningToNotNull,
instruction.getRExpression());
}
final PsiModifierListOwner psi = var.getPsiVariable();
if (!(psi instanceof PsiField) || !psi.hasModifierProperty(PsiModifier.VOLATILE)) {
memState.setVarValue(var, dfaSource);
}
} else if (dfaDest instanceof DfaTypeValue && ((DfaTypeValue) dfaDest).isNotNull()) {
checkNotNullable(
memState, dfaSource, NullabilityProblem.assigningToNotNull, instruction.getRExpression());
}
memState.push(dfaDest);
return nextInstruction(instruction, runner, memState);
}
@Override
public DfaInstructionState[] visitBinop(
BinopInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
myReachable.add(instruction);
DfaValue dfaRight = memState.pop();
DfaValue dfaLeft = memState.pop();
final IElementType opSign = instruction.getOperationSign();
if (opSign != null) {
DfaInstructionState[] states =
handleConstantComparison(instruction, runner, memState, dfaRight, dfaLeft, opSign);
if (states == null) {
states = handleRelationBinop(instruction, runner, memState, dfaRight, dfaLeft);
}
if (states != null) {
return states;
}
if (PLUS == opSign) {
memState.push(instruction.getNonNullStringValue(runner.getFactory()));
} else {
if (instruction instanceof InstanceofInstruction) {
handleInstanceof((InstanceofInstruction) instruction, dfaRight, dfaLeft);
}
memState.push(DfaUnknownValue.getInstance());
}
} else {
memState.push(DfaUnknownValue.getInstance());
}
instruction.setTrueReachable(); // Not a branching instruction actually.
instruction.setFalseReachable();
return nextInstruction(instruction, runner, memState);
}
public DfaInstructionState[] visitConditionalGoto(
ConditionalGotoInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
DfaValue cond = memState.pop();
DfaValue condTrue;
DfaValue condFalse;
if (instruction.isNegated()) {
condFalse = cond;
condTrue = cond.createNegated();
} else {
condTrue = cond;
condFalse = cond.createNegated();
}
if (condTrue == runner.getFactory().getConstFactory().getTrue()) {
markBranchReachable(instruction, true);
return new DfaInstructionState[] {
new DfaInstructionState(runner.getInstruction(instruction.getOffset()), memState)
};
}
if (condFalse == runner.getFactory().getConstFactory().getTrue()) {
markBranchReachable(instruction, false);
return nextInstruction(instruction, runner, memState);
}
ArrayList<DfaInstructionState> result = new ArrayList<DfaInstructionState>();
DfaMemoryState thenState = memState.createCopy();
DfaMemoryState elseState = memState.createCopy();
if (thenState.applyCondition(condTrue)) {
result.add(
new DfaInstructionState(runner.getInstruction(instruction.getOffset()), thenState));
markBranchReachable(instruction, true);
}
if (elseState.applyCondition(condFalse)) {
result.add(
new DfaInstructionState(runner.getInstruction(instruction.getIndex() + 1), elseState));
markBranchReachable(instruction, false);
}
return result.toArray(new DfaInstructionState[result.size()]);
}
@Nullable
private DfaValue[] popCallArguments(
MethodCallInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
final PsiExpression[] args = instruction.getArgs();
PsiMethod method = instruction.getTargetMethod();
boolean varargCall = instruction.isVarArgCall();
DfaValue[] argValues;
if (method == null || instruction.getContracts().isEmpty()) {
argValues = null;
} else {
int paramCount = method.getParameterList().getParametersCount();
if (paramCount == args.length || method.isVarArgs() && args.length >= paramCount - 1) {
argValues = new DfaValue[paramCount];
if (varargCall) {
argValues[paramCount - 1] = DfaUnknownValue.getInstance();
}
} else {
argValues = null;
}
}
for (int i = 0; i < args.length; i++) {
final DfaValue arg = memState.pop();
int paramIndex = args.length - i - 1;
if (argValues != null && (paramIndex < argValues.length - 1 || !varargCall)) {
argValues[paramIndex] = arg;
}
PsiExpression expr = args[paramIndex];
Nullness requiredNullability = instruction.getArgRequiredNullability(expr);
if (requiredNullability == Nullness.NOT_NULL) {
if (!checkNotNullable(
memState, arg, NullabilityProblem.passingNullableToNotNullParameter, expr)) {
forceNotNull(runner, memState, arg);
}
} else if (requiredNullability == Nullness.UNKNOWN) {
checkNotNullable(
memState, arg, NullabilityProblem.passingNullableArgumentToNonAnnotatedParameter, expr);
}
}
return argValues;
}
@Override
public DfaInstructionState[] visitTypeCast(
TypeCastInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
final DfaValueFactory factory = runner.getFactory();
DfaValue dfaExpr = factory.createValue(instruction.getCasted());
if (dfaExpr != null) {
DfaTypeValue dfaType =
(DfaTypeValue) factory.createTypeValue(instruction.getCastTo(), Nullness.UNKNOWN);
DfaRelationValue dfaInstanceof =
factory.getRelationFactory().createRelation(dfaExpr, dfaType, INSTANCEOF_KEYWORD, false);
if (dfaInstanceof != null && !memState.applyInstanceofOrNull(dfaInstanceof)) {
onInstructionProducesCCE(instruction);
}
}
if (instruction.getCastTo() instanceof PsiPrimitiveType) {
memState.push(runner.getFactory().getBoxedFactory().createUnboxed(memState.pop()));
}
return nextInstruction(instruction, runner, memState);
}
public DfaInstructionState[] visitCheckReturnValue(
CheckReturnValueInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
memState.pop();
return nextInstruction(instruction, runner, memState);
}
public DfaInstructionState[] visitAssign(
AssignInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
memState.pop();
memState.push(memState.pop());
return nextInstruction(instruction, runner, memState);
}
public DfaInstructionState[] visitFieldReference(
FieldReferenceInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) {
memState.pop();
return nextInstruction(instruction, runner, memState);
}
