private void initializeSuperMethods(PsiMethod method) {
if (getRefManager().isOfflineView()) return;
for (PsiMethod psiSuperMethod : method.findSuperMethods()) {
if (getRefManager().belongsToScope(psiSuperMethod)) {
RefMethodImpl refSuperMethod = (RefMethodImpl) getRefManager().getReference(psiSuperMethod);
if (refSuperMethod != null) {
addSuperMethod(refSuperMethod);
refSuperMethod.markExtended(this);
}
} else {
setLibraryOverride(true);
}
}
}
public void updateThrowsList(PsiClassType exceptionType) {
if (!getSuperMethods().isEmpty()) {
for (RefMethod refSuper : getSuperMethods()) {
((RefMethodImpl) refSuper).updateThrowsList(exceptionType);
}
} else if (myUnThrownExceptions != null) {
if (exceptionType == null) {
myUnThrownExceptions = null;
return;
}
PsiClass exceptionClass = exceptionType.resolve();
JavaPsiFacade facade = JavaPsiFacade.getInstance(myManager.getProject());
for (int i = myUnThrownExceptions.size() - 1; i >= 0; i--) {
String exceptionFqn = myUnThrownExceptions.get(i);
PsiClass classType =
facade.findClass(
exceptionFqn, GlobalSearchScope.allScope(getRefManager().getProject()));
if (InheritanceUtil.isInheritorOrSelf(exceptionClass, classType, true)
|| InheritanceUtil.isInheritorOrSelf(classType, exceptionClass, true)) {
myUnThrownExceptions.remove(i);
}
}
if (myUnThrownExceptions.isEmpty()) myUnThrownExceptions = null;
}
}
public void setReturnValueUsed(boolean value) {
if (checkFlag(IS_RETURN_VALUE_USED_MASK) == value) return;
setFlag(value, IS_RETURN_VALUE_USED_MASK);
for (RefMethod refSuper : getSuperMethods()) {
((RefMethodImpl) refSuper).setReturnValueUsed(value);
}
}
public void markExtended(RefMethodImpl method) {
if (!getDerivedMethods().contains(method) && !method.getDerivedMethods().contains(this)) {
if (myDerivedMethods == null) {
myDerivedMethods = new ArrayList<RefMethod>(1);
}
myDerivedMethods.add(method);
}
}
public void addSuperMethod(RefMethodImpl refSuperMethod) {
if (!getSuperMethods().contains(refSuperMethod)
&& !refSuperMethod.getSuperMethods().contains(this)) {
if (mySuperMethods == null) {
mySuperMethods = new ArrayList<RefMethod>(1);
}
mySuperMethods.add(refSuperMethod);
}
}
public void updateReturnValueTemplate(PsiExpression expression) {
if (myReturnValueTemplate == null) return;
if (!getSuperMethods().isEmpty()) {
for (final RefMethod refMethod : getSuperMethods()) {
RefMethodImpl refSuper = (RefMethodImpl) refMethod;
refSuper.updateReturnValueTemplate(expression);
}
} else {
String newTemplate = null;
final RefJavaUtil refUtil = RefJavaUtil.getInstance();
if (expression instanceof PsiLiteralExpression) {
PsiLiteralExpression psiLiteralExpression = (PsiLiteralExpression) expression;
newTemplate = psiLiteralExpression.getText();
} else if (expression instanceof PsiReferenceExpression) {
PsiReferenceExpression referenceExpression = (PsiReferenceExpression) expression;
PsiElement resolved = referenceExpression.resolve();
if (resolved instanceof PsiField) {
PsiField psiField = (PsiField) resolved;
if (psiField.hasModifierProperty(PsiModifier.STATIC)
&& psiField.hasModifierProperty(PsiModifier.FINAL)
&& refUtil.compareAccess(refUtil.getAccessModifier(psiField), getAccessModifier())
>= 0) {
newTemplate =
PsiFormatUtil.formatVariable(
psiField,
PsiFormatUtilBase.SHOW_NAME
| PsiFormatUtilBase.SHOW_CONTAINING_CLASS
| PsiFormatUtilBase.SHOW_FQ_NAME,
PsiSubstitutor.EMPTY);
}
}
} else if (refUtil.isCallToSuperMethod(expression, (PsiMethod) getElement())) return;
//noinspection StringEquality
if (myReturnValueTemplate == RETURN_VALUE_UNDEFINED) {
myReturnValueTemplate = newTemplate;
} else if (!Comparing.equal(myReturnValueTemplate, newTemplate)) {
myReturnValueTemplate = null;
}
}
}
private void checkForSuperCall(PsiMethod method) {
if (isConstructor()) {
PsiCodeBlock body = method.getBody();
if (body == null) return;
PsiStatement[] statements = body.getStatements();
boolean isBaseExplicitlyCalled = false;
if (statements.length > 0) {
PsiStatement first = statements[0];
if (first instanceof PsiExpressionStatement) {
PsiExpression firstExpression = ((PsiExpressionStatement) first).getExpression();
if (firstExpression instanceof PsiMethodCallExpression) {
PsiExpression qualifierExpression =
((PsiMethodCallExpression) firstExpression)
.getMethodExpression()
.getQualifierExpression();
if (qualifierExpression instanceof PsiReferenceExpression) {
@NonNls String text = qualifierExpression.getText();
if ("super".equals(text) || text.equals("this")) {
isBaseExplicitlyCalled = true;
}
}
}
}
}
if (!isBaseExplicitlyCalled) {
for (RefClass superClass : getOwnerClass().getBaseClasses()) {
RefMethodImpl superDefaultConstructor =
(RefMethodImpl) superClass.getDefaultConstructor();
if (superDefaultConstructor != null) {
superDefaultConstructor.addInReference(this);
addOutReference(superDefaultConstructor);
}
}
}
}
}
public void updateParameterValues(PsiExpression[] args) {
if (isExternalOverride()) return;
if (!getSuperMethods().isEmpty()) {
for (RefMethod refSuper : getSuperMethods()) {
((RefMethodImpl) refSuper).updateParameterValues(args);
}
} else {
final RefParameter[] params = getParameters();
if (params.length <= args.length && params.length > 0) {
for (int i = 0; i < args.length; i++) {
RefParameter refParameter;
if (params.length <= i) {
refParameter = params[params.length - 1];
} else {
refParameter = params[i];
}
((RefParameterImpl) refParameter).updateTemplateValue(args[i]);
}
}
}
}