private static Set<String> createDelegateMethodList(Class superClass, Class[] interfaces) {
Set<String> selectedMethods = new HashSet<String>();
List<Method> interfaceMethods = new ArrayList<Method>();
if (interfaces != null) {
for (Class thisInterface : interfaces) {
getInheritedMethods(thisInterface, interfaceMethods);
}
for (Method method : interfaceMethods) {
if (!containsEquivalentMethod(OBJECT_METHODS, method)
&& !containsEquivalentMethod(GROOVYOBJECT_METHODS, method)) {
selectedMethods.add(method.getName());
}
}
}
List<Method> additionalMethods = getInheritedMethods(superClass, new ArrayList<Method>());
for (Method method : additionalMethods) {
if (method.getName().indexOf('$') != -1) continue;
if (!containsEquivalentMethod(interfaceMethods, method)
&& !containsEquivalentMethod(OBJECT_METHODS, method)
&& !containsEquivalentMethod(GROOVYOBJECT_METHODS, method)) {
selectedMethods.add(method.getName());
}
}
return selectedMethods;
}
@Override
public void visit(
final int version,
final int access,
final String name,
final String signature,
final String superName,
final String[] interfaces) {
Set<String> interfacesSet = new LinkedHashSet<String>();
if (interfaces != null) Collections.addAll(interfacesSet, interfaces);
for (Class extraInterface : classList) {
if (extraInterface.isInterface())
interfacesSet.add(BytecodeHelper.getClassInternalName(extraInterface));
}
final boolean addGroovyObjectSupport = !GroovyObject.class.isAssignableFrom(superClass);
if (addGroovyObjectSupport) interfacesSet.add("groovy/lang/GroovyObject");
super.visit(
V1_5,
ACC_PUBLIC,
proxyName,
signature,
BytecodeHelper.getClassInternalName(superClass),
interfacesSet.toArray(new String[interfacesSet.size()]));
addDelegateFields();
if (addGroovyObjectSupport) {
createGroovyObjectSupport();
}
for (Class clazz : classList) {
visitClass(clazz);
}
}
private void writeGetters(ClassVisitor visitor, Type generatedType, ModelProperty<?> property) {
Class<?> propertyClass = property.getType().getConcreteClass();
Type propertyType = Type.getType(propertyClass);
Set<String> processedNames = Sets.newHashSet();
for (WeaklyTypeReferencingMethod<?, ?> weakGetter : property.getGetters()) {
Method getter = weakGetter.getMethod();
if (!processedNames.add(getter.getName())) {
continue;
}
MethodVisitor methodVisitor =
declareMethod(
visitor,
getter.getName(),
Type.getMethodDescriptor(propertyType),
AsmClassGeneratorUtils.signature(getter));
putStateFieldValueOnStack(methodVisitor, generatedType);
putConstantOnStack(methodVisitor, property.getName());
invokeStateGetMethod(methodVisitor);
castFirstStackElement(methodVisitor, propertyClass);
finishVisitingMethod(methodVisitor, returnCode(propertyType));
}
}
@Override
public MethodVisitor visitMethod(
final int access,
final String name,
final String desc,
final String signature,
final String[] exceptions) {
Object key = Arrays.asList(name, desc);
if (visitedMethods.contains(key)) return EMPTY_VISITOR;
if (Modifier.isPrivate(access)
|| Modifier.isNative(access)
|| ((access & ACC_SYNTHETIC) != 0)) {
// do not generate bytecode for private methods
return EMPTY_VISITOR;
}
int accessFlags = access;
visitedMethods.add(key);
if ((objectDelegateMethods.contains(name)
|| delegatedClosures.containsKey(name)
|| (!"<init>".equals(name) && hasWildcard))
&& !Modifier.isStatic(access)
&& !Modifier.isFinal(access)) {
if (!GROOVYOBJECT_METHOD_NAMESS.contains(name)) {
if (Modifier.isAbstract(access)) {
// prevents the proxy from being abstract
accessFlags -= ACC_ABSTRACT;
}
if (delegatedClosures.containsKey(name) || (!"<init>".equals(name) && hasWildcard)) {
delegatedClosures.put(name, Boolean.TRUE);
return makeDelegateToClosureCall(name, desc, signature, exceptions, accessFlags);
}
if (generateDelegateField && objectDelegateMethods.contains(name)) {
return makeDelegateCall(name, desc, signature, exceptions, accessFlags);
}
delegatedClosures.put(name, Boolean.TRUE);
return makeDelegateToClosureCall(name, desc, signature, exceptions, accessFlags);
}
} else if ("<init>".equals(name)
&& (Modifier.isPublic(access) || Modifier.isProtected(access))) {
return createConstructor(access, name, desc, signature, exceptions);
} else if (Modifier.isAbstract(access) && !GROOVYOBJECT_METHOD_NAMESS.contains(name)) {
accessFlags -= ACC_ABSTRACT;
MethodVisitor mv = super.visitMethod(accessFlags, name, desc, signature, exceptions);
mv.visitCode();
Type[] args = Type.getArgumentTypes(desc);
if (emptyBody) {
Type returnType = Type.getReturnType(desc);
if (returnType == Type.VOID_TYPE) {
mv.visitInsn(RETURN);
} else {
int loadIns = getLoadInsn(returnType);
switch (loadIns) {
case ILOAD:
mv.visitInsn(ICONST_0);
break;
case LLOAD:
mv.visitInsn(LCONST_0);
break;
case FLOAD:
mv.visitInsn(FCONST_0);
break;
case DLOAD:
mv.visitInsn(DCONST_0);
break;
default:
mv.visitInsn(ACONST_NULL);
}
mv.visitInsn(getReturnInsn(returnType));
mv.visitMaxs(2, registerLen(args) + 1);
}
} else {
// for compatibility with the legacy proxy generator, we should throw an
// UnsupportedOperationException
// instead of an AbtractMethodException
mv.visitTypeInsn(NEW, "java/lang/UnsupportedOperationException");
mv.visitInsn(DUP);
mv.visitMethodInsn(
INVOKESPECIAL, "java/lang/UnsupportedOperationException", "<init>", "()V");
mv.visitInsn(ATHROW);
mv.visitMaxs(2, registerLen(args) + 1);
}
mv.visitEnd();
}
return EMPTY_VISITOR;
}