public void setPlaceholder(boolean placeholder) { this.placeholder = placeholder; type.setGenericsPlaceHolder(placeholder); }
public static ClassNode configureTypeVariableReference(String name) { ClassNode cn = ClassHelper.makeWithoutCaching(name); cn.setGenericsPlaceHolder(true); ClassNode cn2 = ClassHelper.makeWithoutCaching(name); cn2.setGenericsPlaceHolder(true); GenericsType[] gts = new GenericsType[]{new GenericsType(cn2)}; cn.setGenericsTypes(gts); cn.setRedirect(ClassHelper.OBJECT_TYPE); return cn; }
public static ClassNode makeClassSafe0(ClassNode type, GenericsType... genericTypes) { ClassNode plainNodeReference = newClass(type); if (genericTypes != null && genericTypes.length > 0) { plainNodeReference.setGenericsTypes(genericTypes); if (type.isGenericsPlaceHolder()) plainNodeReference.setGenericsPlaceHolder(true); } return plainNodeReference; }
private static GenericsType makePlaceholder(int i) { ClassNode type = ClassHelper.makeWithoutCaching("T" + i); type.setRedirect(OBJECT_TYPE); type.setGenericsPlaceHolder(true); return new GenericsType(type); }
public static Map<String, ClassNode> addMethodGenerics(MethodNode current, Map<String, ClassNode> oldSpec) { Map<String, ClassNode> ret = new HashMap<String, ClassNode>(oldSpec); // ret starts with the original type specs, now add gts for the current method if any GenericsType[] sgts = current.getGenericsTypes(); if (sgts != null) { for (GenericsType sgt : sgts) { String name = sgt.getName(); if (sgt.isPlaceholder()) { ClassNode redirect; if (sgt.getUpperBounds() != null) { redirect = sgt.getUpperBounds()[0]; } else if (sgt.getLowerBound() != null) { redirect = sgt.getLowerBound(); } else { redirect = ClassHelper.OBJECT_TYPE; } ClassNode type = ClassHelper.makeWithoutCaching(name); type.setGenericsPlaceHolder(true); type.setRedirect(redirect); ret.put(name, type); } else { ret.put(name, sgt.getType()); } } } return ret; }
/** * Apply the bounds from the declared type when the using type simply declares a parameter as an unbounded wildcard. * * @param type A parameterized type * @return A parameterized type with more precise wildcards */ static ClassNode boundUnboundedWildcards(ClassNode type) { if (type.isArray()) { return boundUnboundedWildcards(type.getComponentType()).makeArray(); } ClassNode target = type.redirect(); if (target == null || type == target || !isUsingGenericsOrIsArrayUsingGenerics(target)) return type; ClassNode newType = type.getPlainNodeReference(); newType.setGenericsPlaceHolder(type.isGenericsPlaceHolder()); newType.setGenericsTypes(boundUnboundedWildcards(type.getGenericsTypes(), target.getGenericsTypes())); return newType; }
type.setRedirect(genericsType.getType()); type.setGenericsTypes(new GenericsType[]{ genericsType }); type.setGenericsPlaceHolder(true); return true;
static ClassNode applyGenericsContext( Map<GenericsTypeName, GenericsType> spec, ClassNode bound ) { if (bound == null) return null; if (bound.isArray()) { return applyGenericsContext(spec, bound.getComponentType()).makeArray(); } if (!bound.isUsingGenerics()) return bound; ClassNode newBound = bound.getPlainNodeReference(); newBound.setGenericsTypes(applyGenericsContext(spec, bound.getGenericsTypes())); if (bound.isGenericsPlaceHolder()) { GenericsType[] gt = newBound.getGenericsTypes(); boolean hasBounds = hasNonTrivialBounds(gt[0]); if (hasBounds || !gt[0].isPlaceholder()) return getCombinedBoundType(gt[0]); String placeHolderName = newBound.getGenericsTypes()[0].getName(); if (!placeHolderName.equals(newBound.getUnresolvedName())) { // we should produce a clean placeholder ClassNode here ClassNode clean = make(placeHolderName); clean.setGenericsTypes(newBound.getGenericsTypes()); clean.setRedirect(newBound); newBound = clean; } newBound.setGenericsPlaceHolder(true); } return newBound; }
if (type != null && type.isGenericsPlaceHolder() && type.getGenericsTypes() == null) { ClassNode placeholder = ClassHelper.makeWithoutCaching(type.getUnresolvedName()); placeholder.setGenericsPlaceHolder(true); type = makeClassSafeWithGenerics(type, new GenericsType(placeholder));
private static GenericsType applyGenericsContext(Map<GenericsTypeName, GenericsType> spec, GenericsType gt) { if (gt.isPlaceholder()) { GenericsTypeName name = new GenericsTypeName(gt.getName()); GenericsType specType = spec.get(name); if (specType != null) return specType; if (hasNonTrivialBounds(gt)) { GenericsType newGT = new GenericsType(gt.getType(), applyGenericsContext(spec, gt.getUpperBounds()), applyGenericsContext(spec, gt.getLowerBound())); newGT.setPlaceholder(true); return newGT; } return gt; } else if (gt.isWildcard()) { GenericsType newGT = new GenericsType(gt.getType(), applyGenericsContext(spec, gt.getUpperBounds()), applyGenericsContext(spec, gt.getLowerBound())); newGT.setWildcard(true); return newGT; } ClassNode type = gt.getType(); ClassNode newType; if (type.isArray()) { newType = applyGenericsContext(spec, type.getComponentType()).makeArray(); } else { if (type.getGenericsTypes()==null) return gt; newType = type.getPlainNodeReference(); newType.setGenericsPlaceHolder(type.isGenericsPlaceHolder()); newType.setGenericsTypes(applyGenericsContext(spec, type.getGenericsTypes())); } return new GenericsType(newType); }
public void setPlaceholder(boolean placeholder) { this.placeholder = placeholder; type.setGenericsPlaceHolder(placeholder); }
/** * Informs the builder whether to use a generic placeholder in the * resulting {@link ClassNode} or not. * * @param usePlaceholder true if the builder should use it * @return current instance of {@link ClassNodeBuilder} * @since 0.1.0 */ public ClassNodeBuilder genericsPlaceHolder(final Boolean usePlaceholder) { this.classNode.setGenericsPlaceHolder(usePlaceholder); return this; }
private ClassNode configureTypeVariableReference(TypeVariable tv) { ClassNode cn = ClassHelper.makeWithoutCaching(tv.getName()); cn.setGenericsPlaceHolder(true); ClassNode cn2 = ClassHelper.makeWithoutCaching(tv.getName()); cn2.setGenericsPlaceHolder(true); GenericsType[] gts = new GenericsType[]{new GenericsType(cn2)}; cn.setGenericsTypes(gts); cn.setRedirect(ClassHelper.OBJECT_TYPE); return cn; }
public static GenericsType makeGenericsType(ClassNode classNode, ClassNode[] upperBounds, ClassNode lowerBound, boolean placeHolder) { classNode = newClass(classNode); classNode.setGenericsPlaceHolder(placeHolder); return new GenericsType(classNode, upperBounds, lowerBound); }
public static GenericsType makeGenericsType(ClassNode classNode, ClassNode[] upperBounds, ClassNode lowerBound, boolean placeHolder) { classNode = newClass(classNode); classNode.setGenericsPlaceHolder(placeHolder); return new GenericsType(classNode, upperBounds, lowerBound); }
private ClassNode configureTypeVariableReference(TypeVariable tv) { ClassNode cn = ClassHelper.makeWithoutCaching(tv.getName()); cn.setGenericsPlaceHolder(true); ClassNode cn2 = ClassHelper.makeWithoutCaching(tv.getName()); GenericsType[] gts = new GenericsType[]{new GenericsType(cn2)}; cn.setGenericsTypes(gts); cn.setRedirect(ClassHelper.OBJECT_TYPE); return cn; }
private ClassNode configureTypeVariableReference(TypeVariable tv) { ClassNode cn = ClassHelper.makeWithoutCaching(tv.getName()); cn.setGenericsPlaceHolder(true); ClassNode cn2 = ClassHelper.makeWithoutCaching(tv.getName()); GenericsType[] gts = new GenericsType[]{new GenericsType(cn2)}; cn.setGenericsTypes(gts); cn.setRedirect(ClassHelper.OBJECT_TYPE); return cn; }
private ClassNode configureTypeVariableReference(TypeVariable tv) { ClassNode cn = ClassHelper.makeWithoutCaching(tv.getName()); cn.setGenericsPlaceHolder(true); ClassNode cn2 = ClassHelper.makeWithoutCaching(tv.getName()); GenericsType[] gts = new GenericsType[]{new GenericsType(cn2)}; cn.setGenericsTypes(gts); cn.setRedirect(ClassHelper.OBJECT_TYPE); return cn; }
type.setRedirect(gt.getType()); type.setGenericsTypes(new GenericsType[]{gt}); type.setGenericsPlaceHolder(true); return true;
type.setRedirect(gt.getType()); type.setGenericsTypes(new GenericsType[]{gt}); type.setGenericsPlaceHolder(true); return true;