private boolean hardEquals(
PsiModifierListOwner psiVar, PsiType varType, boolean negated, DfaVariableValue qualifier) {
return psiVar == myVariable
&& Comparing.equal(
TypeConversionUtil.erasure(varType), TypeConversionUtil.erasure(myVarType))
&& negated == myIsNegated
&& (myQualifier == null
? qualifier == null
: myQualifier.hardEquals(
qualifier.getPsiVariable(),
qualifier.getVariableType(),
qualifier.isNegated(),
qualifier.getQualifier()));
}
public boolean isFlushableByCalls() {
if (myVariable instanceof PsiLocalVariable || myVariable instanceof PsiParameter) return false;
if (myVariable instanceof PsiVariable && myVariable.hasModifierProperty(PsiModifier.FINAL)) {
return myQualifier != null && myQualifier.isFlushableByCalls();
}
return true;
}
@NotNull
public DfaVariableValue createVariableValue(
@NotNull PsiModifierListOwner myVariable,
@Nullable PsiType varType,
boolean isNegated,
@Nullable DfaVariableValue qualifier) {
Trinity<Boolean, String, DfaVariableValue> key =
Trinity.create(isNegated, ((PsiNamedElement) myVariable).getName(), qualifier);
for (DfaVariableValue aVar : myExistingVars.get(key)) {
if (aVar.hardEquals(myVariable, varType, isNegated, qualifier)) return aVar;
}
DfaVariableValue result =
new DfaVariableValue(myVariable, varType, isNegated, myFactory, qualifier);
myExistingVars.putValue(key, result);
while (qualifier != null) {
qualifier.myDependents.add(result);
qualifier = qualifier.getQualifier();
}
return result;
}
public boolean containsCalls() {
return myVariable instanceof PsiMethod || myQualifier != null && myQualifier.containsCalls();
}
@SuppressWarnings({"HardCodedStringLiteral"})
public String toString() {
return (myIsNegated ? "!" : "")
+ ((PsiNamedElement) myVariable).getName()
+ (myQualifier == null ? "" : "|" + myQualifier.toString());
}
