Package org.codehaus.groovy.ast

## Class ClassNode

- java.lang.Object
- - org.codehaus.groovy.ast.ASTNode
  - - org.codehaus.groovy.ast.AnnotatedNode
    - - org.codehaus.groovy.ast.ClassNode

- All Implemented Interfaces:
    `GroovydocHolder<AnnotatedNode>`, `NodeMetaDataHandler`, `org.objectweb.asm.Opcodes`
  Direct Known Subclasses:
    `CompileUnit.ConstructedOuterNestedClassNode`, `DecompiledClassNode`, `InnerClassNode`, `MixinNode`, `WideningCategories.LowestUpperBoundClassNode`

      public class ClassNode
      extends AnnotatedNode
      implements org.objectweb.asm.Opcodes

  Represents a class in the AST.

  A ClassNode should be created using the methods in ClassHelper. This ClassNode may be used to represent a class declaration or any other type. This class uses a proxy mechanism allowing to create a class for a plain name at AST creation time. In another phase of the compiler the real ClassNode for the plain name may be found. To avoid the need of exchanging this ClassNode with an instance of the correct ClassNode the correct ClassNode is set as redirect. Most method calls are then redirected to that ClassNode.

  There are three types of ClassNodes:

  1. Primary ClassNodes:
     A primary ClassNode is one where we have a source representation which is to be compiled by Groovy and which we have an AST for. The groovy compiler will output one class for each such ClassNode that passes through AsmBytecodeGenerator... not more, not less. That means for example Closures become such ClassNodes too at some point.
  2. ClassNodes create through different sources (typically created from a java.lang.reflect.Class object):
     The compiler will not output classes from these, the methods usually do not contain bodies. These kind of ClassNodes will be used in different checks, but not checks that work on the method bodies. For example if such a ClassNode is a super class to a primary ClassNode, then the abstract method test and others will be done with data based on these. Theoretically it is also possible to mix both (1 and 2) kind of classes in a hierarchy, but this probably works only in the newest Groovy versions. Such ClassNodes normally have to isResolved() returning true without having a redirect.In the Groovy compiler the only version of this, that exists, is a ClassNode created through a Class instance
  3. Labels:
     ClassNodes created through ClassHelper.makeWithoutCaching. They are place holders, its redirect points to the real structure, which can be a label too, but following all redirects it should end with a ClassNode from one of the other two categories. If ResolveVisitor finds such a node, it tries to set the redirects. Any such label created after ResolveVisitor has done its work needs to have a redirect pointing to case 1 or 2. If not the compiler may react strange... this can be considered as a kind of dangling pointer.
  Note: the redirect mechanism is only allowed for classes that are not primary ClassNodes. Typically this is done for classes created by name only. The redirect itself can be any type of ClassNode.

  To describe generic type signature see `getGenericsTypes()` and `setGenericsTypes(GenericsType[])`. These methods are not proxied, they describe the type signature used at the point of declaration or the type signatures provided by the class. If the type signatures provided by the class are needed, then a call to `redirect()` will help.

  See Also:
    `ClassHelper`

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `protected Class` | `clazz` |
    `static ClassNode[]` | `EMPTY_ARRAY` |
    `protected List<InnerClassNode>` | `innerClasses` |
    `protected boolean` | `isPrimaryNode` |
    `protected Object` | `lazyInitLock` |
    `static ClassNode` | `SUPER` |
    `static ClassNode` | `THIS` |

    - ### Fields inherited from interface groovy.lang.groovydoc.GroovydocHolder

      `DOC_COMMENT`

    - ### Fields inherited from interface org.objectweb.asm.Opcodes

      `AALOAD, AASTORE, ACC_ABSTRACT, ACC_ANNOTATION, ACC_BRIDGE, ACC_DEPRECATED, ACC_ENUM, ACC_FINAL, ACC_INTERFACE, ACC_MANDATED, ACC_MODULE, ACC_NATIVE, ACC_OPEN, ACC_PRIVATE, ACC_PROTECTED, ACC_PUBLIC, ACC_RECORD, ACC_STATIC, ACC_STATIC_PHASE, ACC_STRICT, ACC_SUPER, ACC_SYNCHRONIZED, ACC_SYNTHETIC, ACC_TRANSIENT, ACC_TRANSITIVE, ACC_VARARGS, ACC_VOLATILE, ACONST_NULL, ALOAD, ANEWARRAY, ARETURN, ARRAYLENGTH, ASM4, ASM5, ASM6, ASM7, ASM8, ASM9_EXPERIMENTAL, ASTORE, ATHROW, BALOAD, BASTORE, BIPUSH, CALOAD, CASTORE, CHECKCAST, D2F, D2I, D2L, DADD, DALOAD, DASTORE, DCMPG, DCMPL, DCONST_0, DCONST_1, DDIV, DLOAD, DMUL, DNEG, DOUBLE, DREM, DRETURN, DSTORE, DSUB, DUP, DUP_X1, DUP_X2, DUP2, DUP2_X1, DUP2_X2, F_APPEND, F_CHOP, F_FULL, F_NEW, F_SAME, F_SAME1, F2D, F2I, F2L, FADD, FALOAD, FASTORE, FCMPG, FCMPL, FCONST_0, FCONST_1, FCONST_2, FDIV, FLOAD, FLOAT, FMUL, FNEG, FREM, FRETURN, FSTORE, FSUB, GETFIELD, GETSTATIC, GOTO, H_GETFIELD, H_GETSTATIC, H_INVOKEINTERFACE, H_INVOKESPECIAL, H_INVOKESTATIC, H_INVOKEVIRTUAL, H_NEWINVOKESPECIAL, H_PUTFIELD, H_PUTSTATIC, I2B, I2C, I2D, I2F, I2L, I2S, IADD, IALOAD, IAND, IASTORE, ICONST_0, ICONST_1, ICONST_2, ICONST_3, ICONST_4, ICONST_5, ICONST_M1, IDIV, IF_ACMPEQ, IF_ACMPNE, IF_ICMPEQ, IF_ICMPGE, IF_ICMPGT, IF_ICMPLE, IF_ICMPLT, IF_ICMPNE, IFEQ, IFGE, IFGT, IFLE, IFLT, IFNE, IFNONNULL, IFNULL, IINC, ILOAD, IMUL, INEG, INSTANCEOF, INTEGER, INVOKEDYNAMIC, INVOKEINTERFACE, INVOKESPECIAL, INVOKESTATIC, INVOKEVIRTUAL, IOR, IREM, IRETURN, ISHL, ISHR, ISTORE, ISUB, IUSHR, IXOR, JSR, L2D, L2F, L2I, LADD, LALOAD, LAND, LASTORE, LCMP, LCONST_0, LCONST_1, LDC, LDIV, LLOAD, LMUL, LNEG, LONG, LOOKUPSWITCH, LOR, LREM, LRETURN, LSHL, LSHR, LSTORE, LSUB, LUSHR, LXOR, MONITORENTER, MONITOREXIT, MULTIANEWARRAY, NEW, NEWARRAY, NOP, NULL, POP, POP2, PUTFIELD, PUTSTATIC, RET, RETURN, SALOAD, SASTORE, SIPUSH, SOURCE_DEPRECATED, SOURCE_MASK, SWAP, T_BOOLEAN, T_BYTE, T_CHAR, T_DOUBLE, T_FLOAT, T_INT, T_LONG, T_SHORT, TABLESWITCH, TOP, UNINITIALIZED_THIS, V_PREVIEW, V1_1, V1_2, V1_3, V1_4, V1_5, V1_6, V1_7, V1_8, V10, V11, V12, V13, V14, V15, V9`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `ClassNode​(Class<?> c)` | Creates a non-primary `ClassNode` from a real class.
    `ClassNode​(String name, int modifiers, ClassNode superClass)` |
    `ClassNode​(String name, int modifiers, ClassNode superClass, ClassNode[] interfaces, MixinNode[] mixins)` |

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `ConstructorNode` | `addConstructor​(int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code)` |
    `void` | `addConstructor​(ConstructorNode node)` |
    `FieldNode` | `addField​(String name, int modifiers, ClassNode type, Expression initialValue)` |
    `void` | `addField​(FieldNode node)` |
    `FieldNode` | `addFieldFirst​(String name, int modifiers, ClassNode type, Expression initialValue)` |
    `void` | `addFieldFirst​(FieldNode node)` |
    `void` | `addInterface​(ClassNode type)` |
    `MethodNode` | `addMethod​(String name, int modifiers, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code)` | If a method with the given name and parameters is already defined then it is returned otherwise the given method is added to this node.
    `void` | `addMethod​(MethodNode node)` |
    `void` | `addMixin​(MixinNode mixin)` |
    `void` | `addObjectInitializerStatements​(Statement statements)` | Adds a statement to the object initializer.
    `PropertyNode` | `addProperty​(String name, int modifiers, ClassNode type, Expression initialValueExpression, Statement getterBlock, Statement setterBlock)` |
    `void` | `addProperty​(PropertyNode node)` |
    `void` | `addStaticInitializerStatements​(List<Statement> staticStatements, boolean fieldInit)` |
    `MethodNode` | `addSyntheticMethod​(String name, int modifiers, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code)` | Adds a synthetic method as part of the compilation process.
    `void` | `addTransform​(Class<? extends ASTTransformation> transform, ASTNode node)` |
    `GenericsType` | `asGenericsType()` |
    `boolean` | `declaresAnyInterfaces​(ClassNode... classNodes)` |
    `boolean` | `declaresInterface​(ClassNode classNode)` |
    `boolean` | `equals​(Object that)` |
    `List<MethodNode>` | `getAbstractMethods()` |
    `List<MethodNode>` | `getAllDeclaredMethods()` |
    `Set<ClassNode>` | `getAllInterfaces()` |
    `List<AnnotationNode>` | `getAnnotations()` |
    `List<AnnotationNode>` | `getAnnotations​(ClassNode type)` |
    `CompileUnit` | `getCompileUnit()` |
    `ClassNode` | `getComponentType()` |
    `ConstructorNode` | `getDeclaredConstructor​(Parameter[] parameters)` |
    `List<ConstructorNode>` | `getDeclaredConstructors()` |
    `FieldNode` | `getDeclaredField​(String name)` | Finds a field matching the given name in this class.
    `MethodNode` | `getDeclaredMethod​(String name, Parameter[] parameters)` | Finds a method matching the given name and parameters in this class.
    `List<MethodNode>` | `getDeclaredMethods​(String name)` | This methods returns a list of all methods of the given name defined in the current class
    `Map<String,​MethodNode>` | `getDeclaredMethodsMap()` |
    `MethodNode` | `getEnclosingMethod()` |
    `FieldNode` | `getField​(String name)` | Finds a field matching the given name in this class or a parent class.
    `Map<String,​FieldNode>` | `getFieldIndex()` |
    `List<FieldNode>` | `getFields()` |
    `GenericsType[]` | `getGenericsTypes()` |
    `MethodNode` | `getGetterMethod​(String getterName)` |
    `MethodNode` | `getGetterMethod​(String getterName, boolean searchSuperClasses)` |
    `Iterator<InnerClassNode>` | `getInnerClasses()` |
    `ClassNode[]` | `getInterfaces()` |
    `MethodNode` | `getMethod​(String name, Parameter[] parameters)` | Finds a method matching the given name and parameters in this class or any parent class.
    `List<MethodNode>` | `getMethods()` |
    `List<MethodNode>` | `getMethods​(String name)` | This methods creates a list of all methods with this name of the current class and of all super classes
    `MixinNode[]` | `getMixins()` |
    `int` | `getModifiers()` |
    `ModuleNode` | `getModule()` |
    `String` | `getName()` |
    `String` | `getNameWithoutPackage()` |
    `List<Statement>` | `getObjectInitializerStatements()` |
    `ClassNode` | `getOuterClass()` |
    `List<ClassNode>` | `getOuterClasses()` |
    `FieldNode` | `getOuterField​(String name)` |
    `PackageNode` | `getPackage()` |
    `String` | `getPackageName()` |
    `ClassNode` | `getPlainNodeReference()` |
    `List<PropertyNode>` | `getProperties()` |
    `PropertyNode` | `getProperty​(String name)` |
    `MethodNode` | `getSetterMethod​(String setterName)` |
    `MethodNode` | `getSetterMethod​(String setterName, boolean voidOnly)` |
    `ClassNode` | `getSuperClass()` |
    `String` | `getText()` |
    `Map<Class<? extends ASTTransformation>,​Set<ASTNode>>` | `getTransforms​(CompilePhase phase)` |
    `Class` | `getTypeClass()` | Returns the concrete class this classnode relates to.
    `ClassNode[]` | `getUnresolvedInterfaces()` |
    `ClassNode[]` | `getUnresolvedInterfaces​(boolean useRedirect)` |
    `String` | `getUnresolvedName()` |
    `ClassNode` | `getUnresolvedSuperClass()` |
    `ClassNode` | `getUnresolvedSuperClass​(boolean useRedirect)` |
    `boolean` | `hasDeclaredMethod​(String name, Parameter[] parameters)` |
    `int` | `hashCode()` |
    `boolean` | `hasMethod​(String name, Parameter[] parameters)` |
    `boolean` | `hasPackageName()` |
    `boolean` | `hasPossibleMethod​(String name, Expression arguments)` | Returns true if the given method has a possibly matching instance method with the given name and arguments.
    `boolean` | `hasPossibleStaticMethod​(String name, Expression arguments)` | Checks if the given method has a possibly matching static method with the given name and arguments.
    `boolean` | `hasProperty​(String name)` |
    `boolean` | `implementsAnyInterfaces​(ClassNode... classNodes)` |
    `boolean` | `implementsInterface​(ClassNode classNode)` |
    `boolean` | `isAbstract()` |
    `boolean` | `isAnnotated()` |
    `boolean` | `isAnnotationDefinition()` |
    `boolean` | `isArray()` |
    `boolean` | `isDerivedFrom​(ClassNode type)` |
    `boolean` | `isDerivedFromGroovyObject()` |
    `boolean` | `isEnum()` |
    `boolean` | `isGenericsPlaceHolder()` |
    `boolean` | `isInterface()` |
    `boolean` | `isPrimaryClassNode()` |
    `boolean` | `isRedirectNode()` |
    `boolean` | `isResolved()` |
    `boolean` | `isScript()` |
    `boolean` | `isScriptBody()` |
    `boolean` | `isStaticClass()` | Is this class declared in a static method (such as a closure / inner class declared in a static method)
    `boolean` | `isSyntheticPublic()` | Indicates that this class has been "promoted" to public by Groovy when in fact there was no public modifier explicitly in the source code.
    `boolean` | `isUsingGenerics()` |
    `ClassNode` | `makeArray()` | Returns a `ClassNode` representing an array of the type represented by this.
    `protected boolean` | `parametersEqual​(Parameter[] a, Parameter[] b)` |
    `void` | `positionStmtsAfterEnumInitStmts​(List<Statement> staticFieldStatements)` |
    `ClassNode` | `redirect()` | Returns the `ClassNode` this node is a proxy for or the node itself.
    `void` | `removeConstructor​(ConstructorNode node)` |
    `void` | `removeField​(String oldName)` |
    `void` | `removeMethod​(MethodNode node)` |
    `void` | `renameField​(String oldName, String newName)` |
    `void` | `setAnnotated​(boolean annotated)` | Marks if the current class uses annotations or not.
    `protected void` | `setCompileUnit​(CompileUnit cu)` |
    `void` | `setEnclosingMethod​(MethodNode enclosingMethod)` |
    `void` | `setGenericsPlaceHolder​(boolean placeholder)` |
    `void` | `setGenericsTypes​(GenericsType[] genericsTypes)` |
    `void` | `setInterfaces​(ClassNode[] interfaces)` |
    `void` | `setMixins​(MixinNode[] mixins)` |
    `void` | `setModifiers​(int modifiers)` |
    `void` | `setModule​(ModuleNode module)` |
    `String` | `setName​(String name)` |
    `void` | `setRedirect​(ClassNode node)` | Sets this instance as proxy for the given `ClassNode`.
    `void` | `setScript​(boolean script)` |
    `void` | `setScriptBody​(boolean scriptBody)` |
    `void` | `setStaticClass​(boolean staticClass)` |
    `void` | `setSuperClass​(ClassNode superClass)` | Sets the superclass of this `ClassNode`.
    `void` | `setSyntheticPublic​(boolean syntheticPublic)` |
    `void` | `setUnresolvedSuperClass​(ClassNode superClass)` |
    `void` | `setUsingGenerics​(boolean usesGenerics)` |
    `String` | `toString()` |
    `String` | `toString​(boolean showRedirect)` |
    `MethodNode` | `tryFindPossibleMethod​(String name, Expression arguments)` |
    `void` | `visitContents​(GroovyClassVisitor visitor)` |

    - ### Methods inherited from class org.codehaus.groovy.ast.AnnotatedNode

      `addAnnotation, addAnnotations, getDeclaringClass, getGroovydoc, getInstance, hasNoRealSourcePosition, isSynthetic, setDeclaringClass, setHasNoRealSourcePosition, setSynthetic`

    - ### Methods inherited from class org.codehaus.groovy.ast.ASTNode

      `copyNodeMetaData, getColumnNumber, getLastColumnNumber, getLastLineNumber, getLineNumber, getMetaDataMap, setColumnNumber, setLastColumnNumber, setLastLineNumber, setLineNumber, setMetaDataMap, setSourcePosition, visit`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface org.codehaus.groovy.ast.NodeMetaDataHandler

      `copyNodeMetaData, getNodeMetaData, getNodeMetaData, getNodeMetaData, putNodeMetaData, removeNodeMetaData, setNodeMetaData`

