Java Tree.getKind方法代码示例

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
@Override
public Void visitImport(ImportTree node, Void p) {
    if (node.isStatic() && toFind.getModifiers().contains(Modifier.STATIC)) {
        Tree qualIdent = node.getQualifiedIdentifier();
        if (qualIdent.getKind() == Kind.MEMBER_SELECT) {
            MemberSelectTree mst = (MemberSelectTree) qualIdent;
            if (toFind.getSimpleName().contentEquals(mst.getIdentifier())) {
                Element el = info.getTrees().getElement(new TreePath(getCurrentPath(), mst.getExpression()));
                if (el != null && el.equals(toFind.getEnclosingElement())) {
                    try {
                        int[] span = treeUtils.findNameSpan(mst);
                        if(span != null) {
                            MutablePositionRegion region = createRegion(doc, span[0], span[1]);
                            usages.add(region);
                        }
                    } catch (BadLocationException ex) {
                        Exceptions.printStackTrace(ex);
                    }
                }
            }
        }
    }
    return super.visitImport(node, p);
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
static boolean isValid(CompilationInfo javac, TreePath path, Severity severity, Access access, int caret) {
    Tree leaf = path.getLeaf();
    boolean onLine = severity == Severity.HINT && caret > -1;
    switch (leaf.getKind()) {
        case ANNOTATION_TYPE:
        case CLASS:
        case ENUM:
        case INTERFACE:
            return access.isAccessible(javac, path, false) && (!onLine || isInHeader(javac, (ClassTree) leaf, caret));
        case METHOD:
            return access.isAccessible(javac, path, false) && (!onLine || isInHeader(javac, (MethodTree) leaf, caret));
        case VARIABLE:
            return access.isAccessible(javac, path, false);
    }
    return false;
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
public static Set<? extends String> findSuppressedWarnings(CompilationInfo info, TreePath path) {
    //TODO: cache?
    Set<String> keys = new HashSet<String>();

    while (path != null) {
        Tree leaf = path.getLeaf();

        switch (leaf.getKind()) {
            case METHOD:
                handleSuppressWarnings(info, path, ((MethodTree) leaf).getModifiers(), keys);
                break;
            case CLASS:
                handleSuppressWarnings(info, path, ((ClassTree) leaf).getModifiers(), keys);
                break;
            case VARIABLE:
                handleSuppressWarnings(info, path, ((VariableTree) leaf).getModifiers(), keys);
                break;
        }

        path = path.getParentPath();
    }

    return Collections.unmodifiableSet(keys);
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
private static boolean invocationOnThis(MethodInvocationTree mit) {
    Tree select = mit.getMethodSelect();
    
    switch (select.getKind()) {
        case IDENTIFIER:
            return true;
        case MEMBER_SELECT:
            if (((MemberSelectTree) select).getExpression().getKind() == Kind.IDENTIFIER) {
                IdentifierTree ident = (IdentifierTree) ((MemberSelectTree) select).getExpression();

                return ident.getName().contentEquals("this");
            }
    }

    return false;
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
static TreePath findMethod(TreePath path, boolean methodOnly) {
    while (path != null) {
        Tree leaf = path.getLeaf();
        switch (leaf.getKind()) {
            case BLOCK:
                if (path.getParentPath() != null && TreeUtilities.CLASS_TREE_KINDS.contains(path.getParentPath().getLeaf().getKind())) {
                    return path;
                }
                break;
            case LAMBDA_EXPRESSION:
                if (methodOnly) {
                    break;
                }
            case METHOD:
                return path;
            default:
                break;
        }
        path = path.getParentPath();
    }
    return null;
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
public Completeness disambiguateDeclarationVsExpression() {
    // String folding messes up position information.
    ParseTask pt = parseFactory.get();
    List<? extends Tree> units = pt.units();
    if (units.isEmpty()) {
        return error();
    }
    Tree unitTree = units.get(0);
    switch (unitTree.getKind()) {
        case EXPRESSION_STATEMENT:
            return parseExpressionOptionalSemi();
        case LABELED_STATEMENT:
            if (shouldAbort(IDENTIFIER))  return checkResult;
            if (shouldAbort(COLON))  return checkResult;
        return parseStatement();
        case VARIABLE:
        case IMPORT:
        case CLASS:
        case ENUM:
        case ANNOTATION_TYPE:
        case INTERFACE:
        case METHOD:
            return parseDeclaration();
        default:
            return error();
    }
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
MethodTree method(MethodSnippet msn) {
    if (targetClass == null) {
        return null;
    }
    OuterWrap ow = msn.outerWrap();
    if (!(ow instanceof OuterSnippetsClassWrap)) {
        return null;
    }
    int ordinal = ((OuterSnippetsClassWrap) ow).ordinal(msn);
    if (ordinal < 0) {
        return null;
    }
    int count = 0;
    String name = msn.name();
    for (Tree mem : targetClass.getMembers()) {
        if (mem.getKind() == Tree.Kind.METHOD) {
            MethodTree mt = (MethodTree) mem;
            if (mt.getName().toString().equals(name)) {
                if (count == ordinal) {
                    return mt;
                }
                ++count;
            }
        }
    }
    return null;
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
@Override
public Object visitReturn(ReturnTree node, Object p) {
    TreePath path = getCurrentPath();
    TreePath parentPath = path.getParentPath();
    if (suppress) {
        return  super.visitReturn(node, p);
    }
    if (ignoreGuards && parentPath != null) {
        Tree parentTree = parentPath.getLeaf();
        TreePath branchPath = path;
        while (parentTree.getKind() == Tree.Kind.BLOCK) {
            branchPath = parentPath;
            parentPath = parentPath.getParentPath();
            parentTree = parentPath.getLeaf();
        }
        if (parentTree.getKind() == Tree.Kind.IF) {
            IfTree ifTree = (IfTree)parentTree;
            StatementTree trueTree = ifTree.getThenStatement() == branchPath.getLeaf() ? 
                    ifTree.getThenStatement() : ifTree.getElseStatement();
            if (trueTree == node) {
                return  super.visitReturn(node, p);
            }
            if (trueTree.getKind() == Tree.Kind.BLOCK) {
                BlockTree bt = (BlockTree)trueTree;
                if (bt.getStatements().size() == 1) {
                    return  super.visitReturn(node, p);
                }
            }
        }
    }
    returnCount++;
    return super.visitReturn(node, p);
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
private String createEqualsLineForField(VariableTree field) {
    Name fieldName = field.getName();
    Tree fieldType = field.getType();
    if (fieldType.getKind() == Tree.Kind.PRIMITIVE_TYPE) {
        return "if (this." + fieldName + " != other." + fieldName + ") return false;"; // NOI18N
    }
    return "if ((this." + fieldName + " == null && other." + fieldName + " != null) || " + "(this." + fieldName +
            " != null && !this." + fieldName + ".equals(other." + fieldName + "))) return false;"; // NOI18N
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
VariableTree firstVariable() {
    if (targetClass != null) {
        for (Tree mem : targetClass.getMembers()) {
            if (mem.getKind() == Tree.Kind.VARIABLE) {
                VariableTree vt = (VariableTree) mem;
                return vt;
            }
        }
    }
    return null;
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
private static boolean isSetter(Tree member) {
    return member.getKind() == Tree.Kind.METHOD
            && name(member).startsWith("set") //NOI18N
            && ((MethodTree)member).getParameters().size() == 1
            && ((MethodTree)member).getReturnType().getKind() == Tree.Kind.PRIMITIVE_TYPE
            && ((PrimitiveTypeTree)((MethodTree)member).getReturnType()).getPrimitiveTypeKind() == TypeKind.VOID;
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
/** Return true iff this tree is a child of some annotation. */
public static boolean isInAnnotation(Env<?> env, JCTree tree) {
    TreePath tp = TreePath.getPath(env.toplevel, tree);
    if (tp != null) {
        for (Tree t : tp) {
            if (t.getKind() == Tree.Kind.ANNOTATION)
                return true;
        }
    }
    return false;
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
private static String qualifiedString(Tree tree) {
  switch (tree.getKind()) {
  case IDENTIFIER:
      return ((IdentifierTree) tree).getName().toString();
  case MEMBER_SELECT:
    MemberSelectTree select = (MemberSelectTree) tree;
    return qualifiedString(select.getExpression()) + '.' + select.getIdentifier().toString();
  default:
      throw new AssertionError(tree.toString());
  }
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
/**
 * Resolves all fields that belong to the same field group. 
 */
private static @NonNull List<? extends Tree> collectFieldGroup(@NonNull CompilationInfo info, 
        @NonNull TreePath parentPath, Tree leaf) {
    Iterable<? extends Tree> children;

    switch (parentPath.getLeaf().getKind()) {
        case BLOCK: children = ((BlockTree) parentPath.getLeaf()).getStatements(); break;
        case ANNOTATION_TYPE:
        case CLASS:
        case ENUM:
        case INTERFACE:
            children = ((ClassTree) parentPath.getLeaf()).getMembers(); break;
        case CASE:  children = ((CaseTree) parentPath.getLeaf()).getStatements(); break;
        default:    children = Collections.singleton(leaf); break;
    }

    List<Tree> result = new LinkedList<>();
    ModifiersTree currentModifiers = ((VariableTree) leaf).getModifiers();

    for (Tree c : children) {
        if (c.getKind() != Kind.VARIABLE) continue;

        if (((VariableTree) c).getModifiers() == currentModifiers) {
            result.add(c);
        }
    }
    
    return result;
}
 

import com.sun.source.tree.Tree; //导入方法依赖的package包/类
public static @NonNull Collection<? extends TreePath> resolveFieldGroup(@NonNull CompilationInfo info, @NonNull TreePath variable) {
    Tree leaf = variable.getLeaf();

    if (leaf.getKind() != Kind.VARIABLE) {
        return Collections.singleton(variable);
    }

    TreePath parentPath = variable.getParentPath();
    Iterable<? extends Tree> children;

    switch (parentPath.getLeaf().getKind()) {
        case BLOCK: children = ((BlockTree) parentPath.getLeaf()).getStatements(); break;
        case ANNOTATION_TYPE:
        case CLASS:
        case ENUM:
        case INTERFACE:
            children = ((ClassTree) parentPath.getLeaf()).getMembers(); break;
        case CASE:  children = ((CaseTree) parentPath.getLeaf()).getStatements(); break;
        default:    children = Collections.singleton(leaf); break;
    }

    List<TreePath> result = new LinkedList<TreePath>();
    ModifiersTree currentModifiers = ((VariableTree) leaf).getModifiers();

    for (Tree c : children) {
        if (c.getKind() != Kind.VARIABLE) continue;

        if (((VariableTree) c).getModifiers() == currentModifiers) {
            result.add(new TreePath(parentPath, c));
        }
    }
    
    return result;
}