com.intellij.lang.ASTNode Java Examples

@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;

}
 

@Override
public StubBuilder getBuilder()
{
	return new DefaultStubBuilder()
	{
		@Nonnull
		@Override
		protected StubElement createStubForFile(@Nonnull PsiFile file)
		{
			if(file instanceof CSharpFileImpl)
			{
				return new CSharpFileStub((CSharpFileImpl) file);
			}
			return super.createStubForFile(file);
		}

		@Override
		public boolean skipChildProcessingWhenBuildingStubs(@Nonnull ASTNode parent, @Nonnull ASTNode node)
		{
			// skip any lazy parseable elements, like preprocessors or code blocks etc
			if(node.getElementType() instanceof ILazyParseableElementType)
			{
				return true;
			}
			return false;
		}
	};
}
 

@Nullable
public ASTNode findChildByRole(int role) {
  // assert ChildRole.isUnique(role);
  PsiElement firstChild = getFirstChild();

  if (firstChild == null) return null;

  for (ASTNode child = firstChild.getNode(); child != null; child = child.getTreeNext()) {
    if (getChildRole(child) == role) return child;
  }
  return null;
}
 

public static String getValue(HXMLLib lib) {
  ASTNode node = lib.getNode().findChildByType(HXMLTypes.VALUE);

  if (node != null) {
    return node.getText();
  }
  else {
    return null;
  }
}
 

@Override
public boolean textContains(char c) {
  for (ASTNode child = getFirstChildNode(); child != null; child = child.getTreeNext()) {
    if (child.textContains(c)) return true;
  }
  return false;
}
 

@NotNull
public PsiElement createElement(ASTNode node) {
    GLSLElement elt = psiFactory.create(node);
    if (elt != null) {
        return elt;
    } else {
        //Logger.getInstance(GLSLParserDefinition.class).warn("Creating default GLSLElementImpl for "+node);
        return new GLSLElementImpl(node);
    }
}
 

private static TextRange buildImportsFoldingTextRange(ASTNode firstNode, ASTNode lastNode) {
  ASTNode nodeStartFrom = UsefulPsiTreeUtil.getNextSiblingSkipWhiteSpacesAndComments(firstNode.getFirstChildNode());
  if (nodeStartFrom == null) {
    nodeStartFrom = firstNode;
  }
  return new TextRange(nodeStartFrom.getStartOffset(), lastNode.getTextRange().getEndOffset());
}
 

private ThreeState textMatches(ASTNode oldNode, ASTNode newNode) {
  myIndicator.checkCanceled();
  String oldText = TreeUtil.isCollapsedChameleon(oldNode) ? oldNode.getText() : null;
  String newText = TreeUtil.isCollapsedChameleon(newNode) ? newNode.getText() : null;
  if (oldText != null && newText != null) return oldText.equals(newText) ? ThreeState.YES : ThreeState.UNSURE;

  if (oldText != null) {
    return compareTreeToText((TreeElement)newNode, oldText) ? ThreeState.YES : ThreeState.UNSURE;
  }
  if (newText != null) {
    return compareTreeToText((TreeElement)oldNode, newText) ? ThreeState.YES : ThreeState.UNSURE;
  }

  if (oldNode instanceof ForeignLeafPsiElement) {
    return newNode instanceof ForeignLeafPsiElement && oldNode.getText().equals(newNode.getText()) ? ThreeState.YES : ThreeState.NO;
  }

  if (newNode instanceof ForeignLeafPsiElement) return ThreeState.NO;

  if (oldNode instanceof LeafElement) {
    return ((LeafElement)oldNode).textMatches(newNode.getText()) ? ThreeState.YES : ThreeState.NO;
  }
  if (newNode instanceof LeafElement) {
    return ((LeafElement)newNode).textMatches(oldNode.getText()) ? ThreeState.YES : ThreeState.NO;
  }

  if (oldNode instanceof PsiErrorElement && newNode instanceof PsiErrorElement) {
    final PsiErrorElement e1 = (PsiErrorElement)oldNode;
    final PsiErrorElement e2 = (PsiErrorElement)newNode;
    if (!Comparing.equal(e1.getErrorDescription(), e2.getErrorDescription())) return ThreeState.NO;
  }

  return ThreeState.UNSURE;
}
 

public static @NotNull String getMacroName(LatteMacroTag element) {
	ASTNode nameNode = getMacroNameNode(element);
	if (nameNode != null) {
		return nameNode.getText();
	}
	return createMacroName(element);
}
 

