TreeUtils (checker-framework 3.12.0 API)

java.lang.Object
- org.checkerframework.javacutil.TreeUtils

```
public final class TreeUtils
extends Object
```
Utility methods for analyzing a javac Tree.

See Also:

TreePathUtil

Field Summary

Fields
Modifier and Type Field and Description

static org.plumelib.util.UniqueIdMap<Tree> treeUids
Unique IDs for trees.

Fields
Modifier and Type	Field and Description
`static org.plumelib.util.UniqueIdMap<Tree>`	`treeUids` Unique IDs for trees.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static AnnotationMirror`	`annotationFromAnnotationTree(AnnotationTree tree)` Converts the given AnnotationTree to an AnnotationMirror.
`static List<? extends AnnotationMirror>`	`annotationsFromArrayCreation(NewArrayTree tree, int level)` Converts the given NewArrayTree to a list of AnnotationMirrors.
`static List<? extends AnnotationMirror>`	`annotationsFromTree(AnnotatedTypeTree tree)` Converts the given AnnotatedTypeTree to a list of AnnotationMirrors.
`static List<? extends AnnotationMirror>`	`annotationsFromTree(TypeParameterTree tree)` Converts the given TypeParameterTree to a list of AnnotationMirrors.
`static List<AnnotationMirror>`	`annotationsFromTypeAnnotationTrees(List<? extends AnnotationTree> annoTrees)` Converts the given AnnotationTrees to AnnotationMirrors.
`static boolean`	`canHaveTypeAnnotation(Tree tree)` Return `true` if and only if `tree` can have a type annotation.
`static Set<Tree.Kind>`	`classTreeKinds()` Return the set of kinds that represent classes.
`static ExecutableElement`	`constructor(NewClassTree tree)` Determines the symbol for a constructor given an invocation via `new`.
`static boolean`	`containsThisConstructorInvocation(MethodTree node)` Returns true if the first statement in the body is a self constructor invocation within a constructor.
`static LiteralTree`	`createLiteral(com.sun.tools.javac.code.TypeTag typeTag, @Nullable Object value, TypeMirror typeMirror, ProcessingEnvironment processingEnv)` Creates a LiteralTree for the given value.
`static TypeElement`	`elementFromDeclaration(ClassTree node)` Gets the element for a class corresponding to a declaration.
`static ExecutableElement`	`elementFromDeclaration(MethodTree node)` Gets the element for a method corresponding to a declaration.
`static VariableElement`	`elementFromDeclaration(VariableTree node)` Gets the element for a variable corresponding to its declaration.
`static @Nullable Element`	`elementFromTree(Tree tree)` Gets the `Element` for the given Tree API node.
`static @Nullable Element`	`elementFromUse(ExpressionTree node)` Gets the element for the declaration corresponding to this use of an element.
`static ExecutableElement`	`elementFromUse(MethodInvocationTree node)` Returns the ExecutableElement for the called method, from a call.
`static ExecutableElement`	`elementFromUse(NewClassTree node)` Gets the ExecutableElement for the called constructor, from a constructor invocation.
`static com.sun.tools.javac.code.Symbol`	`findFunction(Tree tree, ProcessingEnvironment env)` The type of the lambda or method reference tree is a functional interface type.
`static Tree`	`firstStatement(Tree tree)` Returns the first statement of the tree if it is a block.
`static LiteralTree`	`getDefaultValueTree(TypeMirror typeMirror, ProcessingEnvironment processingEnv)` Return a tree for the default value of the given type.
`static List<? extends AnnotationTree>`	`getExplicitAnnotationTrees(@Nullable List<? extends AnnotationTree> annoTrees, Tree typeTree)` Returns the annotations explicitly written on the given type.
`static VariableElement`	`getField(@FullyQualifiedName String typeName, String fieldName, ProcessingEnvironment env)` Returns the VariableElement for a field declaration.
`static String`	`getFieldName(Tree tree)` Compute the name of the field that the field access `tree` accesses.
`static ExecutableElement`	`getMethod(Class<?> type, String methodName, int params, ProcessingEnvironment env)` Returns the ExecutableElement for a method declaration.
`static ExecutableElement`	`getMethod(Class<?> type, String methodName, ProcessingEnvironment env, String... paramTypes)` Returns the ExecutableElement for a method declaration.
`static ExecutableElement`	`getMethod(@FullyQualifiedName String typeName, String methodName, int params, ProcessingEnvironment env)` Returns the ExecutableElement for a method declaration.
`static ExecutableElement`	`getMethod(@FullyQualifiedName String typeName, String methodName, ProcessingEnvironment env, String... paramTypes)` Returns the ExecutableElement for a method declaration.
`static String`	`getMethodName(Tree tree)` Compute the name of the method that the method access `tree` accesses.
`static @Nullable ExecutableElement`	`getMethodOrNull(@FullyQualifiedName String typeName, String methodName, int params, ProcessingEnvironment env)` Returns the ExecutableElement for a method declaration.
`static List<ExecutableElement>`	`getMethods(@FullyQualifiedName String typeName, String methodName, int params, ProcessingEnvironment env)` Returns all ExecutableElements for method declarations of methodName, in class typeName, with params formal parameters.
`static @Nullable ExpressionTree`	`getReceiverTree(ExpressionTree expression)` Returns the receiver tree of a field access or a method invocation.
`static boolean`	`hasExplicitConstructor(ClassTree node)` Determine whether the given class contains an explicit constructor.
`static boolean`	`hasSyntheticArgument(NewClassTree tree)` Returns true if `tree` has a synthetic argument.
`static boolean`	`isAnonymousConstructor(MethodTree method)` Determines whether or not the node referred to by the given `Tree` is an anonymous constructor (the constructor for an anonymous class.
`static boolean`	`isArrayLengthAccess(Tree tree)` Returns whether or not tree is an access of array length.
`static boolean`	`isClassLiteral(Tree tree)` Determine whether `tree` is a class literal, such as.
`static boolean`	`isClassTree(Tree tree)` Is the given tree kind a class, i.e.
`static boolean`	`isCompileTimeString(ExpressionTree node)` Returns true if the node is a constant-time expression.
`static boolean`	`isConstructor(MethodTree tree)` Checks if the provided method is a constructor method or no.
`static boolean`	`isDiamondTree(Tree tree)` Returns true if the tree is of a diamond type.
`static boolean`	`isEnumSuper(MethodInvocationTree node)` Returns true if this is a super call to the `Enum` constructor.
`static boolean`	`isExplicitThisDereference(ExpressionTree tree)` Determine whether the given expression is either "this" or an outer "C.this".
`static boolean`	`isExprConstTrue(ExpressionTree node)` Determine whether an expression `ExpressionTree` has the constant value true, according to the compiler logic.
`static boolean`	`isExpressionTree(Tree tree)` Determine whether the given tree represents an ExpressionTree.
`static boolean`	`isFieldAccess(Tree tree)` Determine whether `tree` is a field access expressions, such as.
`static boolean`	`isImplicitlyTypedLambda(Tree tree)` Returns true if `tree` is an implicitly typed lambda.
`static boolean`	`isLocalVariable(Tree tree)` Returns true if the tree is the declaration or use of a local variable.
`static boolean`	`isMethodAccess(Tree tree)` Determine whether `tree` refers to a method element, such as.
`static boolean`	`isMethodInvocation(Tree tree, ExecutableElement method, ProcessingEnvironment env)` Returns true if the given element is an invocation of the method, or of any method that overrides that one.
`static boolean`	`isMethodInvocation(Tree methodTree, List<ExecutableElement> methods, ProcessingEnvironment processingEnv)` Returns true if the argument is an invocation of one of the given methods, or of any method that overrides them.
`static boolean`	`isNullExpression(Tree t)` Returns true if the given tree evaluates to `null`.
`static boolean`	`isSelfAccess(ExpressionTree tree)` Returns true if the tree is a tree that 'looks like' either an access of a field or an invocation of a method that are owned by the same accessing instance.
`static boolean`	`isSpecificFieldAccess(Tree tree, VariableElement var)` Returns true if and only if the given `tree` represents a field access of the given `VariableElement`.
`static boolean`	`isStringCompoundConcatenation(CompoundAssignmentTree tree)` Returns true if the compound assignment tree is a string concatenation.
`static boolean`	`isStringConcatenation(Tree tree)` Returns true if the tree represents a `String` concatenation operation.
`static boolean`	`isSuperConstructorCall(MethodInvocationTree tree)` Checks if the method invocation is a call to super.
`static boolean`	`isSynthetic(ExecutableElement ee)` Returns true if the given method is synthetic.
`static boolean`	`isSynthetic(MethodTree node)` Returns true if the given method is synthetic.
`static boolean`	`isThisConstructorCall(MethodInvocationTree tree)` Checks if the method invocation is a call to "this".
`static boolean`	`isTypeDeclaration(Tree node)` Determine whether the given tree represents a declaration of a type (including type parameters).
`static boolean`	`isTypeTree(Tree tree)` Is the given tree a type instantiation?
`static boolean`	`isUseOfElement(ExpressionTree node)` Determine whether the given ExpressionTree has an underlying element.
`static boolean`	`isWideningBinary(BinaryTree node)` Returns true if the binary operator may do a widening primitive conversion.
`static Name`	`methodName(MethodInvocationTree node)` Returns the name of the invoked method.
`static String`	`nameExpressionToString(ExpressionTree nameExpr)` Given a javac ExpressionTree representing a fully qualified name such as "java.lang.Object", creates a String containing the name.
`static String`	`toStringOneLine(Tree tree)` Return toString(), but without line separators.
`static String`	`toStringTruncated(Tree tree, int length)` Return either `toStringOneLine(com.sun.source.tree.Tree)` if it is no more than `length` characters, or `toStringOneLine(com.sun.source.tree.Tree)` quoted and truncated.
`static TypeMirror`	`typeOf(Tree tree)` Returns the type as a TypeMirror of `tree`.
`static Set<Tree.Kind>`	`typeTreeKinds()`
`static @PolyInterned ExpressionTree`	`withoutParens(@PolyInterned ExpressionTree tree)` If the given tree is a parenthesized tree, return the enclosed non-parenthesized tree.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - treeUids
```
public static final org.plumelib.util.UniqueIdMap<Tree> treeUids
```
    Unique IDs for trees.
- Method Detail
  - isConstructor
```
public static boolean isConstructor(MethodTree tree)
```
    Checks if the provided method is a constructor method or no.
    
    Parameters:
    
    tree - a tree defining the method
    
    Returns:
    
    true iff tree describes a constructor
  - isSuperConstructorCall
```
public static boolean isSuperConstructorCall(MethodInvocationTree tree)
```
    Checks if the method invocation is a call to super.
    
    Parameters:
    
    tree - a tree defining a method invocation
    
    Returns:
    
    true iff tree describes a call to super
  - isThisConstructorCall
```
public static boolean isThisConstructorCall(MethodInvocationTree tree)
```
    Checks if the method invocation is a call to "this".
    
    Parameters:
    
    tree - a tree defining a method invocation
    
    Returns:
    
    true iff tree describes a call to this
  - isSelfAccess
```
public static boolean isSelfAccess(ExpressionTree tree)
```
    Returns true if the tree is a tree that 'looks like' either an access of a field or an invocation of a method that are owned by the same accessing instance.
    It would only return true if the access tree is of the form:
```
   field
   this.field

   method()
   this.method()
 
