platform/lang-api/src/com/intellij/codeInspection/ProblemsHolder.java

   1 /*
   2  * Copyright 2000-2009 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.intellij.codeInspection;
  18
  19 import com.intellij.codeInsight.daemon.EmptyResolveMessageProvider;
  20 import com.intellij.openapi.diagnostic.Logger;
  21 import com.intellij.openapi.util.TextRange;
  22 import com.intellij.psi.PsiElement;
  23 import com.intellij.psi.PsiFile;
  24 import com.intellij.psi.PsiReference;
  25 import com.intellij.util.ArrayUtil;
  26 import org.jetbrains.annotations.Nls;
  27 import org.jetbrains.annotations.NotNull;
  28 import org.jetbrains.annotations.Nullable;
  29
  30 import java.util.ArrayList;
  31 import java.util.List;
  32
  33 /**
  34  * @author max
  35  */
  36 public class ProblemsHolder {
  37   private static final Logger LOG = Logger.getInstance("#com.intellij.codeInspection.ProblemsHolder");
  38   private final InspectionManager myManager;
  39   private final PsiFile myFile;
  40   private boolean myOnTheFly;
  41   private List<ProblemDescriptor> myProblems = null;
  42
  43   public ProblemsHolder(@NotNull InspectionManager manager, @NotNull PsiFile file, boolean onTheFly) {
  44     myManager = manager;
  45     myFile = file;
  46     myOnTheFly = onTheFly;
  47   }
  48
  49   public void registerProblem(PsiElement psiElement, @Nls String descriptionTemplate, LocalQuickFix... fixes) {
  50     registerProblem(psiElement, descriptionTemplate, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, fixes);
  51   }
  52
  53   public void registerProblem(PsiElement psiElement,
  54                               String descriptionTemplate,
  55                               ProblemHighlightType highlightType,
  56                               LocalQuickFix... fixes) {
  57     registerProblem(myManager.createProblemDescriptor(psiElement, descriptionTemplate, fixes, highlightType, myOnTheFly));
  58   }
  59
  60   public void registerProblem(ProblemDescriptor problemDescriptor) {
  61     if (myProblems == null) {
  62       myProblems = new ArrayList<ProblemDescriptor>(1);
  63     }
  64     PsiElement element = problemDescriptor.getPsiElement();
  65     if (element != null && !isInPsiFile(element)) {
  66       LOG.error("Reported element " + element + " is not from the file '" + myFile + "' the inspection was invoked for. Message:" + problemDescriptor.getDescriptionTemplate());
  67     }
  68     myProblems.add(problemDescriptor);
  69   }
  70
  71   private boolean isInPsiFile(@NotNull PsiElement element) {
  72     PsiFile file = element.getContainingFile();
  73     return ArrayUtil.indexOf(myFile.getPsiRoots(), file) != -1;
  74   }
  75
  76   public void registerProblem(PsiReference reference, String descriptionTemplate, ProblemHighlightType highlightType) {
  77     LocalQuickFix[] fixes = null;
  78     if (reference instanceof LocalQuickFixProvider) {
  79       fixes = ((LocalQuickFixProvider)reference).getQuickFixes();
  80     }
  81
  82     registerProblem(myManager.createProblemDescriptor(reference.getElement(), reference.getRangeInElement(), descriptionTemplate, highlightType,
  83                                                       myOnTheFly, fixes));
  84   }
  85
  86   public void registerProblem(PsiReference reference) {
  87     assert reference instanceof EmptyResolveMessageProvider;
  88     registerProblem(reference, ((EmptyResolveMessageProvider)reference).getUnresolvedMessagePattern(), ProblemHighlightType.LIKE_UNKNOWN_SYMBOL);
  89   }
  90
  91   public void registerProblem(@NotNull final PsiElement psiElement,
  92                               @NotNull final String message,
  93                               final ProblemHighlightType highlightType,
  94                               final TextRange rangeInElement,
  95                               final LocalQuickFix... fixes) {
  96
  97     final ProblemDescriptor descriptor = myManager.createProblemDescriptor(psiElement, rangeInElement, message, highlightType, myOnTheFly,
  98                                                                            fixes);
  99     registerProblem(descriptor);
 100   }
 101
 102   public void registerProblem(@NotNull final PsiElement psiElement,
 103                               final TextRange rangeInElement,
 104                               @NotNull final String message,
 105                               final LocalQuickFix... fixes) {
 106
 107     final ProblemDescriptor descriptor = myManager.createProblemDescriptor(psiElement, rangeInElement, message, ProblemHighlightType.GENERIC_ERROR_OR_WARNING, myOnTheFly, fixes);
 108     registerProblem(descriptor);
 109   }
 110
 111   @Nullable
 112   public List<ProblemDescriptor> getResults() {
 113     final List<ProblemDescriptor> problems = myProblems;
 114     myProblems = null;
 115     return problems;
 116   }
 117
 118   @Nullable
 119   public ProblemDescriptor[] getResultsArray() {
 120     final List<ProblemDescriptor> problems = myProblems;
 121     myProblems = null;
 122     return problems == null ? null : problems.toArray(new ProblemDescriptor[problems.size()]);
 123   }
 124
 125   public final InspectionManager getManager() {
 126     return myManager;
 127   }
 128   public boolean hasResults() {
 129     return myProblems != null && !myProblems.isEmpty();
 130   }
 131
 132   public boolean isOnTheFly() {
 133     return myOnTheFly;
 134   }
 135 }