com.sun.source.tree.ArrayTypeTree#com.sun.source.tree.IdentifierTree源码实例Demo

/**
 * Helper method for import declarations, names, and qualified names.
 */
private void visitName(Tree node) {
    Deque<Name> stack = new ArrayDeque<>();
    for (; node instanceof MemberSelectTree; node = ((MemberSelectTree) node).getExpression()) {
        stack.addFirst(((MemberSelectTree) node).getIdentifier());
    }
    stack.addFirst(((IdentifierTree) node).getName());
    boolean first = true;
    for (Name name : stack) {
        if (!first) {
            token(".");
        }
        token(name.toString());
        first = false;
    }
}
 

private void dotExpressionUpToArgs(ExpressionTree expression, Optional<BreakTag> tyargTag) {
    expression = getArrayBase(expression);
    switch (expression.getKind()) {
        case MEMBER_SELECT:
            MemberSelectTree fieldAccess = (MemberSelectTree) expression;
            visit(fieldAccess.getIdentifier());
            break;
        case METHOD_INVOCATION:
            MethodInvocationTree methodInvocation = (MethodInvocationTree) expression;
            if (!methodInvocation.getTypeArguments().isEmpty()) {
                builder.open(plusFour);
                addTypeArguments(methodInvocation.getTypeArguments(), ZERO);
                // TODO(jdd): Should indent the name -4.
                builder.breakOp(Doc.FillMode.UNIFIED, "", ZERO, tyargTag);
                builder.close();
            }
            visit(getMethodName(methodInvocation));
            break;
        case IDENTIFIER:
            visit(((IdentifierTree) expression).getName());
            break;
        default:
            scan(expression, null);
            break;
    }
}
 

private void dotExpressionUpToArgs(ExpressionTree expression, Optional<BreakTag> tyargTag) {
    expression = getArrayBase(expression);
    switch (expression.getKind()) {
        case MEMBER_SELECT:
            MemberSelectTree fieldAccess = (MemberSelectTree) expression;
            visit(fieldAccess.getIdentifier());
            break;
        case METHOD_INVOCATION:
            MethodInvocationTree methodInvocation = (MethodInvocationTree) expression;
            if (!methodInvocation.getTypeArguments().isEmpty()) {
                builder.open(plusFour);
                addTypeArguments(methodInvocation.getTypeArguments(), ZERO);
                // TODO(jdd): Should indent the name -4.
                builder.breakOp(Doc.FillMode.UNIFIED, "", ZERO, tyargTag);
                builder.close();
            }
            visit(getMethodName(methodInvocation));
            break;
        case IDENTIFIER:
            visit(((IdentifierTree) expression).getName());
            break;
        default:
            scan(expression, null);
            break;
    }
}
 

@Override
protected boolean perform() {
    TreePath replacePath = replacePathHandle.resolve(copy);

    if (replacePath == null) {
        Logger.getAnonymousLogger().warning(String.format("Attempt to change import for FQN: %s, but the import cannot be resolved in the current context", fqn));
        return false;
    }
    Element el = toImport.resolve(copy);
    if (el == null) {
        return false;
    }
    CharSequence elFQN = copy.getElementUtilities().getElementName(el, true);
    IdentifierTree id = copy.getTreeMaker().Identifier(elFQN);
    copy.rewrite(replacePath.getLeaf(), id);
    
    for (TreePathHandle tph : additionalLocations) {
        replacePath = tph.resolve(copy);
        if (replacePath == null) {
            continue;
        }
        copy.rewrite(replacePath.getLeaf(), id);
    }
    return false;
}
 

@Override
public TypeMirror getTypeMirror(TreePath arg0) {
    Tree tree = arg0.getLeaf();
    if (tree.getKind() == Tree.Kind.IDENTIFIER) {
        Map<String, ObjectVariable> map = null;
        try {
            // [TODO] add JPDADebuggerImpl.getAllLabels() to API
            Method method = debugger.getClass().getMethod("getAllLabels"); // NOI18N
            map = (Map<String, ObjectVariable>) method.invoke(debugger);
        } catch (Exception ex) {
            Exceptions.printStackTrace(ex);
        }
        if (map != null) {
            String name = ((IdentifierTree)tree).getName().toString();
            ObjectVariable var = map.get(name);
            if (var != null) {
                Elements elements = controller.getElements();
                TypeElement typeElem = elements.getTypeElement(var.getClassType().getName());
                if (typeElem != null) {
                    return typeElem.asType();
                }
            }
        }
    }
    return trees.getTypeMirror(arg0);
}
 

