@Override
public boolean applyCondition(DfaValue dfaCond) {
if (dfaCond instanceof DfaUnknownValue) return true;
if (dfaCond instanceof DfaUnboxedValue) {
DfaVariableValue dfaVar = ((DfaUnboxedValue) dfaCond).getVariable();
boolean isNegated = dfaVar.isNegated();
DfaVariableValue dfaNormalVar = isNegated ? dfaVar.createNegated() : dfaVar;
final DfaValue boxedTrue =
myFactory.getBoxedFactory().createBoxed(myFactory.getConstFactory().getTrue());
return applyRelationCondition(
myFactory
.getRelationFactory()
.createRelation(dfaNormalVar, boxedTrue, JavaTokenType.EQEQ, isNegated));
}
if (dfaCond instanceof DfaVariableValue) {
DfaVariableValue dfaVar = (DfaVariableValue) dfaCond;
boolean isNegated = dfaVar.isNegated();
DfaVariableValue dfaNormalVar = isNegated ? dfaVar.createNegated() : dfaVar;
DfaConstValue dfaTrue = myFactory.getConstFactory().getTrue();
return applyRelationCondition(
myFactory
.getRelationFactory()
.createRelation(dfaNormalVar, dfaTrue, JavaTokenType.EQEQ, isNegated));
}
if (dfaCond instanceof DfaConstValue) {
return dfaCond == myFactory.getConstFactory().getTrue()
|| dfaCond != myFactory.getConstFactory().getFalse();
}
if (!(dfaCond instanceof DfaRelationValue)) return true;
return applyRelationCondition((DfaRelationValue) dfaCond);
}
private boolean applyBoxedRelation(
@NotNull DfaVariableValue dfaLeft, DfaValue dfaRight, boolean negated) {
if (!TypeConversionUtil.isPrimitiveAndNotNull(dfaLeft.getVariableType())) return true;
DfaBoxedValue.Factory boxedFactory = myFactory.getBoxedFactory();
DfaValue boxedLeft = boxedFactory.createBoxed(dfaLeft);
DfaValue boxedRight = boxedFactory.createBoxed(dfaRight);
return boxedLeft == null || boxedRight == null || applyRelation(boxedLeft, boxedRight, negated);
}
@NotNull
private DfaValue getMethodResultValue(
MethodCallInstruction instruction,
@Nullable DfaValue qualifierValue,
DfaValueFactory factory) {
DfaValue precalculated = instruction.getPrecalculatedReturnValue();
if (precalculated != null) {
return precalculated;
}
final PsiType type = instruction.getResultType();
final MethodCallInstruction.MethodType methodType = instruction.getMethodType();
if (methodType == MethodCallInstruction.MethodType.UNBOXING) {
return factory.getBoxedFactory().createUnboxed(qualifierValue);
}
if (methodType == MethodCallInstruction.MethodType.BOXING) {
DfaValue boxed = factory.getBoxedFactory().createBoxed(qualifierValue);
return boxed == null ? factory.createTypeValue(type, Nullness.NOT_NULL) : boxed;
}
if (methodType == MethodCallInstruction.MethodType.CAST) {
assert qualifierValue != null;
if (qualifierValue instanceof DfaConstValue) {
Object casted =
TypeConversionUtil.computeCastTo(((DfaConstValue) qualifierValue).getValue(), type);
return factory
.getConstFactory()
.createFromValue(casted, type, ((DfaConstValue) qualifierValue).getConstant());
}
return qualifierValue;
}
if (type != null && (type instanceof PsiClassType || type.getArrayDimensions() > 0)) {
Nullness nullability = myReturnTypeNullability.get(instruction);
if (nullability == Nullness.UNKNOWN && factory.isUnknownMembersAreNullable()) {
nullability = Nullness.NULLABLE;
}
return factory.createTypeValue(type, nullability);
}
return DfaUnknownValue.getInstance();
}
private boolean applyUnboxedRelation(
@NotNull DfaVariableValue dfaLeft, DfaValue dfaRight, boolean negated) {
PsiType type = dfaLeft.getVariableType();
if (!TypeConversionUtil.isPrimitiveWrapper(type)) {
return true;
}
if (negated) {
// from the fact "wrappers are not the same" it does not follow that "unboxed values are not
// equal"
return true;
}
DfaBoxedValue.Factory boxedFactory = myFactory.getBoxedFactory();
DfaValue unboxedLeft = boxedFactory.createUnboxed(dfaLeft);
DfaValue unboxedRight = boxedFactory.createUnboxed(dfaRight);
return applyRelation(unboxedLeft, unboxedRight, false)
&& checkCompareWithBooleanLiteral(unboxedLeft, unboxedRight, false);
}