How to use

declaresInterface

method

in

org.codehaus.groovy.ast.ClassNode

@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;
}