@Override
public Void visitMethodInvocation(MethodInvocationTree node, Void p) {
    if (!node.getArguments().isEmpty()) {
        return null;
    }
    final ExpressionTree et = node.getMethodSelect();
    if (et.getKind() != Tree.Kind.MEMBER_SELECT) {
        return null;
    }
    final MemberSelectTree mst = (MemberSelectTree) et;
    if (!FINALIZE.contentEquals(mst.getIdentifier())) {
        return null;
    }
    if (mst.getExpression().getKind() != Tree.Kind.IDENTIFIER) {
        return null;
    }
    if (!SUPER.contentEquals(((IdentifierTree)mst.getExpression()).getName())) {
        return null;
    }
    found = true;
    return null;
}
 

public Boolean visitIdentifier(IdentifierTree node, TreePath p) {
    if (p == null)
        return super.visitIdentifier(node, p);

    switch (verifyElements(getCurrentPath(), p)) {
        case MATCH_CHECK_DEEPER:
            if (node.getKind() == p.getLeaf().getKind()) {
                return true;
            }

            return deepVerifyIdentifier2MemberSelect(getCurrentPath(), p);
        case MATCH:
            return true;
        default:
        case NO_MATCH:
        case NO_MATCH_CONTINUE:
            return false;
    }
}
 

static boolean checkConstantExpression(final CompilationInfo info, TreePath path) {
    InstanceRefFinder finder = new InstanceRefFinder(info, path) {
        @Override
        public Object visitIdentifier(IdentifierTree node, Object p) {
            Element el = info.getTrees().getElement(getCurrentPath());
            if (el == null || el.asType() == null || el.asType().getKind() == TypeKind.ERROR) {
                return null;
            }
            if (el.getKind() == ElementKind.LOCAL_VARIABLE || el.getKind() == ElementKind.PARAMETER) {
                throw new StopProcessing();
            } else if (el.getKind() == ElementKind.FIELD) {
                if (!el.getModifiers().contains(Modifier.FINAL)) {
                    throw new StopProcessing();
                }
            }
            return super.visitIdentifier(node, p);
        }
    };
    try {
        finder.process();
        return  !(finder.containsInstanceReferences() || finder.containsLocalReferences() || finder.containsReferencesToSuper());
    } catch (StopProcessing e) {
        return false;
    }
}
 

private void addSyntheticTrees(DiffContext diffContext, Tree node) {
    if (node == null) return ;
    
    if (((JCTree) node).pos == (-1)) {
        diffContext.syntheticTrees.add(node);
        return ;
    }
    
    if (node.getKind() == Kind.EXPRESSION_STATEMENT) {
        ExpressionTree est = ((ExpressionStatementTree) node).getExpression();

        if (est.getKind() == Kind.METHOD_INVOCATION) {
            ExpressionTree select = ((MethodInvocationTree) est).getMethodSelect();

            if (select.getKind() == Kind.IDENTIFIER && ((IdentifierTree) select).getName().contentEquals("super")) {
                if (getTreeUtilities().isSynthetic(diffContext.origUnit, node)) {
                    diffContext.syntheticTrees.add(node);
                }
            }
        }
    }
}
 

