Java DebugUtil.finishPsiModification方法代码示例

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
public void testMergeWhenEmptyElementAfterWhitespaceIsLastChild() throws Throwable {
  myBuilder = createBuilder(" foo bar");
  parseWhenEmptyElementAfterWhitespaceIsLastChild();
  final ASTNode tree = myBuilder.getTreeBuilt();
  new DummyHolder(getPsiManager(), (TreeElement)tree, null);

  myBuilder = createBuilder("  bar", tree);
  parseWhenEmptyElementAfterWhitespaceIsLastChild();
  DebugUtil.startPsiModification(null);
  try {
    myBuilder.getTreeBuilt();
    fail();
  }
  catch (BlockSupport.ReparsedSuccessfullyException e) {
    e.getDiffLog().performActualPsiChange(tree.getPsi().getContainingFile());
  }
  finally {
    DebugUtil.finishPsiModification();
  }

  assertEquals("  bar", tree.getText());
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
private static boolean cacheEverything(@NotNull Place place,
                                       @NotNull DocumentWindowImpl documentWindow,
                                       @NotNull InjectedFileViewProvider viewProvider,
                                       @NotNull PsiFile psiFile,
                                       @NotNull SmartPsiElementPointer<PsiLanguageInjectionHost> pointer) {
  FileDocumentManagerImpl.registerDocument(documentWindow, viewProvider.getVirtualFile());

  DebugUtil.startPsiModification("MultiHostRegistrar cacheEverything");
  try {
    viewProvider.forceCachedPsi(psiFile);
  }
  finally {
    DebugUtil.finishPsiModification();
  }

  psiFile.putUserData(FileContextUtil.INJECTED_IN_ELEMENT, pointer);
  PsiDocumentManagerBase.cachePsi(documentWindow, psiFile);

  keepTreeFromChameleoningBack(psiFile);

  return viewProvider.setShreds(place, psiFile.getProject());
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
private static void encodeInformation(TreeElement element, ASTNode original) {
  DebugUtil.startPsiModification(null);
  try {
    encodeInformation(element, original, new HashMap<Object, Object>());
  }
  finally {
    DebugUtil.finishPsiModification();
  }
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
public static TreeElement decodeInformation(TreeElement element) {
  DebugUtil.startPsiModification(null);
  try {
    return decodeInformation(element, new HashMap<Object, Object>());
  }
  finally {
    DebugUtil.finishPsiModification();
  }
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
public static void clearCaches(@NotNull PsiFile injected, @NotNull DocumentWindowImpl documentWindow) {
  VirtualFileWindowImpl virtualFile = (VirtualFileWindowImpl)injected.getVirtualFile();
  PsiManagerEx psiManagerEx = (PsiManagerEx)injected.getManager();
  if (psiManagerEx.getProject().isDisposed()) return;

  DebugUtil.startPsiModification("injected clearCaches");
  try {
    psiManagerEx.getFileManager().setViewProvider(virtualFile, null);
  }
  finally {
    DebugUtil.finishPsiModification();
  }

  PsiElement context = InjectedLanguageManager.getInstance(injected.getProject()).getInjectionHost(injected);
  PsiFile hostFile;
  if (context != null) {
    hostFile = context.getContainingFile();
  }
  else {
    VirtualFile delegate = virtualFile.getDelegate();
    hostFile = delegate.isValid() ? psiManagerEx.findFile(delegate) : null;
  }
  if (hostFile != null) {
    // modification of cachedInjectedDocuments must be under PsiLock
    synchronized (PsiLock.LOCK) {
      List<DocumentWindow> cachedInjectedDocuments = getCachedInjectedDocuments(hostFile);
      for (int i = cachedInjectedDocuments.size() - 1; i >= 0; i--) {
        DocumentWindow cachedInjectedDocument = cachedInjectedDocuments.get(i);
        if (cachedInjectedDocument == documentWindow) {
          cachedInjectedDocuments.remove(i);
        }
      }
    }
  }
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
private static void encodeInformation(TreeElement element, ASTNode original) {
  DebugUtil.startPsiModification(null);
  try {
    encodeInformation(element, original, new HashMap<>());
  }
  finally {
    DebugUtil.finishPsiModification();
  }
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
public static TreeElement decodeInformation(TreeElement element) {
  DebugUtil.startPsiModification(null);
  try {
    return decodeInformation(element, new HashMap<>());
  }
  finally {
    DebugUtil.finishPsiModification();
  }
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
@Override
public ASTNode parseContents(ASTNode chameleon) {
  final CharTable charTable = SharedImplUtil.findCharTableByTree(chameleon);
  final FileElement fileElement = TreeUtil.getFileElement((TreeElement)chameleon);
  final PsiFile psiFile = (PsiFile)fileElement.getPsi();
  PsiFile originalPsiFile = psiFile.getOriginalFile();

  final TemplateLanguageFileViewProvider viewProvider = (TemplateLanguageFileViewProvider)originalPsiFile.getViewProvider();

  final Language templateLanguage = getTemplateFileLanguage(viewProvider);
  final CharSequence sourceCode = chameleon.getChars();

  RangesCollector collector = new RangesCollector();
  final PsiFile templatePsiFile = createTemplateFile(psiFile, templateLanguage, sourceCode, viewProvider, collector);

  final FileElement templateFileElement = ((PsiFileImpl)templatePsiFile).calcTreeElement();

  DebugUtil.startPsiModification("template language parsing");
  try {
    prepareParsedTemplateFile(templateFileElement);
    insertOuters(templateFileElement, sourceCode, collector.myRanges, charTable);

    TreeElement childNode = templateFileElement.getFirstChildNode();

    DebugUtil.checkTreeStructure(templateFileElement);
    DebugUtil.checkTreeStructure(chameleon);
    if (fileElement != chameleon) {
      DebugUtil.checkTreeStructure(psiFile.getNode());
      DebugUtil.checkTreeStructure(originalPsiFile.getNode());
    }

    return childNode;
  }
  finally {
    DebugUtil.finishPsiModification();
  }
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
private void ensureParsed() {
  if (!ourParsingAllowed) {
    LOG.error("Parsing not allowed!!!");
  }
  CharSequence text = myText();
  if (text == null) return;

  if (TreeUtil.getFileElement(this) == null) {
    LOG.error("Chameleons must not be parsed till they're in file tree: " + this);
  }

  ApplicationManager.getApplication().assertReadAccessAllowed();

  DebugUtil.startPsiModification("lazy-parsing");
  try {
    ILazyParseableElementType type = (ILazyParseableElementType)getElementType();
    ASTNode parsedNode = type.parseContents(this);

    if (parsedNode == null && text.length() > 0) {
      CharSequence diagText = ApplicationManager.getApplication().isInternal() ? text : "";
      LOG.error("No parse for a non-empty string: " + diagText + "; type=" + LogUtil.objectAndClass(type));
    }

    synchronized (lock) {
      if (myText == null) return;
      if (rawFirstChild() != null) {
        LOG.error("Reentrant parsing?");
      }

      myText = null;

      if (parsedNode == null) return;
      super.rawAddChildrenWithoutNotifications((TreeElement)parsedNode);
    }
  }
  finally {
    DebugUtil.finishPsiModification();
  }

  if (!Boolean.TRUE.equals(ourSuppressEagerPsiCreation.get())) {
    // create PSI all at once, to reduce contention of PsiLock in CompositeElement.getPsi()
    // create PSI outside the 'lock' since this method grabs PSI_LOCK and deadlock is possible when someone else locks in the other order.
    createAllChildrenPsiIfNecessary();
  }
}
 

import com.intellij.psi.impl.DebugUtil; //导入方法依赖的package包/类
@Override
public ASTNode parseContents(ASTNode chameleon) {
  final CharTable table = SharedImplUtil.findCharTableByTree(chameleon);
  final FileElement treeElement = new DummyHolder(((TreeElement)chameleon).getManager(), null, table).getTreeElement();
  final FileElement fileElement = TreeUtil.getFileElement((TreeElement)chameleon);
  final PsiFile file = (PsiFile)fileElement.getPsi();
  PsiFile originalFile = file.getOriginalFile();

  final TemplateLanguageFileViewProvider viewProvider = (TemplateLanguageFileViewProvider)originalFile.getViewProvider();

  final Language language = getTemplateFileLanguage(viewProvider);
  final CharSequence chars = chameleon.getChars();

  final PsiFile templateFile = createTemplateFile(file, language, chars, viewProvider);

  final FileElement parsed = ((PsiFileImpl)templateFile).calcTreeElement();

  DebugUtil.startPsiModification("template language parsing");
  try {
    prepareParsedTemplateFile(parsed);
    Lexer langLexer = LanguageParserDefinitions.INSTANCE.forLanguage(language).createLexer(file.getProject());
    final Lexer lexer = new MergingLexerAdapter(
      new TemplateBlackAndWhiteLexer(createBaseLexer(viewProvider), langLexer, myTemplateElementType, myOuterElementType),
      TokenSet.create(myTemplateElementType, myOuterElementType));
    lexer.start(chars);
    insertOuters(parsed, lexer, table);

    if (parsed != null) {
      final TreeElement element = parsed.getFirstChildNode();
      if (element != null) {
        parsed.rawRemoveAllChildren();
        treeElement.rawAddChildren(element);
      }
    }
  }
  finally {
    DebugUtil.finishPsiModification();
  }

  treeElement.subtreeChanged();
  TreeElement childNode = treeElement.getFirstChildNode();

  DebugUtil.checkTreeStructure(parsed);
  DebugUtil.checkTreeStructure(treeElement);
  DebugUtil.checkTreeStructure(chameleon);
  if (fileElement != chameleon) {
    DebugUtil.checkTreeStructure(file.getNode());
    DebugUtil.checkTreeStructure(originalFile.getNode());
  }

  return childNode;
}