Fixes #287 and other failures statically checking SDK tests

lib/src/checker/rules.dart

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library dev_compiler.src.checker.rules;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
@@ skipping 246 matching lines @@
     }
 
     if (t is InterfaceType) {
       var typeArguments = t.typeArguments;
       for (var typeArgument in typeArguments) {
         if (!_isTop(typeArgument)) return false;
       }
       return true;
     }
 
-    throw new StateError("Unexpected type");
+    // We should not see any other type aside from malformed code.
+    return false;
   }
 
   /// Check that f1 is a subtype of f2. [ignoreReturn] is used in the DDC
   /// checker to determine whether f1 would be a subtype of f2 if the return
   /// type of f1 is set to match f2's return type.
   // [fuzzyArrows] indicates whether or not the f1 and f2 should be
   // treated as fuzzy arrow types (and hence dynamic parameters to f2 treated as
   // bottom).
   bool isFunctionSubTypeOf(FunctionType f1, FunctionType f2,
       {bool fuzzyArrows: true, bool ignoreReturn: false}) {
@@ skipping 122 matching lines @@
     //  T is not dynamic or object (handled above)
     //  S != T (handled above)
     //  So only true if bound of S is S' and
     //  S' <: T
     if (t1 is TypeParameterType) {
       DartType bound = t1.element.bound;
       if (bound == null) return false;
       return isSubTypeOf(bound, t2);
     }
 
+    if (t2 is TypeParameterType) {
+      return false;
+    }
+
     if (t2.isDartCoreFunction) {
       if (t1 is FunctionType) return true;
       if (t1.element is ClassElement) {
         if ((t1.element as ClassElement).getMethod("call") != null) return true;
       }
     }
 
     // "Traditional" name-based subtype check.
     if (t1 is InterfaceType && t2 is InterfaceType) {
       return _isInterfaceSubTypeOf(t1, t2);
@@ skipping 86 matching lines @@
       var ok = inferrer.inferExpression(expr, toT, errors);
       if (ok) return InferredType.create(this, expr, toT);
       reason = (errors.isNotEmpty) ? errors.first : null;
     }
     if (c is Cast) return DownCast.create(this, expr, c, reason: reason);
     assert(false);
     return null;
   }
 
   DartType elementType(Element e) {
+    if (e == null) {
+      // Malformed code - just return dynamic.
+      return provider.dynamicType;
+    }
     return (e as dynamic).type;
   }
 
   /// Returns `true` if the target expression is dynamic.
   // TODO(jmesserly): remove this in favor of utils? Or a static method here?
   bool isDynamicTarget(Expression target) => utils.isDynamicTarget(target);
 
   /// Returns `true` if the expression is a dynamic function call or method
   /// invocation.
   bool isDynamicCall(Expression call) {
@@ skipping 171 matching lines @@
     if (rawType is! InterfaceType) return false;
     var type = (rawType as InterfaceType);
     if (type.typeParameters == null ||
         type.typeParameters.length == 0) return false;
     if (e.constructorName.type == null) return false;
     // classTypeName is the type name of the class being instantiated
     var classTypeName = e.constructorName.type;
     // Check that we were not passed any type arguments
     if (classTypeName.typeArguments != null) return false;
     // Infer type arguments
+    if (t is! InterfaceType) return false;
     var targs = _matchTypes(type, t);
     if (targs == null) return false;
     if (e.staticElement == null) return false;
     var constructorElement = e.staticElement;
     // From the constructor element get:
     //  the instantiated type of the constructor, then
     //     the uninstantiated element for the constructor, then
     //        the uninstantiated type for the constructor
     var rawConstructorElement =
         constructorElement.type.element as ConstructorElement;
@@ skipping 111 matching lines @@
     var entries = e.entries;
     bool inferEntry(MapLiteralEntry entry) {
       return _inferExpression(entry.key, kType, errors) &&
           _inferExpression(entry.value, vType, errors);
     }
     var b = entries.every(inferEntry);
     if (b) annotateMapLiteral(e, targs);
     return b;
   }
 }