fixes #193, factory constructors as static methods

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;
 (function (dart) {
   'use strict';
 
   // TODO(vsm): This is referenced (as init.globalState) from
   // isolate_helper.dart.  Where should it go?
@@ skipping 133 matching lines @@
     return checkAndCall(f, ftype, obj, args, method);
   }
   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, obj, [index], '[]');
+    return checkAndCall(obj.get, void 0, obj, [index], '[]');
   }
   dart.dindex = dindex;
 
   function dsetindex(obj, index, value) {
-    return checkAndCall(obj.set, obj, [index, value], '[]=');
+    return checkAndCall(obj.set, void 0, obj, [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 733 matching lines @@
    *
    * Otherwise an array should be used, for example `map([1, 2, 3, 4])` will
    * create a map with keys [1, 3] and values [2, 4]. Each key-value pair
    * should be adjacent entries in the array.
    *
    * For a map with no keys the function can be called with no arguments, for
    * example `map()`.
    */
   // TODO(jmesserly): this could be faster
   function map(values) {
-    let map = new collection.LinkedHashMap();
+    let map = collection.LinkedHashMap.new();

[vsm, 2015/05/29 21:08:58]

Hmm, it's too bad the JS user has to now keep track of whether it's a factory or
not as well.  Not sure there's a clean way around it though.  

[Jennifer Messerly, 2015/05/29 21:32:17]

yeah, seems kind of okay because:

* the only way to represent this pattern in JS is with static methods.
* in JS they look like static methods if you go to definition.
* in Dart, they're clearly documented as "factory" and function more like static
methods anyway.

It's not perfect though, agreed.

Here's another option: disallow returning "null" from a factory method, in
essence assert the factory returns a non-nullable type. This would need an extra
runtime check though. Then we'd only need to do this pattern for primitives, to
avoid boxing.

would you prefer that option?

     if (Array.isArray(values)) {
       for (let i = 0, end = values.length - 1; i < end; i += 2) {
         let key = values[i];
         let value = values[i + 1];
         map.set(key, value);
       }
     } else if (typeof values === 'object') {
       for (let key of getOwnPropertyNames(values)) {
         map.set(key, values[key]);
       }
@@ skipping 392 matching lines @@
   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 || (dart = {}));