Java Diagnostic.NOPOS属性代码示例

@Override
public Void visitIdentifier(IdentifierTree tree, Void d) {
    Element el = info.getTrees().getElement(getCurrentPath());
    if (toFind.equals(el)) {
        try {
            long start = sp.getStartPosition(info.getCompilationUnit(), tree);
            long end = sp.getEndPosition(info.getCompilationUnit(), tree);
            if(start != Diagnostic.NOPOS) {
                MutablePositionRegion region = createRegion(doc, (int) start, (int) end);
                usages.add(region);
            }
        } catch (BadLocationException ex) {
            Exceptions.printStackTrace(ex);
        }
    }
    return super.visitIdentifier(tree, d);
}
 

private void insideRequires(Env env) throws IOException {
    int offset = env.getOffset();
    TreePath path = env.getPath();
    RequiresTree req = (RequiresTree) path.getLeaf();
    Tree name = req.getModuleName();
    if (name != null) {
        int extPos = (int) env.getSourcePositions().getEndPosition(env.getRoot(), name);
        if (extPos != Diagnostic.NOPOS && offset > extPos) {
            return;
        }
    }
    if (!req.isStatic()) {
        addKeyword(env, STATIC_KEYWORD, SPACE, false);
    }
    if (!req.isTransitive()) {
        addKeyword(env, TRANSITIVE_KEYWORD, SPACE, false);
    }
    addModuleNames(env, null, false);
}
 

private void insideArrayAccess(Env env) throws IOException {
    int offset = env.getOffset();
    ArrayAccessTree aat = (ArrayAccessTree) env.getPath().getLeaf();
    SourcePositions sourcePositions = env.getSourcePositions();
    CompilationUnitTree root = env.getRoot();
    int aaTextStart = (int) sourcePositions.getEndPosition(root, aat.getExpression());
    if (aaTextStart != Diagnostic.NOPOS) {
        Tree expr = unwrapErrTree(aat.getIndex());
        if (expr == null || offset <= (int) sourcePositions.getStartPosition(root, expr)) {
            String aatText = env.getController().getText().substring(aaTextStart, offset);
            int bPos = aatText.indexOf('['); //NOI18N
            if (bPos > -1) {
                localResult(env);
                addValueKeywords(env);
            }
        }
    }
}
 

private void insideCompoundAssignment(Env env) throws IOException {
    int offset = env.getOffset();
    CompoundAssignmentTree cat = (CompoundAssignmentTree) env.getPath().getLeaf();
    SourcePositions sourcePositions = env.getSourcePositions();
    CompilationUnitTree root = env.getRoot();
    int catTextStart = (int) sourcePositions.getEndPosition(root, cat.getVariable());
    if (catTextStart != Diagnostic.NOPOS) {
        Tree expr = unwrapErrTree(cat.getExpression());
        if (expr == null || offset <= (int) sourcePositions.getStartPosition(root, expr)) {
            String catText = env.getController().getText().substring(catTextStart, offset);
            int eqPos = catText.indexOf('='); //NOI18N
            if (eqPos > -1) {
                localResult(env);
                addValueKeywords(env);
            }
        }
    }
}
 

private final MethodArgument[] composeArguments(List<? extends Tree> args, List<? extends Tree> argTypes) {
    int n = args.size();
    MethodArgument[] arguments = new MethodArgument[n];
    for (int i = 0; i < n; i++) {
        Tree var = args.get(i);
        long startOffset = positions.getStartPosition(tree, var);
        long endOffset = positions.getEndPosition(tree, var);
        if (startOffset == Diagnostic.NOPOS || endOffset == Diagnostic.NOPOS) {
            return new MethodArgument[] {};
        }
        arguments[i] = new MethodArgument(var.toString(),
                                          (argTypes.size() > i) ? argTypes.get(i).toString() : "",
                                          positionDelegate.createPosition(
                                            (int) startOffset,
                                            (int) lineMap.getLineNumber(startOffset),
                                            (int) lineMap.getColumnNumber(startOffset)),
                                          positionDelegate.createPosition(
                                            (int) endOffset,
                                            (int) lineMap.getLineNumber(endOffset),
                                            (int) lineMap.getColumnNumber(endOffset)));
    }
    return arguments;
}
 

private static Token<JavaTokenId> createHighlightImpl(CompilationInfo info, Document doc, TreePath tree) {
    Tree leaf = tree.getLeaf();
    SourcePositions positions = info.getTrees().getSourcePositions();
    CompilationUnitTree cu = info.getCompilationUnit();
    
    //XXX: do not use instanceof:
    if (leaf instanceof MethodTree || leaf instanceof VariableTree || leaf instanceof ClassTree
            || leaf instanceof MemberSelectTree || leaf instanceof AnnotatedTypeTree || leaf instanceof MemberReferenceTree) {
        return findIdentifierSpan(info, doc, tree);
    }
    
    int start = (int) positions.getStartPosition(cu, leaf);
    int end = (int) positions.getEndPosition(cu, leaf);
    
    if (start == Diagnostic.NOPOS || end == Diagnostic.NOPOS) {
        return null;
    }
    
    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;
            }
            if (id == JavaTokenId.THIS || id == JavaTokenId.SUPER) {
                return ts.offsetToken();
            }
        }
    }
    
    return null;
}
 

