private static PsiAnnotation[] getHierarchyAnnotations(
PsiModifierListOwner listOwner, PsiModifierList modifierList) {
final Set<PsiAnnotation> all =
new HashSet<PsiAnnotation>() {
public boolean add(PsiAnnotation o) {
// don't overwrite "higher level" annotations
return !contains(o) && super.add(o);
}
};
if (listOwner instanceof PsiMethod) {
ContainerUtil.addAll(all, modifierList.getAnnotations());
SuperMethodsSearch.search((PsiMethod) listOwner, null, true, true)
.forEach(
new Processor<MethodSignatureBackedByPsiMethod>() {
public boolean process(final MethodSignatureBackedByPsiMethod superMethod) {
ContainerUtil.addAll(
all, superMethod.getMethod().getModifierList().getAnnotations());
return true;
}
});
return all.toArray(new PsiAnnotation[all.size()]);
}
if (listOwner instanceof PsiParameter) {
PsiParameter parameter = (PsiParameter) listOwner;
PsiElement declarationScope = parameter.getDeclarationScope();
PsiParameterList parameterList;
if (declarationScope instanceof PsiMethod
&& parameter.getParent()
== (parameterList = ((PsiMethod) declarationScope).getParameterList())) {
PsiMethod method = (PsiMethod) declarationScope;
final int parameterIndex = parameterList.getParameterIndex(parameter);
ContainerUtil.addAll(all, modifierList.getAnnotations());
SuperMethodsSearch.search(method, null, true, true)
.forEach(
new Processor<MethodSignatureBackedByPsiMethod>() {
public boolean process(final MethodSignatureBackedByPsiMethod superMethod) {
PsiParameter superParameter =
superMethod.getMethod().getParameterList().getParameters()[parameterIndex];
PsiModifierList modifierList = superParameter.getModifierList();
if (modifierList != null) {
ContainerUtil.addAll(all, modifierList.getAnnotations());
}
return true;
}
});
return all.toArray(new PsiAnnotation[all.size()]);
}
}
return modifierList.getAnnotations();
}
/**
* Returns all annotations for <code>listOwner</code>, possibly walking up the method hierarchy.
*
* @see com.intellij.codeInsight.AnnotationUtil#isAnnotated(com.intellij.psi.PsiModifierListOwner,
* java.lang.String, boolean)
*/
private static PsiAnnotation[] getAnnotations(
@NotNull final PsiModifierListOwner listOwner, final boolean inHierarchy) {
final PsiModifierList modifierList = listOwner.getModifierList();
if (modifierList == null) {
return PsiAnnotation.EMPTY_ARRAY;
}
if (!inHierarchy) {
return modifierList.getAnnotations();
}
return CachedValuesManager.getCachedValue(
listOwner,
new CachedValueProvider<PsiAnnotation[]>() {
@Nullable
@Override
public Result<PsiAnnotation[]> compute() {
return Result.create(
getHierarchyAnnotations(listOwner, modifierList),
PsiModificationTracker.MODIFICATION_COUNT);
}
});
}
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)));
}
}
}
}
}
}
}