public void testForEachLoop() throws Exception {
    prepareTest("Test", "package test; public class Test { public Test(java.util.List<String> ll) { for (String s : ll.subList(0, ll.size())  ) { } } }");

    TreePath tp1 = info.getTreeUtilities().pathFor(122 - 30);
    assertEquals(Kind.IDENTIFIER, tp1.getLeaf().getKind());
    assertEquals("ll", ((IdentifierTree) tp1.getLeaf()).getName().toString());

    TreePath tp2 = info.getTreeUtilities().pathFor(127 - 30);
    assertEquals(Kind.MEMBER_SELECT, tp2.getLeaf().getKind());
    assertEquals("subList", ((MemberSelectTree) tp2.getLeaf()).getIdentifier().toString());

    TreePath tp3 = info.getTreeUtilities().pathFor(140 - 30);
    assertEquals(Kind.MEMBER_SELECT, tp3.getLeaf().getKind());
    assertEquals("size", ((MemberSelectTree) tp3.getLeaf()).getIdentifier().toString());

    TreePath tp4 = info.getTreeUtilities().pathFor(146 - 30);
    assertEquals(Kind.METHOD_INVOCATION, tp4.getLeaf().getKind());
    assertEquals("subList", ((MemberSelectTree) ((MethodInvocationTree) tp4.getLeaf()).getMethodSelect()).getIdentifier().toString());
}
 

@Override
public Void visitIdentifier(IdentifierTree tree, Void p) {
    if (info.getTreeUtilities().isSynthetic(getCurrentPath()))
        return null;

    tl.moveToOffset(sourcePositions.getStartPosition(info.getCompilationUnit(), tree));
    
    if (memberSelectBypass != (-1)) {
        tl.moveToOffset(memberSelectBypass);
        memberSelectBypass = -1;
    }
    
    tl.identifierHere(tree, tree2Tokens);
    
    handlePossibleIdentifier(getCurrentPath(), false);
    addParameterInlineHint(tree);
    super.visitIdentifier(tree, null);
    return null;
}
 

private static Token<JavaTokenId> findTokenWithText(CompilationInfo info, String text, int start, int end) {
    TokenHierarchy<?> th = info.getTokenHierarchy();
    TokenSequence<JavaTokenId> ts = th.tokenSequence(JavaTokenId.language()).subSequence(start, end);
    
    while (ts.moveNext()) {
        Token<JavaTokenId> t = ts.token();
        
        if (t.id() == JavaTokenId.IDENTIFIER) {
            boolean nameMatches;
            
            if (!(nameMatches = text.equals(info.getTreeUtilities().decodeIdentifier(t.text()).toString()))) {
                ExpressionTree expr = info.getTreeUtilities().parseExpression(t.text().toString(), new SourcePositions[1]);
                
                nameMatches = expr.getKind() == Kind.IDENTIFIER && text.contentEquals(((IdentifierTree) expr).getName());
            }
            
            if (nameMatches) {
                return t;
            }
        }
    }
    
    return null;
}
 

@Override
public Description matchMemberSelect(MemberSelectTree tree, VisitorState state) {
  if (!matchWithinClass) {
    return Description.NO_MATCH;
  }
  Symbol symbol = ASTHelpers.getSymbol(tree);
  // some checks for cases where we know it is not
  // a null dereference
  if (symbol == null || symbol.getSimpleName().toString().equals("class") || symbol.isEnum()) {
    return Description.NO_MATCH;
  }

  Description badDeref = matchDereference(tree.getExpression(), tree, state);
  if (!badDeref.equals(Description.NO_MATCH)) {
    return badDeref;
  }
  // if we're accessing a field of this, make sure we're not reading the field before init
  if (tree.getExpression() instanceof IdentifierTree
      && ((IdentifierTree) tree.getExpression()).getName().toString().equals("this")) {
    return checkForReadBeforeInit(tree, state);
  }
  return Description.NO_MATCH;
}
 

private void checkIfRefactorableMutation(TreePath currentTreePath, IdentifierTree that) {
    Tree parent = currentTreePath.getParentPath().getLeaf();
    TreePath parentOfParentPath = currentTreePath.getParentPath().getParentPath();
    Tree parentOfParent = parentOfParentPath.getLeaf();

    if ((isStatementPreOrPostfix(parent, parentOfParent) || isLeftHandSideOfCompoundAssignement(parent, that))
            && isPureMutator(parentOfParentPath)) {
        if (this.hasOneNEFReducer) {
            this.hasNonEffectivelyFinalVars = true;
        } else {
            this.hasOneNEFReducer = true;
            this.reducerStatement = currentTreePath.getParentPath().getParentPath().getLeaf();
            this.mutatedVariable = that;
        }
    } else {
        this.hasNonEffectivelyFinalVars = true;
    }
}
 

