ClassNode (Groovy 6.0.0-alpha-1)

org.codehaus.groovy.ast.ClassNode

```
public class ClassNode
extends AnnotatedNode
```
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 placeholders, 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
Modifiers	Name	Description
`static ClassNode[]`	`EMPTY_ARRAY`
`static ClassNode`	`SUPER`
`static ClassNode`	`THIS`
`protected Class<?>`	`clazz`
`protected boolean`	`isPrimaryNode`
`protected Object`	`lazyInitLock`

Constructor Summary

Constructors
Constructor and description
`ClassNode(String name, int modifiers, ClassNode superClass, ClassNode[] interfaces, MixinNode[] mixins)` Constructs a primary `ClassNode` representing a class declaration with all components.
`ClassNode(String name, int modifiers, ClassNode superClass)` Constructs a primary `ClassNode` representing a class declaration with superclass.
`ClassNode(Class<?> c)` Constructs a non-primary `ClassNode` from a real Java class.

Methods Summary

Methods
Type Params	Return Type	Name and description
	`public void`	`addConstructor(ConstructorNode node)`
	`public ConstructorNode`	`addConstructor(int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code)`
	`public void`	`addField(FieldNode node)` Adds a FieldNode to this ClassNode.
	`public FieldNode`	`addField(String name, int modifiers, ClassNode type, Expression initialValue)` Creates and adds a FieldNode to this ClassNode with the specified properties.
	`public void`	`addFieldFirst(FieldNode node)` Adds a FieldNode to this ClassNode at the beginning of the field list.
	`public FieldNode`	`addFieldFirst(String name, int modifiers, ClassNode type, Expression initialValue)` Creates and adds a FieldNode to the beginning of this ClassNode's field list with the specified properties.
	`public void`	`addInterface(ClassNode node)` Adds an interface to the list of interfaces implemented by this ClassNode.
	`public void`	`addMethod(MethodNode node)` Adds a MethodNode to this ClassNode.
	`public MethodNode`	`addMethod(String name, int modifiers, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code)` Creates and adds a MethodNode to this ClassNode with the specified properties, but only if a method with the same name and parameter signature does not already exist.
	`public void`	`addMixin(MixinNode node)`
	`public void`	`addObjectInitializerStatements(Statement statement)` Adds a statement to the object initializer.
	`public void`	`addProperty(PropertyNode node)` Adds a PropertyNode to this ClassNode.
	`public PropertyNode`	`addProperty(String name, int modifiers, ClassNode type, Expression initialValue, Statement getterBlock, Statement setterBlock)` Creates and adds a PropertyNode to this ClassNode with the specified properties, or returns an existing property with the same name if one is already present.
	`public void`	`addStaticInitializerStatements(List<Statement> statements, boolean fieldInit)`
	`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.
	`public void`	`addTransform(Class<? extends ASTTransformation> transform, ASTNode node)`
	`public void`	`addTypeAnnotation(AnnotationNode annotation)`
	`public void`	`addTypeAnnotations(List<AnnotationNode> annotations)`
	`public GenericsType`	`asGenericsType()`
	`public boolean`	`declaresAnyInterfaces(ClassNode classNodes)` Parameters: `classNodes` - the class nodes for the interfaces
	`public boolean`	`declaresInterface(ClassNode classNode)` Parameters: `classNode` - the class node for the interface
	`public boolean`	`equals(Object that)` Compares this ClassNode with another object for equality.
	`public List<MethodNode>`	`getAbstractMethods()` Returns a list of all abstract MethodNodes declared in this ClassNode.
	`public List<MethodNode>`	`getAllDeclaredMethods()` Returns all declared MethodNodes from this ClassNode and its superclasses and interfaces as a list.
	`public Set<ClassNode>`	`getAllInterfaces()`
	`public List<AnnotationNode>`	`getAnnotations()`
	`public List<AnnotationNode>`	`getAnnotations(ClassNode type)`
	`public CompileUnit`	`getCompileUnit()`
	`public ClassNode`	`getComponentType()` Returns the component type of this array ClassNode.
	`public ConstructorNode`	`getDeclaredConstructor(Parameter[] parameters)` Returns: the constructor matching the given parameters or `null`
	`public List<ConstructorNode>`	`getDeclaredConstructors()`
	`public FieldNode`	`getDeclaredField(String name)` Finds a FieldNode matching the given name declared directly in this class.
	`public MethodNode`	`getDeclaredMethod(String name, Parameter[] parameters)` Finds a MethodNode matching the given name and parameter signature declared directly in this class.
	`public List<MethodNode>`	`getDeclaredMethods(String name)` Returns a list of all MethodNodes with the given name declared directly in this class.
	`public Map<String, MethodNode>`	`getDeclaredMethodsMap()` Returns all declared MethodNodes from this ClassNode and its superclasses and interfaces.
	`public MethodNode`	`getEnclosingMethod()` Returns the enclosing MethodNode of this local inner class, or `null` if this is not a local inner class.
	`public FieldNode`	`getField(String name)` Finds a FieldNode matching the given name in this class or any of its superclasses.
	`public Map<String, FieldNode>`	`getFieldIndex()` Returns the internal field index map for fast field lookup by name.
	`public List<FieldNode>`	`getFields()` Returns all FieldNodes declared in this ClassNode, including inherited fields.
	`public GenericsType[]`	`getGenericsTypes()` Returns the generic type parameters for this ClassNode, or `null` if none are defined.
	`public MethodNode`	`getGetterMethod(String getterName)` Finds a getter MethodNode matching the given name, optionally searching superclasses.
	`public MethodNode`	`getGetterMethod(String getterName, boolean searchSupers)` Finds a getter MethodNode matching the given name, optionally searching superclasses and interfaces.
	`public Iterator<InnerClassNode>`	`getInnerClasses()` Returns an iterator over the inner classes defined within this ClassNode.
	`public ClassNode[]`	`getInterfaces()` Returns: the interfaces implemented by this `ClassNode`
	`public MethodNode`	`getMethod(String name, Parameter[] parameters)` Finds a MethodNode matching the given name and parameter signature in this class or any of its superclasses.
	`public List<MethodNode>`	`getMethods()` Returns all MethodNodes declared in this ClassNode, including inherited and synthetic methods.
	`public List<MethodNode>`	`getMethods(String name)` Returns a list of all MethodNodes with the given name from this class and its superclasses.
	`public MixinNode[]`	`getMixins()` Returns: the mixins associated with this `ClassNode`
	`public int`	`getModifiers()` Returns the modifier flags for this ClassNode, combining visibility and behavioral modifiers.
	`public ModuleNode`	`getModule()`
	`public String`	`getName()` Returns the fully-qualified name of this class after following any redirects.
	`public String`	`getNameWithoutPackage()`
	`public List<Statement>`	`getObjectInitializerStatements()`
	`public ClassNode`	`getOuterClass()` Returns the outer class of this ClassNode, or `null` if this is not an inner class.
	`public List<ClassNode>`	`getOuterClasses()` Returns a list of all outer classes enclosing this ClassNode in hierarchical order.
	`public FieldNode`	`getOuterField(String name)` Returns: the field on the outer class or `null` if this is not an inner class
	`public PackageNode`	`getPackage()`
	`public String`	`getPackageName()`
	`public List<ClassNode>`	`getPermittedSubclasses()` Returns: permitted subclasses of sealed type, may initially be empty in early compiler phases
	`public ClassNode`	`getPlainNodeReference()`
	`public ClassNode`	`getPlainNodeReference(boolean skipPrimitives)`
	`public List<PropertyNode>`	`getProperties()` Returns all PropertyNodes declared in this ClassNode.
	`public PropertyNode`	`getProperty(String name)` Finds a PropertyNode matching the given name in this ClassNode.
	`public List<RecordComponentNode>`	`getRecordComponents()` Gets the record components of record type.
	`public MethodNode`	`getSetterMethod(String setterName)` Finds a setter MethodNode matching the given name, optionally searching superclasses.
	`public MethodNode`	`getSetterMethod(String setterName, boolean voidOnly)` Finds a setter MethodNode matching the given name.
	`public ClassNode`	`getSuperClass()` Returns: the `ClassNode` of the super class of this type
	`public String`	`getText()`
	`public Map<Class<? extends ASTTransformation>, Set<ASTNode>>`	`getTransforms(CompilePhase phase)`
	`public List<AnnotationNode>`	`getTypeAnnotations()`
	`public List<AnnotationNode>`	`getTypeAnnotations(ClassNode type)`
	`public Class`	`getTypeClass()` Returns the concrete class this classnode relates to.
	`public ClassNode[]`	`getUnresolvedInterfaces()` Returns the unresolved interfaces implemented by this ClassNode, using redirect resolution by default.
	`public ClassNode[]`	`getUnresolvedInterfaces(boolean deref)` Returns the unresolved interfaces implemented by this ClassNode with optional redirect resolution.
	`public String`	`getUnresolvedName()`
	`public ClassNode`	`getUnresolvedSuperClass()` Returns the unresolved super class of this ClassNode, using redirect resolution by default.
	`public ClassNode`	`getUnresolvedSuperClass(boolean deref)` Returns the unresolved super class of this ClassNode with optional redirect resolution.
	`public boolean`	`hasDeclaredMethod(String name, Parameter[] parameters)` Tests whether a method with the given name and parameter signature is declared directly in this class (not inherited from a superclass).
	`public boolean`	`hasMethod(String name, Parameter[] parameters)` Tests whether a method with the given name and parameter signature exists in this class or any of its superclasses.
	`public boolean`	`hasPackageName()`
	`public boolean`	`hasPossibleMethod(String name, Expression arguments)` Determines if the type has a possibly-matching instance method with the given name and arguments.
	`public boolean`	`hasPossibleStaticMethod(String name, Expression arguments)` Checks if the given method has a possibly matching static method with the given name and arguments.
	`public boolean`	`hasProperty(String name)` Tests whether a property with the given name exists in this ClassNode.
	`public int`	`hashCode()` Returns the hash code for this ClassNode.
	`public boolean`	`implementsAnyInterfaces(ClassNode classNodes)` Parameters: `classNodes` - the class nodes for the interfaces
	`public boolean`	`implementsInterface(ClassNode classNode)` Parameters: `classNode` - the class node for the interface
	`public boolean`	`isAbstract()` Returns whether this ClassNode represents an abstract class.
	`public boolean`	`isAnnotated()` Returns whether this ClassNode has been marked as annotated.
	`public boolean`	`isAnnotationDefinition()` Returns whether this ClassNode represents an annotation type (annotation definition).
	`public boolean`	`isArray()` Determines whether this ClassNode represents an array type.
	`public boolean`	`isDerivedFrom(ClassNode type)` Parameters: `type` - the ClassNode of interest
	`public boolean`	`isDerivedFromGroovyObject()` Returns whether this ClassNode represents a type that implements the `GroovyObject` interface.
	`public boolean`	`isEnum()` Returns whether this ClassNode represents an enumeration type.
	`public boolean`	`isGenericsPlaceHolder()`
	`public boolean`	`isInterface()` Returns whether this ClassNode represents an interface type.
	`public boolean`	`isPrimaryClassNode()` Determines whether this ClassNode is a primary node or redirects to one.
	`public boolean`	`isRecord()` Checks if the ClassNode instance represents a native `record`.
	`public boolean`	`isRedirectNode()` Returns whether this ClassNode is a redirect (proxy) node for another ClassNode.
	`public boolean`	`isResolved()` Determines whether this ClassNode has been resolved to an actual Java class.
	`public boolean`	`isScript()` Returns whether this ClassNode represents a Groovy script body.
	`public boolean`	`isScriptBody()` Returns whether this inner class or closure was declared inside a script body.
	`public boolean`	`isSealed()` Returns: `true` for native and emulated (annotation based) sealed classes
	`public boolean`	`isStaticClass()` Returns whether this inner class or closure was declared inside a static method context.
	`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.
	`public boolean`	`isUsingGenerics()`
	`public ClassNode`	`makeArray()` Returns a `ClassNode` representing an array of the type represented by this.
	`protected boolean`	`parametersEqual(Parameter[] a, Parameter[] b)`
	`public void`	`positionStmtsAfterEnumInitStmts(List<Statement> staticFieldInitializerStatements)`
	`public ClassNode`	`redirect()` Returns the `ClassNode` this node is a proxy for or the node itself.
	`public void`	`removeConstructor(ConstructorNode node)`
	`public void`	`removeField(String oldName)` Removes the FieldNode with the given name from this ClassNode.
	`public void`	`removeMethod(MethodNode node)` Removes the given MethodNode from this ClassNode.
	`public void`	`renameField(String oldName, String newName)`
	`public void`	`setAnnotated(boolean annotated)` Marks this ClassNode as having annotations attached to it.
	`protected void`	`setCompileUnit(CompileUnit cu)`
	`public void`	`setEnclosingMethod(MethodNode enclosingMethod)` Sets the enclosing MethodNode for this local inner class.
	`public void`	`setGenericsPlaceHolder(boolean placeholder)`
	`public void`	`setGenericsTypes(GenericsType[] genericsTypes)` Sets the generic type parameters for this ClassNode.
	`public void`	`setInterfaces(ClassNode[] interfaces)` Sets the interfaces implemented by this ClassNode.
	`public void`	`setMixins(MixinNode[] mixins)`
	`public void`	`setModifiers(int modifiers)` Sets the modifier flags for this ClassNode.
	`public void`	`setModule(ModuleNode module)`
	`public String`	`setName(String name)` Sets the fully-qualified name of this class, delegating to the redirect if one exists.
	`public void`	`setPermittedSubclasses(List<ClassNode> permittedSubclasses)`
	`public void`	`setRecordComponents(List<RecordComponentNode> recordComponents)` Sets the record components for record type.
	`public void`	`setRedirect(ClassNode node)` Sets this instance as a proxy for the given `ClassNode`, enabling deferred class resolution.
	`public void`	`setScript(boolean script)` Marks this ClassNode as a script or removes the script flag.
	`public void`	`setScriptBody(boolean scriptBody)` Marks this inner class or closure as being declared inside a script body.
	`public void`	`setStaticClass(boolean staticClass)` Marks this inner class or closure as being declared in a static method context.
	`public void`	`setSuperClass(ClassNode superClass)` Sets the super class of this ClassNode.
	`public void`	`setSyntheticPublic(boolean syntheticPublic)` Marks this ClassNode as having synthetic public visibility.
	`public void`	`setUnresolvedSuperClass(ClassNode superClass)` Sets the unresolved super class for this ClassNode.
	`public void`	`setUsingGenerics(boolean usesGenerics)`
	`public String`	`toString()` Returns a string representation of this ClassNode for debugging and display purposes.
	`public String`	`toString(boolean showRedirect)` Returns a string representation of this ClassNode with optional redirect information.
	`public MethodNode`	`tryFindPossibleMethod(String name, Expression arguments)`
	`public void`	`visitContents(GroovyClassVisitor visitor)`

