private final Options _opt;

/** Whether the most specific method test can use boxing to match parameters' types. This contradicts

private final boolean _boxingInMostSpecific;

/**

private final boolean _useExplicitTypeArgs;

/**

private final boolean _strictClassEquality;

protected StandardTypeSystem(Options opt, boolean boxingInMostSpecific, boolean useExplicitTypeArgs,

boolean strictClassEquality) {

_opt = opt;

_boxingInMostSpecific = boxingInMostSpecific;

_useExplicitTypeArgs = useExplicitTypeArgs;

_strictClassEquality = strictClassEquality;

}

/** Determine if the type is well-formed. */

public abstract boolean isWellFormed(Type t);

/** Determine if the given types may be treated as equal. This is recursive, transitive, and symmetric. */

public abstract boolean isEqual(Type t1, Type t2);

/**

public abstract boolean isSubtype(Type subT, Type superT);

/** Compute a common supertype of the given list of types. */

public abstract Type join(Iterable<? extends Type> ts);

/** Compute a common subtype of the given list of types. */

public abstract Type meet(Iterable<? extends Type> ts);

/** Produce types that are bounded by the corresponding type argument and parameter. */

protected abstract Iterable<Type> captureTypeArgs(Iterable<? extends Type> targs,

Iterable<? extends VariableType> params);

/**

protected abstract Iterable<Type> inferTypeArguments(Iterable<? extends VariableType> tparams,

Iterable<? extends Type> params, Type returned,

Iterable<? extends Type> args, Option<Type> expected);

protected boolean sameClass(ClassType c1, ClassType c2) {

if (_strictClassEquality) { return c1.ofClass().equals(c2.ofClass()); }

else { return c1.ofClass().fullName().equals(c2.ofClass().fullName()); }

}

protected static final Type CLONEABLE_AND_SERIALIZABLE =

new IntersectionType(IterUtil.make(CLONEABLE, SERIALIZABLE));

// non-static because it depends on makeClassType

private final Type ITERABLE;

{

Class<?> c;

try { c = Class.forName("java.lang.Iterable"); }

catch (ClassNotFoundException e) { c = null; }

ITERABLE = (c == null) ? null : makeClassType(SymbolUtil.wrapClass(c));

}

// non-static because it depends on makeClassType

private final Type COLLECTION = makeClassType(SymbolUtil.wrapClass(Collection.class));

// non-static because it depends on makeClassType

private final Type ENUM;

{

Class<?> c;

try { c = Class.forName("java.lang.Enum"); }

catch (ClassNotFoundException e) { c = null; }

ENUM = (c == null) ? null : makeClassType(SymbolUtil.wrapClass(c));

}

private final DJClass CLASS = SymbolUtil.wrapClass(Class.class);

public TypePrinter typePrinter() { return new StandardTypePrinter(); }

/** Determine if {@code t} is a primitive. */

public boolean isPrimitive(Type t) { return t.apply(IS_PRIMITIVE); }

protected static final TypeVisitorLambda<Boolean> IS_PRIMITIVE = new TypeAbstractVisitor<Boolean>() {

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forPrimitiveType(PrimitiveType t) { return true; }

};

/** Determine if {@code t} is a reference. */

public boolean isReference(Type t) { return t.apply(IS_REFERENCE); }

protected static final TypeVisitorLambda<Boolean> IS_REFERENCE = new TypeAbstractVisitor<Boolean>() {

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forReferenceType(ReferenceType t) { return true; }

@Override public Boolean forVariableType(VariableType t) { return true; }

@Override public Boolean forIntersectionType(IntersectionType t) { return true; }

@Override public Boolean forUnionType(UnionType t) { return true; }

};

/** Determine if {@code t} is an array. */

public boolean isArray(Type t) { return t.apply(IS_ARRAY); }

protected static final TypeVisitorLambda<Boolean> IS_ARRAY = new TypeAbstractVisitor<Boolean>() {

private final Predicate<Type> PRED = LambdaUtil.asPredicate(this);

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forArrayType(ArrayType t) { return true; }

@Override public Boolean forVariableType(VariableType t) { return t.symbol().upperBound().apply(this); }

@Override public Boolean forIntersectionType(IntersectionType t) { return IterUtil.or(t.ofTypes(), PRED); }

@Override public Boolean forUnionType(UnionType t) {

// BOTTOM is not an array type

return !IterUtil.isEmpty(t.ofTypes()) && IterUtil.and(t.ofTypes(), PRED);

}

};

