com.intellij.psi.impl.source.tree.Factory Java Examples

@Override
public ASTNode convert(final Node n) {
  if (n instanceof Token) {
    final Token token = (Token)n;
    return token.myBuilder.createLeaf(token.getTokenType(), token.myTokenStart, token.myTokenEnd);
  }
  else if (n instanceof ErrorItem) {
    return Factory.createErrorElement(((ErrorItem)n).myMessage);
  }
  else {
    final StartMarker startMarker = (StartMarker)n;
    final CompositeElement composite = n == myRoot ? (CompositeElement)myRoot.myBuilder.createRootAST(myRoot) : createComposite(startMarker);
    startMarker.myBuilder.bind(startMarker, composite);
    return composite;
  }
}
 

@Override
public PsiElement setName(@NotNull String newName) throws IncorrectOperationException {
    final GraphQLIdentifier nameIdentifier = getNameIdentifier();
    if (nameIdentifier != null) {
        final LeafElement renamedLeaf = Factory.createSingleLeafElement(GraphQLElementTypes.NAME, newName, null, nameIdentifier.getManager());
        final PsiElement renamedPsiElement = SourceTreeToPsiMap.treeElementToPsi(renamedLeaf);
        if (renamedPsiElement != null) {
            nameIdentifier.getFirstChild().replace(renamedPsiElement);
        }
    }
    return this;
}
 

@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 setName(@NonNls @NotNull String name) throws IncorrectOperationException {
	final PsiElement nameIdentifier = getNameIdentifier();
	if(nameIdentifier != null) {
		final LeafElement renamedLeaf = Factory.createSingleLeafElement(JSGraphQLEndpointTokenTypes.STRING_BODY, name, null, getManager());
		final PsiElement renamedPsiElement = SourceTreeToPsiMap.treeElementToPsi(renamedLeaf);
		if (renamedPsiElement != null) {
			nameIdentifier.replace(renamedPsiElement);
		}
	}
	return this;
}
 

/**
 * Renames an identifier, e.g. during a refactoring
 */
public static PsiElement renameIdentifier(PsiNameIdentifierOwner owner, String name) throws IncorrectOperationException {
	final PsiElement identifier = owner.getNameIdentifier();
	if (identifier == null) {
		throw new IncorrectOperationException();
	}
	final LeafElement renamedLeaf = Factory.createSingleLeafElement(JSGraphQLEndpointTokenTypes.IDENTIFIER, name, null, identifier.getManager());
	final PsiElement renamedPsiElement = SourceTreeToPsiMap.treeElementToPsi(renamedLeaf);
	if (renamedPsiElement != null) {
		identifier.replace(renamedPsiElement);
	}
	return owner;
}
 

@RequiredReadAction
@Override
public void beforeMove(@Nonnull final Editor editor, @Nonnull final MoveInfo info, final boolean down)
{
	super.beforeMove(editor, info, down);

	if(myEnumToInsertSemicolonAfter != null)
	{
		TreeElement semicolon = Factory.createSingleLeafElement(CSharpTokens.SEMICOLON, ";", 0, 1, null, myEnumToInsertSemicolonAfter.getManager());

		try
		{
			PsiElement inserted = myEnumToInsertSemicolonAfter.getParent().addAfter(semicolon.getPsi(), myEnumToInsertSemicolonAfter);
			inserted = CodeInsightUtilBase.forcePsiPostprocessAndRestoreElement(inserted);
			final LogicalPosition position = editor.offsetToLogicalPosition(inserted.getTextRange().getEndOffset());

			info.toMove2 = new LineRange(position.line + 1, position.line + 1);
		}
		catch(IncorrectOperationException e)
		{
			LOG.error(e);
		}
		finally
		{
			myEnumToInsertSemicolonAfter = null;
		}
	}
}
 

private LanguageTokenSeparatorGenerators() {
  super("com.intellij.lang.tokenSeparatorGenerator", new TokenSeparatorGenerator() {
    @Override
    public ASTNode generateWhitespaceBetweenTokens(ASTNode left, ASTNode right) {
      Language l = PsiUtilCore.getNotAnyLanguage(left);
      Language rightLang = PsiUtilCore.getNotAnyLanguage(right);
      if (rightLang.isKindOf(l)) {
        l = rightLang; // get more precise lexer
      }
      final ParserDefinition parserDefinition = LanguageParserDefinitions.INSTANCE.forLanguage(l);
      if (parserDefinition != null) {
        PsiManager manager = right.getTreeParent().getPsi().getManager();
        ASTNode generatedWhitespace;
        switch(parserDefinition.spaceExistenceTypeBetweenTokens(left, right)){
          case MUST:
            generatedWhitespace = Factory.createSingleLeafElement(TokenType.WHITE_SPACE, " ", 0, 1, null, manager);
            break;
          case MUST_LINE_BREAK:
            generatedWhitespace = Factory.createSingleLeafElement(TokenType.WHITE_SPACE, "\n", 0, 1, null, manager);
            break;
          default:
            generatedWhitespace = null;
        }
        return generatedWhitespace;
      }
      return null;
    }
  });
}
 

private void bind(@Nonnull StartMarker rootMarker, @Nonnull CompositeElement rootNode) {
  StartMarker curMarker = rootMarker;
  CompositeElement curNode = rootNode;

  int lexIndex = rootMarker.myLexemeIndex;
  ProductionMarker item = rootMarker.myFirstChild != null ? rootMarker.myFirstChild : rootMarker.myDoneMarker;
  while (true) {
    lexIndex = insertLeaves(lexIndex, item.myLexemeIndex, curNode);

    if (item == rootMarker.myDoneMarker) break;

    if (item instanceof StartMarker) {
      final StartMarker marker = (StartMarker)item;
      if (!marker.myDoneMarker.myCollapse) {
        curMarker = marker;

        final CompositeElement childNode = createComposite(marker);
        curNode.rawAddChildrenWithoutNotifications(childNode);
        curNode = childNode;

        item = marker.myFirstChild != null ? marker.myFirstChild : marker.myDoneMarker;
        continue;
      }
      else {
        lexIndex = collapseLeaves(curNode, marker);
      }
    }
    else if (item instanceof ErrorItem) {
      final CompositeElement errorElement = Factory.createErrorElement(((ErrorItem)item).myMessage);
      curNode.rawAddChildrenWithoutNotifications(errorElement);
    }
    else if (item instanceof DoneMarker) {
      curMarker = (StartMarker)((DoneMarker)item).myStart.myParent;
      curNode = curNode.getTreeParent();
      item = ((DoneMarker)item).myStart;
    }

    item = item.myNext != null ? item.myNext : curMarker.myDoneMarker;
  }
}
 

@Nonnull
private static CompositeElement createComposite(@Nonnull StartMarker marker) {
  final IElementType type = marker.myType;
  if (type == TokenType.ERROR_ELEMENT) {
    String message = marker.myDoneMarker instanceof DoneWithErrorMarker ? ((DoneWithErrorMarker)marker.myDoneMarker).myMessage : null;
    return Factory.createErrorElement(message);
  }

  if (type == null) {
    throw new RuntimeException(UNBALANCED_MESSAGE);
  }

  return ASTFactory.composite(type);
}
 

@Nullable
public static PsiElement createLineFeed(final PsiManager manager) {
  return Factory.createSingleLeafElement(TokenType.WHITE_SPACE, "\n", 0, 1, null, manager).getPsi();
}