new system.register implementation

Author: guybedford

lib/loader.js

@@ -471,7 +471,7 @@ function logloads(loads) {
       /***/
       if (linkSet.loader.loaderObj.execute === false) {
         var loads = [].concat(linkSet.loads);
-        for (var i = 0; i < loads.length; i++) {
+        for (var i = 0, l = loads.length; i < l; i++) {
           var load = loads[i];
           load.module = load.kind == 'dynamic' ? {
             module: _newModule({})
@@ -575,7 +575,7 @@ function logloads(loads) {
       // now add it to the group to indicate its been seen
       groups[load.groupIndex].push(load);
 
-      for (var i = 0; i < loads.length; i++) {
+      for (var i = 0, l = loads.length; i < l; i++) {
         var loadDep = loads[i];
 
         // dependencies not found are already linked
@@ -661,77 +661,80 @@ function logloads(loads) {
       }
     }
 
+
+    // custom module records for binding graph
+    // store linking module records in a separate table
+    var moduleRecords = {};
+    function getOrCreateModuleRecord(name) {
+      return moduleRecords[name] || (moduleRecords[name] = {
+        name: name,
+        dependencies: [],
+        module: new Module(), // start from an empty module and extend
+        importers: [],
+        evaluated: false
+      });
+    }
+
     // custom declarative linking function
     function linkDeclarativeModule(load, loads, loader) {
       if (load.module)
         return;
 
-      // declare the module with an empty depMap
-      var depMap = [];
-
-      var registryEntry = load.declare.call(__global, depMap);
-
-      var moduleDependencies = [];
-
-      // module is just a plain object, until we evaluate it
-      var module = registryEntry.exports;
-
-      console.assert(!load.module, 'Load module already declared!');
+      var module = load.module = getOrCreateModuleRecord(load.name);
+      var moduleObj = load.module.module;
+
+      var registryEntry = load.declare.call(__global, function(name, value) {
+        // NB This should be an Object.defineProperty, but that is very slow.
+        //    By disaling this module write-protection we gain performance.
+        //    It could be useful to allow an option to enable or disable this.
+        moduleObj[name] = value;
+
+        for (var i = 0, l = module.importers.length; i < l; i++) {
+          var importerModule = module.importers[i];
+          if (importerModule.setters) {
+            var importerIndex = importerModule.dependencies.indexOf(module);
+            if (importerIndex != -1) {
+              var setter = importerModule.setters[importerIndex];
+              setter(moduleObj);
+            }
+          }
+        }
+        return value;
+      });
 
-      load.module = {
-        name: load.name,
-        dependencies: moduleDependencies,
-        execute: registryEntry.execute,
-        exports: module,
-        evaluated: false
-      };
+      // setup our setters and execution function
+      load.module.setters = registryEntry.setters;
+      load.module.execute = registryEntry.execute;
 
       // now link all the module dependencies
       // amending the depMap as we go
-      for (var i = 0; i < load.dependencies.length; i++) {
+      for (var i = 0, l = load.dependencies.length; i < l; i++) {
         var depName = load.dependencies[i].value;
-        var depModule;
-        // if dependency already a module, use that
-        if (loader.modules[depName]) {
-          depModule = loader.modules[depName];
-        }
-        else {
+        var depModule = getOrCreateModuleRecord(depName);
+
+        depModule.importers.push(module);
+
+        // if not already a module in the registry, try and link it now
+        if (!loader.modules[depName]) {
+
+          // get the dependency load record
           for (var j = 0; j < loads.length; j++) {
             if (loads[j].name != depName)
               continue;
 
             // only link if already not already started linking (stops at circular / dynamic)
             if (!loads[j].module)
               linkDeclarativeModule(loads[j], loads, loader);
-
-            depModule = loads[j].module;
           }
         }
 
-        var depModuleModule = depModule.exports || depModule.module;
-
         console.assert(depModule, 'Dependency module not found!');
 
-        if (registryEntry.exportStar && indexOf.call(registryEntry.exportStar, load.dependencies[i].key) != -1) {
-          // we are exporting * from this dependency
-          (function(depModuleModule) {
-            for (var p in depModuleModule) (function(p) {
-              // if the property is already defined throw?
-              defineProperty(module, p, {
-                enumerable: true,
-                get: function() {
-                  return depModuleModule[p];
-                },
-                set: function(value) {
-                  depModuleModule[p] = value;
-                }
-              });
-            })(p);
-          })(depModuleModule);
-        }
+        module.dependencies.push(depModule);
 
-        moduleDependencies.push(depModule);
-        depMap[i] = depModuleModule;
+        // run the setter for this dependency
+        if (module.setters[i])
+          module.setters[i](depModule.module);
       }
 
       load.status = 'linked';
@@ -759,6 +762,7 @@ function logloads(loads) {
      * module.module        bound module object
      * module.execute       execution function for module
      * module.dependencies  list of module objects for dependencies
+     * See getOrCreateModuleRecord for all properties
      *
      */
     function doExecute(module) {
@@ -787,7 +791,7 @@ function logloads(loads) {
       var deps = module.dependencies;
       var err;
 
-      for (var i = 0; i < deps.length; i++) {
+      for (var i = 0, l = deps.length; i < l; i++) {
         var dep = deps[i];
         if (indexOf.call(seen, dep) == -1) {
           err = ensureEvaluated(dep, seen, loader);
@@ -807,7 +811,13 @@ function logloads(loads) {
       err = doExecute(module);
       if (err)
         module.failed = true;
-      module.module = _newModule(module.exports);
+      
+      // spec variation
+      // we don't create a new module here because it was created and ammended
+      // we just disable further extensions instead
+      if (Object.preventExtensions)
+        Object.preventExtensions(module.module);
+
       module.execute = undefined;
       return err;
     }