fixes browser/runtime_test, and a few extension member fixes

lib/runtime/dart_runtime.js

 // 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.
 
 var dart, _js_helper, _js_primitives, dartx;
 (function (dart) {
   'use strict';
 
   // TODO(vsm): This is referenced (as init.globalState) from
   // isolate_helper.dart.  Where should it go?
   // See: https://github.com/dart-lang/dev_compiler/issues/164
   dart.globalState = null;
 
   const defineProperty = Object.defineProperty;
   const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
   const getOwnPropertyNames = Object.getOwnPropertyNames;
   const getOwnPropertySymbols = Object.getOwnPropertySymbols;
   const hasOwnProperty = Object.prototype.hasOwnProperty;
   const slice = [].slice;
 
+  let _constructorSig = Symbol('sigCtor');
+  let _methodSig = Symbol("sig");
+  let _staticSig = Symbol("sigStatic");
+
   function getOwnNamesAndSymbols(obj) {
     return getOwnPropertyNames(obj).concat(getOwnPropertySymbols(obj));
   }
 
   function dload(obj, field) {
     field = _canonicalFieldName(obj, field, [], field);
     if (_getMethodType(obj, field) !== void 0) {
       return dart.bind(obj, field);
     }
     // TODO(vsm): Implement NSM robustly.  An 'in' check breaks on certain
@@ skipping 716 matching lines @@
   dart.defineLazyClassGeneric = defineLazyProperty;
 
   function defineMemoizedGetter(obj, name, get) {
     let cache = null;
     function getter() {
       if (cache != null) return cache;
       cache = get();
       get = null;
       return cache;
     }
-    defineProperty(obj, name, {get : getter});
+    defineProperty(obj, name, {get: getter, configurable: true});
   }
 
   function copyPropertiesHelper(to, from, names) {
     for (let name of names) {
       defineProperty(to, name, getOwnPropertyDescriptor(from, name));
     }
     return to;
   }
 
   /**
    * Copy properties from source to destination object.
    * This operation is commonly called `mixin` in JS.
    */
   function copyProperties(to, from) {
     return copyPropertiesHelper(to, from, getOwnNamesAndSymbols(from));
   }
   dart.copyProperties = copyProperties;
 
-  function getExtensionSymbol(name) {
+  function extensionMember(name) {
     let sym = dartx[name];
     if (!sym) dartx[name] = sym = Symbol('dartx.' + name);
     return sym;
   }
+  dart.extensionMember = extensionMember;
 
   /**
    * Copy symbols from the prototype of the source to destination.
    * These are the only properties safe to copy onto an existing public
    * JavaScript class.
    */
   function registerExtension(jsType, dartExtType) {
     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;
-    for (let name of getOwnPropertyNames(extProto)) {
-      let symbol = getExtensionSymbol(name);
-      defineProperty(jsProto, symbol, getOwnPropertyDescriptor(extProto, name));
-    }
+    copyPropertiesHelper(jsProto, extProto, getOwnPropertySymbols(extProto));
   }
   dart.registerExtension = registerExtension;
 
   /**
    * 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']);
    *
    * Results in:
    *
    *     MyType.prototype[dartx.add] = MyType.prototype.add;
    *     MyType.prototype[dartx.remove] = MyType.prototype.remove;
    */
   // TODO(jmesserly): essentially this gives two names to the same method.
   // This benefit is roughly equivalent call performance either way, but the
-  // cost is we need to call implementExtension any time a subclass overrides
+  // cost is we need to call defineExtensionMEmbers any time a subclass overrides
   // one of these methods.
   function defineExtensionMembers(type, methodNames) {
     let proto = type.prototype;
     for (let name of methodNames) {
       let method = getOwnPropertyDescriptor(proto, name);
-      defineProperty(proto, getExtensionSymbol(name), method);
+      defineProperty(proto, extensionMember(name), method);
     }
+    // Ensure the signature is available too.

[Leaf, 2015/06/05 20:42:23]

We could attach something to each method, but it seems a bit wasteful to have
one field for each method instead of one per class, given that tear-offs are
relatively uncommon.  An alternative would be to go ahead and eagerly put the
extension names in the original signature, so you don't have to add them in
here.

[Jennifer Messerly, 2015/06/05 21:08:57]

yeah, not sure in what sense it's wasteful, though? it's (conceptually) the same
amount of data stored either way right?

    { add: fn0, remove: fn1, ... } + { add: sig0, remove: sig1 }
    vs { add: fn0_w_sig, remove: fn1_w_sig, ... }

instead of having two maps, one for the methods and one for the signatures,
we're just folding them together

[Jennifer Messerly, 2015/06/05 21:10:34]

also, wouldn't hypothetical Typed-ES likely work this way, by storing the type
signature and annotations on the method object?

[Leaf, 2015/06/05 21:34:44]

It's no big deal really.  As it stands, we have a single field on the class,
which points to a closure, which if it ever gets called will produce a map with
N entries (N is number of methods).  If we attach it to methods, then each of
the N methods has a field which points to a closure, which if it ever gets
called will produce the type, which can then get cached, and will be copied onto
the torn off/bound function.  So in the assumed common case that nothing gets
torn off (or dynamically called), it's one field vs N, but in the tear off case
you're right, it's the same.  And since we need to look at the signature for
dynamic calls/puts/reflection and other checks, it may not be as uncommon as I'm
thinking? So yeah, not worth worrying about.

I don't know how ES6 will implement it - if you implement it natively you have a
lot more freedom.  My 30 second stab at a design would be to put it on the class
and have a pointer back to the class from the vtable/gc header, but there are
lots of other options, and probably lots of constraints I don't know about... :)

+    // TODO(jmesserly): can we make this cleaner? Ideally signatures would be
+    // associated with the methods, so copying the methods above would
+    // automatically copy the type signature too.
+    var originalSigFn = getOwnPropertyDescriptor(type, _methodSig).get;
+    defineMemoizedGetter(type, _methodSig, function() {
+      var sig = originalSigFn();
+      for (let name of methodNames) {
+        sig[extensionMember(name)] = sig[name];
+      }
+      return sig;
+    });
   }
   dart.defineExtensionMembers = defineExtensionMembers;
 
   function setBaseClass(derived, base) {
     // Link the extension to the type it's extending as a base class.
     derived.prototype.__proto__ = base.prototype;
   }
   dart.setBaseClass = setBaseClass;
 
   /**
@@ skipping 53 matching lines @@
       }
     }
     // Copy each mixin's methods, with later ones overwriting earlier entries.
     for (let m of mixins) {
       copyProperties(Mixin.prototype, m.prototype);
     }
 
     // Set the signature of the Mixin class to be the composition
     // of the signatures of the mixins.
     dart.setSignature(Mixin, {
-      methods : () => {
+      methods: () => {
         let s = {};
         for (let m of mixins) {
           copyProperties(s, m[_methodSig]);
         }
         return s;
       }
     });
 
     // Save mixins for reflection
     Mixin[dart.mixins] = mixins;
@@ skipping 103 matching lines @@
           }
           map.set(arg, value);
         }
       }
       return value;
     }
     return makeGenericType;
   }
   dart.generic = generic;
 
-  let _constructorSig = Symbol('sigCtor');
-  let _methodSig = Symbol("sig");
-  let _staticSig = Symbol("sigStatic");
-
   /// Get the type of a function using the store runtime type
   function _getFunctionType(f) {
     return f[_runtimeType];
   }
 
   /// Get the type of a method using the stored signature
   function _getMethodType(obj, name) {
     if (obj === void 0) return void 0;
     if (obj == null) return void 0;
     let sigObj = obj.__proto__.constructor[_methodSig];
@@ skipping 273 matching lines @@
   // TODO(vsm): DOM facades?
   // See: https://github.com/dart-lang/dev_compiler/issues/173
   NodeList.prototype.get = function(i) { return this[i]; };
   NamedNodeMap.prototype.get = function(i) { return this[i]; };
   DOMTokenList.prototype.get = function(i) { return this[i]; };
 
   /** Dart extension members. */
   dartx = dartx || {};
 
 })(dart || (dart = {}));