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