Codota Logo
ClassNode.setGenericsTypes
Code IndexAdd Codota to your IDE (free)

How to use
setGenericsTypes
method
in
org.codehaus.groovy.ast.ClassNode

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

  • Common ways to obtain ClassNode
private void myMethod () {
ClassNode c =
  • Codota IconExpression expression;expression.getType()
  • Codota IconMethodNode methodNode;methodNode.getReturnType()
  • Codota IconString name;ClassHelper.make(name)
  • Smart code suggestions by Codota
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

private ClassNode configureParameterizedType(ParameterizedType parameterizedType) {
  ClassNode base = configureType(parameterizedType.getRawType());
  GenericsType[] gts = configureTypeArguments(parameterizedType.getActualTypeArguments());
  base.setGenericsTypes(gts);
  return base;
}
origin: org.codehaus.groovy/groovy

private void setGenericsTypes(ClassNode cn) {
  TypeVariable[] tvs = cn.getTypeClass().getTypeParameters();
  GenericsType[] gts = configureTypeVariable(tvs);
  cn.setGenericsTypes(gts);
}
origin: org.codehaus.groovy/groovy

/**
 * wrap type in Class&lt;&gt; 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;
  }
}
origin: org.codehaus.groovy/groovy

@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);
}
origin: org.codehaus.groovy/groovy

private static ClassNode wrapClosureType(final ClassNode returnType) {
  ClassNode inferredType = CLOSURE_TYPE.getPlainNodeReference();
  inferredType.setGenericsTypes(new GenericsType[]{new GenericsType(wrapTypeIfNecessary(returnType))});
  return inferredType;
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

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

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;
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

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);
  }
}
origin: org.codehaus.groovy/groovy

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);
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

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;
}
origin: org.codehaus.groovy/groovy

@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);
  }
}
org.codehaus.groovy.astClassNodesetGenericsTypes

Popular methods of ClassNode

  • getName
  • getMethods
    This methods creates a list of all methods with this name of the current class and of all super clas
  • <init>
    Constructor used by makeArray() if no real class is available
  • getSuperClass
  • equals
  • addMethod
  • getAnnotations
  • addField
  • getFields
    Returns a list containing FieldNode objects for each field in the class represented by this ClassNod
  • getPlainNodeReference
  • getField
    Finds a field matching the given name in this class or a parent class.
  • getMethod
    Finds a method matching the given name and parameters in this class or any parent class.
  • getField,
  • getMethod,
  • isInterface,
  • getNameWithoutPackage,
  • isScript,
  • getDeclaredMethod,
  • getGenericsTypes,
  • getDeclaredConstructors,
  • getModifiers,
  • getTypeClass

Popular in Java

  • Updating database using SQL prepared statement
  • setScale (BigDecimal)
  • findViewById (Activity)
  • getContentResolver (Context)
  • InputStream (java.io)
    A readable source of bytes.Most clients will use input streams that read data from the file system (
  • Collection (java.util)
    Collection is the root of the collection hierarchy. It defines operations on data collections and t
  • TreeMap (java.util)
    A Red-Black tree based NavigableMap implementation. The map is sorted according to the Comparable of
  • Executor (java.util.concurrent)
    An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
  • HttpServlet (javax.servlet.http)
    Provides an abstract class to be subclassed to create an HTTP servlet suitable for a Web site. A sub
  • Loader (org.hibernate.loader)
    Abstract superclass of object loading (and querying) strategies. This class implements useful common
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now