Java WolfTheProblemSolver.getInstance方法代码示例

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
private void reportErrorsToWolf() {
  if (!getFile().getViewProvider().isPhysical()) return; // e.g. errors in evaluate expression
  Project project = getFile().getProject();
  if (!PsiManager.getInstance(project).isInProject(getFile())) return; // do not report problems in libraries
  VirtualFile file = getFile().getVirtualFile();
  if (file == null) return;

  List<Problem> problems = convertToProblems(getInfos(), file, myHasErrorElement);
  WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(project);

  boolean hasErrors = DaemonCodeAnalyzerEx.hasErrors(project, getDocument());
  if (!hasErrors || isWholeFileHighlighting()) {
    wolf.reportProblems(file, problems);
  }
  else {
    wolf.weHaveGotProblems(file, problems);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
@Override
public void run() {
  final VirtualFile[] files;
  synchronized (changedFiles) {
    wasRequested = false;
    files = changedFiles.toArray(new VirtualFile[changedFiles.size()]);
    changedFiles.clear();
  }

  final WolfTheProblemSolver problemSolver = WolfTheProblemSolver.getInstance(project);
  for (VirtualFile file : files) {
    if (problemSolver.hasSyntaxErrors(file)) {
      // threat any other file in queue as dependency of this file — don't flush if some of the queued file is invalid
      // Vladimir.Krivosheev AutoTestManager behavior behavior is preserved.
      // LiveEdit version used another strategy (flush all valid files), but now we use AutoTestManager-inspired strategy
      synchronized (changedFiles) {
        Collections.addAll(changedFiles, files);
      }

      return;
    }
  }

  consumer.consume(files);
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
private void reportErrorsToWolf() {
  if (!myFile.getViewProvider().isPhysical()) return; // e.g. errors in evaluate expression
  Project project = myFile.getProject();
  if (!PsiManager.getInstance(project).isInProject(myFile)) return; // do not report problems in libraries
  VirtualFile file = myFile.getVirtualFile();
  if (file == null) return;

  List<Problem> problems = convertToProblems(getInfos(), file, myHasErrorElement);
  WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(project);

  boolean hasErrors = DaemonCodeAnalyzerImpl.hasErrors(project, getDocument());
  if (!hasErrors || isWholeFileHighlighting()) {
    wolf.reportProblems(file, problems);
  }
  else {
    wolf.weHaveGotProblems(file, problems);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
private static void reportRelevantCompilationErrors(RenderLogger logger, HtmlBuilder builder, RenderService renderService) {
  Module module = logger.getModule();
  Project project = module.getProject();
  WolfTheProblemSolver wolfgang = WolfTheProblemSolver.getInstance(project);
  if (wolfgang.hasProblemFilesBeneath(module)) {
    if (logger.seenTagPrefix(TAG_RESOURCES_PREFIX)) {
      // Do we have errors in the res/ files?
      // See if it looks like we have aapt problems
      boolean haveResourceErrors = wolfgang.hasProblemFilesBeneath(new Condition<VirtualFile>() {
        @Override
        public boolean value(VirtualFile virtualFile) {
          return virtualFile.getFileType() == StdFileTypes.XML;
        }
      });
      if (haveResourceErrors) {
        builder.addBold("NOTE: This project contains resource errors, so aapt did not succeed, " +
                        "which can cause rendering failures. Fix resource problems first.");
        builder.newline().newline();
      }
    }
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
@Override
public void apply(@NotNull PsiFile file, List<RuntimeException> annotationResult, @NotNull AnnotationHolder holder) {
    if (file instanceof YAMLFile) {
        YAMLFile yamlFile = (YAMLFile) file;
        if (!yamlFile.getDocuments().isEmpty()) {
            YAMLDocument yamlDocument = yamlFile.getDocuments().get(0);
            PsiElement found = findChildRecursively(yamlDocument, new String[]{"flow", "operation", "decision"});
            if (found instanceof YAMLKeyValue) {
                YAMLKeyValue keyValue = (YAMLKeyValue) found;
                found = keyValue.getKey();
            } else {
                found = yamlDocument;
            }
            createErrorAnnotations(found, yamlFile, holder, annotationResult);
            createWarningsForMissingElementsInDescription(yamlDocument, yamlFile, holder);
        }
        if (!annotationResult.isEmpty()) {
            HighlightInfo highlightInfo = HighlightInfo.newHighlightInfo(HighlightInfoType.ERROR)
                    .descriptionAndTooltip("Found " + annotationResult.size() + " errors")
                    .range(file).create();
            if (highlightInfo != null) {
                Problem problem = new ProblemImpl(file.getVirtualFile(), highlightInfo, true);
                WolfTheProblemSolver theProblemSolver = WolfTheProblemSolver.getInstance(file.getProject());
                theProblemSolver.reportProblems(file.getVirtualFile(), Collections.singletonList(problem));
            }
        }
    }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
@Override
protected void collectInformationWithProgress(@NotNull final ProgressIndicator progress) {
  if (!Registry.is("wolf.the.problem.solver")) return;
  final WolfTheProblemSolver solver = WolfTheProblemSolver.getInstance(myProject);
  if (solver instanceof WolfTheProblemSolverImpl) {
    ((WolfTheProblemSolverImpl)solver).startCheckingIfVincentSolvedProblemsYet(progress, this);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
public void outputError(String error, int priority) {
  updateErrorAndWarningCounters(priority);
  final AntMessage message = createErrorMessage(priority, error);
  addCommand(new AddMessageCommand(message));
  WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(myProject);
  wolf.queue(message.getFile());
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
public void outputException(String exception) {
  updateErrorAndWarningCounters(PRIORITY_ERR);
  AntMessage message = createErrorMessage(PRIORITY_ERR, exception);
  addCommand(new AddExceptionCommand(message));
  WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(myProject);
  wolf.queue(message.getFile());
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
public void outputJavacMessage(MessageType type, String[] text, VirtualFile file, String url, int line, int column) {
  int priority = type == MessageType.ERROR ? PRIORITY_ERR : PRIORITY_VERBOSE;
  updateErrorAndWarningCounters(priority);
  final AntMessage message = new AntMessage(type, priority, text, file, line, column);
  addCommand(new AddJavacMessageCommand(message, url));
  if (type == MessageType.ERROR) {
    WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(myProject);
    wolf.queue(file);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
@Override
protected void collectInformationWithProgress(final ProgressIndicator progress) {
  if (!Registry.is("wolf.the.problem.solver", true)) return;
  final WolfTheProblemSolver solver = WolfTheProblemSolver.getInstance(myProject);
  if (solver instanceof WolfTheProblemSolverImpl) {
    ((WolfTheProblemSolverImpl)solver).startCheckingIfVincentSolvedProblemsYet(progress, this);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
public void outputError(String error, int priority) {
  //updateErrorAndWarningCounters(priority);
  AntMessage message = createErrorMessage(MessageType.ERROR, priority, error);
  addMessage(MessageType.ERROR, priority, error, message.getFile(), message.getLine(), message.getColumn());
  WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(myProject);
  wolf.queue(message.getFile());
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
public void outputException(String exception) {
  updateErrorAndWarningCounters(PRIORITY_ERR);
  AntMessage message = createErrorMessage(MessageType.ERROR, 0, exception);
  addCommand(new AddExceptionCommand(message));
  WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(myProject);
  wolf.queue(message.getFile());
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
public void outputJavacMessage(MessageType type, String[] text, VirtualFile file, String url, int line, int column) {
  int priority = type == MessageType.ERROR ? PRIORITY_ERR : PRIORITY_VERBOSE;
  updateErrorAndWarningCounters(priority);
  AntMessage message = new AntMessage(type, priority, text, file, line, column);
  addCommand(new AddJavacMessageCommand(message, url));
  if (type == MessageType.ERROR) {
    WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(myProject);
    wolf.queue(file);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
@Override
protected void collectInformationWithProgress(@Nonnull final ProgressIndicator progress) {
  if (!Registry.is("wolf.the.problem.solver")) return;
  final WolfTheProblemSolver solver = WolfTheProblemSolver.getInstance(myProject);
  if (solver instanceof WolfTheProblemSolverImpl) {
    ((WolfTheProblemSolverImpl)solver).startCheckingIfVincentSolvedProblemsYet(progress, this);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入方法依赖的package包/类
private void informWolf(final CompilerMessage message) {
  WolfTheProblemSolver wolf = WolfTheProblemSolver.getInstance(myProject);
  VirtualFile file = getVirtualFile(message);
  wolf.queue(file);
}