private void beautifyAssignement(Tree currentTree, Set<Name> needed) {
    AssignmentTree assigned = (AssignmentTree) ((ExpressionStatementTree) currentTree).getExpression();
    ExpressionTree variable = assigned.getVariable();
    if (variable.getKind() == Tree.Kind.IDENTIFIER) {
        IdentifierTree id = (IdentifierTree) variable;

        if (needed.contains(id.getName())) {
            this.correspondingTree = treeMaker.ExpressionStatement(assigned.getExpression());
        } else {

            this.correspondingTree = this.addReturn(castToStatementTree(currentTree), getOneFromSet(needed));
        }
    } else {
        this.correspondingTree = this.addReturn(castToStatementTree(currentTree), getOneFromSet(needed));
    }
}
 

private static boolean isSuperCtorInvocation(Tree t) {
    if (t.getKind() == Tree.Kind.EXPRESSION_STATEMENT) {
        t = ((ExpressionStatementTree)t).getExpression();
    }
    if (t.getKind() != Tree.Kind.METHOD_INVOCATION) {
        return false;
    }
    MethodInvocationTree mit = (MethodInvocationTree)t;
    if (mit.getMethodSelect() == null || 
        mit.getMethodSelect().getKind() != Tree.Kind.IDENTIFIER) {
        return false;
    }
    return ((IdentifierTree)mit.getMethodSelect()).getName().contentEquals("super");
}
 

private static List<StatementTree> createToStringMethodBodyWithStringBuilder(TreeMaker make, String typeName, Iterable<? extends VariableElement> fields) {
    List<StatementTree> statements = new ArrayList<>();
    final ExpressionTree stringBuilder = make.QualIdent(StringBuilder.class.getName());
    NewClassTree newStringBuilder = make.NewClass(null, Collections.emptyList(), stringBuilder, Collections.emptyList(), null);
    VariableTree variable = make.Variable(make.Modifiers(Collections.emptySet()), "sb", stringBuilder, newStringBuilder); // NOI18N
    statements.add(variable); // StringBuilder sb = new StringBuilder();

    IdentifierTree varName = make.Identifier(variable.getName());
    boolean first = true;
    for (VariableElement variableElement : fields) {
        StringBuilder sb = new StringBuilder();
        if (first) {
            sb.append(typeName).append('{');
        } else {
            sb.append(", "); // NOI18N
        }
        sb.append(variableElement.getSimpleName().toString()).append('=');
        // sb.append("typeName{fieldName=").append(fieldName); or sb.append(", fieldName=").append(fieldName);
        statements.add(make.ExpressionStatement(createAppendInvocation(
                make,
                createAppendInvocation(
                        make,
                        varName,
                        Collections.singletonList(make.Literal(sb.toString()))),
                Collections.singletonList(make.Identifier(variableElement.getSimpleName())))
        ));
        first = false;
    }
    statements.add(make.ExpressionStatement(createAppendInvocation( // sb.append('}');
            make,
            varName,
            Collections.singletonList(make.Literal('}'))
    )));
    statements.add(make.Return(make.MethodInvocation( // return sb.toString();
            Collections.emptyList(),
            make.MemberSelect(varName, "toString"), // NOI18N
            Collections.emptyList()
    )));
    return statements;
}
 

private static void addPropertyParametersIfNeeded(VariableTree node, Type type, String propName) {
    if (node.getType().getKind() == Tree.Kind.PARAMETERIZED_TYPE) {
        ParameterizedTypeTree pTree = (ParameterizedTypeTree) node.getType();

        List<String> parameterTypeNames = pTree.getTypeArguments().stream()
                .filter(argTree -> argTree.getKind() == Tree.Kind.IDENTIFIER)
                .map(argTree -> ((IdentifierTree) argTree).getName().toString())
                .collect(Collectors.toList());
        type.propertyParameter(propName, parameterTypeNames);
    }
}
 

@Override
public Object visitIdentifier(IdentifierTree node, Object p) {
    if (changedNames.contains(node.getName())) {
        Element e = info.getTrees().getElement(getCurrentPath());
        CharSequence nn = renamedVars.get(e);
        if (nn != null) {
            info.rewrite(node, info.getTreeMaker().Identifier(nn));
        }
    }
    return super.visitIdentifier(node, p);
}
 

