static int moveBackToToken(TokenSequence<JavaTokenId> tokenSequence, final int pos, JavaTokenId id) { tokenSequence.move(pos); tokenSequence.moveNext(); // Assumes the pos is located within input bounds while (!id.equals(tokenSequence.token().id())) { if (!tokenSequence.movePrevious()) return -1; } return tokenSequence.offset(); }
@SuppressWarnings("unchecked") private void reformatImpl(TokenHierarchy<?> hierarchy, int startOffset, int endOffset) throws BadLocationException { TokenSequence<?> ts = hierarchy.tokenSequence(); ts.move(startOffset); if (ts.moveNext() && ts.token().id() != CppTokenId.NEW_LINE){ while (ts.movePrevious()){ startOffset = ts.offset(); if (ts.token().id() != CppTokenId.NEW_LINE) { break; } } } while (ts != null && (startOffset == 0 || ts.moveNext())) { ts.move(startOffset); if (CndLexerUtilities.isCppLanguage(ts.language(), true)) { reformatImpl((TokenSequence<CppTokenId>) ts, startOffset, endOffset); return; } if (!ts.moveNext() && !ts.movePrevious()) { return; } ts = ts.embedded(); } }
private static boolean isPreprocessorDirectiveCompletionEnabledImpl(Document doc, int offset) { TokenSequence<TokenId> ts = CndLexerUtilities.getCppTokenSequence(doc, offset, false, true); if (ts == null) { return false; } if (ts.token().id() == CppTokenId.PREPROCESSOR_DIRECTIVE) { @SuppressWarnings("unchecked") TokenSequence<TokenId> embedded = (TokenSequence<TokenId>) ts.embedded(); embedded.moveStart(); embedded.moveNext(); // skip starting # if (!embedded.moveNext()) { return true; // the end of embedded token stream } CndTokenUtilities.shiftToNonWhite(embedded, false); return embedded.offset() + embedded.token().length() >= offset; } return false; }
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(); }
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 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; } } }
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 insideBinaryTree(Env env) throws IOException { int offset = env.getOffset(); TreePath path = env.getPath(); BinaryTree bi = (BinaryTree) path.getLeaf(); SourcePositions sourcePositions = env.getSourcePositions(); CompilationUnitTree root = env.getRoot(); int pos = (int) sourcePositions.getEndPosition(root, bi.getRightOperand()); if (pos != Diagnostic.NOPOS && pos < offset) { return; pos = (int) sourcePositions.getEndPosition(root, bi.getLeftOperand()); if (pos != Diagnostic.NOPOS) { TokenSequence<JavaTokenId> last = findLastNonWhitespaceToken(env, pos, offset); CompilationController controller = env.getController(); controller.toPhase(Phase.RESOLVED); TypeMirror tm = last.token().id() == JavaTokenId.AMP ? controller.getTrees().getTypeMirror(new TreePath(path, bi.getLeftOperand())) : null; if (tm != null && tm.getKind() == TypeKind.DECLARED) { env.addToExcludes(((DeclaredType) tm).asElement()); addTypes(env, EnumSet.of(INTERFACE, ANNOTATION_TYPE), null); } else if (tm != null && tm.getKind() == TypeKind.INTERSECTION) { for (TypeMirror bound : ((IntersectionType) tm).getBounds()) { addTypes(env, EnumSet.of(INTERFACE, ANNOTATION_TYPE), null); } else { localResult(env);
} 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()) {
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; previousEnd = seq.offset() + token.text().length(); break; break; if (!seq.moveNext()) break;
@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; }
while (seq.moveNext() && seq.offset() < plainCommentLimit) { JavaTokenId id = seq.token().id(); if (isComment(id)) { if (cc == null) { tokenIndexAlreadyAdded = seq.index(); if (plainCommentLimit < reset && JAVADOC_KINDS.contains(tree.getKind())) { int end = 0; CommentsCollection result = new CommentsCollection(); while (seq.moveNext() && seq.offset() < reset) { JavaTokenId id = seq.token().id(); if (id == JavaTokenId.JAVADOC_COMMENT) { mixedJDocTokenIndexes.add(seq.index()); start = Math.min(seq.offset(), start); end = Math.max(seq.offset() + seq.token().length(), end); result.add(seq.token()); seq.move(reset); seq.moveNext();
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 if (ts.token().partType() == PartType.COMPLETE) { return null; offsetBehindJavadoc = ts.offset(); Tree leaf = tp.getLeaf(); Kind kind = leaf.getKind(); SourcePositions positions = javac.getTrees().getSourcePositions(); tp = tp.getParentPath(); if (tp == null) { leaf = null; break; leaf = tp.getLeaf(); kind = leaf.getKind(); || positions.getStartPosition(javac.getCompilationUnit(), leaf) < offset) {
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:
return null; 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)));
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; }