@Override public void invoke(@NotNull Project project, @NotNull PsiFile file, @NotNull PsiElement startElement, @NotNull PsiElement endElement) { assert startElement == endElement; com.intellij.lang.ASTNode parentNode = startElement.getNode(); com.intellij.lang.ASTNode whiteSpace = parentNode.findChildByType(TokenType.WHITE_SPACE); BlockSupport blockSupport = BlockSupport.getInstance(project); final int startOffset = whiteSpace.getStartOffset(); final int endOffset = startOffset + whiteSpace.getTextLength(); blockSupport.reparseRange(file, startOffset, endOffset, ""); } }
document.getLineNumber(openingElement.getStartOffset()) != document.getLineNumber(closingElement.getStartOffset())) { tailWrap = Wrap.createWrap(WrapType.ALWAYS, true);
private boolean firstOnLine(@NotNull ASTNode node) { Document document = document(node.getPsi()); assert document != null; int nodeStartOffset = node.getStartOffset(); int lineNumber = document.getLineNumber(nodeStartOffset); int lineStartOffset = document.getLineStartOffset(lineNumber); String prefix = document.getText(new TextRange(lineStartOffset, nodeStartOffset)); return isWhitespace(prefix); }
int stabParentStartOffset = stabParent.getStartOffset(); int directParentStartOffset = stabOperation.getStartOffset(); int spaces = normalIndentSize(stabParent) - (directParentStartOffset - stabParentStartOffset);
@Override public boolean process(PsiElement element) { if (element == null || element.getNode().getStartOffset() >= lineEndOffset) { return false; } if (element != myAnchor && element instanceof PerlHeredocOpener) { myResult = (PerlHeredocOpener)element; return false; } return true; }
@Override public int getTextOffset() { return getNode().getStartOffset(); }
/** * Checks if Heredoc is ahead of current block and it's not possible to insert newline * * @param node in question * @return check result */ public boolean isNewLineForbiddenAt(@NotNull ASTNode node) { int startOffset = node.getStartOffset(); for (TextRange range : myHeredocRangesList) { if (range.contains(startOffset)) { return true; } } return false; }
private int getOpenQuoteOffsetInParent(@NotNull PerlStringMixin element) { return getOpeningQuote(element).getNode().getStartOffset() - element.getNode().getStartOffset(); }
@Override public int getStartOffsetInParent() { return getNode().getStartOffset() - getNode().getTreeParent().getStartOffset(); }
/** * @return line number of the node or -1 if node is null or document missing */ private int getNodeLine(@Nullable ASTNode node) { Document document = getDocument(); return node == null || document == null ? -1 : document.getLineNumber(node.getStartOffset()); } }
protected int getCloseQuoteOffsetInParent(@NotNull PerlStringMixin element) { PsiElement closingQuote = getClosingQuote(element); ASTNode node = element.getNode(); if (closingQuote == null) // unclosed string { return node.getTextLength(); } return closingQuote.getNode().getStartOffset() - node.getStartOffset(); }
protected List<String> getRightSideStrings(@NotNull PsiElement rigthSide) { List<String> result = new ArrayList<>(); if (rigthSide.getFirstChild() != null) { int lastEnd = -1; for (PsiElement psiElement : PerlPsiUtil.collectStringElements(rigthSide.getFirstChild())) { String text = psiElement.getText(); if (StringUtil.isNotEmpty(text)) { int newStart = psiElement.getNode().getStartOffset(); if (newStart == lastEnd) // appending { int lastIndex = result.size() - 1; result.add(result.remove(lastIndex) + text); } else { result.add(text); } lastEnd = newStart + text.length(); } } } return result; }
@Override public boolean process(PsiElement element) { if (element == null || element.getNode().getStartOffset() >= lineEndOffset) { return false; } if (element instanceof PerlHeredocOpener) { //SmartPointerManager#createSmartPsiElementPointer myResult.add(SmartPointerManager.getInstance(element.getProject()).createSmartPsiElementPointer((PerlHeredocOpener)element)); } return true; }
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(); }
public int getTextOffset() { final ASTNode name = getNameSymbol().getNode(); return name != null ? name.getStartOffset() : super.getTextOffset(); }
private void addShred(@NotNull Shred shred) { TextRange shredRange = shred.getRangeInsideHost().shiftRight(myHostNode.getStartOffset()); if (shredRange.isEmpty()) { return; } Entry lastEntry = myEntries.isEmpty() ? null : myEntries.get(myEntries.size() - 1); if (lastEntry != null && lastEntry.myHostRange.getEndOffset() > shredRange.getStartOffset()) { throw new IllegalArgumentException( "Non-sequential range added. Last range: " + lastEntry.myHostRange + " new entry " + shredRange); } // fixme take prefix and suffix lengths into account myEntries.add(new Entry(shredRange, TextRange.from(injectedLength, shredRange.getLength()))); injectedLength += shredRange.getLength(); }
@NotNull @Override public TextRange getDeclarationRange(@NotNull PsiElement container) { if (container instanceof PerlSubDefinitionElement) { PsiPerlBlock body = ((PerlSubDefinitionElement)container).getSubDefinitionBody(); if (body == null) { return TextRange.EMPTY_RANGE; } return TextRange.create(container.getNode().getStartOffset(), body.getTextOffset()); } else if (container instanceof PerlNamespaceDefinitionWithIdentifier) { PsiPerlBlock block = ((PerlNamespaceDefinitionWithIdentifier)container).getBlock(); if (block != null) { return TextRange.create(container.getNode().getStartOffset(), block.getTextOffset()); } PsiPerlNamespaceContent content = ((PerlNamespaceDefinitionWithIdentifier)container).getNamespaceContent(); if (content != null) { return TextRange.create(container.getNode().getStartOffset(), content.getTextOffset()); } return TextRange.EMPTY_RANGE; } throw new IllegalArgumentException("Unhandled container: " + container); } }
@Override public void computeUsages(List<PsiElement> targets) { if (targets == null) { return; } for (PsiElement target : targets) { if (myFile.equals(target.getContainingFile()) && target instanceof PsiNameIdentifierOwner) { PsiElement nameIdentifier = ((PsiNameIdentifierOwner)target).getNameIdentifier(); if (nameIdentifier != null) { TextRange rangeInIdentifier = target instanceof PerlIdentifierRangeProvider ? ((PerlIdentifierRangeProvider)target).getRangeInIdentifier() : ElementManipulators.getValueTextRange(nameIdentifier); myWriteUsages.add(rangeInIdentifier.shiftRight(nameIdentifier.getNode().getStartOffset())); } } for (PsiReference reference : ReferencesSearch.search(target, new LocalSearchScope(myFile)).findAll()) { myReadUsages.add(reference.getRangeInElement().shiftRight(reference.getElement().getNode().getStartOffset())); } } } }
static void registerProblem(BnfExpression choice, BnfExpression branch, String message, ProblemsHolder problemsHolder, LocalQuickFix... fixes) { TextRange textRange = branch.getTextRange(); if (textRange.isEmpty()) { ASTNode nextOr = TreeUtil.findSibling(branch.getNode(), BnfTypes.BNF_OP_OR); ASTNode prevOr = TreeUtil.findSiblingBackward(branch.getNode(), BnfTypes.BNF_OP_OR); int shift = choice.getTextRange().getStartOffset(); int startOffset = prevOr != null ? prevOr.getStartOffset() - shift : 0; TextRange range = new TextRange(startOffset, nextOr != null? nextOr.getStartOffset() + 1 - shift : Math.min(startOffset + 2, choice.getTextLength())); problemsHolder.registerProblem(choice, range, message, fixes); } else { problemsHolder.registerProblem(branch, message, fixes); } } }
private static ASTNode appendDescriptors(final ASTNode node, final Document document, final List<FoldingDescriptor> descriptors) { if (isFoldable(node)) { final IElementType type = node.getElementType(); int startLine = document.getLineNumber(node.getStartOffset()); TextRange adjustedFoldingRange = adjustFoldingRange(node); int endLine = document.getLineNumber(adjustedFoldingRange.getEndOffset()); if (startLine + minumumLineOffset(type) <= endLine) { descriptors.add(new FoldingDescriptor(node, adjustedFoldingRange)); } } if (mayContainFoldBlocks(node)) { //work on all child elements ASTNode child = node.getFirstChildNode(); while (child != null) { child = appendDescriptors(child, document, descriptors).getTreeNext(); } } return node; }