Enable is and as checks on non-ground types

lib/runtime/_operations.js

 // 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.
 
 /* This library defines runtime operations on objects used by the code
  * generator.
  */
 dart_library.library('dart_runtime/_operations', null, /* Imports */[
 ], /* Lazy Imports */[
   'dart/async',
@@ skipping 173 matching lines @@
         isSubtype(type, async.Stream) && isSubtype(actual, async.Stream) ||
         isSubtype(type, async.StreamSubscription) &&
             isSubtype(actual, async.StreamSubscription)) {
       console.warn('Ignoring cast fail from ' + types.typeName(actual) +
         ' to ' + types.typeName(type));
       return true;
     }
     return false;
   }
 
+  function strongInstanceOf(obj, type) {
+    return types.isSubtype(rtti.realRuntimeType(obj), type);
+  }
+  exports.strongInstanceOf = strongInstanceOf;
+
+  function instanceOfOrNull(obj, type) {
+    if ((obj == null) || strongInstanceOf(obj, type)) return true;
+    return false;
+  }
+
   function instanceOf(obj, type) {
-    return types.isSubtype(rtti.realRuntimeType(obj), type);
+    if (strongInstanceOf(obj, type)) return true;
+    // TODO(vsm): This is perhaps too eager to throw a StrongModeError?
+    // It will throw on <int>[] is List<String>.
+    // TODO(vsm): We can statically detect many cases where this
+    // check is unnecessary.
+    if (types.isGroundType(type)) return false;
+    let actual = rtti.realRuntimeType(obj);
+    dart_utils.throwStrongModeError('Strong mode cast failure from ' +

[Leaf, 2015/08/18 23:31:11]

Calling this a "cast failure" is a bit misleading, I think.  Maybe call it an
"is check failure", and say something like "types.typeName(actual) is not an
instance of types.typeName(type)"?

+      types.typeName(actual) + ' to ' + types.typeName(type));
   }
   exports.instanceOf = instanceOf;
 
-  function instanceOfOrNull(obj, type) {
-    if ((obj == null) || instanceOf(obj, type)) return true;
-    let actual = rtti.realRuntimeType(obj);
-    if (_ignoreTypeFailure(actual, type)) return true;
-    return false;
-  }
-  exports.instanceOfOrNull = instanceOfOrNull;
-
   function cast(obj, type) {
     // TODO(vsm): handle non-nullable types
-    if (obj == null) return obj;
+    if (instanceOfOrNull(obj, type)) return obj;
     let actual = rtti.realRuntimeType(obj);
-    if (types.isSubtype(actual, type)) return obj;
-    if (_ignoreTypeFailure(actual, type)) return obj;
-    errors.throwCastError(actual, type);
+    if (_ignoreTypeFailure(actual, type)) {
+      // TODO(vsm): track why this is happening in our async / await tests.
+      if (types.isGroundType(type)) {
+        console.error('Should not ignore cast failure from ' +
+          types.typeName(actual) + ' to ' + types.typeName(type));
+      }
+      return obj;
+    }
+    if (types.isGroundType(type)) {
+      errors.throwCastError(actual, type);
+    }
+    dart_utils.throwStrongModeError('Strong mode cast failure from ' +
+      types.typeName(actual) + ' to ' + types.typeName(type));
   }
   exports.cast = cast;
 
   function arity(f) {
     // TODO(jmesserly): need to parse optional params.
     // In ES6, length is the number of required arguments.
     return { min: f.length, max: f.length };
   }
   exports.arity = arity;
 
   function equals(x, y) {
     if (x == null || y == null) return x == y;
     let eq = x['=='];
     return eq ? eq.call(x, y) : x === y;
   }
   exports.equals = equals;
 
   /** Checks that `x` is not null or undefined. */
   function notNull(x) {
-    // TODO(leafp): This is probably not the right error to throw.
-    if (x == null) throwError('expected not-null value');
+    if (x == null) errors.throwNullValueError();
     return x;
   }
   exports.notNull = notNull;
 
   /**
    * Creates a dart:collection LinkedHashMap.
    *
    * For a map with string keys an object literal can be used, for example
    * `map({'hi': 1, 'there': 2})`.
    *
@@ skipping 169 matching lines @@
     next() {
       let i = this.dartIterator;
       let done = !i.moveNext();
       return { done: done, value: done ? void 0 : i.current };
     }
   }
   exports.JsIterator = JsIterator;
 
 
 });