Clean up runtime type code

lib/runtime/dart_runtime.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.
 
 var dart, dartx;
 (function (dart) {
   'use strict';
 
   const defineProperty = Object.defineProperty;
   const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
@@ skipping 119 matching lines @@
   function dindex(obj, index) {
     return callMethod(obj, 'get', [index], '[]');
   }
   dart.dindex = dindex;
 
   function dsetindex(obj, index, value) {
     return callMethod(obj, 'set', [index, value], '[]=');
   }
   dart.dsetindex = dsetindex;
 
-  function typeToString(type) {
+  function _typeName(type) {
     if (typeof(type) == "function") {
       let name = type.name;
       let args = type[dart.typeArguments];
       if (args) {
         name += '<';
         for (let i = 0; i < args.length; ++i) {
           if (i > 0) name += ', ';
-          name += typeToString(args[i]);
+          name += _typeName(args[i]);
         }
         name += '>';
       }
       return name;
     } else {
       return type.toString();
     }
   }
-  dart.typeName = typeToString;
+  dart.typeName = _typeName;
+
+  function _ignoreTypeFailure(actual, type) {
+    // TODO(vsm): Remove this hack ...
+    // This is primarily due to the lack of generic methods,
+    // but we need to triage all the errors.
+    if (isSubtype(type, core.Iterable) && isSubtype(actual, core.Iterable) ||

[vsm, 2015/06/11 16:30:26]

Ideally, this would do still do a regular Dart subtype check, but it's just a
workaround for now.

+        isSubtype(type, async.Future) && isSubtype(actual, async.Future) ||
+        isSubtype(type, core.Map) && isSubtype(actual, core.Map) ||
+        isSubtype(type, core.Function) && isSubtype(actual, core.Function)) {
+      console.error('Ignoring cast fail from ' + _typeName(actual) +
+        ' to ' + _typeName(type));
+      return true;
+    }
+    return false;
+  }
 
   function cast(obj, type) {
     // TODO(vsm): handle non-nullable types
     if (obj == null) return obj;
     let actual = realRuntimeType(obj);
     if (isSubtype(actual, type)) return obj;
-    // TODO(vsm): Remove this hack ... due to
-    // lack of generic methods.
-    if (isSubtype(type, core.Iterable) && isSubtype(actual, core.Iterable) ||
-        isSubtype(type, async.Future) && isSubtype(actual, async.Future) ||
-        isSubtype(type, core.Map) && isSubtype(actual, core.Map)) {
-      console.log('Warning: ignoring cast fail from ' + typeToString(actual) + ' to ' + typeToString(type));
-      return obj;
-    }
-    // console.log('Error: cast fail from ' + typeToString(actual) + ' to ' + typeToString(type));
+    if (_ignoreTypeFailure(actual, type)) return obj;
     throw new _js_helper.CastErrorImplementation(actual, type);
   }
   dart.as = cast;
 
 
   // TODO(vsm): How should we encode the runtime type?
   const _runtimeType = Symbol('_runtimeType');
 
   function checkPrimitiveType(obj) {
     switch (typeof obj) {
@@ skipping 34 matching lines @@
     return result;
   }
   dart.realRuntimeType = realRuntimeType;
 
   function instanceOf(obj, type) {
     return isSubtype(realRuntimeType(obj), type);
   }
   dart.is = instanceOf;
 
   function instanceOfOrNull(obj, type) {
-    return (obj == null) || instanceOf(obj, type);
+    // FIXME(vsm): This is used only in checkApply.
+    // Just log failures due to generics for now.
+    if ((obj == null) || instanceOf(obj, type)) return true;
+    let actual = realRuntimeType(obj);
+    if (_ignoreTypeFailure(actual, type)) return true;
+    return false;
   }
 
   /**
    * Computes the canonical type.
    * This maps JS types onto their corresponding Dart Type.
    */
   // TODO(jmesserly): lots more needs to be done here.
   function canonicalType(t) {
     if (t === Object) return core.Object;
     if (t === Function) return core.Function;
@@ skipping 189 matching lines @@
   }
   dart.equals = equals;
 
   /** Checks that `x` is not null or undefined. */
   function notNull(x) {
     if (x == null) throwRuntimeError('expected not-null value');
     return x;
   }
   dart.notNull = notNull;
 
-  function _typeName(type) {
-    if (type === void 0) throwRuntimeError('Undefined type');
-    let name = type.name;
-    if (!name) throwRuntimeError('Unexpected type: ' + type);
-    return name;
-  }
-
   class AbstractFunctionType {
     constructor() {
       this._stringValue = null;
     }
 
     /// Check that a function of this type can be applied to 
     /// actuals.
     checkApply(actuals) {
       if (actuals.length < this.args.length) return false;
       let index = 0;
@@ skipping 980 matching lines @@
 
     // TODO(vsm): This is referenced (as init.globalState) from
     // isolate_helper.dart.  Where should it go?
     // See: https://github.com/dart-lang/dev_compiler/issues/164
     dart.globalState = null;
 
     /** Dart extension members. */
     dartx = dartx || {};
   }
 })(dart || (dart = {}));