@Override public boolean declaresInterface(final ClassNode classNode) { for (ClassNode delegate : delegates) { if (delegate.declaresInterface(classNode)) return true; } return false; }
/** * @param classNode the class node for the interface * @return true if this class declares that it implements the given interface * or if one of its interfaces extends directly or indirectly the interface */ public boolean declaresInterface(ClassNode classNode) { ClassNode[] interfaces = redirect().getInterfaces(); if (declaresInterfaceDirect(interfaces, classNode)) return true; List superInterfaces = Arrays.asList(interfaces); while (superInterfaces.size() > 0) { List keep = new ArrayList(); for (int i = 0; i < superInterfaces.size(); i++) { ClassNode cn = (ClassNode) superInterfaces.get(i); if (cn.declaresInterface(classNode)) return true; keep.addAll(Arrays.asList(cn.getInterfaces())); } superInterfaces = keep; } return false; }
/** * @param classNode the class node for the interface * @return true if this class or any base class implements the given interface */ public boolean implementsInterface(ClassNode classNode) { ClassNode node = redirect(); do { if (node.declaresInterface(classNode)) { return true; } node = node.getSuperClass(); } while (node != null); return false; }
/** * @param classNode the class node for the interface * @return true if this class declares that it implements the given interface * or if one of its interfaces extends directly or indirectly the interface */ public boolean declaresInterface(ClassNode classNode) { ClassNode[] interfaces = redirect().getInterfaces(); if (declaresInterfaceDirect(interfaces, classNode)) return true; List superInterfaces = Arrays.asList(interfaces); while (superInterfaces.size() > 0) { List keep = new ArrayList(); for (int i = 0; i < superInterfaces.size(); i++) { ClassNode cn = (ClassNode) superInterfaces.get(i); if (cn.declaresInterface(classNode)) return true; keep.addAll(Arrays.asList(cn.getInterfaces())); } superInterfaces = keep; } return false; }
/** * @param classNode the class node for the interface * @return true if this class declares that it implements the given interface * or if one of its interfaces extends directly or indirectly the interface * * NOTE: Doesn't consider an interface to implement itself. * I think this is intended to be called on ClassNodes representing * classes, not interfaces. * */ public boolean declaresInterface(ClassNode classNode) { ClassNode[] interfaces = redirect().getInterfaces(); for (ClassNode cn : interfaces) { if (cn.equals(classNode)) return true; } for (ClassNode cn : interfaces) { if (cn.declaresInterface(classNode)) return true; } return false; }
/** * @param classNode the class node for the interface * @return true if this class declares that it implements the given interface * or if one of its interfaces extends directly or indirectly the interface */ public boolean declaresInterface(ClassNode classNode) { ClassNode[] interfaces = redirect().getInterfaces(); if (declaresInterfaceDirect(interfaces, classNode)) return true; List superInterfaces = Arrays.asList(interfaces); while (superInterfaces.size() > 0) { List keep = new ArrayList(); for (int i = 0; i < superInterfaces.size(); i++) { ClassNode cn = (ClassNode) superInterfaces.get(i); if (cn.declaresInterface(classNode)) return true; keep.addAll(Arrays.asList(cn.getInterfaces())); } superInterfaces = keep; } return false; }
private MethodNode getCompatibleMethod(ClassNode current, String getAt, ClassNode aType) { // TODO this really should find "best" match or find all matches and complain about ambiguity if more than one // TODO handle getAt with more than one parameter // TODO handle default getAt methods on Java 8 interfaces for (MethodNode methodNode : current.getDeclaredMethods("getAt")) { if (methodNode.getParameters().length == 1) { ClassNode paramType = methodNode.getParameters()[0].getType(); if (aType.isDerivedFrom(paramType) || aType.declaresInterface(paramType)) { return methodNode; } } } return null; }
public void createMopMethods() { ClassNode classNode = controller.getClassNode(); if (classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) { return; } Set<MopKey> currentClassSignatures = buildCurrentClassSignatureSet(classNode.getMethods()); visitMopMethodList(classNode.getMethods(), true, Collections.EMPTY_SET, Collections.EMPTY_LIST); visitMopMethodList(classNode.getSuperClass().getAllDeclaredMethods(), false, currentClassSignatures, controller.getSuperMethodNames()); }
public boolean addGeneratedClosureConstructorCall(ConstructorCallExpression call) { ClassNode classNode = controller.getClassNode(); if (!classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) return false; AsmClassGenerator acg = controller.getAcg(); OperandStack operandStack = controller.getOperandStack(); MethodVisitor mv = controller.getMethodVisitor(); mv.visitVarInsn(ALOAD, 0); ClassNode callNode = classNode.getSuperClass(); TupleExpression arguments = (TupleExpression) call.getArguments(); if (arguments.getExpressions().size()!=2) throw new GroovyBugError("expected 2 arguments for closure constructor super call, but got"+arguments.getExpressions().size()); arguments.getExpression(0).visit(acg); operandStack.box(); arguments.getExpression(1).visit(acg); operandStack.box(); //TODO: replace with normal String, p not needed Parameter p = new Parameter(ClassHelper.OBJECT_TYPE,"_p"); String descriptor = BytecodeHelper.getMethodDescriptor(ClassHelper.VOID_TYPE, new Parameter[]{p,p}); mv.visitMethodInsn(INVOKESPECIAL, BytecodeHelper.getClassInternalName(callNode), "<init>", descriptor, false); operandStack.remove(2); return true; }
staticInitCall )), false); if (fieldHelperClassNode != null && !cNode.declaresInterface(fieldHelperClassNode)) {
private boolean isTypeCompatible(ClassNode base, ClassNode target) { return target.equals(base) || target.implementsInterface(base) || target.declaresInterface(base); }
/** * @param classNode the class node for the interface * @return true if this class or any base class implements the given interface */ public boolean implementsInterface(ClassNode classNode) { ClassNode node = redirect(); do { if (node.declaresInterface(classNode)) { return true; } node = node.getSuperClass(); } while (node != null); return false; }
/** * @param classNode the class node for the interface * @return true if this class or any base class implements the given interface */ public boolean implementsInterface(ClassNode classNode) { ClassNode node = redirect(); do { if (node.declaresInterface(classNode)) { return true; } node = node.getSuperClass(); } while (node != null); return false; }
/** * @param classNode the class node for the interface * @return true if this class or any base class implements the given interface */ public boolean implementsInterface(ClassNode classNode) { ClassNode node = redirect(); do { if (node.declaresInterface(classNode)) { return true; } node = node.getSuperClass(); } while (node != null); return false; }
/** * @param classNode the class node for the interface * @return true if this class or any base class implements the given interface */ public boolean implementsInterface(ClassNode classNode) { ClassNode node = redirect(); do { if (node.declaresInterface(classNode)) { return true; } node = node.getSuperClass(); } while (node != null); return false; }
/** * @param classNode the class node for the interface * @return true if this class declares that it implements the given interface * or if one of its interfaces extends directly or indirectly the interface * * NOTE: Doesn't consider an interface to implement itself. * I think this is intended to be called on ClassNodes representing * classes, not interfaces. * */ public boolean declaresInterface(ClassNode classNode) { ClassNode[] interfaces = redirect().getInterfaces(); for (ClassNode cn : interfaces) { if (cn.equals(classNode)) return true; } for (ClassNode cn : interfaces) { if (cn.declaresInterface(classNode)) return true; } return false; }
public void visitMethod(MethodNode node){ if(isTag && !node.isStatic() && node.getName().equals(TAG) && node.getParameters().length==2 && node.getReturnType().equals(ClassHelper.OBJECT_TYPE)){ ClassNode taggableNode = new ClassNode(Taggable.class); if(!classNode.declaresInterface(taggableNode)){ classNode.addInterface(taggableNode); } } super.visitMethod(node); } }
public void createMopMethods() { ClassNode classNode = controller.getClassNode(); if (classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) { return; } visitMopMethodList(classNode.getMethods(), true); visitMopMethodList(classNode.getSuperClass().getAllDeclaredMethods(), false); }
public void visitMethod(MethodNode node){ if(isTag && !node.isStatic() && node.getName().equals(TAG) && node.getParameters().length==2 && node.getReturnType().equals(ClassHelper.OBJECT_TYPE)){ ClassNode taggableNode = new ClassNode(Taggable.class); if(!classNode.declaresInterface(taggableNode)){ classNode.addInterface(taggableNode); } } super.visitMethod(node); } }
public boolean addGeneratedClosureConstructorCall(ConstructorCallExpression call) { ClassNode classNode = controller.getClassNode(); if (!classNode.declaresInterface(ClassHelper.GENERATED_CLOSURE_Type)) return false; AsmClassGenerator acg = controller.getAcg(); OperandStack operandStack = controller.getOperandStack(); MethodVisitor mv = controller.getMethodVisitor(); mv.visitVarInsn(ALOAD, 0); ClassNode callNode = classNode.getSuperClass(); TupleExpression arguments = (TupleExpression) call.getArguments(); if (arguments.getExpressions().size()!=2) throw new GroovyBugError("expected 2 arguments for closure constructor super call, but got"+arguments.getExpressions().size()); arguments.getExpression(0).visit(acg); operandStack.box(); arguments.getExpression(1).visit(acg); operandStack.box(); //TODO: replace with normal String, p not needed Parameter p = new Parameter(ClassHelper.OBJECT_TYPE,"_p"); String descriptor = BytecodeHelper.getMethodDescriptor(ClassHelper.VOID_TYPE, new Parameter[]{p,p}); mv.visitMethodInsn(INVOKESPECIAL, BytecodeHelper.getClassInternalName(callNode), "<init>", descriptor); operandStack.remove(2); return true; }