/**

public boolean isIterable(Type t) { return isSubtype(t, ITERABLE == null ? COLLECTION : ITERABLE); }

/**

public boolean isEnum(Type t) { return ENUM != null && isSubtype(t, ENUM); }

/** Determine if the type is available at runtime (via a {@link Class} object) */

public boolean isReifiable(Type t) { return t.apply(IS_REIFIABLE); }

// cannot be defined statically, because it relies on the definition of non-static "IS_UNBOUNDED_WILDCARD"

private final TypeVisitorLambda<Boolean> IS_REIFIABLE = new TypeAbstractVisitor<Boolean>() {

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forPrimitiveType(PrimitiveType t) { return true; }

@Override public Boolean forNullType(NullType t) { return true; }

@Override public Boolean forArrayType(ArrayType t) { return t.ofType().apply(this); }

@Override public Boolean forSimpleClassType(SimpleClassType t) { return true; }

@Override public Boolean forRawClassType(RawClassType t) { return true; }

@Override public Boolean forVoidType(VoidType t) { return true; }

@Override public Boolean forParameterizedClassType (ParameterizedClassType t) {

for (Type targ : t.typeArguments()) {

if (!targ.apply(IS_UNBOUNDED_WILDCARD)) { return false; }

}

return true;

}

};

// cannot be defined statically, because it relies on the definition of non-static "isEqual"

private final TypeVisitorLambda<Boolean> IS_UNBOUNDED_WILDCARD = new TypeAbstractVisitor<Boolean>() {

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forWildcard(Wildcard t) {

return isEqual(t.symbol().upperBound(), OBJECT) && isEqual(t.symbol().lowerBound(), NULL);

}

};

/**

public boolean isConcrete(Type t) { return t.apply(IS_CONCRETE); }

private static final TypeVisitorLambda<Boolean> IS_CONCRETE = new TypeAbstractVisitor<Boolean>() {

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forPrimitiveType(PrimitiveType t) { return true; }

@Override public Boolean forArrayType(ArrayType t) { return true; }

@Override public Boolean forSimpleClassType(SimpleClassType t) { return isConcreteClass(t.ofClass()); }

@Override public Boolean forRawClassType(RawClassType t) { return isConcreteClass(t.ofClass()); }

@Override public Boolean forParameterizedClassType(ParameterizedClassType t) {

if (!isConcreteClass(t.ofClass())) { return false; }

for (Type targ : t.typeArguments()) {

if (targ instanceof Wildcard) { return false; }

}

return true;

}

private boolean isConcreteClass(DJClass c) {

return !c.isInterface() && !c.isAbstract();

}

};

public Option<Type> dynamicallyEnclosingType(Type t) { return t.apply(DYNAMICALLY_ENCLOSING); }

private static final TypeVisitorLambda<Option<Type>> DYNAMICALLY_ENCLOSING =

new TypeAbstractVisitor<Option<Type>>() {

public Option<Type> defaultCase(Type t) { return Option.none(); }

@Override public Option<Type> forClassType(ClassType t) {

return Option.<Type>wrap(SymbolUtil.dynamicOuterClassType(t));

}

};

/** Determine if {@code t} is valid in the {@code extends} clause of a class definition */

public boolean isExtendable(Type t) { return t.apply(IS_EXTENDABLE); }

private static final TypeVisitorLambda<Boolean> IS_EXTENDABLE = new TypeAbstractVisitor<Boolean>() {

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forClassType(ClassType t) {

return !t.ofClass().isInterface() && !t.ofClass().isFinal();

}

};

/** Determine if {@code t} is valid in the {@code implements} clause of a class definition */

public boolean isImplementable(Type t) { return t.apply(IS_IMPLEMENTABLE); }

private static final TypeVisitorLambda<Boolean> IS_IMPLEMENTABLE = new TypeAbstractVisitor<Boolean>() {

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forClassType(ClassType t) { return t.ofClass().isInterface(); }

};

/** Test whether a variable is reachable from a type. */

protected boolean containsVar(Type t, final VariableType var) {

return containsAnyVar(t, Collections.singleton(var));

}

/** Test whether any of the given variables is reachable from a type. */

