| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| package org.netbeans.modules.java.completion; |
| |
| import java.io.IOException; |
| import java.util.*; |
| import java.util.concurrent.Callable; |
| |
| import javax.lang.model.element.Element; |
| import static javax.lang.model.element.ElementKind.METHOD; |
| import javax.lang.model.element.ExecutableElement; |
| import static javax.lang.model.element.Modifier.*; |
| import javax.lang.model.element.TypeElement; |
| import javax.lang.model.type.DeclaredType; |
| import javax.lang.model.type.TypeKind; |
| import javax.lang.model.type.TypeMirror; |
| import javax.lang.model.util.Types; |
| import javax.tools.Diagnostic; |
| |
| import com.sun.source.tree.*; |
| import com.sun.source.tree.Tree.Kind; |
| import com.sun.source.util.SourcePositions; |
| import com.sun.source.util.TreePath; |
| import org.netbeans.api.java.source.support.ErrorAwareTreeScanner; |
| import javax.lang.model.element.Name; |
| |
| import org.netbeans.api.java.lexer.JavaTokenId; |
| import org.netbeans.api.java.source.*; |
| import org.netbeans.api.java.source.support.ReferencesCount; |
| import org.netbeans.api.lexer.TokenSequence; |
| import org.netbeans.modules.parsing.api.ResultIterator; |
| import org.netbeans.modules.parsing.api.UserTask; |
| import org.netbeans.modules.parsing.spi.Parser; |
| |
| /** |
| * |
| * @author Dusan Balek |
| */ |
| abstract class BaseTask extends UserTask { |
| |
| protected final int caretOffset; |
| protected final Callable<Boolean> cancel; |
| private int caretInSnapshot; |
| |
| protected BaseTask(int caretOffset, Callable<Boolean> cancel) { |
| this.caretOffset = caretOffset; |
| this.cancel = cancel; |
| } |
| |
| |
| final int getCaretInSnapshot() { |
| return caretInSnapshot; |
| } |
| |
| private CompilationController controller; |
| |
| final int snapshotPos(int pos) { |
| if (pos < 0) { |
| return pos; |
| } |
| int r = controller.getSnapshot().getEmbeddedOffset(pos); |
| if (r == -1) { |
| return pos; |
| } else { |
| return r; |
| } |
| } |
| |
| @Override |
| public void run(ResultIterator resultIterator) throws Exception { |
| Parser.Result result = resultIterator.getParserResult(caretOffset); |
| CompilationController controller = result != null ? CompilationController.get(result) : null; |
| if (controller != null && (cancel == null || !cancel.call())) { |
| try { |
| this.controller = controller; |
| caretInSnapshot = snapshotPos(caretOffset); |
| resolve(controller); |
| } finally { |
| this.controller = null; |
| } |
| } |
| } |
| |
| protected abstract void resolve(CompilationController controller) throws IOException; |
| |
| Tree unwrapErrTree(Tree tree) { |
| if (tree != null && tree.getKind() == Tree.Kind.ERRONEOUS) { |
| Iterator<? extends Tree> it = ((ErroneousTree) tree).getErrorTrees().iterator(); |
| tree = it.hasNext() ? it.next() : null; |
| } |
| return tree; |
| } |
| |
| TypeMirror asMemberOf(Element element, TypeMirror type, Types types) { |
| TypeMirror ret = element.asType(); |
| TypeMirror enclType = element.getEnclosingElement().asType(); |
| if (enclType.getKind() == TypeKind.DECLARED) { |
| enclType = types.erasure(enclType); |
| } |
| while (type != null && type.getKind() == TypeKind.DECLARED) { |
| if ((enclType.getKind() != TypeKind.DECLARED || ((DeclaredType) enclType).asElement().getSimpleName().length() > 0) && types.isSubtype(type, enclType)) { |
| ret = types.asMemberOf((DeclaredType) type, element); |
| break; |
| } |
| type = ((DeclaredType) type).getEnclosingType(); |
| } |
| return ret; |
| } |
| |
| 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; |
| } |
| |
| TokenSequence<JavaTokenId> findFirstNonWhitespaceToken(Env env, int startPos, int endPos) { |
| TokenSequence<JavaTokenId> ts = env.getController().getTokenHierarchy().tokenSequence(JavaTokenId.language()); |
| ts.move(startPos); |
| ts = nextNonWhitespaceToken(ts); |
| if (ts == null || ts.offset() >= endPos) { |
| return null; |
| } |
| return ts; |
| } |
| |
| TokenSequence<JavaTokenId> nextNonWhitespaceToken(TokenSequence<JavaTokenId> ts) { |
| while (ts.moveNext()) { |
| switch (ts.token().id()) { |
| case WHITESPACE: |
| case LINE_COMMENT: |
| case BLOCK_COMMENT: |
| case JAVADOC_COMMENT: |
| break; |
| default: |
| return ts; |
| } |
| } |
| return null; |
| } |
| |
| TokenSequence<JavaTokenId> findLastNonWhitespaceToken(Env env, Tree tree, int position) { |
| int startPos = (int) env.getSourcePositions().getStartPosition(env.getRoot(), tree); |
| return findLastNonWhitespaceToken(env, startPos, position); |
| } |
| |
| TokenSequence<JavaTokenId> findLastNonWhitespaceToken(Env env, int startPos, int endPos) { |
| TokenSequence<JavaTokenId> ts = env.getController().getTokenHierarchy().tokenSequence(JavaTokenId.language()); |
| ts.move(endPos); |
| ts = previousNonWhitespaceToken(ts); |
| if (ts == null || ts.offset() < startPos) { |
| return null; |
| } |
| return ts; |
| } |
| |
| TokenSequence<JavaTokenId> previousNonWhitespaceToken(TokenSequence<JavaTokenId> ts) { |
| while (ts.movePrevious()) { |
| switch (ts.token().id()) { |
| case WHITESPACE: |
| case LINE_COMMENT: |
| case BLOCK_COMMENT: |
| case JAVADOC_COMMENT: |
| break; |
| default: |
| return ts; |
| } |
| } |
| return null; |
| } |
| |
| Env getCompletionEnvironment(CompilationController controller, boolean bottomUpSearch) throws IOException { |
| controller.toPhase(JavaSource.Phase.PARSED); |
| int offset = controller.getSnapshot().getEmbeddedOffset(caretOffset); |
| if (offset < 0 || offset > controller.getText().length()) { |
| return null; |
| } |
| String prefix = null; |
| if (offset > 0) { |
| if (bottomUpSearch) { |
| TokenSequence<JavaTokenId> ts = controller.getTokenHierarchy().tokenSequence(JavaTokenId.language()); |
| // When right at the token end move to previous token; otherwise move to the token that "contains" the offset |
| if (ts.move(offset) == 0 || !ts.moveNext()) { |
| ts.movePrevious(); |
| } |
| int len = offset - ts.offset(); |
| if (len > 0 && ts.token().length() >= len) { |
| if (ts.token().id() == JavaTokenId.IDENTIFIER |
| || ts.token().id().primaryCategory().startsWith("keyword") || //NOI18N |
| ts.token().id().primaryCategory().startsWith("string") || //NOI18N |
| ts.token().id().primaryCategory().equals("literal")) //NOI18N |
| { //TODO: Use isKeyword(...) when available |
| prefix = ts.token().text().toString().substring(0, len); |
| offset = ts.offset(); |
| } else if ((ts.token().id() == JavaTokenId.DOUBLE_LITERAL |
| || ts.token().id() == JavaTokenId.FLOAT_LITERAL |
| || ts.token().id() == JavaTokenId.FLOAT_LITERAL_INVALID |
| || ts.token().id() == JavaTokenId.LONG_LITERAL) |
| && ts.token().text().charAt(0) == '.') { |
| prefix = ts.token().text().toString().substring(1, len); |
| offset = ts.offset() + 1; |
| } |
| } |
| } else { |
| TokenSequence<JavaTokenId> ts = controller.getTokenHierarchy().tokenSequence(JavaTokenId.language()); |
| // When right at the token start move offset to the position "inside" the token |
| ts.move(offset); |
| if (!ts.moveNext()) { |
| ts.movePrevious(); |
| } |
| if (ts.offset() == offset && ts.token().length() > 0 |
| && (ts.token().id() == JavaTokenId.IDENTIFIER |
| || ts.token().id().primaryCategory().startsWith("keyword") || //NOI18N |
| ts.token().id().primaryCategory().startsWith("string") || //NOI18N |
| ts.token().id().primaryCategory().equals("literal"))) { //NOI18N |
| offset++; |
| } |
| } |
| } |
| offset = Math.min(offset, controller.getText().length()); |
| TreePath path = controller.getTreeUtilities().pathFor(offset); |
| if (bottomUpSearch) { |
| TreePath treePath = path; |
| while (treePath != null) { |
| TreePath pPath = treePath.getParentPath(); |
| TreePath gpPath = pPath != null ? pPath.getParentPath() : null; |
| JavaCompletionTask.Env env = getEnvImpl(controller, path, treePath, pPath, gpPath, offset, prefix, true); |
| if (env != null) { |
| return env; |
| } |
| treePath = treePath.getParentPath(); |
| } |
| } else { |
| if (JavaSource.Phase.RESOLVED.compareTo(controller.getPhase()) > 0) { |
| LinkedList<TreePath> reversePath = new LinkedList<>(); |
| TreePath treePath = path; |
| while (treePath != null) { |
| reversePath.addFirst(treePath); |
| treePath = treePath.getParentPath(); |
| } |
| for (TreePath tp : reversePath) { |
| TreePath pPath = tp.getParentPath(); |
| TreePath gpPath = pPath != null ? pPath.getParentPath() : null; |
| Env env = getEnvImpl(controller, path, tp, pPath, gpPath, offset, prefix, false); |
| if (env != null) { |
| return env; |
| } |
| } |
| } |
| } |
| return new Env(offset, prefix, controller, path, controller.getTrees().getSourcePositions(), null); |
| } |
| |
| private Env getEnvImpl(CompilationController controller, TreePath orig, TreePath path, TreePath pPath, TreePath gpPath, int offset, String prefix, boolean upToOffset) throws IOException { |
| Tree tree = path != null ? path.getLeaf() : null; |
| Tree parent = pPath != null ? pPath.getLeaf() : null; |
| Tree grandParent = gpPath != null ? gpPath.getLeaf() : null; |
| SourcePositions sourcePositions = controller.getTrees().getSourcePositions(); |
| CompilationUnitTree root = controller.getCompilationUnit(); |
| TreeUtilities tu = controller.getTreeUtilities(); |
| if (upToOffset && TreeUtilities.CLASS_TREE_KINDS.contains(tree.getKind())) { |
| controller.toPhase(withinAnonymousOrLocalClass(tu, path) ? JavaSource.Phase.RESOLVED : JavaSource.Phase.ELEMENTS_RESOLVED); |
| return new Env(offset, prefix, controller, orig, sourcePositions, null); |
| } else if (parent != null && tree.getKind() == Tree.Kind.BLOCK |
| && (parent.getKind() == Tree.Kind.METHOD || TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()))) { |
| controller.toPhase(withinAnonymousOrLocalClass(tu, path) ? JavaSource.Phase.RESOLVED : JavaSource.Phase.ELEMENTS_RESOLVED); |
| int blockPos = (int) sourcePositions.getStartPosition(root, tree); |
| String blockText = controller.getText().substring(blockPos, upToOffset ? offset : (int) sourcePositions.getEndPosition(root, tree)); |
| final SourcePositions[] sp = new SourcePositions[1]; |
| final StatementTree block = (((BlockTree) tree).isStatic() ? tu.parseStaticBlock(blockText, sp) : tu.parseStatement(blockText, sp)); |
| if (block == null) { |
| return null; |
| } |
| sourcePositions = new SourcePositionsImpl(block, sourcePositions, sp[0], blockPos, upToOffset ? offset : -1); |
| Scope scope = controller.getTrees().getScope(path); |
| path = tu.pathFor(new TreePath(pPath, block), offset, sourcePositions); |
| if (upToOffset) { |
| Tree last = path.getLeaf(); |
| List<? extends StatementTree> stmts = null; |
| switch (path.getLeaf().getKind()) { |
| case BLOCK: |
| stmts = ((BlockTree) path.getLeaf()).getStatements(); |
| break; |
| case FOR_LOOP: |
| stmts = ((ForLoopTree) path.getLeaf()).getInitializer(); |
| break; |
| case ENHANCED_FOR_LOOP: |
| stmts = Collections.singletonList(((EnhancedForLoopTree) path.getLeaf()).getStatement()); |
| break; |
| case METHOD: |
| stmts = ((MethodTree) path.getLeaf()).getParameters(); |
| break; |
| case SWITCH: |
| CaseTree lastCase = null; |
| for (CaseTree caseTree : ((SwitchTree) path.getLeaf()).getCases()) { |
| lastCase = caseTree; |
| } |
| if (lastCase != null) { |
| stmts = lastCase.getStatements(); |
| } |
| break; |
| case CASE: |
| stmts = ((CaseTree) path.getLeaf()).getStatements(); |
| break; |
| case CONDITIONAL_AND: case CONDITIONAL_OR: |
| BinaryTree bt = (BinaryTree) last; |
| if (sourcePositions.getStartPosition(path.getCompilationUnit(), bt.getRightOperand()) == offset && |
| bt.getRightOperand().getKind() == Kind.ERRONEOUS) { |
| last = bt.getRightOperand(); |
| } |
| break; |
| } |
| if (stmts != null) { |
| for (StatementTree st : stmts) { |
| if (sourcePositions.getEndPosition(root, st) <= offset) { |
| last = st; |
| } |
| } |
| } |
| scope = tu.reattributeTreeTo(block, scope, last); |
| } else { |
| tu.reattributeTreeTo(block, scope, block); |
| } |
| return new Env(offset, prefix, controller, path, sourcePositions, scope); |
| } else if (tree.getKind() == Tree.Kind.LAMBDA_EXPRESSION) { |
| controller.toPhase(JavaSource.Phase.RESOLVED); |
| Tree lambdaBody = ((LambdaExpressionTree) tree).getBody(); |
| Scope scope = null; |
| TreePath blockPath = path.getParentPath(); |
| int bodyPos = 0; |
| while (blockPath != null) { |
| if (blockPath.getLeaf().getKind() == Tree.Kind.BLOCK) { |
| if (blockPath.getParentPath().getLeaf().getKind() == Tree.Kind.METHOD |
| || TreeUtilities.CLASS_TREE_KINDS.contains(blockPath.getParentPath().getLeaf().getKind())) { |
| final int blockPos = (int) sourcePositions.getStartPosition(root, blockPath.getLeaf()); |
| final String blockText = upToOffset && getCaretInSnapshot() > offset |
| ? controller.getText().substring(blockPos, offset) + whitespaceString(getCaretInSnapshot() - offset) + controller.getText().substring(getCaretInSnapshot(), (int) sourcePositions.getEndPosition(root, blockPath.getLeaf())) |
| : controller.getText().substring(blockPos, (int) sourcePositions.getEndPosition(root, blockPath.getLeaf())); |
| final SourcePositions[] sp = new SourcePositions[1]; |
| final StatementTree block = (((BlockTree) blockPath.getLeaf()).isStatic() ? tu.parseStaticBlock(blockText, sp) : tu.parseStatement(blockText, sp)); |
| if (block == null) { |
| return null; |
| } |
| sourcePositions = new SourcePositionsImpl(block, sourcePositions, sp[0], blockPos, -1); |
| path = tu.getPathElementOfKind(Tree.Kind.LAMBDA_EXPRESSION, tu.pathFor(new TreePath(blockPath.getParentPath(), block), offset, sourcePositions)); |
| if (path == null) { |
| return null; |
| } |
| lambdaBody = ((LambdaExpressionTree) path.getLeaf()).getBody(); |
| bodyPos = (int) sourcePositions.getStartPosition(root, lambdaBody); |
| if (bodyPos >= offset) { |
| TokenSequence<JavaTokenId> ts = controller.getTokenHierarchy().tokenSequence(JavaTokenId.language()); |
| ts.move(offset); |
| while (ts.movePrevious()) { |
| switch (ts.token().id()) { |
| case WHITESPACE: |
| case LINE_COMMENT: |
| case BLOCK_COMMENT: |
| case JAVADOC_COMMENT: |
| break; |
| case ARROW: |
| scope = controller.getTrees().getScope(blockPath); |
| scope = tu.reattributeTreeTo(block, scope, lambdaBody); |
| return new Env(offset, prefix, controller, path, sourcePositions, scope); |
| default: |
| return null; |
| } |
| } |
| } |
| scope = controller.getTrees().getScope(blockPath); |
| scope = tu.reattributeTreeTo(block, scope, lambdaBody); |
| break; |
| } |
| } |
| blockPath = blockPath.getParentPath(); |
| } |
| if (scope == null) { |
| scope = controller.getTrees().getScope(new TreePath(path, lambdaBody)); |
| bodyPos = (int) sourcePositions.getStartPosition(root, lambdaBody); |
| if (bodyPos >= offset) { |
| TokenSequence<JavaTokenId> ts = controller.getTokenHierarchy().tokenSequence(JavaTokenId.language()); |
| ts.move(offset); |
| while (ts.movePrevious()) { |
| switch (ts.token().id()) { |
| case WHITESPACE: |
| case LINE_COMMENT: |
| case BLOCK_COMMENT: |
| case JAVADOC_COMMENT: |
| break; |
| case ARROW: |
| return new Env(offset, prefix, controller, path, sourcePositions, scope); |
| default: |
| return null; |
| } |
| } |
| } |
| } |
| String bodyText = controller.getText().substring(bodyPos, upToOffset ? offset : (int) sourcePositions.getEndPosition(root, lambdaBody)); |
| final SourcePositions[] sp = new SourcePositions[1]; |
| final Tree body = bodyText.charAt(0) == '{' ? tu.parseStatement(bodyText, sp) : tu.parseExpression(bodyText, sp); |
| final Tree fake = body instanceof ExpressionTree ? new ExpressionStatementTree() { |
| @Override |
| public Object accept(TreeVisitor v, Object p) { |
| return v.visitExpressionStatement(this, p); |
| } |
| |
| @Override |
| public ExpressionTree getExpression() { |
| return (ExpressionTree) body; |
| } |
| |
| @Override |
| public Tree.Kind getKind() { |
| return Tree.Kind.EXPRESSION_STATEMENT; |
| } |
| } : body; |
| sourcePositions = new SourcePositionsImpl(fake, sourcePositions, sp[0], bodyPos, upToOffset ? offset : -1); |
| path = tu.pathFor(new TreePath(path, fake), offset, sourcePositions); |
| if (upToOffset && !(body instanceof ExpressionTree)) { |
| Tree last = path.getLeaf(); |
| List<? extends StatementTree> stmts = null; |
| switch (path.getLeaf().getKind()) { |
| case BLOCK: |
| stmts = ((BlockTree) path.getLeaf()).getStatements(); |
| break; |
| case FOR_LOOP: |
| stmts = ((ForLoopTree) path.getLeaf()).getInitializer(); |
| break; |
| case ENHANCED_FOR_LOOP: |
| stmts = Collections.singletonList(((EnhancedForLoopTree) path.getLeaf()).getStatement()); |
| break; |
| case METHOD: |
| stmts = ((MethodTree) path.getLeaf()).getParameters(); |
| break; |
| case SWITCH: |
| CaseTree lastCase = null; |
| for (CaseTree caseTree : ((SwitchTree) path.getLeaf()).getCases()) { |
| lastCase = caseTree; |
| } |
| if (lastCase != null) { |
| stmts = lastCase.getStatements(); |
| } |
| break; |
| case CASE: |
| stmts = ((CaseTree) path.getLeaf()).getStatements(); |
| break; |
| } |
| if (stmts != null) { |
| for (StatementTree st : stmts) { |
| if (sourcePositions.getEndPosition(root, st) <= offset) { |
| last = st; |
| } |
| } |
| } |
| scope = tu.reattributeTreeTo(body, scope, last); |
| } else { |
| scope = tu.reattributeTreeTo(body, scope, body); |
| } |
| return new Env(offset, prefix, controller, path, sourcePositions, scope); |
| } else if (grandParent != null && TreeUtilities.CLASS_TREE_KINDS.contains(grandParent.getKind()) |
| && parent != null && parent.getKind() == Tree.Kind.VARIABLE && unwrapErrTree(((VariableTree) parent).getInitializer()) == tree) { |
| if (tu.isEnum((ClassTree) grandParent)) { |
| controller.toPhase(JavaSource.Phase.RESOLVED); |
| return null; |
| } |
| controller.toPhase(withinAnonymousOrLocalClass(tu, path) ? JavaSource.Phase.RESOLVED : JavaSource.Phase.ELEMENTS_RESOLVED); |
| Scope scope = controller.getTrees().getScope(path); |
| final int initPos = (int) sourcePositions.getStartPosition(root, tree); |
| String initText = controller.getText().substring(initPos, upToOffset ? offset : (int) sourcePositions.getEndPosition(root, tree)); |
| if (initText.length() > 0) { |
| final SourcePositions[] sp = new SourcePositions[1]; |
| final ExpressionTree init = tu.parseVariableInitializer(initText, sp); |
| final ExpressionStatementTree fake = new ExpressionStatementTree() { |
| @Override |
| public Object accept(TreeVisitor v, Object p) { |
| return v.visitExpressionStatement(this, p); |
| } |
| |
| @Override |
| public ExpressionTree getExpression() { |
| return init; |
| } |
| |
| @Override |
| public Tree.Kind getKind() { |
| return Tree.Kind.EXPRESSION_STATEMENT; |
| } |
| }; |
| sourcePositions = new SourcePositionsImpl(fake, sourcePositions, sp[0], initPos, upToOffset ? offset : -1); |
| path = tu.pathFor(new TreePath(pPath, fake), offset, sourcePositions); |
| if (upToOffset && sp[0].getEndPosition(root, init) + initPos > offset) { |
| scope = tu.reattributeTreeTo(init, scope, path.getLeaf()); |
| } else { |
| tu.reattributeTree(init, scope); |
| } |
| } |
| return new Env(offset, prefix, controller, path, sourcePositions, scope); |
| } else if (parent != null && TreeUtilities.CLASS_TREE_KINDS.contains(parent.getKind()) && tree.getKind() == Tree.Kind.VARIABLE |
| && ((VariableTree) tree).getInitializer() != null && orig == path |
| && sourcePositions.getStartPosition(root, ((VariableTree) tree).getInitializer()) >= 0 |
| && sourcePositions.getStartPosition(root, ((VariableTree) tree).getInitializer()) <= offset) { |
| controller.toPhase(withinAnonymousOrLocalClass(tu, path) ? JavaSource.Phase.RESOLVED : JavaSource.Phase.ELEMENTS_RESOLVED); |
| tree = ((VariableTree) tree).getInitializer(); |
| Scope scope = controller.getTrees().getScope(new TreePath(path, tree)); |
| final int initPos = (int) sourcePositions.getStartPosition(root, tree); |
| String initText = controller.getText().substring(initPos, offset); |
| if (initText.length() > 0) { |
| final SourcePositions[] sp = new SourcePositions[1]; |
| final ExpressionTree init = tu.parseVariableInitializer(initText, sp); |
| final ExpressionStatementTree fake = new ExpressionStatementTree() { |
| @Override |
| public Object accept(TreeVisitor v, Object p) { |
| return v.visitExpressionStatement(this, p); |
| } |
| |
| @Override |
| public ExpressionTree getExpression() { |
| return init; |
| } |
| |
| @Override |
| public Tree.Kind getKind() { |
| return Tree.Kind.EXPRESSION_STATEMENT; |
| } |
| }; |
| sourcePositions = new SourcePositionsImpl(fake, sourcePositions, sp[0], initPos, offset); |
| path = tu.pathFor(new TreePath(path, fake), offset, sourcePositions); |
| tu.reattributeTree(init, scope); |
| } |
| return new Env(offset, prefix, controller, path, sourcePositions, scope); |
| } |
| return null; |
| } |
| |
| private static String whitespaceString(int length) { |
| StringBuilder sb = new StringBuilder(); |
| for (int i = 0; i < length; i++) { |
| sb.append(' '); |
| } |
| return sb.toString(); |
| } |
| |
| private static class SourcePositionsImpl extends ErrorAwareTreeScanner<Void, Tree> implements SourcePositions { |
| |
| private final Tree root; |
| private final SourcePositions original; |
| private final SourcePositions modified; |
| private final int startOffset; |
| private final int endOffset; |
| |
| private boolean found; |
| |
| private SourcePositionsImpl(Tree root, SourcePositions original, SourcePositions modified, int startOffset, int endOffset) { |
| this.root = root; |
| this.original = original; |
| this.modified = modified; |
| this.startOffset = startOffset; |
| this.endOffset = endOffset; |
| } |
| |
| @Override |
| public long getStartPosition(CompilationUnitTree compilationUnitTree, Tree tree) { |
| if (tree == root) { |
| return startOffset; |
| } |
| found = false; |
| scan(root, tree); |
| return found ? modified.getStartPosition(compilationUnitTree, tree) + startOffset : original.getStartPosition(compilationUnitTree, tree); |
| } |
| |
| @Override |
| public long getEndPosition(CompilationUnitTree compilationUnitTree, Tree tree) { |
| if (tree == root) { |
| return endOffset; |
| } |
| found = false; |
| scan(root, tree); |
| return found ? modified.getEndPosition(compilationUnitTree, tree) + startOffset : original.getEndPosition(compilationUnitTree, tree); |
| } |
| |
| @Override |
| public Void scan(Tree node, Tree p) { |
| if (node == p) { |
| found = true; |
| } else { |
| super.scan(node, p); |
| } |
| return null; |
| } |
| |
| } |
| |
| private static boolean isCamelCasePrefix(String prefix) { |
| if (prefix == null || prefix.length() < 2 || prefix.charAt(0) == '"') { |
| return false; |
| } |
| for (int i = 1; i < prefix.length(); i++) { |
| if (Character.isUpperCase(prefix.charAt(i))) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private static boolean withinAnonymousOrLocalClass(TreeUtilities tu, TreePath path) { |
| do { |
| path = tu.getPathElementOfKind(TreeUtilities.CLASS_TREE_KINDS, path); |
| if (path == null) { |
| return false; |
| } |
| path = path.getParentPath(); |
| if (path.getLeaf().getKind() != Tree.Kind.COMPILATION_UNIT && !TreeUtilities.CLASS_TREE_KINDS.contains(path.getLeaf().getKind())) { |
| return true; |
| } |
| } while (true); |
| } |
| |
| static final class Env { |
| |
| private final int offset; |
| private final String prefix; |
| private final boolean isCamelCasePrefix; |
| private final CompilationController controller; |
| private final TreePath path; |
| private final SourcePositions sourcePositions; |
| private Scope scope; |
| private ReferencesCount referencesCount; |
| private Map<Name, Element> refs = null; |
| private boolean afterExtends = false; |
| private boolean insideNew = false; |
| private boolean insideForEachExpression = false; |
| private boolean insideClass = false; |
| private Set<? extends TypeMirror> smartTypes = null; |
| private Set<Element> excludes = null; |
| private Set<String> kws = new HashSet<>(); |
| private boolean addSemicolon = false; |
| private boolean checkAddSemicolon = true; |
| private int assignToVarPos = -2; |
| private boolean checkAccessibility = true; |
| |
| private Env(int offset, String prefix, CompilationController controller, TreePath path, SourcePositions sourcePositions, Scope scope) { |
| this.offset = offset; |
| this.prefix = prefix; |
| this.isCamelCasePrefix = BaseTask.isCamelCasePrefix(prefix); |
| this.controller = controller; |
| this.path = path; |
| this.sourcePositions = sourcePositions; |
| this.scope = scope; |
| } |
| |
| public int getOffset() { |
| return offset; |
| } |
| |
| public String getPrefix() { |
| return prefix; |
| } |
| |
| public boolean isCamelCasePrefix() { |
| return isCamelCasePrefix; |
| } |
| |
| public CompilationController getController() { |
| return controller; |
| } |
| |
| public CompilationUnitTree getRoot() { |
| return path.getCompilationUnit(); |
| } |
| |
| public TreePath getPath() { |
| return path; |
| } |
| |
| public SourcePositions getSourcePositions() { |
| return sourcePositions; |
| } |
| |
| public Scope getScope() throws IOException { |
| if (scope == null) { |
| controller.toPhase(JavaSource.Phase.ELEMENTS_RESOLVED); |
| scope = controller.getTreeUtilities().scopeFor(offset); |
| } |
| return scope; |
| } |
| |
| public ReferencesCount getReferencesCount() { |
| if (referencesCount == null) { |
| referencesCount = ReferencesCount.get(controller.getClasspathInfo()); |
| } |
| return referencesCount; |
| } |
| |
| public Map<Name, ? extends Element> getForwardReferences() { |
| if (refs == null) { |
| refs = new HashMap<>(); |
| for (Element ref : SourceUtils.getForwardReferences(path, offset, sourcePositions, controller.getTrees())) { |
| refs.put(ref.getSimpleName(), ref); |
| } |
| } |
| return refs; |
| } |
| |
| public boolean isAfterExtends() { |
| return afterExtends; |
| } |
| |
| public void afterExtends() { |
| this.afterExtends = true; |
| } |
| |
| public void insideForEachExpression() { |
| this.insideForEachExpression = true; |
| } |
| |
| public boolean isInsideForEachExpression() { |
| return insideForEachExpression; |
| } |
| |
| public void insideNew() { |
| this.insideNew = true; |
| } |
| |
| public boolean isInsideNew() { |
| return insideNew; |
| } |
| |
| public void insideClass() { |
| this.insideClass = true; |
| } |
| |
| public boolean isInsideClass() { |
| return insideClass; |
| } |
| |
| public void setSmartTypes(Set<? extends TypeMirror> smartTypes) throws IOException { |
| this.smartTypes = smartTypes; |
| } |
| |
| public Set<? extends TypeMirror> getSmartTypes() throws IOException { |
| return smartTypes; |
| } |
| |
| public void addToExcludes(Element toExclude) { |
| if (toExclude != null) { |
| if (excludes == null) { |
| excludes = new HashSet<>(); |
| } |
| excludes.add(toExclude); |
| } |
| } |
| |
| public Set<? extends Element> getExcludes() { |
| return excludes; |
| } |
| |
| public void addExcludedKW(String kw) { |
| if (kw != null) { |
| kws.add(kw); |
| } |
| } |
| |
| public boolean isExcludedKW(String kw) { |
| return kws.contains(kw); |
| } |
| |
| public void skipAccessibilityCheck() { |
| this.checkAccessibility = false; |
| } |
| |
| public boolean isAccessible(Scope scope, Element member, TypeMirror type, boolean selectSuper) { |
| if (!checkAccessibility) { |
| return true; |
| } |
| if (type.getKind() != TypeKind.DECLARED) { |
| return member.getModifiers().contains(PUBLIC); |
| } |
| if (getController().getTrees().isAccessible(scope, member, (DeclaredType) type)) { |
| return true; |
| } |
| return selectSuper |
| && member.getModifiers().contains(PROTECTED) && !member.getModifiers().contains(STATIC) |
| && !member.getKind().isClass() && !member.getKind().isInterface() |
| && getController().getTrees().isAccessible(scope, (TypeElement) ((DeclaredType) type).asElement()) |
| && (member.getKind() != METHOD |
| || getController().getElementUtilities().getImplementationOf((ExecutableElement) member, (TypeElement) ((DeclaredType) type).asElement()) == member); |
| } |
| |
| public boolean addSemicolon() { |
| if (checkAddSemicolon) { |
| TreePath tp = getPath(); |
| Tree tree = tp.getLeaf(); |
| if (tree.getKind() == Tree.Kind.IDENTIFIER || tree.getKind() == Tree.Kind.PRIMITIVE_TYPE) { |
| tp = tp.getParentPath(); |
| if (tp.getLeaf().getKind() == Tree.Kind.VARIABLE && ((VariableTree) tp.getLeaf()).getType() == tree) { |
| addSemicolon = true; |
| } |
| } |
| if (tp.getLeaf().getKind() == Tree.Kind.MEMBER_SELECT |
| || (tp.getLeaf().getKind() == Tree.Kind.METHOD_INVOCATION && ((MethodInvocationTree) tp.getLeaf()).getMethodSelect() == tree) |
| || tp.getLeaf().getKind() == Tree.Kind.VARIABLE) { |
| tp = tp.getParentPath(); |
| } |
| if (tp.getLeaf().getKind() == Tree.Kind.EXPRESSION_STATEMENT |
| && tp.getParentPath().getLeaf().getKind() != Tree.Kind.LAMBDA_EXPRESSION |
| || tp.getLeaf().getKind() == Tree.Kind.BLOCK |
| || tp.getLeaf().getKind() == Tree.Kind.RETURN) { |
| addSemicolon = true; |
| } |
| checkAddSemicolon = false; |
| } |
| return addSemicolon; |
| } |
| |
| 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; |
| } |
| } |
| } |
