updates, move Loader.prototype.parse into loader implementation

Author: guybedford

lib/loader.js

@@ -262,14 +262,14 @@ function logloads(loads) {
         if (load.status != 'loading')
           return;
 
-        var depsList;
         if (instantiateResult === undefined) {
           load.address = load.address || 'anon' + ++anonCnt;
           load.kind = 'declarative';
-          depsList = loader.loaderObj.parse(load);
+          // parse sets load.declare, load.depsList
+          loader.loaderObj.parse(load);
         }
         else if (typeof instantiateResult == 'object') {
-          depsList = instantiateResult.deps || [];
+          load.depsList = instantiateResult.deps || [];
           load.execute = instantiateResult.execute;
           load.kind = 'dynamic';
         }
@@ -278,7 +278,7 @@ function logloads(loads) {
 
         // 15.2.4.6 ProcessLoadDependencies
         load.dependencies = [];
-        load.depsList = depsList;
+        var depsList = load.depsList;
 
         var loadPromises = [];
         for (var i = 0, l = depsList.length; i < l; i++) (function(request, index) {
@@ -1012,6 +1012,58 @@ function logloads(loads) {
 
     var _newModule = Loader.prototype.newModule;
 
+
+    /*
+     * Traceur-specific Parsing Code for Loader
+     */
+    (function() {
+      function checkForErrors(output, load) {
+        if (output.errors.length) {
+          for (var i = 0, l = output.errors.length; i < l; i++)
+            console.error(output.errors[i]);
+          throw new Error('Parse of ' + load.name + ', ' + load.address + ' failed, ' + output.errors.length);
+        }
+      }
+
+      // parse function is used to parse a load record
+      // Returns an array of ModuleSpecifiers
+      Loader.prototype.parse = function(load) {
+        if (!traceur) {
+          if (typeof window == 'undefined')
+            traceur = require('traceur');
+          else if (__global.traceur)
+            traceur = __global.traceur;
+          else
+            throw new TypeError('Include Traceur for module syntax support');
+        }
+
+        console.assert(load.source, 'Non-empty source');
+
+        var depsList;
+
+        load.kind = 'declarative';
+
+        var compiler = new traceur.Compiler();
+        var options = System.traceurOptions || {};
+        options.modules = 'instantiate';
+        var output = compiler.stringToTree({content: load.source, options: options});
+        checkForErrors(output);
+
+        output = compiler.treeToTree(output);
+        checkForErrors(output);
+
+        output = compiler.treeToString(output);
+        checkForErrors(output);
+        var source = output.js;
+        var sourceMap = output.generatedSourceMap;
+
+        if (__global.btoa && sourceMap)
+          source += '\n//# sourceMappingURL=data:application/json;base64,' + btoa(unescape(encodeURIComponent(sourceMap))) + '\n';
+
+        __eval(source, __global, load);
+      }
+    })();
+
     if (typeof exports === 'object')
       module.exports = Loader;
 
@@ -1022,4 +1074,32 @@ function logloads(loads) {
 
   })();
 
+  // Define our eval outside of the scope of any other reference defined in this
+  // file to avoid adding those references to the evaluation scope.
+  var __curRegister;
+  function __eval(__source, __global, load) {
+    // Hijack System.register to set declare function
+    __curRegister = System.register;
+    System.register = function(name, deps, declare) {
+      if (typeof name != 'string') {
+        declare = deps;
+        deps = name;
+      }
+      // store the registered declaration as load.declare
+      // store the deps as load.deps
+      load.declare = declare;
+      load.depsList = deps;
+    }
+    try {
+      eval('var __moduleName = "' + (load.name || '').replace('"', '\"') + '"; (function() { ' + __source + ' \n }).call(__global);');
+    }
+    catch(e) {
+      if (e.name == 'SyntaxError' || e.name == 'TypeError')
+        e.message = 'Evaluating ' + (load.name || load.address) + '\n\t' + e.message;
+      throw e;
+    }
+
+    System.register = __curRegister;
+  }
+
 })(typeof global !== 'undefined' ? global : this);