@@ -719,8 +719,7 @@ private DJClass resolveThis(Option<String> outerName, Node node) {
 
     private void addRuntimeCheck(Node node, Type expectedType, Type declaredActualType) {
       if (!ts.isSubtype(ts.erase(declaredActualType), ts.erase(expectedType))) {
-        Thunk<Class<?>> erasedExpectedType = ts.erasedClass(expectedType);
-        if (erasedExpectedType != null) { setCheckedType(node, erasedExpectedType); }
+        setCheckedType(node, ts.erasedClass(expectedType));
       }
     }
 
 
@@ -111,31 +111,66 @@ public TypeNameChecker(TypeContext ctx, Options options) {
     visitor = new TypeNameVisitor();
   }
 
+  /** Get the type corresponding to {@code t}; verify that it is well-formed. */
   public Type check(TypeName t) {
+    Type result = t.acceptVisitor(visitor);
+    ensureWellFormed(t);
+    return result;
+  }
+  
+  /**
+   * Get the type corresponding to {@code t}; verify that it is structurally well-formed, but
+   * delay full well-formedness checking until a later {@link #ensureWellFormed} call. 
+   */
+  public Type checkStructure(TypeName t) {
     return t.acceptVisitor(visitor);
   }
 
+  /** Invoke {@link #check} on each element of a list. */
   public Iterable<Type> checkList(Iterable<? extends TypeName> l) {
-    return IterUtil.mapSnapshot(l, visitor);
+    Iterable<Type> result = IterUtil.mapSnapshot(l, visitor);
+    ensureWellFormedList(l);
+    return result;
+  }
+  
+  /** Invoke {@link #checkStructure} on each element of a list. */
+  public Iterable<Type> checkStructureForList(Iterable<? extends TypeName> l) {
+    Iterable<Type> result = IterUtil.mapSnapshot(l, visitor);
+    return result;
   }
 
+  /**
+   * Verify that a TypeName that has already been checked is well-formed (according to
+   * {@link TypeSystem#isWellFormed}).
+   */
+  public void ensureWellFormed(TypeName t) {
+    if (!ts.isWellFormed(getType(t))) {
+      throw new ExecutionError("malformed.type", t);
+    }
+  }
+  
+  /** Invoke {@link #ensureWellFormed} on each element of a list. */
+  public void ensureWellFormedList(Iterable<? extends TypeName> l) {
+    for (TypeName t : l) { ensureWellFormed(t); }
+  }
+  
+  
   /** Tag the given type parameters with a new VariableType, and set the bounds appropriately. */
   public void checkTypeParameters(TypeParameter[] tparams) {
     for (TypeParameter tparam : tparams) {
       setTypeVariable(tparam, new VariableType(new BoundedSymbol(tparam, tparam.getRepresentation())));
     }
     TypeNameVisitor v = new TypeNameVisitor();
     for (TypeParameter param : tparams) {
-      Type firstBound = param.getBound().acceptVisitor(v);
-      Iterable<Type> restBounds = checkList(param.getInterfaceBounds());
-      BoundedSymbol bounds = getTypeVariable(param).symbol();
-      if (IterUtil.isEmpty(restBounds)) { bounds.initializeUpperBound(firstBound); }
-      else {
-        bounds.initializeUpperBound(new IntersectionType(IterUtil.compose(firstBound, restBounds)));
+      Type upperBound = param.getBound().acceptVisitor(v);
+      for (Type t : checkList(param.getInterfaceBounds())) {
+        upperBound = ts.meet(upperBound, t);
       }
+      BoundedSymbol bounds = getTypeVariable(param).symbol();
+      bounds.initializeUpperBound(upperBound);
       bounds.initializeLowerBound(TypeSystem.NULL);
     }
-  }  
+  }
 
   private class TypeNameVisitor extends AbstractVisitor<Type> implements Lambda<TypeName, Type> {
 
@@ -282,7 +317,7 @@ private class TypeNameVisitor extends AbstractVisitor<Type> implements Lambda<Ty
         }
         catch (AmbiguousNameException e) { throw new ExecutionError("ambiguous.name", node); }
         catch (InvalidTargetException e) { throw new RuntimeException("context produced bad type"); }
-        catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument", node); }
+        catch (InvalidTypeArgumentException e) { throw new ExecutionError("type.argument.arity", node); }
         catch (UnmatchedLookupException e) {
           if (e.matches() == 0) { throw new ExecutionError("undefined.name.noinfo", node); }
           else { throw new ExecutionError("ambiguous.name", node); }
 
@@ -75,7 +75,9 @@ private Iterable<CompilationUnit> parse(Iterable<? extends File> sources) throws
   private void typeCheck(Iterable<CompilationUnit> sources, Iterable<? extends File> cp) throws InterpreterException {
     ClassLoader loader = new PathClassLoader(null, cp);
     Library classLib = SymbolUtil.classLibrary(loader);
+    debug.logStart("creating TreeLibrary");
     Library sourceLib = new TreeLibrary(sources, loader, _opt);
+    debug.logEnd("creating TreeLibrary");
     TypeContext context = new TopLevelContext(new LibraryContext(new LibraryContext(classLib), sourceLib), loader);
     CompilationUnitChecker checker = new CompilationUnitChecker(context, _opt);
     List<InterpreterException> errors = new ArrayList<InterpreterException>();
Original file line number	Diff line number	Diff line change
@@ -719,8 +719,7 @@ private DJClass resolveThis(Option<String> outerName, Node node) {
719	719
720	720	private void addRuntimeCheck(Node node, Type expectedType, Type declaredActualType) {
721	721	if (!ts.isSubtype(ts.erase(declaredActualType), ts.erase(expectedType))) {
722		- Thunk<Class<?>> erasedExpectedType = ts.erasedClass(expectedType);
723		- if (erasedExpectedType != null) { setCheckedType(node, erasedExpectedType); }
	722	+ setCheckedType(node, ts.erasedClass(expectedType));
724	723	}
725	724	}
726	725