@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;
}
@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 void checkMember(@NotNull final PsiMember member) {
if (member.hasModifierProperty(PsiModifier.PRIVATE)
|| member.hasModifierProperty(PsiModifier.NATIVE)) return;
if (member instanceof PsiMethod && member instanceof SyntheticElement || !member.isPhysical())
return;
if (member instanceof PsiMethod) {
PsiMethod method = (PsiMethod) member;
if (!method.getHierarchicalMethodSignature().getSuperSignatures().isEmpty()) {
log(member.getName() + " overrides");
return; // overrides
}
if (MethodUtils.isOverridden(method)) {
log(member.getName() + " overridden");
return;
}
}
if (member instanceof PsiEnumConstant) return;
if (member instanceof PsiClass
&& (member instanceof PsiAnonymousClass
|| member instanceof PsiTypeParameter
|| member instanceof PsiSyntheticClass
|| PsiUtil.isLocalClass((PsiClass) member))) {
return;
}
final PsiClass memberClass = member.getContainingClass();
if (memberClass != null
&& (memberClass.isInterface()
|| memberClass.isEnum()
|| memberClass.isAnnotationType()
|| PsiUtil.isLocalClass(memberClass) && member instanceof PsiClass)) {
return;
}
final PsiFile memberFile = member.getContainingFile();
Project project = memberFile.getProject();
if (myDeadCodeInspection.isEntryPoint(member)) {
log(member.getName() + " is entry point");
return;
}
PsiModifierList memberModifierList = member.getModifierList();
if (memberModifierList == null) return;
final int currentLevel = PsiUtil.getAccessLevel(memberModifierList);
final AtomicInteger maxLevel = new AtomicInteger(PsiUtil.ACCESS_LEVEL_PRIVATE);
final AtomicBoolean foundUsage = new AtomicBoolean();
PsiDirectory memberDirectory = memberFile.getContainingDirectory();
final PsiPackage memberPackage =
memberDirectory == null
? null
: JavaDirectoryService.getInstance().getPackage(memberDirectory);
log(member.getName() + ": checking effective level for " + member);
boolean result =
UnusedSymbolUtil.processUsages(
project,
memberFile,
member,
new EmptyProgressIndicator(),
null,
new Processor<UsageInfo>() {
@Override
public boolean process(UsageInfo info) {
foundUsage.set(true);
PsiFile psiFile = info.getFile();
if (psiFile == null) return true;
if (!(psiFile instanceof PsiJavaFile)) {
log(" refd from " + psiFile.getName() + "; set to public");
maxLevel.set(PsiUtil.ACCESS_LEVEL_PUBLIC);
if (memberClass != null) {
childMembersAreUsedOutsideMyPackage.add(memberClass);
}
return false; // referenced from XML, has to be public
}
// int offset = info.getNavigationOffset();
// if (offset == -1) return true;
PsiElement element = info.getElement();
if (element == null) return true;
@PsiUtil.AccessLevel
int level =
getEffectiveLevel(element, psiFile, memberFile, memberClass, memberPackage);
log(
" ref in file "
+ psiFile.getName()
+ "; level = "
+ PsiUtil.getAccessModifier(level)
+ "; ("
+ element
+ ")");
while (true) {
int oldLevel = maxLevel.get();
if (level <= oldLevel || maxLevel.compareAndSet(oldLevel, level)) break;
}
if (level == PsiUtil.ACCESS_LEVEL_PUBLIC && memberClass != null) {
childMembersAreUsedOutsideMyPackage.add(memberClass);
}
return level != PsiUtil.ACCESS_LEVEL_PUBLIC;
}
});
if (!foundUsage.get()) {
log(member.getName() + " unused; ignore");
return; // do not propose private for unused method
}
int max = maxLevel.get();
if (max == PsiUtil.ACCESS_LEVEL_PRIVATE && memberClass == null) {
max = PsiUtil.ACCESS_LEVEL_PACKAGE_LOCAL;
}
log(member.getName() + ": effective level is '" + PsiUtil.getAccessModifier(max) + "'");
if (max < currentLevel) {
if (max == PsiUtil.ACCESS_LEVEL_PACKAGE_LOCAL
&& member instanceof PsiClass
&& childMembersAreUsedOutsideMyPackage.contains(member)) {
log(member.getName() + " children used outside my package; ignore");
return; // e.g. some public method is used outside my package (without importing class)
}
PsiElement toHighlight =
currentLevel == PsiUtil.ACCESS_LEVEL_PACKAGE_LOCAL
? ((PsiNameIdentifierOwner) member).getNameIdentifier()
: ContainerUtil.find(
memberModifierList.getChildren(),
new Condition<PsiElement>() {
@Override
public boolean value(PsiElement element) {
return element instanceof PsiKeyword
&& element.getText().equals(PsiUtil.getAccessModifier(currentLevel));
}
});
assert toHighlight != null
: member
+ " ; "
+ ((PsiNameIdentifierOwner) member).getNameIdentifier()
+ "; "
+ memberModifierList.getText();
myHolder.registerProblem(
toHighlight,
"Access can be " + PsiUtil.getAccessModifier(max),
new ChangeModifierFix(PsiUtil.getAccessModifier(max)));
}
}
