Support lazy JS types.

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/rtti.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 association between runtime objects and
 /// runtime types.
 part of dart._runtime;
 
 /// Runtime type information.  This module defines the mapping from
 /// runtime objects to their runtime type information.  See the types
@@ skipping 40 matching lines @@
 ///
 /// `dart.fn(cls, rType, argsT, extras)` marks cls as having the
 /// runtime type dart.functionType(rType, argsT, extras).
 ///
 /// Note that since we are producing a type for a concrete function,
 /// it is sound to use the definite arrow type.
 ///
 fn(closure, t) {
   if (t == null) {
     // No type arguments, it's all dynamic
-    t = definiteFunctionType(
-        JS('', '#', dynamic),
-        JS('', 'Array(#.length).fill(#)', closure, dynamic),
-        JS('', 'void 0'));
+    t = definiteFunctionType(JS('', '#', dynamic),
+        JS('', 'Array(#.length).fill(#)', closure, dynamic), JS('', 'void 0'));
   }
   tag(closure, t);
   return closure;
 }
 
 lazyFn(closure, computeType) {
   tagLazy(closure, computeType);
   return closure;
 }
 
@@ skipping 79 matching lines @@
 /// that implements the dart:core Type interface.
 wrapType(type) {
   // If we've already wrapped this type once, use the previous wrapper. This
   // way, multiple references to the same type return an identical Type.
   if (JS('bool', '#.hasOwnProperty(#)', type, _typeObject)) {
     return JS('', '#[#]', type, _typeObject);
   }
   return JS('', '#[#] = new #(#)', type, _typeObject, WrappedType, type);
 }
 
+var _lazyJSTypes = JS('', 'new Map()');
+
+lazyJSType(getJSTypeCallback, name) {
+  var key = JS('String', '#.toString()', getJSTypeCallback);
+  if (JS('bool', '#.has(#)', _lazyJSTypes, key)) {
+    return JS('', '#.get(#)', _lazyJSTypes, key);
+  }
+  var ret = JS('', 'new #(#, #)', LazyJSType, getJSTypeCallback, name);
+  JS('', '#.set(#, #)', _lazyJSTypes, key, ret);
+  return ret;
+}
+
+// TODO(jacobr): do not use the same LazyJSType object for anonymous JS types
+// from different libraries.
+lazyAnonymousJSType(name) {
+  if (JS('bool', '#.has(#)', _lazyJSTypes, name)) {
+    return JS('', '#.get(#)', _lazyJSTypes, name);
+  }
+  var ret = JS('', 'new #(null, #)', LazyJSType, name);
+  JS('', '#.set(#, #)', _lazyJSTypes, name, ret);
+  return ret;
+}
+
 /// Given a WrappedType, return the internal runtime type object.
 unwrapType(obj) => obj._wrappedType;
 
 _getRuntimeType(value) => JS('', '#[#]', value, _runtimeType);
 getIsNamedConstructor(value) => JS('', '#[#]', value, isNamedConstructor);
 // TODO(bmilligan): Define the symbol in rtti.dart instead of dart_library.js
 // and get rid of the call to dart_library in the JS here.
 getDartLibraryName(value) => JS('', '#[dart_library.dartLibraryName]', value);
 
 /// Tag the runtime type of [value] to be type [t].
 void tag(value, t) {
   JS('', '#[#] = #', value, _runtimeType, t);
 }
 
 void tagComputed(value, compute) {
   JS('', '#(#, #, { get: # })', defineProperty, value, _runtimeType, compute);
 }
 
 void tagLazy(value, compute) {
-  JS('', '#(#, #, { get: # })',
-      defineLazyProperty, value, _runtimeType, compute);
+  JS('', '#(#, #, { get: # })', defineLazyProperty, value, _runtimeType,
+      compute);
 }