protected InspectionTool[] getInspectionTools(PsiElement psiElement, InspectionManager manager) {
final ModifiableModel model =
InspectionProjectProfileManager.getInstance(manager.getProject())
.getInspectionProfile()
.getModifiableModel();
InspectionProfileWrapper profile = new InspectionProfileWrapper((InspectionProfile) model);
profile.init(manager.getProject());
return profile.getInspectionTools(psiElement);
}
@Nullable
private ProblemDescriptor[] checkMember(
final PsiDocCommentOwner docCommentOwner,
final InspectionManager manager,
final boolean isOnTheFly) {
final ArrayList<ProblemDescriptor> problems = new ArrayList<ProblemDescriptor>();
final PsiDocComment docComment = docCommentOwner.getDocComment();
if (docComment == null) return null;
final Set<PsiJavaCodeReferenceElement> references = new HashSet<PsiJavaCodeReferenceElement>();
docComment.accept(getVisitor(references, docCommentOwner, problems, manager, isOnTheFly));
for (PsiJavaCodeReferenceElement reference : references) {
final List<PsiClass> classesToImport = new ImportClassFix(reference).getClassesToImport();
final PsiElement referenceNameElement = reference.getReferenceNameElement();
problems.add(
manager.createProblemDescriptor(
referenceNameElement != null ? referenceNameElement : reference,
cannotResolveSymbolMessage("<code>" + reference.getText() + "</code>"),
!isOnTheFly || classesToImport.isEmpty() ? null : new AddImportFix(classesToImport),
ProblemHighlightType.LIKE_UNKNOWN_SYMBOL,
isOnTheFly));
}
return problems.isEmpty() ? null : problems.toArray(new ProblemDescriptor[problems.size()]);
}
private void reportMissingOnClickProblem(
OnClickConverter.MyReference reference,
PsiClass activity,
String methodName,
boolean incorrectSignature) {
String activityName = activity.getName();
if (activityName == null) {
activityName = "";
}
final String message =
incorrectSignature
? AndroidBundle.message(
"android.inspections.on.click.missing.incorrect.signature",
methodName,
activityName)
: AndroidBundle.message(
"android.inspections.on.click.missing.problem", methodName, activityName);
final LocalQuickFix[] fixes =
StringUtil.isJavaIdentifier(methodName)
? new LocalQuickFix[] {new MyQuickFix(methodName, reference.getConverter(), activity)}
: LocalQuickFix.EMPTY_ARRAY;
myResult.add(
myInspectionManager.createProblemDescriptor(
reference.getElement(),
reference.getRangeInElement(),
message,
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
myOnTheFly,
fixes));
}
private ProblemDescriptor generateProblemDescriptor(
RegExpChar ch, InspectionManager manager, boolean isOnTheFly) {
Character value = ch.getValue();
String msg = "Character class already contains char '" + value + "'";
return manager.createProblemDescriptor(
ch,
msg,
isOnTheFly,
new LocalQuickFix[] {new DeleteCharFix(ch)},
ProblemHighlightType.GENERIC_ERROR_OR_WARNING);
}
private static ProblemDescriptor createDescriptor(
@NotNull PsiElement element, String template, InspectionManager manager, boolean onTheFly) {
return manager.createProblemDescriptor(
element, template, onTheFly, null, ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
}
public static void visitRefInDocTag(
final PsiDocTag tag,
final JavadocManager manager,
final PsiElement context,
final ArrayList<ProblemDescriptor> problems,
final InspectionManager inspectionManager,
final boolean onTheFly) {
final String tagName = tag.getName();
final PsiDocTagValue value = tag.getValueElement();
if (value == null) return;
final JavadocTagInfo info = manager.getTagInfo(tagName);
if (info != null && !info.isValidInContext(context)) return;
final String message = info == null || !info.isInline() ? null : info.checkTagValue(value);
if (message != null) {
problems.add(createDescriptor(value, message, inspectionManager, onTheFly));
}
final PsiReference reference = value.getReference();
if (reference == null) return;
final PsiElement element = reference.resolve();
if (element != null) return;
final int textOffset = value.getTextOffset();
if (textOffset == value.getTextRange().getEndOffset()) return;
final PsiDocTagValue valueElement = tag.getValueElement();
if (valueElement == null) return;
final CharSequence paramName =
value
.getContainingFile()
.getViewProvider()
.getContents()
.subSequence(textOffset, value.getTextRange().getEndOffset());
final String params = "<code>" + paramName + "</code>";
final List<LocalQuickFix> fixes = new ArrayList<LocalQuickFix>();
if (onTheFly && "param".equals(tagName)) {
final PsiDocCommentOwner commentOwner =
PsiTreeUtil.getParentOfType(tag, PsiDocCommentOwner.class);
if (commentOwner instanceof PsiMethod) {
final PsiMethod method = (PsiMethod) commentOwner;
final PsiParameter[] parameters = method.getParameterList().getParameters();
final PsiDocTag[] tags = tag.getContainingComment().getTags();
final Set<String> unboundParams = new HashSet<String>();
for (PsiParameter parameter : parameters) {
if (!JavaDocLocalInspection.isFound(tags, parameter)) {
unboundParams.add(parameter.getName());
}
}
if (!unboundParams.isEmpty()) {
fixes.add(new RenameReferenceQuickFix(unboundParams));
}
}
}
fixes.add(new RemoveTagFix(tagName, paramName));
problems.add(
inspectionManager.createProblemDescriptor(
valueElement,
reference.getRangeInElement(),
cannotResolveSymbolMessage(params),
ProblemHighlightType.LIKE_UNKNOWN_SYMBOL,
onTheFly,
fixes.toArray(new LocalQuickFix[fixes.size()])));
}
@Override
public void visitXmlAttributeValue(XmlAttributeValue value) {
for (PsiReference reference : value.getReferences()) {
if (!(reference instanceof OnClickConverter.MyReference)) {
continue;
}
final OnClickConverter.MyReference ref = (OnClickConverter.MyReference) reference;
final String methodName = ref.getValue();
if (methodName.isEmpty()) {
continue;
}
final ResolveResult[] results = ref.multiResolve(false);
final Set<PsiClass> resolvedClasses = new HashSet<PsiClass>();
final Set<PsiClass> resolvedClassesWithMistake = new HashSet<PsiClass>();
for (ResolveResult result : results) {
if (result instanceof OnClickConverter.MyResolveResult) {
final PsiElement element = result.getElement();
if (element != null) {
final PsiClass aClass = PsiTreeUtil.getParentOfType(element, PsiClass.class);
if (aClass != null) {
resolvedClasses.add(aClass);
if (!((OnClickConverter.MyResolveResult) result).hasCorrectSignature()) {
resolvedClassesWithMistake.add(aClass);
}
}
}
}
}
PsiClass activity = null;
for (PsiClass relatedActivity : myRelatedActivities) {
if (!containsOrExtends(resolvedClasses, relatedActivity)) {
activity = relatedActivity;
break;
} else if (activity == null
&& containsOrExtends(resolvedClassesWithMistake, relatedActivity)) {
activity = relatedActivity;
}
}
if (activity != null) {
reportMissingOnClickProblem(
ref, activity, methodName, resolvedClassesWithMistake.contains(activity));
} else if (results.length == 0) {
myResult.add(
myInspectionManager.createProblemDescriptor(
value,
reference.getRangeInElement(),
ProblemsHolder.unresolvedReferenceMessage(reference),
ProblemHighlightType.GENERIC_ERROR_OR_WARNING,
myOnTheFly));
} else if (resolvedClassesWithMistake.size() > 0) {
reportMissingOnClickProblem(
ref, resolvedClassesWithMistake.iterator().next(), methodName, 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()]);
}