protected boolean containsAnyVar(Type t, final Set<? extends VariableType> vars) {

return t.apply(new TypeAbstractVisitor<Boolean>() {

private final RecursionStack<Type> _stack = new RecursionStack<Type>(Wrapper.<Type>factory());

public Boolean defaultCase(Type t) { return false; }

@Override public Boolean forArrayType(ArrayType t) { return t.ofType().apply(this); }

@Override public Boolean forParameterizedClassType(ParameterizedClassType t) {

return checkList(t.typeArguments());

}

@Override public Boolean forBoundType(BoundType t) { return checkList(t.ofTypes()); }

@Override public Boolean forVariableType(VariableType t) {

return vars.contains(t) || checkBoundedSymbol(t, t.symbol());

}

@Override public Boolean forWildcard(Wildcard w) { return checkBoundedSymbol(w, w.symbol()); }

private Boolean checkList(Iterable<? extends Type> types) {

for (Type t : types) {

if (t.apply(this)) { return true; }

}

return false;

}

private Boolean checkBoundedSymbol(Type t, final BoundedSymbol s) {

final TypeVisitor<Boolean> visitor = this; // handles this shadowing

Thunk<Boolean> handleBounds = new Thunk<Boolean>() {

public Boolean value() {

return s.lowerBound().apply(visitor) || s.upperBound().apply(visitor);

}

};

return _stack.apply(handleBounds, false, t);

}

});

}

/** Whether two types are known to be disjoint. (Standard version is implicitly defined in JLS 5.5.) */

public boolean isDisjoint(final Type s, final Type t) {

// By default, returns null for arrays and classes

abstract class Visitor extends TypeAbstractVisitor<Boolean> {

private final Type _other;

public Visitor(Type other) { _other = other; }

public abstract boolean recur(Type that);

@Override public Boolean forPrimitiveType(PrimitiveType that) {

return !isSubtype(that, _other) && !isSubtype(_other, that);

}

@Override public Boolean forNullType(NullType that) {

return !isSubtype(that, _other);

}

@Override public Boolean forArrayType(ArrayType that) { return null; }

@Override public Boolean forClassType(ClassType that) { return null; }

@Override public Boolean forIntersectionType(IntersectionType that) {

for (Type elt : that.ofTypes()) { if (recur(elt)) return true; }

return false;

}

@Override public Boolean forUnionType(UnionType that) {

for (Type elt : that.ofTypes()) { if (!recur(elt)) return false; }

return true;

}

@Override public Boolean forVariableType(VariableType that) {

// TODO: to be correct, we would need to recur (checked by a RecursionStack)

return false;

}

@Override public Boolean forTopType(TopType s) { return false; }

@Override public Boolean forBottomType(BottomType s) { return true; }

}

Boolean sResult = s.apply(new Visitor(t) {

public boolean recur(Type that) { return isDisjoint(that, t); }

});

if (sResult != null) { return sResult; }

else {

return t.apply(new Visitor(s) {

public boolean recur(Type that) { return isDisjoint(s, that); }

@Override public Boolean forArrayType(ArrayType t) {

if (s instanceof ArrayType) { return isDisjoint(((ArrayType) s).ofType(), t.ofType()); }

else { return !isSubtype(t, s); }

}

@Override public Boolean forClassType(ClassType t) {

if (s instanceof ArrayType) { return !isSubtype(s, t); }

else {

ClassType sAsClass = (ClassType) s;

if (sAsClass.ofClass().isFinal() || t.ofClass().isFinal() ||

(!sAsClass.ofClass().isInterface() && !t.ofClass().isInterface())) {

// either one of them is a final class or both are non-final classes

if (!isSubtype(s, erase(t)) && !isSubtype(t, erase(s))) { return true; }

}

// TODO: The JLS also checks for disjoint type arguments (comparing *all* common superclasses)

return false;

}

}

});

}

}

/** Determine if {@link #assign} would succeed given a non-constant expression of the given type */

public boolean isAssignable(Type target, Type expT) {

// TODO: Handle unchecked warnings -- perhaps at the call site

try {

Expression e = TypeUtil.makeEmptyExpression();

NodeProperties.setType(e, expT);

assign(target, e);

return true;

}

catch (UnsupportedConversionException e) { return false; }

}

/** Determine if {@link #assign} would succeed given a constant expression of the given type and value */

public boolean isAssignable(Type target, Type expT, Object expValue) {

// TODO: Handle unchecked warnings -- perhaps at the call site

try {

Expression e = TypeUtil.makeEmptyExpression();

NodeProperties.setType(e, expT);

NodeProperties.setValue(e, expValue);

assign(target, e);

return true;

}

catch (UnsupportedConversionException e) { return false; }

}

public boolean isPrimitiveConvertible(Type t) {

return isPrimitive(t) ||

(!_opt.prohibitBoxing() && !isSubtype(t, NULL) &&

(isSubtype(t, BOOLEAN_CLASS) ||

isSubtype(t, CHARACTER_CLASS) ||

isSubtype(t, BYTE_CLASS) ||

isSubtype(t, SHORT_CLASS) ||

isSubtype(t, INTEGER_CLASS) ||

isSubtype(t, LONG_CLASS) ||

isSubtype(t, FLOAT_CLASS) ||

isSubtype(t, DOUBLE_CLASS)));

}

