/**
* Creates a ClassNode from a real class. The resulting ClassNode will not be a primary ClassNode.
*/
public ClassNode(Class c) {
this(c.getName(), c.getModifiers(), null, null, MixinNode.EMPTY_ARRAY);
clazz = c;
lazyInitDone = false;
CompileUnit cu = getCompileUnit();
if (cu != null) cu.addClass(this);
isPrimaryNode = false;
}
private void makeInterfaceTypes(CompileUnit cu, ClassNode classNode, Class clazz) {
Type[] interfaceTypes = clazz.getGenericInterfaces();
if (interfaceTypes.length == 0) {
classNode.setInterfaces(ClassNode.EMPTY_ARRAY);
} else {
Class[] interfaceClasses = clazz.getInterfaces();
ClassNode[] ret = new ClassNode[interfaceTypes.length];
for (int i = 0; i < interfaceTypes.length; i++) {
ret[i] = makeClassNode(cu, interfaceTypes[i], interfaceClasses[i]);
}
classNode.setInterfaces(ret);
}
}
private ClassNode configureClass(Class c) {
if (c.isPrimitive()) {
return ClassHelper.make(c);
} else {
return ClassHelper.makeWithoutCaching(c, false);
}
}
@SuppressWarnings("Unchecked")
public static Object checkImmutable(Class<?> clazz, String fieldName, Object field) {
Immutable immutable = (Immutable) clazz.getAnnotation(MY_CLASS);
List<Class> knownImmutableClasses = new ArrayList<Class>();
if (immutable != null && immutable.knownImmutableClasses().length > 0) {
knownImmutableClasses = Arrays.asList(immutable.knownImmutableClasses());
}
if (field == null
|| field instanceof Enum
|| inImmutableList(field.getClass().getName())
|| knownImmutableClasses.contains(field.getClass())) return field;
if (field instanceof Collection) return DefaultGroovyMethods.asImmutable((Collection) field);
if (field.getClass().getAnnotation(MY_CLASS) != null) return field;
final String typeName = field.getClass().getName();
throw new RuntimeException(
createErrorMessage(clazz.getName(), fieldName, typeName, "constructing"));
}
@SuppressWarnings("unchecked")
public <T extends Enum> T getEnumMemberValue(
AnnotationNode node, String name, Class<T> type, T defaultValue) {
if (node == null) return defaultValue;
final PropertyExpression member = (PropertyExpression) node.getMember(name);
if (member == null) return defaultValue;
if (!type.equals(member.getObjectExpression().getType().getTypeClass())) return defaultValue;
try {
String value = member.getPropertyAsString();
Method fromString = type.getMethod("valueOf", String.class);
return (T) fromString.invoke(null, value);
} catch (Exception e) {
return defaultValue;
}
}
private ClassNode makeClassNode(CompileUnit cu, Type t, Class c) {
ClassNode back = null;
if (cu != null) back = cu.getClass(c.getName());
if (back == null) back = ClassHelper.make(c);
if (!(t instanceof Class)) {
ClassNode front = configureType(t);
front.setRedirect(back);
return front;
}
return back;
}
public void addTransform(Class<? extends ASTTransformation> transform, ASTNode node) {
GroovyASTTransformation annotation = transform.getAnnotation(GroovyASTTransformation.class);
if (annotation == null) return;
Set<ASTNode> nodes = getTransformInstances().get(annotation.phase()).get(transform);
if (nodes == null) {
nodes = new LinkedHashSet<ASTNode>();
getTransformInstances().get(annotation.phase()).put(transform, nodes);
}
nodes.add(node);
}
private void configureAnnotation(AnnotationNode node, Annotation annotation) {
Class type = annotation.annotationType();
if (type == Retention.class) {
Retention r = (Retention) annotation;
RetentionPolicy value = r.value();
setRetentionPolicy(value, node);
node.setMember(
"value",
new PropertyExpression(
new ClassExpression(ClassHelper.makeWithoutCaching(RetentionPolicy.class, false)),
value.toString()));
} else if (type == Target.class) {
Target t = (Target) annotation;
ElementType[] elements = t.value();
ListExpression elementExprs = new ListExpression();
for (ElementType element : elements) {
elementExprs.addExpression(
new PropertyExpression(
new ClassExpression(ClassHelper.ELEMENT_TYPE_TYPE), element.name()));
}
node.setMember("value", elementExprs);
} else {
Method[] declaredMethods = type.getDeclaredMethods();
for (int i = 0; i < declaredMethods.length; i++) {
Method declaredMethod = declaredMethods[i];
try {
Object value = declaredMethod.invoke(annotation);
Expression valueExpression = annotationValueToExpression(value);
if (valueExpression == null) continue;
node.setMember(declaredMethod.getName(), valueExpression);
} catch (IllegalAccessException e) {
} catch (InvocationTargetException e) {
}
}
}
}
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);
}
}