@Override
public boolean isMethodOnlyCallsSuper(PsiMethod method) {
boolean hasStatements = false;
PsiCodeBlock body = method.getBody();
if (body != null) {
PsiStatement[] statements = body.getStatements();
for (PsiStatement statement : statements) {
boolean isCallToSameSuper = false;
if (statement instanceof PsiExpressionStatement) {
isCallToSameSuper =
isCallToSuperMethod(((PsiExpressionStatement) statement).getExpression(), method);
} else if (statement instanceof PsiReturnStatement) {
PsiExpression expression = ((PsiReturnStatement) statement).getReturnValue();
isCallToSameSuper = expression == null || isCallToSuperMethod(expression, method);
}
hasStatements = true;
if (isCallToSameSuper) continue;
return false;
}
}
if (hasStatements) {
final PsiMethod[] superMethods = method.findSuperMethods();
for (PsiMethod superMethod : superMethods) {
if (VisibilityUtil.compare(
VisibilityUtil.getVisibilityModifier(superMethod.getModifierList()),
VisibilityUtil.getVisibilityModifier(method.getModifierList()))
> 0) return false;
}
}
return hasStatements;
}
private static void checkSuperclassMembers(
PsiClass superClass,
MemberInfoBase<? extends PsiMember>[] infos,
MultiMap<PsiElement, String> conflictsList) {
for (MemberInfoBase<? extends PsiMember> info : infos) {
PsiMember member = info.getMember();
boolean isConflict = false;
if (member instanceof PsiField) {
String name = member.getName();
isConflict = superClass.findFieldByName(name, false) != null;
} else if (member instanceof PsiMethod) {
PsiSubstitutor superSubstitutor =
TypeConversionUtil.getSuperClassSubstitutor(
superClass, member.getContainingClass(), PsiSubstitutor.EMPTY);
MethodSignature signature = ((PsiMethod) member).getSignature(superSubstitutor);
final PsiMethod superClassMethod =
MethodSignatureUtil.findMethodBySignature(superClass, signature, false);
isConflict = superClassMethod != null;
}
if (isConflict) {
String message =
RefactoringBundle.message(
"0.already.contains.a.1",
RefactoringUIUtil.getDescription(superClass, false),
RefactoringUIUtil.getDescription(member, false));
message = CommonRefactoringUtil.capitalize(message);
conflictsList.putValue(superClass, message);
}
if (member instanceof PsiMethod) {
final PsiMethod method = (PsiMethod) member;
final PsiModifierList modifierList = method.getModifierList();
if (!modifierList.hasModifierProperty(PsiModifier.PRIVATE)) {
for (PsiClass subClass : ClassInheritorsSearch.search(superClass)) {
if (method.getContainingClass() != subClass) {
MethodSignature signature =
((PsiMethod) member)
.getSignature(
TypeConversionUtil.getSuperClassSubstitutor(
superClass, subClass, PsiSubstitutor.EMPTY));
final PsiMethod wouldBeOverriden =
MethodSignatureUtil.findMethodBySignature(subClass, signature, false);
if (wouldBeOverriden != null
&& VisibilityUtil.compare(
VisibilityUtil.getVisibilityModifier(wouldBeOverriden.getModifierList()),
VisibilityUtil.getVisibilityModifier(modifierList))
> 0) {
conflictsList.putValue(
wouldBeOverriden,
CommonRefactoringUtil.capitalize(
RefactoringUIUtil.getDescription(method, true)
+ " in super class would clash with local method from "
+ RefactoringUIUtil.getDescription(subClass, true)));
}
}
}
}
}
}
}
