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:

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.

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

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.

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.