@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
public static PsiAnnotation getAnnotation(
@NotNull PsiModifierListOwner field, @NotNull String annotationName) {
final PsiModifierList modifierList = field.getModifierList();
if (modifierList == null) return null;
return modifierList.findAnnotation(annotationName);
}
private static void annotate(
final PsiElementFactory factory,
final PsiModifierListOwner listOwner,
final String annotationQName)
throws IncorrectOperationException {
final PsiModifierList modifierList = listOwner.getModifierList();
LOG.assertTrue(modifierList != null);
modifierList.addAfter(factory.createAnnotationFromText("@" + annotationQName, listOwner), null);
}
public ModifierFix(
@NotNull PsiModifierListOwner owner,
@Modifier @NotNull String modifier,
boolean shouldHave,
boolean showContainingClass) {
super(owner.getModifierList());
myModifier = modifier;
myShouldHave = shouldHave;
myShowContainingClass = showContainingClass;
PsiVariable variable = owner instanceof PsiVariable ? (PsiVariable) owner : null;
myName = format(variable, owner.getModifierList());
myVariable =
variable == null
? null
: SmartPointerManager.getInstance(owner.getProject())
.createSmartPsiElementPointer(variable);
}
protected final void registerModifierError(
@NotNull String modifier, @NotNull PsiModifierListOwner parameter, Object... infos) {
final PsiModifierList modifiers = parameter.getModifierList();
if (modifiers == null) {
return;
}
final PsiElement[] children = modifiers.getChildren();
for (final PsiElement child : children) {
final String text = child.getText();
if (modifier.equals(text)) {
registerError(child, infos);
}
}
}
private static boolean hasAnnotation(
PsiModifierListOwner modifierListOwner, String qualifiedName) {
PsiModifierList modifierList = modifierListOwner.getModifierList();
if (modifierList != null) {
for (PsiAnnotation annotation : modifierList.getAnnotations()) {
if (annotation instanceof ClsAnnotationImpl) {
if (qualifiedName.equals(annotation.getQualifiedName())) {
return true;
}
}
}
}
return false;
}
private static void makeMemberPackageLocal(PsiElement element) {
final PsiElement parent = element.getParent();
final PsiReferenceExpression reference = (PsiReferenceExpression) parent;
final PsiModifierListOwner member = (PsiModifierListOwner) reference.resolve();
if (member == null) {
return;
}
final PsiModifierList modifiers = member.getModifierList();
if (modifiers == null) {
return;
}
modifiers.setModifierProperty(PsiModifier.PUBLIC, false);
modifiers.setModifierProperty(PsiModifier.PROTECTED, false);
modifiers.setModifierProperty(PsiModifier.PRIVATE, false);
}
@Override
public void invoke(
@NotNull Project project,
@NotNull PsiFile file,
@Nullable("is null when called from inspection") Editor editor,
@NotNull PsiElement startElement,
@NotNull PsiElement endElement) {
final PsiModifierListOwner myModifierListOwner = (PsiModifierListOwner) startElement;
final ExternalAnnotationsManager annotationsManager =
ExternalAnnotationsManager.getInstance(project);
final PsiModifierList modifierList = myModifierListOwner.getModifierList();
LOG.assertTrue(modifierList != null);
if (modifierList.findAnnotation(myAnnotation) != null) return;
final ExternalAnnotationsManager.AnnotationPlace annotationAnnotationPlace =
annotationsManager.chooseAnnotationsPlace(myModifierListOwner);
if (annotationAnnotationPlace == ExternalAnnotationsManager.AnnotationPlace.NOWHERE) return;
if (annotationAnnotationPlace == ExternalAnnotationsManager.AnnotationPlace.EXTERNAL) {
for (String fqn : myAnnotationsToRemove) {
annotationsManager.deannotate(myModifierListOwner, fqn);
}
annotationsManager.annotateExternally(myModifierListOwner, myAnnotation, file, myPairs);
} else {
final PsiFile containingFile = myModifierListOwner.getContainingFile();
if (!CodeInsightUtilBase.preparePsiElementForWrite(containingFile)) return;
for (String fqn : myAnnotationsToRemove) {
PsiAnnotation annotation = AnnotationUtil.findAnnotation(myModifierListOwner, fqn);
if (annotation != null) {
annotation.delete();
}
}
PsiAnnotation inserted = modifierList.addAnnotation(myAnnotation);
for (PsiNameValuePair pair : myPairs) {
inserted.setDeclaredAttributeValue(pair.getName(), pair.getValue());
}
JavaCodeStyleManager.getInstance(project).shortenClassReferences(inserted);
if (containingFile != file) {
UndoUtil.markPsiFileForUndo(file);
}
}
}
private void processEntry(
@Nullable JavaElementArrangementEntry entry,
@Nullable PsiModifierListOwner modifier,
@Nullable PsiElement nextPsiRoot) {
if (entry == null) {
return;
}
if (modifier != null) {
parseModifiers(modifier.getModifierList(), entry);
}
if (nextPsiRoot == null) {
return;
}
myStack.push(entry);
try {
nextPsiRoot.acceptChildren(this);
} finally {
myStack.pop();
}
}
/**
* 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);
}
});
}
@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);
}
}
}
@Override
public String getAccessModifier(PsiModifierListOwner psiElement) {
if (psiElement instanceof PsiParameter) return PsiModifier.PACKAGE_LOCAL;
PsiModifierList list = psiElement.getModifierList();
String result = PsiModifier.PACKAGE_LOCAL;
if (list != null) {
if (list.hasModifierProperty(PsiModifier.PRIVATE)) {
result = PsiModifier.PRIVATE;
} else if (list.hasModifierProperty(PsiModifier.PROTECTED)) {
result = PsiModifier.PROTECTED;
} else if (list.hasModifierProperty(PsiModifier.PUBLIC)) {
result = PsiModifier.PUBLIC;
} else if (psiElement.getParent() instanceof PsiClass) {
PsiClass ownerClass = (PsiClass) psiElement.getParent();
if (ownerClass.isInterface()) {
result = PsiModifier.PUBLIC;
}
}
}
return result;
}
public static boolean isDeprecatedByAnnotation(@NotNull PsiModifierListOwner owner) {
PsiModifierList modifierList = owner.getModifierList();
return modifierList != null && modifierList.findAnnotation("java.lang.Deprecated") != null;
}
@SuppressWarnings({"unchecked", "ConstantConditions"})
private void handleModifierList(final PsiElement el, final PsiElement replacement)
throws IncorrectOperationException {
// We want to copy all comments, including doc comments and modifier lists
// that are present in matched nodes but not present in search/replace
Map<String, String> newNameToSearchPatternNameMap = myContext.getNewName2PatternNameMap();
ModifierListOwnerCollector collector = new ModifierListOwnerCollector();
el.accept(collector);
Map<String, PsiNamedElement> originalNamedElements =
(Map<String, PsiNamedElement>) collector.namedElements.clone();
collector.namedElements.clear();
replacement.accept(collector);
Map<String, PsiNamedElement> replacedNamedElements =
(Map<String, PsiNamedElement>) collector.namedElements.clone();
collector.namedElements.clear();
if (originalNamedElements.size() == 0 && replacedNamedElements.size() == 0) {
Replacer.handleComments(el, replacement, myContext);
return;
}
final PsiStatement[] statements = getCodeBlock().getStatements();
if (statements.length > 0) {
statements[0].getParent().accept(collector);
}
Map<String, PsiNamedElement> searchedNamedElements =
(Map<String, PsiNamedElement>) collector.namedElements.clone();
collector.namedElements.clear();
for (String name : originalNamedElements.keySet()) {
PsiNamedElement originalNamedElement = originalNamedElements.get(name);
PsiNamedElement replacementNamedElement = replacedNamedElements.get(name);
String key = newNameToSearchPatternNameMap.get(name);
if (key == null) key = name;
PsiNamedElement searchNamedElement = searchedNamedElements.get(key);
if (replacementNamedElement == null
&& originalNamedElements.size() == 1
&& replacedNamedElements.size() == 1) {
replacementNamedElement = replacedNamedElements.entrySet().iterator().next().getValue();
}
PsiElement comment = null;
if (originalNamedElement instanceof PsiDocCommentOwner) {
comment = ((PsiDocCommentOwner) originalNamedElement).getDocComment();
if (comment == null) {
PsiElement prevElement = originalNamedElement.getPrevSibling();
if (prevElement instanceof PsiWhiteSpace) {
prevElement = prevElement.getPrevSibling();
}
if (prevElement instanceof PsiComment) {
comment = prevElement;
}
}
}
if (replacementNamedElement != null && searchNamedElement != null) {
Replacer.handleComments(originalNamedElement, replacementNamedElement, myContext);
}
if (comment != null
&& replacementNamedElement instanceof PsiDocCommentOwner
&& !(replacementNamedElement.getFirstChild() instanceof PsiDocComment)) {
final PsiElement nextSibling = comment.getNextSibling();
PsiElement prevSibling = comment.getPrevSibling();
replacementNamedElement.addRangeBefore(
prevSibling instanceof PsiWhiteSpace ? prevSibling : comment,
nextSibling instanceof PsiWhiteSpace ? nextSibling : comment,
replacementNamedElement.getFirstChild());
}
if (originalNamedElement instanceof PsiModifierListOwner
&& replacementNamedElement instanceof PsiModifierListOwner) {
PsiModifierList modifierList =
((PsiModifierListOwner) originalNamedElements.get(name)).getModifierList();
if (searchNamedElement instanceof PsiModifierListOwner) {
PsiModifierList modifierListOfSearchedElement =
((PsiModifierListOwner) searchNamedElement).getModifierList();
final PsiModifierListOwner modifierListOwner =
((PsiModifierListOwner) replacementNamedElement);
PsiModifierList modifierListOfReplacement = modifierListOwner.getModifierList();
if (modifierListOfSearchedElement.getTextLength() == 0
&& modifierListOfReplacement.getTextLength() == 0
&& modifierList.getTextLength() > 0) {
PsiElement space = modifierList.getNextSibling();
if (!(space instanceof PsiWhiteSpace)) {
space = createWhiteSpace(space);
}
modifierListOfReplacement.replace(modifierList);
// copy space after modifier list
if (space instanceof PsiWhiteSpace) {
modifierListOwner.addRangeAfter(space, space, modifierListOwner.getModifierList());
}
} else if (modifierListOfSearchedElement.getTextLength() == 0
&& modifierList.getTextLength() > 0) {
modifierListOfReplacement.addRange(
modifierList.getFirstChild(), modifierList.getLastChild());
}
}
}
}
}