```
    It does not perform any semantical check to differentiate between fields and local variables; local methods or imported static methods.
    Parameters:
    
    tree - expression tree representing an access to object member
    
    Returns:
    
    true iff the member is a member of this instance
  - withoutParens
```
public static @PolyInterned ExpressionTree withoutParens(@PolyInterned ExpressionTree tree)
```
    If the given tree is a parenthesized tree, return the enclosed non-parenthesized tree. Otherwise, return the same tree.
    
    Parameters:
    
    tree - an expression tree
    
    Returns:
    
    the outermost non-parenthesized tree enclosed by the given tree
  - elementFromTree
```
@Pure
public static @Nullable Element elementFromTree(Tree tree)
```
    Gets the Element for the given Tree API node. For an object instantiation returns the value of the JCTree.JCNewClass.constructor field. Note that this result might differ from the result of constructor(NewClassTree).
    
    Parameters:
    
    tree - the Tree node to get the symbol for
    
    Returns:
    
    the Symbol for the given tree, or null if one could not be found
    
    Throws:
    
    IllegalArgumentException - if tree is null or is not a valid javac-internal tree (JCTree)
  - elementFromDeclaration
```
public static TypeElement elementFromDeclaration(ClassTree node)
```
    Gets the element for a class corresponding to a declaration.
    
    Parameters:
    
    node - class declaration
    
    Returns:
    
    the element for the given class
  - elementFromDeclaration
```
public static ExecutableElement elementFromDeclaration(MethodTree node)
```
    Gets the element for a method corresponding to a declaration.
    
    Returns:
    
    the element for the given method
  - elementFromDeclaration
```
public static VariableElement elementFromDeclaration(VariableTree node)
```
    Gets the element for a variable corresponding to its declaration.
    
    Returns:
    
    the element for the given variable
  - elementFromUse
```
@Pure
public static @Nullable Element elementFromUse(ExpressionTree node)
```
    Gets the element for the declaration corresponding to this use of an element. To get the element for a declaration, use elementFromDeclaration(ClassTree), elementFromDeclaration(MethodTree), or elementFromDeclaration(VariableTree) instead.
    This method is just a wrapper around elementFromTree(Tree), but this class might be the first place someone looks for this functionality.
    
    Parameters:
    
    node - the tree corresponding to a use of an element
    
    Returns:
    
    the element for the corresponding declaration, null otherwise
  - elementFromUse
```
@Pure
public static ExecutableElement elementFromUse(MethodInvocationTree node)
```
    Returns the ExecutableElement for the called method, from a call.
    
    Parameters:
    
    node - a method call
    
    Returns:
    
    the ExecutableElement for the called method
  - elementFromUse
```
@Pure
public static ExecutableElement elementFromUse(NewClassTree node)
```
    Gets the ExecutableElement for the called constructor, from a constructor invocation.
    
    Parameters:
    
    node - a constructor invocation
    
    Returns:
    
    the ExecutableElement for the called constructor
    
    See Also:
    
    constructor(NewClassTree)
  - constructor
```
public static ExecutableElement constructor(NewClassTree tree)
```
    Determines the symbol for a constructor given an invocation via new.
    If the tree is a declaration of an anonymous class, then method returns constructor that gets invoked in the extended class, rather than the anonymous constructor implicitly added by the constructor (JLS 15.9.5.1)
    
    Parameters:
    
    tree - the constructor invocation
    
    Returns:
    
    the ExecutableElement corresponding to the constructor call in tree
    
    See Also:
    
    elementFromUse(NewClassTree)
  - isUseOfElement
```
@EnsuresNonNullIf(result=true,
                  expression="elementFromUse(#1)")
 @Pure
