Refine search
public int getElementPosition( final Element e, final Tree t ) { return (int) trees.getSourcePositions().getStartPosition( trees.getPath( e ). getCompilationUnit(), t ); }
private void addHighlightFor(Tree t) { int start = (int) info.getTrees().getSourcePositions().getStartPosition(info.getCompilationUnit(), t); int end = (int) info.getTrees().getSourcePositions().getEndPosition(info.getCompilationUnit(), t); highlights.add(new int[] {start, end}); }
private boolean isIn(int caretPosition, Token span) { // System.err.println("caretPosition = " + caretPosition ); // System.err.println("span[0]= " + span[0]); // System.err.println("span[1]= " + span[1]); if (span == null) return false; return span.offset(null) <= caretPosition && caretPosition <= span.offset(null) + span.length(); }
int size = oldL.size(); data = new ArrayList<int[]>(size); SourcePositions positions = diffContext.trees.getSourcePositions(); CompilationUnitTree compilationUnit = diffContext.origUnit; int treeStart = (int) positions.getStartPosition(compilationUnit, item); int treeEnd = (int) positions.getEndPosition(compilationUnit, item); seq.move(treeStart); seq.moveNext(); if (null != moveToSrcRelevant(seq, Direction.BACKWARD)) { seq.moveNext(); int previousEnd = seq.offset(); Token<JavaTokenId> token; while (nonRelevant.contains((token = seq.token()).id())) { int localResult = -1; switch (token.id()) { case WHITESPACE: int indexOf = token.text().toString().indexOf('\n'); if (indexOf > -1) { localResult = seq.offset() + indexOf;
public static Doc findJavadoc(CompilationInfo javac, Document doc, int offset) { TokenSequence<JavaTokenId> ts = SourceUtils.getJavaTokenSequence(javac.getTokenHierarchy(), offset); if (ts == null || !movedToJavadocToken(ts, offset)) { return null; TokenSequence<JavadocTokenId> jdts = ts.embedded(JavadocTokenId.language()); int offsetBehindJavadoc = ts.offset() + ts.token().length(); while (ts.moveNext()) { TokenId tid = ts.token().id(); if (tid == JavaTokenId.BLOCK_COMMENT) { if ("/**/".contentEquals(ts.token().text())) { // NOI18N tp = tp.getParentPath(); if (tp == null) { leaf = null; break; leaf = tp.getLeaf(); kind = leaf.getKind(); || positions.getStartPosition(javac.getCompilationUnit(), leaf) < offset) { Element el = javac.getTrees().getElement(tp); Doc jdoc = el != null? javac.getElementUtilities().javaDocFor(el): null; if (isInvalidDocInstance(jdoc, jdts)) {
private void insideConditionalExpression(Env env) throws IOException { ConditionalExpressionTree co = (ConditionalExpressionTree) env.getPath().getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); int coTextStart = (int) sourcePositions.getStartPosition(root, co); if (coTextStart != Diagnostic.NOPOS) { TokenSequence<JavaTokenId> last = findLastNonWhitespaceToken(env, coTextStart, env.getOffset()); if (last != null && (last.token().id() == JavaTokenId.QUESTION || last.token().id() == JavaTokenId.COLON)) { localResult(env); addValueKeywords(env); } } }
private void lookForTrailing(TokenSequence<JavaTokenId> seq, Tree tree) { seq.move((int) positions.getEndPosition(unit, tree)); List<TrailingCommentsDataHolder> comments = new LinkedList<TrailingCommentsDataHolder>(); int maxLines = 0; int newlines = 0; int lastIndex = -1; while (seq.moveNext()) { if (lastIndex == (-1)) lastIndex = seq.index(); Token<JavaTokenId> t = seq.token(); if (t.id() == JavaTokenId.WHITESPACE) { int nls = numberOfNL(t, seq.offset()); newlines += nls; } else if (isComment(t.id())) { if (index >= 0 && maxLines < Integer.MAX_VALUE && seq.token().length() > 0 && h.comment.id() == JavaTokenId.JAVADOC_COMMENT) { TreePath tp = info.getTreeUtilities().pathFor(seq.offset() + 1); while (tp.getParentPath() != null && positions.getStartPosition(info.getCompilationUnit(), tp.getParentPath().getLeaf()) == seq.offset()) { tp = tp.getParentPath(); if (tp != null && JAVADOC_KINDS.contains(tp.getLeaf().getKind())) { assign = false;
@Override public Boolean scan(Tree tree, Void p) { int lastEndPos = endPos; if (tree != null && tree.getKind() != Tree.Kind.COMPILATION_UNIT) { if (tree instanceof FakeBlock) { endPos = Integer.MAX_VALUE; } else { endPos = (int)sp.getEndPosition(getCurrentPath().getCompilationUnit(), tree); if (tree.getKind() != Tree.Kind.ERRONEOUS && tree.getKind() != Tree.Kind.BLOCK && (tree.getKind() != Tree.Kind.CLASS || getCurrentPath().getLeaf().getKind() != Tree.Kind.NEW_CLASS) && (tree.getKind() != Tree.Kind.NEW_ARRAY)) { int startPos = (int)sp.getStartPosition(getCurrentPath().getCompilationUnit(), tree); if (startPos >= 0 && startPos > tokens.offset()) { tokens.move(startPos); if (!tokens.moveNext()) tokens.movePrevious();
SourcePositions sourcePositions = info.getTrees().getSourcePositions(); TreePath path = pathFor(pos); CompilationUnitTree root = path.getCompilationUnit(); switch (path.getLeaf().getKind()) { case BLOCK: stmts = ((BlockTree)path.getLeaf()).getStatements(); break; case FOR_LOOP: Tree tree = null; for (StatementTree st : stmts) { if (sourcePositions.getStartPosition(root, st) < pos) tree = st; path = new TreePath(path, tree); Scope scope = info.getTrees().getScope(path); if (TreeUtilities.CLASS_TREE_KINDS.contains(path.getLeaf().getKind())) { TokenSequence<JavaTokenId> ts = info.getTokenHierarchy().tokenSequence(JavaTokenId.language()); ts.move(pos); while(ts.movePrevious()) { switch (ts.token().id()) { case WHITESPACE: case LINE_COMMENT:
private List<int[]> detectBreakOrContinueTarget(CompilationInfo info, Document document, TreePath breakOrContinue, int caretPosition) { List<int[]> result = new ArrayList<int[]>(); StatementTree target = info.getTreeUtilities().getBreakContinueTarget(breakOrContinue); TokenSequence<JavaTokenId> ts = info.getTokenHierarchy().tokenSequence(JavaTokenId.language()); ts.move((int) info.getTrees().getSourcePositions().getStartPosition(info.getCompilationUnit(), target)); if (ts.moveNext()) { result.add(new int[] {ts.offset(), ts.offset() + ts.token().length()}); ts.move((int) info.getTrees().getSourcePositions().getEndPosition(info.getCompilationUnit(), block)); if (ts.movePrevious() && ts.token().id() == JavaTokenId.RBRACE) { result.add(new int[] {ts.offset(), ts.offset() + ts.token().length()}); result.addAll(detectLabel(info, document, info.getTrees().getPath(info.getCompilationUnit(), target)));
public static List<Integer> getElementPosition(CompilationInfo info, Tree tree){ SourcePositions srcPos = info.getTrees().getSourcePositions(); int startOffset = (int) srcPos.getStartPosition(info.getCompilationUnit(), tree); int endOffset = (int) srcPos.getEndPosition(info.getCompilationUnit(), tree); if (TreeUtilities.CLASS_TREE_KINDS.contains(tree.getKind())){ startTree = ((ClassTree)tree).getModifiers(); } else if (tree.getKind() == Tree.Kind.METHOD){ startTree = ((MethodTree)tree).getReturnType(); } else if (tree.getKind() == Tree.Kind.VARIABLE){ startTree = ((VariableTree)tree).getType(); int searchStart = (int) srcPos.getEndPosition(info.getCompilationUnit(), startTree); tokenSequence.move(searchStart); eob = !tokenSequence.moveNext(); while (!eob && tokenSequence.token().id() != JavaTokenId.IDENTIFIER); Token<?> identifier = tokenSequence.token(); startOffset = identifier.offset(info.getTokenHierarchy()); endOffset = startOffset + identifier.length();
public int assignToVarPos() { if (assignToVarPos < -1) { TreePath tp = getPath(); Tree tree = tp.getLeaf(); if (tp.getLeaf().getKind() == Tree.Kind.MEMBER_SELECT || (tp.getLeaf().getKind() == Tree.Kind.METHOD_INVOCATION && ((MethodInvocationTree) tp.getLeaf()).getMethodSelect() == tree)) { tp = tp.getParentPath(); } if (tp.getLeaf().getKind() == Tree.Kind.EXPRESSION_STATEMENT) { assignToVarPos = getController().getSnapshot().getOriginalOffset((int) getSourcePositions().getStartPosition(getRoot(), tree)); } else if (tp.getLeaf().getKind() == Tree.Kind.BLOCK) { assignToVarPos = getController().getSnapshot().getOriginalOffset(offset); } else { assignToVarPos = -1; } } return assignToVarPos; } }
private int getIndentLevel(TokenSequence<JavaTokenId> tokens, TreePath path) { if (path.getLeaf().getKind() == Tree.Kind.COMPILATION_UNIT) return 0; Tree lastTree = null; int indent = -1; while (path != null) { int offset = (int)sp.getStartPosition(path.getCompilationUnit(), path.getLeaf()); if (offset < 0) return indent; tokens.move(offset); String text = null; while (tokens.movePrevious()) { Token<JavaTokenId> token = tokens.token(); if (token.id() == WHITESPACE) { text = token.text().toString(); int idx = text.lastIndexOf('\n'); if (idx >= 0) { break; } else if (token.id() == LINE_COMMENT) { indent = text != null ? getCol(text) : 0; break; switch (path.getLeaf().getKind()) { case ANNOTATION_TYPE: case CLASS:
} else { int tdpos = 0; SourcePositions positions = diffContext.trees.getSourcePositions(); int typeDeclStart; do { Tree t = cut.getTypeDecls().get(tdpos); typeDeclStart = (int) positions.getStartPosition(cut, t); if (TreeUtilities.CLASS_TREE_KINDS.contains(t.getKind())) { break; seq.move(typeDeclStart); if (null != moveToSrcRelevant(seq, Direction.BACKWARD)) { resultPos = seq.offset() + seq.token().length(); } else { return 0; while (seq.moveNext() && nonRelevant.contains(seq.token().id()) && counter < 3) { if (JavaTokenId.WHITESPACE == seq.token().id()) { String white = seq.token().text().toString(); int index = 0, pos = 0;
private static Token<JavaTokenId> createHighlightImpl(CompilationInfo info, Document doc, TreePath tree) { Tree leaf = tree.getLeaf(); SourcePositions positions = info.getTrees().getSourcePositions(); CompilationUnitTree cu = info.getCompilationUnit(); int start = (int) positions.getStartPosition(cu, leaf); int end = (int) positions.getEndPosition(cu, leaf); TokenHierarchy<?> th = info.getTokenHierarchy(); TokenSequence<JavaTokenId> ts = th.tokenSequence(JavaTokenId.language()); if (ts.move(start) == Integer.MAX_VALUE) { return null; if (ts.moveNext()) { Token<JavaTokenId> token = ts.token(); if (ts.offset() == start && token != null) { final JavaTokenId id = token.id(); if (id == JavaTokenId.IDENTIFIER) { return token;
private static Token<JavaTokenId> findIdentifierSpanImpl(CompilationInfo info, MemberSelectTree tree, CompilationUnitTree cu, SourcePositions positions) { int start = (int)positions.getStartPosition(cu, tree); int endPosition = (int)positions.getEndPosition(cu, tree); if (start == (-1) || endPosition == (-1)) return null; String member = tree.getIdentifier().toString(); TokenHierarchy<?> th = info.getTokenHierarchy(); TokenSequence<JavaTokenId> ts = th.tokenSequence(JavaTokenId.language()); if (ts.move(endPosition) == Integer.MAX_VALUE) { return null; } if (ts.moveNext()) { while (ts.offset() >= start) { Token<JavaTokenId> t = ts.token(); if (t.id() == JavaTokenId.IDENTIFIER && member.equals(info.getTreeUtilities().decodeIdentifier(t.text()).toString())) { return t; } if (!ts.movePrevious()) break; } } return null; }
if (e == null || javac.getElementUtilities().isSynthetic(e)) return null; tree = javac.getTrees().getTree(e); if (tree == null) return null; int elementStartOffset = (int) javac.getTrees().getSourcePositions().getStartPosition(javac.getCompilationUnit(), tree); TokenSequence<JavaTokenId> s = SourceUtils.getJavaTokenSequence(javac.getTokenHierarchy(), elementStartOffset); if (s == null) { return null; s.move(elementStartOffset); Token<JavaTokenId> token = null; while (s.movePrevious()) { token = s.token(); switch (token.id()) { case BLOCK_COMMENT: if (!"/**/".contentEquals(token.text())) { // NOI18N break; if (token.partType() == PartType.COMPLETE) { return javac.getElements().getDocComment(e) == null ? null : s.embedded(JavadocTokenId.language());
@Override public Void visitIdentifier(IdentifierTree tree, Void d) { if (info.getTrees().getSourcePositions().getStartPosition(getCurrentPath().getCompilationUnit(), tree) < 0) return null; typeUsed(info.getTrees().getElement(getCurrentPath()), getCurrentPath(), getCurrentPath().getParentPath().getLeaf().getKind() == Kind.METHOD_INVOCATION); return super.visitIdentifier(tree, null); }
@Override public Void visitVariable(VariableTree tree, EnumSet<UseTypes> d) { tl.moveToOffset(sourcePositions.getStartPosition(info.getCompilationUnit(), tree)); TreePath type = new TreePath(getCurrentPath(), tree.getType()); if (type.getLeaf() instanceof ArrayTypeTree) { type = new TreePath(type, ((ArrayTypeTree) type.getLeaf()).getType()); if (type.getLeaf().getKind() == Kind.IDENTIFIER) handlePossibleIdentifier(type, EnumSet.of(UseTypes.CLASS_USE)); Element e = info.getTrees().getElement(getCurrentPath()); if (tree.getInitializer() != null) { uses = EnumSet.of(UseTypes.DECLARATION, UseTypes.WRITE); int[] span = info.getTreeUtilities().findNameSpan(tree); if (span != null) tl.moveToOffset(span[0]);
public static Interval createInterval(TreePath tp, CompilationInfo info, Interval root, Interval p, FileObject parentFile) { Tree t = tp.getLeaf(); long start = info.getTrees().getSourcePositions().getStartPosition(info.getCompilationUnit(), t); long end = info.getTrees().getSourcePositions().getEndPosition(info.getCompilationUnit(), t); Element current = info.getTrees().getElement(tp); Tree.Kind kind = tp.getLeaf().getKind(); if (kind != Tree.Kind.CLASS && kind != Tree.Kind.METHOD) { if (tp.getParentPath()==null || tp.getParentPath().getLeaf().getKind() == Tree.Kind.COMPILATION_UNIT) { i.subintervals.add(p); if (tp.getParentPath().getLeaf().getKind() == Tree.Kind.COMPILATION_UNIT) { return i;