Support for dart:typed_data

tool/input_sdk/private/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 241 matching lines @@
   let initMethod = proto[$name];
   let ctor = function() { return initMethod.apply(this, arguments); };
   ctor.prototype = proto;
   // Use defineProperty so we don't hit a property defined on Function,
   // like `caller` and `arguments`.
   $defineProperty($clazz, $name, { value: ctor, configurable: true });
 })()''');
 
 final _extensionType = JS('', 'Symbol("extensionType")');
 
+getExtensionType(obj) => JS('', '$obj[$_extensionType]');
+
 final dartx = JS('', '{}');
 
 getExtensionSymbol(name) => JS('', '''(() => {
   let sym = $dartx[$name];
   if (!sym) $dartx[$name] = sym = Symbol('dartx.' + $name);
   return sym;
 })()''');
 
 defineExtensionNames(names) => JS('', '$names.forEach($getExtensionSymbol)');
 
+// Install properties in prototype order.  Properties / descriptors from
+// more specific types should overwrite ones from less specific types.
+_installProperties(jsProto, extProto) => JS('', '''(() => {
+  if (extProto !== $Object.prototype && extProto !== jsProto) {
+    $_installProperties(jsProto, extProto.__proto__);
+  }
+  $copyTheseProperties(jsProto, extProto, $getOwnPropertySymbols(extProto));
+})()''');
+
 ///
 /// 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('', '''(() => {
   let extProto = $dartExtType.prototype;
   let jsProto = $jsType.prototype;
 
   // Mark the JS type's instances so we can easily check for extensions.
   $assert_(jsProto[$_extensionType] === void 0);
-  jsProto[$_extensionType] = extProto;
-
-  let dartObjProto = $Object.prototype;
-  while (extProto !== dartObjProto && extProto !== jsProto) {
-    $copyTheseProperties(jsProto, extProto, $getOwnPropertySymbols(extProto));
-    extProto = extProto.__proto__;
-  }
+  jsProto[$_extensionType] = $dartExtType;
+  $_installProperties(jsProto, extProto);
   let originalSigFn = $getOwnPropertyDescriptor($dartExtType, $_methodSig).get;
   $assert_(originalSigFn);
   $defineMemoizedGetter($jsType, $_methodSig, originalSigFn);
 })()''');
 
 ///
 /// 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.
@@ skipping 38 matching lines @@
   // Check for certain names that we can't use in JS
   if ($name == 'constructor' || $name == 'prototype') {
     $name = '+' + $name;
   }
   return $name;
 })()''');
 
 /// Sets the type of `obj` to be `type`
 setType(obj, type) => JS('', '''(() => {
   $obj.__proto__ = $type.prototype;
+  // TODO(vsm): This should be set in registerExtension, but that is only
+  // invoked on the generic type (e.g., JSArray<dynamic>, not JSArray<int>).

[Jennifer Messerly, 2016/02/10 00:20:30]

Given a generic type T, it's possible to get its raw type R, then from that you
can get its extension type. This is all handled by dart.generic

So it shouldn't be necessary to put this here. We can already find the type for
List<int> and such, AFAIK. I'll add some code that should work on the other end.

[vsm, 2016/02/11 22:36:06]

I need this to go the other way around - i.e., to map the raw object back to the
generic type.

[Jennifer Messerly, 2016/02/11 23:04:57]

I'm 99% sure this should not be needed. In JavaScript:

    obj.__proto__.contstructor == type

so you don't need the _extensionType field. That's what I'm saying.
 

+  $obj.__proto__[$_extensionType] = type;

[Jennifer Messerly, 2016/02/10 00:20:30]

(possibly moot based on above comment)

I think this should be $type in the quasiquote scheme. (Whether this makes any
difference, I'm not sure. We really need to change the way the SDK libs are
written... it's kind of in an awkward place now)

[vsm, 2016/02/11 22:36:06]

Done.

   return $obj;
 })()''');
 
 /// Sets the element type of a list literal.
 list(obj, elementType) =>
     JS('', '$setType($obj, ${getGenericClass(JSArray)}($elementType))');
 
 setBaseClass(derived, base) => JS('', '''(() => {
   // Link the extension to the type it's extending as a base class.
   $derived.prototype.__proto__ = $base.prototype;
 })()''');