public static boolean isUseOfElement(ExpressionTree node)
```
    Determine whether the given ExpressionTree has an underlying element.
    
    Parameters:
    
    node - the ExpressionTree to test
    
    Returns:
    
    whether the tree refers to an identifier, member select, or method invocation
  - hasSyntheticArgument
```
public static boolean hasSyntheticArgument(NewClassTree tree)
```
    Returns true if tree has a synthetic argument.
    For some anonymous classes with an explicit enclosing expression, javac creates a synthetic argument to the constructor that is the enclosing expression of the NewClassTree. Suppose a programmer writes:
```
     class Outer {
         class Inner { }
         void method() {
             this.new Inner(){};
         }
     }
 
```
    Java 9 javac creates the following synthetic tree for this.new Inner(){}:
```
    new Inner(this) {
         (.Outer x0) {
             x0.super();
         }
    }
 
```
    Java 11 javac creates a different tree without the synthetic argument for this.new Inner(){}:
```
    this.new Inner() {
         (.Outer x0) {
             x0.super();
         }
    }
 
```
    Parameters:
    
    tree - a new class tree
    
    Returns:
    
    true if tree has a synthetic argument
  - methodName
```
public static Name methodName(MethodInvocationTree node)
```
    Returns the name of the invoked method.
    
    Returns:
    
    the name of the invoked method
  - containsThisConstructorInvocation
```
public static boolean containsThisConstructorInvocation(MethodTree node)
```
    Returns true if the first statement in the body is a self constructor invocation within a constructor.
    
    Returns:
    
    true if the first statement in the body is a self constructor invocation within a constructor
  - firstStatement
```
public static Tree firstStatement(Tree tree)
```
    Returns the first statement of the tree if it is a block. If it is not a block or an empty block, tree is returned.
    
    Parameters:
    
    tree - any kind of tree
    
    Returns:
    
    the first statement of the tree if it is a block. If it is not a block or an empty block, tree is returned.
  - hasExplicitConstructor
```
public static boolean hasExplicitConstructor(ClassTree node)
```
    Determine whether the given class contains an explicit constructor.
    
    Parameters:
    
    node - a class tree
    
    Returns:
    
    true iff there is an explicit constructor
  - isSynthetic
```
public static boolean isSynthetic(ExecutableElement ee)
```
    Returns true if the given method is synthetic.
    
    Parameters:
    
    ee - a method or constructor element
    
    Returns:
    
    true iff the given method is synthetic
  - isSynthetic
```
public static boolean isSynthetic(MethodTree node)
```
    Returns true if the given method is synthetic.
    
    Parameters:
    
    node - a method declaration tree
    
    Returns:
    
    true iff the given method is synthetic
  - isDiamondTree
```
public static boolean isDiamondTree(Tree tree)
```
    Returns true if the tree is of a diamond type. In contrast to the implementation in TreeInfo, this version works on Trees.
    
    See Also:
    
    TreeInfo.isDiamond(JCTree)
  - isStringConcatenation
```
public static boolean isStringConcatenation(Tree tree)
```
    Returns true if the tree represents a String concatenation operation.
  - isStringCompoundConcatenation
```
public static boolean isStringCompoundConcatenation(CompoundAssignmentTree tree)
```
    Returns true if the compound assignment tree is a string concatenation.
  - isCompileTimeString
```
public static boolean isCompileTimeString(ExpressionTree node)
```
    Returns true if the node is a constant-time expression.
    A tree is a constant-time expression if it is:
    1. a literal tree
    2. a reference to a final variable initialized with a compile time constant
    3. a String concatenation of two compile time constants
  - getReceiverTree
```
public static @Nullable ExpressionTree getReceiverTree(ExpressionTree expression)
```
    Returns the receiver tree of a field access or a method invocation.
    
    Parameters:
    
    expression - a field access or a method invocation
    
    Returns:
    
    the expression's receiver tree, or null if it does not have an explicit receiver
  - classTreeKinds
```
public static Set<Tree.Kind> classTreeKinds()
```
    Return the set of kinds that represent classes.
    
    Returns:
    
    the set of kinds that represent classes
  - isClassTree
```
public static boolean isClassTree(Tree tree)
```
    Is the given tree kind a class, i.e. a class, enum, interface, or annotation type.
    
    Parameters:
    
    tree - the tree to test
    
    Returns:
    
    true, iff the given kind is a class kind
  - typeTreeKinds
```
public static Set<Tree.Kind> typeTreeKinds()
```
  - isTypeTree
```
public static boolean isTypeTree(Tree tree)
```
    Is the given tree a type instantiation?
    TODO: this is an under-approximation: e.g. an identifier could be either a type use or an expression. How can we distinguish.
    
    Parameters:
    
    tree - the tree to test
    
    Returns:
    
    true, iff the given tree is a type
  - isMethodInvocation
```
public static boolean isMethodInvocation(Tree tree,
                                         ExecutableElement method,
                                         ProcessingEnvironment env)
