TreeUtils (checker-framework 2.5.8 API)

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

```
public final class TreeUtils
extends Object
```
A utility class made for helping to analyze a given Tree.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static AnnotationMirror`	`annotationFromAnnotationTree(AnnotationTree tree)`
`static List<? extends AnnotationMirror>`	`annotationsFromArrayCreation(NewArrayTree node, int level)`
`static List<? extends AnnotationMirror>`	`annotationsFromTree(AnnotatedTypeTree node)`
`static List<? extends AnnotationMirror>`	`annotationsFromTree(TypeParameterTree node)`
`static List<AnnotationMirror>`	`annotationsFromTypeAnnotationTrees(List<? extends AnnotationTree> annos)`
`static boolean`	`canHaveTypeAnnotation(Tree tree)`
`static Set<Tree.Kind>`	`classTreeKinds()`
`static ExecutableElement`	`constructor(NewClassTree tree)` Determines the symbol for a constructor given an invocation via `new`.
`static boolean`	`containsThisConstructorInvocation(MethodTree node)`
`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 Element`	`elementFromUse(ExpressionTree node)` Gets the element for the declaration corresponding to this use of an element.
`static ExecutableElement`	`elementFromUse(MethodInvocationTree node)`
`static ExecutableElement`	`elementFromUse(NewClassTree node)` Specialization for return type.
`static @Nullable ClassTree`	`enclosingClass(@Nullable TreePath path)` Gets the enclosing class of the tree node defined by the given `TreePath`.
`static @Nullable MethodTree`	`enclosingMethod(@Nullable TreePath path)` Gets the enclosing method of the tree node defined by the given `TreePath`.
`static @Nullable Tree`	`enclosingMethodOrLambda(@Nullable TreePath path)` Gets the enclosing method or lambda expression of the tree node defined by the given `TreePath`.
`static <T extends Tree> T`	`enclosingOfClass(TreePath path, Class<T> treeClass)` Gets the first enclosing tree in path, of the specified class.
`static Tree`	`enclosingOfKind(TreePath path, Set<Tree.Kind> kinds)` Gets the first enclosing tree in path, with any one of the specified kinds.
`static Tree`	`enclosingOfKind(TreePath path, Tree.Kind kind)` Gets the first enclosing tree in path, of the specified kind.
`static @Nullable BlockTree`	`enclosingTopLevelBlock(TreePath path)`
`static VariableTree`	`enclosingVariable(TreePath path)` Gets the enclosing variable of a tree node defined by the given `TreePath`.
`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)`
`static Tree`	`getAssignmentContext(TreePath treePath)` Returns the tree with the assignment context for the treePath leaf node.
`static VariableElement`	`getField(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(String typeName, String methodName, int params, ProcessingEnvironment env)` Returns the ExecutableElement for the method declaration of methodName, in class typeName, with params formal parameters.
`static ExecutableElement`	`getMethod(String typeName, String methodName, ProcessingEnvironment env, String... paramTypes)` Returns the ExecutableElement for a method declaration of methodName, in class typeName, with formal parameters of the given types.
`static List<ExecutableElement>`	`getMethodList(String typeName, String methodName, int params, ProcessingEnvironment env)` Returns all ExecutableElements for method declarations of methodName, in class typeName, with params formal parameters.
`static String`	`getMethodName(Tree tree)` Compute the name of the method that the method access `tree` accesses.
`static 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`	`isAnonymousConstructor(MethodTree method)` Determines whether or not the node referred to by the given `TreePath` 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)`
`static boolean`	`isExplicitThisDereference(ExpressionTree tree)` Determine whether the given expression is either "this" or an outer "C.this".
`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`	`isGetClassInvocation(MethodInvocationTree invocationTree)`
`static boolean`	`isImplicitlyTypedLambda(Tree tree)` Returns true if `tree` is an implicitly typed lambda.
`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.
`protected static boolean`	`isNamedMethodCall(String name, MethodInvocationTree tree)` Checks if the method call is a call to the given method name.
`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`	`isSuperCall(MethodInvocationTree tree)` Checks if the method invocation is a call to super.
`static boolean`	`isThisCall(MethodInvocationTree tree)` Checks if the method invocation is a call to "this".
`static boolean`	`isTreeInStaticScope(TreePath path)` Returns whether or not the leaf of the tree path is in a static scope.
`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 Name`	`methodName(MethodInvocationTree node)`
`static TreePath`	`pathTillClass(TreePath path)` Gets path to the first enclosing class tree, where class is defined by the classTreeKinds method.
`static TreePath`	`pathTillOfKind(TreePath path, Set<Tree.Kind> kinds)` Gets path to the first enclosing tree with any one of the specified kinds.
`static TreePath`	`pathTillOfKind(TreePath path, Tree.Kind kind)` Gets path to the first enclosing tree of the specified kind.
`static ExpressionTree`	`skipParens(ExpressionTree tree)` If the given tree is a parenthesized tree, it returns the enclosed non-parenthesized tree.
`static TypeMirror`	`typeOf(Tree tree)`
`static Set<Tree.Kind>`	`typeTreeKinds()`

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

- 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
  - isSuperCall
```
public static boolean isSuperCall(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
  - isThisCall
```
public static boolean isThisCall(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
  - isNamedMethodCall
```
protected static boolean isNamedMethodCall(String name,
                                           MethodInvocationTree tree)
```
    Checks if the method call is a call to the given method name.
    
    Parameters:
    
    name - a method name
    
    tree - a tree defining a method invocation
    
    Returns:
    
    true iff tree describes a call to the given method
  - 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
  - enclosingOfKind
```
public static Tree enclosingOfKind(TreePath path,
                                   Tree.Kind kind)
```
    Gets the first enclosing tree in path, of the specified kind.
    
    Parameters:
    
    path - the path defining the tree node
    
    kind - the kind of the desired tree
    
    Returns:
    
    the enclosing tree of the given type as given by the path
  - enclosingOfKind
```
public static Tree enclosingOfKind(TreePath path,
                                   Set<Tree.Kind> kinds)
```
    Gets the first enclosing tree in path, with any one of the specified kinds.
    
    Parameters:
    
    path - the path defining the tree node
    
    kinds - the set of kinds of the desired tree
    
    Returns:
    
    the enclosing tree of the given type as given by the path
  - pathTillClass
```
public static TreePath pathTillClass(TreePath path)
```
    Gets path to the first enclosing class tree, where class is defined by the classTreeKinds method.
    
    Parameters:
    
    path - the path defining the tree node
    
    Returns:
    
    the path to the enclosing class tree
  - pathTillOfKind
```
public static TreePath pathTillOfKind(TreePath path,
                                      Tree.Kind kind)
```
    Gets path to the first enclosing tree of the specified kind.
    
    Parameters:
    
    path - the path defining the tree node
    
    kind - the kind of the desired tree
    
    Returns:
    
    the path to the enclosing tree of the given type
  - pathTillOfKind
```
public static TreePath pathTillOfKind(TreePath path,
                                      Set<Tree.Kind> kinds)
```
    Gets path to the first enclosing tree with any one of the specified kinds.
    
    Parameters:
    
    path - the path defining the tree node
    
    kinds - the set of kinds of the desired tree
    
    Returns:
    
    the path to the enclosing tree of the given type
  - enclosingOfClass
```
public static <T extends Tree> T enclosingOfClass(TreePath path,
                                                  Class<T> treeClass)
```
    Gets the first enclosing tree in path, of the specified class.
    
    Parameters:
    
    path - the path defining the tree node
    
    treeClass - the class of the desired tree
    
    Returns:
    
    the enclosing tree of the given type as given by the path
  - enclosingClass
```
public static @Nullable ClassTree enclosingClass(@Nullable TreePath path)
```
    Gets the enclosing class of the tree node defined by the given TreePath. It returns a Tree, from which checkers.types.AnnotatedTypeMirror or Element can be obtained.
    
    Parameters:
    
    path - the path defining the tree node
    
    Returns:
    
    the enclosing class (or interface) as given by the path, or null if one does not exist
  - enclosingVariable
```
public static VariableTree enclosingVariable(TreePath path)
```
    Gets the enclosing variable of a tree node defined by the given TreePath.
    
    Parameters:
    
    path - the path defining the tree node
    
    Returns:
    
    the enclosing variable as given by the path, or null if one does not exist
  - enclosingMethod
```
public static @Nullable MethodTree enclosingMethod(@Nullable TreePath path)
```
    Gets the enclosing method of the tree node defined by the given TreePath. It returns a Tree, from which an checkers.types.AnnotatedTypeMirror or Element can be obtained.
    
    Parameters:
    
    path - the path defining the tree node
    
    Returns:
    
    the enclosing method as given by the path, or null if one does not exist
  - enclosingMethodOrLambda
```
public static @Nullable Tree enclosingMethodOrLambda(@Nullable TreePath path)
```
    Gets the enclosing method or lambda expression of the tree node defined by the given TreePath. It returns a Tree, from which an checkers.types.AnnotatedTypeMirror or Element can be obtained.
    
    Parameters:
    
    path - the path defining the tree node
    
    Returns:
    
    the enclosing method or lambda as given by the path, or null if one does not exist
  - enclosingTopLevelBlock
```
public static @Nullable BlockTree enclosingTopLevelBlock(TreePath path)
```
  - skipParens
```
public static ExpressionTree skipParens(ExpressionTree tree)
```
    If the given tree is a parenthesized tree, it returns the enclosed non-parenthesized tree. Otherwise, it returns the same tree.
    
    Parameters:
    
    tree - an expression tree
    
    Returns:
    
    the outermost non-parenthesized tree enclosed by the given tree
  - getAssignmentContext
```
public static Tree getAssignmentContext(TreePath treePath)
```
    Returns the tree with the assignment context for the treePath leaf node. (Does not handle pseudo-assignment of an argument to a parameter or a receiver expression to a receiver.)
    The assignment context for the treePath is the leaf of its parent, if the parent is one of the following trees:
    - AssignmentTree
    - CompoundAssignmentTree
    - MethodInvocationTree
    - NewArrayTree
    - NewClassTree
    - ReturnTree
    - VariableTree
    If the parent is a ConditionalExpressionTree we need to distinguish two cases: If the leaf is either the then or else branch of the ConditionalExpressionTree, then recurse on the parent. If the leaf is the condition of the ConditionalExpressionTree, then return null to not consider this assignment context.
    If the leaf is a ParenthesizedTree, then recurse on the parent.
    Otherwise, null is returned.
    Returns:
    
    the assignment context as described
  - elementFromTree
```
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 final TypeElement elementFromDeclaration(ClassTree node)
```
    Gets the element for a class corresponding to a declaration.
    
    Returns:
    
    the element for the given class
  - elementFromDeclaration
```
public static final ExecutableElement elementFromDeclaration(MethodTree node)
```
    Gets the element for a method corresponding to a declaration.
    
    Returns:
    
    the element for the given method
  - elementFromDeclaration
```
public static final VariableElement elementFromDeclaration(VariableTree node)
```
    Gets the element for a variable corresponding to its declaration.
    
    Returns:
    
    the element for the given variable
  - elementFromUse
```
public static final 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
  - elementFromUse
```
public static final ExecutableElement elementFromUse(MethodInvocationTree node)
```
  - elementFromUse
```
public static final ExecutableElement elementFromUse(NewClassTree node)
```
    Specialization for return type. Might return null if element wasn't found.
    
    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
```
public static final 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
  - methodName
```
public static final Name methodName(MethodInvocationTree node)
```
    Returns:
    
    the name of the invoked method
  - containsThisConstructorInvocation
```
public static final boolean containsThisConstructorInvocation(MethodTree node)
```
    Returns:
    
    true if the first statement in the body is a self constructor invocation within a constructor
  - firstStatement
```
public static final Tree firstStatement(Tree tree)
```
  - 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
  - isDiamondTree
```
public static final 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 final boolean isStringConcatenation(Tree tree)
```
    Returns true if the tree represents a String concatenation operation.
  - isStringCompoundConcatenation
```
public static final 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 ExpressionTree getReceiverTree(ExpressionTree expression)
```
    Returns the receiver tree of a field access or a method invocation.
  - classTreeKinds
```
public static Set<Tree.Kind> classTreeKinds()
```
  - 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.
  - getMethod
```
public static ExecutableElement getMethod(String typeName,
                                          String methodName,
                                          int params,
                                          ProcessingEnvironment env)
```
    Returns the ExecutableElement for the method declaration of methodName, in class typeName, with params formal parameters. 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...).
  - getMethodList
```
public static List<ExecutableElement> getMethodList(String typeName,
                                                    String methodName,
                                                    int params,
                                                    ProcessingEnvironment env)
```
    Returns all ExecutableElements for method declarations of methodName, in class typeName, with params formal parameters.
  - getMethod
```
public static ExecutableElement getMethod(String typeName,
                                          String methodName,
                                          ProcessingEnvironment env,
                                          String... paramTypes)
```
    Returns the ExecutableElement for a method declaration of methodName, in class typeName, with formal parameters of the given types. Errs if there is no matching method.
  - isExplicitThisDereference
```
public static final 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.
    
    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.
    
    Returns:
    
    the name of the method accessed by tree.
  - canHaveTypeAnnotation
```
public static boolean canHaveTypeAnnotation(Tree tree)
```
    Returns:
    
    true if and only if tree can have a type annotation.
    TODO: is this implementation precise enough? E.g. does a .class literal work correctly?
  - 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(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.
    TODO: is there a nicer way than an instanceof?
    
    Parameters:
    
    tree - the Tree to test
    
    Returns:
    
    whether the tree is an ExpressionTree
  - isEnumSuper
```
public static boolean isEnumSuper(MethodInvocationTree node)
```
    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
  - isGetClassInvocation
```
public static boolean isGetClassInvocation(MethodInvocationTree invocationTree)
```
    Returns:
    
    true iff invocationTree is an instance of getClass()
    
    See Also:
    
    Object.getClass()
  - isTreeInStaticScope
```
public static boolean isTreeInStaticScope(TreePath path)
```
    Returns whether or not the leaf of the tree path is in a static scope.
    
    Parameters:
    
    path - TreePath whose leaf may or may not be in static scope
    
    Returns:
    
    returns whether or not the leaf of the tree path is in a static scope
  - 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 TreePath is an anonymous constructor (the constructor for an anonymous class.
    
    Parameters:
    
    method - the TreePath 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 final List<AnnotationMirror> annotationsFromTypeAnnotationTrees(List<? extends AnnotationTree> annos)
```
  - annotationFromAnnotationTree
```
public static AnnotationMirror annotationFromAnnotationTree(AnnotationTree tree)
```
  - annotationsFromTree
```
public static final List<? extends AnnotationMirror> annotationsFromTree(AnnotatedTypeTree node)
```
  - annotationsFromTree
```
public static final List<? extends AnnotationMirror> annotationsFromTree(TypeParameterTree node)
```
  - annotationsFromArrayCreation
```
public static final List<? extends AnnotationMirror> annotationsFromArrayCreation(NewArrayTree node,
                                                                                  int level)
```
  - typeOf
```
public static TypeMirror typeOf(Tree 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.

Class TreeUtils

Method Summary

Methods inherited from class java.lang.Object

Method Detail

isConstructor

isSuperCall

isThisCall

isNamedMethodCall

isSelfAccess

enclosingOfKind

enclosingOfKind

pathTillClass

pathTillOfKind

pathTillOfKind

enclosingOfClass

enclosingClass

enclosingVariable

enclosingMethod

enclosingMethodOrLambda

enclosingTopLevelBlock

skipParens

getAssignmentContext

elementFromTree

elementFromDeclaration

elementFromDeclaration

elementFromDeclaration

elementFromUse

elementFromUse

elementFromUse

constructor

isUseOfElement

methodName

containsThisConstructorInvocation

firstStatement

hasExplicitConstructor

isDiamondTree

isStringConcatenation

isStringCompoundConcatenation

isCompileTimeString

getReceiverTree

classTreeKinds

isClassTree

typeTreeKinds

isTypeTree

isMethodInvocation

getMethod

getMethodList

getMethod

isExplicitThisDereference

isClassLiteral

isFieldAccess

getFieldName

isMethodAccess

getMethodName

canHaveTypeAnnotation

isSpecificFieldAccess

getField

isExpressionTree

isEnumSuper

isTypeDeclaration

isGetClassInvocation

isTreeInStaticScope

isArrayLengthAccess

isAnonymousConstructor

annotationsFromTypeAnnotationTrees

annotationFromAnnotationTree

annotationsFromTree

annotationsFromTree

annotationsFromArrayCreation

typeOf

findFunction

isImplicitlyTypedLambda