Best code snippets using org.codehaus.groovy.ast.ClassNode.setGenericsTypes(Showing top 15 results out of 315)

static void addMethodLevelDeclaredGenerics(MethodNode method, Map<GenericsTypeName, GenericsType> resolvedPlaceholders) {
  ClassNode dummy = OBJECT_TYPE.getPlainNodeReference();
  dummy.setGenericsTypes(method.getGenericsTypes());
  GenericsUtils.extractPlaceholders(dummy, resolvedPlaceholders);
}

private void setGenericsTypes(ClassNode cn) {
  TypeVariable[] tvs = cn.getTypeClass().getTypeParameters();
  GenericsType[] gts = configureTypeVariable(tvs);
  cn.setGenericsTypes(gts);
}

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

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

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

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 ClassNode configureParameterizedType(ParameterizedType parameterizedType) {
  ClassNode base = configureType(parameterizedType.getRawType());
  GenericsType[] gts = configureTypeArguments(parameterizedType.getActualTypeArguments());
  base.setGenericsTypes(gts);
  return base;
}

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

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

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

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

private static ClassNode wrapClosureType(final ClassNode returnType) {
  ClassNode inferredType = CLOSURE_TYPE.getPlainNodeReference();
  inferredType.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(returnType))});
  return inferredType;
}