Support lazy JS types.

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; }
+  TypeRep() {
+    _initialize;
+  }
   String get name => this.toString();
 }
 
 class Dynamic extends TypeRep {
   toString() => 'dynamic';
 }
 
+class LazyJSType implements Type {
+  final _jsTypeCallback;
+  final _dartName;
+
+  LazyJSType(this._jsTypeCallback, this._dartName);
+
+  get _rawJSType => JS('', '#()', _jsTypeCallback);
+
+  toString() => _jsTypeCallback != null ? typeName(_rawJSType) : _dartName;
+}
+
+_isInstanceOfLazyJSType(o, LazyJSType t) {
+  if (t._jsTypeCallback != null) {
+    return JS('bool', 'dart.is(#, #)', o, t._rawJSType);
+  }
+  if (o == null) return false;
+  // Anonymous case: match any JS type.
+  return _isJSObject(o);
+}
+
+_asInstanceOfLazyJSType(o, LazyJSType t) {
+  if (t._jsTypeCallback != null) {
+    return JS('bool', 'dart.as(#, #)', o, t._rawJSType);
+  }
+  // Anonymous case: allow any JS type.
+  if (o == null) return null;
+  if (!_isJSObject(o)) _throwCastError(o, t, true);
+  return o;
+}
+
+bool _isJSObject(o) => JS('bool', '!dart.getReifiedType(o)[dart._runtimeType]');
+
 @JSExportName('dynamic')
 final _dynamic = new Dynamic();
 
 final _initialize = _initialize2();
 
-_initialize2() => JS('', '''(() => {
+_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);
+  };
 })()''');
 
 class Void extends TypeRep {
   toString() => 'void';
 }
 
 @JSExportName('void')
 final _void = new Void();
 
 class Bottom extends TypeRep {
   toString() => 'bottom';
 }
+
 final bottom = new Bottom();
 
 class JSObject extends TypeRep {
   toString() => 'NativeJavaScriptObject';
 }
 
 final jsobject = new JSObject();
 
 class WrappedType extends Type {
   final _wrappedType;
   WrappedType(this._wrappedType);
   toString() => typeName(_wrappedType);
 }
 
