How to use

setGenericsTypes

method

in

org.codehaus.groovy.ast.ClassNode

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

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

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

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

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

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