fix #30030, fix #27327 - fix tearoffs and various Object member bugs

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/types.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 the representation of runtime types.
 part of dart._runtime;
 
 final metadata = JS('', 'Symbol("metadata")');
 
 /// The symbol used to store the cached `Type` object associated with a class.
@@ skipping 38 matching lines @@
 ///     T.as(o): Implements 'o as T'.
 ///     T._check(o): Implements the type assertion of 'T x = o;'
 ///
 /// By convention, we used named JavaScript functions for these methods with the
 /// name 'is_X', 'as_X' and 'check_X' for various X to indicate the type or the
 /// implementation strategy for the test (e.g 'is_String', 'is_G' for generic
 /// types, etc.)
 // TODO(jmesserly): we shouldn't implement Type here. It should be moved down
 // to AbstractFunctionType.
 class TypeRep implements Type {
-  TypeRep() {
-    _initialize;
-  }
   String get name => this.toString();
+
+  @JSExportName('is')
+  bool is_T(object) => instanceOf(object, this);
+
+  @JSExportName('as')
+  as_T(object) => cast(object, this);
+
+  @JSExportName('_check')
+  check_T(object) => check(object, this);
 }
 
 class Dynamic extends TypeRep {
   toString() => 'dynamic';
+
+  @JSExportName('is')
+  bool is_T(object) => true;
+
+  @JSExportName('as')
+  as_T(object) => object;
+
+  @JSExportName('_check')
+  check_T(object) => object;
 }
 
 class LazyJSType extends TypeRep {
-  final _jsTypeCallback;
-  final _dartName;
+  final Function() _rawJSType;
+  final String _dartName;
 
-  LazyJSType(this._jsTypeCallback, this._dartName);
+  LazyJSType(this._rawJSType, this._dartName);
 
-  get _rawJSType => JS('', '#()', _jsTypeCallback);
+  toString() => typeName(_rawJSType());
 
-  toString() => _jsTypeCallback != null ? typeName(_rawJSType) : _dartName;
+  rawJSTypeForCheck() {
+    var raw = _rawJSType();
+    if (raw != null) return raw;
+    _warn('Cannot find native JavaScript type ($_dartName) for type check');
+    return _dynamic;
+  }
+
+  @JSExportName('is')
+  bool is_T(obj) => instanceOf(obj, rawJSTypeForCheck());
+
+  @JSExportName('as')
+  as_T(obj) => cast(obj, rawJSTypeForCheck());
+
+  @JSExportName('_check')
+  check_T(obj) => check(obj, rawJSTypeForCheck());
+}
+
+/// An anonymous JS type
+///
+/// For the purposes of subtype checks, these match any JS type.
+class AnonymousJSType extends TypeRep {
+  final String _dartName;
+  AnonymousJSType(this._dartName);
+  toString() => _dartName;
+
+  @JSExportName('is')
+  bool is_T(obj) => _isJSType(getReifiedType(obj));
+
+  @JSExportName('as')
+  as_T(obj) => is_T(obj) ? obj : cast(obj, this);
+
+  @JSExportName('_check')
+  check_T(obj) => is_T(obj) ? obj : check(obj, this);
 }
 
 void _warn(arg) {
   JS('void', 'console.warn(#)', arg);
 }
 