private void insideUses(Env env) throws IOException {
    int offset = env.getOffset();
    TreePath path = env.getPath();
    UsesTree uses = (UsesTree) path.getLeaf();
    Tree name = uses.getServiceName();
    if (name != null) {
        int extPos = (int) env.getSourcePositions().getEndPosition(env.getRoot(), name);
        if (extPos != Diagnostic.NOPOS && offset > extPos) {
            return;
        }
    }
    options.add(Options.ALL_COMPLETION);
    addTypes(env, EnumSet.of(ANNOTATION_TYPE, CLASS, INTERFACE), null);
}
 

private void insideAssignment(Env env) throws IOException {
    int offset = env.getOffset();
    TreePath path = env.getPath();
    AssignmentTree as = (AssignmentTree) path.getLeaf();
    SourcePositions sourcePositions = env.getSourcePositions();
    CompilationUnitTree root = env.getRoot();
    int asTextStart = (int) sourcePositions.getEndPosition(root, as.getVariable());
    if (asTextStart != Diagnostic.NOPOS) {
        Tree expr = unwrapErrTree(as.getExpression());
        if (expr == null || offset <= (int) sourcePositions.getStartPosition(root, expr)) {
            CompilationController controller = env.getController();
            String asText = controller.getText().substring(asTextStart, offset);
            int eqPos = asText.indexOf('='); //NOI18N
            if (eqPos > -1) {
                TreePath parentPath = path.getParentPath();
                if (parentPath.getLeaf().getKind() != Tree.Kind.ANNOTATION) {
                    localResult(env);
                    addValueKeywords(env);
                } else if (as.getVariable().getKind() == Tree.Kind.IDENTIFIER) {
                    insideAnnotationAttribute(env, parentPath, ((IdentifierTree) as.getVariable()).getName());
                    addLocalConstantsAndTypes(env);
                }
            }
        } else {
            insideExpression(env, new TreePath(path, expr));
        }
    }
}
 

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);
        if (last != null) {
            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()) {
                    if (bound.getKind() == TypeKind.DECLARED) {
                        env.addToExcludes(((DeclaredType) bound).asElement());
                    }
                }
                addTypes(env, EnumSet.of(INTERFACE, ANNOTATION_TYPE), null);
            } else {
                localResult(env);
                addValueKeywords(env);
            }
        }
    }
}
 

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);
        }
    }
}
 

List<Tree> getArgumentsUpToPos(Env env, Iterable<? extends ExpressionTree> args, int startPos, int position, boolean strict) {
    List<Tree> ret = new ArrayList<>();
    CompilationUnitTree root = env.getRoot();
    SourcePositions sourcePositions = env.getSourcePositions();
    if (args == null) {
        return null; //TODO: member reference???
    }
    for (ExpressionTree e : args) {
        int pos = (int) sourcePositions.getEndPosition(root, e);
        if (pos != Diagnostic.NOPOS && (position > pos || !strict && position == pos)) {
            startPos = pos;
            ret.add(e);
        } else {
            break;
        }
    }
    if (startPos < 0) {
        return ret;
    }
    if (position >= startPos) {
        TokenSequence<JavaTokenId> last = findLastNonWhitespaceToken(env, startPos, position);
        if (last == null) {
            if (!strict && !ret.isEmpty()) {
                ret.remove(ret.size() - 1);
                return ret;
            }
        } else if (last.token().id() == JavaTokenId.LPAREN || last.token().id() == JavaTokenId.COMMA) {
            return ret;
        }
    }
    return null;
}
 

private boolean isCurrentTree(Tree aTree) {
    int startLine = (int) lineMap.getLineNumber(positions.getStartPosition(tree, aTree));
    if (startLine == Diagnostic.NOPOS) {
        return false;
    }
    int endLine = (int) lineMap.getLineNumber(positions.getEndPosition(tree, aTree));
    if (endLine == Diagnostic.NOPOS) {
        return false;
    }
    return startLine <= lineNumber && lineNumber <= endLine;
}
 

private Diagnostic<JavaFileObject> createDiagnostic(
        final Diagnostic.Kind kind, final String code, final Object... args) {
    return new Diagnostic<JavaFileObject>() {
        public String getCode() {
            return code;
        }
        public long getColumnNumber() {
            return Diagnostic.NOPOS;
        }
        public long getEndPosition() {
            return Diagnostic.NOPOS;
        }
        public Kind getKind() {
            return kind;
        }
        public long getLineNumber() {
            return Diagnostic.NOPOS;
        }
        public String getMessage(Locale locale) {
            if (code.length() == 0)
                return (String) args[0];
            return getText(code, args); // FIXME locale
        }
        public long getPosition() {
            return Diagnostic.NOPOS;
        }
        public JavaFileObject getSource() {
            return null;
        }
        public long getStartPosition() {
            return Diagnostic.NOPOS;
        }
    };
}
 

