improve DDC's type checks

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/operations.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.
 
 /// This library defines runtime operations on objects used by the code
 /// generator.
 part of dart._runtime;
 
 class InvocationImpl extends Invocation {
   final Symbol memberName;
@@ skipping 136 matching lines @@
 // behavior for JS types.
 // TODO(jacobr): remove the type checking rules workaround when mirrors based
 // PageLoader code can generate the correct reified generic types.
 dputMirror(obj, field, value) {
   var f = _canonicalMember(obj, field);
   _trackCall(obj);
   if (f != null) {
     var setterType = getSetterType(getType(obj), f);
     if (setterType != null) {
       setterType = _stripGenericArguments(setterType);
-      return JS('', '#[#] = #', obj, f, check(value, setterType));
+      return JS('', '#[#] = #._check(#)', obj, f, setterType, value);
     }
   }
   return noSuchMethod(
       obj, new InvocationImpl(field, JS('', '[#]', value), isSetter: true));
 }
 
 dput(obj, field, value) {
   var f = _canonicalMember(obj, field);
   _trackCall(obj);
   if (f != null) {
     var setterType = getSetterType(getType(obj), f);
     if (setterType != null) {
-      return JS('', '#[#] = #', obj, f, check(value, setterType));
+      return JS('', '#[#] = #._check(#)', obj, f, setterType, value);
     }
     // Always allow for JS interop objects.
     if (isJsInterop(obj)) {
       return JS('', '#[#] = #', obj, f, value);
     }
   }
   return noSuchMethod(
       obj, new InvocationImpl(field, JS('', '[#]', value), isSetter: true));
 }
 
 /// Check that a function of a given type can be applied to
 /// actuals.
 _checkApply(type, actuals) => JS('', '''(() => {
   // TODO(vsm): Remove when we no longer need mirrors metadata.
   // An array is used to encode annotations attached to the type.
   if ($type instanceof Array) {
     $type = type[0];
   }
   if ($actuals.length < $type.args.length) return false;
   let index = 0;
   for(let i = 0; i < $type.args.length; ++i) {
-    $check($actuals[i], $type.args[i]);
+    $type.args[i]._check($actuals[i]);
     ++index;
   }
   if ($actuals.length == $type.args.length) return true;
   let extras = $actuals.length - $type.args.length;
   if ($type.optionals.length > 0) {
     if (extras > $type.optionals.length) return false;
     for(let i = 0, j=index; i < extras; ++i, ++j) {
-      $check($actuals[j], $type.optionals[i]);
+      $type.optionals[i]._check($actuals[j]);
     }
     return true;
   }
   // TODO(leafp): We can't tell when someone might be calling
   // something expecting an optional argument with named arguments
 
   if (extras != 1) return false;
   // An empty named list means no named arguments
   if ($getOwnPropertyNames($type.named).length == 0) return false;
   let opts = $actuals[index];
   let names = $getOwnPropertyNames(opts);
   // Type is something other than a map
   if (names.length == 0) return false;
   for (var name of names) {
     if (!($hasOwnProperty.call($type.named, name))) {
       return false;
     }
-    $check(opts[name], $type.named[name]);
+    $type.named[name]._check(opts[name]);
   }
   return true;
 })()''');
 
 _toSymbolName(symbol) => JS('', '''(() => {
         let str = $symbol.toString();
         // Strip leading 'Symbol(' and trailing ')'
         return str.substring(7, str.length-1);
     })()''');
 
@@ skipping 246 matching lines @@
         !!$isSubtype(type, $StreamSubscription) &&
         !!$isSubtype(actual, $StreamSubscription)) {
       console.warn('Ignoring cast fail from ' + $typeName(actual) +
                    ' to ' + $typeName(type));
       return true;
     }
     return false;
   });
 })()''');
 
-/// Returns true if [obj] is an instance of [type] in strong mode, otherwise
-/// false.
-///
-/// This also allows arbitrary JS function objects to be subtypes of every Dart
-/// function types.
-bool strongInstanceOf(obj, type, ignoreFromWhiteList) => JS('', '''(() => {
-  let actual = $getReifiedType($obj);
-  let result = $isSubtype(actual, $type);
-  if (result ||
-      (actual == $int && $isSubtype($double, $type)) ||
-      (actual == $jsobject && $_isFunctionType(type) &&
-          typeof(obj) === 'function')) {
-    return true;
-  }
-  if (result === null &&
-      dart.__ignoreWhitelistedErrors &&
-      $ignoreFromWhiteList &&
-      $_ignoreTypeFailure(actual, $type)) {
-    return true;
-  }
-  return false;
-})()''');
-
-/// Returns true if [obj] is null or an instance of [type]
-/// Returns false if [obj] is non-null and not an instance of [type]
-/// in strong mode
-bool instanceOfOrNull(obj, type) {
-  // If strongInstanceOf returns null, convert to false here.
-  return obj == null || JS('bool', '#', strongInstanceOf(obj, type, true));
-}
-
 @JSExportName('is')
 bool instanceOf(obj, type) {
   if (obj == null) {
     return JS('bool', '# == # || #', type, Null, _isTop(type));
   }
-  return strongInstanceOf(obj, type, false);
+  return JS('#', '!!#', isSubtype(getReifiedType(obj), type));
 }
 
 @JSExportName('as')
-cast(obj, type) {
-  if (JS('bool', '# == #', type, dynamic) || obj == null) return obj;
-  bool result = strongInstanceOf(obj, type, true);
-  if (JS('bool', '#', result)) return obj;
-  if (JS('bool', '!dart.__ignoreAllErrors')) {
-    _throwCastError(obj, type, result);
+cast(obj, type, bool typeError) {
+  if (obj == null) return obj;
+  var actual = getReifiedType(obj);
+  var result = isSubtype(actual, type);
+  if (JS(
+      'bool',
+      '# === true || # === null && dart.__ignoreWhitelistedErrors && #(#, #)',
+      result,
+      result,
+      _ignoreTypeFailure,
+      actual,
+      type)) {
+    return obj;
   }
-  JS('', 'console.error(#)',
-      'Actual: ${typeName(getReifiedType(obj))} Expected: ${typeName(type)}');
-  return obj;
-}
-
-check(obj, type) {
-  if (JS('bool', '# == #', type, dynamic) || obj == null) return obj;
-  bool result = strongInstanceOf(obj, type, true);
-  if (JS('bool', '#', result)) return obj;
-  if (JS('bool', '!dart.__ignoreAllErrors')) {
-    _throwTypeError(obj, type, result);
-  }
-  JS('', 'console.error(#)',
-      'Actual: ${typeName(getReifiedType(obj))} Expected: ${typeName(type)}');
-  return obj;
+  return castError(obj, type, typeError);
 }
 
 bool test(bool obj) {
   if (obj == null) _throwBooleanConversionError();
   return obj;
 }
 
 bool dtest(obj) {
   if (obj is! bool) booleanConversionFailed(obj);
   return obj;
 }
 
 void _throwBooleanConversionError() =>
     throw new BooleanConversionAssertionError();
 
 void booleanConversionFailed(obj) {
   if (obj == null) {
     _throwBooleanConversionError();
   }
   var actual = getReifiedType(obj);
   var expected = JS('', '#', bool);
   throw new TypeErrorImplementation.fromMessage(
       "type '${typeName(actual)}' is not a subtype of "
       "type '${typeName(expected)}' in boolean expression");
 }
 
-void _throwCastError(obj, type, bool result) {
-  var actual = getReifiedType(obj);
-  if (result == false) throwCastError(obj, actual, type);
+castError(obj, type, bool typeError) {
+  var objType = getReifiedType(obj);
+  if (JS('bool', '!dart.__ignoreAllErrors')) {
+    var errorInStrongMode = isSubtype(objType, type) == null;
 
-  throwStrongModeCastError(obj, actual, type);
-}
+    var actual = typeName(objType);
+    var expected = typeName(type);
+    if (JS('bool', 'dart.__trapRuntimeErrors')) JS('', 'debugger');
 
-void _throwTypeError(obj, type, bool result) {
-  var actual = getReifiedType(obj);
-  if (result == false) throwTypeError(obj, actual, type);
-
-  throwStrongModeTypeError(obj, actual, type);
+    var error = JS('bool', '#', typeError)
+        ? new TypeErrorImplementation(obj, actual, expected, errorInStrongMode)
+        : new CastErrorImplementation(obj, actual, expected, errorInStrongMode);
+    throw error;
+  }
+  JS('', 'console.error(#)',
+      'Actual: ${typeName(objType)} Expected: ${typeName(type)}');
+  return obj;
 }
 
 asInt(obj) {
   if (obj == null) return null;
 
   if (JS('bool', 'Math.floor(#) != #', obj, obj)) {
-    throwCastError(obj, getReifiedType(obj), JS('', '#', int));
+    castError(obj, JS('', '#', int), false);
   }
   return obj;
 }
 
-/// Adds type type test predicates to a constructor for a non-parameterized
-/// type. Non-parameterized types can use `instanceof` for subclass checks and
-/// fall through to a helper for subtype tests.
-addSimpleTypeTests(ctor) => JS('', '''(() => {
-  $ctor.is = function is_C(object) {
-    // This is incorrect for classes [Null] and [Object], so we do not use
-    // [addSimpleTypeTests] for these classes.
-    if (object instanceof this) return true;
-    return dart.is(object, this);
-  };
-  $ctor.as = function as_C(object) {
-    if (object instanceof this) return object;
-    return dart.as(object, this);
-  };
-  $ctor._check = function check_C(object) {
-    if (object instanceof this) return object;
-    return dart.check(object, this);
-  };
-})()''');
-
-/// Adds type type test predicates to a constructor. Used for parmeterized
-/// types. We avoid `instanceof` for, e.g. `x is ListQueue` since there is
-/// no common class for `ListQueue<int>` and `ListQueue<String>`.
-addTypeTests(ctor) => JS('', '''(() => {
-  $ctor.as = function as_G(object) {
-    return dart.as(object, this);
-  };
-  $ctor.is = function is_G(object) {
-    return dart.is(object, this);
-  };
-  $ctor._check = function check_G(object) {
-    return dart.check(object, this);
-  };
-})()''');
-
 // TODO(vsm): Consider optimizing this.  We may be able to statically
 // determine which == operation to invoke given the static types.
 equals(x, y) => JS('', '''(() => {
   if ($x == null || $y == null) return $x == $y;
   let eq = $x[dartx['==']] || $x['=='];
   return eq ? eq.call($x, $y) : $x === $y;
 })()''');
 
 /// Checks that `x` is not null or undefined. */
 notNull(x) {
@@ skipping 285 matching lines @@
   var extension = getExtensionType(obj);
   if (extension != null) {
     return JS('', '#[dartx.noSuchMethod](#)', obj, invocation);
   }
   return JS('', '#.noSuchMethod(#)', obj, invocation);
 }
 
 constFn(x) => JS('', '() => x');
 
 runtimeType(obj) {
-  // Handle primitives where the method isn't on the object.
-  var result = _checkPrimitiveType(obj);
-  if (result != null) return wrapType(result);
-
-  // Delegate to the (possibly user-defined) method on the object.
-  var extension = getExtensionType(obj);
-  if (extension != null) {
-    result = JS('', '#[dartx.runtimeType]', obj);
-    // If extension doesn't override runtimeType, return the extension type.
-    return result ?? wrapType(extension);
+  if (obj == null) return Null;
+  if (JS('bool', '# instanceof #', obj, Object)) {
+    // A normal Dart object: get `obj.runtimeType`
+    // (callable Dart classes are also handled here)
+    return JS('', '#.runtimeType', obj);
   }
-  if (JS('bool', 'typeof # == "function" && # instanceof Function', obj, obj)) {
-    return wrapType(getReifiedType(obj));
+  if (JS('bool', 'typeof obj == "object"')) {
+    // Some other kind of JS object.
+    var extensionType = JS('', '#[#]', obj, _extensionType);
+    if (extensionType != null) {
+      // An extension type: get `obj[dartx.runtimeType]`
+      var result = JS('', '#[dartx.runtimeType]', obj);
+      // If the extension doesn't override runtimeType, handle that.
+      // TODO(jmesserly): is this still possible? Object members should always
+      // be defined on extension types.
+      if (result != null) return result;
+    } else {
+      extensionType = jsobject;
+    }
+    return wrapType(extensionType);
   }
-  return JS('', '#.runtimeType', obj);
+  // All other types: fall back to `getReifiedType`
+  return wrapType(getReifiedType(obj));
 }
 
 /// Implements Dart's interpolated strings as ES2015 tagged template literals.
 ///
 /// For example: dart.str`hello ${name}`
 String str(strings, @rest values) => JS('', '''(() => {
   let s = $strings[0];
   for (let i = 0, len = $values.length; i < len; ) {
     s += $notNull($_toString($values[i])) + $strings[++i];
   }
@@ skipping 33 matching lines @@
 /// Libraries are not actually deferred in DDC, so this just returns a future
 /// that completes immediately.
 Future loadLibrary() => new Future.value();
 
 /// Defines lazy statics.
 void defineLazy(to, from) {
   for (var name in getOwnNamesAndSymbols(from)) {
     defineLazyProperty(to, name, getOwnPropertyDescriptor(from, name));
   }
 }