com.intellij.psi.impl.source.SourceTreeToPsiMap#treeElementToPsi ( )源码实例Demo

private void init(final ASTNode child) {
    if (child == null) {
        return;
    }
    ASTNode treePrev = child.getTreePrev();
    while (treePrev != null && SpacingUtil.isWhiteSpace(treePrev)) {
        treePrev = treePrev.getTreePrev();
    }

    if (treePrev == null) {
        init(child.getTreeParent());
    } else {
        myChild2 = child;
        myChild1 = treePrev;
        final CompositeElement parent = (CompositeElement) treePrev.getTreeParent();
        myParent = SourceTreeToPsiMap.treeElementToPsi(parent);
    }
}
 

@Nullable
private static ASTNode findPreviousWhiteSpace(final ASTNode leafElement, final IElementType whiteSpaceTokenType) {
  final int offset = leafElement.getTextRange().getStartOffset() - 1;
  if (offset < 0) return null;
  final PsiElement psiElement = SourceTreeToPsiMap.treeElementToPsi(leafElement);
  if (psiElement == null) {
    return null;
  }
  final PsiElement found = psiElement.getContainingFile().findElementAt(offset);
  if (found == null) return null;
  final ASTNode treeElement = found.getNode();
  if (treeElement != null && treeElement.getElementType() == whiteSpaceTokenType) return treeElement;
  return null;
}
 

@Override
public GraphQLIdentifierImpl handleContentChange(@NotNull GraphQLIdentifierImpl element, @NotNull TextRange range, String newContent) throws IncorrectOperationException {
    // replace the NAME leaf element inside the identifier
    final LeafElement renamedLeaf = Factory.createSingleLeafElement(GraphQLElementTypes.NAME, newContent, null, element.getManager());
    final PsiElement renamedPsiElement = SourceTreeToPsiMap.treeElementToPsi(renamedLeaf);
    if (renamedPsiElement != null) {
        element.getFirstChild().replace(renamedPsiElement);
    }
    return element;

}
 

@Override
public PsiElement replace(@Nonnull PsiElement newElement) throws IncorrectOperationException {
  LOG.assertTrue(getTreeParent() != null);
  CheckUtil.checkWritable(this);
  TreeElement elementCopy = ChangeUtil.copyToElement(newElement);
  getTreeParent().replaceChildInternal(this, elementCopy);
  elementCopy = ChangeUtil.decodeInformation(elementCopy);
  final PsiElement result = SourceTreeToPsiMap.treeElementToPsi(elementCopy);

  this.invalidate();
  return result;
}
 

@SuppressWarnings("SimplifiableIfStatement")
@Override
protected boolean isRegionCollapsedByDefault(@NotNull ASTNode node) {
    final PsiElement element = SourceTreeToPsiMap.treeElementToPsi(node);
    if (element == null) return false;

    ANTLRv4FoldingSettings settings = ANTLRv4FoldingSettings.getInstance();

    if (RULE_BLOCKS.contains(node.getElementType())) return settings.isCollapseRuleBlocks();
    if (node.getElementType() == TOKENSSPEC) return settings.isCollapseTokens();

    if (element instanceof AtAction) return settings.isCollapseActions();

    if (element instanceof ANTLRv4FileRoot) {
        return settings.isCollapseFileHeader();
    }
    if (node.getElementType() == DOC_COMMENT_TOKEN) {

        PsiElement parent = element.getParent();

        if (parent instanceof ANTLRv4FileRoot) {
            PsiElement firstChild = parent.getFirstChild();
            if (firstChild instanceof PsiWhiteSpace) {
                firstChild = firstChild.getNextSibling();
            }
            if (element.equals(firstChild)) {
                return settings.isCollapseFileHeader();
            }
        }
        return settings.isCollapseDocComments();
    }
    if (isComment(element)) {
        return settings.isCollapseComments();
    }
    return false;

}
 

/**
 * @return the parent of this element. Uses stub hierarchy if possible, but might cause an expensive switch to AST
 * if the parent stub doesn't correspond to the parent AST node.
 */
@Override
public PsiElement getParent() {
  T stub = getGreenStub();
  if (stub != null && !((ObjectStubBase<?>)stub).isDangling()) {
    return stub.getParentStub().getPsi();
  }

  return SourceTreeToPsiMap.treeElementToPsi(getNode().getTreeParent());
}
 

@Override
public PsiElement replace(@Nonnull final PsiElement newElement) throws IncorrectOperationException {
  CheckUtil.checkWritable(this);
  TreeElement elementCopy = ChangeUtil.copyToElement(newElement);
  if (getParent() instanceof ASTDelegatePsiElement) {
    final ASTDelegatePsiElement parentElement = (ASTDelegatePsiElement)getParent();
    parentElement.replaceChildInternal(this, elementCopy);
  }
  else {
    CodeEditUtil.replaceChild(getParent().getNode(), getNode(), elementCopy);
  }
  elementCopy = ChangeUtil.decodeInformation(elementCopy);
  return SourceTreeToPsiMap.treeElementToPsi(elementCopy);
}
 

