@Nullable private static IElementType getFirstChild(ASTNode parent) { ASTNode child = parent.getFirstChildNode(); if (child == null) { return null; } while (child.getElementType() == BallerinaTypes.LINE_COMMENT || child.getElementType() == TokenType.WHITE_SPACE) { child = child.getTreeNext(); if (child == null) { return null; } } return child.getElementType(); }
@Override protected boolean isRegionCollapsedByDefault(@NotNull ASTNode node) { IElementType type = node.getElementType(); if (type == GoParserDefinition.LINE_COMMENT || type == GoParserDefinition.MULTILINE_COMMENT) { return CodeFoldingSettings.getInstance().COLLAPSE_DOC_COMMENTS; } if (type == GoTypes.BLOCK && CodeFoldingSettings.getInstance().COLLAPSE_METHODS) { ASTNode parent = node.getTreeParent(); return parent != null && parent.getPsi() instanceof GoFunctionOrMethodDeclaration; } return CodeFoldingSettings.getInstance().COLLAPSE_IMPORTS && node.getElementType() == GoTypes.IMPORT_LIST; } }
@NotNull private List<Block> buildSubBlocks() { List<Block> blocks = ContainerUtil.newArrayList(); for (ASTNode child = myNode.getFirstChildNode(); child != null; child = child.getTreeNext()) { IElementType childType = child.getElementType(); if (child.getTextRange().getLength() == 0) { continue; } if (childType == TokenType.WHITE_SPACE) { continue; } Alignment alignment = getAlignment(child); Indent indent = calculateIndent(child); Wrap wrap = createWrap(child); blocks.add( new BallerinaBlock(child, alignment, indent, wrap, mySettings, mySpacingBuilder, myAlignmentMap)); } return blocks; }
private boolean oneLinerKeywordPair(ASTNode keywordPair) { ASTNode keywordKey = keywordPair.findChildByType(KEYWORD_KEY); boolean oneLiner = false; if (keywordKey != null && keywordKey.getText().equals("do")) { ASTNode keywords = keywordPair.getTreeParent(); ASTNode keywordsParent = keywords.getTreeParent(); if (keywordsParent.getElementType() == NO_PARENTHESES_ONE_ARGUMENT) { ASTNode argumentsParent = keywordsParent.getTreeParent(); if (UNMATCHED_CALL_TOKEN_SET.contains(argumentsParent.getElementType())) { oneLiner = true; } } } return oneLiner; }
private boolean lastArgument(@NotNull ASTNode node) { boolean lastArgument = true; ASTNode currentNode = node; while (currentNode != null) { IElementType elementType = currentNode.getElementType(); if (elementType == COMMA) { lastArgument = false; break; } else if (elementType == NO_PARENTHESES_ONE_ARGUMENT) { break; } else { ASTNode nextNode = currentNode.getTreeNext(); if (nextNode == null) { currentNode = currentNode.getTreeParent(); } else { currentNode = nextNode; } } } return lastArgument; }
private static boolean isOperatorEquals(@Nullable PsiElement l, @Nullable PsiElement r) { if (l == null || r == null) return false; ASTNode lNode = l.getNode(); ASTNode rNode = r.getNode(); return lNode instanceof LeafElement && lNode.getElementType().equals(rNode.getElementType()); }
private boolean oneLinerUnmatchedCallBody(@NotNull ASTNode container) { ASTNode containerParent = container.getTreeParent(); boolean oneLiner = false; if (containerParent.getElementType() == ACCESS_EXPRESSION) { ASTNode accessExpressionParent = containerParent.getTreeParent(); if (KEYWORD_PAIR_TOKEN_SET.contains(accessExpressionParent.getElementType())) { oneLiner = oneLinerKeywordPair(accessExpressionParent); } } return oneLiner; }
@Override public boolean shouldCreateStub(ASTNode node) { return super.shouldCreateStub(node) && node.getElementType() == GoTypes.VAR_SPEC && PsiTreeUtil.getParentOfType(node.getPsi(), GoFunctionOrMethodDeclaration.class) == null; }
protected boolean shouldCreateStubInBlock(ASTNode node) { return PsiTreeUtil.getParentOfType(node.getPsi(), GoBlock.class) == null; } }
private static TextRange adjustFoldingRange(ASTNode node) { if (node.getElementType() == HEREDOC_CONTENT_ELEMENT) { int startOffset = node.getStartOffset(); //walk to the last content element before the close marker for (ASTNode next = node.getTreeNext(); next != null; next = next.getTreeNext()) { IElementType elementType = next.getElementType(); if (elementType == BashElementTypes.HEREDOC_END_ELEMENT || elementType == BashElementTypes.HEREDOC_END_IGNORING_TABS_ELEMENT) { return TextRange.create(startOffset, next.getStartOffset() - 1); } } } return node.getTextRange(); }
private static boolean hasAtLeastCountChildren(@NotNull CompositeElement parent, @NotNull IElementType childElementType, int atLeastCount) { int count = 0; for (ASTNode child = parent.getFirstChildNode(); child != null && count < atLeastCount; child = child.getTreeNext()) { if (child.getElementType() == childElementType) { count++; } } return count >= atLeastCount; }
ASTNode stab = stabOperation.getTreeParent(); ASTNode stabParent = stab.getTreeParent(); IElementType stabParentElementType = stabParent.getElementType(); childrenIndent = Indent.getSpaceIndent(normalIndentSize(stab), true); } else { ASTNode stabParent = stab.getTreeParent(); childrenIndent = null; } else { IElementType stabParentElementType = stabParent.getElementType(); int stabParentStartOffset = stabParent.getStartOffset(); int directParentStartOffset = stabOperation.getStartOffset(); int spaces = normalIndentSize(stabParent) - (directParentStartOffset - stabParentStartOffset);
@Override public ASTNode parseContents(@NotNull ASTNode chameleon) { PsiElement parentElement = chameleon.getTreeParent().getPsi(); Project project = parentElement.getProject(); PsiBuilder builder = PsiBuilderFactory.getInstance().createBuilder( project, chameleon, getLexer(parentElement.getProject()), getLanguage(), chameleon.getText()); return getParser().parse(this, builder).getFirstChildNode(); }
@NotNull public static Resolvable resolvable(@NotNull ElixirAtom atom) { ElixirCharListLine charListLine = atom.getCharListLine(); Resolvable resolvable; if (charListLine != null) { resolvable = resolvable(charListLine); } else { ElixirStringLine stringLine = atom.getStringLine(); if (stringLine != null) { resolvable = resolvable(stringLine); } else { ASTNode atomNode = atom.getNode(); ASTNode atomFragmentNode = atomNode.getLastChildNode(); assert atomFragmentNode.getElementType() == ElixirTypes.ATOM_FRAGMENT; resolvable = new Exact(":" + atomFragmentNode.getText()); } } return resolvable; }
@Override public boolean process(@NotNull PsiElement element) { IElementType type = element.getNode().getElementType(); myIsLineBreakpointAvailable = !(type instanceof PsiWhiteSpace) && !element.getNode().getText().isEmpty(); return true; }
if (typeNode != null && innerTypeNode != null) { StringBuilder result = new StringBuilder(); for (ASTNode node : typeNode.getChildren(null)) { if (node.equals(innerTypeNode)) { break; if (node.getElementType() != TokenType.WHITE_SPACE) { result.append(XmlStringUtil.escapeString(node.getText()));
public static boolean isSingleChildParent(PsiElement psi, @NotNull IElementType childType) { if (psi == null) { return false; } ASTNode child = getDeepestEquivalent(psi.getNode()); return child.getTreePrev() == null && child.getTreeNext() == null && (child.getElementType() == childType); }
@Contract(pure = true) protected boolean isStartOfValueLine(@Nullable final ASTNode currentNode) { if (null == currentNode) { return false; } final ImpexValueGroup child = PsiTreeUtil.findChildOfType( currentNode.getTreeParent().getPsi(), ImpexValueGroup.class ); return child == currentNode.getPsi(); }
private static void printAST(ASTNode node, int indent) { ASTNode sibling = node; while (sibling != null) { for (int i = 0; i < indent; i++) { System.out.print(" "); } System.out.println(sibling.toString() + " " + sibling.getTextRange().toString()); printAST(sibling.getFirstChildNode(), indent + 2); sibling = sibling.getTreeNext(); } }
@NotNull IElementType openingElementType, @NotNull IElementType closingElementType) { Document document = document(parent.getPsi()); Wrap tailWrap = null; ASTNode openingElement = parent.findChildByType(openingElementType); ASTNode closingElement = parent.findChildByType(closingElementType); document.getLineNumber(openingElement.getStartOffset()) != document.getLineNumber(closingElement.getStartOffset())) { tailWrap = Wrap.createWrap(WrapType.ALWAYS, true);