@NotNull @Override public TextRange getTextRange() { return myNode.getTextRange(); }
@NotNull @Override public TextRange getTextRange() { return myNode.getTextRange(); }
private void highlight(@NotNull final ElixirMapArguments mapArguments, @NotNull AnnotationHolder annotationHolder, @NotNull final TextAttributesKey textAttributesKey) { ASTNode[] braces = mapArguments.getNode().getChildren(BRACES_TOKEN_SET); for (ASTNode brace : braces) { highlight(brace.getTextRange(), annotationHolder, textAttributesKey); } }
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(); } }
/** * Highlights fragment ASTNodes under `body` that have fragment type from `fragmented.getFragmentType()`. * * @param fragmented supplies fragment type * @param body contains fragments * @param annotationHolder the container which receives annotations created by the plugin. * @param textAttributesKey text attributes to apply to the fragments. */ private void highlightFragments(@NotNull final Fragmented fragmented, @NotNull final Body body, @NotNull AnnotationHolder annotationHolder, @NotNull final TextAttributesKey textAttributesKey) { ASTNode bodyNode = body.getNode(); ASTNode[] fragmentNodes = bodyNode.getChildren( TokenSet.create(fragmented.getFragmentType()) ); for (ASTNode fragmentNode : fragmentNodes) { highlight( fragmentNode.getTextRange(), annotationHolder, textAttributesKey ); } }
/** * Called to apply the fix. * * @param project {@link Project} * @param descriptor problem reported by the tool which provided this quick fix action */ @Override public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) { BlockSupport blockSupport = BlockSupport.getInstance(project); TextRange textRange = matchOperatorASTNode.getTextRange(); blockSupport.reparseRange( matchOperatorASTNode.getPsi().getContainingFile(), textRange.getStartOffset(), textRange.getEndOffset(), "::" ); }
@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; }
@NotNull private List<Block> buildSubBlocks() { AlignmentStrategy.AlignmentPerTypeStrategy strategy = null; boolean isStruct = getNode().getElementType() == STRUCT_TYPE; Alignment forType = null; if (isStruct) { strategy = AlignmentStrategy.createAlignmentPerTypeStrategy(ContainerUtil.list(FIELD_DECLARATION, LINE_COMMENT), STRUCT_TYPE, true); forType = Alignment.createAlignment(true); } 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; IElementType substitutor = childType == MULTILINE_COMMENT ? LINE_COMMENT : childType; Alignment alignment = strategy != null ? strategy.getAlignment(substitutor) : null; GoFormattingBlock e = buildSubBlock(child, alignment); if (isStruct) { e.putUserDataIfAbsent(TYPE_ALIGNMENT_INSIDE_STRUCT, forType); } blocks.add(e); } return Collections.unmodifiableList(blocks); }
@NotNull @Override public TextRange getTextRange() { return node.getTextRange(); }
@NotNull public TextRange getTextRange() { return astNode.getTextRange(); }
@Override @NotNull public TextRange getTextRange() { return node.getTextRange(); }
@NotNull public TextRange getTextRange() { return myNode.getTextRange(); }
@Override public TextRange getTextRange() { return getNode().getTextRange(); }
@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; } } }
/** * Returns the deepest nested ast node which still covers the same part of the file as the parent node. Happens if a single leaf node is * contained in several composite parent nodes of the same range, e.g. a var in a combined word. * * @param parent The element to use as the startin point * @return The deepest node inside of parent which covers the same range or (if none exists) the input element */ @NotNull public static ASTNode getDeepestEquivalent(ASTNode parent) { ASTNode element = parent; while (element.getFirstChildNode() != null && element.getFirstChildNode() == element.getLastChildNode() && element.getTextRange().equals(parent.getTextRange())) { element = element.getFirstChildNode(); } return element; }
private static boolean spanMultipleLines(@NotNull ASTNode node, @NotNull Document document) { final TextRange range = node.getTextRange(); return document.getLineNumber(range.getStartOffset()) < document.getLineNumber(range.getEndOffset()); }
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(); }
@SuppressWarnings("unchecked") private static void addRuleRefFoldingDescriptors(List<FoldingDescriptor> descriptors, PsiElement root) { for (RuleSpecNode specNode : PsiTreeUtil.findChildrenOfType(root, RuleSpecNode.class)) { GrammarElementRefNode refNode = PsiTreeUtil.findChildOfAnyType(specNode, GrammarElementRefNode.class); if (refNode == null) continue; PsiElement nextSibling = refNode.getNextSibling(); if (nextSibling == null) continue; int startOffset = nextSibling.getTextOffset(); ASTNode backward = TreeUtil.findChildBackward(specNode.getNode(), SEMICOLON); if (backward == null) continue; int endOffset = backward.getTextRange().getEndOffset(); if (startOffset >= endOffset) continue; descriptors.add(new FoldingDescriptor(specNode, new TextRange(startOffset, endOffset))); } }
/** Find smallest subtree of t enclosing range startCharIndex..stopCharIndex * inclusively using postorder traversal. Recursive depth-first-search. */ public static PsiElement getRootOfSubtreeEnclosingRegion(PsiElement t, int startCharIndex, // inclusive int stopCharIndex) // inclusive { for (PsiElement c : t.getChildren()) { PsiElement sub = getRootOfSubtreeEnclosingRegion(c, startCharIndex, stopCharIndex); if ( sub!=null ) return sub; } IElementType elementType = t.getNode().getElementType(); if ( elementType instanceof RuleIElementType ) { TextRange r = t.getNode().getTextRange(); // is range fully contained in t? Note: jetbrains uses exclusive right end (use < not <=) if ( startCharIndex>=r.getStartOffset() && stopCharIndex<r.getEndOffset() ) { return t; } } return null; }
@Override public boolean isNewLineForbiddenAt(@NotNull ASTNode node) { if (super.isNewLineForbiddenAt(node)) { return true; } PsiElement element = node.getPsi(); PsiFile file = element.getContainingFile(); Document document = PsiDocumentManager.getInstance(file.getProject()).getDocument(file); if (document != null) { int offset = node.getTextRange().getStartOffset(); int lineNumber = document.getLineNumber(offset); int lineStartOffset = document.getLineStartOffset(lineNumber); PsiElement firstElement = file.findElementAt(lineStartOffset); if (firstElement != null && firstElement.getNode().getElementType() == getLineOpenerToken()) { return true; } } return false; } }