Java 类com.intellij.openapi.application.ReadAction 实例源码

private void doCollectUsages(final ProjectStructureElement element) {
  final List<ProjectStructureElementUsage> usages = new ReadAction<List<ProjectStructureElementUsage>>() {
    @Override
    protected void run(@NotNull final Result<List<ProjectStructureElementUsage>> result) {
      if (myStopped.get()) return;

      if (LOG.isDebugEnabled()) {
        LOG.debug("collecting usages in " + element);
      }
      result.setResult(getUsagesInElement(element));
    }
  }.execute().getResultObject();
  if (usages != null) {
    myResultsUpdateQueue.queue(new UsagesCollectedUpdate(element, usages));
  }
}

public static MultiMap<String, Artifact> createOutputToArtifactMap(final Project project) {
  final MultiMap<String, Artifact> result = MultiMap.create(FileUtil.PATH_HASHING_STRATEGY);
  new ReadAction() {
    protected void run(@NotNull final Result r) {
      for (Artifact artifact : ArtifactManager.getInstance(project).getArtifacts()) {
        String outputPath = artifact.getOutputFilePath();
        if (!StringUtil.isEmpty(outputPath)) {
          result.putValue(outputPath, artifact);
        }
      }
    }
  }.execute();


  return result;
}

/**
 * Read action will be taken automatically
 */
public static <RESULT> RESULT visit(@NotNull XSourcePosition position, @NotNull Project project, @NotNull Visitor<RESULT> visitor, RESULT defaultResult) {
  AccessToken token = ReadAction.start();
  try {
    Document document = FileDocumentManager.getInstance().getDocument(position.getFile());
    PsiFile file = document == null || document.getTextLength() == 0 ? null : PsiDocumentManager.getInstance(project).getPsiFile(document);
    if (file == null) {
      return defaultResult;
    }

    int positionOffset;
    int column = position instanceof SourceInfo ? Math.max(((SourceInfo)position).getColumn(), 0) : 0;
    try {
      positionOffset = column == 0 ? DocumentUtil.getFirstNonSpaceCharOffset(document, position.getLine()) : document.getLineStartOffset(position.getLine()) + column;
    }
    catch (IndexOutOfBoundsException ignored) {
      return defaultResult;
    }

    PsiElement element = file.findElementAt(positionOffset);
    return element == null ? defaultResult : visitor.visit(element, positionOffset, document);
  }
  finally {
    token.finish();
  }
}

@Override
public int getOffset() {
  if (offset == -1) {
    Document document;
    AccessToken token = ReadAction.start();
    try {
      document = file.isValid() ? FileDocumentManager.getInstance().getDocument(file) : null;
    }
    finally {
      token.finish();
    }

    if (document == null) {
      return -1;
    }

    offset = line < document.getLineCount() ? document.getLineStartOffset(line) : -1;
  }
  return offset;
}

/**
 * Allows to answer if any file that belongs to the given project has changes in comparison with VCS.
 * 
 * @param project  target project to check
 * @return         <code>true</code> if any file that belongs to the given project has changes in comparison with VCS
 *                 <code>false</code> otherwise
 */
public static boolean hasChanges(@NotNull final Project project) {
  final ModifiableModuleModel moduleModel = new ReadAction<ModifiableModuleModel>() {
    @Override
    protected void run(@NotNull Result<ModifiableModuleModel> result) throws Throwable {
      result.setResult(ModuleManager.getInstance(project).getModifiableModel());
    }
  }.execute().getResultObject();
  try {
    for (Module module : moduleModel.getModules()) {
      if (hasChanges(module)) {
        return true;
      }
    }
    return false;
  }
  finally {
    moduleModel.dispose();
  }
}

private void checkFiles() {
  final VirtualFile[] files;
  synchronized (myFilesToCheck) {
    files = myFilesToCheck.toArray(new VirtualFile[myFilesToCheck.size()]);
    myFilesToCheck.clear();
  }
  final List<VirtualFile> newEditedGeneratedFiles = new ArrayList<VirtualFile>();
  new ReadAction() {
    protected void run(final @NotNull Result result) {
      if (myProject.isDisposed()) return;
      for (VirtualFile file : files) {
        if (isGenerated(file)) {
          newEditedGeneratedFiles.add(file);
        }
      }
    }
  }.execute();

  if (!newEditedGeneratedFiles.isEmpty()) {
    myEditedGeneratedFiles.addAll(newEditedGeneratedFiles);
    myEditorNotifications.updateAllNotifications();
  }
}

