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; }
@NotNull private GoFormattingBlock buildSubBlock(@NotNull ASTNode child, @Nullable Alignment alignment) { if (child.getPsi() instanceof GoType && child.getTreeParent().getElementType() == FIELD_DECLARATION) { alignment = getUserData(TYPE_ALIGNMENT_INSIDE_STRUCT); } Indent indent = calcIndent(child); return new GoFormattingBlock(child, alignment, indent, null, mySettings, mySpacingBuilder); }
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; }
@NotNull private WrapType listContainerValueWrapType(@NotNull ASTNode list) { WrapType wrapType = containerValueWrapType(list); if (wrapType == WrapType.ALWAYS) { ASTNode parent = list.getTreeParent(); if (parent.getElementType() == ACCESS_EXPRESSION) { ASTNode grandParent = parent.getTreeParent(); if (KEYWORD_PAIR_TOKEN_SET.contains(grandParent.getElementType())) { // It is assumed that the parent of a keyword pair is keywords ASTNode keywords = grandParent.getTreeParent(); ASTNode keywordsParent = keywords.getTreeParent(); IElementType keywordsParentElementType = keywordsParent.getElementType(); if (keywordsParentElementType == NO_PARENTHESES_ONE_ARGUMENT) { wrapType = noParenthesesOneArgumentWrapType(keywordsParent); } } } } return wrapType; }
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; }
@NotNull private WrapType noParenthesesOneArgumentWrapType(@NotNull ASTNode noParenthesesOneArgument) { ASTNode noParenthesesOneArgumentParent = noParenthesesOneArgument.getTreeParent(); WrapType wrapType = WrapType.ALWAYS; if (UNMATCHED_CALL_TOKEN_SET.contains(noParenthesesOneArgumentParent.getElementType())) { Call call = noParenthesesOneArgumentParent.getPsi(Call.class); if (IMPORT.equals(call.functionName())) { /* Usage of `import` with `only` or `except` is meant for compactness, so applying keyword exclusivity would go against that */ wrapType = WrapType.CHOP_DOWN_IF_LONG; } } return wrapType; }
ASTNode treeParent = myNode.getTreeParent().getTreeParent(); if (myAlignmentMap.containsKey(treeParent)) { alignment = myAlignmentMap.get(treeParent); ASTNode treeParent = myNode.getTreeParent().getTreeParent(); if (myAlignmentMap.containsKey(treeParent)) { alignment = myAlignmentMap.get(treeParent);
@Nullable private Indent stabChildrenIndent(@NotNull ASTNode stab) { Indent childrenIndent; if (firstOnLine(stab)) { ASTNode stabParent = stab.getTreeParent(); childrenIndent = Indent.getNormalIndent( stabParent.getElementType() == DO_BLOCK && codeStyleSettings(stabParent).ALIGN_UNMATCHED_CALL_DO_BLOCKS == CodeStyleSettings.UnmatchedCallDoBlockAlignment.CALL.value ); } else { childrenIndent = null; } return childrenIndent; }
@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; } }
ASTNode stab = stabOperation.getTreeParent(); ASTNode stabParent = stab.getTreeParent(); IElementType stabParentElementType = stabParent.getElementType(); childrenIndent = Indent.getSpaceIndent(normalIndentSize(stab), true); } else { ASTNode stabParent = stab.getTreeParent();
public static ASTNode getRoot(final ASTNode node) { ASTNode currentNode = node; ASTNode parent; while ((parent = currentNode.getTreeParent()) != null) { currentNode = parent; } return currentNode; }
private boolean testParentType(ASTNode node, IElementType type) { return node != null && node.getTreeParent() != null && node.getTreeParent().getElementType() == type; } }
/** * Check if we are in grep map or sort * * @return check result */ private static boolean inGrepMapSort(@NotNull ASTNode node) { ASTNode parent = node.getTreeParent(); IElementType parentElementType; return parent != null && ((parentElementType = parent.getElementType()) == GREP_EXPR || parentElementType == SORT_EXPR || parentElementType == MAP_EXPR); }
@Override protected boolean isRegionCollapsedByDefault(@NotNull ASTNode node) { // This code should collapse header comments. // However, in most of the cases it will not work, // as when file is open caret is at the beginning of the document, // thus preventing collapsing it. // TODO: Collapse header comment when file is opened return node.getTreeParent() instanceof FileASTNode && findPreviousNonWhitespaceOrCommentNode(node) == null; }
@Nullable public static ASTNode findEquivalentParent(@NotNull ASTNode node, @Nullable IElementType stopAt) { TextRange sourceRange = node.getTextRange(); ASTNode current = node; while (true) { ASTNode parent = current.getTreeParent(); if (parent == null || !parent.getTextRange().equals(sourceRange)) { return stopAt != null && current.getElementType() != stopAt ? null : current; } current = parent; if (stopAt == null || stopAt.equals(current.getElementType())) { return current; } } }
@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(); }
@Nullable @Override public PsiElement getParent(@NotNull ASTNode node) { ASTNode child = node.getTreeParent(); return child == null ? null : child.getPsi(); }
public static IElementType getParentNodeOfType(ASTNode node, IElementType... tokenTypes) { TokenSet tokenSet = TokenSet.create(tokenTypes); while ((node = node.getTreeParent()) != null) { if (tokenSet.contains(node.getElementType())) { return node.getElementType(); } } return null; } }
@Override public int getStartOffsetInParent() { return getNode().getStartOffset() - getNode().getTreeParent().getStartOffset(); }
@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(); }