/**
* 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 {@link
* #getPlainNodeReference()}.
*
* @return the class this classnode relates to. May return null.
*/
public Class getTypeClass() {
if (clazz != null) return clazz;
if (redirect != null) return redirect.getTypeClass();
ClassNode component = redirect().componentType;
if (component != null && component.isResolved()) {
return Array.newInstance(component.getTypeClass(), 0).getClass();
}
throw new GroovyBugError(
"ClassNode#getTypeClass for " + getName() + " is called before the type class is set ");
}
public static String getClassInternalName(ClassNode t) {
if (t.isPrimaryClassNode()) {
if (t.isArray()) return "[L" + getClassInternalName(t.getComponentType()) + ";";
return getClassInternalName(t.getName());
}
return getClassInternalName(t.getTypeClass());
}
private void configureAnnotationFromDefinition(AnnotationNode definition, AnnotationNode root) {
ClassNode type = definition.getClassNode();
if (!type.isResolved()) return;
Class clazz = type.getTypeClass();
if (clazz == Retention.class) {
Expression exp = definition.getMember("value");
if (!(exp instanceof PropertyExpression)) return;
PropertyExpression pe = (PropertyExpression) exp;
String name = pe.getPropertyAsString();
RetentionPolicy policy = RetentionPolicy.valueOf(name);
setRetentionPolicy(policy, root);
} else if (clazz == Target.class) {
Expression exp = definition.getMember("value");
if (!(exp instanceof ListExpression)) return;
ListExpression le = (ListExpression) exp;
int bitmap = 0;
for (Expression e : le.getExpressions()) {
PropertyExpression element = (PropertyExpression) e;
String name = element.getPropertyAsString();
ElementType value = ElementType.valueOf(name);
bitmap |= getElementCode(value);
}
root.setAllowedTargets(bitmap);
}
}
public void configureClassNode(CompileUnit compileUnit, ClassNode classNode) {
Class clazz = classNode.getTypeClass();
Field[] fields = clazz.getDeclaredFields();
for (Field f : fields) {
ClassNode ret = makeClassNode(compileUnit, f.getGenericType(), f.getType());
classNode.addField(f.getName(), f.getModifiers(), ret, null);
}
Method[] methods = clazz.getDeclaredMethods();
for (Method m : methods) {
ClassNode ret = makeClassNode(compileUnit, m.getGenericReturnType(), m.getReturnType());
Parameter[] params =
makeParameters(compileUnit, m.getGenericParameterTypes(), m.getParameterTypes());
ClassNode[] exceptions =
makeClassNodes(compileUnit, m.getGenericExceptionTypes(), m.getExceptionTypes());
MethodNode mn = new MethodNode(m.getName(), m.getModifiers(), ret, params, exceptions, null);
setMethodDefaultValue(mn, m);
setAnnotationMetaData(m.getAnnotations(), mn);
mn.setGenericsTypes(configureTypeVariable(m.getTypeParameters()));
classNode.addMethod(mn);
}
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor ctor : constructors) {
Parameter[] params =
makeParameters(compileUnit, ctor.getGenericParameterTypes(), ctor.getParameterTypes());
ClassNode[] exceptions =
makeClassNodes(compileUnit, ctor.getGenericExceptionTypes(), ctor.getExceptionTypes());
classNode.addConstructor(ctor.getModifiers(), params, exceptions, null);
}
Class sc = clazz.getSuperclass();
if (sc != null)
classNode.setUnresolvedSuperClass(
makeClassNode(compileUnit, clazz.getGenericSuperclass(), sc));
makeInterfaceTypes(compileUnit, classNode, clazz);
setAnnotationMetaData(classNode.getTypeClass().getAnnotations(), classNode);
PackageNode packageNode = classNode.getPackage();
if (packageNode != null) {
setAnnotationMetaData(classNode.getTypeClass().getPackage().getAnnotations(), packageNode);
}
}
private static Annotation getTransformClassAnnotation(ClassNode annotatedType) {
if (!annotatedType.isResolved()) return null;
for (Annotation ann : annotatedType.getTypeClass().getAnnotations()) {
// because compiler clients are free to choose any GroovyClassLoader for
// resolving ClassNodeS such as annotatedType, we have to compare by name,
// and cannot cast the return value to GroovyASTTransformationClass
if (ann.annotationType().getName().equals(GroovyASTTransformationClass.class.getName())) {
return ann;
}
}
return null;
}
/** box top level operand */
public static boolean box(MethodVisitor mv, ClassNode type) {
if (type.isPrimaryClassNode()) return false;
return box(mv, type.getTypeClass());
}
public static void unbox(MethodVisitor mv, ClassNode type) {
if (type.isPrimaryClassNode()) return;
unbox(mv, type.getTypeClass());
}
private void setGenericsTypes(ClassNode cn) {
TypeVariable[] tvs = cn.getTypeClass().getTypeParameters();
GenericsType[] gts = configureTypeVariable(tvs);
cn.setGenericsTypes(gts);
}
public static String getClassInternalName(ClassNode t) {
if (t.isPrimaryClassNode()) {
return getClassInternalName(t.getName());
}
return getClassInternalName(t.getTypeClass());
}
public void configureClassNode(CompileUnit compileUnit, ClassNode classNode) {
try {
Class clazz = classNode.getTypeClass();
Field[] fields = clazz.getDeclaredFields();
for (Field f : fields) {
ClassNode ret = makeClassNode(compileUnit, f.getGenericType(), f.getType());
FieldNode fn = new FieldNode(f.getName(), f.getModifiers(), ret, classNode, null);
setAnnotationMetaData(f.getAnnotations(), fn);
classNode.addField(fn);
}
Method[] methods = clazz.getDeclaredMethods();
for (Method m : methods) {
ClassNode ret = makeClassNode(compileUnit, m.getGenericReturnType(), m.getReturnType());
Parameter[] params =
makeParameters(
compileUnit,
m.getGenericParameterTypes(),
m.getParameterTypes(),
m.getParameterAnnotations());
ClassNode[] exceptions =
makeClassNodes(compileUnit, m.getGenericExceptionTypes(), m.getExceptionTypes());
MethodNode mn =
new MethodNode(m.getName(), m.getModifiers(), ret, params, exceptions, null);
mn.setSynthetic(m.isSynthetic());
setMethodDefaultValue(mn, m);
setAnnotationMetaData(m.getAnnotations(), mn);
mn.setGenericsTypes(configureTypeVariable(m.getTypeParameters()));
classNode.addMethod(mn);
}
Constructor[] constructors = clazz.getDeclaredConstructors();
for (Constructor ctor : constructors) {
Parameter[] params =
makeParameters(
compileUnit,
ctor.getGenericParameterTypes(),
ctor.getParameterTypes(),
ctor.getParameterAnnotations());
ClassNode[] exceptions =
makeClassNodes(compileUnit, ctor.getGenericExceptionTypes(), ctor.getExceptionTypes());
classNode.addConstructor(ctor.getModifiers(), params, exceptions, null);
}
Class sc = clazz.getSuperclass();
if (sc != null)
classNode.setUnresolvedSuperClass(
makeClassNode(compileUnit, clazz.getGenericSuperclass(), sc));
makeInterfaceTypes(compileUnit, classNode, clazz);
setAnnotationMetaData(classNode.getTypeClass().getAnnotations(), classNode);
PackageNode packageNode = classNode.getPackage();
if (packageNode != null) {
setAnnotationMetaData(classNode.getTypeClass().getPackage().getAnnotations(), packageNode);
}
} catch (NoClassDefFoundError e) {
throw new NoClassDefFoundError(
"Unable to load class "
+ classNode.toString(false)
+ " due to missing dependency "
+ e.getMessage());
} catch (MalformedParameterizedTypeException e) {
throw new RuntimeException(
"Unable to configure class node for class "
+ classNode.toString(false)
+ " due to malformed parameterized types",
e);
}
}