@Override
public void processQuery(@NotNull final ReferencesSearch.SearchParameters queryParameters, @NotNull final Processor<PsiReference> consumer) {
  new ReadAction() {
    @Override
    protected void run(@NotNull final Result result) throws Throwable {
      final PsiElement refElement = queryParameters.getElementToSearch();
      if (PyMagicLiteralTools.isMagicLiteral(refElement)) {
        final String refText = ((StringLiteralExpression)refElement).getStringValue();
        if (!StringUtil.isEmpty(refText)) {
          final SearchScope searchScope = queryParameters.getEffectiveSearchScope();
          queryParameters.getOptimizer().searchWord(refText, searchScope, true, refElement);
        }
      }
    }
  }.execute();
}

/**
 * Tests skeletons for built-in classes. We can't compare files (CLR class may be changed from version to version),
 * but we are sure there should be class System.Web.AspNetHostingPermissionLevel which is part of public API
 */
public void testImportBuiltInSystem() throws Exception {
  final SkeletonTestTask task = new SkeletonTestTask(
    null,
    "System.Web",
    "import_system.py",
    null
  );
  runPythonTest(task);
  final PyFile skeleton = task.getGeneratedSkeleton();
  new ReadAction() {
    @Override
    protected void run(@NotNull Result result) throws Throwable {
      Assert.assertNotNull("System.Web does not contain class AspNetHostingPermissionLevel. Error generating stub? It has classes  " +
                           skeleton.getTopLevelClasses(),
                           skeleton.findTopLevelClass("AspNetHostingPermissionLevel"));
    }
  }.execute();

}

@Nullable
public static OpenInBrowserRequest create(@NotNull final PsiElement element) {
  PsiFile psiFile;
  AccessToken token = ReadAction.start();
  try {
    psiFile = element.isValid() ? element.getContainingFile() : null;
    if (psiFile == null || psiFile.getVirtualFile() == null) {
      return null;
    }
  }
  finally {
    token.finish();
  }

  return new OpenInBrowserRequest(psiFile) {
    @NotNull
    @Override
    public PsiElement getElement() {
      return element;
    }
  };
}

@Override
protected void setUpInWriteAction() throws Exception {
  super.setUpInWriteAction();

  final GradleResourceCompilerConfigurationGenerator buildConfigurationGenerator = new GradleResourceCompilerConfigurationGenerator(myProject);
  CompilerManager.getInstance(myProject).addBeforeTask(new CompileTask() {
    @Override
    public boolean execute(CompileContext context) {
      AccessToken token = ReadAction.start();
      try {
        buildConfigurationGenerator.generateBuildConfiguration(context);
      }
      finally {
        token.finish();
      }
      return true;
    }
  });
}

@Override
public void runActivity(@NotNull final Project project) {
  configureBuildClasspath(project);
  showNotificationForUnlinkedGradleProject(project);

  final GradleResourceCompilerConfigurationGenerator buildConfigurationGenerator = new GradleResourceCompilerConfigurationGenerator(project);
  CompilerManager.getInstance(project).addBeforeTask(new CompileTask() {
    @Override
    public boolean execute(CompileContext context) {
      AccessToken token = ReadAction.start();
      try {
        buildConfigurationGenerator.generateBuildConfiguration(context);
      }
      finally {
        token.finish();
      }
      return true;
    }
  });
}

