How to use

isArray

method

in

org.codehaus.groovy.ast.ClassNode

static boolean isVargs(Parameter[] params) {
  if (params.length == 0) return false;
  if (params[params.length - 1].getType().isArray()) return true;
  return false;
}

private static boolean isVargs(Parameter[] p) {
  if (p.length==0) return false;
  ClassNode clazz = p[p.length-1].getType();
  return (clazz.isArray());
}

private static String getStaticFieldName(ClassNode type) {
  ClassNode componentType = type;
  StringBuilder prefix = new StringBuilder();
  for (; componentType.isArray(); componentType = componentType.getComponentType()) {
    prefix.append("$");
  }
  if (prefix.length() != 0) prefix.insert(0, "array");
  String name = prefix + "$class$" + makeFieldClassName(componentType);
  return name;
}

private String nameOf(ClassNode theType) {
  StringBuilder ret = new StringBuilder();
  if (theType.isArray()) {
    ret.append(nameOf(theType.getComponentType()));
    ret.append("[]");
  } else {
    ret.append(theType.getName());
  }
  return ret.toString();
}

private static Tuple2<ClassNode, Integer> extractArrayInfo(ClassNode type) {
  int dimension = 0;
  do {
    dimension++;
  } while ((type = type.getComponentType()).isArray());
  return new Tuple2<ClassNode, Integer>(type, dimension);
}

private static String buildTypeName(ClassNode type) {
  if (type.isArray()) {
    return String.format("%sArray", buildTypeName(type.getComponentType()));
  }
  return type.getNameWithoutPackage();
}

private boolean lastIsArray(List<Expression> argumentList, int pos) {
  Expression last = argumentList.get(pos);
  ClassNode type = controller.getTypeChooser().resolveType(last, controller.getClassNode());
  return type.isArray();
}

static String prettyPrintType(ClassNode type) {
  if (type.isArray()) {
    return prettyPrintType(type.getComponentType()) + "[]";
  }
  return type.toString(false);
}

private static boolean isGenericsPlaceHolderOrArrayOf(ClassNode cn) {
  if (cn.isArray()) return isGenericsPlaceHolderOrArrayOf(cn.getComponentType());
  return cn.isGenericsPlaceHolder();
}

private boolean isAssignable(ClassNode node, ClassNode testNode) {
  if (node.isArray() && testNode.isArray()) {
    return isArrayAssignable(node.getComponentType(), testNode.getComponentType());
  }
  if (testNode.isInterface()) {
    if (node.equals(testNode) || node.implementsInterface(testNode)) return true;
  }
  return node.isDerivedFrom(testNode);
}

private void printType(PrintWriter out, ClassNode type) {
  if (type.isArray()) {
    printType(out, type.getComponentType());
    out.print("[]");
  } else if (java5 && type.isGenericsPlaceHolder()) {
    out.print(type.getGenericsTypes()[0].getName());
  } else {
    printGenericsBounds(out, type, false);
  }
}

private static ClassNode cleanType(ClassNode type) {
  // todo: should this be directly handled by getPlainNodeReference?
  if (type.isArray()) return cleanType(type.getComponentType()).makeArray();
  return type.getPlainNodeReference();
}

Expression transformListExpression(final ListExpression expr) {
  MethodNode target = expr.getNodeMetaData(StaticTypesMarker.DIRECT_METHOD_CALL_TARGET);
  if (target instanceof ConstructorNode) {
    if (target.getDeclaringClass().isArray()) {
      return transformArrayConstructor(expr, target);
    }
    return transformRegularConstructor(expr, target);
  } else {
    return transformer.superTransform(expr);
  }
}

private boolean compatibleArgumentType(ClassNode argumentType, ClassNode paramType) {
  if (argumentType == null) return false;
  if (ClassHelper.getWrapper(argumentType).equals(ClassHelper.getWrapper(paramType))) return true;
  if (paramType.isInterface()) return argumentType.implementsInterface(paramType);
  if (paramType.isArray() && argumentType.isArray())
    return compatibleArgumentType(argumentType.getComponentType(), paramType.getComponentType());
  return ClassHelper.getWrapper(argumentType).isDerivedFrom(ClassHelper.getWrapper(paramType));
}

public static void doCast(MethodVisitor mv, ClassNode type) {
  if (type == ClassHelper.OBJECT_TYPE) return;
  if (ClassHelper.isPrimitiveType(type) && type != VOID_TYPE) {
    unbox(mv, type);
  } else {
    mv.visitTypeInsn(
        CHECKCAST,
        type.isArray() ? 
            BytecodeHelper.getTypeDescription(type) : 
            BytecodeHelper.getClassInternalName(type.getName()));
  }
}

public ClassNode getPlainNodeReference() {
  if (ClassHelper.isPrimitiveType(this)) return this;
  ClassNode n = new ClassNode(name, modifiers, superClass,null,null);
  n.isPrimaryNode = false;
  n.setRedirect(redirect());
  if (isArray()) {
    n.componentType = redirect().getComponentType();
  } 
  return n;
}

public static boolean missesGenericsTypes(ClassNode cn) {
  if (cn.isArray()) return missesGenericsTypes(cn.getComponentType());
  GenericsType[] cnTypes = cn.getGenericsTypes();
  GenericsType[] rnTypes = cn.redirect().getGenericsTypes();
  if (rnTypes != null && cnTypes == null) return true;
  if (cnTypes != null) {
    for (GenericsType genericsType : cnTypes) {
      if (genericsType.isPlaceholder()) return true;
    }
  }
  return false;
}

private static ClassNode makeRawType(final ClassNode receiver) {
  if (receiver.isArray()) {
    return makeRawType(receiver.getComponentType()).makeArray();
  }
  ClassNode raw = receiver.getPlainNodeReference();
  raw.setUsingGenerics(false);
  raw.setGenericsTypes(null);
  return raw;
}

public static String getClassInternalName(ClassNode t) {
  if (t.isPrimaryClassNode() || t instanceof DecompiledClassNode) {
    if (t.isArray()) return "[L"+getClassInternalName(t.getComponentType())+";";
    return getClassInternalName(t.getName());
  }
  return getClassInternalName(t.getTypeClass());
}

public void checkReturnType(ClassNode attrType, ASTNode node) {
  if (attrType.isArray()) {
    checkReturnType(attrType.getComponentType(), node);
  } else if (ClassHelper.isPrimitiveType(attrType)) {
  } else if (ClassHelper.STRING_TYPE.equals(attrType)) {
  } else if (ClassHelper.CLASS_Type.equals(attrType)) {
  } else if (attrType.isDerivedFrom(ClassHelper.Enum_Type)) {
  } else if (isValidAnnotationClass(attrType)) {
  } else {
    addError("Unexpected return type " + attrType.getName(), node);
  }
}