sort classes in dependency order, or load lazily if needed, fixes #78

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;
 (function (dart) {
+  'use strict';
+
   var defineProperty = Object.defineProperty;
   var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
   var getOwnPropertyNames = Object.getOwnPropertyNames;
 
   // Adapted from Angular.js
   var FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
   var FN_ARG_SPLIT = /,/;
   var FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
   var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
 
@@ skipping 139 matching lines @@
       var value = f();
       lazySetter(value);
       return value;
     }
     desc.get = lazyGetter;
     desc.configurable = true;
     if (writable) desc.set = lazySetter;
     defineProperty(to, name, desc);
   }
 
-  function defineLazyProperties(to, from) {
+  function defineLazy(to, from) {
     var names = getOwnPropertyNames(from);
     for (var i = 0; i < names.length; i++) {
       var name = names[i];
       defineLazyProperty(to, name, getOwnPropertyDescriptor(from, name));
     }
   }
-  dart.defineLazyProperties = defineLazyProperties;
+  // TODO(jmesserly): these are identical, but this makes it easier to grep for.
+  dart.defineLazyClass = defineLazy;
+  dart.defineLazyProperties = defineLazy;
+  dart.defineLazyClassGeneric = defineLazyProperty;
 
   /**
    * Copy properties from source to destination object.
    * This operation is commonly called `mixin` in JS.
    */
   function copyProperties(to, from) {
     var names = getOwnPropertyNames(from);
     for (var i = 0; i < names.length; i++) {
       var name = names[i];
       defineProperty(to, name, getOwnPropertyDescriptor(from, name));
     }
     return to;
   }
   dart.copyProperties = copyProperties;
 
   /**
    * Returns a new type that mixes members from base and all mixins.
    *
    * 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*/) {
-    // Inherit statics from Base to simulate ES6 class inheritance
-    // Conceptually this is: `class Mixin extends base {}`
-    function Mixin() {
-      // TODO(jmesserly): since we're using initializers and not constructors,
-      // we can just skip directly to core.Object.
-      core.Object.apply(this, arguments);
+    // Create an initializer for the mixin, so when derived constructor calls
+    // super, we can correctly initialize base and mixins.
+    var mixins = Array.prototype.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 (var i = mixins.length - 1; i >= 0; i--) {
+          var mixin = mixins[i];
+          mixin.prototype[mixin.name].call(this);
+        }
+        // Run base initializer.
+        base.prototype[base.name].apply(this, arguments);
+      }
     }
-    Mixin.__proto__ = base;
-    Mixin.prototype = Object.create(base.prototype);
-    Mixin.prototype.constructor = Mixin;
-    // Copy each mixin, with later ones overwriting earlier entries.
-    var mixins = Array.prototype.slice.call(arguments, 1);
+    // Copy each mixin's methods, with later ones overwriting earlier entries.
     for (var i = 0; i < mixins.length; i++) {
       copyProperties(Mixin.prototype, mixins[i].prototype);
     }
-    // Create an initializer for the mixin, so when derived constructor calls
-    // super, we can correctly initialize base and mixins.
-    var baseCtor = base.prototype[base.name];
-    Mixin.prototype[base.name] = function() {
-      // Run mixin initializers. They cannot have arguments.
-      // Run them backwards so most-derived mixin is initialized first.
-      for (var i = mixins.length - 1; i >= 0; i--) {
-        var mixin = mixins[i];
-        mixin.prototype[mixin.name].call(this);
-      }
-      // Run base initializer.
-      baseCtor.apply(this, arguments);
-    }
     return Mixin;
   }
   dart.mixin = mixin;
 
   /**
    * Creates a dart:collection LinkedHashMap.
    *
    * For a map with string keys an object literal can be used, for example
    * `map({'hi': 1, 'there': 2})`.
    *
@@ skipping 61 matching lines @@
 
     var resultMap = new Map();
     function makeGenericType(/*...arguments*/) {
       if (arguments.length != length) {
         throw 'requires ' + length + ' type arguments';
       }
 
       var value = resultMap;
       for (var i = 0; i < length; i++) {
         var arg = arguments[i];
-        // TODO(jmesserly): assume `dynamic` here?
-        if (arg === void 0) throw 'undefined is not allowed as a type argument';
+        if (arg === void 0) arg = dart.dynamic;
 
         var map = value;
         value = map.get(arg);
         if (value === void 0) {
           if (i + 1 == length) {
             value = typeConstructor.apply(null, arguments);
             // Save the type constructor and arguments for reflection.
             if (value) {
               var args = Array.prototype.slice.call(arguments);
               value[dart.typeSignature] = [makeGenericType].concat(args);
             }
           } else {
             value = new Map();
           }
           map.set(arg, value);
         }
       }
       return value;
     }
     return makeGenericType;
   }
   dart.generic = generic;
 
-
-  /**
-   * Implements Dart constructor behavior. Because of V8 `super` [constructor
-   * restrictions](https://code.google.com/p/v8/issues/detail?id=3330#c65) we
-   * cannot currently emit actual ES6 constructors with super calls. Instead
-   * we use the same trick as named constructors, and do them as instance
-   * methods that perform initialization.
-   */
-  // TODO(jmesserly): we'll need to rethink this once the ES6 spec and V8
-  // settles. See <https://github.com/dart-lang/dart-dev-compiler/issues/51>.
-  // Performance of this pattern is likely to be bad.
-  core.Object = function Object() {
-    // Get the class name for this instance.
-    var name = this.constructor.name;
-    // Call the default constructor.
-    var init = this[name];
-    var result = void 0;
-    if (init) result = init.apply(this, arguments);
-    return result === void 0 ? this : result;
-  };
-  // The initializer for Object
-  core.Object.prototype.Object = function() {};
-  core.Object.prototype.constructor = core.Object;
+  // TODO(jmesserly): this is just a placeholder.
+  dart.dynamic = Object.create(null);
 
 })(dart || (dart = {}));