public void scheduleUpdateIndicesList(@Nullable final Consumer<List<MavenIndex>> consumer) {
  myUpdateQueue.queue(new Update(MavenProjectIndicesManager.this) {
    public void run() {
      Set<Pair<String, String>> remoteRepositoriesIdsAndUrls;
      File localRepository;

      AccessToken accessToken = ReadAction.start();

      try {
        if (myProject.isDisposed()) return;

        remoteRepositoriesIdsAndUrls = collectRemoteRepositoriesIdsAndUrls();
        localRepository = getLocalRepository();
      }
      finally {
        accessToken.finish();
      }

      myProjectIndices = MavenIndicesManager.getInstance().ensureIndicesExist(myProject, localRepository, remoteRepositoriesIdsAndUrls);
      if(consumer != null) {
        consumer.consume(myProjectIndices);
      }
    }
  });
}

private static boolean processReferencesInUIForms(Processor<PsiReference> processor,
                                                  PsiManager psiManager,
                                                  PsiField field,
                                                  GlobalSearchScope scope1,
                                                  LocalSearchScope filterScope) {
  GlobalSearchScope scope = GlobalSearchScope.projectScope(psiManager.getProject()).intersectWith(scope1);
  final AccessToken token = ReadAction.start();
  PsiClass containingClass = field.getContainingClass();
  if (containingClass == null) return true;
  String fieldName;
  try {
    fieldName = field.getName();
  }
  finally {
    token.finish();
  }
  final List<PsiFile> files = FormClassIndex.findFormsBoundToClass(psiManager.getProject(), containingClass, scope);
  return processReferencesInFiles(files, psiManager, fieldName, field, filterScope, processor);
}

private static boolean containsGroovyClasses(final Project project) {
  return CachedValuesManager.getManager(project).getCachedValue(project, new CachedValueProvider<Boolean>() {
    @Nullable
    @Override
    public Result<Boolean> compute() {
      AccessToken accessToken = ReadAction.start();
      try {
        return Result.create(FileTypeIndex.containsFileOfType(GroovyFileType.GROOVY_FILE_TYPE, GlobalSearchScope.projectScope(project)),
                             PsiModificationTracker.JAVA_STRUCTURE_MODIFICATION_COUNT);
      }
      finally {
        accessToken.finish();
      }
    }
  });
}

/**
 * Runs the getter under a progress indicator that cancels itself after a certain timeout (assumes
 * that the getter will check for cancellation cooperatively).
 *
 * @param getter computes the GotoRelatedItems.
 * @return a list of items computed, or Optional.empty if timed out.
 */
private Optional<List<? extends GotoRelatedItem>> getItemsWithTimeout(
    ThrowableComputable<List<? extends GotoRelatedItem>, RuntimeException> getter) {
  try {
    ProgressIndicator indicator = new ProgressIndicatorBase();
    ProgressIndicator wrappedIndicator =
        new WatchdogIndicator(indicator, TIMEOUT_MS, TimeUnit.MILLISECONDS);
    // We don't use "runProcessWithProgressSynchronously" because that pops up a ProgressWindow,
    // and that will cause the event IDs to bump up and no longer match the event ID stored in
    // DataContexts which may be used in one of the GotoRelatedProvider#getItems overloads.
    return Optional.of(
        ProgressManager.getInstance()
            .runProcess(() -> ReadAction.compute(getter), wrappedIndicator));
  } catch (ProcessCanceledException e) {
    return Optional.empty();
  }
}

private void doCollectUsages(final ProjectStructureElement element) {
  final List<ProjectStructureElementUsage> usages = new ReadAction<List<ProjectStructureElementUsage>>() {
    @Override
    protected void run(final Result<List<ProjectStructureElementUsage>> result) {
      if (myStopped.get()) return;

      if (LOG.isDebugEnabled()) {
        LOG.debug("collecting usages in " + element);
      }
      result.setResult(getUsagesInElement(element));
    }
  }.execute().getResultObject();

  invokeLater(new Runnable() {
    @Override
    public void run() {
      if (myStopped.get() || usages == null) return;

      if (LOG.isDebugEnabled()) {
        LOG.debug("updating usages for " + element);
      }
      updateUsages(element, usages);
    }
  });
}