public static PsiElement addRange(PsiElement thisElement,
                                  PsiElement first,
                                  PsiElement last,
                                  ASTNode anchor,
                                  Boolean before) throws IncorrectOperationException {
  CheckUtil.checkWritable(thisElement);
  final CharTable table = findCharTableByTree(SourceTreeToPsiMap.psiElementToTree(thisElement));

  TreeElement copyFirst = null;
  ASTNode copyLast = null;
  ASTNode next = SourceTreeToPsiMap.psiElementToTree(last).getTreeNext();
  ASTNode parent = null;
  for (ASTNode element = SourceTreeToPsiMap.psiElementToTree(first); element != next; element = element.getTreeNext()) {
    TreeElement elementCopy = ChangeUtil.copyElement((TreeElement)element, table);
    if (element == first.getNode()) {
      copyFirst = elementCopy;
    }
    if (element == last.getNode()) {
      copyLast = elementCopy;
    }
    if (parent == null) {
      parent = elementCopy.getTreeParent();
    }
    else {
      if(elementCopy.getElementType() == TokenType.WHITE_SPACE)
        CodeEditUtil.setNodeGenerated(elementCopy, true);
      parent.addChild(elementCopy, null);
    }
  }
  if (copyFirst == null) return null;
  copyFirst = ((CompositeElement)SourceTreeToPsiMap.psiElementToTree(thisElement)).addInternal(copyFirst, copyLast, anchor, before);
  for (TreeElement element = copyFirst; element != null; element = element.getTreeNext()) {
    element = ChangeUtil.decodeInformation(element);
    if (element.getTreePrev() == null) {
      copyFirst = element;
    }
  }
  return SourceTreeToPsiMap.treeElementToPsi(copyFirst);
}
 

public static PsiElement doReplace(PsiElement psiElement, TreeElement treeElement, PsiElement newElement) {
  CompositeElement treeParent = treeElement.getTreeParent();
  LOG.assertTrue(treeParent != null);
  CheckUtil.checkWritable(psiElement);
  TreeElement elementCopy = ChangeUtil.copyToElement(newElement);
  treeParent.replaceChildInternal(treeElement, elementCopy);
  elementCopy = ChangeUtil.decodeInformation(elementCopy);
  final PsiElement result = SourceTreeToPsiMap.treeElementToPsi(elementCopy);
  treeElement.invalidate();
  return result;
}
 

@Override
public PsiElement copy() {
  ASTNode elementCopy = copyElement();
  return SourceTreeToPsiMap.treeElementToPsi(elementCopy);
}
 

@Nullable
public final PsiElement findChildByRoleAsPsiElement(int role) {
  ASTNode element = findChildByRole(role);
  if (element == null) return null;
  return SourceTreeToPsiMap.treeElementToPsi(element);
}
 

@Override
@RequiredReadAction
public PsiElement findElementAt(int offset) {
  ASTNode treeElement = getNode().findLeafElementAt(offset);
  return SourceTreeToPsiMap.treeElementToPsi(treeElement);
}
 

@Override
public PsiElement copy() {
  ASTNode elementCopy = copyElement();
  return SourceTreeToPsiMap.treeElementToPsi(elementCopy);
}
 

@Nullable
public final PsiElement findChildByRoleAsPsiElement(int role) {
  ASTNode element = findChildByRole(role);
  if (element == null) return null;
  return SourceTreeToPsiMap.treeElementToPsi(element);
}
 

public static PsiElement getParent(ASTNode thisElement) {
  return SourceTreeToPsiMap.treeElementToPsi(thisElement.getTreeParent());
}
 

@Override
public PsiElement copy() {
  ASTNode elementCopy = copyElement();
  return SourceTreeToPsiMap.treeElementToPsi(elementCopy);
}
 

@Nullable
public static PsiElement getLastChild(ASTNode element) {
  return SourceTreeToPsiMap.treeElementToPsi(element.getLastChildNode());
}
 

public static PsiElement getNextSibling(ASTNode thisElement) {
  return SourceTreeToPsiMap.treeElementToPsi(thisElement.getTreeNext());
}
 

@Override
public PsiElement copy() {
  ASTNode elementCopy = copyElement();
  return SourceTreeToPsiMap.treeElementToPsi(elementCopy);
}
 

@Override
public PsiElement findElementAt(int offset) {
  ASTNode leaf = findLeafElementAt(offset);
  return SourceTreeToPsiMap.treeElementToPsi(leaf);
}