Examples with ProblemsHolder com.intellij.codeInspection.ProblemsHolder used on opensource projects

Example 6 with ProblemsHolder

use of com.intellij.codeInspection.ProblemsHolder in project intellij-community by JetBrains.

the class HighlightSeverityTest method testErrorLikeUnusedSymbol.

public void testErrorLikeUnusedSymbol() throws Exception {
    enableInspectionTool(new LocalInspectionTool() {

        @NotNull
        @Override
        public String getShortName() {
            return getDisplayName();
        }

        @NotNull
        @Override
        public PsiElementVisitor buildVisitor(@NotNull final ProblemsHolder holder, boolean isOnTheFly, @NotNull LocalInspectionToolSession session) {
            return new JavaElementVisitor() {

                @Override
                public void visitIdentifier(PsiIdentifier identifier) {
                    if (identifier.getText().equals("k")) {
                        holder.registerProblem(identifier, "Variable 'k' is never used");
                    }
                }
            };
        }

        @NotNull
        @Override
        public HighlightDisplayLevel getDefaultLevel() {
            return HighlightDisplayLevel.ERROR;
        }

        @Nls
        @NotNull
        @Override
        public String getDisplayName() {
            return "x";
        }

        @Nls
        @NotNull
        @Override
        public String getGroupDisplayName() {
            return getDisplayName();
        }
    });
    doTest(BASE_PATH + "/" + getTestName(false) + ".java", true, false);
}

Example 7 with ProblemsHolder

use of com.intellij.codeInspection.ProblemsHolder in project intellij-community by JetBrains.

the class InspectionLIfeCycleTest method testInspectionFinishedCalledOnce.

public void testInspectionFinishedCalledOnce() throws Exception {
    String text = "class LQF {\n" + "    int f;\n" + "    public void me() {\n" + "        <caret>\n" + "    }\n" + "}";
    configureFromFileText("x.java", text);
    final AtomicInteger startedCount = new AtomicInteger();
    final AtomicInteger finishedCount = new AtomicInteger();
    final Key<Object> KEY = Key.create("just key");
    LocalInspectionTool tool = new LocalInspectionTool() {

        @Nls
        @NotNull
        @Override
        public String getGroupDisplayName() {
            return "fegna";
        }

        @Nls
        @NotNull
        @Override
        public String getDisplayName() {
            return getGroupDisplayName();
        }

        @NotNull
        @Override
        public String getShortName() {
            return getGroupDisplayName();
        }

        @NotNull
        @Override
        public PsiElementVisitor buildVisitor(@NotNull ProblemsHolder holder, boolean isOnTheFly) {
            return new PsiElementVisitor() {
            };
        }

        @Override
        public void inspectionStarted(@NotNull LocalInspectionToolSession session, boolean isOnTheFly) {
            startedCount.incrementAndGet();
            session.putUserData(KEY, session);
        }

        @Override
        public void inspectionFinished(@NotNull LocalInspectionToolSession session, @NotNull ProblemsHolder problemsHolder) {
            finishedCount.incrementAndGet();
            assertEmpty(problemsHolder.getResults());
            assertSame(session, session.getUserData(KEY));
        }
    };
    enableInspectionTool(tool);
    List<HighlightInfo> infos = highlightErrors();
    assertEmpty(infos);
    assertEquals(1, startedCount.get());
    assertEquals(1, finishedCount.get());
}

Example 8 with ProblemsHolder

use of com.intellij.codeInspection.ProblemsHolder in project intellij-community by JetBrains.

the class FieldCanBeLocalInspectionBase method doCheckClass.

private void doCheckClass(final PsiClass aClass, ProblemsHolder holder, final List<String> excludeAnnos, boolean ignoreFieldsUsedInMultipleMethods) {
    if (aClass.isInterface())
        return;
    final PsiField[] fields = aClass.getFields();
    final Set<PsiField> candidates = new LinkedHashSet<>();
    for (PsiField field : fields) {
        if (AnnotationUtil.isAnnotated(field, excludeAnnos)) {
            continue;
        }
        if (field.hasModifierProperty(PsiModifier.PRIVATE) && !(field.hasModifierProperty(PsiModifier.STATIC) && field.hasModifierProperty(PsiModifier.FINAL))) {
            candidates.add(field);
        }
    }
    removeFieldsReferencedFromInitializers(aClass, candidates);
    if (candidates.isEmpty())
        return;
    final Set<PsiField> usedFields = new THashSet<>();
    removeReadFields(aClass, candidates, usedFields, ignoreFieldsUsedInMultipleMethods);
    if (candidates.isEmpty())
        return;
    final ImplicitUsageProvider[] implicitUsageProviders = Extensions.getExtensions(ImplicitUsageProvider.EP_NAME);
    for (final PsiField field : candidates) {
        if (usedFields.contains(field) && !hasImplicitReadOrWriteUsage(field, implicitUsageProviders)) {
            if (!ReferencesSearch.search(field, new LocalSearchScope(aClass)).forEach(reference -> {
                final PsiElement element = reference.getElement();
                if (element instanceof PsiReferenceExpression) {
                    final PsiElement qualifier = ((PsiReferenceExpression) element).getQualifier();
                    return qualifier == null || qualifier instanceof PsiThisExpression && ((PsiThisExpression) qualifier).getQualifier() == null;
                }
                return true;
            })) {
                continue;
            }
            final String message = InspectionsBundle.message("inspection.field.can.be.local.problem.descriptor");
            final ArrayList<LocalQuickFix> fixes = new ArrayList<>();
            SpecialAnnotationsUtilBase.createAddToSpecialAnnotationFixes(field, qualifiedName -> {
                final LocalQuickFix quickFix = SpecialAnnotationsUtilBase.createAddToSpecialAnnotationsListQuickFix(InspectionGadgetsBundle.message("add.0.to.ignore.if.annotated.by.list.quickfix", qualifiedName), QuickFixBundle.message("fix.add.special.annotation.family"), EXCLUDE_ANNOS, qualifiedName, field);
                fixes.add(quickFix);
                return true;
            });
            final LocalQuickFix fix = createFix();
            if (fix != null) {
                fixes.add(fix);
            }
            holder.registerProblem(field.getNameIdentifier(), message, fixes.toArray(new LocalQuickFix[fixes.size()]));
        }
    }
}