private boolean checkUnderReadAction(PsiFile file, CompileContext context, Computable<Map<ProblemDescriptor, HighlightDisplayLevel>> runnable) {
  AccessToken token = ReadAction.start();
  try {
    if (!file.isValid()) return false;

    final Document document = myPsiDocumentManager.getCachedDocument(file);
    if (document != null && myPsiDocumentManager.isUncommited(document)) {
      final String url = file.getViewProvider().getVirtualFile().getUrl();
      context.addMessage(CompilerMessageCategory.WARNING, CompilerBundle.message("warning.text.file.has.been.changed"), url, -1, -1);
      return false;
    }

    if (reportProblems(context, runnable.compute())) return false;
  }
  finally {
    token.finish();
  }
  return true;
}

public static MultiMap<String, Artifact> createOutputToArtifactMap(final Project project) {
  final MultiMap<String, Artifact> result = new MultiMap<String, Artifact>() {
    @Override
    protected Map<String, Collection<Artifact>> createMap() {
      return new THashMap<String, Collection<Artifact>>(FileUtil.PATH_HASHING_STRATEGY);
    }
  };
  new ReadAction() {
    protected void run(final Result r) {
      for (Artifact artifact : ArtifactManager.getInstance(project).getArtifacts()) {
        String outputPath = artifact.getOutputFilePath();
        if (!StringUtil.isEmpty(outputPath)) {
          result.putValue(outputPath, artifact);
        }
      }
    }
  }.execute();


  return result;
}

@Override
public CompileScope getAdditionalScope(@NotNull final CompileScope baseScope, @NotNull CompilerFilter filter, @NotNull final Project project) {
  if (ArtifactCompileScope.getArtifacts(baseScope) != null) {
    return null;
  }
  final ArtifactsCompiler compiler = ArtifactsCompiler.getInstance(project);
  if (compiler == null || !filter.acceptCompiler(compiler)) {
    return null;
  }
  return new ReadAction<CompileScope>() {
    protected void run(final Result<CompileScope> result) {
      final Set<Artifact> artifacts = ArtifactCompileScope.getArtifactsToBuild(project, baseScope, false);
      result.setResult(ArtifactCompileScope.createScopeForModulesInArtifacts(project, artifacts));
    } 
  }.execute().getResultObject();
}

/**
 * Allows to answer if any file that belongs to the given project has changes in comparison with VCS.
 * 
 * @param project  target project to check
 * @return         <code>true</code> if any file that belongs to the given project has changes in comparison with VCS
 *                 <code>false</code> otherwise
 */
public static boolean hasChanges(@NotNull final Project project) {
  final ModifiableModuleModel moduleModel = new ReadAction<ModifiableModuleModel>() {
    @Override
    protected void run(Result<ModifiableModuleModel> result) throws Throwable {
      result.setResult(ModuleManager.getInstance(project).getModifiableModel());
    }
  }.execute().getResultObject();
  try {
    for (Module module : moduleModel.getModules()) {
      if (hasChanges(module)) {
        return true;
      }
    }
    return false;
  }
  finally {
    moduleModel.dispose();
  }
}

private String getContextForKnownFacet(final @NotNull DeploymentModel deploymentModel, final @NotNull JavaEEModuleExtension javaeeFacet)
{
    String providedContext = getProvidedContext(deploymentModel);
    if(providedContext != null)
    {
        return providedContext;
    }

    return new ReadAction<String>()
    {

        @Override
        protected void run(@NotNull Result<String> result)
        {
            Class facetTypeId = javaeeFacet.getClass();
            for(FacetContextProvider facetContextProvider : getFacetContextProviders())
            {
                if(facetContextProvider.getFacetId().equals(facetTypeId))
                {
                    result.setResult(facetContextProvider.getDeploymentContext(getWebModuleContextProviders(), deploymentModel, javaeeFacet));
                    return;
                }
            }
        }
    }.execute().getResultObject();
}

@Override
public void fetchChildren(@Nonnull Function<T, TreeNode<T>> nodeFactory, @javax.annotation.Nullable T parentValue) {
  for (Object o : ReadAction.compute(() -> myStructure.getChildElements(parentValue))) {
    T element = (T)o;
    TreeNode<T> apply = nodeFactory.apply(element);

    apply.setLeaf(o instanceof AbstractTreeNode && !((AbstractTreeNode)o).isAlwaysShowPlus());


    apply.setRender((fileElement, itemPresentation) -> {
      NodeDescriptor descriptor = myStructure.createDescriptor(element, null);

      descriptor.update();

      itemPresentation.append(descriptor.toString());
      try {
        ReadAction.run(() -> itemPresentation.setIcon((consulo.ui.image.Image)descriptor.getIcon()));
      }
      catch (Exception e) {
        e.printStackTrace();
      }
    });
  }
}