```
    Returns true if the given element is an invocation of the method, or of any method that overrides that one.
  - isMethodInvocation
```
public static boolean isMethodInvocation(Tree methodTree,
                                         List<ExecutableElement> methods,
                                         ProcessingEnvironment processingEnv)
```
    Returns true if the argument is an invocation of one of the given methods, or of any method that overrides them.
  - getMethod
```
public static ExecutableElement getMethod(Class<?> type,
                                          String methodName,
                                          int params,
                                          ProcessingEnvironment env)
```
    Returns the ExecutableElement for a method declaration. Errs if there is not exactly one matching method. If more than one method takes the same number of formal parameters, then use getMethod(String, String, ProcessingEnvironment, String...).
    
    Parameters:
    
    type - the class that contains the method
    
    methodName - the name of the method
    
    params - the number of formal parameters
    
    env - the processing environment
    
    Returns:
    
    the ExecutableElement for the specified method
  - getMethod
```
public static ExecutableElement getMethod(@FullyQualifiedName String typeName,
                                          String methodName,
                                          int params,
                                          ProcessingEnvironment env)
```
    Returns the ExecutableElement for a method declaration. Errs if there is not exactly one matching method. If more than one method takes the same number of formal parameters, then use getMethod(String, String, ProcessingEnvironment, String...).
    
    Parameters:
    
    typeName - the class that contains the method
    
    methodName - the name of the method
    
    params - the number of formal parameters
    
    env - the processing environment
    
    Returns:
    
    the ExecutableElement for the specified method
  - getMethodOrNull
```
public static @Nullable ExecutableElement getMethodOrNull(@FullyQualifiedName String typeName,
                                                          String methodName,
                                                          int params,
                                                          ProcessingEnvironment env)
