private void writeNonAbstractMethodWrapper(
ClassVisitor visitor, Type generatedType, Class<?> managedTypeClass, Method method) {
Label start = new Label();
Label end = new Label();
Label handler = new Label();
MethodVisitor methodVisitor = declareMethod(visitor, method);
methodVisitor.visitTryCatchBlock(start, end, handler, null);
setCanCallSettersField(methodVisitor, generatedType, false);
methodVisitor.visitLabel(start);
invokeSuperMethod(methodVisitor, managedTypeClass, method);
methodVisitor.visitLabel(end);
setCanCallSettersField(methodVisitor, generatedType, true);
methodVisitor.visitInsn(ARETURN);
methodVisitor.visitLabel(handler);
setCanCallSettersField(methodVisitor, generatedType, true);
methodVisitor.visitInsn(ATHROW);
methodVisitor.visitMaxs(0, 0);
methodVisitor.visitEnd();
}
private void writeGroovyMethods(ClassVisitor visitor, Class<?> managedTypeClass) {
// Object propertyMissing(String name)
MethodVisitor methodVisitor =
declareMethod(
visitor, "propertyMissing", GET_PROPERTY_MISSING_METHOD_DESCRIPTOR, CONCRETE_SIGNATURE);
// throw new MissingPropertyException(name, <managed-type>.class)
methodVisitor.visitTypeInsn(NEW, MISSING_PROPERTY_EXCEPTION_TYPE);
methodVisitor.visitInsn(DUP);
putFirstMethodArgumentOnStack(methodVisitor);
putClassOnStack(methodVisitor, managedTypeClass);
methodVisitor.visitMethodInsn(
INVOKESPECIAL,
MISSING_PROPERTY_EXCEPTION_TYPE,
"<init>",
MISSING_PROPERTY_CONSTRUCTOR_DESCRIPTOR,
false);
finishVisitingMethod(methodVisitor, ATHROW);
// Object propertyMissing(String name, Object value)
methodVisitor =
declareMethod(
visitor, "propertyMissing", SET_PROPERTY_MISSING_METHOD_DESCRIPTOR, CONCRETE_SIGNATURE);
// throw new MissingPropertyException(name, <managed-type>.class)
methodVisitor.visitTypeInsn(NEW, MISSING_PROPERTY_EXCEPTION_TYPE);
methodVisitor.visitInsn(DUP);
putFirstMethodArgumentOnStack(methodVisitor);
putClassOnStack(methodVisitor, managedTypeClass);
methodVisitor.visitMethodInsn(
INVOKESPECIAL,
MISSING_PROPERTY_EXCEPTION_TYPE,
"<init>",
MISSING_PROPERTY_CONSTRUCTOR_DESCRIPTOR,
false);
finishVisitingMethod(methodVisitor, ATHROW);
// Object methodMissing(String name, Object args)
methodVisitor =
declareMethod(
visitor, "methodMissing", METHOD_MISSING_METHOD_DESCRIPTOR, CONCRETE_SIGNATURE);
// throw new MissingMethodException(name, <managed-type>.class, args)
methodVisitor.visitTypeInsn(NEW, MISSING_METHOD_EXCEPTION_TYPE);
methodVisitor.visitInsn(DUP);
putMethodArgumentOnStack(methodVisitor, 1);
putClassOnStack(methodVisitor, managedTypeClass);
putMethodArgumentOnStack(methodVisitor, 2);
methodVisitor.visitTypeInsn(CHECKCAST, OBJECT_ARRAY_TYPE);
methodVisitor.visitMethodInsn(
INVOKESPECIAL,
MISSING_METHOD_EXCEPTION_TYPE,
"<init>",
MISSING_METHOD_EXCEPTION_CONSTRUCTOR_DESCRIPTOR,
false);
finishVisitingMethod(methodVisitor, ATHROW);
}
private void throwExceptionBecauseCalledOnItself(MethodVisitor methodVisitor) {
String exceptionInternalName = Type.getInternalName(UnsupportedOperationException.class);
methodVisitor.visitTypeInsn(NEW, exceptionInternalName);
methodVisitor.visitInsn(DUP);
putConstantOnStack(methodVisitor, "Calling setters of a managed type on itself is not allowed");
String constructorDescriptor = Type.getMethodDescriptor(Type.VOID_TYPE, STRING_TYPE);
methodVisitor.visitMethodInsn(
INVOKESPECIAL, exceptionInternalName, CONSTRUCTOR_NAME, constructorDescriptor, false);
methodVisitor.visitInsn(ATHROW);
}
private void pushDefaultValue(MethodVisitor methodVisitor, Class<?> primitiveType) {
int ins = ICONST_0;
if (long.class == primitiveType) {
ins = LCONST_0;
} else if (double.class == primitiveType) {
ins = DCONST_0;
} else if (float.class == primitiveType) {
ins = FCONST_0;
}
methodVisitor.visitInsn(ins);
}
private void unboxType(MethodVisitor methodVisitor, Class<?> primitiveClass) {
// Float f = (Float) tmp
// f==null?0:f.floatValue()
Class<?> boxedType = BOXED_TYPES.get(primitiveClass);
Type primitiveType = Type.getType(primitiveClass);
methodVisitor.visitTypeInsn(CHECKCAST, Type.getInternalName(boxedType));
methodVisitor.visitInsn(DUP);
Label exit = new Label();
Label elseValue = new Label();
methodVisitor.visitJumpInsn(IFNONNULL, elseValue);
methodVisitor.visitInsn(POP);
pushDefaultValue(methodVisitor, primitiveClass);
methodVisitor.visitJumpInsn(GOTO, exit);
methodVisitor.visitLabel(elseValue);
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
Type.getInternalName(boxedType),
primitiveClass.getSimpleName() + "Value",
Type.getMethodDescriptor(primitiveType),
false);
methodVisitor.visitLabel(exit);
}
// the overload of type Object for Groovy coercions: public void setFoo(Object foo)
private void createTypeConvertingSetter(
ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
if (!property.isWritable() || !(property.getSchema() instanceof ScalarValueSchema)) {
return;
}
Class<?> propertyClass = property.getType().getConcreteClass();
Type propertyType = Type.getType(propertyClass);
Class<?> boxedClass =
propertyClass.isPrimitive() ? BOXED_TYPES.get(propertyClass) : propertyClass;
Type boxedType = Type.getType(boxedClass);
Method setter = property.getSetter().getMethod();
MethodVisitor methodVisitor =
declareMethod(
visitor,
setter.getName(),
SET_OBJECT_PROPERTY_DESCRIPTOR,
SET_OBJECT_PROPERTY_DESCRIPTOR);
putThisOnStack(methodVisitor);
putTypeConverterFieldValueOnStack(methodVisitor, generatedType);
// Object converted = $typeConverter.convert(foo, Float.class, false);
methodVisitor.visitVarInsn(ALOAD, 1); // put var #1 ('foo') on the stack
methodVisitor.visitLdcInsn(boxedType); // push the constant Class onto the stack
methodVisitor.visitInsn(
propertyClass.isPrimitive()
? ICONST_1
: ICONST_0); // push int 1 or 0 (interpreted as true or false) onto the stack
methodVisitor.visitMethodInsn(
INVOKEINTERFACE,
TYPE_CONVERTER_TYPE.getInternalName(),
"convert",
COERCE_TO_SCALAR_DESCRIPTOR,
true);
methodVisitor.visitTypeInsn(CHECKCAST, boxedType.getInternalName());
if (propertyClass.isPrimitive()) {
unboxType(methodVisitor, propertyClass);
}
// invoke the typed setter, popping 'this' and 'converted' from the stack
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
setter.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, propertyType),
false);
finishVisitingMethod(methodVisitor);
}
private void writeEqualsMethod(ClassVisitor cw, Type generatedType) {
MethodVisitor methodVisitor =
cw.visitMethod(Opcodes.ACC_PUBLIC, "equals", EQUALS_METHOD_DESCRIPTOR, null, null);
methodVisitor.visitCode();
methodVisitor.visitVarInsn(ALOAD, 0);
methodVisitor.visitVarInsn(ALOAD, 1);
Label notSameLabel = new Label();
methodVisitor.visitJumpInsn(IF_ACMPNE, notSameLabel);
methodVisitor.visitInsn(ICONST_1);
methodVisitor.visitInsn(IRETURN);
methodVisitor.visitLabel(notSameLabel);
methodVisitor.visitVarInsn(ALOAD, 1);
methodVisitor.visitTypeInsn(INSTANCEOF, MANAGED_INSTANCE_TYPE);
Label notManagedInstanceLabel = new Label();
methodVisitor.visitJumpInsn(IFNE, notManagedInstanceLabel);
methodVisitor.visitInsn(ICONST_0);
methodVisitor.visitInsn(IRETURN);
methodVisitor.visitLabel(notManagedInstanceLabel);
methodVisitor.visitVarInsn(ALOAD, 0);
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
"getBackingNode",
GET_BACKING_NODE_METHOD_DESCRIPTOR,
false);
methodVisitor.visitVarInsn(ALOAD, 1);
methodVisitor.visitTypeInsn(CHECKCAST, MANAGED_INSTANCE_TYPE);
methodVisitor.visitMethodInsn(
INVOKEINTERFACE,
MANAGED_INSTANCE_TYPE,
"getBackingNode",
GET_BACKING_NODE_METHOD_DESCRIPTOR,
true);
methodVisitor.visitMethodInsn(
INVOKEINTERFACE, MUTABLE_MODEL_NODE_TYPE, "equals", EQUALS_METHOD_DESCRIPTOR, true);
finishVisitingMethod(methodVisitor, Opcodes.IRETURN);
}
private void writeHashCodeMethod(ClassVisitor visitor, Type generatedType) {
MethodVisitor methodVisitor =
declareMethod(visitor, "hashCode", HASH_CODE_METHOD_DESCRIPTOR, null);
methodVisitor.visitVarInsn(ALOAD, 0);
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
"getBackingNode",
GET_BACKING_NODE_METHOD_DESCRIPTOR,
false);
methodVisitor.visitMethodInsn(
INVOKEINTERFACE, MUTABLE_MODEL_NODE_TYPE, "hashCode", HASH_CODE_METHOD_DESCRIPTOR, true);
methodVisitor.visitInsn(IRETURN);
finishVisitingMethod(methodVisitor, Opcodes.IRETURN);
}
private void writeConfigureMethod(
ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
if (!property.isWritable() && property.getSchema() instanceof CompositeSchema) {
// Adds a void $propName(Closure<?> cl) method that delegates to model state
MethodVisitor methodVisitor =
declareMethod(
visitor,
property.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, CLOSURE_TYPE),
null);
putStateFieldValueOnStack(methodVisitor, generatedType);
putConstantOnStack(methodVisitor, property.getName());
putFirstMethodArgumentOnStack(methodVisitor);
methodVisitor.visitMethodInsn(
INVOKEINTERFACE,
MODEL_ELEMENT_STATE_TYPE_INTERNAL_NAME,
"apply",
STATE_APPLY_METHOD_DESCRIPTOR,
true);
finishVisitingMethod(methodVisitor);
return;
}
if (!property.isWritable() && property.getSchema() instanceof UnmanagedImplStructSchema) {
UnmanagedImplStructSchema<?> structSchema =
(UnmanagedImplStructSchema<?>) property.getSchema();
if (!structSchema.isAnnotated()) {
return;
}
// Adds a void $propName(Closure<?> cl) method that executes the closure
MethodVisitor methodVisitor =
declareMethod(
visitor,
property.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, CLOSURE_TYPE),
null);
putThisOnStack(methodVisitor);
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
property.getGetters().get(0).getName(),
Type.getMethodDescriptor(Type.getType(property.getType().getConcreteClass())),
false);
putFirstMethodArgumentOnStack(methodVisitor);
methodVisitor.visitMethodInsn(
INVOKESTATIC,
Type.getInternalName(ClosureBackedAction.class),
"execute",
Type.getMethodDescriptor(Type.VOID_TYPE, OBJECT_TYPE, CLOSURE_TYPE),
false);
finishVisitingMethod(methodVisitor);
return;
}
// Adds a void $propName(Closure<?> cl) method that throws MME, to avoid attempts to convert
// closure to something else
MethodVisitor methodVisitor =
declareMethod(
visitor,
property.getName(),
Type.getMethodDescriptor(Type.VOID_TYPE, CLOSURE_TYPE),
null);
putThisOnStack(methodVisitor);
putConstantOnStack(methodVisitor, property.getName());
methodVisitor.visitInsn(Opcodes.ICONST_1);
methodVisitor.visitTypeInsn(Opcodes.ANEWARRAY, OBJECT_TYPE.getInternalName());
methodVisitor.visitInsn(Opcodes.DUP);
methodVisitor.visitInsn(Opcodes.ICONST_0);
putFirstMethodArgumentOnStack(methodVisitor);
methodVisitor.visitInsn(Opcodes.AASTORE);
methodVisitor.visitMethodInsn(
INVOKEVIRTUAL,
generatedType.getInternalName(),
"methodMissing",
METHOD_MISSING_METHOD_DESCRIPTOR,
false);
finishVisitingMethod(methodVisitor);
}