public static void main(String[] args) throws Exception {
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    if (compiler == null) {
        throw new RuntimeException("can't get javax.tools.JavaCompiler!");
    }
    DiagnosticCollector<JavaFileObject> diagColl =
        new DiagnosticCollector<JavaFileObject>();
    try (StandardJavaFileManager fm = compiler.getStandardFileManager(null, null, null)) {
        List<String> options = new ArrayList<String>();
        options.add("-processor");
        options.add("MyProcessor");
        options.add("-proc:only");
        List<File> files = new ArrayList<File>();
        files.add(new File(T6458823.class.getResource("TestClass.java").toURI()));
        final CompilationTask task = compiler.getTask(null, fm, diagColl,
            options, null, fm.getJavaFileObjectsFromFiles(files));
        task.call();
        int diagCount = 0;
        for (Diagnostic<? extends JavaFileObject> diag : diagColl.getDiagnostics()) {
            if (diag.getKind() != Diagnostic.Kind.WARNING) {
                throw new AssertionError("Only warnings expected");
            }
            System.out.println(diag);
            if (diag.getPosition() == Diagnostic.NOPOS) {
                throw new AssertionError("No position info in message");
            }
            if (diag.getSource() == null) {
                throw new AssertionError("No source info in message");
            }
            diagCount++;
        }
        if (diagCount != 2) {
            throw new AssertionError("unexpected number of warnings: " +
                diagCount + ", expected: 2");
        }
    }
}
 

public static EditorContext.Operation[] computeOperations(CompilationController ci,
                                                          int offset,
                                                          int lineNumber,
                                                          EditorContext.BytecodeProvider bytecodeProvider,
                                                          ASTOperationCreationDelegate opCreationDelegate) throws IOException {
    if (!PreferredCCParser.toPhase(ci, JavaSource.Phase.RESOLVED, LOG)) {//TODO: ELEMENTS_RESOLVED may be sufficient
        return new EditorContext.Operation[] {};
    }
    // We need the enclosing statement/block
    Tree statementTree = findStatementInScope(ci.getTreeUtilities().pathFor(offset));
    LOG.log(Level.FINE, "Statement tree found at line {0}:\n{1}\n", new Object[]{ lineNumber, statementTree });
    if (statementTree == null) {
        Scope scope = ci.getTreeUtilities().scopeFor(offset);
        Element method = scope.getEnclosingMethod();
        if (method == null) {
            return new EditorContext.Operation[] {};
        }
        statementTree = ci.getTrees().getTree(method);
    }
    if (statementTree == null) { // method not found
        return new EditorContext.Operation[] {};
    }
    CompilationUnitTree cu = ci.getCompilationUnit();
    SourcePositions sp = ci.getTrees().getSourcePositions();
    int statementStart = (int) cu.getLineMap().getLineNumber(sp.getStartPosition(cu, statementTree));
    int statementEnd = (int) cu.getLineMap().getLineNumber(sp.getEndPosition(cu, statementTree));
    ExpressionScanner scanner = new ExpressionScanner(lineNumber, statementStart, statementEnd,
                                                      cu, ci.getTrees().getSourcePositions());
    ExpressionScanner.ExpressionsInfo info = new ExpressionScanner.ExpressionsInfo();
    List<Tree> expTrees = statementTree.accept(scanner, info);

    LOG.log(Level.FINE, "expression trees = {0}", expTrees);
    
    //com.sun.source.tree.ExpressionTree expTree = scanner.getExpressionTree();
    if (expTrees == null || expTrees.isEmpty()) {
        return new EditorContext.Operation[] {};
    }
    int treeStartLine = Integer.MAX_VALUE;
    int treeEndLine = 0;
    for (int i = 0; i < expTrees.size(); i++) {
        Tree tree = expTrees.get(i);
        int start = (int) cu.getLineMap().getLineNumber(
            sp.getStartPosition(cu, tree));
        int end = (int) cu.getLineMap().getLineNumber(
            sp.getEndPosition(cu, tree));
        if (start == Diagnostic.NOPOS || end == Diagnostic.NOPOS) {
            continue;
        }
        if (start < treeStartLine) {
            treeStartLine = start;
        }
        if (end > treeEndLine) {
            treeEndLine = end;
        }
    }
    if (treeStartLine == Integer.MAX_VALUE) {
        return null;
    }
    //t3 = System.nanoTime();
    int[] indexes = bytecodeProvider.indexAtLines(treeStartLine, treeEndLine);
    if (indexes == null) {
        return null;
    }
    Map<Tree, EditorContext.Operation> nodeOperations = new HashMap<Tree, EditorContext.Operation>();
    EditorContext.Operation[] ops = AST2Bytecode.matchSourceTree2Bytecode(
            cu,
            ci,
            expTrees, info, bytecodeProvider.byteCodes(),
            indexes,
            bytecodeProvider.constantPool(),
            opCreationDelegate,
            nodeOperations);
    if (ops != null) {
        assignNextOperations(statementTree, cu, ci,
                             bytecodeProvider, opCreationDelegate,
                             expTrees, info, nodeOperations);
    }
    return ops;
}