@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); }
public static String[] getAnnotationNames(PsiModifierListOwner psi) { List<String> annoNames = ContainerUtil.newArrayList(); final PsiModifierList modifierList = psi.getModifierList(); if (modifierList instanceof GrModifierList) { for (GrAnnotation annotation : ((GrModifierList) modifierList).getRawAnnotations()) { final String name = annotation.getShortName(); if (StringUtil.isNotEmpty(name)) { annoNames.add(name); } } } return ArrayUtil.toStringArray(annoNames); }
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(); } }
private void addAnnotations(PsiModifierListOwner from, SNode to) { ListSequence.fromList(SLinkOperations.getTargets(to, "annotation", true)) .addSequence( Sequence.fromIterable(Sequence.fromArray(from.getModifierList().getAnnotations())) .select( new ISelector<PsiAnnotation, SNode>() { public SNode select(PsiAnnotation it) { PsiAnnotation psiAnno = it; SNode anno = resolveAnnotation(psiAnno); if ((anno == null)) { return null; } ListSequence.fromList(SLinkOperations.getTargets(anno, "value", true)) .addSequence( Sequence.fromIterable( Sequence.fromArray( psiAnno.getParameterList().getAttributes())) .select( new ISelector<PsiNameValuePair, SNode>() { public SNode select(PsiNameValuePair it) { SNode annoParam = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.AnnotationInstanceValue", null); String paramName = it.getName(); annoParam.setReference( "key", new DynamicReference( "key", annoParam, null, paramName)); return annoParam; } })); return anno; } })); }
/** * 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()); } } } } }