private ClassNode addTypeArguments(ClassNode basicType, AST node) { List<GenericsType> typeArgumentList = getTypeArgumentsList(node); // a 0-length type argument list means we face the diamond operator basicType.setGenericsTypes(typeArgumentList.toArray(GenericsType.EMPTY_ARRAY)); return basicType; }
private ClassNode configureParameterizedType(ParameterizedType parameterizedType) { ClassNode base = configureType(parameterizedType.getRawType()); GenericsType[] gts = configureTypeArguments(parameterizedType.getActualTypeArguments()); base.setGenericsTypes(gts); return base; }
private void setGenericsTypes(ClassNode cn) { TypeVariable[] tvs = cn.getTypeClass().getTypeParameters(); GenericsType[] gts = configureTypeVariable(tvs); cn.setGenericsTypes(gts); }
/** * wrap type in Class<> if usingClass==true */ private static ClassNode makeType(ClassNode cn, boolean usingClass) { if (usingClass) { ClassNode clazzType = CLASS_Type.getPlainNodeReference(); clazzType.setGenericsTypes(new GenericsType[]{new GenericsType(cn)}); return clazzType; } else { return cn; } }
@Override public void visitEnd() { ClassNode base = resolver.resolveClass(baseName); if (arguments.isEmpty()) { finished(base); return; } ClassNode bound = base.getPlainNodeReference(); bound.setGenericsTypes(arguments.toArray(GenericsType.EMPTY_ARRAY)); finished(bound); }
private static ClassNode wrapClosureType(final ClassNode returnType) { ClassNode inferredType = CLOSURE_TYPE.getPlainNodeReference(); inferredType.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(returnType))}); return inferredType; }
private static ClassNode createInnerHelperClass(ClassNode buildee, String builderClassName, int fieldsSize) { final String fullName = buildee.getName() + "$" + builderClassName; ClassNode builder = new InnerClassNode(buildee, fullName, PUBLIC_STATIC, OBJECT_TYPE); GenericsType[] gtypes = new GenericsType[fieldsSize]; for (int i = 0; i < gtypes.length; i++) { gtypes[i] = makePlaceholder(i); } builder.setGenericsTypes(gtypes); return builder; }
private ClassNode makeThis() { ClassNode ret = typeCheckingContext.getEnclosingClassNode(); if (typeCheckingContext.isInStaticContext) { ClassNode staticRet = CLASS_Type.getPlainNodeReference(); GenericsType gt = new GenericsType(ret); staticRet.setGenericsTypes(new GenericsType[]{gt}); ret = staticRet; } return ret; }
static void addMethodLevelDeclaredGenerics(MethodNode method, Map<GenericsTypeName, GenericsType> resolvedPlaceholders) { ClassNode dummy = OBJECT_TYPE.getPlainNodeReference(); dummy.setGenericsTypes(method.getGenericsTypes()); GenericsUtils.extractPlaceholders(dummy, resolvedPlaceholders); }
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 ClassNode makeSuper() { ClassNode ret = typeCheckingContext.getEnclosingClassNode().getSuperClass(); if (typeCheckingContext.isInStaticContext) { ClassNode staticRet = CLASS_Type.getPlainNodeReference(); GenericsType gt = new GenericsType(ret); staticRet.setGenericsTypes(new GenericsType[]{gt}); ret = staticRet; } return ret; }
private static ClassNode adjustTypeForSpreading(ClassNode inferredRightExpressionType, Expression leftExpression) { // imagine we have: list*.foo = 100 // then the assignment must be checked against [100], not 100 ClassNode wrappedRHS = inferredRightExpressionType; if (leftExpression instanceof PropertyExpression && ((PropertyExpression) leftExpression).isSpreadSafe()) { wrappedRHS = LIST_TYPE.getPlainNodeReference(); wrappedRHS.setGenericsTypes(new GenericsType[]{ new GenericsType(getWrapper(inferredRightExpressionType)) }); } return wrappedRHS; }
private ClassNode configureWildcardType(WildcardType wildcardType) { ClassNode base = ClassHelper.makeWithoutCaching("?"); base.setRedirect(ClassHelper.OBJECT_TYPE); //TODO: more than one lower bound for wildcards? ClassNode[] lowers = configureTypes(wildcardType.getLowerBounds()); ClassNode lower = null; // TODO: is it safe to remove this? What was the original intention? if (lowers != null) lower = lowers[0]; ClassNode[] upper = configureTypes(wildcardType.getUpperBounds()); GenericsType t = new GenericsType(base, upper, lower); t.setWildcard(true); ClassNode ref = ClassHelper.makeWithoutCaching(Object.class, false); ref.setGenericsTypes(new GenericsType[]{t}); return ref; }
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 storeInferredTypeForPropertyExpression(final PropertyExpression pexp, final ClassNode flatInferredType) { if (pexp.isSpreadSafe()) { ClassNode list = LIST_TYPE.getPlainNodeReference(); list.setGenericsTypes(new GenericsType[]{ new GenericsType(flatInferredType) }); storeType(pexp, list); } else { storeType(pexp, flatInferredType); } }
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; }
private static GenericsType buildWildcardType(GenericsType origin) { ClassNode lowerBound = origin.getType().getPlainNodeReference(); if (hasNonTrivialBounds(origin)) { lowerBound.setGenericsTypes(new GenericsType[]{origin}); } ClassNode base = makeWithoutCaching("?"); GenericsType gt = new GenericsType(base, null, lowerBound); gt.setWildcard(true); return gt; }
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 ClassNode nonGeneric(ClassNode type) { if (type.isUsingGenerics()) { final ClassNode nonGen = ClassHelper.makeWithoutCaching(type.getName()); nonGen.setRedirect(type); nonGen.setGenericsTypes(null); nonGen.setUsingGenerics(false); return nonGen; } if (type.isArray() && type.getComponentType().isUsingGenerics()) { return type.getComponentType().getPlainNodeReference().makeArray(); } return type; }
@Override public void visitRangeExpression(final RangeExpression expression) { super.visitRangeExpression(expression); ClassNode fromType = getWrapper(getType(expression.getFrom())); ClassNode toType = getWrapper(getType(expression.getTo())); if (Integer_TYPE.equals(fromType) && Integer_TYPE.equals(toType)) { storeType(expression, ClassHelper.make(IntRange.class)); } else { ClassNode rangeType = ClassHelper.make(Range.class).getPlainNodeReference(); rangeType.setGenericsTypes(new GenericsType[]{new GenericsType(WideningCategories.lowestUpperBound(fromType, toType))}); storeType(expression, rangeType); } }