Example 9 with ProblemsHolder

use of com.intellij.codeInspection.ProblemsHolder in project intellij-community by JetBrains.

the class PyArgumentListInspection method highlightUnexpectedArguments.

private static void highlightUnexpectedArguments(@NotNull PyArgumentList node, @NotNull ProblemsHolder holder, @NotNull List<PyCallExpression.PyArgumentsMapping> mappings, @NotNull TypeEvalContext context) {
    if (mappings.isEmpty() || mappings.stream().anyMatch(mapping -> mapping.getUnmappedArguments().isEmpty()))
        return;
    if (mappings.size() == 1) {
        // if there is only one mapping, we could suggest quick fixes
        final Set<String> duplicateKeywords = getDuplicateKeywordArguments(node);
        for (PyExpression argument : mappings.get(0).getUnmappedArguments()) {
            final List<LocalQuickFix> quickFixes = Lists.newArrayList(new PyRemoveArgumentQuickFix());
            if (argument instanceof PyKeywordArgument) {
                if (duplicateKeywords.contains(((PyKeywordArgument) argument).getKeyword())) {
                    continue;
                }
                quickFixes.add(new PyRenameArgumentQuickFix());
            }
            holder.registerProblem(argument, PyBundle.message("INSP.unexpected.arg"), quickFixes.toArray(new LocalQuickFix[quickFixes.size() - 1]));
        }
    } else {
        // all mappings have unmapped arguments so we couldn't determine desired argument list and suggest appropriate quick fixes
        holder.registerProblem(node, addPossibleCalleesRepresentationAndWrapInHtml(PyBundle.message("INSP.unexpected.arg(s)"), mappings, context));
    }
}

Example 10 with ProblemsHolder

use of com.intellij.codeInspection.ProblemsHolder in project intellij-community by JetBrains.

the class XmlImportOptimizer method processFile.

@NotNull
@Override
public CollectingInfoRunnable processFile(final PsiFile file) {
    return new CollectingInfoRunnable() {

        int myRemovedNameSpaces = 0;

        @Override
        public void run() {
            XmlFile xmlFile = (XmlFile) file;
            Project project = xmlFile.getProject();
            HighlightDisplayKey key = HighlightDisplayKey.find(myInspection.getShortName());
            if (!InspectionProjectProfileManager.getInstance(project).getCurrentProfile().isToolEnabled(key, xmlFile))
                return;
            ProblemsHolder holder = new ProblemsHolder(InspectionManager.getInstance(project), xmlFile, false);
            final XmlElementVisitor visitor = (XmlElementVisitor) myInspection.buildVisitor(holder, false);
            new PsiRecursiveElementVisitor() {

                @Override
                public void visitElement(PsiElement element) {
                    if (element instanceof XmlAttribute) {
                        visitor.visitXmlAttribute((XmlAttribute) element);
                    } else {
                        super.visitElement(element);
                    }
                }
            }.visitFile(xmlFile);
            ProblemDescriptor[] results = holder.getResultsArray();
            List<ProblemDescriptor> list = ContainerUtil.filter(results, myCondition);
            Map<XmlUnusedNamespaceInspection.RemoveNamespaceDeclarationFix, ProblemDescriptor> fixes = new LinkedHashMap<>();
            for (ProblemDescriptor result : list) {
                for (QuickFix fix : result.getFixes()) {
                    if (fix instanceof XmlUnusedNamespaceInspection.RemoveNamespaceDeclarationFix) {
                        fixes.put((XmlUnusedNamespaceInspection.RemoveNamespaceDeclarationFix) fix, result);
                    }
                }
            }
            SmartPsiElementPointer<XmlTag> pointer = null;
            for (Map.Entry<XmlUnusedNamespaceInspection.RemoveNamespaceDeclarationFix, ProblemDescriptor> fix : fixes.entrySet()) {
                pointer = fix.getKey().doFix(project, fix.getValue(), false);
                myRemovedNameSpaces++;
            }
            if (pointer != null) {
                XmlUnusedNamespaceInspection.RemoveNamespaceDeclarationFix.reformatStartTag(project, pointer);
            }
        }

        @Nullable
        @Override
        public String getUserNotificationInfo() {
            return myRemovedNameSpaces > 0 ? "Removed " + myRemovedNameSpaces + " namespace" + (myRemovedNameSpaces > 1 ? "s" : "") : null;
        }
    };
}