import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
private static void prefetchProjectFiles(Project project) {
  if (!Blaze.isBlazeProject(project)) {
    return;
  }
  BlazeProjectData projectData = getBlazeProjectData(project);
  ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
  if (projectViewSet == null) {
    return;
  }
  long start = System.currentTimeMillis();
  ListenableFuture<?> future =
      PrefetchService.getInstance().prefetchProjectFiles(project, projectViewSet, projectData);
  TransactionGuard.submitTransaction(
      project,
      () -> {
        DumbService.getInstance(project).queueTask(new PrefetchTask(future, start));
      });
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
private void refactor(String currentStepText, String newStepText, TransactionId contextTransaction, CompileContext context, RefactorStatusCallback refactorStatusCallback) {
    refactorStatusCallback.onStatusChange("Refactoring...");
    Module module = GaugeUtil.moduleForPsiElement(file);
    TransactionGuard.getInstance().submitTransaction(() -> {
    }, contextTransaction, () -> {
        Api.PerformRefactoringResponse response = null;
        FileDocumentManager.getInstance().saveAllDocuments();
        FileDocumentManager.getInstance().saveDocumentAsIs(editor.getDocument());
        GaugeService gaugeService = Gauge.getGaugeService(module, true);
        try {
            response = gaugeService.getGaugeConnection().sendPerformRefactoringRequest(currentStepText, newStepText);
        } catch (Exception e) {
            refactorStatusCallback.onFinish(new RefactoringStatus(false, String.format("Could not execute refactor command: %s", e.toString())));
            return;
        }
        new UndoHandler(response.getFilesChangedList(), module.getProject(), "Refactoring").handle();
        if (!response.getSuccess()) {
            showMessage(response, context, refactorStatusCallback);
            return;
        }
        refactorStatusCallback.onFinish(new RefactoringStatus(true));
    });
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
/**
 * Updates route list. The method starts task that call 'rake routes' and parses result after complete.
 * After routes are parsed, Routes panel is updated.
 *
 * @return True if update task is started, false if new task is not started because routes update is in progress.
 */
public boolean updateRouteList() {
    if (isUpdating())
        return false;

    setState(UPDATING);

    // Save all documents to make sure that requestMethods will be collected using actual files.
    TransactionGuard.submitTransaction(ApplicationManager.getApplication(), () -> {
        FileDocumentManager.getInstance().saveAllDocuments();

        // Start background task.
        (new UpdateRoutesTask()).queue();
    });

    return true;
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
public static void performActionDumbAware(AnAction action, AnActionEvent e) {
  Runnable runnable = new Runnable() {
    @Override
    public void run() {
      try {
        action.actionPerformed(e);
      }
      catch (IndexNotReadyException e1) {
        showDumbModeWarning(e);
      }
    }

    @Override
    public String toString() {
      return action + " of " + action.getClass();
    }
  };

  if (action.startInTransaction()) {
    TransactionGuard.getInstance().submitTransactionAndWait(runnable);
  }
  else {
    runnable.run();
  }
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
public void run(boolean newConfigFolder) {
  try {
    ApplicationEx app = ApplicationManagerEx.getApplicationEx();
    app.load(PathManager.getOptionsPath());

    if (myPostStarter.needStartInTransaction()) {
      ((TransactionGuardImpl)TransactionGuard.getInstance()).performUserActivity(() -> myPostStarter.main(newConfigFolder, myArgs));
    }
    else {
      myPostStarter.main(newConfigFolder, myArgs);
    }

    myPostStarter = null;

    ourLoaded = true;
  }
  catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
public static void afterItemInsertion(final CompletionProgressIndicator indicator, final Runnable laterRunnable) {
  if (laterRunnable != null) {
    ActionTracker tracker = new ActionTracker(indicator.getEditor(), indicator);
    Runnable wrapper = () -> {
      if (!indicator.getProject().isDisposed() && !tracker.hasAnythingHappened()) {
        laterRunnable.run();
      }
      indicator.disposeIndicator();
    };
    if (ApplicationManager.getApplication().isUnitTestMode()) {
      wrapper.run();
    }
    else {
      TransactionGuard.getInstance().submitTransactionLater(indicator, wrapper);
    }
  }
  else {
    indicator.disposeIndicator();
  }
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
static boolean chooseActionAndInvoke(@Nonnull PsiFile hostFile,
                                     @Nullable final Editor hostEditor,
                                     @Nonnull final IntentionAction action,
                                     @Nonnull String text,
                                     @Nonnull final Project project) {
  FeatureUsageTracker.getInstance().triggerFeatureUsed("codeassists.quickFix");
  ((FeatureUsageTrackerImpl)FeatureUsageTracker.getInstance()).getFixesStats().registerInvocation();

  PsiDocumentManager.getInstance(project).commitAllDocuments();

  Pair<PsiFile, Editor> pair = chooseFileForAction(hostFile, hostEditor, action);
  if (pair == null) return false;

  CommandProcessor.getInstance()
          .executeCommand(project, () -> TransactionGuard.getInstance().submitTransactionAndWait(() -> invokeIntention(action, pair.second, pair.first)),
                          text, null);
  return true;
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
private static void reloadPsi(final VirtualFile file, final Project project) {
  final FileManagerImpl fileManager = (FileManagerImpl)((PsiManagerEx)PsiManager.getInstance(project)).getFileManager();
  if (fileManager.findCachedViewProvider(file) != null) {
    Runnable runnable = new Runnable() {
      @Override
      public void run() {
        WriteAction.run(new ThrowableRunnable<RuntimeException>() {
          @Override
          public void run() throws RuntimeException {
            fileManager.forceReload(file);
          }
        });
      }
    };
    if (ApplicationManager.getApplication().isDispatchThread()) {
      runnable.run();
    } else {
      TransactionGuard.submitTransaction(project, runnable);
    }
  }
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
public static void openOptionOrPerformAction(@Nonnull Object element,
                                             final String enteredText,
                                             @Nullable final Project project,
                                             Component component,
                                             @Nullable AnActionEvent e) {
  if (element instanceof OptionDescription) {
    final String configurableId = ((OptionDescription)element).getConfigurableId();
    TransactionGuard.getInstance().submitTransactionLater(project != null ? project : ApplicationManager.getApplication(), new Runnable() {
      @Override
      public void run() {
        ShowSettingsUtilImpl.showSettingsDialog(project, configurableId, enteredText);
      }
    });
  }
  else {
    performAction(element, component, e);
  }
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
private void doDrop(TreeNode targetNode, PsiElement[] sourceElements) {
  final PsiElement targetElement = getPsiElement(targetNode);
  if (targetElement == null) return;

  if (DumbService.isDumb(myProject)) {
    Messages.showMessageDialog(myProject, "Copy refactoring is not available while indexing is in progress", "Indexing", null);
    return;
  }

  final PsiDirectory psiDirectory;
  if (targetElement instanceof PsiDirectoryContainer) {
    final PsiDirectoryContainer directoryContainer = (PsiDirectoryContainer)targetElement;
    final PsiDirectory[] psiDirectories = directoryContainer.getDirectories();
    psiDirectory = psiDirectories.length != 0 ? psiDirectories[0] : null;
  }
  else if (targetElement instanceof PsiDirectory) {
    psiDirectory = (PsiDirectory)targetElement;
  }
  else {
    final PsiFile containingFile = targetElement.getContainingFile();
    LOG.assertTrue(containingFile != null);
    psiDirectory = containingFile.getContainingDirectory();
  }
  TransactionGuard.getInstance().submitTransactionAndWait(() -> CopyHandler.doCopy(sourceElements, psiDirectory));
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
protected void restartAnalysis(final Project project, final AnalysisScope scope)
{
	TransactionGuard guard = TransactionGuard.getInstance();
	TransactionId id = guard.getContextTransaction();
	DumbService.getInstance(project).smartInvokeLater(() -> TransactionGuard.getInstance().submitTransaction(project, id, () ->
	{
		if(DumbService.isDumb(project))
		{
			restartAnalysis(project, scope);
		}
		else
		{
			analyze(project, scope);
		}
	}));
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
@Nullable
private static Project openProject(@NotNull String projectPath) {
  final Project[] project = {null};
  ApplicationManager.getApplication().invokeAndWait(() -> {
    TransactionGuard.getInstance().submitTransactionAndWait(() ->
      project[0] = ProjectUtil.openProject(projectPath, null, true));
    requestFocus(project[0]);
  });
  return project[0];
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
private static void rebuildSymbols(Project project) {
  TransactionGuard.getInstance()
      .submitTransactionLater(
          project,
          () ->
              ApplicationManager.getApplication().runReadAction(() -> doRebuildSymbols(project)));
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
private static void rebuildSymbols(Project project, OCWorkspace workspace) {
  TransactionGuard.submitTransaction(
      project,
      () ->
          ApplicationManager.getApplication()
              .runReadAction(
                  () ->
                      OCWorkspaceModificationTrackersCompatUtils.getTrackers(project)
                          .getBuildSettingsChangesTracker()
                          .incModificationCount()));
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
void compileAndRefactor(String currentStepText, String newStepText, @Nullable RefactorStatusCallback refactorStatusCallback) {
    refactorStatusCallback.onStatusChange("Compiling...");
    TransactionId contextTransaction = TransactionGuard.getInstance().getContextTransaction();
    CompilerManager.getInstance(project).make((aborted, errors, warnings, context) -> {
        if (errors > 0) {
            refactorStatusCallback.onFinish(new RefactoringStatus(false, "Please fix all errors before refactoring."));
            return;
        }
        refactor(currentStepText, newStepText, contextTransaction, context, refactorStatusCallback);
    });
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
@Nonnull
private HyperlinkListener createGotToOptionsListener(@Nonnull final UsageTarget[] targets) {
  return new HyperlinkAdapter() {
    @Override
    protected void hyperlinkActivated(HyperlinkEvent e) {
      if (e.getDescription().equals(FIND_OPTIONS_HREF_TARGET)) {
        TransactionGuard.getInstance().submitTransactionAndWait(() -> FindManager.getInstance(myProject).showSettingsAndFindUsages(targets));
      }
    }
  };
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
@Nonnull
private HyperlinkListener createSearchInProjectListener() {
  return new HyperlinkAdapter() {
    @Override
    protected void hyperlinkActivated(HyperlinkEvent e) {
      if (e.getDescription().equals(SEARCH_IN_PROJECT_HREF_TARGET)) {
        PsiElement psiElement = getPsiElement(mySearchFor);
        if (psiElement != null) {
          TransactionGuard.getInstance().submitTransactionAndWait(
                  () -> FindManager.getInstance(myProject).findUsagesInScope(psiElement, GlobalSearchScope.projectScope(myProject)));
        }
      }
    }
  };
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
public void saveDocument(@Nonnull final Document document, final boolean explicit) {
  ApplicationManager.getApplication().assertIsDispatchThread();
  ((TransactionGuardImpl)TransactionGuard.getInstance()).assertWriteActionAllowed();

  if (!myUnsavedDocuments.contains(document)) return;

  try {
    doSaveDocument(document, explicit);
  }
  catch (IOException e) {
    handleErrorsOnSave(Collections.singletonMap(document, e));
  }
  catch (SaveVetoException ignored) {
  }
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
private static Processor<VirtualFile> createChangeCharsetProcessor() {
  return file -> {
    if (!(file instanceof VirtualFileSystemEntry)) return false;
    Document cachedDocument = FileDocumentManager.getInstance().getCachedDocument(file);
    if (cachedDocument == null) return true;
    ProgressManager.progress("Reloading files...", file.getPresentableUrl());
    TransactionGuard.submitTransaction(ApplicationManager.getApplication(), () -> clearAndReload(file));
    return true;
  };
}
 

import com.intellij.openapi.application.TransactionGuard; //导入依赖的package包/类
private void reloadAllFilesUnder(@Nullable final VirtualFile root) {
  tryStartReloadWithProgress(() -> processSubFiles(root, file -> {
    if (!(file instanceof VirtualFileSystemEntry)) return true;
    Document cachedDocument = FileDocumentManager.getInstance().getCachedDocument(file);
    if (cachedDocument != null) {
      ProgressManager.progress("Reloading file...", file.getPresentableUrl());
      TransactionGuard.submitTransaction(myProject, () -> reload(file));
    }
    // for not loaded files deep under project, reset encoding to give them chance re-detect the right one later
    else if (file.isCharsetSet() && !file.equals(root)) {
      file.setCharset(null);
    }
    return true;
  }));
}