import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
private boolean matchesScope(VirtualFile file, Project project, ProjectFileIndex fileIndex) {
  if (file == null) return false;
  boolean isSource = fileIndex.isInSourceContent(file);
  if (myScope == SCOPE_ANY) {
    return fileIndex.isInContent(file) && FilePatternPackageSet.matchesModule(myModuleGroupPattern, myModulePattern, file, fileIndex);
  }
  if (myScope == SCOPE_SOURCE) {
    return isSource && !fileIndex.isInTestSourceContent(file) && FilePatternPackageSet.matchesModule(myModuleGroupPattern, myModulePattern,
                                                                                                     file, fileIndex);
  }
  if (myScope == SCOPE_LIBRARY) {
    return (fileIndex.isInLibraryClasses(file) || fileIndex.isInLibrarySource(file)) && matchesLibrary(myModulePattern, file, fileIndex);
  }
  if (myScope == SCOPE_TEST) {
    return isSource && fileIndex.isInTestSourceContent(file) && FilePatternPackageSet.matchesModule(myModuleGroupPattern, myModulePattern,
                                                                                                    file, fileIndex);
  }
  if (myScope == SCOPE_PROBLEM) {
    return isSource && WolfTheProblemSolver.getInstance(project).isProblemFile(file) &&
           FilePatternPackageSet.matchesModule(myModuleGroupPattern, myModulePattern, file, fileIndex);
  }
  throw new RuntimeException("Unknown scope: " + myScope);
}
 

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 projectOpened() {
  MessageBusConnection connection = myProject.getMessageBus().connect(myProject);
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          if (myProject.isDisposed()) return;
          VcsDirtyScopeManager.getInstance(myProject).markEverythingDirty();
        }
      }, ModalityState.NON_MODAL);
    }
  });
  final WolfTheProblemSolver.ProblemListener myProblemListener = new MyProblemListener();
  WolfTheProblemSolver.getInstance(myProject).addProblemListener(myProblemListener,myProject);
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
public PsiAwareFileEditorManagerImpl(final Project project,
                                     final PsiManager psiManager,
                                     final WolfTheProblemSolver problemSolver,
                                     DockManager dockManager,
                                     MessageBus messageBus,
                                     EditorHistoryManager editorHistoryManager) {
  super(project, dockManager, editorHistoryManager);
  myPsiManager = psiManager;
  myProblemSolver = problemSolver;
  myPsiTreeChangeListener = new MyPsiTreeChangeListener();
  myProblemListener = new MyProblemListener();
  registerExtraEditorDataProvider(new TextEditorPsiDataProvider(), null);

  // reinit syntax highlighter for Groovy. In power save mode keywords are highlighted by GroovySyntaxHighlighter insteadof
  // GrKeywordAndDeclarationHighlighter. So we need to drop caches for token types attributes in LayeredLexerEditorHighlighter
  messageBus.connect().subscribe(PowerSaveMode.TOPIC, new PowerSaveMode.Listener() {
    @Override
    public void powerSaveStateChanged() {
      for (Editor editor : EditorFactory.getInstance().getAllEditors()) {
        ((EditorEx)editor).reinitSettings();
      }
    }
  });
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
public DefaultScopesProvider(@NotNull Project project) {
  myProject = project;
  final NamedScope projectScope = new ProjectFilesScope();
  final NamedScope nonProjectScope = new NonProjectFilesScope();
  final String text = FilePatternPackageSet.SCOPE_FILE + ":*//*";
  myProblemsScope = new NamedScope(IdeBundle.message("predefined.scope.problems.name"), new AbstractPackageSet(text) {
    @Override
    public boolean contains(VirtualFile file, @NotNull NamedScopesHolder holder) {
      return contains(file, holder.getProject(), holder);
    }

    @Override
    public boolean contains(VirtualFile file, @NotNull Project project, @Nullable NamedScopesHolder holder) {
      return project == myProject
             && WolfTheProblemSolver.getInstance(myProject).isProblemFile(file);
    }
  });
  myScopes = Arrays.asList(projectScope, getProblemsScope(), getAllScope(), nonProjectScope);
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
static void unsubscribeFrom(NavBarPanel panel) {
  final NavBarListener listener = (NavBarListener)panel.getClientProperty(LISTENER);
  panel.putClientProperty(LISTENER, null);
  if (listener != null) {
    final Project project = panel.getProject();
    KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener(listener);
    FileStatusManager.getInstance(project).removeFileStatusListener(listener);
    PsiManager.getInstance(project).removePsiTreeChangeListener(listener);
    WolfTheProblemSolver.getInstance(project).removeProblemListener(listener);
    ActionManager.getInstance().removeAnActionListener(listener);
    final MessageBusConnection connection = (MessageBusConnection)panel.getClientProperty(BUS);
    panel.putClientProperty(BUS, null);
    if (connection != null) {
      connection.disconnect();
    }
    LafManager.getInstance().removeLafManagerListener(listener);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
private static void refreshFile(@NotNull final StudyState studyState, @NotNull final Project project) {
  final Editor editor = studyState.getEditor();
  final TaskFile taskFile = studyState.getTaskFile();
  if (!resetTaskFile(editor.getDocument(), project, taskFile, studyState.getVirtualFile().getName())) {
    Messages.showInfoMessage("The initial text of task file is unavailable", "Failed to Refresh Task File");
    return;
  }
  WolfTheProblemSolver.getInstance(project).clearProblems(studyState.getVirtualFile());
  taskFile.setHighlightErrors(false);
  StudyUtils.drawAllWindows(editor, taskFile);
  EduAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile, true);
  ApplicationManager.getApplication().invokeLater(new Runnable() {
    @Override
    public void run() {
      IdeFocusManager.getInstance(project).requestFocus(editor.getContentComponent(), true);
    }
  });

  StudyNavigator.navigateToFirstAnswerPlaceholder(editor, taskFile);
  showBalloon(project, "You can start again now", MessageType.INFO);
}
 

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包/类
@Override
public void projectOpened() {
  MessageBusConnection connection = myProject.getMessageBus().connect(myProject);
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      ApplicationManager.getApplication().invokeLater(new Runnable() {
        @Override
        public void run() {
          if (myProject.isDisposed() || !DirectoryIndex.getInstance(myProject).isInitialized()) return;
          VcsDirtyScopeManager.getInstance(myProject).markEverythingDirty();
        }
      }, ModalityState.NON_MODAL);
    }
  });
  final WolfTheProblemSolver.ProblemListener myProblemListener = new MyProblemListener();
  WolfTheProblemSolver.getInstance(myProject).addProblemListener(myProblemListener,myProject);
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
static void unsubscribeFrom(NavBarPanel panel) {
  final NavBarListener listener = (NavBarListener)panel.getClientProperty(LISTENER);
  panel.putClientProperty(LISTENER, null);
  if (listener != null) {
    final Project project = panel.getProject();
    KeyboardFocusManager.getCurrentKeyboardFocusManager().removePropertyChangeListener(listener);
    FileStatusManager.getInstance(project).removeFileStatusListener(listener);
    PsiManager.getInstance(project).removePsiTreeChangeListener(listener);
    WolfTheProblemSolver.getInstance(project).removeProblemListener(listener);
    ActionManager.getInstance().removeAnActionListener(listener);
    final MessageBusConnection connection = (MessageBusConnection)panel.getClientProperty(BUS);
    panel.putClientProperty(BUS, null);
    if (connection != null) {
      connection.disconnect();
    }
  }
}
 

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包/类
public PsiAwareFileEditorManagerImpl(final Project project,
                                     final PsiManager psiManager,
                                     final WolfTheProblemSolver problemSolver,
                                     DockManager dockManager) {
  super(project, dockManager);

  myPsiManager = psiManager;
  myProblemSolver = problemSolver;
  myPsiTreeChangeListener = new MyPsiTreeChangeListener();
  myProblemListener = new MyProblemListener();
  registerExtraEditorDataProvider(new TextEditorPsiDataProvider(), null);

  // reinit syntax highlighter for Groovy. In power save mode keywords are highlighted by GroovySyntaxHighlighter insteadof
  // GrKeywordAndDeclarationHighlighter. So we need to drop caches for token types attributes in LayeredLexerEditorHighlighter
  project.getMessageBus().connect().subscribe(PowerSaveMode.TOPIC, new PowerSaveMode.Listener() {
    @Override
    public void powerSaveStateChanged() {
      UIUtil.invokeLaterIfNeeded(() -> {
        for (Editor editor : EditorFactory.getInstance().getAllEditors()) {
          ((EditorEx)editor).reinitSettings();
        }
      });
    }
  });
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
private static void refreshFile(@NotNull final StudyState studyState, @NotNull final Project project) {
  final Editor editor = studyState.getEditor();
  final TaskFile taskFile = studyState.getTaskFile();
  final Task task = taskFile.getTask();
  if (task instanceof TaskWithSubtasks) {
    for (AnswerPlaceholder placeholder : taskFile.getActivePlaceholders()) {
      StudySubtaskUtils.refreshPlaceholder(editor, placeholder);
    }
  }
  else {
    if (!resetTaskFile(editor.getDocument(), project, taskFile)) {
      Messages.showInfoMessage("The initial text of task file is unavailable", "Failed to Refresh Task File");
      return;
    }
    if (task instanceof ChoiceTask) {
      final StudyToolWindow window = StudyUtils.getStudyToolWindow(project);
      if (window != null) {
        window.setBottomComponent(new StudyChoiceVariantsPanel((ChoiceTask)task));
      }
    }
  }
  WolfTheProblemSolver.getInstance(project).clearProblems(studyState.getVirtualFile());
  taskFile.setHighlightErrors(false);
  StudyUtils.drawAllAnswerPlaceholders(editor, taskFile);
  EduAnswerPlaceholderPainter.createGuardedBlocks(editor, taskFile);
  ApplicationManager.getApplication().invokeLater(
    () -> IdeFocusManager.getInstance(project).requestFocus(editor.getContentComponent(), true));

  StudyNavigator.navigateToFirstAnswerPlaceholder(editor, taskFile);
  showBalloon(project, MessageType.INFO);
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
@Override
public void editorCreated(@NotNull final EditorFactoryEvent event) {
  final Editor editor = event.getEditor();
  final Project project = editor.getProject();
  if (project == null) {
    return;
  }

  final Document document = editor.getDocument();
  final VirtualFile openedFile = FileDocumentManager.getInstance().getFile(document);
  if (openedFile != null) {
    final TaskFile taskFile = StudyUtils.getTaskFile(project, openedFile);
    if (taskFile != null) {
      WolfTheProblemSolver.getInstance(project).clearProblems(openedFile);
      final ToolWindow studyToolWindow = ToolWindowManager.getInstance(project).getToolWindow(StudyToolWindowFactory.STUDY_TOOL_WINDOW);
      if (studyToolWindow != null) {
        StudyUtils.updateToolWindows(project);
        studyToolWindow.show(null);
      }
      Course course = StudyTaskManager.getInstance(project).getCourse();
      if (course == null) {
        return;
      }

      StudyEditor.addDocumentListener(document, new EduDocumentListener(taskFile, true));

      if (!taskFile.getAnswerPlaceholders().isEmpty()) {
        StudyNavigator.navigateToFirstAnswerPlaceholder(editor, taskFile);
        boolean isStudyProject = EduNames.STUDY.equals(course.getCourseMode());
        StudyUtils.drawAllAnswerPlaceholders(editor, taskFile);
        if (isStudyProject) {
          editor.addEditorMouseListener(new WindowSelectionListener(taskFile));
        }
      }
    }
  }
}
 

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包/类
static void subscribeTo(NavBarPanel panel) {
  if (panel.getClientProperty(LISTENER) != null) {
    unsubscribeFrom(panel);
  }

  final NavBarListener listener = new NavBarListener(panel);
  final Project project = panel.getProject();
  panel.putClientProperty(LISTENER, listener);
  KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener(listener);
  FileStatusManager.getInstance(project).addFileStatusListener(listener);
  PsiManager.getInstance(project).addPsiTreeChangeListener(listener);
  WolfTheProblemSolver.getInstance(project).addProblemListener(listener);
  ActionManager.getInstance().addAnActionListener(listener);

  final MessageBusConnection connection = project.getMessageBus().connect();
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, listener);
  connection.subscribe(NavBarModelListener.NAV_BAR, listener);
  connection.subscribe(FileEditorManagerListener.FILE_EDITOR_MANAGER, listener);
  panel.putClientProperty(BUS, connection);
  panel.addKeyListener(listener);

  if (panel.isInFloatingMode()) {
    final Window window = SwingUtilities.windowForComponent(panel);
    if (window != null) {
      window.addWindowFocusListener(listener);
    }
  } else {
    LafManager.getInstance().addLafManagerListener(listener);
  }
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
public ProjectTreeBuilder(@NotNull Project project,
                          @NotNull JTree tree,
                          @NotNull DefaultTreeModel treeModel,
                          @Nullable Comparator<NodeDescriptor> comparator,
                          @NotNull ProjectAbstractTreeStructureBase treeStructure) {
  super(project, tree, treeModel, treeStructure, comparator);

  final MessageBusConnection connection = project.getMessageBus().connect(this);

  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new ModuleRootAdapter() {
    @Override
    public void rootsChanged(ModuleRootEvent event) {
      queueUpdate();
    }
  });

  connection.subscribe(BookmarksListener.TOPIC, new MyBookmarksListener());

  PsiManager.getInstance(project).addPsiTreeChangeListener(createPsiTreeChangeListener(project), this);
  FileStatusManager.getInstance(project).addFileStatusListener(new MyFileStatusListener(), this);
  CopyPasteManager.getInstance().addContentChangedListener(new CopyPasteUtil.DefaultCopyPasteListener(getUpdater()), this);

  WolfTheProblemSolver.getInstance(project).addProblemListener(new MyProblemListener(), this);

  setCanYieldUpdate(true);

  initRootNode();
}
 

import com.intellij.problems.WolfTheProblemSolver; //导入依赖的package包/类
public void initListeners() {
  final MessageBusConnection connection = myProject.getMessageBus().connect(this);
  connection.subscribe(ProjectTopics.PROJECT_ROOTS, new MyModuleRootListener());
  PsiManager.getInstance(myProject).addPsiTreeChangeListener(myPsiTreeChangeAdapter);
  WolfTheProblemSolver.getInstance(myProject).addProblemListener(myProblemListener);
  ChangeListManager.getInstance(myProject).addChangeListListener(myChangesListListener);
  FileStatusManager.getInstance(myProject).addFileStatusListener(myFileStatusListener, myProject);
}