Inherited Methods Summary

Inherited Methods
Methods inherited from class	Name
`class AnnotatedNode`	`addAnnotation, addAnnotation, addAnnotations, getAnnotations, getAnnotations, getDeclaringClass, getGroovydoc, getInstance, hasNoRealSourcePosition, isSynthetic, setDeclaringClass, setHasNoRealSourcePosition, setSynthetic`
`class ASTNode`	`copyNodeMetaData, getColumnNumber, getLastColumnNumber, getLastLineNumber, getLineNumber, getMetaDataMap, getText, setColumnNumber, setLastColumnNumber, setLastLineNumber, setLineNumber, setMetaDataMap, setSourcePosition, visit`

- Field Detail
  - public static final ClassNode[] EMPTY_ARRAY
  - public static final ClassNode SUPER
  - public static final ClassNode THIS
  - protected Class<?> clazz
  - protected boolean isPrimaryNode
  - protected final Object lazyInitLock
- Constructor Detail
  - public ClassNode(String name, int modifiers, ClassNode superClass, ClassNode[] interfaces, MixinNode[] mixins)
    
    Constructs a primary ClassNode representing a class declaration with all components. This constructor creates a new ClassNode that will be compiled by Groovy. The node represents an actual source class definition with specified interfaces and mixins.
    Parameters:
    name - the fully-qualified name of the class (e.g., "com.example.MyClass")
    modifiers - the bytecode modifiers (flags from Modifier or org.objectweb.asm.Opcodes)
    superClass - the base class (ClassNode representing the parent type); use ClassHelper.OBJECT_TYPE if no direct base class
    interfaces - array of ClassNode instances for interfaces implemented by this class; may be empty
    mixins - array of MixinNode instances to be mixed into this class; may be empty
  - public ClassNode(String name, int modifiers, ClassNode superClass)
    
    Constructs a primary ClassNode representing a class declaration with superclass. This is a convenience constructor for creating classes with a single superclass and no interfaces or mixins. It delegates to the full constructor with empty interface and mixin arrays.
    Parameters:
    name - the fully-qualified name of the class (e.g., "com.example.MyClass")
    modifiers - the bytecode modifiers (flags from Modifier or org.objectweb.asm.Opcodes)
    superClass - the base class (ClassNode representing the parent type); use ClassHelper.OBJECT_TYPE if no direct base class
  - public ClassNode(Class<?> c)
    
    Constructs a non-primary ClassNode from a real Java class. This constructor creates a ClassNode that represents an actual Java class loaded at runtime (not a Groovy source class). The class information is lazily initialized from reflection, and the node will not be compiled by Groovy.
    Parameters:
    c - the Java class (Class) to wrap; must not be null
