@Override
public void onInitialize(RefElement refElement) {
((RefElementImpl) refElement).setFlag(true, CAN_BE_FINAL_MASK);
if (refElement instanceof RefClass) {
final RefClass refClass = (RefClass) refElement;
final PsiClass psiClass = refClass.getElement();
if (refClass.isEntry()) {
((RefClassImpl) refClass).setFlag(false, CAN_BE_FINAL_MASK);
return;
}
if (refClass.isAbstract() || refClass.isAnonymous() || refClass.isInterface()) {
((RefClassImpl) refClass).setFlag(false, CAN_BE_FINAL_MASK);
return;
}
if (!refClass.isSelfInheritor(psiClass)) {
for (PsiClass psiSuperClass : psiClass.getSupers()) {
if (myManager.belongsToScope(psiSuperClass)) {
RefClass refSuperClass = (RefClass) myManager.getReference(psiSuperClass);
if (refSuperClass != null) {
((RefClassImpl) refSuperClass).setFlag(false, CAN_BE_FINAL_MASK);
}
}
}
}
} else if (refElement instanceof RefMethod) {
final RefMethod refMethod = (RefMethod) refElement;
final PsiElement element = refMethod.getElement();
if (element instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) element;
if (refMethod.isConstructor()
|| refMethod.isAbstract()
|| refMethod.isStatic()
|| PsiModifier.PRIVATE.equals(refMethod.getAccessModifier())
|| refMethod.getOwnerClass().isAnonymous()
|| refMethod.getOwnerClass().isInterface()) {
((RefMethodImpl) refMethod).setFlag(false, CAN_BE_FINAL_MASK);
}
if (PsiModifier.PRIVATE.equals(refMethod.getAccessModifier())
&& refMethod.getOwner() != null
&& !(refMethod.getOwnerClass().getOwner() instanceof RefElement)) {
((RefMethodImpl) refMethod).setFlag(false, CAN_BE_FINAL_MASK);
}
for (PsiMethod psiSuperMethod : psiMethod.findSuperMethods()) {
if (myManager.belongsToScope(psiSuperMethod)) {
RefMethod refSuperMethod = (RefMethod) myManager.getReference(psiSuperMethod);
if (refSuperMethod != null) {
((RefMethodImpl) refSuperMethod).setFlag(false, CAN_BE_FINAL_MASK);
}
}
}
}
}
}
private boolean isAccessibleFrom(RefElement from, RefJavaElement to, String accessModifier) {
if (accessModifier == PsiModifier.PUBLIC) return true;
final RefJavaUtil refUtil = RefJavaUtil.getInstance();
if (accessModifier == PsiModifier.PACKAGE_LOCAL) {
return RefJavaUtil.getPackage(from) == RefJavaUtil.getPackage(to);
}
RefClass fromTopLevel = refUtil.getTopLevelClass(from);
RefClass toTopLevel = refUtil.getTopLevelClass(to);
RefClass fromOwner = refUtil.getOwnerClass(from);
RefClass toOwner = refUtil.getOwnerClass(to);
if (accessModifier == PsiModifier.PROTECTED) {
if (SUGGEST_PRIVATE_FOR_INNERS) {
return refUtil.isInheritor(fromTopLevel, toOwner)
|| fromOwner != null && refUtil.isInheritor(fromOwner, toTopLevel)
|| toOwner != null && refUtil.getOwnerClass(toOwner) == from;
}
return refUtil.isInheritor(fromTopLevel, toOwner);
}
if (accessModifier == PsiModifier.PRIVATE) {
if (SUGGEST_PRIVATE_FOR_INNERS) {
if (isInExtendsList(to, fromTopLevel.getElement().getExtendsList())) return false;
if (isInExtendsList(to, fromTopLevel.getElement().getImplementsList())) return false;
if (isInAnnotations(to, fromTopLevel)) return false;
return fromTopLevel == toOwner
|| fromOwner == toTopLevel
|| toOwner != null && refUtil.getOwnerClass(toOwner) == from;
}
if (fromOwner != null
&& fromOwner.isStatic()
&& !to.isStatic()
&& refUtil.isInheritor(fromOwner, toOwner)) return false;
if (fromTopLevel == toOwner) {
if (from instanceof RefClass && to instanceof RefClass) {
final PsiClass fromClass = ((RefClass) from).getElement();
LOG.assertTrue(fromClass != null);
if (isInExtendsList(to, fromClass.getExtendsList())) return false;
if (isInExtendsList(to, fromClass.getImplementsList())) return false;
}
return true;
}
}
return false;
}
private static boolean isInAnnotations(final RefJavaElement to, final RefClass fromTopLevel) {
final PsiModifierList modifierList = fromTopLevel.getElement().getModifierList();
if (modifierList == null) return false;
final PsiElement toElement = to.getElement();
final boolean[] resolved = new boolean[] {false};
modifierList.accept(
new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitReferenceExpression(PsiReferenceExpression expression) {
if (resolved[0]) return;
super.visitReferenceExpression(expression);
if (expression.resolve() == toElement) {
resolved[0] = true;
}
}
});
return resolved[0];
}
