Methods 
                        
                            | Type Params | 
                            Return Type | 
                            Name and description | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            andX(Expression lhv, Expression rhv)
  | 
                        
                        
                        
                             | 
                            static ArgumentListExpression | 
                            args(Expression... expressions)
  | 
                        
                        
                        
                             | 
                            static ArgumentListExpression | 
                            args(List<Expression> expressions)
  | 
                        
                        
                        
                             | 
                            static ArgumentListExpression | 
                            args(Parameter[] parameters)
  | 
                        
                        
                        
                             | 
                            static ArgumentListExpression | 
                            args(String... names)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            assignS(Expression target, Expression value)
  | 
                        
                        
                        
                             | 
                            static Expression | 
                            assignX(Expression target, Expression value)
  | 
                        
                        
                        
                             | 
                            static Expression | 
                            attrX(Expression oe, Expression prop)
  | 
                        
                        
                        
                             | 
                            static BlockStatement | 
                            block(VariableScope varScope, Statement... stmts)
  | 
                        
                        
                        
                             | 
                            static BlockStatement | 
                            block(VariableScope varScope, List<Statement> stmts)
  | 
                        
                        
                        
                             | 
                            static BlockStatement | 
                            block(Statement... stmts)
  | 
                        
                        
                        
                             | 
                            static MethodCallExpression | 
                            callSuperX(String methodName, Expression args)
  | 
                        
                        
                        
                             | 
                            static MethodCallExpression | 
                            callSuperX(String methodName)
  | 
                        
                        
                        
                             | 
                            static MethodCallExpression | 
                            callThisX(String methodName, Expression args)
  | 
                        
                        
                        
                             | 
                            static MethodCallExpression | 
                            callThisX(String methodName)
  | 
                        
                        
                        
                             | 
                            static MethodCallExpression | 
                            callX(Expression receiver, String methodName, Expression args)
  | 
                        
                        
                        
                             | 
                            static MethodCallExpression | 
                            callX(Expression receiver, Expression method, Expression args)
  | 
                        
                        
                        
                             | 
                            static MethodCallExpression | 
                            callX(Expression receiver, String methodName)
  | 
                        
                        
                        
                             | 
                            static StaticMethodCallExpression | 
                            callX(ClassNode receiver, String methodName, Expression args)
  | 
                        
                        
                        
                             | 
                            static StaticMethodCallExpression | 
                            callX(ClassNode receiver, String methodName)
  | 
                        
                        
                        
                             | 
                            static CastExpression | 
                            castX(ClassNode type, Expression expression)
  | 
                        
                        
                        
                             | 
                            static CastExpression | 
                            castX(ClassNode type, Expression expression, boolean ignoreAutoboxing)
  | 
                        
                        
                        
                             | 
                            static CatchStatement | 
                            catchS(Parameter variable, Statement code)
  | 
                        
                        
                        
                             | 
                            static ClassExpression | 
                            classX(ClassNode clazz)
  | 
                        
                        
                        
                             | 
                            static ClassExpression | 
                            classX(Class clazz)
  | 
                        
                        
                        
                             | 
                            static Parameter[] | 
                            cloneParams(Parameter[] source)
  | 
                        
                        
                        
                             | 
                            static ClosureExpression | 
                            closureX(Parameter[] params, Statement code)
  | 
                        
                        
                        
                             | 
                            static ClosureExpression | 
                            closureX(Statement code)
  | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            cmpX(Expression lhv, Expression rhv)
  | 
                        
                        
                        
                             | 
                            static ConstantExpression | 
                            constX(Object val)
  | 
                        
                        
                        
                             | 
                            static ConstantExpression | 
                            constX(Object val, boolean keepPrimitive)
  | 
                        
                        
                        
                             | 
                            static void | 
                            copyAnnotatedNodeAnnotations(AnnotatedNode annotatedNode, List<AnnotationNode> copied, List<AnnotationNode> notCopied) Copies all candidateAnnotations with retention policy RetentionPolicy.RUNTIME
 and RetentionPolicy.CLASS. | 
                        
                        
                        
                             | 
                            static Statement | 
                            createConstructorStatementDefault(FieldNode fNode)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            ctorSuperS(Expression args)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            ctorSuperS()
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            ctorThisS(Expression args)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            ctorThisS()
  | 
                        
                        
                        
                             | 
                            static ConstructorCallExpression | 
                            ctorX(ClassNode type, Expression args)
  | 
                        
                        
                        
                             | 
                            static ConstructorCallExpression | 
                            ctorX(ClassNode type)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            declS(Expression target, Expression init)
  | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            eqX(Expression lhv, Expression rhv)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            equalsNullX(Expression argExpr)
  | 
                        
                        
                        
                             | 
                            static FieldExpression | 
                            fieldX(FieldNode fieldNode)
  | 
                        
                        
                        
                             | 
                            static FieldExpression | 
                            fieldX(ClassNode owner, String fieldName)
  | 
                        
                        
                        
                             | 
                            static Expression | 
                            findArg(String argName)
  | 
                        
                        
                        
                             | 
                            static List<MethodNode> | 
                            getAllMethods(ClassNode type)
  | 
                        
                        
                        
                             | 
                            static List<PropertyNode> | 
                            getAllProperties(ClassNode type)
  | 
                        
                        
                        
                             | 
                            static String | 
                            getGetterName(PropertyNode pNode)
  | 
                        
                        
                        
                             | 
                            static List<FieldNode> | 
                            getInstanceNonPropertyFields(ClassNode cNode)
  | 
                        
                        
                        
                             | 
                            static List<PropertyNode> | 
                            getInstanceProperties(ClassNode cNode)
  | 
                        
                        
                        
                             | 
                            static List<FieldNode> | 
                            getInstancePropertyFields(ClassNode cNode)
  | 
                        
                        
                        
                             | 
                            static Set<ClassNode> | 
                            getInterfacesAndSuperInterfaces(ClassNode type)
  | 
                        
                        
                        
                             | 
                            static List<FieldNode> | 
                            getSuperNonPropertyFields(ClassNode cNode)
  | 
                        
                        
                        
                             | 
                            static List<FieldNode> | 
                            getSuperPropertyFields(ClassNode cNode)
  | 
                        
                        
                        
                             | 
                            static Expression | 
                            getterThisX(ClassNode annotatedNode, PropertyNode pNode) This method is similar to propX(Expression, Expression) but will make sure that if the property
 being accessed is defined inside the classnode provided as a parameter, then a getter call is generated
 instead of a field access. | 
                        
                        
                        
                             | 
                            static Expression | 
                            getterX(ClassNode annotatedNode, PropertyNode pNode) @deprecated use getterThisX instead | 
                        
                        
                        
                             | 
                            static Expression | 
                            getterX(ClassNode annotatedNode, Expression receiver, PropertyNode pNode) This method is similar to propX(Expression, Expression) but will make sure that if the property
 being accessed is defined inside the classnode provided as a parameter, then a getter call is generated
 instead of a field access. | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            hasClassX(Expression instance, ClassNode cNode)
  | 
                        
                        
                        
                             | 
                            static boolean | 
                            hasDeclaredMethod(ClassNode cNode, String name, int argsCount)
  | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            hasEqualFieldX(FieldNode fNode, Expression other)
  | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            hasEqualPropertyX(PropertyNode pNode, Expression other)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            hasSameFieldX(FieldNode fNode, Expression other)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            hasSamePropertyX(PropertyNode pNode, Expression other)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            ifElseS(Expression cond, Statement thenStmt, Statement elseStmt)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            ifS(Expression cond, Expression trueExpr)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            ifS(Expression cond, Statement trueStmt)
  | 
                        
                        
                        
                             | 
                            static Expression | 
                            indexX(Expression target, Expression value)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            isInstanceOfX(Expression objectExpression, ClassNode cNode)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            isOneX(Expression expr)
  | 
                        
                        
                        
                             | 
                            static boolean | 
                            isOrImplements(ClassNode type, ClassNode interfaceType)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            isTrueX(Expression argExpr)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            isZeroX(Expression expr)
  | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            ltX(Expression lhv, Expression rhv)
  | 
                        
                        
                        
                             | 
                            static String | 
                            makeDescriptorWithoutReturnType(MethodNode mn)
  | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            neX(Expression lhv, Expression rhv)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            notNullX(Expression argExpr)
  | 
                        
                        
                        
                             | 
                            static NotExpression | 
                            notX(Expression expr)
  | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            orX(Expression lhv, Expression rhv)
  | 
                        
                        
                        
                             | 
                            static Parameter | 
                            param(ClassNode type, String name)
  | 
                        
                        
                        
                             | 
                            static Parameter | 
                            param(ClassNode type, String name, Expression initialExpression)
  | 
                        
                        
                        
                             | 
                            static Parameter[] | 
                            params(Parameter... params)
  | 
                        
                        
                        
                             | 
                            static BinaryExpression | 
                            plusX(Expression lhv, Expression rhv)
  | 
                        
                        
                        
                             | 
                            static Expression | 
                            propX(Expression owner, String property)
  | 
                        
                        
                        
                             | 
                            static Expression | 
                            propX(Expression owner, Expression property)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            returnS(Expression expr)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            safeExpression(Expression fieldExpr, Expression expression)
  | 
                        
                        
                        
                             | 
                            static BooleanExpression | 
                            sameX(Expression self, Expression other)
  | 
                        
                        
                        
                             | 
                            static Statement | 
                            stmt(Expression expr)
  | 
                        
                        
                        
                             | 
                            static TernaryExpression | 
                            ternaryX(Expression cond, Expression trueExpr, Expression elseExpr)
  | 
                        
                        
                        
                             | 
                            static ThrowStatement | 
                            throwS(Expression expr)
  | 
                        
                        
                        
                             | 
                            static VariableExpression | 
                            varX(String name)
  | 
                        
                        
                        
                             | 
                            static VariableExpression | 
                            varX(Variable variable)
  | 
                        
                        
                        
                             | 
                            static VariableExpression | 
                            varX(String name, ClassNode type)
  |