@Nullable private ASTNode getPrevNonSpaceNode(@NotNull ASTNode node) { ASTNode prevNode = node.getTreePrev(); return PsiUtilCore.getElementType(prevNode) != TokenType.WHITE_SPACE ? prevNode : prevNode.getTreePrev(); }
public static ASTNode getPrevSiblingOfType(@Nullable final ASTNode child, @Nullable final IElementType type) { if (child == null) return null; if (child.getElementType() == type) { return child.getTreePrev(); } return getPrevSiblingOfType(child.getTreePrev(), type); }
@Nullable public static ASTNode getPrevSiblingOfType(@Nullable final ASTNode child, @NotNull final HashSet<IElementType> newHashSet, @NotNull final HashSet<IElementType> excluded) { if (child == null) return null; if (newHashSet.contains(child.getElementType())) { return child; } if(excluded.contains(child.getElementType())){ return null; } return getPrevSiblingOfType(child.getTreePrev(), newHashSet,excluded); }
public static boolean isSingleChildParent(PsiElement psi) { if (psi == null) { return false; } ASTNode child = psi.getNode(); return child.getTreePrev() == null && child.getTreeNext() == null; }
@Nullable private ASTNode findPreviousNonWhitespaceOrCommentNode(@NotNull ASTNode node) { ASTNode tmp = node; while (tmp != null) { IElementType type = tmp.getElementType(); if (!(tmp instanceof PsiWhiteSpace || type == token(COMMENT) || type == token(LINE_COMMENT))) { break; } tmp = tmp.getTreePrev(); } return tmp; } }
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); }
private static boolean isFoldable(ASTNode node) { IElementType type = node.getElementType(); if (type == HEREDOC_CONTENT_ELEMENT) { // only the first heredoc element of a single heredoc is foldable, // the range expansion expands it until the last content element ASTNode prev = node.getTreePrev(); if (prev != null && prev.getElementType() == BashTokenTypes.LINE_FEED) { //first heredoc content element, better PSI would be an improvement here return true; } } return foldableTokens.contains(type); }
@Nullable @Override public PsiElement getPrevSibling(@NotNull ASTNode node) { ASTNode sibling = node.getTreePrev(); return sibling == null ? null : sibling.getPsi(); }
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); } }
@Override public boolean isIncomplete() { ASTNode lastChild = myNode.getLastChildNode(); while (lastChild != null && lastChild.getElementType() == TokenType.WHITE_SPACE) { lastChild = lastChild.getTreePrev(); } if (lastChild == null) return false; if (lastChild.getElementType() == TokenType.ERROR_ELEMENT) return true; return FormatterUtil.isIncomplete(lastChild); }
/** * Checks that current node is first, controlling optional SET and GET */ protected boolean isFirst() { boolean defaultValue = myNode.getTreePrev() == null; if (defaultValue) { IElementType parentNodeType = PsiUtilCore.getElementType(myNode.getTreeParent()); if (parentNodeType == SET_DIRECTIVE) { return PsiUtilCore.getElementType(myNode) == TT2_SET; } else if (parentNodeType == GET_DIRECTIVE) { return PsiUtilCore.getElementType(myNode) == TT2_GET; } } return defaultValue; }
/** * registers an ASTNode in some internal structure if it's necessary. * e.g. comments, here-docs */ @NotNull public ASTNode registerNode(@NotNull ASTNode node) { if (getDocument() == null) { return node; } IElementType nodeType = PsiUtilCore.getElementType(node); if (nodeType == COMMENT_LINE) { ASTNode prevNode = node.getTreePrev(); if (prevNode != null && !StringUtil.containsLineBreak(prevNode.getChars())) { myCommentsLines.set(getNodeLine(node)); } } else if (nodeType == HEREDOC_OPENER) { myHeredocRangesList.add( TextRange.create(node.getStartOffset() + 1, getDocument().getLineEndOffset(getNodeLine(node))) ); } return node; }
/** * @param node Tree node * @return true if node is incomplete */ public boolean isIncomplete(@NotNull final ASTNode node) { if (node.getElementType() instanceof ILazyParseableElementType) { return false; } ASTNode lastChild = node.getLastChildNode(); while (lastChild != null && !(lastChild.getElementType() instanceof ILazyParseableElementType) && (lastChild.getPsi() instanceof PsiWhiteSpace || lastChild.getPsi() instanceof PsiComment)) { lastChild = lastChild.getTreePrev(); } return lastChild != null && (lastChild.getPsi() instanceof PsiErrorElement || isIncomplete(lastChild)); }
private static PsiElement findFurthestSiblingOfSameType(@NotNull PsiElement anchor, boolean after) { ASTNode node = anchor.getNode(); final IElementType expectedType = node.getElementType(); ASTNode lastSeen = node; while (node != null) { final IElementType elementType = node.getElementType(); if (elementType == expectedType) { lastSeen = node; } else if (elementType == TokenType.WHITE_SPACE) { if (expectedType == token(LINE_COMMENT) && node.getText().indexOf('\n', 1) != -1) { break; } } else if (!COMMENT_TOKEN_SET.contains(elementType) || COMMENT_TOKEN_SET.contains(expectedType)) { break; } node = after ? node.getTreeNext() : node.getTreePrev(); } return lastSeen.getPsi(); }
public boolean isArrayUse() { if (!isParameterExpansion()) { return false; } PsiElement nextLeafNode = PsiTreeUtil.nextLeaf(this); if (nextLeafNode == null) { return false; } ASTNode nextLeaf = nextLeafNode.getNode(); ASTNode nextNode = getNextSibling().getNode(); boolean nextLeafIsSquare = nextLeaf.getElementType() == BashTokenTypes.LEFT_SQUARE; ASTNode prev = getNode().getTreePrev(); if (prev != null && (prev.getElementType() == BashTokenTypes.PARAM_EXPANSION_OP_HASH || prev.getElementType() == BashTokenTypes.PARAM_EXPANSION_OP_HASH_HASH)) { return true; } //${ a[1], etc. } if (nextNode.getElementType() == BashElementTypes.ARITHMETIC_COMMAND && nextLeafIsSquare) { return true; } //${ a[*] } and ${ a[@] } PsiElement nextLeaf2nd = PsiTreeUtil.nextLeaf(nextLeafNode); if (nextLeafIsSquare && nextLeaf2nd != null) { IElementType next2 = nextLeaf2nd.getNode().getElementType(); return next2 == BashTokenTypes.PARAM_EXPANSION_OP_STAR || next2 == BashTokenTypes.PARAM_EXPANSION_OP_AT; } return false; }
if (leftType == EQ && leftNode.getTreePrev() != null && leftNode.getTreePrev().getElementType() == ASSIGNMENT_WORD) { if (leftType == SEMI && leftNode.getTreePrev().getPsi() instanceof BashCommand && rightPsi instanceof BashCommand) { return COMMON_SPACING_WITH_NL;