| Class | 
                        Description | 
                    
                            | 
                                
                                    AnnotationConstantExpression
                                
                             | 
                            Represents an annotation "constant" that may appear in annotation attributes
 (mainly used as a marker). | 
                        
                            | 
                                
                                    ArgumentListExpression
                                
                             | 
                            Represents one or more arguments being passed into a method | 
                        
                            | 
                                
                                    ArrayExpression
                                
                             | 
                            Represents an array object construction.
  | 
                        
                            | 
                                
                                    AttributeExpression
                                
                             | 
                            Represents an attribute access (accessing the field of a class) such as the expression "foo. | 
                        
                            | 
                                
                                    BinaryExpression
                                
                             | 
                            Represents two expressions and an operation | 
                        
                            | 
                                
                                    BitwiseNegationExpression
                                
                             | 
                             | 
                        
                            | 
                                
                                    BooleanExpression
                                
                             | 
                            Represents a boolean expression | 
                        
                            | 
                                
                                    CastExpression
                                
                             | 
                            Represents a typecast expression. | 
                        
                            | 
                                
                                    ClassExpression
                                
                             | 
                            Represents access to a Java/Groovy class in an expression, such
 as when invoking a static method or accessing a static type | 
                        
                            | 
                                
                                    ClosureExpression
                                
                             | 
                            Represents a closure expression such as { statement }
 or { i -> statement } or { i, x, String y ->  statement } | 
                        
                            | 
                                
                                    ClosureListExpression
                                
                             | 
                            This class represents a list of expressions used to
 create closures.  | 
                        
                            | 
                                
                                    ConstantExpression
                                
                             | 
                            Represents a constant expression such as null, true, false. | 
                        
                            | 
                                
                                    ConstructorCallExpression
                                
                             | 
                            A constructor call. | 
                        
                            | 
                                
                                    DeclarationExpression
                                
                             | 
                            Represents one or more local variables.  | 
                        
                            | 
                                
                                    ElvisOperatorExpression
                                
                             | 
                            Represents a short ternary expression x ? | 
                        
                            | 
                                
                                    EmptyExpression
                                
                             | 
                            Placeholder for an empty expression.  | 
                        
                            | 
                                
                                    Expression
                                
                             | 
                            Base class for any expression. | 
                        
                            | 
                                
                                    FieldExpression
                                
                             | 
                            Represents a field access such as the expression "this.foo". | 
                        
                            | 
                                
                                    GStringExpression
                                
                             | 
                            Represents a String expression which contains embedded values inside
 it such as "hello there ${user} how are you" which is expanded lazily | 
                        
                            | 
                                
                                    LambdaExpression
                                
                             | 
                            Represents a lambda expression such as one of these:
 
 e -> e * 2
 (x, y) -> x + y
 (x, y) -> { x + y 
 (int x, int y) -> { x + y }
 }
   | 
                        
                            | 
                                
                                    ListExpression
                                
                             | 
                            Represents a list expression [1, 2, 3] which creates a mutable List | 
                        
                            | 
                                
                                    MapEntryExpression
                                
                             | 
                            Represents an entry inside a map expression such as 1 : 2 or 'foo' : 'bar'. | 
                        
                            | 
                                
                                    MapExpression
                                
                             | 
                            Represents a map expression [1 : 2, "a" : "b", x : y] which creates a mutable Map | 
                        
                            | 
                                
                                    MethodCallExpression
                                
                             | 
                            A method call on an object or class. | 
                        
                            | 
                                
                                    MethodPointerExpression
                                
                             | 
                            Represents a method pointer on an object such as
 {- code:
 - foo.
    | 
                        
                            | 
                                
                                    MethodReferenceExpression
                                
                             | 
                            Represents a method reference or a constructor reference,
 e.g.  | 
                        
                            | 
                                
                                    NamedArgumentListExpression
                                
                             | 
                            Represents one or more arguments being passed into a method by name | 
                        
                            | 
                                
                                    NotExpression
                                
                             | 
                             | 
                        
                            | 
                                
                                    PostfixExpression
                                
                             | 
                            Represents a postfix expression like foo++ or bar++ | 
                        
                            | 
                                
                                    PrefixExpression
                                
                             | 
                            Represents a prefix expression like ++foo or --bar | 
                        
                            | 
                                
                                    PropertyExpression
                                
                             | 
                            Represents a property access such as the expression "foo.bar". | 
                        
                            | 
                                
                                    RangeExpression
                                
                             | 
                            Represents a range expression such as for iterating.
  | 
                        
                            | 
                                
                                    SpreadExpression
                                
                             | 
                            Represents a spread expression *x in the list expression [1, *x, 2]. | 
                        
                            | 
                                
                                    SpreadMapExpression
                                
                             | 
                            Represents a spread map expression *:m
 in the map expression [1, *:m, 2, "c":100]
 or in the method invoke expression func(1, *:m, 2, "c":100). | 
                        
                            | 
                                
                                    StaticMethodCallExpression
                                
                             | 
                            A static method call on a class | 
                        
                            | 
                                
                                    TernaryExpression
                                
                             | 
                            Represents a ternary expression (booleanExpression) ?  | 
                        
                            | 
                                
                                    TupleExpression
                                
                             | 
                             | 
                        
                            | 
                                
                                    UnaryMinusExpression
                                
                             | 
                             | 
                        
                            | 
                                
                                    UnaryPlusExpression
                                
                             | 
                             | 
                        
                            | 
                                
                                    VariableExpression
                                
                             | 
                            Represents a local variable name, the simplest form of expression. e.g. "foo". |