fixes #40, extension methods for primitive types

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;
+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;
 
-  let defineProperty = Object.defineProperty;
-  let getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
-  let getOwnPropertyNames = Object.getOwnPropertyNames;
-  let getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  const defineProperty = Object.defineProperty;
+  const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+  const getOwnPropertyNames = Object.getOwnPropertyNames;
+  const getOwnPropertySymbols = Object.getOwnPropertySymbols;
+  const hasOwnProperty = Object.prototype.hasOwnProperty;
+  const slice = [].slice;
 
   function getOwnNamesAndSymbols(obj) {
     return getOwnPropertyNames(obj).concat(getOwnPropertySymbols(obj));
   }
 
   function dload(obj, field) {
-    field = _canonicalFieldName(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
     // types.  hasOwnProperty doesn't chase the proto chain.
     // Also, do we want an NSM on regular JS objects?
     // See: https://github.com/dart-lang/dev_compiler/issues/169
     var result = obj[field];
 
-    // TODO(leafp): Decide whether to keep this for javascript
-    // objects, or just use the javascript semantics.
-    if (typeof result == "function" &&
-        !Object.prototype.hasOwnProperty.call(obj, field)) {
+    // TODO(vsm): Check this more robustly.
+    if (typeof result == "function" && !hasOwnProperty.call(obj, field)) {
       // This appears to be a method tearoff.  Bind this.
       return result.bind(obj);
     }
     return result;
   }
   dart.dload = dload;
 
   function dput(obj, field, value) {
-    field = _canonicalFieldName(obj, field);
+    field = _canonicalFieldName(obj, field, [value], field);
     // TODO(vsm): Implement NSM and type checks.
     // See: https://github.com/dart-lang/dev_compiler/issues/170
     obj[field] = value;
   }
   dart.dput = dput;
 
   // TODO(jmesserly): this should call noSuchMethod, not throw.
   function throwNoSuchMethod(obj, name, args, opt_func) {
     if (obj === void 0) obj = opt_func;
     throw new core.NoSuchMethodError(obj, name, args);
@@ skipping 27 matching lines @@
     if (ftype.checkApply(args)) {
       return f.apply(obj, args);
     }
 
     // TODO(leafp): throw a type error (rather than NSM)
     // if the arity matches but the types are wrong.
     throwNoSuchMethod(obj, name, args, f);
   }
 
   function dcall(f/*, ...args*/) {
-    let args = Array.prototype.slice.call(arguments, 1);
+    let args = slice.call(arguments, 1);
     let ftype = _getFunctionType(f);
     return checkAndCall(f, ftype, void 0, args, 'call');
   }
   dart.dcall = dcall;
 
-  // TODO(vsm): Automatically build this.
-  // All dynamic methods should check for these.
-  // See: https://github.com/dart-lang/dev_compiler/issues/142
-  var _extensionMethods = {
-    // Lazy - as these symbols may not be loaded yet.
-    // TODO(vsm): This should record / check the receiver type
-    // as well.  E.g., only look for core.$map if the receiver
-    // is an Iterable.
-    'map': () => core.$map
-  };
-
-  // TODO(leafp): Integrate this with the eventual proper extension
-  // method system.
-  function _canonicalFieldName(obj, name) {
-    if (obj[name] === void 0) return _extensionMethods[name]();
+  let _extensionType = Symbol('extensionType');
+  function _canonicalFieldName(obj, name, args, displayName) {
+    if (obj[_extensionType]) {
+      var extension = dartx[name];
+      if (extension) return extension;
+      // TODO(jmesserly): in the future we might have types that "overlay" Dart
+      // methods while also exposing the full native API, e.g. dart:html vs
+      // dart:dom. To support that we'd need to fall back to the normal name
+      // if an extension method wasn't found.
+      throwNoSuchMethod(obj, displayName, args);
+    }
     return name;
   }
 
+  /** Shared code for dsend, dindex, and dsetindex. */
+  function callMethod(obj, name, args, displayName) {
+    let symbol = _canonicalFieldName(obj, name, args, displayName);
+    let f = obj[symbol];
+    let ftype = _getMethodType(obj, name);
+    return checkAndCall(f, ftype, obj, args, displayName);
+  }
+
   function dsend(obj, method/*, ...args*/) {
-    let args = Array.prototype.slice.call(arguments, 2);
-    let symbol = _canonicalFieldName(obj, method);
-    let f = obj[symbol];
-    let ftype = _getMethodType(obj, symbol);
-    return checkAndCall(f, ftype, obj, args, method);
+    return callMethod(obj, method, slice.call(arguments, 2));
   }
   dart.dsend = dsend;
 
   function dindex(obj, index) {
-    // TODO(jmesserly): remove this special case once Array extensions are
-    // hooked up.
-    if (obj instanceof Array && realRuntimeType(index) == core.int) {
-      return obj[index];
-    }
-    return checkAndCall(obj.get, void 0, obj, [index], '[]');
+    return callMethod(obj, 'get', [index], '[]');
   }
   dart.dindex = dindex;
 
   function dsetindex(obj, index, value) {
-    return checkAndCall(obj.set, void 0, obj, [index, value], '[]=');
+    return callMethod(obj, 'set', [index, value], '[]=');
   }
   dart.dsetindex = dsetindex;
 
   function typeToString(type) {
     if (typeof(type) == "function") {
       var name = type.name;
       var args = type[dart.typeArguments];
       if (args) {
         name += '<';
         for (var i = 0; i < args.length; ++i) {
@@ skipping 22 matching lines @@
       console.log('Warning: ignoring cast fail from ' + typeToString(actual) + ' to ' + typeToString(type));
       return obj;
     }
     // console.log('Error: cast fail from ' + typeToString(actual) + ' to ' + typeToString(type));
     throw new _js_helper.CastErrorImplementation(actual, type);
   }
   dart.as = cast;
 
 
   // TODO(vsm): How should we encode the runtime type?
-  let _runtimeType = Symbol('_runtimeType');
+  const _runtimeType = Symbol('_runtimeType');
 
   function checkPrimitiveType(obj) {
     switch (typeof obj) {
       case "undefined":
         return core.Null;
       case "number":
         return Math.floor(obj) == obj ? core.int : core.double;
       case "boolean":
         return core.bool;
       case "string":
@@ skipping 48 matching lines @@
     if (t === Array) return core.List;
 
     // We shouldn't normally get here with these types, unless something strange
     // happens like subclassing Number in JS and passing it to Dart.
     if (t === String) return core.String;
     if (t === Number) return core.double;
     if (t === Boolean) return core.bool;
     return t;
   }
 
-  let subtypeMap = new Map();
+  const subtypeMap = new Map();
   function isSubtype(t1, t2) {
     // See if we already know the answer
     // TODO(jmesserly): general purpose memoize function?
     let map = subtypeMap.get(t1);
     let result;
     if (map) {
       result = map.get(t2);
       if (result !== void 0) return result;
     } else {
       subtypeMap.set(t1, map = new Map());
@@ skipping 293 matching lines @@
       let build = () => {
         let args = Array.apply(null, new Array(len)).map(() => core.Object);
         return functionType(core.Object, args);
       };
       // We could be called before Object is defined.
       if (core.Object === void 0) return fn(closure, build);
       t = build();
     } else {
       // We're passed the piecewise components of the function type,
       // construct it.
-      let args = Array.prototype.slice.call(arguments, 1);
+      let args = slice.call(arguments, 1);
       t = functionType.apply(null, args);
     }
     setRuntimeType(closure, t);
     return closure;
   }
   dart.fn = fn;
 
   function functionType(returnType, args, extra) {
     // TODO(vsm): Cache / memomize?
     var optionals;
@@ skipping 196 matching lines @@
 
   /**
    * 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;
+  }
+
   /**
    * 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(to, from) {
-    return copyPropertiesHelper(to.prototype, from.prototype,
-        getOwnPropertySymbols(from.prototype));
+  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));
+    }
   }
   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
+  // one of these methods.

[vsm, 2015/06/04 21:50:02]

I see.  So, the virtual dispatch is happening on foo[dartx.add] rather than on
foo.add? 

[Jennifer Messerly, 2015/06/04 21:57:46]

exactly. If we wanted to do it the other way, we'd add a stub like:

MyType.prototype[dartx.add] = function() { return this.add.apply(this,
arguments); }

in practice it'd be `this[name].apply(this, arguments);` and the stub function
closes over the name.

Overall it's worse, IMO. Maybe this should just be a comment instead of a TODO

+  function defineExtensionMembers(type, methodNames) {
+    let proto = type.prototype;
+    for (let name of methodNames) {
+      let method = getOwnPropertyDescriptor(proto, name);
+      defineProperty(proto, getExtensionSymbol(name), method);
+    }
+  }
+  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;
 
   /**
    * This is called whenever a derived class needs to introduce a new field,
    * shadowing a field or getter/setter pair on its parent.
    *
@@ skipping 24 matching lines @@
    *
    * Each mixin applies in sequence, with further to the right ones overriding
    * previous entries.
    *
    * For each mixin, we only take its own properties, not anything from its
    * superclass (prototype).
    */
   function mixin(base/*, ...mixins*/) {
     // Create an initializer for the mixin, so when derived constructor calls
     // super, we can correctly initialize base and mixins.
-    let mixins = Array.prototype.slice.call(arguments, 1);
+    let mixins = slice.call(arguments, 1);
 
     // Create a class that will hold all of the mixin methods.
     class Mixin extends base {
       // Initializer method: run mixin initializers, then the base.
       [base.name](/*...args*/) {
         // Run mixin initializers. They cannot have arguments.
         // Run them backwards so most-derived mixin is initialized first.
         for (let i = mixins.length - 1; i >= 0; i--) {
           let mixin = mixins[i];
           let init = mixin.prototype[mixin.name];
@@ skipping 67 matching lines @@
   function throw_(obj) { throw obj; }
   dart.throw_ = throw_;
 
   /**
    * Given a class and an initializer method name, creates a constructor
    * function with the same name. For example `new SomeClass.name(args)`.
    */
   function defineNamedConstructor(clazz, name) {
     let proto = clazz.prototype;
     let initMethod = proto[name];
-    let ctor = function() { return initMethod.apply(this, arguments); }
+    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 });
   }
   dart.defineNamedConstructor = defineNamedConstructor;
 
   function stackTrace(exception) {
     return _js_helper.getTraceFromException(exception);
   }
   dart.stackTrace = stackTrace;
 
   /** The Symbol for storing type arguments on a specialized generic type. */
   dart.typeArguments = Symbol('typeArguments');
   dart.originalDeclaration = Symbol('originalDeclaration');
 
   /** Memoize a generic type constructor function. */
   function generic(typeConstructor) {
     let length = typeConstructor.length;
     if (length < 1) throw Error('must have at least one generic type argument');
 
     let resultMap = new Map();
     function makeGenericType(/*...arguments*/) {
       if (arguments.length != length && arguments.length != 0) {
         throw Error('requires ' + length + ' or 0 type arguments');
       }
-      let args = Array.prototype.slice.call(arguments);
+      let args = slice.call(arguments);
       // TODO(leafp): This should really be core.Object for
       // consistency, but Object is not attached to core
       // until the entire core library has been processed,
       // which is too late.
       while (args.length < length) args.push(dart.dynamic);
 
       let value = resultMap;
       for (let i = 0; i < length; i++) {
         let arg = args[i];
         if (arg == null) {
@@ skipping 147 matching lines @@
       }
       map = value;
     }
     if (map.has(_value)) return map.get(_value);
     let value = valueFn();
     map.set(_value, value);
     return value;
   }
 
   /** The global constant table. */
-  let constants = new Map();
+  const constants = new Map();
 
   /**
    * Canonicalize a constant object.
    *
    * Preconditions:
    * - `obj` is an objects or array, not a primitive.
    * - nested values of the object are themselves already canonicalized.
    */
   function constant(obj) {
     let objectKey = [realRuntimeType(obj)];
-    // There's no guarantee in JS that names/symbols are returned in the same
-    // order. We could probably get the same order if we're judicious about
-    // initializing them, but easier to not depend on that.
+    // TODO(jmesserly): there's no guarantee in JS that names/symbols are
+    // returned in the same order.
+    //
+    // We could probably get the same order if we're judicious about
+    // initializing fields in a consistent order across all const constructors.
+    // Alternatively we need a way to sort them to make consistent.
+    //
+    // Right now we use the (name,value) pairs in sequence, which prevents
+    // an object with incorrect field values being returned, but won't
+    // canonicalize correctly if key order is different.
     for (let name of getOwnNamesAndSymbols(obj)) {
-      // TODO(jmesserly): we can make this faster if needed.
       objectKey.push(name);
       objectKey.push(obj[name]);
     }
     return multiKeyPutIfAbsent(constants, objectKey, () => obj);
   }
   dart.const = constant;
 
   // TODO(vsm): Rationalize these type methods.  We're currently using the
   // setType / proto scheme for nominal types (e.g., classes) and the
   // setRuntimeType / field scheme for structural types (e.g., functions
   // - and only in tests for now).
   // See: https://github.com/dart-lang/dev_compiler/issues/172
 
   /** Sets the type of `obj` to be `type` */
   function setType(obj, type) {
     obj.__proto__ = type.prototype;
     return obj;
   }
   dart.setType = setType;
 
+  /** Sets the element type of a list literal. */
+  function list(obj, elementType) {
+    return setType(obj, _interceptors.JSArray$(elementType));
+  }
+  dart.list = list;
+
   /** Sets the internal runtime type of `obj` to be `type` */
   function setRuntimeType(obj, type) {
     obj[_runtimeType] = type;
   }
   dart.setRuntimeType = setRuntimeType;
 
   // The following are helpers for Object methods when the receiver
   // may be null or primitive.  These should only be generated by
   // the compiler.
   function hashCode(obj) {
@@ skipping 86 matching lines @@
   }
   dart.defineLibrary = defineLibrary;
 
   // TODO(jmesserly): hack to bootstrap the SDK
   _js_helper = _js_helper || {};
   _js_helper.checkNum = notNull;
 
   _js_primitives = _js_primitives || {};
   _js_primitives.printString = (s) => console.log(s);
 
-  // TODO(vsm): Plumb this correctly.
-  // See: https://github.com/dart-lang/dev_compiler/issues/40
-  String.prototype.contains = function(sub) { return this.indexOf(sub) >= 0; }
-  let _split = String.prototype.split;
-  String.prototype.split = function() {
-    let result = _split.apply(this, arguments);
-    dart.setType(result, core.List$(core.String));
-    return result;
-  };
-  String.prototype.get = function(i) {
-    return this[i];
-  };
-  String.prototype.codeUnitAt = function(i) {
-    return this.charCodeAt(i);
-  };
-  String.prototype.replaceAllMapped =  function(from, cb) {
-    return this.replace(from.multiple, function() {
-      // Remove offset & string from the result array
-      var matches = arguments;
-      matches.splice(-2, 2);
-      // The callback receives match, p1, ..., pn
-      return cb(matches);
-    });
-  };
-  String.prototype['+'] = function(arg) { return this.valueOf() + arg; };
-
-  Boolean.prototype['!'] = function() { return !this.valueOf(); };
-  Boolean.prototype['&&'] = function(arg) { return this.valueOf() && arg; };
-  Boolean.prototype['||'] = function(arg) { return this.valueOf() || arg; };
-  Number.prototype['<'] = function(arg) { return this.valueOf() < arg; };
-  Number.prototype['<='] = function(arg) { return this.valueOf() <= arg; };
-  Number.prototype['>'] = function(arg) { return this.valueOf() > arg; };
-  Number.prototype['+'] = function(arg) { return this.valueOf() + arg; };
-
   // 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 = {}));