-final AbstractFunctionType = JS('', '''
+final AbstractFunctionType = JS(
+    '',
+    '''
   class AbstractFunctionType extends $TypeRep {
     constructor() {
       super();
       this._stringValue = null;
     }
 
     toString() { return this.name; }
 
     get name() {
       if (this._stringValue) return this._stringValue;
@@ skipping 34 matching lines @@
     }
   }
 ''');
 
 /// Memo table for named argument groups. A named argument packet
 /// {name1 : type1, ..., namen : typen} corresponds to the path
 /// n, name1, type1, ...., namen, typen.  The element of the map
 /// reached via this path (if any) is the canonical representative
 /// for this packet.
 final _fnTypeNamedArgMap = JS('', 'new Map()');
+
 /// Memo table for positional argument groups. A positional argument
 /// packet [type1, ..., typen] (required or optional) corresponds to
 /// the path n, type1, ...., typen.  The element reached via
 /// this path (if any) is the canonical representative for this
 /// packet. Note that required and optional parameters packages
 /// may have the same canonical representation.
 final _fnTypeArrayArgMap = JS('', 'new Map()');
+
 /// Memo table for function types. The index path consists of the
 /// path length - 1, the returnType, the canonical positional argument
 /// packet, and if present, the canonical optional or named argument
 /// packet.  A level of indirection could be avoided here if desired.
 final _fnTypeTypeMap = JS('', 'new Map()');
+
 /// Memo table for small function types with no optional or named
 /// arguments and less than a fixed n (currently 3) number of
 /// required arguments.  Indexing into this table by the number
 /// of required arguments yields a map which is indexed by the
 /// argument types themselves.  The element reached via this
 /// index path (if present) is the canonical function type.
 final _fnTypeSmallMap = JS('', '[new Map(), new Map(), new Map()]');
 
-final FunctionType = JS('', '''
+final FunctionType = JS(
+    '',
+    '''
   class FunctionType extends $AbstractFunctionType {
     static _memoizeArray(map, arr, create) {
       let len = arr.length;
       map = FunctionType._lookupNonTerminal(map, len);
       for (var i = 0; i < len-1; ++i) {
         map = FunctionType._lookupNonTerminal(map, arr[i]);
       }
       let result = map.get(arr[len-1]);
       if (result !== void 0) return result;
       map.set(arr[len-1], result = create());
@@ skipping 133 matching lines @@
         }
         return result;
       }
       this.args = process(this.args, this.metadata);
       this.optionals = process(this.optionals, this.metadata);
       // TODO(vsm): Add named arguments.
     }
   }
 ''');
 
-
-final Typedef = JS('', '''
+final Typedef = JS(
+    '',
+    '''
   class Typedef extends $AbstractFunctionType {
     constructor(name, closure) {
       super();
       this._name = name;
       this._closure = closure;
       this._functionType = null;
     }
 
     get name() {
       return this._name;
@@ skipping 23 matching lines @@
     }
 
     get metadata() {
       return this.functionType.metadata;
     }
   }
 ''');
 
 final _typeFormalCount = JS('', 'Symbol("_typeFormalCount")');
 
-_functionType(definite, returnType, args, extra) => JS('', '''(() => {
+_functionType(definite, returnType, args, extra) => JS(
+    '',
+    '''(() => {
   // TODO(jmesserly): this is a bit of a retrofit, to easily fit
   // generic functions into all of the existing ways we generate function
   // signatures. Given `(T) => [T, [T]]` we'll return a function that does
   // `(T) => _functionType(definite, T, [T])` ... we could do this in the
   // compiler instead, at a slight cost to code size.
   if ($args === void 0 && $extra === void 0) {
     const fnTypeParts = $returnType;
     // A closure that computes the remaining arguments.
     // Return a function that makes the type.
     function makeGenericFnType(...types) {
@@ skipping 15 matching lines @@
 
 ///
 /// Create a definite function type. No substitution of dynamic for
 /// bottom occurs.
 ///
 definiteFunctionType(returnType, args, extra) =>
     _functionType(true, returnType, args, extra);
 
 typedef(name, closure) => JS('', 'new #(#, #)', Typedef, name, closure);
 
-typeName(type) => JS('', '''(() => {
+typeName(type) => JS(
+    '',
+    '''(() => {
   if ($type === void 0) return "undefined type";
   if ($type === null) return "null type";
   // Non-instance types
   if ($type instanceof $TypeRep) {
     if ($type instanceof $Typedef) {
       return $type.name + "(" + $type.functionType.toString() + ")";
     }
     return $type.toString();
   }
 
@@ skipping 32 matching lines @@
   return "JSObject<" + $type.name + ">";
 })()''');
 
 /// Get the underlying function type, potentially from the call method
 /// for a class type.
 getImplicitFunctionType(type) {
   if (isFunctionType(type)) return type;
   return getMethodTypeFromType(type, 'call');
 }
 
-bool isFunctionType(type) =>
-    JS('bool', '# instanceof # || # === #',
-        type, AbstractFunctionType, type, Function);
+bool isFunctionType(type) => JS('bool', '# instanceof # || # === #', type,
+    AbstractFunctionType, type, Function);
+
+isLazyJSSubtype(LazyJSType t1, LazyJSType t2, covariant) {
+  if (t1 == t2) return true;
+
+  // All anonymous JS types are subtypes of each other.
+  if (t1._jsTypeCallback == null || t2._jsTypeCallback == null) return true;
+  return isClassSubType(t1._rawJSType, t2._rawJSType, covariant);
+}
 
 /// 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 [covariant] 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, covariant) => JS('', '''(() => {
+isFunctionSubtype(ft1, ft2, covariant) => JS(
+    '',
+    '''(() => {
   if ($ft2 === $Function) {
     return true;
   }
 
   if ($ft1 === $Function) {
     return false;
   }
 
   let ret1 = $ft1.returnType;
   let ret2 = $ft2.returnType;
@@ skipping 59 matching lines @@
   // Dart allows void functions to subtype dynamic functions, but not
   // other functions.
   if (ret1 === $_void) return (ret2 === $dynamic);
   if (!$_isSubtype(ret1, ret2, $covariant)) return null;
   return true;
 })()''');
 
 /// TODO(leafp): This duplicates code in operations.dart.
 /// I haven't found a way to factor it out that makes the
 /// code generator happy though.
-_subtypeMemo(f) => JS('', '''(() => {
+_subtypeMemo(f) => JS(
+    '',
+    '''(() => {
   let memo = new Map();
   return (t1, t2) => {
     let map = memo.get(t1);
     let result;
     if (map) {
       result = map.get(t2);
       if (result !== void 0) return result;
     } else {
       memo.set(t1, map = new Map());
     }
     result = $f(t1, t2);
     map.set(t2, result);
     return result;
   };
 })()''');
 
 /// Returns true if [t1] <: [t2].
 /// Returns false if [t1] </: [t2] in both spec and strong mode
 /// Returns undefined if [t1] </: [t2] in strong mode, but spec
 ///  mode may differ
-final isSubtype =
-    JS('', '$_subtypeMemo((t1, t2) => (t1 === t2) || $_isSubtype(t1, t2, true))');
+final isSubtype = JS(
+    '', '$_subtypeMemo((t1, t2) => (t1 === t2) || $_isSubtype(t1, t2, true))');
 
 _isBottom(type) => JS('bool', '# == #', type, bottom);
 
 _isTop(type) => JS('bool', '# == # || # == #', type, Object, type, dynamic);
 
-_isSubtype(t1, t2, covariant) => JS('', '''(() => {
+_isSubtype(t1, t2, covariant) => JS(
+    '',
+    '''(() => {
   if ($t1 === $t2) return true;
 
   // Trivially true.
   if ($_isTop($t2) || $_isBottom($t1)) {
     return true;
   }
 
   // Trivially false.
   if ($_isBottom($t2)) return null;
   if ($_isTop($t1)) {
@@ skipping 13 matching lines @@
   // Function subtyping.
 
   // Handle Objects with call methods.  Those are functions
   // even if they do not *nominally* subtype core.Function.
   t1 = $getImplicitFunctionType(t1);
   if (!t1) return false;
 
   if ($isFunctionType($t1) && $isFunctionType($t2)) {
     return $isFunctionSubtype($t1, $t2, $covariant);
   }
+  
+  if ($t1 instanceof $LazyJSType && $t2 instanceof $LazyJSType) {
+    return $isLazyJSSubtype($t1, $t2, $covariant);
+  }
+  
   return false;
 })()''');
 
-isClassSubType(t1, t2, covariant) => JS('', '''(() => {
+isClassSubType(t1, t2, covariant) => JS(
+    '',
+    '''(() => {
   // We support Dart's covariant generics with the caveat that we do not
   // substitute bottom for dynamic in subtyping rules.
   // I.e., given T1, ..., Tn where at least one Ti != dynamic we disallow:
   // - S !<: S<T1, ..., Tn>
   // - S<dynamic, ..., dynamic> !<: S<T1, ..., Tn>
   if ($t1 == $t2) return true;
 
   if ($t1 == $Object) return false;
 
   // If t1 is a JS Object, we may not hit core.Object.
@@ skipping 60 matching lines @@
   // so the answer is indefinite.
   if (indefinite) return null;
   // We found no definite supertypes and no indefinite supertypes, so we
   // can return false.
   return false;
 })()''');
 
 // TODO(jmesserly): this isn't currently used, but it could be if we want
 // `obj is NonGroundType<T,S>` to be rejected at runtime instead of compile
 // time.
-isGroundType(type) => JS('', '''(() => {
+isGroundType(type) => JS(
+    '',
+    '''(() => {
   // TODO(vsm): Cache this if we start using it at runtime.
 
   if ($type instanceof $AbstractFunctionType) {
     if (!$_isTop($type.returnType)) return false;
     for (let i = 0; i < $type.args.length; ++i) {
       if (!$_isBottom($type.args[i])) return false;
     }
     for (let i = 0; i < $type.optionals.length; ++i) {
       if (!$_isBottom($type.optionals[i])) return false;
     }
     let names = $getOwnPropertyNames($type.named);
     for (let i = 0; i < names.length; ++i) {
       if (!$_isBottom($type.named[names[i]])) return false;
     }
     return true;
   }
 
   let typeArgs = $getGenericArgs($type);
   if (!typeArgs) return true;
   for (let t of typeArgs) {
     if (t != $Object && t != $dynamic) return false;
   }
   return true;
 })()''');