```
    Returns the ExecutableElement for a method declaration. Returns null there is no matching method. Errs if there is more than one matching method. If more than one method takes the same number of formal parameters, then use getMethod(String, String, ProcessingEnvironment, String...).
    
    Parameters:
    
    typeName - the class that contains the method
    
    methodName - the name of the method
    
    params - the number of formal parameters
    
    env - the processing environment
    
    Returns:
    
    the ExecutableElement for the specified method, or null
  - getMethods
```
public static List<ExecutableElement> getMethods(@FullyQualifiedName String typeName,
                                                 String methodName,
                                                 int params,
                                                 ProcessingEnvironment env)
```
    Returns all ExecutableElements for method declarations of methodName, in class typeName, with params formal parameters.
    
    Parameters:
    
    typeName - the class that contains the method
    
    methodName - the name of the method
    
    params - the number of formal parameters
    
    env - the processing environment
    
    Returns:
    
    the ExecutableElements for all matching methods
  - getMethod
```
public static ExecutableElement getMethod(Class<?> type,
                                          String methodName,
                                          ProcessingEnvironment env,
                                          String... paramTypes)
```
    Returns the ExecutableElement for a method declaration. Errs if there is no matching method.
    
    Parameters:
    
    type - the class that contains the method
    
    methodName - the name of the method
    
    env - the processing environment
    
    paramTypes - the method's formal parameter types
    
    Returns:
    
    the ExecutableElement for the specified method
  - getMethod
```
public static ExecutableElement getMethod(@FullyQualifiedName String typeName,
                                          String methodName,
                                          ProcessingEnvironment env,
                                          String... paramTypes)