- Method Detail
  - public void addConstructor(ConstructorNode node)
  - public ConstructorNode addConstructor(int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code)
  - public void addField(FieldNode node)
    
    Adds a FieldNode to this ClassNode. The field is added to the end of the field list and its declaring class is set to this node's redirect target. The field is registered in the internal field index for fast lookup by name.
    Parameters:
    node - the FieldNode to add, must not be null
    See Also:
    addFieldFirst(FieldNode)
    removeField(String)
  - public FieldNode addField(String name, int modifiers, ClassNode type, Expression initialValue)
    
    Creates and adds a FieldNode to this ClassNode with the specified properties. The field is initialized with the given name, modifiers, type, and optional initial value expression. This is a convenience method that creates a FieldNode and adds it via addField(FieldNode).
    Parameters:
    name - the name of the field
    modifiers - the access modifiers for the field (e.g., ACC_PUBLIC, ACC_PRIVATE)
    type - the ClassNode representing the field's type
    initialValue - the initial value Expression, or null if no initializer
    Returns:
    the newly created FieldNode
    See Also:
    addFieldFirst(String, int, ClassNode, Expression)
  - public void addFieldFirst(FieldNode node)
    
    Adds a FieldNode to this ClassNode at the beginning of the field list. This method is similar to addField(FieldNode) but prepends the field instead of appending it, which can be useful when field declaration order matters.
    Parameters:
    node - the FieldNode to add first, must not be null
    See Also:
    addField(FieldNode)
  - public FieldNode addFieldFirst(String name, int modifiers, ClassNode type, Expression initialValue)
    
    Creates and adds a FieldNode to the beginning of this ClassNode's field list with the specified properties. This is a convenience method for adding fields where declaration order is significant.
    Parameters:
    name - the name of the field
    modifiers - the access modifiers for the field (e.g., ACC_PUBLIC, ACC_PRIVATE)
    type - the ClassNode representing the field's type
    initialValue - the initial value Expression, or null if no initializer
    Returns:
    the newly created FieldNode
    See Also:
    addField(String, int, ClassNode, Expression)
  - public void addInterface(ClassNode node)
    
    Adds an interface to the list of interfaces implemented by this ClassNode. If the interface is already implemented, this method has no effect. The interface is appended to the end of the current interfaces array.
    Parameters:
    node - the ClassNode representing the interface to add
    See Also:
    getInterfaces()
    setInterfaces(ClassNode[])
  - public void addMethod(MethodNode node)
    
    Adds a MethodNode to this ClassNode. The method is added to the internal methods list and registered by name in the methods map for fast lookup. The method's declaring class is set to this node's redirect target. This method does not check for duplicates.
    Parameters:
    node - the MethodNode to add, must not be null
    See Also:
    removeMethod(MethodNode)
    getMethod(String, Parameter[])
    MethodNode
  - public MethodNode addMethod(String name, int modifiers, ClassNode returnType, Parameter[] parameters, ClassNode[] exceptions, Statement code)
    
    Creates and adds a MethodNode to this ClassNode with the specified properties, but only if a method with the same name and parameter signature does not already exist. If a matching method is already declared in this class, it is returned without adding a new one. This method is useful for adding default method implementations (e.g., getProperty(), invokeMethod()) where the class may already have a user-defined version.
    Parameters:
    name - the name of the method
    modifiers - the access modifiers (e.g., ACC_PUBLIC, ACC_STATIC)
    returnType - the ClassNode representing the return type
    parameters - array of Parameters, or an empty array for no parameters
    exceptions - array of exception ClassNodes that the method declares, or an empty array
    code - the method body as a Statement, or null
    Returns:
    the newly created MethodNode or an existing method if one matches the name and parameters
    See Also:
    addMethod(MethodNode)
    getDeclaredMethod(String, Parameter[])
  - public void addMixin(MixinNode node)
  - public void addObjectInitializerStatements(Statement statement)
    
    Adds a statement to the object initializer.
    Parameters:
    statement - the statement to be added
  - public void addProperty(PropertyNode node)
    
    Adds a PropertyNode to this ClassNode. The property's associated field is also added to the field list, and the property itself is registered in the properties list. The property's declaring class is set to this node's redirect target.
    Parameters:
    node - the PropertyNode to add, must not be null
    See Also:
    addField(FieldNode)
    PropertyNode
  - public PropertyNode addProperty(String name, int modifiers, ClassNode type, Expression initialValue, Statement getterBlock, Statement setterBlock)
    
    Creates and adds a PropertyNode to this ClassNode with the specified properties, or returns an existing property with the same name if one is already present. If a property with the given name exists, the method updates its getter block, setter block, and initial value expression if they are currently null. This prevents duplicate properties while allowing partial initialization across multiple calls.
    Parameters:
    name - the name of the property
    modifiers - the access modifiers for the property (e.g., ACC_PUBLIC, ACC_PRIVATE)
    type - the ClassNode representing the property's type
    initialValue - the initial value Expression, or null if no initializer
    getterBlock - the getter method's Statement body, or null
    setterBlock - the setter method's Statement body, or null
    Returns:
    the newly created PropertyNode or the existing property if one with this name is already present
    See Also:
    addProperty(PropertyNode)
    PropertyNode
  - public void addStaticInitializerStatements(List<Statement> statements, boolean fieldInit)
  - 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.
  - public void addTransform(Class<? extends ASTTransformation> transform, ASTNode node)
  - public void addTypeAnnotation(AnnotationNode annotation)
  - public void addTypeAnnotations(List<AnnotationNode> annotations)
  - public GenericsType asGenericsType()
  - 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
  - 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.
    See Also:
    GeneralUtils.isOrImplements
  - public boolean equals(Object that)
    
    Compares this ClassNode with another object for equality. Two ClassNodes are considered equal if:
    - They are the same object (identity check)
    - Both are ClassNode instances and either have identical redirects, identical component types (for arrays), or have matching text representations
    If this ClassNode is a redirect node, the comparison is delegated to the redirect target. Array ClassNodes are compared based on their component types.
    Parameters:
    that - the object to compare with this ClassNode
    Returns:
    true if the objects represent the same class; false otherwise
    See Also:
    hashCode()
    redirect()
  - public List<MethodNode> getAbstractMethods()
    
    Returns a list of all abstract MethodNodes declared in this ClassNode. Abstract methods are obtained from the declared methods map and filtered to return only those with the abstract modifier set. This includes abstract methods from superclasses and implemented interfaces.
    Returns:
    a list of abstract MethodNodes (possibly empty); returns an empty list if there are no abstract methods
    See Also:
    getDeclaredMethodsMap()
    MethodNode.isAbstract
  - public List<MethodNode> getAllDeclaredMethods()
    
    Returns all declared MethodNodes from this ClassNode and its superclasses and interfaces as a list. This is a convenience method that collects all values from the declared methods map into a single list.
    Returns:
    a list of all MethodNodes declared in this class, superclasses, and interfaces; an empty list if no methods are found
    See Also:
    getDeclaredMethodsMap()
  - public Set<ClassNode> getAllInterfaces()
  - public List<AnnotationNode> getAnnotations()
  - public List<AnnotationNode> getAnnotations(ClassNode type)
  - public CompileUnit getCompileUnit()
  - public ClassNode getComponentType()
    
    Returns the component type of this array ClassNode. If this ClassNode does not represent an array type, returns null. For array types, this returns the ClassNode representing the element type (e.g., for "String[]", returns the ClassNode for "String").
    Returns:
    the ClassNode representing the array's element type, or null if not an array
  - public ConstructorNode getDeclaredConstructor(Parameter[] parameters)
    
    Returns:
    the constructor matching the given parameters or null
  - public List<ConstructorNode> getDeclaredConstructors()
  - public FieldNode getDeclaredField(String name)
    
    Finds a FieldNode matching the given name declared directly in this class. This method does not search superclasses; to include inherited fields, use getField(String). If this node is a proxy (has a redirect), the call is forwarded to the redirect target.
    Parameters:
    name - the name of the field to find
    Returns:
    the FieldNode with the given name declared in this class, or null if not found
    See Also:
    getField(String)
    getFields()
  - public MethodNode getDeclaredMethod(String name, Parameter[] parameters)
    
    Finds a MethodNode matching the given name and parameter signature declared directly in this class. This method does not search superclasses; to include inherited methods, use getMethod(String, Parameter[]). Parameter matching is done by comparing parameter types using the parametersEqual(Parameter[], Parameter[]) method.
    Parameters:
    name - the name of the method to find
    parameters - an array of Parameters representing the method signature, or null/empty for methods with no parameters
    Returns:
    the MethodNode with the given name and parameters, or null if not found
    See Also:
    getMethod(String, Parameter[])
    getDeclaredMethods(String)
  - public List<MethodNode> getDeclaredMethods(String name)
    
    Returns a list of all MethodNodes with the given name declared directly in this class. This method does not search superclasses; to include inherited methods, use getMethods(String). If this node is a proxy (has a redirect), the call is forwarded to the redirect target. The list may be empty if no methods with the given name are declared in this class.
    Parameters:
    name - the name of the methods to find
    Returns:
    a list of MethodNodes with the given name (possibly empty)
    See Also:
    getMethods(String)
    getDeclaredMethod(String, Parameter[])
  - public Map<String, MethodNode> getDeclaredMethodsMap()
    
    Returns all declared MethodNodes from this ClassNode and its superclasses and interfaces. The methods are collected in a single map with method type descriptors as keys, allowing resolution of method overrides across the inheritance hierarchy. This method provides a complete view of all accessible methods.
    Returns:
    a map from method type descriptor (name and signature) to MethodNode; includes methods from superclasses and interfaces
    See Also:
    getDeclaredMethods(String)
    getMethod(String, Parameter[])
    MethodNode.getTypeDescriptor
  - public MethodNode getEnclosingMethod()
    
    Returns the enclosing MethodNode of this local inner class, or null if this is not a local inner class. Local inner classes are those declared within method bodies. If this ClassNode has a redirect, returns the enclosing method from the redirect.
    Returns:
    the MethodNode enclosing this class, or null
    See Also:
    setEnclosingMethod(MethodNode)
    getOuterClass()
  - public FieldNode getField(String name)
    
    Finds a FieldNode matching the given name in this class or any of its superclasses. This method searches the inheritance hierarchy starting from this ClassNode and moving up through superclasses until a field with the matching name is found.
    Parameters:
    name - the name of the field to find
    Returns:
    the FieldNode with the given name, or null if not found in this class or any superclass
    See Also:
    getDeclaredField(String)
    getFields()
  - @Deprecated(forRemoval = true, since = "5.0.0")
    public Map<String, FieldNode> getFieldIndex()
    
    Returns the internal field index map for fast field lookup by name. This method is deprecated as field access should go through getField(String) or getDeclaredField(String). The field index is an internal implementation detail and may change in future versions.
    deprecated:
    for removal since 5.0.0; use getField(String) or getDeclaredField(String) instead
    
    Returns:
    a map from field name to FieldNode, or null if no field index exists
    See Also:
    getField(String)
    getDeclaredField(String)
  - public List<FieldNode> getFields()
    
    Returns all FieldNodes declared in this ClassNode, including inherited fields. If this node is a proxy (has a redirect), the call is forwarded to the redirect target. The returned list includes fields from this class only, not from super classes.
    Returns:
    an unmodifiable or mutable list of FieldNodes associated with this ClassNode; an empty list if this class declares no fields
    See Also:
    getDeclaredField(String)
    FieldNode
  - public GenericsType[] getGenericsTypes()
    
    Returns the generic type parameters for this ClassNode, or null if none are defined. Generic types represent type parameters and their bounds as declared in class definitions. For example, in class List<T>, the GenericsType array would contain a single element representing the type parameter T.
    Returns:
    an array of GenericsType representing the type parameters, or null
    See Also:
    setGenericsTypes(GenericsType[])
    isUsingGenerics()
  - public MethodNode getGetterMethod(String getterName)
    
    Finds a getter MethodNode matching the given name, optionally searching superclasses. A getter method is defined as a method with no parameters that returns a non-void type. For methods starting with "is", the return type must be boolean. Synthetic and bridge methods are disregarded in favor of the most specific real getter.
    Parameters:
    getterName - the name of the getter method to find
    Returns:
    the getter MethodNode, or null if not found
    See Also:
    getGetterMethod(String, boolean)
    getSetterMethod(String)
  - public MethodNode getGetterMethod(String getterName, boolean searchSupers)
    
    Finds a getter MethodNode matching the given name, optionally searching superclasses and interfaces. A getter method is defined as a method with no parameters that returns a non-void type. For methods starting with "is", the return type must be boolean. Synthetic and bridge methods are disregarded in favor of the most specific real getter.
    Parameters:
    getterName - the name of the getter method to find
    searchSupers - if true, searches superclasses and interfaces for the getter; if false, searches only methods declared in this class
    Returns:
    the getter MethodNode, or null if not found
    See Also:
    getSetterMethod(String, boolean)
    MethodNode
  - public Iterator<InnerClassNode> getInnerClasses()
    
    Returns an iterator over the inner classes defined within this ClassNode. The iterator is backed by an unmodifiable view of the inner classes list. Returns an empty iterator if this class has no inner classes defined.
    Returns:
    an Iterator of InnerClassNodes defined in this class, never null
    See Also:
    addInnerClass(InnerClassNode)
  - public ClassNode[] getInterfaces()
    
    Returns:
    the interfaces implemented by this ClassNode
  - public MethodNode getMethod(String name, Parameter[] parameters)
    
    Finds a MethodNode matching the given name and parameter signature in this class or any of its superclasses. This method searches the inheritance hierarchy starting from this ClassNode. Parameter matching is done by comparing parameter types using the parametersEqual(Parameter[], Parameter[]) method.
    Parameters:
    name - the name of the method to find
    parameters - an array of Parameters representing the method signature, or null/empty for methods with no parameters
    Returns:
    the MethodNode with the given name and parameters, or null if not found in this class or any superclass
    See Also:
    getDeclaredMethod(String, Parameter[])
    getMethods(String)
  - public List<MethodNode> getMethods()
    
    Returns all MethodNodes declared in this ClassNode, including inherited and synthetic methods. If this node is a proxy (has a redirect), the call is forwarded to the redirect target. This list includes constructors and all instance and static methods defined for this class.
    Returns:
    a list of all MethodNodes associated with this ClassNode; an empty list if this class declares no methods
    See Also:
    getDeclaredMethods(String)
    getMethod(String, Parameter[])
    MethodNode
  - public List<MethodNode> getMethods(String name)
    
    Returns a list of all MethodNodes with the given name from this class and its superclasses. This method searches the inheritance hierarchy starting from this ClassNode and moving up through superclasses, collecting all methods with matching names. The list may be empty if no methods with the given name are found in the class hierarchy.
    Parameters:
    name - the name of the methods to find
    Returns:
    a list of MethodNodes with the given name from this class and its superclasses (possibly empty)
    See Also:
    getDeclaredMethods(String)
    getMethod(String, Parameter[])
  - public MixinNode[] getMixins()
    
    Returns:
    the mixins associated with this ClassNode
  - public int getModifiers()
    
    Returns the modifier flags for this ClassNode, combining visibility and behavioral modifiers. The flags are represented as a bitmask using ASM/bytecode conventions (e.g., ACC_PUBLIC, ACC_ABSTRACT, ACC_INTERFACE, ACC_ENUM). This method follows redirects if present, ensuring the modifiers of the actual target ClassNode are returned. Individual modifiers can be tested using bitwise AND operations with the ASM Opcodes constants.
    Returns:
    the modifier flags as an integer bitmask
    See Also:
    setModifiers(int)
    isAbstract()
    isInterface()
    isEnum()
  - public ModuleNode getModule()
  - public String getName()
    
    Returns the fully-qualified name of this class after following any redirects. If this ClassNode is a proxy for another ClassNode, the name of the target is returned. The name remains consistent across all compilation phases for the redirected type.
    Returns:
    the fully-qualified class name (e.g., "com.example.MyClass" or "int[]")
  - public String getNameWithoutPackage()
  - public List<Statement> getObjectInitializerStatements()
  - public ClassNode getOuterClass()
    
    Returns the outer class of this ClassNode, or null if this is not an inner class. If this ClassNode has a redirect, returns the outer class from the redirect. This method traverses the class hierarchy upward to find the immediately enclosing class.
    Returns:
    the outer ClassNode, or null if not an inner class
    See Also:
    getOuterClasses()
  - public List<ClassNode> getOuterClasses()
    
    Returns a list of all outer classes enclosing this ClassNode in hierarchical order. The innermost outer class appears first in the list. Returns an empty list if this is not an inner class. If this ClassNode has a redirect, the list is derived from the redirect.
    Returns:
    a List of enclosing ClassNodes in order from innermost to outermost, never null
    See Also:
    getOuterClass()
  - public FieldNode getOuterField(String name)
    
    Returns:
    the field on the outer class or null if this is not an inner class
  - public PackageNode getPackage()
  - public String getPackageName()
  - @Incubating
    public List<ClassNode> getPermittedSubclasses()
    
    Returns:
    permitted subclasses of sealed type, may initially be empty in early compiler phases
  - public ClassNode getPlainNodeReference()
  - public ClassNode getPlainNodeReference(boolean skipPrimitives)
  - public List<PropertyNode> getProperties()
    
    Returns all PropertyNodes declared in this ClassNode. If this node is a proxy (has a redirect), the call is forwarded to the redirect target. Properties are distinct from fields and represent a higher-level abstraction with getter/setter semantics.
    Returns:
    a mutable list of PropertyNodes associated with this ClassNode; an empty list if this class declares no properties
    See Also:
    getProperty(String)
    PropertyNode
  - public PropertyNode getProperty(String name)
    
    Finds a PropertyNode matching the given name in this ClassNode. This method searches through the properties list, comparing by name. Only direct properties of this class are searched, not inherited ones.
    Parameters:
    name - the name of the property to find
    Returns:
    the PropertyNode with the given name, or null if not found
    See Also:
    hasProperty(String)
    getProperties()
  - @Incubating
    public List<RecordComponentNode> getRecordComponents()
    
    Gets the record components of record type.
    Returns:
    RecordComponentNode instances
    Since:
    4.0.0
  - public MethodNode getSetterMethod(String setterName)
    
    Finds a setter MethodNode matching the given name, optionally searching superclasses. A setter method is defined as a method with exactly one parameter that returns void. This method searches from this class up the inheritance hierarchy until a matching setter is found.
    Parameters:
    setterName - the name of the setter method to find
    Returns:
    the setter MethodNode, or null if not found
    See Also:
    getSetterMethod(String, boolean)
    getGetterMethod(String)
  - public MethodNode getSetterMethod(String setterName, boolean voidOnly)
    
    Finds a setter MethodNode matching the given name. A setter method is defined as a method with exactly one parameter. If voidOnly is true, the method must also return void. The method searches this class and superclasses for the first matching setter.
    Parameters:
    setterName - the name of the setter method to find
    voidOnly - if true, only returns setter methods that return void; if false, accepts setters that return any type
    Returns:
    the setter MethodNode, or null if not found
    See Also:
    getGetterMethod(String, boolean)
    MethodNode
  - public ClassNode getSuperClass()
    
    Returns:
    the ClassNode of the super class of this type
  - public String getText()
  - public Map<Class<? extends ASTTransformation>, Set<ASTNode>> getTransforms(CompilePhase phase)
  - public List<AnnotationNode> getTypeAnnotations()
  - public List<AnnotationNode> getTypeAnnotations(ClassNode type)
  - 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.
  - public ClassNode[] getUnresolvedInterfaces()
    
    Returns the unresolved interfaces implemented by this ClassNode, using redirect resolution by default. The unresolved interfaces represent the raw interface hierarchy without applying redirect resolution. Returns an empty array if this class implements no interfaces.
    Returns:
    an array of ClassNode representing the interfaces, never null
    See Also:
    getUnresolvedInterfaces(boolean)
  - public ClassNode[] getUnresolvedInterfaces(boolean deref)
    
    Returns the unresolved interfaces implemented by this ClassNode with optional redirect resolution. When deref is true, resolves redirects recursively; otherwise returns the raw interfaces stored in this ClassNode. Resolving may trigger lazy class initialization.
    Parameters:
    deref - true to apply redirect resolution, false to return raw interfaces
    Returns:
    an array of ClassNode representing the interfaces, never null
    See Also:
    getUnresolvedInterfaces()
  - public String getUnresolvedName()
  - public ClassNode getUnresolvedSuperClass()
    
    Returns the unresolved super class of this ClassNode, using redirect resolution by default. The unresolved super class represents the raw class hierarchy without applying redirect resolution. Returns null if this class has no explicit superclass.
    Returns:
    the unresolved ClassNode representing the super class, or null
    See Also:
    getUnresolvedSuperClass(boolean)
  - public ClassNode getUnresolvedSuperClass(boolean deref)
    
    Returns the unresolved super class of this ClassNode with optional redirect resolution. When deref is true, resolves redirects recursively; otherwise returns the raw superclass stored in this ClassNode. Resolving may trigger lazy class initialization.
    Parameters:
    deref - true to apply redirect resolution, false to return raw superclass
    Returns:
    the unresolved ClassNode representing the super class, or null
    See Also:
    getUnresolvedSuperClass()
  - public boolean hasDeclaredMethod(String name, Parameter[] parameters)
    
    Tests whether a method with the given name and parameter signature is declared directly in this class (not inherited from a superclass). This is a convenience method for checking method existence.
    Parameters:
    name - the name of the method to check
    parameters - an array of Parameters representing the method signature, or null/empty for methods with no parameters
    Returns:
    true if a method with the given name and parameters is declared in this class, false otherwise
    See Also:
    getDeclaredMethod(String, Parameter[])
    hasMethod(String, Parameter[])
  - public boolean hasMethod(String name, Parameter[] parameters)
    
    Tests whether a method with the given name and parameter signature exists in this class or any of its superclasses. This is a convenience method for checking method existence.
    Parameters:
    name - the name of the method to check
    parameters - an array of Parameters representing the method signature, or null/empty for methods with no parameters
    Returns:
    true if a method with the given name and parameters exists, false otherwise
    See Also:
    getMethod(String, Parameter[])
    hasDeclaredMethod(String, Parameter[])
  - public boolean hasPackageName()
  - public boolean hasPossibleMethod(String name, Expression arguments)
    
    Determines if the type 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
  - 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
  - public boolean hasProperty(String name)
    
    Tests whether a property with the given name exists in this ClassNode. This method searches through the properties list, comparing by name.
    Parameters:
    name - the name of the property to check
    Returns:
    true if a property with the given name exists, false otherwise
    See Also:
    getProperty(String)
    getProperties()
  - public int hashCode()
    
    Returns the hash code for this ClassNode. The hash code is based on the redirect's hash code if a redirect exists, or the text representation's hash code if this is a primary or array ClassNode. This ensures that equal ClassNodes (by equals(Object)) have equal hash codes, maintaining the hash code contract for use in hash-based collections.
    Returns:
    a hash code value for this ClassNode
    See Also:
    equals(Object)
  - public boolean implementsAnyInterfaces(ClassNode classNodes)
    
    Parameters:
    classNodes - the class nodes for the interfaces
    Returns:
    true if this type implements any of the given interfaces
  - public boolean implementsInterface(ClassNode classNode)
    
    Parameters:
    classNode - the class node for the interface
    Returns:
    true if this type implements the given interface
  - public boolean isAbstract()
    
    Returns whether this ClassNode represents an abstract class. A class is abstract if the ACC_ABSTRACT modifier flag is set in its modifiers. Abstract classes cannot be instantiated directly; they serve as base types for subclasses. This method checks the actual modifier bits, independent of the source code syntax.
    Returns:
    true if this class has the abstract modifier set; false otherwise
    See Also:
    getModifiers()
    setModifiers(int)
  - public boolean isAnnotated()
    
    Returns whether this ClassNode has been marked as annotated. This flag is set to true when annotations are added to the class via addAnnotation(AnnotationNode) or related methods. It serves as a quick indicator that the class carries metadata annotations, without requiring iteration through the full annotations list. The flag does not distinguish between different types of annotations (type annotations, method annotations, etc.).
    Returns:
    true if this class has been marked as having annotations; false otherwise
    See Also:
    setAnnotated(boolean)
    getAnnotations()
  - public boolean isAnnotationDefinition()
    
    Returns whether this ClassNode represents an annotation type (annotation definition). Annotation types are always interfaces with both the ACC_INTERFACE and ACC_ANNOTATION modifier flags set. They define metadata that can be attached to program elements. All annotation types are interfaces but not all interfaces are annotations.
    Returns:
    true if this class is an annotation type; false otherwise
    See Also:
    isInterface()
    getModifiers()
  - public boolean isArray()
    
    Determines whether this ClassNode represents an array type. A ClassNode is an array if its component type has been set. The component type represents the element type of the array (e.g., "int" for "int[]", or "String" for "String[]").
    Returns:
    true if this ClassNode represents an array type; false if it represents a scalar type
  - public boolean isDerivedFrom(ClassNode type)
    
    Parameters:
    type - the ClassNode of interest
    Returns:
    true if this node is derived from the given ClassNode
  - public boolean isDerivedFromGroovyObject()
    
    Returns whether this ClassNode represents a type that implements the GroovyObject interface. GroovyObject is the core interface that all Groovy objects implement, providing methods like getProperty(), setProperty(), and invokeMethod() for dynamic behavior. This method checks the class hierarchy to determine if GroovyObject is in the list of implemented interfaces.
    Returns:
    true if this type directly or indirectly implements GroovyObject; false otherwise
    See Also:
    implementsInterface(ClassNode)
    isDerivedFrom(ClassNode)
  - public boolean isEnum()
    
    Returns whether this ClassNode represents an enumeration type. An enum class has the ACC_ENUM modifier flag set in its modifiers. Enumerations define a fixed set of named constants that can be iterated over at compile time.
    Returns:
    true if this class is an enumeration; false otherwise
    See Also:
    getModifiers()
    setModifiers(int)
  - public boolean isGenericsPlaceHolder()
  - public boolean isInterface()
    
    Returns whether this ClassNode represents an interface type. A class is an interface if the ACC_INTERFACE modifier flag is set in its modifiers. Interfaces define contracts for implementing classes without providing implementation details. Note that annotations are also interfaces (with the ACC_ANNOTATION flag also set).
    Returns:
    true if this class is an interface; false if it is a regular class
    See Also:
    isAnnotationDefinition()
    getModifiers()
  - public boolean isPrimaryClassNode()
    
    Determines whether this ClassNode is a primary node or redirects to one. A primary ClassNode represents actual Groovy source code that will be compiled into bytecode. Returns true if this node is primary or if its redirect target (or array component type) is a primary ClassNode. Non-primary nodes are typically loaded via reflection.
    Returns:
    true if this is a primary ClassNode or redirects to one; false if it only represents a reflected class
  - @Incubating
    public boolean isRecord()
    
    Checks if the ClassNode instance represents a native record. Check instead for the RecordBase annotation if looking for records and record-like classes currently being compiled.
    Returns:
    true if the instance represents a native record
    Since:
    4.0.0
  - public boolean isRedirectNode()
    
    Returns whether this ClassNode is a redirect (proxy) node for another ClassNode. A redirect node acts as a placeholder that forwards most method calls to its target ClassNode. This mechanism is used during compilation to defer class resolution until the actual target class is available. The actual target can be found using redirect().
    Returns:
    true if this node redirects to another ClassNode; false if it is a standalone node
    See Also:
    redirect()
    setRedirect(ClassNode)
    isPrimaryClassNode()
  - public boolean isResolved()
    
    Determines whether this ClassNode has been resolved to an actual Java class. A ClassNode is considered resolved if it represents a real Class object loaded at runtime, or if it has been redirected to a resolved ClassNode, or if it represents an array of resolved component types. During early compilation phases, unresolved ClassNodes may reference types that haven't been loaded yet.
    Returns:
    true if this ClassNode has been resolved to a real class; false if it still represents an unresolved reference
  - public boolean isScript()
    
    Returns whether this ClassNode represents a Groovy script body. A script is a special class that executes at the top level rather than requiring instantiation. This method checks both the direct flag and whether the class derives from Script. During compilation, script bodies are compiled into classes that extend the Script base class.
    Returns:
    true if this class represents a script; false otherwise
    See Also:
    setScript(boolean)
    isScriptBody()
    isDerivedFrom(ClassNode)
  - public boolean isScriptBody()
    
    Returns whether this inner class or closure was declared inside a script body. This flag distinguishes between inner classes/closures defined within a script's top-level code versus those defined within regular class methods. Script body context affects how local variable access and scoping rules are applied. This method follows redirects if present.
    Returns:
    true if this inner class or closure is inside a script body; false otherwise
    See Also:
    setScriptBody(boolean)
    isScript()
    isStaticClass()
  - @Incubating
    public boolean isSealed()
    
    Returns:
    true for native and emulated (annotation based) sealed classes
    Since:
    4.0.0
  - public boolean isStaticClass()
    
    Returns whether this inner class or closure was declared inside a static method context. This flag identifies classes that are nested within static methods (as opposed to instance methods or top-level definitions). Inner classes in static contexts have different scoping rules and cannot access instance variables of the enclosing class. This method follows redirects if present.
    Returns:
    true if this class is declared in a static method; false otherwise
    See Also:
    setStaticClass(boolean)
    isScriptBody()
  - 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
  - public boolean isUsingGenerics()
  - public ClassNode makeArray()
    
    Returns a ClassNode representing an array of the type represented by this.
  - @Deprecated(forRemoval = true, since = "4.0.0")
    protected boolean parametersEqual(Parameter[] a, Parameter[] b)
  - public void positionStmtsAfterEnumInitStmts(List<Statement> staticFieldInitializerStatements)
  - public ClassNode redirect()
    
    Returns the ClassNode this node is a proxy for or the node itself. If this ClassNode has been set as a proxy to another ClassNode via setRedirect(ClassNode), recursively follows the redirect chain to return the ultimate target ClassNode. If no redirect is set, returns this. This mechanism allows lazy resolution of class references during compilation.
    Returns:
    the final ClassNode in the redirect chain; never null
  - public void removeConstructor(ConstructorNode node)
  - public void removeField(String oldName)
    
    Removes the FieldNode with the given name from this ClassNode. This method removes the field from the internal field list and index. If this node is a proxy (has a redirect), the operation is performed on the redirect target.
    Parameters:
    oldName - the name of the field to remove
    See Also:
    addField(FieldNode)
    getField(String)
    FieldNode
  - public void removeMethod(MethodNode node)
    
    Removes the given MethodNode from this ClassNode. The method is removed from the internal methods list and the methods map. If this node is a proxy (has a redirect), the operation is performed on the redirect target.
    Parameters:
    node - the MethodNode to remove
    See Also:
    addMethod(MethodNode)
    getMethod(String, Parameter[])
    MethodNode
  - public void renameField(String oldName, String newName)
  - public void setAnnotated(boolean annotated)
    
    Marks this ClassNode as having annotations attached to it. This flag is used internally by the compiler to track whether annotations have been added to the class. It should be set to true when annotations are added and may be used as an optimization to avoid scanning the annotations list for empty cases.
    Parameters:
    annotated - true to mark as having annotations; false to clear the flag
    See Also:
    isAnnotated()
    addAnnotation(AnnotationNode)
    addTypeAnnotation(AnnotationNode)
  - @Deprecated(forRemoval = true, since = "5.0.0")
    protected void setCompileUnit(CompileUnit cu)
  - public void setEnclosingMethod(MethodNode enclosingMethod)
    
    Sets the enclosing MethodNode for this local inner class. This is typically called when processing classes declared within method bodies.
    Parameters:
    enclosingMethod - the MethodNode enclosing this class, or null
    See Also:
    getEnclosingMethod()
  - public void setGenericsPlaceHolder(boolean placeholder)
  - public void setGenericsTypes(GenericsType[] genericsTypes)
    
    Sets the generic type parameters for this ClassNode. Setting generics types updates the generics usage indicator for this class. This method is typically called during compiler phases when type information becomes available.
    Parameters:
    genericsTypes - an array of GenericsType representing the type parameters, or null
    See Also:
    getGenericsTypes()
    isUsingGenerics()
  - public void setInterfaces(ClassNode[] interfaces)
    
    Sets the interfaces implemented by this ClassNode. If this ClassNode has a redirect, the interfaces are set on the redirect instead. Updates the generics usage indicator if any interface uses generics and this is a primary ClassNode.
    Parameters:
    interfaces - an array of ClassNode representing the interfaces, or null
    See Also:
    getInterfaces()
    addInterface(ClassNode)
    isUsingGenerics()
  - public void setMixins(MixinNode[] mixins)
  - public void setModifiers(int modifiers)
    
    Sets the modifier flags for this ClassNode. The modifiers are a bitmask of ASM/bytecode convention flags (e.g., ACC_PUBLIC, ACC_ABSTRACT, ACC_INTERFACE, ACC_ENUM). Calling this method directly on a redirect node updates the redirect's modifiers instead of this node's. Use this method to control visibility and structural attributes like abstractness or finality.
    Parameters:
    modifiers - the new modifier flags as a bitmask
    See Also:
    getModifiers()
    isAbstract()
    isInterface()
  - public void setModule(ModuleNode module)
  - public String setName(String name)
    
    Sets the fully-qualified name of this class, delegating to the redirect if one exists. Allows the class name to be updated after construction, which is occasionally used during AST transformation phases. Changes are propagated to the redirect target if present.
    Parameters:
    name - the new fully-qualified class name to set
    Returns:
    the name that was set
  - @Incubating
    public void setPermittedSubclasses(List<ClassNode> permittedSubclasses)
  - @Incubating
    public void setRecordComponents(List<RecordComponentNode> recordComponents)
    
    Sets the record components for record type.
    Since:
    4.0.0
  - public void setRedirect(ClassNode node)
    
    Sets this instance as a proxy for the given ClassNode, enabling deferred class resolution. After calling this method, most operations on this ClassNode are forwarded to the target ClassNode. Redirect is only allowed for non-primary ClassNodes (see isPrimaryClassNode()). If the target is null, the redirect is removed, making this node standalone again.
    throws:
    GroovyBugError if this is a primary ClassNode, as redirects are only for proxy nodes
    
    Parameters:
    node - the ClassNode to redirect to; if null the redirect is cleared
  - public void setScript(boolean script)
    
    Marks this ClassNode as a script or removes the script flag. Setting this to true indicates that this class represents a Groovy script that should be executed at the top level. This is used internally during compilation to identify script classes that need special treatment (e.g., extending the Script base class).
    Parameters:
    script - true to mark as a script; false to unmark
    See Also:
    isScript()
    setScriptBody(boolean)
  - public void setScriptBody(boolean scriptBody)
    
    Marks this inner class or closure as being declared inside a script body. When set to true, indicates that the class definition occurs at the top level of a Groovy script (outside of any method or class definition). This affects variable scoping and how the compiler generates code for accessing enclosing scope variables. Typically used by the compiler during script class generation.
    Parameters:
    scriptBody - true to mark as defined in script body; false otherwise
    See Also:
    isScriptBody()
    setStaticClass(boolean)
  - public void setStaticClass(boolean staticClass)
    
    Marks this inner class or closure as being declared in a static method context. When set to true, indicates that this class definition occurs within a static method, affecting how the compiler generates access to enclosing class members. Static inner classes have restricted access to the enclosing class (only to static members).
    Parameters:
    staticClass - true to mark as defined in a static context; false otherwise
    See Also:
    isStaticClass()
    setScriptBody(boolean)
  - public void setSuperClass(ClassNode superClass)
    
    Sets the super class of this ClassNode. If this ClassNode has a redirect, the super class is set on the redirect instead. Updates the generics usage indicator if the super class uses generics and this is a primary ClassNode.
    Parameters:
    superClass - the ClassNode representing the super class, or null
    See Also:
    getSuperClass()
    isUsingGenerics()
  - public void setSyntheticPublic(boolean syntheticPublic)
    
    Marks this ClassNode as having synthetic public visibility. When set to true, indicates that this class was implicitly made public by Groovy's default visibility rule rather than having an explicit public modifier in the source code. This distinction is important for AST transformations that need to preserve the original intent regarding visibility and access control.
    Parameters:
    syntheticPublic - true if public was added by the compiler; false if explicitly declared
    See Also:
    isSyntheticPublic()
    getModifiers()
  - public void setUnresolvedSuperClass(ClassNode superClass)
    
    Sets the unresolved super class for this ClassNode. This method sets the raw superclass without applying any redirect resolution.
    Parameters:
    superClass - the ClassNode representing the super class, or null
  - public void setUsingGenerics(boolean usesGenerics)
  - public String toString()
    
    Returns a string representation of this ClassNode for debugging and display purposes. For array types, appends "[]" to the component type's string representation. For generic types, includes generic type parameters (e.g., "List"). If this is a redirect node, includes arrow notation showing the redirect target.
    Returns:
    a string representation of this ClassNode, including fully-qualified name and type information
  - public String toString(boolean showRedirect)
    
    Returns a string representation of this ClassNode with optional redirect information. For array types, appends "[]" to the component type's string representation. For generic types, includes generic type parameters (e.g., "List"). If showRedirect is true and this is a redirect node, includes arrow notation showing the redirect target; otherwise the redirect information is omitted.
    Parameters:
    showRedirect - if true, includes redirect information in the output; if false, omits it
    Returns:
    a string representation of this ClassNode
  - public MethodNode tryFindPossibleMethod(String name, Expression arguments)
  - public void visitContents(GroovyClassVisitor visitor)

