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 and 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 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_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_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

Fields inherited from interface groovy.lang.groovydoc.GroovydocHolder

DOC_COMMENT

Constructor Summary

Constructors

Constructor and 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

Modifier and Type	Method and Description
void	addConstructor(ConstructorNode node)
ConstructorNode	addConstructor(int modifiers, Parameter[] parameters, ClassNode[] exceptions, Statement code)
void	addField(FieldNode node)
FieldNode	addField(String name, int modifiers, ClassNode type, Expression initialValue)
void	addFieldFirst(FieldNode node)
FieldNode	addFieldFirst(String name, int modifiers, ClassNode type, Expression initialValue)
void	addInterface(ClassNode type)
void	addMethod(MethodNode node)
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	addMixin(MixinNode mixin)
void	addObjectInitializerStatements(Statement statements) Adds a statement to the object initializer.
void	addProperty(PropertyNode node)
PropertyNode	addProperty(String name, int modifiers, ClassNode type, Expression initialValueExpression, Statement getterBlock, Statement setterBlock)
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