@javax.annotation.Nullable
private static Document createPsiDocument(@Nonnull Project project,
                                          @Nonnull String content,
                                          @Nonnull FileType fileType,
                                          @Nonnull String fileName,
                                          boolean readOnly) {
  return ReadAction.compute(() -> {
    LightVirtualFile file = new LightVirtualFile(fileName, fileType, content);
    file.setWritable(!readOnly);

    file.putUserData(DiffPsiFileSupport.KEY, true);

    Document document = FileDocumentManager.getInstance().getDocument(file);
    if (document == null) return null;

    PsiDocumentManager.getInstance(project).getPsiFile(document);

    return document;
  });
}

public static MultiMap<String, Artifact> createOutputToArtifactMap(final Project project) {
  final MultiMap<String, Artifact> result = new MultiMap<String, Artifact>() {
    @Nonnull
    @Override
    protected Map<String, Collection<Artifact>> createMap() {
      return new THashMap<String, Collection<Artifact>>(FileUtil.PATH_HASHING_STRATEGY);
    }
  };
  new ReadAction() {
    @Override
    protected void run(final Result r) {
      for (Artifact artifact : ArtifactManager.getInstance(project).getArtifacts()) {
        String outputPath = artifact.getOutputFilePath();
        if (!StringUtil.isEmpty(outputPath)) {
          result.putValue(outputPath, artifact);
        }
      }
    }
  }.execute();


  return result;
}

/**
 * Pause the current thread until dumb mode ends, and then run the read action. Index is guaranteed to be available inside that read action,
 * unless this method is already called with read access allowed.
 *
 * @throws ProcessCanceledException if the project is closed during dumb mode
 */
public void runReadActionInSmartMode(@Nonnull Runnable r) {
  if (ApplicationManager.getApplication().isReadAccessAllowed()) {
    // we can't wait for smart mode to begin (it'd result in a deadlock),
    // so let's just pretend it's already smart and fail with IndexNotReadyException if not
    r.run();
    return;
  }

  while (true) {
    waitForSmartMode();
    boolean success = ReadAction.compute(() -> {
      if (getProject().isDisposed()) {
        throw new ProcessCanceledException();
      }
      if (isDumb()) {
        return false;
      }
      r.run();
      return true;
    });
    if (success) break;
  }
}

@Override
boolean pointsToTheSameElementAs(@Nonnull final SmartPointerElementInfo other) {
  if (other instanceof SelfElementInfo) {
    final SelfElementInfo otherInfo = (SelfElementInfo)other;
    if (!getVirtualFile().equals(other.getVirtualFile()) || myIdentikit != otherInfo.myIdentikit) return false;

    return ReadAction.compute(() -> {
      Segment range1 = getPsiRange();
      Segment range2 = otherInfo.getPsiRange();
      return range1 != null && range2 != null
             && range1.getStartOffset() == range2.getStartOffset()
             && range1.getEndOffset() == range2.getEndOffset();
    });
  }
  return false;
}

@Override
public boolean pointsToTheSameElementAs(@Nonnull final SmartPointerElementInfo other) {
  if (other instanceof AnchorElementInfo) {
    if (!getVirtualFile().equals(other.getVirtualFile())) return false;

    long packed1 = myStubElementTypeAndId;
    long packed2 = ((AnchorElementInfo)other).myStubElementTypeAndId;

    if (packed1 != -1 && packed2 != -1) {
      return packed1 == packed2;
    }
    if (packed1 != -1 || packed2 != -1) {
      return ReadAction.compute(() -> Comparing.equal(restoreElement(), other.restoreElement()));
    }
  }
  return super.pointsToTheSameElementAs(other);
}