private boolean fillFirstArgument(
        ExpressionTree e,
        List<ExpressionTree> items,
        Indent indent) {
    // is there a trailing dereference?
    if (items.size() < 2) {
        return false;
    }
    // don't special-case calls nested inside expressions
    if (e.getKind() != METHOD_INVOCATION) {
        return false;
    }
    MethodInvocationTree methodInvocation = (MethodInvocationTree) e;
    Name name = getMethodName(methodInvocation);
    if (!(methodInvocation.getMethodSelect() instanceof IdentifierTree)
            || name.length() > 4
            || !methodInvocation.getTypeArguments().isEmpty()
            || methodInvocation.getArguments().size() != 1) {
        return false;
    }
    builder.open(ZERO);
    builder.open(indent);
    visit(name);
    token("(");
    ExpressionTree arg = getOnlyElement(methodInvocation.getArguments());
    scan(arg, null);
    builder.close();
    token(")");
    builder.close();
    return true;
}
 

/**
 */
private List<IdentifierTree> createIdentifiers(
                                        TreeMaker maker,
                                        List<VariableTree> variables) {
    List<IdentifierTree> identifiers;
    if (variables.isEmpty()) {
        identifiers = Collections.<IdentifierTree>emptyList();
    } else {
        identifiers = new ArrayList<IdentifierTree>(variables.size());
        for (VariableTree var : variables) {
            identifiers.add(maker.Identifier(var.getName().toString()));
        }
    }
    return identifiers;
}
 

private static String methodName(MethodInvocationTree mit) {
    ExpressionTree select = mit.getMethodSelect();

    switch (select.getKind()) {
        case IDENTIFIER: return ((IdentifierTree) select).getName().toString();
        case MEMBER_SELECT: return ((MemberSelectTree) select).getIdentifier().toString();
        default: throw new UnsupportedOperationException(select.getKind().toString());
    }
}
 

@Override
public Tree visitIdentifier(IdentifierTree tree, Void p) {
    IdentifierTree n = make.Identifier(tree.getName());
    model.setElement(n, model.getElement(tree));
    model.setType(n, model.getType(tree));
    comments.copyComments(tree, n);
    model.setPos(n, model.getPos(tree));
    return n;
}
 

@Override
public Boolean visitAnnotation(AnnotationTree node, TreePath p) {
    if (p == null)
        return super.visitAnnotation(node, p);

    AnnotationTree t = (AnnotationTree) p.getLeaf();
    
    List<? extends ExpressionTree> arguments = t.getArguments();
    
    if (arguments.size() == 1) {
        ExpressionTree arg = arguments.get(0);
        
        if (arg.getKind() == Kind.ASSIGNMENT) {
            AssignmentTree at = (AssignmentTree) arg;
            
            if (   at.getVariable().getKind() == Kind.IDENTIFIER
                && isMultistatementWildcardTree(at.getExpression())
                && ((IdentifierTree) at.getVariable()).getName().contentEquals("value")) {
                arguments = Collections.singletonList(at.getExpression());
            }
        }
    }
    
    if (!checkLists(node.getArguments(), arguments, p))
        return false;

    return scan(node.getAnnotationType(), t.getAnnotationType(), p);
}
 

public static boolean isPureMemberSelect(Tree mst, boolean allowVariables) {
    switch (mst.getKind()) {
        case IDENTIFIER: return allowVariables || ((IdentifierTree) mst).getName().charAt(0) != '$';
        case MEMBER_SELECT: return isPureMemberSelect(((MemberSelectTree) mst).getExpression(), allowVariables);
        default: return false;
    }
}
 

@Override
public Object visitIdentifier(IdentifierTree node, Object p) {
    String nn = node.getName().toString();
    if (nn.equals("this")) {
        return true;
    }
    handleIdentifier(node, node.getName());
    return null;
}
 

private static String name(Tree tree) {
    switch (tree.getKind()) {
        case VARIABLE:
            return ((VariableTree)tree).getName().toString();
        case METHOD:
            return ((MethodTree)tree).getName().toString();
        case CLASS:
            return ((ClassTree)tree).getSimpleName().toString();
        case IDENTIFIER:
            return ((IdentifierTree)tree).getName().toString();
        case MEMBER_SELECT:
            return name(((MemberSelectTree)tree).getExpression()) + '.' + ((MemberSelectTree)tree).getIdentifier();
    }
    return ""; //NOI18N
}
 

