public static <T> T getOrCreateCache( Key<T> cacheKey, PsiElement element, CacheProvider<T> provider) { final PsiFile containingFile; if (element instanceof PsiFile) { containingFile = (PsiFile) element; } else { final PsiClass topLevelClass = PsiUtil.getTopLevelClass(element); if (topLevelClass == null) { return provider.provide(); } containingFile = topLevelClass.getContainingFile(); } if (containingFile == null) { return provider.provide(); } final PsiFile originalFile = containingFile.getOriginalFile(); T copyableUserData = originalFile.getCopyableUserData(cacheKey); if (copyableUserData != null) { if (!provider.isCacheValid(copyableUserData)) { copyableUserData = null; } } if (copyableUserData == null) { originalFile.putCopyableUserData(cacheKey, copyableUserData = provider.provide()); } return copyableUserData; }
public static Collection<AnnotationSearchResult> findAllAnnotatedElements( PsiElement element, String annotation) { final PsiClass bean = PsiUtil.getTopLevelClass(element); if (bean == null) { return Collections.emptyList(); } final List<AnnotationSearchResult> elementList = new ArrayList<AnnotationSearchResult>(); PsiAnnotation a; for (PsiField e : bean.getAllFields()) { a = getAnnotationFromElement(e, annotation); if (a != null) { elementList.add(new AnnotationSearchResult(a, e)); } } for (PsiMethod e : bean.getAllMethods()) { a = getAnnotationFromElement(e, annotation); if (a != null) { elementList.add(new AnnotationSearchResult(a, e)); } for (PsiParameter p : e.getParameterList().getParameters()) { a = getAnnotationFromElement(p, annotation); if (a != null) { elementList.add(new AnnotationSearchResult(a, p)); } } } return elementList; }
public static long getLastUpdate(PsiElement element) { try { final PsiClass topLevelClass = PsiUtil.getTopLevelClass(element); if (topLevelClass == null) { return -1; } final PsiFile containingFile = topLevelClass.getContainingFile(); return containingFile.getOriginalFile().getModificationStamp(); } catch (PsiInvalidElementAccessException e) { return -1; } }
@NotNull public static SearchScope getMemberUseScope(@NotNull PsiMember member) { PsiFile file = member.getContainingFile(); PsiElement topElement = file == null ? member : file; Project project = topElement.getProject(); final GlobalSearchScope maximalUseScope = ResolveScopeManager.getInstance(project).getUseScope(topElement); if (isInServerPage(file)) return maximalUseScope; PsiClass aClass = member.getContainingClass(); if (aClass instanceof PsiAnonymousClass && !(aClass instanceof PsiEnumConstantInitializer && member instanceof PsiMethod && member.hasModifierProperty(PsiModifier.PUBLIC) && ((PsiMethod) member).findSuperMethods().length > 0)) { // member from anonymous class can be called from outside the class PsiElement methodCallExpr = PsiUtil.isLanguageLevel8OrHigher(aClass) ? PsiTreeUtil.getTopmostParentOfType(aClass, PsiStatement.class) : PsiTreeUtil.getParentOfType(aClass, PsiMethodCallExpression.class); return new LocalSearchScope(methodCallExpr != null ? methodCallExpr : aClass); } PsiModifierList modifierList = member.getModifierList(); int accessLevel = modifierList == null ? PsiUtil.ACCESS_LEVEL_PUBLIC : PsiUtil.getAccessLevel(modifierList); if (accessLevel == PsiUtil.ACCESS_LEVEL_PUBLIC || accessLevel == PsiUtil.ACCESS_LEVEL_PROTECTED) { return maximalUseScope; // class use scope doesn't matter, since another very visible class // can inherit from aClass } if (accessLevel == PsiUtil.ACCESS_LEVEL_PRIVATE) { PsiClass topClass = PsiUtil.getTopLevelClass(member); return topClass != null ? new LocalSearchScope(topClass) : file == null ? maximalUseScope : new LocalSearchScope(file); } if (file instanceof PsiJavaFile) { PsiPackage aPackage = JavaPsiFacade.getInstance(project).findPackage(((PsiJavaFile) file).getPackageName()); if (aPackage != null) { SearchScope scope = PackageScope.packageScope(aPackage, false); return scope.intersectWith(maximalUseScope); } } return maximalUseScope; }
@Nullable public static String getSourcePositionPackageDisplayName( DebugProcessImpl debugProcess, @Nullable SourcePosition position) { if (position == null) { return null; } final PsiFile positionFile = position.getFile(); if (positionFile instanceof JspFile) { final PsiDirectory dir = positionFile.getContainingDirectory(); return dir != null ? dir.getVirtualFile().getPresentableUrl() : null; } final PsiClass psiClass = getClassAt(position); if (psiClass != null) { PsiClass toplevel = PsiUtil.getTopLevelClass(psiClass); if (toplevel != null) { String qName = toplevel.getQualifiedName(); if (qName != null) { int i = qName.lastIndexOf('.'); return i > 0 ? qName.substring(0, i) : ""; } } } if (positionFile instanceof PsiClassOwner) { String name = ((PsiClassOwner) positionFile).getPackageName(); if (!StringUtil.isEmpty(name)) { return name; } } if (debugProcess != null && debugProcess.isAttached()) { List<ReferenceType> allClasses = debugProcess.getPositionManager().getAllClasses(position); if (!allClasses.isEmpty()) { final String className = allClasses.get(0).name(); int dotIndex = className.lastIndexOf('.'); if (dotIndex >= 0) { return className.substring(0, dotIndex); } } } return ""; }
public static boolean isSourceLevelAccessible( PsiElement context, PsiClass psiClass, final boolean pkgContext) { if (!JavaPsiFacade.getInstance(psiClass.getProject()) .getResolveHelper() .isAccessible(psiClass, context, null)) { return false; } if (pkgContext) { PsiClass topLevel = PsiUtil.getTopLevelClass(psiClass); if (topLevel != null) { String fqName = topLevel.getQualifiedName(); if (fqName != null && StringUtil.isEmpty(StringUtil.getPackageName(fqName))) { return false; } } } return true; }
/** * Computes indentation of PsiClass, PsiMethod and PsiField elements after formatting * * @param element PsiClass or PsiMethod or PsiField * @return indentation size */ private int getIndentSpecial(@NotNull PsiElement element) { assert (element instanceof PsiClass || element instanceof PsiField || element instanceof PsiMethod); int indentSize = mySettings.getIndentSize(JavaFileType.INSTANCE); boolean doNotIndentTopLevelClassMembers = mySettings.getCommonSettings(JavaLanguage.INSTANCE).DO_NOT_INDENT_TOP_LEVEL_CLASS_MEMBERS; int indent = 0; PsiClass top = PsiUtil.getTopLevelClass(element); while (top != null && !element.isEquivalentTo(top)) { if (doNotIndentTopLevelClassMembers && element.getParent().isEquivalentTo(top)) { break; } element = element.getParent(); indent += indentSize; } return indent; }
@NotNull public static SearchScope getClassUseScope(@NotNull PsiClass aClass) { if (aClass instanceof PsiAnonymousClass) { return new LocalSearchScope(aClass); } final GlobalSearchScope maximalUseScope = ResolveScopeManager.getElementUseScope(aClass); PsiFile file = aClass.getContainingFile(); if (PsiImplUtil.isInServerPage(file)) return maximalUseScope; final PsiClass containingClass = aClass.getContainingClass(); if (aClass.hasModifierProperty(PsiModifier.PUBLIC) || aClass.hasModifierProperty(PsiModifier.PROTECTED)) { return containingClass == null ? maximalUseScope : containingClass.getUseScope(); } else if (aClass.hasModifierProperty(PsiModifier.PRIVATE) || aClass instanceof PsiTypeParameter) { PsiClass topClass = PsiUtil.getTopLevelClass(aClass); return new LocalSearchScope(topClass == null ? aClass.getContainingFile() : topClass); } else { PsiPackage aPackage = null; if (file instanceof PsiJavaFile) { aPackage = JavaPsiFacade.getInstance(aClass.getProject()) .findPackage(((PsiJavaFile) file).getPackageName()); } if (aPackage == null) { PsiDirectory dir = file.getContainingDirectory(); if (dir != null) { aPackage = JavaDirectoryService.getInstance().getPackage(dir); } } if (aPackage != null) { SearchScope scope = PackageScope.packageScope(aPackage, false); scope = scope.intersectWith(maximalUseScope); return scope; } return new LocalSearchScope(file); } }
@Override public void visitField(@NotNull PsiField field) { super.visitField(field); if (!field.hasModifierProperty(PsiModifier.PRIVATE)) { return; } if (HighlightUtil.isSerializationImplicitlyUsedField(field)) { return; } final PsiClass containingClass = PsiUtil.getTopLevelClass(field); if (!shouldCheckVariable(field, containingClass)) { return; } final ArrayReadWriteVisitor visitor = new ArrayReadWriteVisitor(field, !isSimpleArrayExpression(field.getInitializer())); containingClass.accept(visitor); final boolean written = visitor.isWritten(); if (!visitor.isReferenced() || written == visitor.isRead()) { return; } registerFieldError(field, Boolean.valueOf(written)); }
@NotNull public static SearchScope getMemberUseScope(@NotNull PsiMember member) { final GlobalSearchScope maximalUseScope = ResolveScopeManager.getElementUseScope(member); PsiFile file = member.getContainingFile(); if (isInServerPage(file)) return maximalUseScope; PsiClass aClass = member.getContainingClass(); if (aClass instanceof PsiAnonymousClass) { // member from anonymous class can be called from outside the class PsiElement methodCallExpr = PsiTreeUtil.getParentOfType(aClass, PsiMethodCallExpression.class); return new LocalSearchScope(methodCallExpr != null ? methodCallExpr : aClass); } if (member.hasModifierProperty(PsiModifier.PUBLIC)) { return maximalUseScope; // class use scope doesn't matter, since another very visible class // can inherit from aClass } else if (member.hasModifierProperty(PsiModifier.PROTECTED)) { return maximalUseScope; // class use scope doesn't matter, since another very visible class // can inherit from aClass } else if (member.hasModifierProperty(PsiModifier.PRIVATE)) { PsiClass topClass = PsiUtil.getTopLevelClass(member); return topClass != null ? new LocalSearchScope(topClass) : new LocalSearchScope(file); } else { if (file instanceof PsiJavaFile) { PsiPackage aPackage = JavaPsiFacade.getInstance(member.getProject()) .findPackage(((PsiJavaFile) file).getPackageName()); if (aPackage != null) { SearchScope scope = PackageScope.packageScope(aPackage, false); scope = scope.intersectWith(maximalUseScope); return scope; } } return maximalUseScope; } }
private static void findLocalHidesFieldCollisions( final PsiElement element, final String newName, final Map<? extends PsiElement, String> allRenames, final List<UsageInfo> result) { if (!(element instanceof PsiLocalVariable) && !(element instanceof PsiParameter)) return; PsiClass toplevel = PsiUtil.getTopLevelClass(element); if (toplevel == null) return; PsiElement scopeElement; if (element instanceof PsiLocalVariable) { scopeElement = RefactoringUtil.getVariableScope((PsiLocalVariable) element); } else { // Parameter scopeElement = ((PsiParameter) element).getDeclarationScope(); } LOG.assertTrue(scopeElement != null); scopeElement.accept( new JavaRecursiveElementWalkingVisitor() { @Override public void visitReferenceExpression(PsiReferenceExpression expression) { super.visitReferenceExpression(expression); if (!expression.isQualified()) { PsiElement resolved = expression.resolve(); if (resolved instanceof PsiField) { final PsiField field = (PsiField) resolved; String fieldNewName = allRenames.containsKey(field) ? allRenames.get(field) : field.getName(); if (newName.equals(fieldNewName)) { result.add(new LocalHidesFieldUsageInfo(expression, element)); } } } } }); }
public static void invoke( final Project project, PsiFile file, final Editor editor, PsiElement element) { if (!FileModificationService.getInstance().prepareFileForWrite(file)) return; final PsiJavaCodeReferenceElement refExpr = (PsiJavaCodeReferenceElement) element.getParent(); final PsiClass aClass = (PsiClass) refExpr.resolve(); if (aClass == null) { return; } final PsiClass containingClass = PsiUtil.getTopLevelClass(refExpr); if (aClass != containingClass) { PsiImportList importList = ((PsiJavaFile) file).getImportList(); if (importList == null) { return; } boolean alreadyImported = false; for (PsiImportStaticStatement statement : importList.getImportStaticStatements()) { if (!statement.isOnDemand()) continue; PsiClass staticResolve = statement.resolveTargetClass(); if (aClass == staticResolve) { alreadyImported = true; break; } } if (!alreadyImported) { PsiImportStaticStatement importStaticStatement = JavaPsiFacade.getInstance(file.getProject()) .getElementFactory() .createImportStaticStatement(aClass, "*"); importList.add(importStaticStatement); } } List<PsiFile> roots = file.getViewProvider().getAllFiles(); for (final PsiFile root : roots) { PsiElement copy = root.copy(); final PsiManager manager = root.getManager(); final TIntArrayList expressionToDequalifyOffsets = new TIntArrayList(); copy.accept( new JavaRecursiveElementWalkingVisitor() { int delta; @Override public void visitReferenceElement(PsiJavaCodeReferenceElement expression) { if (isParameterizedReference(expression)) return; PsiElement qualifierExpression = expression.getQualifier(); if (qualifierExpression instanceof PsiJavaCodeReferenceElement && ((PsiJavaCodeReferenceElement) qualifierExpression).isReferenceTo(aClass)) { try { PsiElement resolved = expression.resolve(); int end = expression.getTextRange().getEndOffset(); qualifierExpression.delete(); delta += end - expression.getTextRange().getEndOffset(); PsiElement after = expression.resolve(); if (manager.areElementsEquivalent(after, resolved)) { expressionToDequalifyOffsets.add( expression.getTextRange().getStartOffset() + delta); } } catch (IncorrectOperationException e) { LOG.error(e); } } super.visitElement(expression); } }); expressionToDequalifyOffsets.forEachDescending( new TIntProcedure() { @Override public boolean execute(int offset) { PsiJavaCodeReferenceElement expression = PsiTreeUtil.findElementOfClassAtOffset( root, offset, PsiJavaCodeReferenceElement.class, false); if (expression == null) { return false; } PsiElement qualifierExpression = expression.getQualifier(); if (qualifierExpression instanceof PsiJavaCodeReferenceElement && ((PsiJavaCodeReferenceElement) qualifierExpression).isReferenceTo(aClass)) { qualifierExpression.delete(); if (editor != null) { HighlightManager.getInstance(project) .addRangeHighlight( editor, expression.getTextRange().getStartOffset(), expression.getTextRange().getEndOffset(), EditorColorsManager.getInstance() .getGlobalScheme() .getAttributes(EditorColors.SEARCH_RESULT_ATTRIBUTES), false, null); } } return true; } }); } }