public static FilePath getLocalPath(@Nonnull Project project, FilePath filePath) {
  // check if the file has just been renamed (IDEADEV-15494)
  Change change = ReadAction.compute(() -> {
    if (project.isDisposed()) throw new ProcessCanceledException();
    return ChangeListManager.getInstance(project).getChange(filePath);
  });
  if (change != null) {
    ContentRevision beforeRevision = change.getBeforeRevision();
    ContentRevision afterRevision = change.getAfterRevision();
    if (beforeRevision != null && afterRevision != null && !beforeRevision.getFile().equals(afterRevision.getFile()) &&
        beforeRevision.getFile().equals(filePath)) {
      return afterRevision.getFile();
    }
  }
  return filePath;
}

private <B extends XBreakpoint<?>> void handleBreakpoint(final XBreakpointHandler<B> handler, final B b, final boolean register,
                                                         final boolean temporary) {
  if (register) {
    boolean active = ReadAction.compute(() -> isBreakpointActive(b));
    if (active) {
      synchronized (myRegisteredBreakpoints) {
        myRegisteredBreakpoints.put(b, new CustomizedBreakpointPresentation());
      }
      handler.registerBreakpoint(b);
    }
  }
  else {
    boolean removed;
    synchronized (myRegisteredBreakpoints) {
      removed = myRegisteredBreakpoints.remove(b) != null;
    }
    if (removed) {
      handler.unregisterBreakpoint(b, temporary);
    }
  }
}

@Nonnull
static PsiElement[] getSelfAndImplementations(Editor editor,
                                              @Nonnull PsiElement element,
                                              @Nonnull ImplementationSearcher handler,
                                              final boolean includeSelfAlways) {
  final PsiElement[] handlerImplementations = handler.searchImplementations(element, editor, includeSelfAlways, true);
  if (handlerImplementations.length > 0) return handlerImplementations;

  return ReadAction.compute(() -> {
    PsiElement psiElement = element;
    PsiFile psiFile = psiElement.getContainingFile();
    if (psiFile == null) {
      // Magically, it's null for ant property declarations.
      psiElement = psiElement.getNavigationElement();
      psiFile = psiElement.getContainingFile();
      if (psiFile == null) {
        return PsiElement.EMPTY_ARRAY;
      }
    }
    if (psiFile.getVirtualFile() != null && (psiElement.getTextRange() != null || psiElement instanceof PsiFile)) {
      return new PsiElement[]{psiElement};
    }
    return PsiElement.EMPTY_ARRAY;
  });
}

/**
 * Allows to answer if any file that belongs to the given project has changes in comparison with VCS.
 *
 * @param project  target project to check
 * @return         <code>true</code> if any file that belongs to the given project has changes in comparison with VCS
 *                 <code>false</code> otherwise
 */
public static boolean hasChanges(@Nonnull final Project project) {
  final ModifiableModuleModel moduleModel = new ReadAction<ModifiableModuleModel>() {
    @Override
    protected void run(@Nonnull Result<ModifiableModuleModel> result) throws Throwable {
      result.setResult(ModuleManager.getInstance(project).getModifiableModel());
    }
  }.execute().getResultObject();
  try {
    for (Module module : moduleModel.getModules()) {
      if (hasChanges(module)) {
        return true;
      }
    }
    return false;
  }
  finally {
    moduleModel.dispose();
  }
}

private void doCollectUsages(final ProjectStructureElement element) {
  final List<ProjectStructureElementUsage> usages = new ReadAction<List<ProjectStructureElementUsage>>() {
    @Override
    protected void run(final Result<List<ProjectStructureElementUsage>> result) {
      if (myStopped.get()) return;

      if (LOG.isDebugEnabled()) {
        LOG.debug("collecting usages in " + element);
      }
      result.setResult(getUsagesInElement(element));
    }
  }.execute().getResultObject();

  invokeLater(new Runnable() {
    @Override
    public void run() {
      if (myStopped.get() || usages == null) return;

      if (LOG.isDebugEnabled()) {
        LOG.debug("updating usages for " + element);
      }
      updateUsages(element, usages);
    }
  });
}