protected void doModification(ResultIterator resultIterator) throws Exception {
    final CodeStyle codeStyle = codeStyleProducer.create(previewPrefs);
    WorkingCopy copy = WorkingCopy.get(resultIterator.getParserResult());
    copy.toPhase(Phase.RESOLVED);
    TreeMaker tm = copy.getTreeMaker();
    GeneratorUtilities gu = GeneratorUtilities.get(copy);
    CompilationUnitTree cut = copy.getCompilationUnit();
    ClassTree ct = (ClassTree) cut.getTypeDecls().get(0);
    List<Tree> members = new ArrayList<Tree>();
    String name = CodeStyleUtils.addPrefixSuffix("name",
            codeStyle.getFieldNamePrefix(),
            codeStyle.getFieldNameSuffix());
    VariableTree field = tm.Variable(tm.Modifiers(Collections.singleton(Modifier.PRIVATE)), name, tm.Type("String"), null);
    members.add(field);
    String cond = CodeStyleUtils.addPrefixSuffix("cond",
            codeStyle.getFieldNamePrefix(),
            codeStyle.getFieldNameSuffix());
    VariableTree booleanField = tm.Variable(tm.Modifiers(Collections.singleton(Modifier.PRIVATE)), cond, tm.PrimitiveType(TypeKind.BOOLEAN), null);
    members.add(booleanField);
    members.add(gu.createConstructor(ct, Collections.singletonList(field)));
    members.add(gu.createGetter(field));
    members.add(gu.createSetter(ct, field));
    members.add(gu.createGetter(booleanField));
    members.add(gu.createSetter(ct, booleanField));
    ModifiersTree mods = tm.Modifiers(EnumSet.of(Modifier.PRIVATE, Modifier.STATIC));
    ClassTree nested = tm.Class(mods, "Nested", Collections.<TypeParameterTree>emptyList(), null, Collections.<Tree>emptyList(), Collections.<Tree>emptyList()); //NOI18N
    members.add(nested);
    IdentifierTree nestedId = tm.Identifier("Nested"); //NOI18N
    String instance = CodeStyleUtils.addPrefixSuffix("instance",
            codeStyle.getStaticFieldNamePrefix(),
            codeStyle.getStaticFieldNameSuffix());
    VariableTree staticField = tm.Variable(mods, instance, nestedId, null); //NOI18N
    members.add(staticField);
    members.add(gu.createGetter(staticField));
    members.add(gu.createSetter(ct, staticField));
    ClassTree newCT = gu.insertClassMembers(ct, members);
    copy.rewrite(ct, newCT);
}
 

@Override
public Object visitIdentifier(IdentifierTree node, Object p) {
    Element el = ci.getTrees().getElement(getCurrentPath());
    if (el != null && el.getKind() == ElementKind.PARAMETER) {
        unusedVars.remove(el);
        if (unusedVars.isEmpty()) {
            throw new StopProcessing();
        }
    }
    return super.visitIdentifier(node, p);
}
 

private static VariableTree createLoggerField(TreeMaker make, ClassTree cls, CharSequence name, Set<Modifier> mods) {
    ModifiersTree modifiers = make.Modifiers(mods, Collections.<AnnotationTree>emptyList());
    final List<ExpressionTree> none = Collections.<ExpressionTree>emptyList();
    IdentifierTree className = make.Identifier(cls.getSimpleName());
    MemberSelectTree classType = make.MemberSelect(className, "class"); // NOI18N
    MemberSelectTree getName  = make.MemberSelect(classType, "getName"); // NOI18N
    MethodInvocationTree initClass = make.MethodInvocation(none, getName, none);
    final ExpressionTree logger = make.QualIdent(Logger.class.getName());
    MemberSelectTree getLogger = make.MemberSelect(logger, "getLogger"); // NOI18N
    MethodInvocationTree initField = make.MethodInvocation(none, getLogger, Collections.nCopies(1, initClass));
    return make.Variable(modifiers, name, logger, initField); // NOI18N
}