@Override public ClassNode getPlainNodeReference() { ClassNode[] intf = interfaces==null?null:new ClassNode[interfaces.length]; if (intf!=null) { for (int i = 0; i < interfaces.length; i++) { intf[i] = interfaces[i].getPlainNodeReference(); } } LowestUpperBoundClassNode plain = new LowestUpperBoundClassNode(name, upper.getPlainNodeReference(), intf); return plain; } }
public ClosureExpression(Parameter[] parameters, Statement code) { this.parameters = parameters; this.code = code; super.setType(ClassHelper.CLOSURE_TYPE.getPlainNodeReference()); }
private static void collectTraits(final Class clazz, final Set<ClassNode> traits) { Annotation annotation = clazz.getAnnotation(Trait.class); if (annotation != null) { ClassNode trait = ClassHelper.make(clazz); traits.add(trait.getPlainNodeReference()); LinkedHashSet<ClassNode> selfTypes = new LinkedHashSet<ClassNode>(); Traits.collectSelfTypes(trait, selfTypes, true, true); for (ClassNode selfType : selfTypes) { if (Traits.isTrait(selfType)) { traits.add(selfType.getPlainNodeReference()); } } } }
private static Parameter createSelfParameter(final ClassNode traitClass, boolean isStatic) { final ClassNode rawType = traitClass.getPlainNodeReference(); ClassNode type = createReceiverType(isStatic, rawType); return new Parameter(type, isStatic?Traits.STATIC_THIS_OBJECT:Traits.THIS_OBJECT); }
/** * 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 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 getCorrectedClassNode(ClassNode type, ClassNode superClass, boolean handlingGenerics) { ClassNode corrected; if (handlingGenerics && missesGenericsTypes(type)) { corrected = superClass.getPlainNodeReference(); } else { corrected = GenericsUtils.correctToGenericsSpecRecurse(GenericsUtils.createGenericsSpec(type), superClass); } return corrected; }
private static ClassNode adjustForTargetType(final ClassNode targetType, final ClassNode resultType) { if (targetType.isUsingGenerics() && missesGenericsTypes(resultType)) { // unchecked assignment within ternary/elvis // examples: // List<A> list = existingAs ?: [] // in that case, the inferred type of the RHS is the type of the RHS // "completed" with generics type information available in the LHS return GenericsUtils.parameterizeType(targetType, resultType.getPlainNodeReference()); } return resultType; }
private ClassNode makeClassNode(CompileUnit cu, Type t, Class c) { ClassNode back = null; if (cu != null) back = cu.getClass(c.getName()); if (back == null) back = ClassHelper.make(c); if (!(t instanceof Class)) { ClassNode front = configureType(t); front.setRedirect(back); return front; } return back.getPlainNodeReference(); }
public static FieldNode addEnumConstant(ClassNode enumClass, String name, Expression init) { int modifiers = PUBLIC_FS | Opcodes.ACC_ENUM; if (init != null && !(init instanceof ListExpression)) { ListExpression list = new ListExpression(); list.addExpression(init); init = list; } FieldNode fn = new FieldNode(name, modifiers, enumClass.getPlainNodeReference(), enumClass, init); enumClass.addField(fn); return fn; } }
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 cleanType(ClassNode type) { // todo: should this be directly handled by getPlainNodeReference? if (type.isArray()) return cleanType(type.getComponentType()).makeArray(); return type.getPlainNodeReference(); }
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; }
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); } }
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; }