Enable is and as checks on non-ground types

Failures generate a StrongModeError.  Fixes #236.  Partially addresses #238.

Some issues to do:
- We're too eager to throw a StrongModeError.  E.g., <int>[] is List<String> will throw.
- We don't differentiate between implicit and explicit casts.

[email protected]

Review URL: https://codereview.chromium.org/1298893003 .

Author: vsmenon

pkg/dev_compiler/lib/runtime/_classes.js

@@ -24,7 +24,7 @@ dart_library.library('dart_runtime/_classes', null, /* Imports */[
   const copyTheseProperties = dart_utils.copyTheseProperties;
   const defineMemoizedGetter = dart_utils.defineMemoizedGetter;
   const safeGetOwnProperty = dart_utils.safeGetOwnProperty;
-  const throwError = dart_utils.throwError;
+  const throwInternalError = dart_utils.throwInternalError;
 
   const defineProperty = Object.defineProperty;
   const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
@@ -110,12 +110,12 @@ dart_library.library('dart_runtime/_classes', null, /* Imports */[
   function generic(typeConstructor) {
     let length = typeConstructor.length;
     if (length < 1) {
-      throwError('must have at least one generic type argument');
+      throwInternalError('must have at least one generic type argument');
     }
     let resultMap = new Map();
     function makeGenericType(/*...arguments*/) {
       if (arguments.length != length && arguments.length != 0) {
-        throwError('requires ' + length + ' or 0 type arguments');
+        throwInternalError('requires ' + length + ' or 0 type arguments');
       }
       let args = slice.call(arguments);
       while (args.length < length) args.push(types.dynamic);
@@ -124,7 +124,7 @@ dart_library.library('dart_runtime/_classes', null, /* Imports */[
       for (let i = 0; i < length; i++) {
         let arg = args[i];
         if (arg == null) {
-          throwError('type arguments should not be null: '
+          throwInternalError('type arguments should not be null: '
                             + typeConstructor);
         }
         let map = value;

pkg/dev_compiler/lib/runtime/_errors.js

@@ -29,4 +29,13 @@ dart_library.library('dart_runtime/_errors', null, /* Imports */[
     operations.throw(new core.AssertionError());
   }
   exports.throwAssertionError = throwAssertionError;
+
+  function throwNullValueError() {
+    // TODO(vsm): Per spec, we should throw an NSM here.  Technically, we ought
+    // to thread through method info, but that uglifies the code and can't
+    // actually be queried ... it only affects how the error is printed.
+    operations.throw(new core.NoSuchMethodError(null,
+      new core.Symbol('<Unexpected Null Value>'), null, null, null));
+  }
+  exports.throwNullValueError = throwNullValueError;
 });

pkg/dev_compiler/lib/runtime/_operations.js

@@ -191,26 +191,47 @@ dart_library.library('dart_runtime/_operations', null, /* Imports */[
     return false;
   }
 
-  function instanceOf(obj, type) {
+  function strongInstanceOf(obj, type) {
     return types.isSubtype(rtti.realRuntimeType(obj), type);
   }
-  exports.instanceOf = instanceOf;
+  exports.strongInstanceOf = strongInstanceOf;
 
   function instanceOfOrNull(obj, type) {
-    if ((obj == null) || instanceOf(obj, type)) return true;
-    let actual = rtti.realRuntimeType(obj);
-    if (_ignoreTypeFailure(actual, type)) return true;
+    if ((obj == null) || strongInstanceOf(obj, type)) return true;
     return false;
   }
-  exports.instanceOfOrNull = instanceOfOrNull;
+
+  function instanceOf(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 is check failure: ' +
+      types.typeName(actual) + ' does not soundly subtype ' +
+      types.typeName(type));
+  }
+  exports.instanceOf = instanceOf;
 
   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;
 
@@ -230,8 +251,7 @@ dart_library.library('dart_runtime/_operations', null, /* Imports */[
 
   /** 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;

pkg/dev_compiler/lib/runtime/dart_library.js

@@ -48,7 +48,7 @@ var dart_library =
       for (let name of list) {
         let lib = libraries[name];
         if (!lib) {
-          dart_utils.throwError('Library not available: ' + name);
+          dart_utils.throwInternalError('Library not available: ' + name);
         }
         results.push(handler(lib));
       }
@@ -58,7 +58,7 @@ var dart_library =
     load(inheritedPendingSet) {
       // Check for cycles
       if (this._state == LibraryLoader.LOADING) {
-        dart_utils.throwError('Circular dependence on library: '
+        dart_utils.throwInternalError('Circular dependence on library: '
                               + this._name);
       } else if (this._state >= LibraryLoader.LOADED) {
         return this._library;
@@ -105,7 +105,9 @@ var dart_library =
   function import_(libraryName) {
     bootstrap();
     let loader = libraries[libraryName];
-    if (!loader) dart_utils.throwError('Library not found: ' + libraryName);
+    // TODO(vsm): A user might call this directly from JS (as we do in tests).
+    // We may want a different error type.
+    if (!loader) dart_utils.throwInternalError('Library not found: ' + libraryName);
     return loader.load();
   }
   dart_library.import = import_;

pkg/dev_compiler/lib/runtime/dart_runtime.js

@@ -89,6 +89,7 @@ dart_library.library('dart_runtime/dart', null, /* Imports */[
     'notNull',
     'stackPrint',
     'stackTrace',
+    'strongInstanceOf',
     'throw',
     'toString',
   ])

pkg/dev_compiler/lib/runtime/dart_utils.js

@@ -21,16 +21,28 @@ var dart_utils =
 
   const slice = [].slice;
 
+  class StrongModeError extends Error {
+    constructor(message) {
+      super(message);
+    }
+  }
+
+  /** This error indicates a strong mode specific failure.
+   */
+  function throwStrongModeError(message) {
+    throw new StrongModeError(message);
+  }
+  dart_utils.throwStrongModeError = throwStrongModeError;
 
   /** This error indicates a bug in the runtime or the compiler.
    */
-  function throwError(message) {
+  function throwInternalError(message) {
     throw Error(message);
   }
-  dart_utils.throwError = throwError;
+  dart_utils.throwInternalError = throwInternalError;
 
   function assert(condition) {
-    if (!condition) throwError("The compiler is broken: failed assert");
+    if (!condition) throwInternalError("The compiler is broken: failed assert");
   }
   dart_utils.assert = assert;
 
@@ -60,7 +72,7 @@ var dart_utils =
       value = x;
     }
     function circularInitError() {
-      throwError('circular initialization for field ' + name);
+      throwInternalError('circular initialization for field ' + name);
     }
     function lazyGetter() {
       if (init == null) return value;

pkg/dev_compiler/lib/src/checker/checker.dart

@@ -694,7 +694,7 @@ class CodeChecker extends RecursiveAstVisitor {
   void _checkRuntimeTypeCheck(AstNode node, TypeName typeName) {
     var type = getType(typeName);
     if (!rules.isGroundType(type)) {
-      _recordMessage(new InvalidRuntimeCheckError(node, type));
+      _recordMessage(new NonGroundTypeCheckInfo(node, type));
     }
   }
 

pkg/dev_compiler/lib/src/info.dart

@@ -464,15 +464,19 @@ class InvalidParameterDeclaration extends StaticError {
   @override String get message => 'Type check failed: {0} is not of type {1}';
 }
 
-class InvalidRuntimeCheckError extends StaticError {
+class NonGroundTypeCheckInfo extends StaticInfo {
   final DartType type;
+  final AstNode node;
 
-  InvalidRuntimeCheckError(AstNode node, this.type) : super(node) {
+  NonGroundTypeCheckInfo(this.node, this.type) {
     assert(node is IsExpression || node is AsExpression);
   }
 
   @override List<Object> get arguments => [type];
-  String get message => "Invalid runtime check on non-ground type {0}";
+  String get message =>
+      "Runtime check on non-ground type {0} may throw StrongModeError";
+
+  toErrorCode() => new HintCode(name, message);
 }
 
 // Invalid override of an instance member of a class.