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) {
     let sym = dartx[name];
     if (!sym) dartx[name] = sym = Symbol('dartx.' + name);
     return sym;
   }
 
+  function defineExtensionNames(names) {
+    names.forEach(getExtensionSymbol);
+  }
+  dart.defineExtensionNames = defineExtensionNames;
+
   /**
    * 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);
     }
+    // Ensure the signature is available too.
+    // TODO(jmesserly): not sure if we can do this in a cleaner way. Essentially
+    // we need to copy the signature (and in the future, other data like
+    // annotations) any time we copy a method as part of our metaprogramming.
+    // It might be more friendly to JS metaprogramming if we include this info
+    // on the function.
+    var originalSigFn = getOwnPropertyDescriptor(type, _methodSig).get;
+    defineMemoizedGetter(type, _methodSig, function() {
+      var sig = originalSigFn();
+      for (let name of methodNames) {
+        sig[getExtensionSymbol(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 = {}));