public boolean isReferenceConvertible(Type t) {

return isReference(t) || !_opt.prohibitBoxing() && t instanceof PrimitiveType;

}

public Type immediateSuperclass(Type t) {

if (t instanceof ClassType) { return ((ClassType) t).ofClass().immediateSuperclass(); }

else { return null; }

}

public Type capture(Type t) { return t.apply(CAPTURE); }

// cannot be defined statically, because it relies on the definition of non-static "capture"

private final TypeVisitorLambda<Type> CAPTURE = new TypeAbstractVisitor<Type>() {

public Type defaultCase(Type t) { return t; }

public Type forVarargArrayType(VarargArrayType t) { return new SimpleArrayType(t.ofType()); }

@Override public Type forParameterizedClassType(ParameterizedClassType t) { return capture(t); }

};

protected ParameterizedClassType capture(ParameterizedClassType t) {

boolean ground = true; // optimization: simply return non-wildcard cases

for (Type arg : t.typeArguments()) {

if (arg instanceof Wildcard) { ground = false; break; }

}

if (ground) { return t; }

else {

Iterable<VariableType> params = SymbolUtil.allTypeParameters(t.ofClass());

Iterable<Type> captureArgs = captureTypeArgs(t.typeArguments(), params);

return new ParameterizedClassType(t.ofClass(), captureArgs);

}

}

/**

public Type erase(Type t) { return t.apply(ERASE); }

private static final TypeVisitorLambda<Type> ERASE = new TypeAbstractVisitor<Type>() {

public Type defaultCase(Type t) { return t; }

@Override public Type forNullType(NullType t) { return OBJECT; }

@Override public Type forSimpleArrayType(SimpleArrayType t) {

Type newElementType = t.ofType().apply(this);

return (t.ofType() == newElementType) ? t : new SimpleArrayType(newElementType);

}

@Override public Type forVarargArrayType(VarargArrayType t) {

Type newElementType = t.ofType().apply(this);

return (t.ofType() == newElementType) ? t : new VarargArrayType(newElementType);

}

@Override public Type forParameterizedClassType(ParameterizedClassType t) {

return new RawClassType(t.ofClass());

}

@Override public Type forVariableType(VariableType t) { return t.symbol().upperBound().apply(this); }

@Override public Type forIntersectionType(IntersectionType t) {

if (IterUtil.isEmpty(t.ofTypes())) { return OBJECT; }

else { return IterUtil.first(t.ofTypes()).apply(this); }

}

@Override public Type forUnionType(UnionType t) {

// TODO: improve this result by performing a join on the erased class hierarchy

return OBJECT;

}

@Override public Type forWildcard(Wildcard t) { throw new IllegalArgumentException(); }

@Override public Type forTopType(TopType t) { throw new IllegalArgumentException(); }

@Override public Type forBottomType(BottomType t) { throw new IllegalArgumentException(); }

};

/**

public Thunk<Class<?>> erasedClass(Type t) { return t.apply(ERASED_CLASS); }

private static final TypeVisitorLambda<Thunk<Class<?>>> ERASED_CLASS = new TypeVisitorLambda<Thunk<Class<?>>>() {

public Thunk<Class<?>> forBooleanType(BooleanType t) { return LambdaUtil.<Class<?>>valueLambda(boolean.class); }

public Thunk<Class<?>> forCharType(CharType t) { return LambdaUtil.<Class<?>>valueLambda(char.class); }

public Thunk<Class<?>> forByteType(ByteType t) { return LambdaUtil.<Class<?>>valueLambda(byte.class); }

public Thunk<Class<?>> forShortType(ShortType t) { return LambdaUtil.<Class<?>>valueLambda(short.class); }

public Thunk<Class<?>> forIntType(IntType t) { return LambdaUtil.<Class<?>>valueLambda(int.class); }

public Thunk<Class<?>> forLongType(LongType t) { return LambdaUtil.<Class<?>>valueLambda(long.class); }

public Thunk<Class<?>> forFloatType(FloatType t) { return LambdaUtil.<Class<?>>valueLambda(float.class); }

public Thunk<Class<?>> forDoubleType(DoubleType t) { return LambdaUtil.<Class<?>>valueLambda(double.class); }

public Thunk<Class<?>> forNullType(NullType t) { return forSimpleClassType(OBJECT); }

public Thunk<Class<?>> forSimpleArrayType(SimpleArrayType t) {

Thunk<Class<?>> elementType = t.ofType().apply(this);

return (elementType == null) ? null : SymbolUtil.arrayClassThunk(elementType);

}

public Thunk<Class<?>> forVarargArrayType(VarargArrayType t) {

Thunk<Class<?>> elementType = t.ofType().apply(this);

return (elementType == null) ? null : SymbolUtil.arrayClassThunk(elementType);

}

public Thunk<Class<?>> forSimpleClassType(SimpleClassType t) { return wrapDJClass(t.ofClass()); }

public Thunk<Class<?>> forRawClassType(RawClassType t) { return wrapDJClass(t.ofClass()); }

public Thunk<Class<?>> forParameterizedClassType(ParameterizedClassType t) {

return wrapDJClass(t.ofClass());

}

public Thunk<Class<?>> forVariableType(VariableType t) {

return t.symbol().upperBound().apply(this);

}

public Thunk<Class<?>> forIntersectionType(IntersectionType t) {

Iterator<? extends Type> sups = t.ofTypes().iterator();

if (!sups.hasNext()) { return null; }

else { return sups.next().apply(this); }

}

public Thunk<Class<?>> forUnionType(UnionType t) { return forSimpleClassType(OBJECT); }

public Thunk<Class<?>> forWildcard(Wildcard t) { throw new IllegalArgumentException(); }

public Thunk<Class<?>> forVoidType(VoidType t) { return LambdaUtil.<Class<?>>valueLambda(void.class); }

public Thunk<Class<?>> forTopType(TopType t) { throw new IllegalArgumentException(); }

public Thunk<Class<?>> forBottomType(BottomType t) { throw new IllegalArgumentException(); }

private Thunk<Class<?>> wrapDJClass(final DJClass c) {

return new Thunk<Class<?>>() {

public Class<?> value() { return c.load(); }

};

}

};

/** Convert a raw class type to its wildcard-parameterized equivalent. */

