private static ClassNode unwrapOwner(ClassNode owner) { if (ClassHelper.CLASS_Type.equals(owner) && owner.getGenericsTypes()!=null && owner.getGenericsTypes().length==1) { return owner.getGenericsTypes()[0].getType(); } return owner; }
@Override public GenericsType[] getGenericsTypes() { lazyInitSupers(); return super.getGenericsTypes(); }
private static ClassNode getComponentTypeForList(ClassNode fType) { if (fType.isUsingGenerics() && fType.getGenericsTypes().length == 1) { return fType.getGenericsTypes()[0].getType(); } else { return ClassHelper.OBJECT_TYPE; } }
protected static boolean hasRHSIncompleteGenericTypeInfo(final ClassNode inferredRightExpressionType) { boolean replaceType = false; GenericsType[] genericsTypes = inferredRightExpressionType.getGenericsTypes(); if (genericsTypes != null) { for (GenericsType genericsType : genericsTypes) { if (genericsType.isPlaceholder()) { replaceType = true; break; } } } return replaceType; }
/** * A helper method which will extract the n-th generic type from a class node. * @param type the class node from which to pick a generic type * @param gtIndex the index of the generic type to extract * @return the n-th generic type, or {@link org.codehaus.groovy.ast.ClassHelper#OBJECT_TYPE} if it doesn't exist. */ public static ClassNode pickGenericType(ClassNode type, int gtIndex) { final GenericsType[] genericsTypes = type.getGenericsTypes(); if (genericsTypes==null || genericsTypes.length<gtIndex) { return ClassHelper.OBJECT_TYPE; } return genericsTypes[gtIndex].getType(); }
private static void writeGenericsBoundType(StringBuilder ret, ClassNode printType, boolean writeInterfaceMarker) { if (writeInterfaceMarker && printType.isInterface()) ret.append(":"); if (printType.isGenericsPlaceHolder() && printType.getGenericsTypes()!=null) { ret.append("T"); ret.append(printType.getGenericsTypes()[0].getName()); ret.append(";"); } else { ret.append(getTypeDescription(printType, false)); addSubTypes(ret, printType.getGenericsTypes(), "<", ">"); if (!ClassHelper.isPrimitiveType(printType)) ret.append(";"); } }
public static String getGenericsBounds(ClassNode type) { GenericsType[] genericsTypes = type.getGenericsTypes(); if (genericsTypes == null) return null; StringBuilder ret = new StringBuilder(100); if (type.isGenericsPlaceHolder()) { addSubTypes(ret, type.getGenericsTypes(), "", ""); } else { GenericsType gt = new GenericsType(type); writeGenericsBounds(ret, gt, false); } return ret.toString(); }
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 Map<GenericsTypeName, GenericsType> resolvePlaceHoldersFromDeclaration(ClassNode receiver, ClassNode declaration, MethodNode method, boolean isStaticTarget) { Map<GenericsTypeName, GenericsType> resolvedPlaceholders; if (isStaticTarget && CLASS_Type.equals(receiver) && receiver.isUsingGenerics() && receiver.getGenericsTypes().length > 0 && !OBJECT_TYPE.equals(receiver.getGenericsTypes()[0].getType())) { return resolvePlaceHoldersFromDeclaration(receiver.getGenericsTypes()[0].getType(), declaration, method, isStaticTarget); } else { resolvedPlaceholders = extractPlaceHolders(method, receiver, declaration); } return resolvedPlaceholders; }
private void printGenericsBounds(PrintWriter out, ClassNode type, boolean skipName) { if (!skipName) printTypeName(out, type); if (!java5) return; if (!ClassHelper.isCachedType(type)) { printGenericsBounds(out, type.getGenericsTypes()); } }
private void resolveOrFail(ClassNode type, ASTNode node, boolean prefereImports) { resolveGenericsTypes(type.getGenericsTypes()); if (prefereImports && resolveAliasFromModule(type)) return; resolveOrFail(type, node); }
static GenericsType[] getGenericsWithoutArray(ClassNode type) { if (type.isArray()) return getGenericsWithoutArray(type.getComponentType()); return type.getGenericsTypes(); }
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 FieldNode tryGetFieldNode(final ClassNode weavedType, final String fieldName) { FieldNode fn = weavedType.getDeclaredField(fieldName); if (fn == null && ClassHelper.CLASS_Type.equals(weavedType)) { GenericsType[] genericsTypes = weavedType.getGenericsTypes(); if (genericsTypes != null && genericsTypes.length == 1) { // for static properties fn = genericsTypes[0].getType().getDeclaredField(fieldName); } } return fn; }
/** * Returns true if a class node makes use of generic types. If the class node represents an * array type, then checks if the component type is using generics. * * @param cn a class node for which to check if it is using generics * @return true if the type (or component type) is using generics */ public static boolean isUsingGenericsOrIsArrayUsingGenerics(ClassNode cn) { if (cn.isArray()) { return isUsingGenericsOrIsArrayUsingGenerics(cn.getComponentType()); } return (cn.isUsingGenerics() && cn.getGenericsTypes() != null); }
public static ClassNode correctToGenericsSpec(Map<String, ClassNode> genericsSpec, ClassNode type) { if (type.isArray()) { return correctToGenericsSpec(genericsSpec, type.getComponentType()).makeArray(); } if (type.isGenericsPlaceHolder()) { String name = type.getGenericsTypes()[0].getName(); type = genericsSpec.get(name); } if (type == null) type = ClassHelper.OBJECT_TYPE; return type; }
static Map<GenericsTypeName, GenericsType> applyGenericsContextToParameterClass( Map<GenericsTypeName, GenericsType> spec, ClassNode parameterUsage ) { GenericsType[] gts = parameterUsage.getGenericsTypes(); if (gts == null) return Collections.EMPTY_MAP; GenericsType[] newGTs = applyGenericsContext(spec, gts); ClassNode newTarget = parameterUsage.redirect().getPlainNodeReference(); newTarget.setGenericsTypes(newGTs); return GenericsUtils.extractPlaceholders(newTarget); }
protected void addNoMatchingMethodError(ClassNode receiver, final String name, final ClassNode[] args, final Expression call) { if (isClassClassNodeWrappingConcreteType(receiver)) { receiver = receiver.getGenericsTypes()[0].getType(); } addStaticTypeError("Cannot find matching method " + receiver.getText() + "#" + toMethodParametersString(name, args) + ". Please check if the declared type is correct and if the method exists.", call); }
private static Map<GenericsTypeName, GenericsType> getGenericsParameterMapOfThis(ClassNode cn) { if (cn == null) return null; Map<GenericsTypeName, GenericsType> map = null; if (cn.getEnclosingMethod() != null) { map = extractGenericsParameterMapOfThis(cn.getEnclosingMethod()); } else if (cn.getOuterClass() != null) { map = getGenericsParameterMapOfThis(cn.getOuterClass()); } map = mergeGenerics(map, cn.getGenericsTypes()); return map; }
protected void visitGenerics(ClassNode node) { if (node.isUsingGenerics()) { GenericsType[] generics = node.getGenericsTypes(); if(generics == null) return; for (GenericsType genericType : generics) { visitNode(genericType); visitType(genericType.getType()); if (genericType.getLowerBound() != null) { visitType(genericType.getLowerBound()); } visitTypes(genericType.getUpperBounds()); } } }