Summary:
Field
Constructor
Method

| Detail:
Field
Constructor
Method

[Java] Class ClassNode

Field Summary

Constructor Summary

Methods Summary

Inherited Methods Summary

Field Detail

public static final ClassNode[] EMPTY_ARRAY

public static final ClassNode SUPER

public static final ClassNode THIS

protected Class<?> clazz

protected boolean isPrimaryNode

protected final Object lazyInitLock

Constructor Detail

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

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

public ClassNode(Class<?> c)

Method Detail

public void addConstructor(ConstructorNode node)

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

public void addField(FieldNode node)

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

public void addFieldFirst(FieldNode node)

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

public void addInterface(ClassNode node)

public void addMethod(MethodNode node)

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

public void addMixin(MixinNode node)

public void addObjectInitializerStatements(Statement statement)

public void addProperty(PropertyNode node)

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

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

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

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

public void addTypeAnnotation(AnnotationNode annotation)

public void addTypeAnnotations(List<AnnotationNode> annotations)

public GenericsType asGenericsType()

public boolean declaresAnyInterfaces(ClassNode classNodes)

public boolean declaresInterface(ClassNode classNode)

public boolean equals(Object that)

public List<MethodNode> getAbstractMethods()

public List<MethodNode> getAllDeclaredMethods()