```
    Returns the ExecutableElement for a method declaration. Errs if there is no matching method.
    
    Parameters:
    
    typeName - the class that contains the method
    
    methodName - the name of the method
    
    env - the processing environment
    
    paramTypes - the method's formal parameter types
    
    Returns:
    
    the ExecutableElement for the specified method
  - isExplicitThisDereference
```
public static boolean isExplicitThisDereference(ExpressionTree tree)
```
    Determine whether the given expression is either "this" or an outer "C.this".
    TODO: Should this also handle "super"?
  - isClassLiteral
```
public static boolean isClassLiteral(Tree tree)
```
    Determine whether tree is a class literal, such as.
```
   Object . class
 
```
    Returns:
    
    true iff if tree is a class literal
  - isFieldAccess
```
public static boolean isFieldAccess(Tree tree)
```
    Determine whether tree is a field access expressions, such as.
```
   f
   obj . f
 
```
    Returns:
    
    true iff if tree is a field access expression (implicit or explicit)
  - getFieldName
```
public static String getFieldName(Tree tree)
```
    Compute the name of the field that the field access tree accesses. Requires tree to be a field access, as determined by isFieldAccess.
    
    Parameters:
    
    tree - a field access tree
    
    Returns:
    
    the name of the field accessed by tree
  - isMethodAccess
```
public static boolean isMethodAccess(Tree tree)
```
    Determine whether tree refers to a method element, such as.
```
   m(...)
   obj . m(...)
 
```
    Returns:
    
    true iff if tree is a method access expression (implicit or explicit)
  - getMethodName
```
public static String getMethodName(Tree tree)
```
    Compute the name of the method that the method access tree accesses. Requires tree to be a method access, as determined by isMethodAccess.
    
    Parameters:
    
    tree - a method access tree
    
    Returns:
    
    the name of the method accessed by tree
  - canHaveTypeAnnotation
```
public static boolean canHaveTypeAnnotation(Tree tree)
```
    Return true if and only if tree can have a type annotation.
    
    Returns:
    
    true if and only if tree can have a type annotation
  - isSpecificFieldAccess
```
public static boolean isSpecificFieldAccess(Tree tree,
                                            VariableElement var)
```
    Returns true if and only if the given tree represents a field access of the given VariableElement.
  - getField
```
public static VariableElement getField(@FullyQualifiedName String typeName,
                                       String fieldName,
                                       ProcessingEnvironment env)