public PsiDocumentManagerImpl(@Nonnull final Project project,
                              @Nonnull PsiManager psiManager,
                              @Nonnull EditorFactory editorFactory,
                              @Nonnull MessageBus bus,
                              @NonNls @Nonnull final DocumentCommitProcessor documentCommitThread) {
  super(project, psiManager, bus, documentCommitThread);
  myDocumentCommitThread = documentCommitThread;
  editorFactory.getEventMulticaster().addDocumentListener(this, project);
  MessageBusConnection connection = bus.connect();
  connection.subscribe(AppTopics.FILE_DOCUMENT_SYNC, new FileDocumentManagerAdapter() {
    @Override
    public void fileContentLoaded(@Nonnull final VirtualFile virtualFile, @Nonnull Document document) {
      PsiFile psiFile = ReadAction.compute(() -> myProject.isDisposed() || !virtualFile.isValid() ? null : getCachedPsiFile(virtualFile));
      fireDocumentCreated(document, psiFile);
    }
  });
  connection.subscribe(DocumentBulkUpdateListener.TOPIC, new DocumentBulkUpdateListener.Adapter() {
    @Override
    public void updateFinished(@Nonnull Document doc) {
      documentCommitThread.commitAsynchronously(project, doc, "Bulk update finished", TransactionGuard.getInstance().getContextTransaction());
    }
  });
  Disposer.register(project, () -> ((DocumentCommitThread)myDocumentCommitThread).cancelTasksOnProjectDispose(project));
}

static int processUsagesInFile(@Nonnull final PsiFile psiFile, @Nonnull final VirtualFile virtualFile, @Nonnull final FindModel findModel, @Nonnull final Processor<UsageInfo> consumer) {
  if (findModel.getStringToFind().isEmpty()) {
    if (!ReadAction.compute(() -> consumer.process(new UsageInfo(psiFile)))) {
      throw new ProcessCanceledException();
    }
    return 1;
  }
  if (virtualFile.getFileType().isBinary()) return 0; // do not decompile .class files
  final Document document = ReadAction.compute(() -> virtualFile.isValid() ? FileDocumentManager.getInstance().getDocument(virtualFile) : null);
  if (document == null) return 0;
  final int[] offset = {0};
  int count = 0;
  int found;
  ProgressIndicator indicator = ProgressWrapper.unwrap(ProgressManager.getInstance().getProgressIndicator());
  TooManyUsagesStatus tooManyUsagesStatus = TooManyUsagesStatus.getFrom(indicator);
  do {
    tooManyUsagesStatus.pauseProcessingIfTooManyUsages(); // wait for user out of read action
    found = ReadAction.compute(() -> {
      if (!psiFile.isValid()) return 0;
      return addToUsages(document, consumer, findModel, psiFile, offset, USAGES_PER_READ_ACTION);
    });
    count += found;
  }
  while (found != 0);
  return count;
}

@Nonnull
static String buildStringToFindForIndicesFromRegExp(@Nonnull String stringToFind, @Nonnull Project project) {
  if (!Registry.is("idea.regexp.search.uses.indices")) return "";

  return ReadAction.compute(() -> {
    final List<PsiElement> topLevelRegExpChars = getTopLevelRegExpChars("a", project);
    if (topLevelRegExpChars.size() != 1) return "";

    // leave only top level regExpChars
    return StringUtil.join(getTopLevelRegExpChars(stringToFind, project), new Function<PsiElement, String>() {
      final Class regExpCharPsiClass = topLevelRegExpChars.get(0).getClass();

      @Override
      public String fun(PsiElement element) {
        if (regExpCharPsiClass.isInstance(element)) {
          String text = element.getText();
          if (!text.startsWith("\\")) return text;
        }
        return " ";
      }
    }, "");
  });
}

/**
 * Finds duplicates of the code fragment specified in the finder in given scopes.
 * Note that in contrast to {@link #processDuplicates} the search is performed synchronously because normally you need the results in
 * order to complete the refactoring. If user cancels it, empty list will be returned.
 *
 * @param finder          finder object to seek for duplicates
 * @param searchScopes    scopes where to look them in
 * @param generatedMethod new method that should be excluded from the search
 * @return list of discovered duplicate code fragments or empty list if user interrupted the search
 * @see #replaceDuplicates(PsiElement, Editor, Consumer, List)
 */
