@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); } } }
private Nullness calcInherentNullability() { PsiModifierListOwner var = getPsiVariable(); Nullness nullability = DfaPsiUtil.getElementNullability(getVariableType(), var); if (nullability != Nullness.UNKNOWN) { return nullability; } Nullness defaultNullability = myFactory.isUnknownMembersAreNullable() && MEMBER_OR_METHOD_PARAMETER.accepts(var) ? Nullness.NULLABLE : Nullness.UNKNOWN; if (var instanceof PsiParameter && var.getParent() instanceof PsiForeachStatement) { PsiExpression iteratedValue = ((PsiForeachStatement) var.getParent()).getIteratedValue(); if (iteratedValue != null) { PsiType itemType = JavaGenericsUtil.getCollectionItemType(iteratedValue); if (itemType != null) { return DfaPsiUtil.getElementNullability(itemType, var); } } } if (var instanceof PsiField && DfaPsiUtil.isFinalField((PsiVariable) var) && myFactory.isHonorFieldInitializers()) { List<PsiExpression> initializers = DfaPsiUtil.findAllConstructorInitializers((PsiField) var); if (initializers.isEmpty()) { return defaultNullability; } boolean hasUnknowns = false; for (PsiExpression expression : initializers) { Nullness nullness = getFieldInitializerNullness(expression); if (nullness == Nullness.NULLABLE) { return Nullness.NULLABLE; } if (nullness == Nullness.UNKNOWN) { hasUnknowns = true; } } if (hasUnknowns) { if (DfaPsiUtil.isInitializedNotNull((PsiField) var)) { return Nullness.NOT_NULL; } return defaultNullability; } return Nullness.NOT_NULL; } return defaultNullability; }
public static boolean isInSynchronizedContext(PsiElement element) { final PsiElement context = PsiTreeUtil.getParentOfType(element, PsiMethod.class, PsiSynchronizedStatement.class); if (context instanceof PsiSynchronizedStatement) { return true; } if (context == null) { return false; } final PsiModifierListOwner modifierListOwner = (PsiModifierListOwner) context; return modifierListOwner.hasModifierProperty(PsiModifier.SYNCHRONIZED); }
static boolean isAnnotationEditable(@NotNull PsiElement element) { PsiModifierListOwner annotationOwner = getAnnotationOwner(element); PsiAnnotation annotation = findKotlinSignatureAnnotation(element); assert annotation != null; if (annotation.getContainingFile() == annotationOwner.getContainingFile()) { return annotation.isWritable(); } else { ExternalAnnotationsManager annotationsManager = ExternalAnnotationsManager.getInstance(element.getProject()); return annotationsManager.isExternalAnnotationWritable( annotationOwner, KOTLIN_SIGNATURE_ANNOTATION); } }
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); }
private static AllowedValues getAllowedValuesFromMagic( @NotNull PsiModifierListOwner element, @NotNull PsiType type, PsiAnnotation magic) { if (magic == null) return null; PsiAnnotationMemberValue[] allowedValues; final boolean canBeOred; if (TypeConversionUtil.getTypeRank(type) <= TypeConversionUtil.LONG_RANK) { PsiAnnotationMemberValue intValues = magic.findAttributeValue("intValues"); allowedValues = intValues instanceof PsiArrayInitializerMemberValue ? ((PsiArrayInitializerMemberValue) intValues).getInitializers() : PsiAnnotationMemberValue.EMPTY_ARRAY; if (allowedValues.length == 0) { PsiAnnotationMemberValue orValue = magic.findAttributeValue("flags"); allowedValues = orValue instanceof PsiArrayInitializerMemberValue ? ((PsiArrayInitializerMemberValue) orValue).getInitializers() : PsiAnnotationMemberValue.EMPTY_ARRAY; canBeOred = true; } else { canBeOred = false; } } else if (type.equals( PsiType.getJavaLangString( element.getManager(), GlobalSearchScope.allScope(element.getProject())))) { PsiAnnotationMemberValue strValuesAttr = magic.findAttributeValue("stringValues"); allowedValues = strValuesAttr instanceof PsiArrayInitializerMemberValue ? ((PsiArrayInitializerMemberValue) strValuesAttr).getInitializers() : PsiAnnotationMemberValue.EMPTY_ARRAY; canBeOred = false; } else { return null; // other types not supported } if (allowedValues.length != 0) { return new AllowedValues(allowedValues, canBeOred); } // last resort: try valuesFromClass PsiAnnotationMemberValue[] values = readFromClass("valuesFromClass", magic, type); boolean ored = false; if (values == null) { values = readFromClass("flagsFromClass", magic, type); ored = true; } if (values == null) return null; return new AllowedValues(values, ored); }
public boolean isFlushableByCalls() { if (myVariable instanceof PsiLocalVariable || myVariable instanceof PsiParameter) return false; if (myVariable instanceof PsiVariable && myVariable.hasModifierProperty(PsiModifier.FINAL)) { return myQualifier != null && myQualifier.isFlushableByCalls(); } return 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); }
@Override public void annotateExternally( @NotNull final PsiModifierListOwner listOwner, @NotNull final String annotationFQName, @NotNull final PsiFile fromFile, final PsiNameValuePair[] value) { final Project project = myPsiManager.getProject(); final PsiFile containingFile = listOwner.getContainingFile(); if (!(containingFile instanceof PsiJavaFile)) { return; } final String packageName = ((PsiJavaFile) containingFile).getPackageName(); final VirtualFile virtualFile = containingFile.getVirtualFile(); LOG.assertTrue(virtualFile != null); final List<OrderEntry> entries = ProjectRootManager.getInstance(project).getFileIndex().getOrderEntriesForFile(virtualFile); if (entries.isEmpty()) { return; } for (final OrderEntry entry : entries) { if (entry instanceof ModuleOrderEntry) continue; VirtualFile[] virtualFiles = AnnotationOrderRootType.getFiles(entry); virtualFiles = filterByReadOnliness(virtualFiles); if (virtualFiles.length > 0) { chooseRootAndAnnotateExternally( listOwner, annotationFQName, fromFile, project, packageName, virtualFile, virtualFiles, value); } else { if (ApplicationManager.getApplication().isUnitTestMode() || ApplicationManager.getApplication().isHeadlessEnvironment()) { return; } SwingUtilities.invokeLater( new Runnable() { @Override public void run() { setupRootAndAnnotateExternally( entry, project, listOwner, annotationFQName, fromFile, packageName, virtualFile, value); } }); } break; } }
@NotNull static PsiModifierListOwner getAnnotationOwner(@NotNull PsiElement element) { PsiModifierListOwner annotationOwner = element.getOriginalElement() instanceof PsiModifierListOwner ? (PsiModifierListOwner) element.getOriginalElement() : (PsiModifierListOwner) element; if (!annotationOwner.isPhysical()) { // this is fake PsiFile which is mirror for ClsFile without sources ASTNode node = SourceTreeToPsiMap.psiElementToTree(element); if (node != null) { PsiCompiledElement compiledElement = node.getUserData(ClsElementImpl.COMPILED_ELEMENT); if (compiledElement instanceof PsiModifierListOwner) { return (PsiModifierListOwner) compiledElement; } } } return annotationOwner; }
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 void setCorrectVisibility(final HashSet<PsiMember> movedMembers, GrMemberInfo info) { PsiModifierListOwner modifierListOwner = info.getMember(); if (myTargetSuperClass.isInterface()) { PsiUtil.setModifierProperty(modifierListOwner, PsiModifier.PUBLIC, true); } else if (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE)) { if (info.isToAbstract() || willBeUsedInSubclass( modifierListOwner, movedMembers, myTargetSuperClass, mySourceClass)) { PsiUtil.setModifierProperty(modifierListOwner, PsiModifier.PROTECTED, true); } if (modifierListOwner instanceof GrTypeDefinition) { ((GrTypeDefinition) modifierListOwner) .accept( new GroovyRecursiveElementVisitor() { @Override public void visitMethod(GrMethod method) { check(method); } @Override public void visitField(GrField field) { check(field); } @Override public void visitTypeDefinition(GrTypeDefinition typeDefinition) { check(typeDefinition); super.visitTypeDefinition(typeDefinition); } private void check(PsiMember member) { if (member.hasModifierProperty(PsiModifier.PRIVATE)) { if (willBeUsedInSubclass( member, movedMembers, myTargetSuperClass, mySourceClass)) { PsiUtil.setModifierProperty(member, PsiModifier.PROTECTED, true); } } } }); } } }
@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); } } }
public boolean execute(PsiElement element, ResolveState state) { //noinspection SuspiciousMethodCalls if (myNonInitializedFields.contains(element)) { return true; } if (!(element instanceof PsiClass) && element instanceof PsiModifierListOwner) { PsiModifierListOwner modifierListOwner = (PsiModifierListOwner) element; if (myStatic) { if (!modifierListOwner.hasModifierProperty(PsiModifier.STATIC)) { // we don't need non static method in static context. return true; } } else { if (!mySettings.SHOW_STATIC_AFTER_INSTANCE && modifierListOwner.hasModifierProperty(PsiModifier.STATIC) && !myMembersFlag) { // according settings we don't need to process such fields/methods return true; } } } final PsiElement elementParent = myElement.getParent(); if (element instanceof PsiPackage && myScope instanceof PsiClass) { if (!(elementParent instanceof PsiQualifiedReference && ((PsiQualifiedReference) elementParent).getQualifier() != null)) { return true; } } if (satisfies(element, state) && isAccessible(element)) { CompletionElement element1 = new CompletionElement( myQualifierType, element, state.get(PsiSubstitutor.KEY), myQualifierClass); if (myResultNames.add(element1.getUniqueId())) { myResults.add(element1); } } return true; }
@Override public void setCorrectVisibility(MemberInfo info) { PsiModifierListOwner modifierListOwner = info.getMember(); if (myIsTargetInterface) { PsiUtil.setModifierProperty(modifierListOwner, PsiModifier.PUBLIC, true); } else if (modifierListOwner.hasModifierProperty(PsiModifier.PRIVATE)) { if (info.isToAbstract() || willBeUsedInSubclass(modifierListOwner, myTargetSuperClass, mySourceClass)) { PsiUtil.setModifierProperty(modifierListOwner, PsiModifier.PROTECTED, true); } if (modifierListOwner instanceof PsiClass) { modifierListOwner.accept( new JavaRecursiveElementWalkingVisitor() { @Override public void visitMethod(PsiMethod method) { check(method); } @Override public void visitField(PsiField field) { check(field); } @Override public void visitClass(PsiClass aClass) { check(aClass); super.visitClass(aClass); } private void check(PsiMember member) { if (member.hasModifierProperty(PsiModifier.PRIVATE)) { if (willBeUsedInSubclass(member, myTargetSuperClass, mySourceClass)) { PsiUtil.setModifierProperty(member, PsiModifier.PROTECTED, true); } } } }); } } }
@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 DfaInstructionState[] visitAssign( AssignInstruction instruction, DataFlowRunner runner, DfaMemoryState memState) { DfaValue dfaSource = memState.pop(); DfaValue dfaDest = memState.pop(); if (dfaDest instanceof DfaVariableValue) { DfaVariableValue var = (DfaVariableValue) dfaDest; DfaValueFactory factory = runner.getFactory(); if (dfaSource instanceof DfaVariableValue && factory.getVarFactory().getAllQualifiedBy(var).contains(dfaSource)) { Nullness nullability = memState.isNotNull(dfaSource) ? Nullness.NOT_NULL : ((DfaVariableValue) dfaSource).getInherentNullability(); dfaSource = factory.createTypeValue(((DfaVariableValue) dfaSource).getVariableType(), nullability); } if (var.getInherentNullability() == Nullness.NOT_NULL) { checkNotNullable( memState, dfaSource, NullabilityProblem.assigningToNotNull, instruction.getRExpression()); } final PsiModifierListOwner psi = var.getPsiVariable(); if (!(psi instanceof PsiField) || !psi.hasModifierProperty(PsiModifier.VOLATILE)) { memState.setVarValue(var, dfaSource); } } else if (dfaDest instanceof DfaTypeValue && ((DfaTypeValue) dfaDest).isNotNull()) { checkNotNullable( memState, dfaSource, NullabilityProblem.assigningToNotNull, instruction.getRExpression()); } memState.push(dfaDest); return nextInstruction(instruction, runner, memState); }
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; }
@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 String calcText( PsiModifierListOwner modifierListOwner, @NotNull String annotation) { final String shortName = annotation.substring(annotation.lastIndexOf('.') + 1); if (modifierListOwner instanceof PsiNamedElement) { final String name = ((PsiNamedElement) modifierListOwner).getName(); if (name != null) { FindUsagesProvider provider = LanguageFindUsages.INSTANCE.forLanguage(modifierListOwner.getLanguage()); return CodeInsightBundle.message( "inspection.i18n.quickfix.annotate.element.as", provider.getType(modifierListOwner), name, shortName); } } return CodeInsightBundle.message("inspection.i18n.quickfix.annotate.as", shortName); }
private DfaVariableValue( @NotNull PsiModifierListOwner variable, @Nullable PsiType varType, boolean isNegated, DfaValueFactory factory, @Nullable DfaVariableValue qualifier) { super(factory); myVariable = variable; myIsNegated = isNegated; myQualifier = qualifier; myVarType = varType; DfaValue typeValue = myFactory.createTypeValue(varType, Nullness.UNKNOWN); myTypeValue = typeValue instanceof DfaTypeValue ? (DfaTypeValue) typeValue : null; if (varType != null && !varType.isValid()) { PsiUtil.ensureValidType( varType, "Variable: " + variable + " of class " + variable.getClass()); } }
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); } }); }
@Nullable private static PsiAnnotation findContainerAnnotation( PsiModifierListOwner owner, String annotationFQN) { PsiElement element = owner.getParent(); while (element != null) { if (element instanceof PsiModifierListOwner) { PsiAnnotation annotation = AnnotationUtil.findAnnotation((PsiModifierListOwner) element, annotationFQN); if (annotation != null) { return annotation; } } if (element instanceof PsiClassOwner) { String packageName = ((PsiClassOwner) element).getPackageName(); PsiPackage psiPackage = JavaPsiFacade.getInstance(element.getProject()).findPackage(packageName); return AnnotationUtil.findAnnotation(psiPackage, annotationFQN); } element = element.getContext(); } return null; }
private static AllowedValues parseBeanInfo(@NotNull PsiModifierListOwner owner) { PsiMethod method = null; if (owner instanceof PsiParameter) { PsiParameter parameter = (PsiParameter) owner; PsiElement scope = parameter.getDeclarationScope(); if (!(scope instanceof PsiMethod)) return null; PsiElement nav = scope.getNavigationElement(); if (!(nav instanceof PsiMethod)) return null; method = (PsiMethod) nav; if (method.isConstructor()) { // not a property, try the @ConstructorProperties({"prop"}) PsiAnnotation annotation = AnnotationUtil.findAnnotation(method, "java.beans.ConstructorProperties"); if (annotation == null) return null; PsiAnnotationMemberValue value = annotation.findAttributeValue("value"); if (!(value instanceof PsiArrayInitializerMemberValue)) return null; PsiAnnotationMemberValue[] initializers = ((PsiArrayInitializerMemberValue) value).getInitializers(); PsiElement parent = parameter.getParent(); if (!(parent instanceof PsiParameterList)) return null; int index = ((PsiParameterList) parent).getParameterIndex(parameter); if (index >= initializers.length) return null; PsiAnnotationMemberValue initializer = initializers[index]; if (!(initializer instanceof PsiLiteralExpression)) return null; Object val = ((PsiLiteralExpression) initializer).getValue(); if (!(val instanceof String)) return null; PsiMethod setter = PropertyUtil.findPropertySetter( method.getContainingClass(), (String) val, false, false); if (setter == null) return null; // try the @beaninfo of the corresponding setter method = (PsiMethod) setter.getNavigationElement(); } } else if (owner instanceof PsiMethod) { PsiElement nav = owner.getNavigationElement(); if (!(nav instanceof PsiMethod)) return null; method = (PsiMethod) nav; } if (method == null) return null; PsiClass aClass = method.getContainingClass(); if (aClass == null) return null; if (PropertyUtil.isSimplePropertyGetter(method)) { List<PsiMethod> setters = PropertyUtil.getSetters(aClass, PropertyUtil.getPropertyNameByGetter(method)); if (setters.size() != 1) return null; method = setters.get(0); } if (!PropertyUtil.isSimplePropertySetter(method)) return null; PsiDocComment doc = method.getDocComment(); if (doc == null) return null; PsiDocTag beaninfo = doc.findTagByName("beaninfo"); if (beaninfo == null) return null; String data = StringUtil.join( beaninfo.getDataElements(), new Function<PsiElement, String>() { @Override public String fun(PsiElement element) { return element.getText(); } }, "\n"); int enumIndex = StringUtil.indexOfSubstringEnd(data, "enum:"); if (enumIndex == -1) return null; data = data.substring(enumIndex); int colon = data.indexOf(":"); int last = colon == -1 ? data.length() : data.substring(0, colon).lastIndexOf("\n"); data = data.substring(0, last); List<PsiAnnotationMemberValue> values = new ArrayList<PsiAnnotationMemberValue>(); for (String line : StringUtil.splitByLines(data)) { List<String> words = StringUtil.split(line, " ", true, true); if (words.size() != 2) continue; String ref = words.get(1); PsiExpression constRef = JavaPsiFacade.getElementFactory(aClass.getProject()) .createExpressionFromText(ref, aClass); if (!(constRef instanceof PsiReferenceExpression)) continue; PsiReferenceExpression expr = (PsiReferenceExpression) constRef; values.add(expr); } if (values.isEmpty()) return null; PsiAnnotationMemberValue[] array = values.toArray(new PsiAnnotationMemberValue[values.size()]); return new AllowedValues(array, false); }
@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()); } } } } }
@Override @Nullable public List<PsiFile> findExternalAnnotationsFiles(@NotNull PsiModifierListOwner listOwner) { final PsiFile containingFile = listOwner.getContainingFile(); if (!(containingFile instanceof PsiJavaFile)) { return null; } final PsiJavaFile javaFile = (PsiJavaFile) containingFile; final String packageName = javaFile.getPackageName(); final VirtualFile virtualFile = containingFile.getVirtualFile(); if (virtualFile == null) return null; final List<PsiFile> files = myExternalAnnotations.get(virtualFile); if (files == NULL_LIST) return null; if (files != null) { boolean allValid = true; for (PsiFile file : files) { allValid &= file.isValid(); } if (allValid) { return files; } } if (virtualFile == null) { return null; } Set<PsiFile> possibleAnnotationsXmls = new THashSet<PsiFile>(); for (VirtualFile root : getExternalAnnotationsRoots(virtualFile)) { final VirtualFile ext = root.findFileByRelativePath(packageName.replace('.', '/') + "/" + ANNOTATIONS_XML); if (ext == null) continue; final PsiFile psiFile = myPsiManager.findFile(ext); if (psiFile == null) continue; possibleAnnotationsXmls.add(psiFile); } List<PsiFile> result; if (possibleAnnotationsXmls.isEmpty()) { myExternalAnnotations.put(virtualFile, NULL_LIST); result = null; } else { result = new SmartList<PsiFile>(possibleAnnotationsXmls); // sorting by writability: writable go first Collections.sort( result, new Comparator<PsiFile>() { @Override public int compare(PsiFile f1, PsiFile f2) { boolean w1 = f1.isWritable(); boolean w2 = f2.isWritable(); if (w1 == w2) { return 0; } return w1 ? -1 : 1; } }); myExternalAnnotations.put(virtualFile, result); } return result; }
public static boolean isDeprecatedByAnnotation(@NotNull PsiModifierListOwner owner) { PsiModifierList modifierList = owner.getModifierList(); return modifierList != null && modifierList.findAnnotation("java.lang.Deprecated") != null; }