```
    Returns the VariableElement for a field declaration.
    
    Parameters:
    
    typeName - the class where the field is declared
    
    fieldName - the name of the field
    
    env - the processing environment
    
    Returns:
    
    the VariableElement for typeName.fieldName
  - isExpressionTree
```
public static boolean isExpressionTree(Tree tree)
```
    Determine whether the given tree represents an ExpressionTree.
    
    Parameters:
    
    tree - the Tree to test
    
    Returns:
    
    whether the tree is an ExpressionTree
  - isEnumSuper
```
public static boolean isEnumSuper(MethodInvocationTree node)
```
    Returns true if this is a super call to the Enum constructor.
    
    Parameters:
    
    node - the method invocation to check
    
    Returns:
    
    true if this is a super call to the Enum constructor
  - isTypeDeclaration
```
public static boolean isTypeDeclaration(Tree node)
```
    Determine whether the given tree represents a declaration of a type (including type parameters).
    
    Parameters:
    
    node - the Tree to test
    
    Returns:
    
    true if the tree is a type declaration
  - isArrayLengthAccess
```
public static boolean isArrayLengthAccess(Tree tree)
```
    Returns whether or not tree is an access of array length.
    
    Parameters:
    
    tree - tree to check
    
    Returns:
    
    true if tree is an access of array length
  - isAnonymousConstructor
```
public static boolean isAnonymousConstructor(MethodTree method)
```
    Determines whether or not the node referred to by the given Tree is an anonymous constructor (the constructor for an anonymous class.
    
    Parameters:
    
    method - the Tree for a node that may be an anonymous constructor
    
    Returns:
    
    true if the given path points to an anonymous constructor, false if it does not
  - annotationsFromTypeAnnotationTrees
```
public static List<AnnotationMirror> annotationsFromTypeAnnotationTrees(List<? extends AnnotationTree> annoTrees)
```
    Converts the given AnnotationTrees to AnnotationMirrors.
    
    Parameters:
    
    annoTrees - list of annotation trees to convert to annotation mirrors
    
    Returns:
    
    list of annotation mirrors that represent the given annotation trees
  - annotationFromAnnotationTree
```
public static AnnotationMirror annotationFromAnnotationTree(AnnotationTree tree)
```
    Converts the given AnnotationTree to an AnnotationMirror.
    
    Parameters:
    
    tree - annotation tree to convert to an annotation mirror
    
    Returns:
    
    annotation mirror that represent the given annotation tree
  - annotationsFromTree
```
public static List<? extends AnnotationMirror> annotationsFromTree(AnnotatedTypeTree tree)
```
    Converts the given AnnotatedTypeTree to a list of AnnotationMirrors.
    
    Parameters:
    
    tree - annotated type tree to convert
    
    Returns:
    
    list of AnnotationMirrors from the tree
  - annotationsFromTree
```
public static List<? extends AnnotationMirror> annotationsFromTree(TypeParameterTree tree)
```
    Converts the given TypeParameterTree to a list of AnnotationMirrors.
    
    Parameters:
    
    tree - type parameter tree to convert
    
    Returns:
    
    list of AnnotationMirrors from the tree
  - annotationsFromArrayCreation
```
public static List<? extends AnnotationMirror> annotationsFromArrayCreation(NewArrayTree tree,
                                                                            int level)
```
    Converts the given NewArrayTree to a list of AnnotationMirrors.
    
    Parameters:
    
    tree - new array tree
    
    Returns:
    
    list of AnnotationMirrors from the tree
  - isLocalVariable
```
public static boolean isLocalVariable(Tree tree)
```
    Returns true if the tree is the declaration or use of a local variable.
    
    Returns:
    
    true if the tree is the declaration or use of a local variable
  - typeOf
```
public static TypeMirror typeOf(Tree tree)
```
    Returns the type as a TypeMirror of tree. To obtain tree's AnnotatedTypeMirror, call AnnotatedTypeFactory.getAnnotatedType().
    
    Returns:
    
    the type as a TypeMirror of tree
  - findFunction
```
public static com.sun.tools.javac.code.Symbol findFunction(Tree tree,
                                                           ProcessingEnvironment env)
```
    The type of the lambda or method reference tree is a functional interface type. This method returns the single abstract method declared by that functional interface. (The type of this method is referred to as the function type.)
    
    Parameters:
    
    tree - lambda or member reference tree
    
    env - ProcessingEnvironment
    
    Returns:
    
    the single abstract method declared by the type of the tree
  - isImplicitlyTypedLambda
```
public static boolean isImplicitlyTypedLambda(Tree tree)
```
    Returns true if tree is an implicitly typed lambda.
    A lambda expression whose formal type parameters have inferred types is an implicitly typed lambda. (See JLS 15.27.1)
    
    Parameters:
    
    tree - any kind of tree
    
    Returns:
    
    true iff tree is an implicitly typed lambda
  - isExprConstTrue
```
public static boolean isExprConstTrue(ExpressionTree node)
```
    Determine whether an expression ExpressionTree has the constant value true, according to the compiler logic.
    
    Parameters:
    
    node - the expression to be checked
    
    Returns:
    
    true if node has the constant value true
  - toStringOneLine
```
public static String toStringOneLine(Tree tree)
```
    Return toString(), but without line separators.
    
    Parameters:
    
    tree - a tree
    
    Returns:
    
    a one-line string representation of the tree
  - toStringTruncated
```
public static String toStringTruncated(Tree tree,
                                       int length)
