@Nullable
public static String getMemberQualifiedName(PsiMember member) {
if (member instanceof PsiClass) {
return ((PsiClass) member).getQualifiedName();
}
PsiClass containingClass = member.getContainingClass();
if (containingClass == null) return null;
String className = containingClass.getQualifiedName();
if (className == null) return null;
return className + "." + member.getName();
}
@Override
public boolean isAbstractWhenDisabled(MemberInfo member) {
PsiClass currentSuperClass = getSuperClass();
if (currentSuperClass == null) return false;
if (currentSuperClass.isInterface()) {
final PsiMember psiMember = member.getMember();
if (psiMember instanceof PsiMethod) {
return !psiMember.hasModifierProperty(PsiModifier.STATIC);
}
}
return false;
}
@Override
public int checkForProblems(@NotNull MemberInfo member) {
if (member.isChecked()) return OK;
PsiClass currentSuperClass = getSuperClass();
if (currentSuperClass != null && currentSuperClass.isInterface()) {
PsiMember element = member.getMember();
if (element.hasModifierProperty(PsiModifier.STATIC)) {
return super.checkForProblems(member);
}
return OK;
} else {
return super.checkForProblems(member);
}
}
@NotNull
private static Map<String, List<Pair<PsiMember, PsiSubstitutor>>> generateMapByList(
@NotNull final List<Pair<PsiMember, PsiSubstitutor>> list) {
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> map =
new THashMap<String, List<Pair<PsiMember, PsiSubstitutor>>>();
map.put(ALL, list);
for (final Pair<PsiMember, PsiSubstitutor> info : list) {
PsiMember element = info.getFirst();
String currentName = element.getName();
List<Pair<PsiMember, PsiSubstitutor>> listByName = map.get(currentName);
if (listByName == null) {
listByName = new ArrayList<Pair<PsiMember, PsiSubstitutor>>(1);
map.put(currentName, listByName);
}
listByName.add(info);
}
return map;
}
@NotNull
private static List<PsiMember> findByMap(
@NotNull PsiClass aClass, String name, boolean checkBases, @NotNull MemberType type) {
if (name == null) return Collections.emptyList();
if (checkBases) {
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allMethodsMap = getMap(aClass, type);
List<Pair<PsiMember, PsiSubstitutor>> list = allMethodsMap.get(name);
if (list == null) return Collections.emptyList();
List<PsiMember> ret = new ArrayList<PsiMember>(list.size());
for (final Pair<PsiMember, PsiSubstitutor> info : list) {
ret.add(info.getFirst());
}
return ret;
} else {
PsiMember[] members = null;
switch (type) {
case METHOD:
members = aClass.getMethods();
break;
case CLASS:
members = aClass.getInnerClasses();
break;
case FIELD:
members = aClass.getFields();
break;
}
List<PsiMember> list = new ArrayList<PsiMember>();
for (PsiMember member : members) {
if (name.equals(member.getName())) {
list.add(member);
}
}
return list;
}
}
private static boolean processCachedMembersByName(
@NotNull PsiClass aClass,
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
boolean isRaw,
@NotNull PsiSubstitutor substitutor,
@NotNull MembersMap value,
String name,
@NotNull LanguageLevel languageLevel) {
final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory();
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) {
final PsiField fieldByName = aClass.findFieldByName(name, false);
if (fieldByName != null) {
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
if (!processor.execute(fieldByName, state)) return false;
} else {
final Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allFieldsMap =
value.get(MemberType.FIELD);
final List<Pair<PsiMember, PsiSubstitutor>> list = allFieldsMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
PsiMember candidateField = candidate.getFirst();
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
candidateField.getContainingClass(),
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
processor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER,
candidateField.getContainingClass());
if (!processor.execute(candidateField, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
}
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
if (last != null && last.getParent() == aClass) {
if (last instanceof PsiClass) {
if (!processor.execute(last, state)) return false;
}
// Parameters
final PsiTypeParameterList list = aClass.getTypeParameterList();
if (list != null && !list.processDeclarations(processor, state, last, place)) return false;
}
if (!(last instanceof PsiReferenceList)) {
final PsiClass classByName = aClass.findInnerClassByName(name, false);
if (classByName != null) {
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
if (!processor.execute(classByName, state)) return false;
} else {
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allClassesMap =
value.get(MemberType.CLASS);
List<Pair<PsiMember, PsiSubstitutor>> list = allClassesMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
PsiMember inner = candidate.getFirst();
PsiClass containingClass = inner.getContainingClass();
if (containingClass != null) {
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
containingClass,
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
processor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass);
if (!processor.execute(inner, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
}
}
}
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) {
if (processor instanceof MethodResolverProcessor) {
final MethodResolverProcessor methodResolverProcessor = (MethodResolverProcessor) processor;
if (methodResolverProcessor.isConstructor()) {
final PsiMethod[] constructors = aClass.getConstructors();
methodResolverProcessor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
for (PsiMethod constructor : constructors) {
if (!methodResolverProcessor.execute(constructor, state)) return false;
}
return true;
}
}
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allMethodsMap =
value.get(MemberType.METHOD);
List<Pair<PsiMember, PsiSubstitutor>> list = allMethodsMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
ProgressIndicatorProvider.checkCanceled();
PsiMethod candidateMethod = (PsiMethod) candidate.getFirst();
if (processor instanceof MethodResolverProcessor) {
if (candidateMethod.isConstructor()
!= ((MethodResolverProcessor) processor).isConstructor()) continue;
}
final PsiClass containingClass = candidateMethod.getContainingClass();
if (visited != null && visited.contains(candidateMethod.getContainingClass())) {
continue;
}
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
containingClass,
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
finalSubstitutor = checkRaw(isRaw, factory, candidateMethod, finalSubstitutor);
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass);
if (!processor.execute(candidateMethod, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
if (visited != null) {
for (Pair<PsiMember, PsiSubstitutor> aList : list) {
visited.add(aList.getFirst().getContainingClass());
}
}
}
}
return true;
}
public CommonProblemDescriptor[] checkElement(
@NotNull final PsiElement psiElement, InspectionManager manager, Project project) {
final Map<PsiElement, Collection<String>> suppressedScopes =
new THashMap<PsiElement, Collection<String>>();
psiElement.accept(
new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitModifierList(PsiModifierList list) {
super.visitModifierList(list);
final PsiElement parent = list.getParent();
if (parent instanceof PsiModifierListOwner && !(parent instanceof PsiClass)) {
checkElement(parent);
}
}
@Override
public void visitComment(PsiComment comment) {
checkElement(comment);
}
@Override
public void visitClass(PsiClass aClass) {
if (aClass == psiElement) {
super.visitClass(aClass);
checkElement(aClass);
}
}
private void checkElement(final PsiElement owner) {
String idsString = SuppressManager.getInstance().getSuppressedInspectionIdsIn(owner);
if (idsString != null && idsString.length() != 0) {
List<String> ids = StringUtil.split(idsString, ",");
if (IGNORE_ALL
&& (ids.contains(SuppressionUtil.ALL)
|| ids.contains(SuppressionUtil.ALL.toLowerCase()))) return;
Collection<String> suppressed = suppressedScopes.get(owner);
if (suppressed == null) {
suppressed = ids;
} else {
for (String id : ids) {
if (!suppressed.contains(id)) {
suppressed.add(id);
}
}
}
suppressedScopes.put(owner, suppressed);
}
}
});
if (suppressedScopes.values().isEmpty()) return null;
// have to visit all file from scratch since inspections can be written in any perversive way
// including checkFile() overriding
Collection<InspectionTool> suppressedTools = new THashSet<InspectionTool>();
InspectionTool[] tools = getInspectionTools(psiElement, manager);
for (Collection<String> ids : suppressedScopes.values()) {
for (Iterator<String> iterator = ids.iterator(); iterator.hasNext(); ) {
final String shortName = iterator.next().trim();
for (InspectionTool tool : tools) {
if (tool instanceof LocalInspectionToolWrapper
&& ((LocalInspectionToolWrapper) tool).getTool().getID().equals(shortName)) {
if (!((LocalInspectionToolWrapper) tool).isUnfair()) {
suppressedTools.add(tool);
} else {
iterator.remove();
break;
}
} else if (tool.getShortName().equals(shortName)) {
// ignore global unused as it won't be checked anyway
if (!(tool instanceof LocalInspectionToolWrapper)
&& !(tool instanceof GlobalInspectionToolWrapper)) {
iterator.remove();
break;
} else {
suppressedTools.add(tool);
}
}
}
}
}
final AnalysisScope scope = new AnalysisScope(psiElement.getContainingFile());
final InspectionManagerEx inspectionManagerEx =
((InspectionManagerEx) InspectionManager.getInstance(project));
GlobalInspectionContextImpl globalContext = inspectionManagerEx.createNewGlobalContext(false);
globalContext.setCurrentScope(scope);
final RefManagerImpl refManager = ((RefManagerImpl) globalContext.getRefManager());
refManager.inspectionReadActionStarted();
final List<ProblemDescriptor> result;
try {
result = new ArrayList<ProblemDescriptor>();
for (InspectionTool tool : suppressedTools) {
String toolId =
tool instanceof LocalInspectionToolWrapper
? ((LocalInspectionToolWrapper) tool).getTool().getID()
: tool.getShortName();
tool.initialize(globalContext);
Collection<CommonProblemDescriptor> descriptors;
if (tool instanceof LocalInspectionToolWrapper) {
LocalInspectionToolWrapper local = (LocalInspectionToolWrapper) tool;
if (local.isUnfair()) continue; // cant't work with passes other than LocalInspectionPass
local.processFile(psiElement.getContainingFile(), false, manager);
descriptors = local.getProblemDescriptors();
} else if (tool instanceof GlobalInspectionToolWrapper) {
GlobalInspectionToolWrapper global = (GlobalInspectionToolWrapper) tool;
if (global.getTool().isGraphNeeded()) {
refManager.findAllDeclarations();
}
global.processFile(scope, manager, globalContext, false);
descriptors = global.getProblemDescriptors();
} else {
continue;
}
for (PsiElement suppressedScope : suppressedScopes.keySet()) {
Collection<String> suppressedIds = suppressedScopes.get(suppressedScope);
if (!suppressedIds.contains(toolId)) continue;
for (CommonProblemDescriptor descriptor : descriptors) {
if (!(descriptor instanceof ProblemDescriptor)) continue;
PsiElement element = ((ProblemDescriptor) descriptor).getPsiElement();
if (element == null) continue;
PsiElement annotation =
SuppressManager.getInstance().getElementToolSuppressedIn(element, toolId);
if (annotation != null && PsiTreeUtil.isAncestor(suppressedScope, annotation, false)
|| annotation == null && !PsiTreeUtil.isAncestor(suppressedScope, element, false)) {
suppressedIds.remove(toolId);
break;
}
}
}
}
for (PsiElement suppressedScope : suppressedScopes.keySet()) {
Collection<String> suppressedIds = suppressedScopes.get(suppressedScope);
for (String toolId : suppressedIds) {
PsiMember psiMember;
String problemLine = null;
if (suppressedScope instanceof PsiMember) {
psiMember = (PsiMember) suppressedScope;
} else {
psiMember = PsiTreeUtil.getParentOfType(suppressedScope, PsiDocCommentOwner.class);
final PsiStatement statement =
PsiTreeUtil.getNextSiblingOfType(suppressedScope, PsiStatement.class);
problemLine = statement != null ? statement.getText() : null;
}
if (psiMember != null && psiMember.isValid()) {
String description =
InspectionsBundle.message("inspection.redundant.suppression.description");
if (myQuickFixes == null) myQuickFixes = new BidirectionalMap<String, QuickFix>();
final String key = toolId + (problemLine != null ? ";" + problemLine : "");
QuickFix fix = myQuickFixes.get(key);
if (fix == null) {
fix = new RemoveSuppressWarningAction(toolId, problemLine);
myQuickFixes.put(key, fix);
}
PsiElement identifier = null;
if (psiMember instanceof PsiMethod) {
identifier = ((PsiMethod) psiMember).getNameIdentifier();
} else if (psiMember instanceof PsiField) {
identifier = ((PsiField) psiMember).getNameIdentifier();
} else if (psiMember instanceof PsiClass) {
identifier = ((PsiClass) psiMember).getNameIdentifier();
}
if (identifier == null) {
identifier = psiMember;
}
result.add(
manager.createProblemDescriptor(
identifier,
description,
(LocalQuickFix) fix,
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
false));
}
}
}
} finally {
refManager.inspectionReadActionFinished();
globalContext.close(true);
}
return result.toArray(new ProblemDescriptor[result.size()]);
}