public void buildReferences() {
PsiClass psiClass = getElement();
if (psiClass != null) {
for (PsiClassInitializer classInitializer : psiClass.getInitializers()) {
RefJavaUtil.getInstance().addReferences(psiClass, this, classInitializer.getBody());
}
RefJavaUtil.getInstance().addReferences(psiClass, this, psiClass.getModifierList());
PsiField[] psiFields = psiClass.getFields();
for (PsiField psiField : psiFields) {
getRefManager().getReference(psiField);
final PsiExpression initializer = psiField.getInitializer();
if (initializer != null) {
RefJavaUtil.getInstance().addReferences(psiClass, this, initializer);
}
}
PsiMethod[] psiMethods = psiClass.getMethods();
for (PsiMethod psiMethod : psiMethods) {
getRefManager().getReference(psiMethod);
}
getRefManager().fireBuildReferences(this);
}
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
final PsiElement element = descriptor.getPsiElement();
final PsiModifierListOwner psiElement =
PsiTreeUtil.getParentOfType(element, PsiModifierListOwner.class);
if (psiElement != null) {
RefJavaElement refElement =
(RefJavaElement) (myManager != null ? myManager.getReference(psiElement) : null);
try {
if (psiElement instanceof PsiVariable) {
((PsiVariable) psiElement).normalizeDeclaration();
}
final PsiModifierList modifierList = psiElement.getModifierList();
LOG.assertTrue(modifierList != null);
modifierList.setModifierProperty(PsiModifier.FINAL, true);
modifierList.setModifierProperty(PsiModifier.VOLATILE, false);
} catch (IncorrectOperationException e) {
LOG.error(e);
}
if (refElement != null) {
RefJavaUtil.getInstance().setIsFinal(refElement, true);
}
}
}
@Nullable
@PsiModifier.ModifierConstant
public String getPossibleAccess(@Nullable RefJavaElement refElement) {
if (refElement == null) return null;
String curAccess = refElement.getAccessModifier();
String weakestAccess = PsiModifier.PRIVATE;
if (isTopLevelClass(refElement) || isCalledOnSubClasses(refElement)) {
weakestAccess = PsiModifier.PACKAGE_LOCAL;
}
if (isAbstractMethod(refElement)) {
weakestAccess = PsiModifier.PROTECTED;
}
if (curAccess == weakestAccess) return curAccess;
while (true) {
String weakerAccess = getWeakerAccess(curAccess, refElement);
if (weakerAccess == null
|| RefJavaUtil.getInstance().compareAccess(weakerAccess, weakestAccess) < 0) break;
if (isAccessible(refElement, weakerAccess)) {
curAccess = weakerAccess;
} else {
break;
}
}
return curAccess;
}
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 boolean isAccessible(
RefJavaElement to, @PsiModifier.ModifierConstant String accessModifier) {
for (RefElement refElement : to.getInReferences()) {
if (!isAccessibleFrom(refElement, to, accessModifier)) return false;
}
if (to instanceof RefMethod) {
RefMethod refMethod = (RefMethod) to;
if (refMethod.isAbstract()
&& (refMethod.getDerivedMethods().isEmpty()
|| refMethod.getAccessModifier() == PsiModifier.PRIVATE)) return false;
for (RefMethod refOverride : refMethod.getDerivedMethods()) {
if (!isAccessibleFrom(refOverride, to, accessModifier)) return false;
}
for (RefMethod refSuper : refMethod.getSuperMethods()) {
if (RefJavaUtil.getInstance().compareAccess(refSuper.getAccessModifier(), accessModifier)
> 0) return false;
}
}
if (to instanceof RefClass) {
RefClass refClass = (RefClass) to;
for (RefClass subClass : refClass.getSubClasses()) {
if (!isAccessibleFrom(subClass, to, accessModifier)) return false;
}
List children = refClass.getChildren();
if (children != null) {
for (Object refElement : children) {
if (!isAccessible((RefJavaElement) refElement, accessModifier)) return false;
}
}
for (final RefElement refElement : refClass.getInTypeReferences()) {
if (!isAccessibleFrom(refElement, refClass, accessModifier)) return false;
}
List<RefJavaElement> classExporters = ((RefClassImpl) refClass).getClassExporters();
if (classExporters != null) {
for (RefJavaElement refExporter : classExporters) {
if (getAccessLevel(accessModifier) < getAccessLevel(refExporter.getAccessModifier()))
return false;
}
}
}
return true;
}
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;
}
}
}
@Override
public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
if (!FileModificationService.getInstance()
.preparePsiElementForWrite(descriptor.getPsiElement())) return;
final PsiModifierListOwner element =
PsiTreeUtil.getParentOfType(descriptor.getPsiElement(), PsiModifierListOwner.class);
if (element != null) {
RefElement refElement = null;
if (myManager != null) {
refElement = myManager.getReference(element);
}
try {
if (element instanceof PsiVariable) {
((PsiVariable) element).normalizeDeclaration();
}
PsiModifierList list = element.getModifierList();
LOG.assertTrue(list != null);
if (element instanceof PsiMethod) {
PsiMethod psiMethod = (PsiMethod) element;
PsiClass containingClass = psiMethod.getContainingClass();
if (containingClass != null
&& containingClass.getParent() instanceof PsiFile
&& myHint == PsiModifier.PRIVATE
&& list.hasModifierProperty(PsiModifier.FINAL)) {
list.setModifierProperty(PsiModifier.FINAL, false);
}
}
list.setModifierProperty(myHint, true);
if (refElement instanceof RefJavaElement) {
RefJavaUtil.getInstance().setAccessModifier((RefJavaElement) refElement, myHint);
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
}
public void appendLocation(final RefEntity entity, final StringBuffer buf) {
RefEntity owner = entity.getOwner();
if (owner instanceof RefPackage) {
buf.append(InspectionsBundle.message("inspection.export.results.package"));
buf.append(HTMLComposerImpl.NBSP).append(HTMLComposerImpl.CODE_OPENING);
buf.append(RefJavaUtil.getInstance().getPackageName(entity));
buf.append(HTMLComposerImpl.CODE_CLOSING);
} else if (owner instanceof RefMethod) {
buf.append(InspectionsBundle.message("inspection.export.results.method"));
buf.append(HTMLComposerImpl.NBSP);
myComposer.appendElementReference(buf, (RefElement) owner);
} else if (owner instanceof RefField) {
buf.append(InspectionsBundle.message("inspection.export.results.field"));
buf.append(HTMLComposerImpl.NBSP);
myComposer.appendElementReference(buf, (RefElement) owner);
buf.append(HTMLComposerImpl.NBSP);
buf.append(InspectionsBundle.message("inspection.export.results.initializer"));
} else if (owner instanceof RefClass) {
appendClassOrInterface(buf, (RefClass) owner, false);
buf.append(HTMLComposerImpl.NBSP);
myComposer.appendElementReference(buf, (RefElement) owner);
}
}
@Override
public void buildReferences() {
// Work on code block to find what we're referencing...
PsiMethod method = (PsiMethod) getElement();
if (method == null) return;
PsiCodeBlock body = method.getBody();
final RefJavaUtil refUtil = RefJavaUtil.getInstance();
refUtil.addReferences(method, this, body);
refUtil.addReferences(method, this, method.getModifierList());
checkForSuperCall(method);
setOnlyCallsSuper(refUtil.isMethodOnlyCallsSuper(method));
setBodyEmpty(
isOnlyCallsSuper()
|| !isExternalOverride() && (body == null || body.getStatements().length == 0));
refUtil.addTypeReference(method, method.getReturnType(), getRefManager(), this);
for (RefParameter parameter : getParameters()) {
refUtil.setIsFinal(parameter, parameter.getElement().hasModifierProperty(PsiModifier.FINAL));
}
getRefManager().fireBuildReferences(this);
}
private static boolean isTopLevelClass(RefElement refElement) {
return refElement instanceof RefClass
&& RefJavaUtil.getInstance().getTopLevelClass(refElement) == refElement;
}