public static PsiElement createElement(ASTNode node) {
  IElementType type = node.getElementType();
   if (type == STEP) {
    return new JenkinsStepImpl(node);
  }
  throw new AssertionError("Unknown element type: " + type);
}
 

public static PsiElement[] getFilteredChildren(@Nonnull final PsiElement element,
                                               @Nullable Condition<PsiElement> isElementSignificantCondition,
                                               boolean areCommentsSignificant) {
  ASTNode[] children1 = element.getNode().getChildren(null);
  ArrayList<PsiElement> array = new ArrayList<PsiElement>();
  for (ASTNode node : children1) {
    final PsiElement child = node.getPsi();
    if (!(child instanceof PsiWhiteSpace) && (areCommentsSignificant || !(child instanceof PsiComment)) &&
        (isElementSignificantCondition == null || isElementSignificantCondition.value(child))) {
      array.add(child);
    }
  }
  return PsiUtilCore.toPsiElementArray(array);
}
 

@Override
public Object getData(@Nonnull @NonNls Key<?> dataId) {
  if (PlatformDataKeys.NAVIGATABLE == dataId) {
    String fqn = null;
    if (myPsiTree.hasFocus()) {
      final TreePath path = myPsiTree.getSelectionPath();
      if (path != null) {
        DefaultMutableTreeNode node = (DefaultMutableTreeNode)path.getLastPathComponent();
        if (!(node.getUserObject() instanceof ViewerNodeDescriptor)) return null;
        ViewerNodeDescriptor descriptor = (ViewerNodeDescriptor)node.getUserObject();
        Object elementObject = descriptor.getElement();
        final PsiElement element = elementObject instanceof PsiElement
                                   ? (PsiElement)elementObject
                                   : elementObject instanceof ASTNode ? ((ASTNode)elementObject).getPsi() : null;
        if (element != null) {
          fqn = element.getClass().getName();
        }
      }
    } else if (myRefs.hasFocus()) {
      final Object value = myRefs.getSelectedValue();
      if (value instanceof String) {
        fqn = (String)value;
      }
    }
    if (fqn != null) {
      return getContainingFileForClass(fqn);
    }
  }
  return null;
}
 

/** The function name */
@Nullable
public ASTNode getFunctionNameNode() {
  PsiElement argList = getArgList();
  if (argList != null) {
    // We want the reference expr directly prior to the open parenthesis.
    // This accounts for Skylark native.rule calls.
    PsiElement prev = argList.getPrevSibling();
    if (prev instanceof ReferenceExpression) {
      return prev.getNode();
    }
  }
  return getNode().findChildByType(BuildElementTypes.REFERENCE_EXPRESSION);
}
 

public PsiInnerModuleImpl(@NotNull ORTypes types, @NotNull ASTNode node) {
    super(types, node);
}
 

public CSharpAsExpressionImpl(@Nonnull ASTNode node)
{
	super(node);
}
 

public NixExprImpl(ASTNode node) {
  super(node);
}
 

public GLSLBreakStatement(@NotNull ASTNode astNode) {
    super(astNode);
}
 

@Nonnull
@Override
public DotNetParameter createElement(@Nonnull ASTNode astNode)
{
	return new CSharpStubParameterImpl(astNode);
}
 

public CSharpPreprocessorPragmaImpl(@Nonnull ASTNode node)
{
	super(node);
}
 

public Positional(ASTNode node) {
  super(node);
}
 

public NixEvalExprImpl(ASTNode node) {
  super(node);
}
 

public XQueryModuleDeclImpl(ASTNode node) {
  super(node);
}
 

public XQueryAxisStepImpl(ASTNode node) {
  super(node);
}
 

public WeaveKeyExpressionImpl(ASTNode node) {
  super(node);
}
 

public WeaveObjectExpressionImpl(ASTNode node) {
  super(node);
}
 

public MelDoWhileExpressionImpl(ASTNode node) {
  super(node);
}
 

public CSharpVariableImpl(@Nonnull ASTNode node)
{
	super(node);
}
 

public MakefilePsiElement(ASTNode astNode) {
  super(astNode);
}
 

public AbstractExpression(final ASTNode astNode, final String name, Type type) {
    super(astNode, name);
    this.type = type;
}
 

public BashWordImpl(final ASTNode astNode) {
    super(astNode, "bash combined word");
}