-_isInstanceOfLazyJSType(o, LazyJSType t) {
-  if (t._jsTypeCallback != null) {
-    if (t._rawJSType == null) {
-      var expected = t._dartName;
-      var actual = typeName(getReifiedType(o));
-      _warn('Cannot find native JavaScript type ($expected) '
-          'to type check $actual');
-      return true;
-    }
-    return JS('bool', 'dart.is(#, #)', o, t._rawJSType);
+bool _isJSType(t) => JS('bool', '!#[dart._runtimeType]', t);
+
+var _lazyJSTypes = JS('', 'new Map()');
+var _anonymousJSTypes = JS('', 'new Map()');
+
+lazyJSType(Function() getJSTypeCallback, String name) {
+  var ret = JS('', '#.get(#)', _lazyJSTypes, name);
+  if (ret == null) {
+    ret = new LazyJSType(getJSTypeCallback, name);
+    JS('', '#.set(#, #)', _lazyJSTypes, name, ret);
   }
-  if (o == null) return false;
-  // Anonymous case: match any JS type.
-  return _isJSObject(o);
+  return ret;
 }
 
-_asInstanceOfLazyJSType(o, LazyJSType t) {
-  if (t._jsTypeCallback != null) {
-    if (t._rawJSType == null) {
-      var expected = t._dartName;
-      var actual = typeName(getReifiedType(o));
-      _warn('Cannot find native JavaScript type ($expected) '
-          'to type check $actual');
-      return o;
-    }
-    return JS('bool', 'dart.as(#, #)', o, t._rawJSType);
+anonymousJSType(String name) {
+  var ret = JS('', '#.get(#)', _anonymousJSTypes, name);
+  if (ret == null) {
+    ret = new AnonymousJSType(name);
+    JS('', '#.set(#, #)', _anonymousJSTypes, name, ret);
   }
-  // Anonymous case: allow any JS type.
-  if (o == null) return null;
-  if (!_isJSObject(o)) _throwCastError(o, t, true);
-  return o;
+  return ret;
 }
 
-bool _isJSObject(o) =>
-    JS('bool', '!dart.getReifiedType(#)[dart._runtimeType]', o);
-
-bool _isJSType(t) => JS('bool', '!#[dart._runtimeType]', t);
-
 @JSExportName('dynamic')
 final _dynamic = new Dynamic();
 
-final _initialize = _initialize2();
-
-_initialize2() => JS(
-    '',
-    '''(() => {
-  // JavaScript API forwards to runtime library.
-  $TypeRep.prototype.is = function is_T(object) {
-    return dart.is(object, this);
-  };
-  $TypeRep.prototype.as = function as_T(object) {
-    return dart.as(object, this);
-  };
-  $TypeRep.prototype._check = function check_T(object) {
-    return dart.check(object, this);
-  };
-
-  // Fast path for type `dynamic`.
-  $Dynamic.prototype.is = function is_Dynamic(object) {
-    return true;
-  };
-  $Dynamic.prototype.as = function as_Dynamic(object) {
-    return object;
-  };
-  $Dynamic.prototype._check = function check_Dynamic(object) {
-    return object;
-  };
-
-  $LazyJSType.prototype.is = function is_T(object) {
-    return $_isInstanceOfLazyJSType(object, this);
-  };
-  $LazyJSType.prototype.as = function as_T(object) {
-    return $_asInstanceOfLazyJSType(object, this);
-  };
-  $LazyJSType.prototype._check = function check_T(object) {
-    return $_asInstanceOfLazyJSType(object, this);
-  };
-})()''');
-
 class Void extends TypeRep {
   toString() => 'void';
 }
 
 @JSExportName('void')
 final _void = new Void();
 
 class Bottom extends TypeRep {
   toString() => 'bottom';
 }
@@ skipping 529 matching lines @@
   }
   if (tag) return "Not a type: " + tag.name;
   return "JSObject<" + $type.name + ">";
 })()''');
 
 /// Returns `true` if we have a non-generic function type representation or the
 /// type for `Function`, which is a supertype of all functions in Dart.
 bool _isFunctionType(type) => JS('bool', '# instanceof # || # === #', type,
     AbstractFunctionType, type, Function);
 
-isLazyJSSubtype(t1, LazyJSType t2, isCovariant) {
-  // All JS types are subtypes of anonymous JS types.
-  if (t2._jsTypeCallback == null) {
-    return _isJSType(t1);
-  }
-  return _isSubtype(t1, t2._rawJSType, isCovariant);
-}
-
 /// Returns true if [ft1] <: [ft2].
 /// Returns false if [ft1] </: [ft2] in both spec and strong mode
 /// Returns null if [ft1] </: [ft2] in strong mode, but spec mode
 /// may differ
 /// If [isCovariant] is true, then we are checking subtyping in a covariant
 /// position, and hence the direction of the check for function types
 /// corresponds to the direction of the check according to the Dart spec.
 isFunctionSubtype(ft1, ft2, isCovariant) => JS(
     '',
     '''(() => {
@@ skipping 154 matching lines @@
 
   // "Traditional" name-based subtype check.  Avoid passing
   // function types to the class subtype checks, since we don't
   // currently distinguish between generic typedefs and classes.
   if (!($t1 instanceof $AbstractFunctionType) &&
       !($t2 instanceof $AbstractFunctionType)) {
     let result = $isClassSubType($t1, $t2, $isCovariant);
     if (result === true || result === null) return result;
   }
 
+  if ($t2 instanceof $AnonymousJSType) {
+    // All JS types are subtypes of anonymous JS types.
+    return $_isJSType($t1);
+  }
   if ($t2 instanceof $LazyJSType) {
-    return $isLazyJSSubtype($t1, $t2, $isCovariant);
+    return $_isSubtype($t1, $t2.rawJSTypeForCheck(), isCovariant);
   }
 
   // Function subtyping.
 
   // Handle Objects with call methods.  Those are functions
   // even if they do not *nominally* subtype core.Function.
   if (!$_isFunctionType($t1)) {
     $t1 = $getMethodType($t1, 'call');
     if ($t1 == null) return false;
   }
@@ skipping 158 matching lines @@
     return true;
   }
 
   let typeArgs = $getGenericArgs($type);
   if (!typeArgs) return true;
   for (let t of typeArgs) {
     if (t != $Object && t != $dynamic) return false;
   }
   return true;
 })()''');