public Set<ClassNode> getAllInterfaces()

public List<AnnotationNode> getAnnotations()

public List<AnnotationNode> getAnnotations(ClassNode type)

public CompileUnit getCompileUnit()

public ClassNode getComponentType()

public ConstructorNode getDeclaredConstructor(Parameter[] parameters)

public List<ConstructorNode> getDeclaredConstructors()

public FieldNode getDeclaredField(String name)

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

public List<MethodNode> getDeclaredMethods(String name)

public Map<String, MethodNode> getDeclaredMethodsMap()

public MethodNode getEnclosingMethod()

public FieldNode getField(String name)

@Deprecated(forRemoval = true, since = "5.0.0")public Map<String, FieldNode> getFieldIndex()

public List<FieldNode> getFields()

public GenericsType[] getGenericsTypes()

public MethodNode getGetterMethod(String getterName)

public MethodNode getGetterMethod(String getterName, boolean searchSupers)

public Iterator<InnerClassNode> getInnerClasses()

public ClassNode[] getInterfaces()

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

public List<MethodNode> getMethods()

public List<MethodNode> getMethods(String name)

public MixinNode[] getMixins()

public int getModifiers()

public ModuleNode getModule()

public String getName()

public String getNameWithoutPackage()

public List<Statement> getObjectInitializerStatements()

public ClassNode getOuterClass()

public List<ClassNode> getOuterClasses()

public FieldNode getOuterField(String name)

public PackageNode getPackage()

public String getPackageName()

@Incubatingpublic List<ClassNode> getPermittedSubclasses()

public ClassNode getPlainNodeReference()

public ClassNode getPlainNodeReference(boolean skipPrimitives)

public List<PropertyNode> getProperties()

public PropertyNode getProperty(String name)

@Deprecated(forRemoval = true, since = "5.0.0")
public Map<String, FieldNode> getFieldIndex()

@Incubating
public List<ClassNode> getPermittedSubclasses()

@Incubating
public List<RecordComponentNode> getRecordComponents()

@Incubating
public boolean isRecord()

@Incubating
public boolean isSealed()

@Deprecated(forRemoval = true, since = "4.0.0")
protected boolean parametersEqual(Parameter[] a, Parameter[] b)

@Deprecated(forRemoval = true, since = "5.0.0")
protected void setCompileUnit(CompileUnit cu)

@Incubating
public void setPermittedSubclasses(List<ClassNode> permittedSubclasses)

@Incubating
public void setRecordComponents(List<RecordComponentNode> recordComponents)