protected ParameterizedClassType parameterize(final RawClassType t) {

Iterable<VariableType> tparams = SymbolUtil.allTypeParameters(t.ofClass());

return new ParameterizedClassType(t.ofClass(), IterUtil.mapSnapshot(tparams, new Lambda<VariableType, Type>() {

public Type value(VariableType param) {

// identity is determined by t and param -- result should be identical when repeatedly invoked

return new Wildcard(new BoundedSymbol(Pair.make(t, param), OBJECT, NULL));

}

}));

}

/**

public Type reflectionClassOf(Type t) {

if (IterUtil.isEmpty(SymbolUtil.allTypeParameters(CLASS))) { return makeClassType(CLASS); }

else {

try { return makeClassType(CLASS, IterUtil.make(t)); }

catch (InvalidTypeArgumentException e) {

throw new RuntimeException("java.lang.Class has unexpected type parameter(s)");

}

}

}

/**

public Type arrayElementType(Type t) {

return t.apply(ARRAY_ELEMENT_TYPE);

}

// not defined statically because it relies on non-static meet() and join()

private final TypeVisitorLambda<Type> ARRAY_ELEMENT_TYPE = new TypeAbstractVisitor<Type>() {

public Type defaultCase(Type t) { throw new IllegalArgumentException(); }

@Override public Type forArrayType(ArrayType t) { return t.ofType(); }

@Override public Type forVariableType(VariableType t) { return t.symbol().upperBound().apply(this); }

@Override public Type forIntersectionType(IntersectionType t) {

// at least one element has an array type

return meet(IterUtil.map(t.ofTypes(), new Lambda<Type, Type>() {

public Type value(Type arrayT) {

return arrayT.apply(IS_ARRAY) ? arrayT.apply(ARRAY_ELEMENT_TYPE) : TOP;

}

}));

}

@Override public Type forUnionType(UnionType t) {

// there is at least one element, and all have array types

return join(IterUtil.map(t.ofTypes(), this));

}

};

protected static class SubstitutionMap {

private Map<VariableType, Type> _sigma;

private Iterable<? extends VariableType> _vars;

private Iterable<? extends Type> _values;

public static final SubstitutionMap EMPTY = new SubstitutionMap(IterUtil.<VariableType>empty(),

EMPTY_TYPE_ITERABLE);

public SubstitutionMap(Iterable<? extends VariableType> vars, Iterable<? extends Type> values) {

_sigma = null;

_vars = vars;

_values = values;

}

public SubstitutionMap(Map<? extends VariableType, ? extends Type> map) {

// make a copy to prevent mutation

_sigma = new HashMap<VariableType, Type>(map);

}

public boolean isEmpty() {

if (_sigma == null) { return IterUtil.isEmpty(_vars); }

else { return _sigma.isEmpty(); }

}

public Type get(VariableType v) {

if (_sigma == null) { initSigma(); }

return _sigma.get(v);

}

// Initialize the map lazily, because in same cases it may not be used at all.

private void initSigma() {

_sigma = new HashMap<VariableType, Type>();

for (Pair<VariableType, Type> pair : IterUtil.zip(_vars, _values)) {

_sigma.put(pair.first(), pair.second());

}

_vars = null;

_values = null;

}

}

/**

protected Type substitute(Type t, Iterable<? extends VariableType> params, Iterable<? extends Type> args) {

return substitute(t, new SubstitutionMap(params, args));

}

protected Type substitute(Type t, Map<? extends VariableType, ? extends Type> map) {

return substitute(t, new SubstitutionMap(map));

}

protected Type substitute(Type t, final SubstitutionMap sigma) {

if (sigma.isEmpty()) { return t; }

else {

final PrecomputedRecursionStack<Type, Type> stack = PrecomputedRecursionStack.make();

return t.apply(new TypeUpdateVisitor() {

@Override public Type forVariableType(VariableType t) {

Type result = sigma.get(t);

return (result == null) ? t : result;

}

@Override public Type forWildcard(final Wildcard t) {

final Wildcard newWildcard = new Wildcard(new BoundedSymbol(new Object()));

Thunk<Type> substituteBounds = new Thunk<Type>() {

public Type value() {

BoundedSymbol bounds = t.symbol();

Type newUpper = recur(bounds.upperBound());

Type newLower = recur(bounds.lowerBound());

if (newUpper == bounds.upperBound() && newLower == bounds.lowerBound()) { return t; }

else {

newWildcard.symbol().initializeUpperBound(newUpper);

newWildcard.symbol().initializeLowerBound(newLower);

return newWildcard;

}

}

};

return stack.apply(substituteBounds, newWildcard, t);

}

});

}

}

private Iterable<? extends Type> substitute(Iterable<? extends Type> ts,

Iterable<? extends VariableType> vars,

Iterable<? extends Type> values) {

return substitute(ts, new SubstitutionMap(vars, values));

}

private Iterable<? extends Type> substitute(Iterable<? extends Type> ts, final SubstitutionMap sigma) {

if (sigma.isEmpty()) { return ts; }

else {

return IterUtil.mapSnapshot(ts, new Lambda<Type, Type>() {

public Type value(Type t) { return substitute(t, sigma); }

});

}

}

/**

public ClassType makeClassType(DJClass c) {

if (IterUtil.isEmpty(SymbolUtil.allTypeParameters(c))) { return new SimpleClassType(c); }

else { return new RawClassType(c); }

}

/**

public ClassType makeClassType(DJClass c, Iterable<? extends Type> args) throws InvalidTypeArgumentException {

if (IterUtil.isEmpty(args)) { return makeClassType(c); }

else {

Iterable<VariableType> params = SymbolUtil.allTypeParameters(c);

if (IterUtil.sizeOf(params) != IterUtil.sizeOf(args)) { throw new InvalidTypeArgumentException(); }

else {

ParameterizedClassType result = new ParameterizedClassType(c, args);

return result;

}

}

}

/**

public Expression makePrimitive(Expression e) throws UnsupportedConversionException {

Type t = NodeProperties.getType(e);

if (isPrimitive(t)) { return e; }

else if (_opt.prohibitBoxing()) { throw new UnsupportedConversionException(); }

// Note: The spec is not clear about whether a *subtype* (such as a variable) can

// be unboxed. We allow it here unless the type is null, because that seems

// like the correct approach.

else if (isSubtype(t, NULL)) { throw new UnsupportedConversionException(); }

else if (isSubtype(t, BOOLEAN_CLASS)) { return unbox(e, "booleanValue"); }

else if (isSubtype(t, CHARACTER_CLASS)) { return unbox(e, "charValue"); }

else if (isSubtype(t, BYTE_CLASS)) { return unbox(e, "byteValue"); }

else if (isSubtype(t, SHORT_CLASS)) { return unbox(e, "shortValue"); }

else if (isSubtype(t, INTEGER_CLASS)) { return unbox(e, "intValue"); }

else if (isSubtype(t, LONG_CLASS)) { return unbox(e, "longValue"); }

else if (isSubtype(t, FLOAT_CLASS)) { return unbox(e, "floatValue"); }

else if (isSubtype(t, DOUBLE_CLASS)) { return unbox(e, "doubleValue"); }

else { throw new UnsupportedConversionException(); }

}

private Expression unbox(Expression exp, String methodName) {

ObjectMethodCall result = new ObjectMethodCall(exp, methodName, null, exp.getSourceInfo());

try {

ObjectMethodInvocation inv = lookupMethod(exp, methodName, EMPTY_TYPE_ITERABLE, EMPTY_EXPRESSION_ITERABLE,

NONE_TYPE_OPTION, new TopLevelAccessModule(""));

result.setExpression(inv.object());

result.setArguments(CollectUtil.makeList(inv.args()));

NodeProperties.setMethod(result, inv.method());

NodeProperties.setType(result, capture(inv.returnType()));

if (NodeProperties.hasValue(exp)) { NodeProperties.setValue(result, NodeProperties.getValue(exp)); }

return result;

}

catch (TypeSystemException e) { throw new RuntimeException("Unboxing method inaccessible", e); }

}

/**

public Expression makeReference(final Expression e) throws UnsupportedConversionException {

Type t = NodeProperties.getType(e);

if (isReference(t)) { return e; }

else if (_opt.prohibitBoxing()) { throw new UnsupportedConversionException(); }

else {

Expression result = t.apply(new TypeAbstractVisitor<Expression>() {

public Expression defaultCase(Type t) { return null; }

@Override public Expression forBooleanType(BooleanType t) { return box(e, BOOLEAN_CLASS); }

@Override public Expression forCharType(CharType t) { return box(e, CHARACTER_CLASS); }

@Override public Expression forByteType(ByteType t) { return box(e, BYTE_CLASS); }

@Override public Expression forShortType(ShortType t) { return box(e, SHORT_CLASS); }

@Override public Expression forIntType(IntType t) { return box(e, INTEGER_CLASS); }

@Override public Expression forLongType(LongType t) { return box(e, LONG_CLASS); }

@Override public Expression forFloatType(FloatType t) { return box(e, FLOAT_CLASS); }

@Override public Expression forDoubleType(DoubleType t) { return box(e, DOUBLE_CLASS); }

});

if (result == null) { throw new UnsupportedConversionException(); }

else { return result; }

}

}

private Expression box(Expression exp, ClassType boxedType) {

ReferenceTypeName boxedTypeName = new ReferenceTypeName("java", "lang", boxedType.ofClass().declaredName());

NodeProperties.setType(boxedTypeName, boxedType);

List<Expression> arguments = Collections.singletonList(exp);

if (JavaVersion.CURRENT.supports(JavaVersion.JAVA_5)) {

StaticMethodCall m = new StaticMethodCall(boxedTypeName, "valueOf", arguments, exp.getSourceInfo());

try {

MethodInvocation inv = lookupStaticMethod(boxedType, "valueOf", EMPTY_TYPE_ITERABLE, arguments,

NONE_TYPE_OPTION, new TopLevelAccessModule(""));

m.setArguments(CollectUtil.makeList(inv.args()));

NodeProperties.setMethod(m, inv.method());

NodeProperties.setType(m, capture(inv.returnType()));

if (NodeProperties.hasValue(exp)) { NodeProperties.setValue(m, NodeProperties.getValue(exp)); }

return m;

}

catch (TypeSystemException e) { throw new RuntimeException("Boxing method inaccessible", e); }

}

else {

SimpleAllocation k = new SimpleAllocation(boxedTypeName, arguments, exp.getSourceInfo());

try {

ConstructorInvocation inv = lookupConstructor(boxedType, EMPTY_TYPE_ITERABLE, arguments, NONE_TYPE_OPTION,

new TopLevelAccessModule(""));

k.setArguments(CollectUtil.makeList(inv.args()));

NodeProperties.setConstructor(k, inv.constructor());

NodeProperties.setType(k, boxedType);

if (NodeProperties.hasValue(exp)) { NodeProperties.setValue(k, NodeProperties.getValue(exp)); }

return k;

}

catch (TypeSystemException e) { throw new RuntimeException("Boxing constructor inaccessible", e); }

}

}

/**

public Expression unaryPromote(final Expression e) throws UnsupportedConversionException {

// Note: Variables with primitive bounds are not supported

Expression result = NodeProperties.getType(e).apply(new TypeAbstractVisitor<Expression>() {

public Expression defaultCase(Type t) { return null; }

@Override public Expression forNumericType(NumericType t) { return e; }

@Override public Expression forCharType(CharType t) { return makeCast(INT, e); }

@Override public Expression forByteType(ByteType t) { return makeCast(INT, e); }

@Override public Expression forShortType(ShortType t) { return makeCast(INT, e); }

});

if (result == null) { throw new UnsupportedConversionException(); }

else { return result; }

}

/**

public Pair<Expression, Expression> binaryPromote(final Expression e1, final Expression e2)

throws UnsupportedConversionException {

// Note: Variables with primitive bounds are not fully supported

final Type t1 = NodeProperties.getType(e1);

final Type t2 = NodeProperties.getType(e2);

final Type t1Promoted = t1.apply(new TypeAbstractVisitor<Type>() {

@Override public Type defaultCase(Type t) { return null; }

@Override public Type forNumericType(NumericType t) { return INT; }

@Override public Type forFloatingPointType(FloatingPointType t) { return t; }

@Override public Type forLongType(LongType t) { return t; }

});

if (t1Promoted == null) { throw new UnsupportedConversionException(); }

final Type promoted = t2.apply(new TypeAbstractVisitor<Type>() {

@Override public Type defaultCase(Type t) { return null; }

@Override public Type forNumericType(NumericType t) { return t1Promoted; }

@Override public Type forDoubleType(DoubleType t) { return t; }

@Override public Type forFloatType(FloatType t) {

return (t1Promoted instanceof DoubleType) ? t1Promoted : t;

}

@Override public Type forLongType(LongType t) {

return (t1Promoted instanceof FloatingPointType) ? t1Promoted : t;

}

});

if (promoted == null) { throw new UnsupportedConversionException(); }

return Pair.make(t1.equals(promoted) ? e1 : makeCast(promoted, e1),

t2.equals(promoted) ? e2 : makeCast(promoted, e2));

}

/**

public Pair<Expression, Expression> mergeConditional(final Expression e1, final Expression e2)

throws UnsupportedConversionException {

return NodeProperties.getType(e1).apply(new TypeAbstractVisitor<Pair<Expression, Expression>>() {

public Pair<Expression, Expression> defaultCase(Type t1) {

if (isNumericReference(t1)) { return checkForNumericE2(); }

else if (isBooleanReference(t1) && NodeProperties.getType(e2) instanceof BooleanType) {

try { return Pair.make(makePrimitive(e1), e2); }

catch (UnsupportedConversionException e) { throw new RuntimeException("isBooleanReference() lied"); }

}

else { return joinReferences(); }

}

@Override public Pair<Expression, Expression> forBooleanType(BooleanType t1) {

Type t2 = NodeProperties.getType(e2);

if (t2 instanceof BooleanType) { return Pair.make(e1, e2); }

else if (isBooleanReference(t2)) {

try { return Pair.make(e1, makePrimitive(e2)); }

catch (UnsupportedConversionException e) { throw new RuntimeException("isBooleanReference() lied"); }

}

else { return joinReferences(); }

}

@Override public Pair<Expression, Expression> forNumericType(NumericType t1) { return checkForNumericE2(); }

private boolean isNumericReference(Type t) {

return !_opt.prohibitBoxing() && !isSubtype(t, NULL) &&

(isSubtype(t, CHARACTER_CLASS) ||

isSubtype(t, BYTE_CLASS) ||

isSubtype(t, SHORT_CLASS) ||

isSubtype(t, INTEGER_CLASS) ||

isSubtype(t, LONG_CLASS) ||

isSubtype(t, FLOAT_CLASS) ||

isSubtype(t, DOUBLE_CLASS));

}

private boolean isBooleanReference(Type t) {

return !_opt.prohibitBoxing() && isSubtype(t, BOOLEAN_CLASS) && !isSubtype(t, NULL);

}

private Pair<Expression, Expression> checkForNumericE2() {

return NodeProperties.getType(e2).apply(new TypeAbstractVisitor<Pair<Expression, Expression>>() {

public Pair<Expression, Expression> defaultCase(Type t2) {

if (isNumericReference(t2)) { return joinNumbers(); }

else { return joinReferences(); }

}

@Override public Pair<Expression, Expression> forNumericType(NumericType t2) { return joinNumbers(); }

});

}

private Pair<Expression, Expression> joinNumbers() {

try {

Expression unboxed1 = makePrimitive(e1);

Expression unboxed2 = makePrimitive(e2);

Type numT1 = NodeProperties.getType(unboxed1);

Type numT2 = NodeProperties.getType(unboxed2);

Type joined = null;

if (NodeProperties.hasValue(unboxed1) && numT1 instanceof IntType) {

joined = inRange(NodeProperties.getValue(unboxed1), numT2) ? numT2 : null;

}

if (joined == null && NodeProperties.hasValue(unboxed2) && numT2 instanceof IntType) {

joined = inRange(NodeProperties.getValue(unboxed2), numT1) ? numT1 : null;

}

if (joined == null) { joined = join(numT1, numT2); }