Registration-based approach to cross frame support.

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.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 operations that define and manipulate Dart
 /// classes.  Included in this are:
 ///   - Generics
 ///   - Class metadata
 ///   - Extension methods
 ///
@@ skipping 392 matching lines @@
   }
   return sym;
 }
 
 defineExtensionNames(names) =>
     JS('', '#.forEach(#)', names, getExtensionSymbol);
 
 /// Install properties in prototype-first order.  Properties / descriptors from
 /// more specific types should overwrite ones from less specific types.
 void _installProperties(jsProto, dartType, installedParent) {
-  if (JS('bool', '# === #', dartType, Object)) {
+  // Extension types should bottom out at core.Object.  The one exception
+  // is JSArray, which we rewire to the native Array type.

[Jennifer Messerly, 2017/07/14 19:38:08]

hmmm wait I don't understand the JSArray comment. JSArray also bottoms out at
core.Object. I fixed that in my CL. Maybe try reverting this change? it should
be a no-op now.

That's why we walk up the class hierarchy:
* start from the ES6 class for JSArray
* walk up its __proto__
* that takes you to the ES6 class for core.Object

... the problem that happened before is:
* start from the ES6 class JSArray
* get `JSArray.prototype`
* walk up its __proto__
* that takes you to JavaScript's `Array.prototype`
* walk up its __proto__
* that takes you to JavaScript's `Object.prototype`

... anyways, if revert doesn't work, LMK, I can try and debug what's going on?

+  if (JS('bool', '# === # || # === #.Object', dartType, Object, dartType,
+      global_)) {
     _installPropertiesForObject(jsProto);
     return;
   }
   // If the extension methods of the parent have been installed on the parent
   // of [jsProto], the methods will be available via prototype inheritance.
   var dartSupertype = JS('', '#.__proto__', dartType);
   if (JS('bool', '# !== #', dartSupertype, installedParent)) {
     _installProperties(jsProto, dartSupertype, installedParent);
   }
 
   var dartProto = JS('', '#.prototype', dartType);
   copyTheseProperties(jsProto, dartProto, getOwnPropertySymbols(dartProto));
 }
 
 void _installPropertiesForObject(jsProto) {
   // core.Object members need to be copied from the non-symbol name to the
   // symbol name.
   var coreObjProto = JS('', '#.prototype', Object);
   var names = getOwnPropertyNames(coreObjProto);
   for (int i = 0; i < JS('int', '#.length', names); ++i) {
     var name = JS('', '#[#]', names, i);
     var desc = getOwnPropertyDescriptor(coreObjProto, name);
     defineProperty(jsProto, getExtensionSymbol(name), desc);
   }
 }
 
-/// Copy symbols from the prototype of the source to destination.
-/// These are the only properties safe to copy onto an existing public
-/// JavaScript class.
-registerExtension(jsType, dartExtType) => JS(
+var _extensionMap;

[Jennifer Messerly, 2017/07/14 19:38:08]

this can be eager initialized:

    final _extensionMap = JS('', 'new Map()');

we'll always have extension types, Dart can't run without
numbers/strings/bools/arrays/etc :)

[vsm, 2017/07/19 15:59:02]

Done.

+
+_cacheExtension(name, dartExtType) {
+  if (_extensionMap == null) _extensionMap = JS('', 'new Map()');
+  JS('', '#.set(#, #)', _extensionMap, name, dartExtType);
+}
+
+_applyExtension(jsType, dartExtType) => JS(
     '',
     '''(() => {
   // TODO(vsm): Not all registered js types are real.
   if (!jsType) return;
 
+  let extProto = $dartExtType.prototype;

[Jennifer Messerly, 2017/07/14 19:38:08]

this line is unused. I'm guessing it was a merge conflict with my change that
fixed JSArray

[vsm, 2017/07/19 15:59:02]

Done.

   let jsProto = $jsType.prototype;
 
   // TODO(vsm): This sometimes doesn't exist on FF.  These types will be
   // broken.
   if (!jsProto) return;
 
   $_installProperties(jsProto, $dartExtType, jsProto[$_extensionType]);
 
   // Mark the JS type's instances so we can easily check for extensions.
   jsProto[$_extensionType] = $dartExtType;
 
   function updateSig(sigF) {
     let originalDesc = $getOwnPropertyDescriptor($dartExtType, sigF);
     if (originalDesc === void 0) return;
     let originalSigFn = originalDesc.get;
     $assert_(originalSigFn);
-    $defineMemoizedGetter($jsType, sigF, originalSigFn);
+    $defineMemoizedGetter(jsType, sigF, originalSigFn);
   }
   updateSig($_methodSig);
   updateSig($_fieldSig);
   updateSig($_getterSig);
   updateSig($_setterSig);
 })()''');
 
+/// Apply all registered extensions to a window.  This is intended for
+/// different frames, where registrations need to be reapplied.
+applyAllExtensions(global) {
+  JS('', '#.forEach((dartExtType, name) => #(#[name], dartExtType))',
+      _extensionMap, _applyExtension, global);
+}
+
+/// Copy symbols from the prototype of the source to destination.
+/// These are the only properties safe to copy onto an existing public
+/// JavaScript class.
+registerExtension(name, dartExtType) {
+  _cacheExtension(name, dartExtType);

[Jennifer Messerly, 2017/07/14 19:38:08]

based on suggestion above this is a 1-liner now and can be inlined:

    registerExtension(name, dartExtType) {
      JS('', '#.set(#, #)', _extensionMap, name, dartExtType);
      ...

[vsm, 2017/07/19 15:59:01]

Done.

+  var jsType = JS('', '#[#]', global_, name);
+  _applyExtension(jsType, dartExtType);
+}
+
 ///
 /// Mark a concrete type as implementing extension methods.
 /// For example: `class MyIter implements Iterable`.
 ///
 /// This takes a list of names, which are the extension methods implemented.
 /// It will add a forwarder, so the extension method name redirects to the
 /// normal Dart method name. For example:
 ///
 ///     defineExtensionMembers(MyType, ['add', 'remove']);
 ///
@@ skipping 69 matching lines @@
 
 defineEnumValues(enumClass, names) {
   var values = [];
   for (var i = 0; i < JS('int', '#.length', names); i++) {
     var value = const_(JS('', 'new #.new(#)', enumClass, i));
     JS('', '#.push(#)', values, value);
     defineValue(enumClass, JS('', '#[#]', names, i), value);
   }
   JS('', '#.values = #', enumClass, constList(values, enumClass));
 }