Merge branch 'newregister'

Conflicts:
	lib/loader.js

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,79 @@ 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 = [];
+      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.
+        module.locked = true;
+        moduleObj[name] = value;
+
+        for (var i = 0, l = module.importers.length; i < l; i++) {
+          var importerModule = module.importers[i];
+          if (!importerModule.locked) {
+            var importerIndex = importerModule.dependencies.indexOf(module);
+            importerModule.setters[importerIndex](moduleObj);
+          }
+        }
 
-      // module is just a plain object, until we evaluate it
-      var module = registryEntry.exports;
+        module.locked = false;
+        return value;
+      });
 
-      console.assert(!load.module, 'Load module already declared!');
-
-      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);
+        module.dependencies.push(depModule);
+
+        // 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);
-        }
-
-        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 +761,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 +790,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,8 +810,13 @@ function logloads(loads) {
       err = doExecute(module);
       if (err)
         module.failed = true;
-      else
-        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;
     }

test/syntax/circular1.js

@@ -2,6 +2,8 @@ import {fn2, variable2} from './circular2';
 
 export var variable1 = 'test circular 1';
 
+export { output as output2 } from './circular2';
+
 fn2();
 
 export var output;

test/syntax/circular2.js

@@ -2,6 +2,8 @@ import {fn1, variable1} from './circular1';
 
 export var variable2 = 'test circular 2';
 
+export { output as output1 } from './circular1';
+
 fn1();
 
 export var output;

test/syntax/even.js

@@ -5,4 +5,6 @@ export var counter = 0;
 export function even(n) {
   counter++;
   return n == 0 || odd(n - 1);
-}
+}
+
+odd(1);

test/test.js

@@ -211,7 +211,9 @@ function runTests() {
       System['import']('syntax/circular2').then(function(m2) {
         assert(
           [m2.output, 'test circular 1'],
-          [m1.output, 'test circular 2']
+          [m1.output, 'test circular 2'],
+          [m2.output1, 'test circular 2'],
+          [m1.output2, 'test circular 1']
         );
       }, err);
     }, err);
@@ -221,9 +223,9 @@ function runTests() {
     System['import']('syntax/even').then(function(m) {
       assert(
         [m.even(10), true],
-        [m.counter, 6],
+        [m.counter, 7],
         [m.even(15), false],
-        [m.counter, 14]
+        [m.counter, 15]
       );
     }, err);
   });
@@ -337,7 +339,7 @@ function runTests() {
   test('Re-export binding', function(assert, err) {
     System['import']('syntax/reexport-binding').then(function(m) {
       System['import']('syntax/rebinding').then(function(m) {
-        assert(m.p, 3);
+        assert(m.p, 4);
       });
     }, err);
   });