```
    Return either toStringOneLine(com.sun.source.tree.Tree) if it is no more than length characters, or toStringOneLine(com.sun.source.tree.Tree) quoted and truncated.
    
    Parameters:
    
    tree - a tree
    
    length - the maximum length for the result; must be at least 6
    
    Returns:
    
    a one-line string representation of the tree that is no longer than length characters long
  - nameExpressionToString
```
public static String nameExpressionToString(ExpressionTree nameExpr)
```
    Given a javac ExpressionTree representing a fully qualified name such as "java.lang.Object", creates a String containing the name.
    
    Parameters:
    
    nameExpr - an ExpressionTree representing a fully qualified name
    
    Returns:
    
    a String representation of the fully qualified name
  - isWideningBinary
```
public static boolean isWideningBinary(BinaryTree node)
```
    Returns true if the binary operator may do a widening primitive conversion. See JLS chapter 5.
    
    Parameters:
    
    node - a binary tree
    
    Returns:
    
    true if the tree's operator does numeric promotion on its arguments
  - getExplicitAnnotationTrees
```
public static List<? extends AnnotationTree> getExplicitAnnotationTrees(@Nullable List<? extends AnnotationTree> annoTrees,
                                                                        Tree typeTree)
```
    Returns the annotations explicitly written on the given type.
    
    Parameters:
    
    annoTrees - annotations written before a variable/method declaration; null if this type is not from such a location. This might contain type annotations that the Java parser attached to the declaration rather than to the type.
    
    typeTree - the type whose annotations to return
    
    Returns:
    
    the annotations explicitly written on the given type
  - getDefaultValueTree
```
public static LiteralTree getDefaultValueTree(TypeMirror typeMirror,
                                              ProcessingEnvironment processingEnv)
```
    Return a tree for the default value of the given type. The default value is 0, false, or null.
    
    Parameters:
    
    typeMirror - a type
    
    processingEnv - the processing environment
    
    Returns:
    
    a tree for type's default value
  - createLiteral
```
public static LiteralTree createLiteral(com.sun.tools.javac.code.TypeTag typeTag,
                                        @Nullable Object value,
                                        TypeMirror typeMirror,
                                        ProcessingEnvironment processingEnv)
```
    Creates a LiteralTree for the given value.
    
    Parameters:
    
    typeTag - the literal's type tag
    
    value - a wrapped primitive, null, or a String
    
    typeMirror - the typeMirror for the literal
    
    processingEnv - the processing environment
    
    Returns:
    
    a LiteralTree for the given type tag and value
  - isNullExpression
```
public static boolean isNullExpression(Tree t)
```
    Returns true if the given tree evaluates to null.
    
    Parameters:
    
    t - a tree
    
    Returns:
    
    true if the given tree evaluates to null

Class TreeUtils

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

treeUids

Method Detail

isConstructor

isSuperConstructorCall

isThisConstructorCall

isSelfAccess

withoutParens

elementFromTree

elementFromDeclaration

elementFromDeclaration

elementFromDeclaration

elementFromUse

elementFromUse

elementFromUse

constructor

isUseOfElement

hasSyntheticArgument

methodName

containsThisConstructorInvocation

firstStatement

hasExplicitConstructor

isSynthetic

isSynthetic

isDiamondTree

isStringConcatenation

isStringCompoundConcatenation

isCompileTimeString

getReceiverTree

classTreeKinds

isClassTree

typeTreeKinds

isTypeTree

isMethodInvocation

isMethodInvocation

getMethod

getMethod

getMethodOrNull

getMethods

getMethod

getMethod

isExplicitThisDereference

isClassLiteral

isFieldAccess

getFieldName

isMethodAccess

getMethodName

canHaveTypeAnnotation

isSpecificFieldAccess

getField

isExpressionTree

isEnumSuper

isTypeDeclaration

isArrayLengthAccess

isAnonymousConstructor

annotationsFromTypeAnnotationTrees

annotationFromAnnotationTree

annotationsFromTree

annotationsFromTree

annotationsFromArrayCreation

isLocalVariable

typeOf

findFunction

isImplicitlyTypedLambda

isExprConstTrue

toStringOneLine

toStringTruncated

nameExpressionToString

isWideningBinary

getExplicitAnnotationTrees

getDefaultValueTree

createLiteral

isNullExpression