SourcePositions positions = diffContext.trees.getSourcePositions(); CompilationUnitTree compilationUnit = diffContext.origUnit; int sectionStart = (int) positions.getStartPosition(compilationUnit, oldL.get(0)); int sectionEnd = (int) positions.getEndPosition(compilationUnit, oldL.get(oldL.size()-1)); seq.move(sectionStart); seq.moveNext(); Token<JavaTokenId> token; while (seq.movePrevious() && nonRelevant.contains((token = seq.token()).id())) { if (JavaTokenId.LINE_COMMENT == token.id()) { break; } else if (JavaTokenId.BLOCK_COMMENT == token.id() || JavaTokenId.JAVADOC_COMMENT == token.id()) { break; } else if (JavaTokenId.WHITESPACE == token.id()) { int indexOf = token.text().toString().indexOf('\n'); while (seq.moveNext() && nonRelevant.contains((token = seq.token()).id())) { if (JavaTokenId.LINE_COMMENT == token.id()) { } else if (JavaTokenId.BLOCK_COMMENT == token.id() || JavaTokenId.JAVADOC_COMMENT == token.id()) { break; } else if (JavaTokenId.WHITESPACE == token.id()) { int indexOf = token.text().toString().indexOf('\n'); sectionEnd = seq.offset() + token.text().length();
protected int[] findNextSpellSpan() throws BadLocationException { TokenHierarchy<Document> h = TokenHierarchy.get((Document) doc); TokenSequence<?> ts = h.tokenSequence(); if (ts == null || hidden) { return new int[]{-1, -1}; } ts.move(nextSearchOffset); while (ts.moveNext()) { TokenId id = ts.token().id(); if (id == XMLTokenId.BLOCK_COMMENT || id == XMLTokenId.TEXT) { return new int[]{ts.offset(), ts.offset() + ts.token().length()}; } } return new int[]{-1, -1}; } }
@Override public void run() { TokenHierarchy<Document> hi = TokenHierarchy.get(doc); TokenSequence<?> ts = hi.tokenSequence(); while (ts.moveNext()) { Token<?> token = ts.token(); if (CppTokenId.COMMENT_CATEGORY.equals(token.id().primaryCategory())) { TokenSequence<?> te = ts.embedded(); if (te != null) { while (te.moveNext()) { Token<?> commentToken = te.token(); if (commentToken.id() == DoxygenTokenId.IDENT) { if (text.contentEquals(commentToken.text())) { int offset = commentToken.offset(hi); comments.add(new CsmCommentReferenceImpl(text, offset, offset + commentToken.length(), file)); } } } } } } } });
private void insideModifiers(Env env, TreePath modPath) throws IOException { int offset = env.getOffset(); ModifiersTree mods = (ModifiersTree) modPath.getLeaf(); Set<Modifier> m = EnumSet.noneOf(Modifier.class); TokenSequence<JavaTokenId> ts = env.getController().getTreeUtilities().tokensFor(mods, env.getSourcePositions()); JavaTokenId lastNonWhitespaceTokenId = null; while (ts.moveNext() && ts.offset() < offset) { lastNonWhitespaceTokenId = ts.token().id(); switch (lastNonWhitespaceTokenId) { case PUBLIC: addTypes(env, EnumSet.of(ANNOTATION_TYPE), null); return; TreePath parentPath = modPath.getParentPath(); Tree parent = parentPath.getLeaf(); TreePath grandParentPath = parentPath.getParentPath(); Tree grandParent = grandParentPath != null ? grandParentPath.getLeaf() : null; if (isTopLevelClass(parent, env.getRoot())) { addClassModifiers(env, m); } else if (parent.getKind() != Tree.Kind.VARIABLE || grandParent == null || TreeUtilities.CLASS_TREE_KINDS.contains(grandParent.getKind())) { addMemberModifiers(env, m, false); addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null); } else if (parent.getKind() == Tree.Kind.VARIABLE && grandParent.getKind() == Tree.Kind.METHOD) { addMemberModifiers(env, m, true); addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null);
private void insideMemberReference(Env env) throws IOException { TreePath path = env.getPath(); MemberReferenceTree mr = (MemberReferenceTree) path.getLeaf(); TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, mr, env.getOffset()); if (ts != null) { switch (ts.token().id()) { case COLONCOLON: case GT: CompilationController controller = env.getController(); ExpressionTree exp = mr.getQualifierExpression(); TreePath expPath = new TreePath(path, exp); Trees trees = controller.getTrees(); TypeMirror type = trees.getTypeMirror(expPath); if (type != null && type.getKind() == TypeKind.TYPEVAR) { while (type != null && type.getKind() == TypeKind.TYPEVAR) { Element e = trees.getElement(expPath); addMethodReferences(env, type, e); if (e == null || e.getKind().isClass() || e.getKind().isInterface()) { case LT: case COMMA: addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null); break;
private void insideTypeCheck(Env env) throws IOException { InstanceOfTree iot = (InstanceOfTree) env.getPath().getLeaf(); TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, iot, env.getOffset()); if (ts != null && ts.token().id() == JavaTokenId.INSTANCEOF) { addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null); } }
public int prepare(int startPos, StringBuilder aHead, StringBuilder aTail) { seq.move(startPos); seq.moveNext(); moveToSrcRelevant(seq, Direction.BACKWARD); while (seq.moveNext() && nonRelevant.contains(seq.token().id())) { if (JavaTokenId.WHITESPACE == seq.token().id()) { int newlineInToken = seq.token().text().toString().indexOf('\n'); if (newlineInToken > -1) { return seq.offset() + newlineInToken + 1; } } else if (JavaTokenId.LINE_COMMENT == seq.token().id()) { return seq.offset() + seq.token().text().length(); } } return startPos; }
private TokenSequence<JavaTokenId> findFirstOtherToken(int startOffset, int endOffset, EnumSet<JavaTokenId> ids) { if (startOffset == endOffset) { return null; } ts.move(startOffset); boolean backward = startOffset > endOffset; while (backward ? ts.movePrevious() : ts.moveNext()) { if (backward && ts.offset() < endOffset || !backward && ts.offset() > endOffset) { return null; } if (!ids.contains(ts.token().id())) { return ts; } } return null; }
private void insideMethodInvocation(Env env) throws IOException { TreePath path = env.getPath(); MethodInvocationTree mi = (MethodInvocationTree) path.getLeaf(); int offset = env.getOffset(); TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, mi, offset); if (ts == null || (ts.token().id() != JavaTokenId.LPAREN && ts.token().id() != JavaTokenId.COMMA)) { SourcePositions sp = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); int lastTokenEndOffset = ts != null ? ts.offset() + ts.token().length() : -1; for (ExpressionTree arg : mi.getArguments()) { int pos = (int) sp.getEndPosition(root, arg); if (lastTokenEndOffset == pos) { insideExpression(env, new TreePath(path, arg)); break; } if (offset <= pos) { break; } } return; } String prefix = env.getPrefix(); if (prefix == null || prefix.length() == 0) { addMethodArguments(env, mi); } addLocalMembersAndVars(env); addValueKeywords(env); addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null); addPrimitiveTypeKeywords(env); }
private void insideLambdaExpression(Env env) throws IOException { TreePath path = env.getPath(); LambdaExpressionTree let = (LambdaExpressionTree) path.getLeaf(); TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, let, env.getOffset()); if (ts != null) { switch (ts.token().id()) { case ARROW: localResult(env); addValueKeywords(env); break; case COMMA: if (let.getParameters().isEmpty() || env.getController().getTrees().getSourcePositions().getStartPosition(path.getCompilationUnit(), let.getParameters().get(0).getType()) >= 0) { addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null); addPrimitiveTypeKeywords(env); addKeyword(env, FINAL_KEYWORD, SPACE, false); } break; } } }
int pos = (int) sourcePositions.getEndPosition(root, fl.getCondition()); if (pos != Diagnostic.NOPOS && pos < offset) { lastTree = fl.getCondition(); int pos = (int) sourcePositions.getEndPosition(root, init); if (pos == Diagnostic.NOPOS || offset <= pos) { break; if (last != null && last.token().id() == JavaTokenId.LPAREN) { addLocalFieldsAndVars(env); addTypes(env, EnumSet.of(CLASS, INTERFACE, ENUM, ANNOTATION_TYPE, TYPE_PARAMETER), null); addPrimitiveTypeKeywords(env); if (last != null && last.token().id() == JavaTokenId.SEMICOLON) { localResult(env); addValueKeywords(env); } else if (last != null && last.token().id() == JavaTokenId.RPAREN) { localResult(env); addKeywordsForStatement(env); } else { switch (lastTree.getKind()) { case VARIABLE: Tree var = ((VariableTree) lastTree).getInitializer(); if (var != null) { insideExpression(env, new TreePath(new TreePath(path, lastTree), var));
private void insideTypeParameter(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); TypeParameterTree tp = (TypeParameterTree) path.getLeaf(); CompilationController controller = env.getController(); TokenSequence<JavaTokenId> ts = findLastNonWhitespaceToken(env, tp, offset); if (ts != null) { switch (ts.token().id()) { case EXTENDS: controller.toPhase(Phase.ELEMENTS_RESOLVED); addTypes(env, EnumSet.of(CLASS, INTERFACE, ANNOTATION_TYPE), null); break; case AMP: controller.toPhase(Phase.ELEMENTS_RESOLVED); addTypes(env, EnumSet.of(INTERFACE, ANNOTATION_TYPE), null); break; case IDENTIFIER: if (ts.offset() == env.getSourcePositions().getStartPosition(env.getRoot(), tp)) { addKeyword(env, EXTENDS_KEYWORD, SPACE, false); } break; } } }
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())) { comments.add(new TrailingCommentsDataHolder(newlines, t, lastIndex)); maxLines = Math.max(maxLines, newlines); if (t.id() == JavaTokenId.LINE_COMMENT) { newlines = 1; lastWhiteNewline = seq.offset() + t.length(); } else { newlines = 0; if (t.id() == JavaTokenId.RBRACE || t.id() == JavaTokenId.ELSE) maxLines = Integer.MAX_VALUE; break; 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);
} 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; while ((pos = white.indexOf('\n', pos)) > -1) { } else if (JavaTokenId.LINE_COMMENT == seq.token().id()) { ++counter; resultPos += seq.token().text().toString().length(); } else if (JavaTokenId.BLOCK_COMMENT == seq.token().id() || JavaTokenId.JAVADOC_COMMENT == seq.token().id()) {
static JavaTokenId moveFwdToOneOfTokens(TokenSequence<JavaTokenId> tokenSequence, final int pos, EnumSet<JavaTokenId> ids) { tokenSequence.move(pos); tokenSequence.moveNext(); // Assumes the pos is located within input bounds while (!ids.contains(tokenSequence.token().id())) { if (!tokenSequence.moveNext()) return null; } return tokenSequence.token().id(); }
@SuppressWarnings("empty-statement") private static int goAfterLastNewLine(final TokenSequence<JavaTokenId> seq) { int base = seq.offset(); seq.movePrevious(); while (seq.moveNext() && nonRelevant.contains(seq.token().id())) ; while (seq.movePrevious() && nonRelevant.contains(seq.token().id())) { switch (seq.token().id()) { case LINE_COMMENT: seq.moveNext(); return seq.offset(); case WHITESPACE: char[] c = seq.token().text().toString().toCharArray(); for (int i = c.length; i > 0; ) { if (c[--i] == '\n') { return seq.offset() + i + 1; } } } } if ((seq.index() == 0 || seq.moveNext()) && nonRelevant.contains(seq.token().id())) { return seq.offset(); } return base; }
private static boolean isEachOfTokens(Token[] tokens, PHPTokenId[] tokenIds) { Set<PHPTokenId> set = EnumSet.noneOf(PHPTokenId.class); for (Token token : tokens) { TokenId searchedId = token.id(); for (PHPTokenId tokenId : tokenIds) { if (tokenId.equals(searchedId)) { set.add(tokenId); } } } return set.size() == tokenIds.length; }