- - ### Field Detail

    - #### EMPTY_ARRAY

          public static final ClassNode[] EMPTY_ARRAY

    - #### THIS

          public static final ClassNode THIS

    - #### SUPER

          public static final ClassNode SUPER

    - #### isPrimaryNode

          protected boolean isPrimaryNode

    - #### innerClasses

          protected List<InnerClassNode> innerClasses

    - #### lazyInitLock

          protected final Object lazyInitLock

    - #### clazz

          protected Class clazz

  - ### Constructor Detail

    - #### ClassNode

          public ClassNode​(Class<?> c)

      Creates a non-primary `ClassNode` from a real class.

    - #### ClassNode

          public ClassNode​(String name,
                           int modifiers,
                           ClassNode superClass)

      Parameters:
        `name` - the fully-qualified name of the class
        `modifiers` - the modifiers; see `Opcodes`
        `superClass` - the base class; use "java.lang.Object" if no direct base class

    - #### ClassNode

          public ClassNode​(String name,
                           int modifiers,
                           ClassNode superClass,
                           ClassNode[] interfaces,
                           MixinNode[] mixins)

      Parameters:
        `name` - the fully-qualified name of the class
        `modifiers` - the modifiers; see `Opcodes`
        `superClass` - the base class; use "java.lang.Object" if no direct base class
        `interfaces` - the interfaces for this class
        `mixins` - the mixins for this class

  - ### Method Detail

    - #### redirect

          public ClassNode redirect()

      Returns the `ClassNode` this node is a proxy for or the node itself.

    - #### isRedirectNode

          public boolean isRedirectNode()

    - #### setRedirect

          public void setRedirect​(ClassNode node)

      Sets this instance as proxy for the given `ClassNode`.
      Parameters:
        `node` - the class to redirect to; if `null` the redirect is removed

    - #### makeArray

          public ClassNode makeArray()

      Returns a `ClassNode` representing an array of the type represented by this.

    - #### isPrimaryClassNode

          public boolean isPrimaryClassNode()

      Returns:
        `true` if this instance is a primary `ClassNode`

    - #### getEnclosingMethod

          public MethodNode getEnclosingMethod()

    - #### setEnclosingMethod

          public void setEnclosingMethod​(MethodNode enclosingMethod)

    - #### isSyntheticPublic

          public boolean isSyntheticPublic()

      Indicates that this class has been "promoted" to public by Groovy when in fact there was no public modifier explicitly in the source code. That is, it remembers that it has applied Groovy's "public classes by default" rule. This property is typically only of interest to AST transform writers.
      Returns:
        `true` if node is public but had no explicit public modifier

    - #### setSyntheticPublic

          public void setSyntheticPublic​(boolean syntheticPublic)

    - #### setSuperClass

          public void setSuperClass​(ClassNode superClass)

      Sets the superclass of this `ClassNode`.

    - #### getFields

          public List<FieldNode> getFields()

      Returns:
        the fields associated with this `ClassNode`

    - #### getInterfaces

          public ClassNode[] getInterfaces()

      Returns:
        the interfaces implemented by this `ClassNode`

    - #### setInterfaces

          public void setInterfaces​(ClassNode[] interfaces)

    - #### getMixins

          public MixinNode[] getMixins()

      Returns:
        the mixins associated with this `ClassNode`

    - #### setMixins

          public void setMixins​(MixinNode[] mixins)

    - #### getMethods

          public List<MethodNode> getMethods()

      Returns:
        the methods associated with this `ClassNode`

    - #### getAbstractMethods

          public List<MethodNode> getAbstractMethods()

      Returns:
        the abstract methods associated with this `ClassNode`

    - #### getAllDeclaredMethods

          public List<MethodNode> getAllDeclaredMethods()

    - #### getAllInterfaces

          public Set<ClassNode> getAllInterfaces()

    - #### getDeclaredMethodsMap

          public Map<String,​MethodNode> getDeclaredMethodsMap()

    - #### getName

          public String getName()

    - #### getUnresolvedName

          public String getUnresolvedName()

    - #### setName

          public String setName​(String name)

    - #### getModifiers

          public int getModifiers()

    - #### setModifiers

          public void setModifiers​(int modifiers)

    - #### getProperties

          public List<PropertyNode> getProperties()

    - #### getDeclaredConstructors

          public List<ConstructorNode> getDeclaredConstructors()

    - #### getDeclaredConstructor

          public ConstructorNode getDeclaredConstructor​(Parameter[] parameters)

      Returns:
        the constructor matching the given parameters or `null`

    - #### removeConstructor

          public void removeConstructor​(ConstructorNode node)

    - #### getModule

          public ModuleNode getModule()

    - #### getPackage

          public PackageNode getPackage()

    - #### setModule

          public void setModule​(ModuleNode module)

    - #### addField

          public void addField​(FieldNode node)

    - #### addFieldFirst

          public void addFieldFirst​(FieldNode node)

    - #### getFieldIndex

          public Map<String,​FieldNode> getFieldIndex()

    - #### addProperty

          public void addProperty​(PropertyNode node)

    - #### addProperty

          public PropertyNode addProperty​(String name,
                                          int modifiers,
                                          ClassNode type,
                                          Expression initialValueExpression,
                                          Statement getterBlock,
                                          Statement setterBlock)

    - #### hasProperty

          public boolean hasProperty​(String name)

    - #### getProperty

          public PropertyNode getProperty​(String name)

    - #### addConstructor

          public void addConstructor​(ConstructorNode node)

    - #### addConstructor

          public ConstructorNode addConstructor​(int modifiers,
                                                Parameter[] parameters,
                                                ClassNode[] exceptions,
                                                Statement code)

    - #### addMethod

          public void addMethod​(MethodNode node)

    - #### removeMethod

          public void removeMethod​(MethodNode node)

    - #### addMethod

          public MethodNode addMethod​(String name,
                                      int modifiers,
                                      ClassNode returnType,
                                      Parameter[] parameters,
                                      ClassNode[] exceptions,
                                      Statement code)

      If a method with the given name and parameters is already defined then it is returned otherwise the given method is added to this node. This method is useful for default method adding like getProperty() or invokeMethod() where there may already be a method defined in a class and so the default implementations should not be added if already present.

    - #### hasDeclaredMethod

          public boolean hasDeclaredMethod​(String name,
                                           Parameter[] parameters)

      See Also:
        `getDeclaredMethod(String, Parameter[])`

    - #### hasMethod

          public boolean hasMethod​(String name,
                                   Parameter[] parameters)

      See Also:
        `getMethod(String, Parameter[])`

    - #### addSyntheticMethod

          public MethodNode addSyntheticMethod​(String name,
                                               int modifiers,
                                               ClassNode returnType,
                                               Parameter[] parameters,
                                               ClassNode[] exceptions,
                                               Statement code)

      Adds a synthetic method as part of the compilation process.

    - #### addField

          public FieldNode addField​(String name,
                                    int modifiers,
                                    ClassNode type,
                                    Expression initialValue)

    - #### addFieldFirst

          public FieldNode addFieldFirst​(String name,
                                         int modifiers,
                                         ClassNode type,
                                         Expression initialValue)

    - #### addInterface

          public void addInterface​(ClassNode type)

    - #### equals

          public boolean equals​(Object that)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `ASTNode`

    - #### addMixin

          public void addMixin​(MixinNode mixin)

    - #### getDeclaredField

          public FieldNode getDeclaredField​(String name)

      Finds a field matching the given name in this class.
      Parameters:
        `name` - the name of the field of interest
      Returns:
        the method matching the given name and parameters or null

    - #### getField

          public FieldNode getField​(String name)

      Finds a field matching the given name in this class or a parent class.
      Parameters:
        `name` - the name of the field of interest
      Returns:
        the method matching the given name and parameters or null

    - #### getOuterField

          public FieldNode getOuterField​(String name)

      Returns:
        the field on the outer class or `null` if this is not an inner class

    - #### getOuterClass

          public ClassNode getOuterClass()

    - #### getOuterClasses

          public List<ClassNode> getOuterClasses()

    - #### addObjectInitializerStatements

          public void addObjectInitializerStatements​(Statement statements)

      Adds a statement to the object initializer.
      Parameters:
        `statements` - the statement to be added

    - #### getObjectInitializerStatements

          public List<Statement> getObjectInitializerStatements()

    - #### addStaticInitializerStatements

          public void addStaticInitializerStatements​(List<Statement> staticStatements,
                                                     boolean fieldInit)

    - #### positionStmtsAfterEnumInitStmts

          public void positionStmtsAfterEnumInitStmts​(List<Statement> staticFieldStatements)

    - #### getDeclaredMethods

          public List<MethodNode> getDeclaredMethods​(String name)

      This methods returns a list of all methods of the given name defined in the current class
      Returns:
        the method list
      See Also:
        `getMethods(String)`

    - #### getMethods

          public List<MethodNode> getMethods​(String name)

      This methods creates a list of all methods with this name of the current class and of all super classes
      Returns:
        the methods list
      See Also:
        `getDeclaredMethods(String)`

    - #### getDeclaredMethod

          public MethodNode getDeclaredMethod​(String name,
                                              Parameter[] parameters)

      Finds a method matching the given name and parameters in this class.
      Returns:
        the method matching the given name and parameters or null

    - #### getMethod

          public MethodNode getMethod​(String name,
                                      Parameter[] parameters)

      Finds a method matching the given name and parameters in this class or any parent class.
      Returns:
        the method matching the given name and parameters or null

    - #### isDerivedFrom

          public boolean isDerivedFrom​(ClassNode type)

      Parameters:
        `type` - the ClassNode of interest
      Returns:
        true if this node is derived from the given ClassNode

    - #### isDerivedFromGroovyObject

          public boolean isDerivedFromGroovyObject()

      Returns:
        `true` if this type implements `GroovyObject`

    - #### implementsAnyInterfaces

          public boolean implementsAnyInterfaces​(ClassNode... classNodes)

      Parameters:
        `classNodes` - the class nodes for the interfaces
      Returns:
        `true` if this type implements any of the given interfaces

    - #### implementsInterface

          public boolean implementsInterface​(ClassNode classNode)

      Parameters:
        `classNode` - the class node for the interface
      Returns:
        `true` if this type implements the given interface

    - #### declaresAnyInterfaces

          public boolean declaresAnyInterfaces​(ClassNode... classNodes)

      Parameters:
        `classNodes` - the class nodes for the interfaces
      Returns:
        `true` if this type declares that it implements any of the given interfaces or if one of its interfaces extends directly/indirectly any of the given interfaces

    - #### declaresInterface

          public boolean declaresInterface​(ClassNode classNode)

      Parameters:
        `classNode` - the class node for the interface
      Returns:
        `true` if this class declares that it implements the given interface or if one of its interfaces extends directly/indirectly the interface NOTE: Doesn't consider an interface to implement itself. I think this is intended to be called on ClassNodes representing classes, not interfaces.

    - #### getSuperClass

          public ClassNode getSuperClass()

      Returns:
        the `ClassNode` of the super class of this type

    - #### getUnresolvedSuperClass

          public ClassNode getUnresolvedSuperClass()

    - #### getUnresolvedSuperClass

          public ClassNode getUnresolvedSuperClass​(boolean useRedirect)

    - #### setUnresolvedSuperClass

          public void setUnresolvedSuperClass​(ClassNode superClass)

    - #### getUnresolvedInterfaces

          public ClassNode[] getUnresolvedInterfaces()

    - #### getUnresolvedInterfaces

          public ClassNode[] getUnresolvedInterfaces​(boolean useRedirect)

    - #### getCompileUnit

          public CompileUnit getCompileUnit()

    - #### setCompileUnit

          protected void setCompileUnit​(CompileUnit cu)

    - #### parametersEqual

          protected boolean parametersEqual​(Parameter[] a,
                                            Parameter[] b)

      Returns:
        `true` if the two arrays are of the same size and have the same contents

    - #### getPackageName

          public String getPackageName()

    - #### getNameWithoutPackage

          public String getNameWithoutPackage()

    - #### visitContents

          public void visitContents​(GroovyClassVisitor visitor)

    - #### getGetterMethod

          public MethodNode getGetterMethod​(String getterName)

    - #### getGetterMethod

          public MethodNode getGetterMethod​(String getterName,
                                            boolean searchSuperClasses)

    - #### getSetterMethod

          public MethodNode getSetterMethod​(String setterName)

    - #### getSetterMethod

          public MethodNode getSetterMethod​(String setterName,
                                            boolean voidOnly)

    - #### isStaticClass

          public boolean isStaticClass()

      Is this class declared in a static method (such as a closure / inner class declared in a static method)

    - #### setStaticClass

          public void setStaticClass​(boolean staticClass)

    - #### isScriptBody

          public boolean isScriptBody()

      Returns:
        `true` if this inner class or closure was declared inside a script body

    - #### setScriptBody

          public void setScriptBody​(boolean scriptBody)

    - #### isScript

          public boolean isScript()

    - #### setScript

          public void setScript​(boolean script)

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

    - #### toString

          public String toString​(boolean showRedirect)

    - #### hasPossibleMethod

          public boolean hasPossibleMethod​(String name,
                                           Expression arguments)

      Returns true if the given method has a possibly matching instance method with the given name and arguments.
      Parameters:
        `name` - the name of the method of interest
        `arguments` - the arguments to match against
      Returns:
        true if a matching method was found

    - #### tryFindPossibleMethod

          public MethodNode tryFindPossibleMethod​(String name,
                                                  Expression arguments)

    - #### hasPossibleStaticMethod

          public boolean hasPossibleStaticMethod​(String name,
                                                 Expression arguments)

      Checks if the given method has a possibly matching static method with the given name and arguments.
      Parameters:
        `name` - the name of the method of interest
        `arguments` - the arguments to match against
      Returns:
        `true` if a matching method was found

    - #### isInterface

          public boolean isInterface()

    - #### isAbstract

          public boolean isAbstract()

    - #### isResolved

          public boolean isResolved()

    - #### isArray

          public boolean isArray()

    - #### getComponentType

          public ClassNode getComponentType()

    - #### getTypeClass

          public Class getTypeClass()

      Returns the concrete class this classnode relates to. However, this method is inherently unsafe as it may return null depending on the compile phase you are using. AST transformations should never use this method directly, but rather obtain a new class node using `getPlainNodeReference()`.
      Returns:
        the class this classnode relates to. May return null.

    - #### hasPackageName

          public boolean hasPackageName()

    - #### setAnnotated

          public void setAnnotated​(boolean annotated)

      Marks if the current class uses annotations or not.

    - #### isAnnotated

          public boolean isAnnotated()

    - #### asGenericsType

          public GenericsType asGenericsType()

    - #### getGenericsTypes

          public GenericsType[] getGenericsTypes()

    - #### setGenericsTypes

          public void setGenericsTypes​(GenericsType[] genericsTypes)

    - #### setGenericsPlaceHolder

          public void setGenericsPlaceHolder​(boolean placeholder)

    - #### isGenericsPlaceHolder

          public boolean isGenericsPlaceHolder()

    - #### isUsingGenerics

          public boolean isUsingGenerics()

    - #### setUsingGenerics

          public void setUsingGenerics​(boolean usesGenerics)

    - #### getPlainNodeReference

          public ClassNode getPlainNodeReference()

    - #### isAnnotationDefinition

          public boolean isAnnotationDefinition()

    - #### getAnnotations

          public List<AnnotationNode> getAnnotations()

      Overrides:
        `getAnnotations` in class `AnnotatedNode`

    - #### getAnnotations

          public List<AnnotationNode> getAnnotations​(ClassNode type)

      Overrides:
        `getAnnotations` in class `AnnotatedNode`

    - #### addTransform

          public void addTransform​(Class<? extends ASTTransformation> transform,
                                   ASTNode node)

    - #### getTransforms

          public Map<Class<? extends ASTTransformation>,​Set<ASTNode>> getTransforms​(CompilePhase phase)

    - #### renameField

          public void renameField​(String oldName,
                                  String newName)

    - #### removeField

          public void removeField​(String oldName)

    - #### isEnum

          public boolean isEnum()

    - #### getInnerClasses

          public Iterator<InnerClassNode> getInnerClasses()

      Returns:
        iterator of inner classes defined inside this one

    - #### getText

          public String getText()

      Overrides:
        `getText` in class `ASTNode`