@Nonnull
public static List<SimpleMatch> collectDuplicates(@Nonnull SimpleDuplicatesFinder finder,
                                                  @Nonnull List<PsiElement> searchScopes,
                                                  @Nonnull PsiElement generatedMethod) {
  final Project project = generatedMethod.getProject();
  try {
    //noinspection RedundantCast
    return ProgressManager.getInstance().runProcessWithProgressSynchronously(
            (ThrowableComputable<List<SimpleMatch>, RuntimeException>)() -> {
              ProgressManager.getInstance().getProgressIndicator().setIndeterminate(true);
              return ReadAction.compute(() -> finder.findDuplicates(searchScopes, generatedMethod));
            }, RefactoringBundle.message("searching.for.duplicates"), true, project);
  }
  catch (ProcessCanceledException e) {
    return Collections.emptyList();
  }
}

public static ClassLoader createUsersClassLoader(JavaTestConfigurationBase configuration)
{
    Module module = configuration.getConfigurationModule().getModule();
    List<URL> urls = new ArrayList<>();

    PathsList pathsList = ReadAction.compute(() -> (module == null || configuration.getTestSearchScope() == TestSearchScope.WHOLE_PROJECT ? OrderEnumerator.orderEntries(configuration.getProject
            ()) : OrderEnumerator.orderEntries(module)).runtimeOnly().recursively().getPathsList()); //include jdk to avoid NoClassDefFoundError for classes inside tools.jar
    for(VirtualFile file : pathsList.getVirtualFiles())
    {
        try
        {
            urls.add(VfsUtilCore.virtualToIoFile(file).toURI().toURL());
        }
        catch(MalformedURLException ignored)
        {
            LOG.info(ignored);
        }
    }

    return UrlClassLoader.build().allowLock().useCache().urls(urls).get();
}

private static boolean addAliasingUsages(@NotNull PomTarget pomTarget, @NotNull final FindUsagesOptions options, @NotNull final Processor<UsageInfo> processor)
{
    for(AliasingPsiTargetMapper aliasingPsiTargetMapper : Extensions.getExtensions(AliasingPsiTargetMapper.EP_NAME))
    {
        for(final AliasingPsiTarget psiTarget : aliasingPsiTargetMapper.getTargets(pomTarget))
        {
            boolean success = ReferencesSearch.search(new ReferencesSearch.SearchParameters(ReadAction.compute(() -> PomService.convertToPsi(psiTarget)), options.searchScope, false, options
                    .fastTrack)).forEach(new ReadActionProcessor<PsiReference>()
            {
                @Override
                public boolean processInReadAction(final PsiReference reference)
                {
                    return addResult(reference, options, processor);
                }
            });
            if(!success)
            {
                return false;
            }
        }
    }
    return true;
}

@NotNull
private static Query<PsiMember> createQuery(@NotNull PsiClass target, @NotNull PsiClass annClass)
{
    PsiImmediateClassType type = new PsiImmediateClassType(target, PsiSubstitutor.EMPTY);
    return new FilteredQuery<>(AnnotatedMembersSearch.search(annClass), psiMember -> ReadAction.compute(() ->
    {
        if(psiMember instanceof PsiMethod && !psiMember.hasModifierProperty(PsiModifier.STATIC))
        {
            PsiParameterList parameterList = ((PsiMethod) psiMember).getParameterList();
            PsiParameter[] parameters = parameterList.getParameters();
            if(parameters.length == 1 && parameters[0].getType().equals(type))
            {
                return true;
            }
        }
        return false;
    }));
}

@Nullable
private static String findOwnerMethod(final PsiFile file, final int offset)
{
    if(offset < 0 /*|| file instanceof JspFile*/)
    {
        return null;
    }
    if(file instanceof PsiClassOwner)
    {
        return ReadAction.compute(() ->
        {
            PsiMethod method = DebuggerUtilsEx.findPsiMethod(file, offset);
            return method != null ? method.getName() : null;
        });
    }
    return null;
}