Java TypeVar类代码示例

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
/**
 * Erasure destroys the implementation parameter subtype
 * relationship for intersection types
 */
boolean interfaceParameterIsIntersectionType() {
    List<Type> tl = tree.getDescriptorType(types).getParameterTypes();
    if (tree.kind == ReferenceKind.UNBOUND) {
        tl = tl.tail;
    }
    for (; tl.nonEmpty(); tl = tl.tail) {
        Type pt = tl.head;
        if (pt.getKind() == TypeKind.TYPEVAR) {
            TypeVar tv = (TypeVar) pt;
            if (tv.bound.getKind() == TypeKind.INTERSECTION) {
                return true;
            }
        }
    }
    return false;
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
@Override
public Type visitTypeVar(TypeVar t, Boolean upward) {
    if (vars.contains(t)) {
        try {
            if (seen.add(t)) {
                return (upward ?
                        t.getUpperBound() :
                        (t.getLowerBound() == null) ?
                                syms.botType :
                                t.getLowerBound())
                            .map(this, upward);
            } else {
                //cycle
                return syms.objectType;
            }
        } finally {
            seen.remove(t);
        }
    } else {
        return t;
    }
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
@Override
public UTypeVar visitTypeVar(TypeVar type, Void v) {
  /*
   * In order to handle recursively bounded type variables without a stack overflow, we first
   * cache a type var with no bounds, then we template the bounds.
   */
  TypeSymbol tsym = type.asElement();
  if (typeVariables.containsKey(tsym)) {
    return typeVariables.get(tsym);
  }
  UTypeVar var = UTypeVar.create(tsym.getSimpleName().toString());
  typeVariables.put(tsym, var); // so the type variable can be used recursively in the bounds
  var.setLowerBound(type.getLowerBound().accept(this, null));
  var.setUpperBound(type.getUpperBound().accept(this, null));
  return var;
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
/**
 * Returns the upper bound of a type if it has one, or the type itself if not. Correctly handles
 * wildcards and capture variables.
 */
public static Type getUpperBound(Type type, Types types) {
  if (type.hasTag(TypeTag.WILDCARD)) {
    return types.wildUpperBound(type);
  }

  if (type.hasTag(TypeTag.TYPEVAR) && ((TypeVar) type).isCaptured()) {
    return types.cvarUpperBound(type);
  }

  if (type.getUpperBound() != null) {
    return type.getUpperBound();
  }

  // concrete type, e.g. java.lang.String, or a case we haven't considered
  return type;
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
@Override
public UTypeVar visitTypeVar(TypeVar type, Void v) {
  /*
   * In order to handle recursively bounded type variables without a stack overflow, we first
   * cache a type var with no bounds, then we template the bounds.
   */
  TypeSymbol tsym = type.asElement();
  if (typeVariables.containsKey(tsym)) {
    return typeVariables.get(tsym);
  }
  UTypeVar var = UTypeVar.create(tsym.getSimpleName().toString());
  typeVariables.put(
      tsym, var); // so the type variable can be used recursively in the bounds
  var.setLowerBound(type.getLowerBound().accept(this, null));
  var.setUpperBound(type.getUpperBound().accept(this, null));
  return var;
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
@Override
public Violation visitTypeVar(TypeVar type, Void s) {
  TypeVariableSymbol tyvar = (TypeVariableSymbol) type.tsym;
  if (containerTypeParameters.contains(tyvar.getSimpleName().toString())) {
    return Violation.absent();
  }
  if (isThreadSafeTypeParameter(tyvar)) {
    return Violation.absent();
  }
  String message;
  if (!allowContainerTypeParameters) {
    message =
        String.format("'%s' is not annotated @ImmutableTypeParameter", tyvar.getSimpleName());
  } else if (!containerTypeParameters.isEmpty()) {
    message =
        String.format(
            "'%s' is a mutable type variable (not in '%s')",
            tyvar.getSimpleName(), Joiner.on(", ").join(containerTypeParameters));
  } else {
    message = String.format("'%s' is a mutable type variable", tyvar.getSimpleName());
  }
  return Violation.of(message);
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
@Override
public Void visitTypeVar(TypeVar t, Void s) {
    if (t.bound instanceof PlaceholderType)
        t.bound = ((PlaceholderType)t.bound).delegate;
    else if (t.bound != null)
        t.bound.accept(this, s);
    if (t.lower instanceof PlaceholderType)
        t.lower = ((PlaceholderType)t.lower).delegate;
    else if (t.lower != null)
        t.lower.accept(this, s);
    return null;
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
public static boolean checkTypesAssignable(CompilationInfo info, TypeMirror from, TypeMirror to) {
    Context c = ((JavacTaskImpl) info.impl.getJavacTask()).getContext();
    if (from.getKind() == TypeKind.TYPEVAR) {
        Types types = Types.instance(c);
        TypeVar t = types.substBound((TypeVar)from, com.sun.tools.javac.util.List.of((Type)from), com.sun.tools.javac.util.List.of(types.boxedTypeOrType((Type)to)));
        return info.getTypes().isAssignable(t.getUpperBound(), to)
                || info.getTypes().isAssignable(to, t.getUpperBound());
    }
    if (from.getKind() == TypeKind.WILDCARD) {
        from = Types.instance(c).wildUpperBound((Type)from);
    }
    return Check.instance(c).checkType(null, (Type)from, (Type)to).getKind() != TypeKind.ERROR;
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
private boolean unique(TypeVar typevar) {
    int found = 0;
    for (Type t : whereClauses.get(WhereClauseKind.TYPEVAR).keySet()) {
        if (t.toString().equals(typevar.toString())) {
            found++;
        }
    }
    if (found < 1)
        throw new AssertionError("Missing type variable in where clause " + typevar);
    return found == 1;
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
@Override
public String visitTypeVar(TypeVar t, Locale locale) {
    if (unique(t) ||
            !getConfiguration().isEnabled(RichFormatterFeature.UNIQUE_TYPEVAR_NAMES)) {
        return t.toString();
    } else {
        return localize(locale,
                "compiler.misc.type.var",
                t.toString(), indexOf(t, WhereClauseKind.TYPEVAR));
    }
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
/** Class enter visitor method for type parameters.
 *  Enter a symbol for type parameter in local scope, after checking that it
 *  is unique.
 */
@Override
public void visitTypeParameter(JCTypeParameter tree) {
    TypeVar a = (tree.type != null)
        ? (TypeVar)tree.type
        : new TypeVar(tree.name, env.info.scope.owner, syms.botType);
    tree.type = a;
    if (chk.checkUnique(tree.pos(), a.tsym, env.info.scope)) {
        env.info.scope.enter(a.tsym);
    }
    result = a;
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
/**
 * Return the string form of a type variable along with any
 * "extends" clause.  Class names are qualified if "full" is true.
 */
static String typeVarToString(DocEnv env, TypeVar v, boolean full) {
    StringBuilder s = new StringBuilder(v.toString());
    List<Type> bounds = getBounds(v, env);
    if (bounds.nonEmpty()) {
        boolean first = true;
        for (Type b : bounds) {
            s.append(first ? " extends " : " & ");
            s.append(TypeMaker.getTypeString(env, b, full));
            first = false;
        }
    }
    return s.toString();
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
/**
 * Get the bounds of a type variable as listed in the "extends" clause.
 */
private static List<Type> getBounds(TypeVar v, DocEnv env) {
    final Type upperBound = v.getUpperBound();
    Name boundname = upperBound.tsym.getQualifiedName();
    if (boundname == boundname.table.names.java_lang_Object
        && !upperBound.isAnnotated()) {
        return List.nil();
    } else {
        return env.types.getBounds(v);
    }
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
@SuppressWarnings("fallthrough")
public static com.sun.javadoc.Type getType(DocEnv env, Type t,
        boolean errToClassDoc, boolean considerAnnotations) {
    if (env.legacyDoclet) {
        t = env.types.erasure(t);
    }

    if (considerAnnotations && t.isAnnotated()) {
        return new AnnotatedTypeImpl(env, t);
    }

    switch (t.getTag()) {
    case CLASS:
        if (ClassDocImpl.isGeneric((ClassSymbol)t.tsym)) {
            return env.getParameterizedType((ClassType)t);
        } else {
            return env.getClassDoc((ClassSymbol)t.tsym);
        }
    case WILDCARD:
        Type.WildcardType a = (Type.WildcardType)t;
        return new WildcardTypeImpl(env, a);
    case TYPEVAR: return new TypeVariableImpl(env, (TypeVar)t);
    case ARRAY: return new ArrayTypeImpl(env, t);
    case BYTE: return PrimitiveType.byteType;
    case CHAR: return PrimitiveType.charType;
    case SHORT: return PrimitiveType.shortType;
    case INT: return PrimitiveType.intType;
    case LONG: return PrimitiveType.longType;
    case FLOAT: return PrimitiveType.floatType;
    case DOUBLE: return PrimitiveType.doubleType;
    case BOOLEAN: return PrimitiveType.booleanType;
    case VOID: return PrimitiveType.voidType;
    case ERROR:
        if (errToClassDoc)
            return env.getClassDoc((ClassSymbol)t.tsym);
        // FALLTHRU
    default:
        return new PrimitiveType(t.tsym.getQualifiedName().toString());
    }
}
 

import com.sun.tools.javac.code.Type.TypeVar; //导入依赖的package包/类
/**
 * Return the formal type parameters of a class or method as an
 * angle-bracketed string.  Each parameter is a type variable with
 * optional bounds.  Class names are qualified if "full" is true.
 * Return "" if there are no type parameters or we're hiding generics.
 */
static String typeParametersString(DocEnv env, Symbol sym, boolean full) {
    if (env.legacyDoclet || sym.type.getTypeArguments().isEmpty()) {
        return "";
    }
    StringBuilder s = new StringBuilder();
    for (Type t : sym.type.getTypeArguments()) {
        s.append(s.length() == 0 ? "<" : ", ");
        s.append(TypeVariableImpl.typeVarToString(env, (TypeVar)t, full));
    }
    s.append(">");
    return s.toString();
}