Issue 427 - Desugar arrow functions to normal or bound functions

scripts/abprewrite.js

 // This script rewrites AST to be compatible with JavaScript 1.5 and decompiles
 // the modified tree then
 
 include("../scripts/astDecompile.js");
 include("../utils/beautify.js");
 
 let headerPrinted = false;
 
 // See https://developer.mozilla.org/en-US/docs/SpiderMonkey/Parser_API for
 // AST structure.
@@ skipping 378 matching lines @@
     return modifyForStatement(ast.body);
   }
 
   return ast;
 }
 
 function modifyFunctionExpression(ast)
 {
   if (ast.expression)
   {
-    // Convert expression closures:
-    // function() foo;
-    //
-    // Change into:
-    // function()
-    // {
-    //   return foo;
-    // }
-    ast.expression = false;
-    ast.body = {
-      type: "BlockStatement",
-      body: [
-        {
-          type: "ReturnStatement",
-          argument: ast.body
-        }
-      ]
-    };
+    print("Use arrow functions instead of function expressions!\n");
+    throw new Error("Use arrow functions instead of function expressions!");
   }
 
   if (ast.generator)
   {
     // Convert generators:
     // function()
     // {
     //   ...
     //   yield "foo";
     //   ...
@@ skipping 25 matching lines @@
   }
 
   return ast;
 }
 
 function modifyFunctionDeclaration(ast)
 {
   return modifyFunctionExpression(ast);
 }
 
+function modifyArrowExpression(ast)
+{
+  if (ast.body.type != "BlockStatement") {
+    // Convert expressions to block statements.
+    // (a) => a + 1
+    //
+    // Change into:
+    // (a) => { return a + 1; }
+    ast.body = {
+      type: "BlockStatement",
+      body: [
+        {
+          type: "ReturnStatement",
+          argument: ast.body
+        }
+      ]
+    };
+  }
+
+  // Now convert the arrow expression into a normal
+  // function expression.
+  ast.type = "FunctionExpression";
+  ast.expression = false;
+
+  // We want to avoid the .bind call if |this| isn't actually used.
+  // This is not necessarily always correct, but should be good enough.
+  var body = decompileAST(ast.body);
+  if (["this", "Function", "eval", "=>"].some(search => body.contains(search))) {

[Wladimir Palant, 2014/05/15 06:53:44]

I think this would be better here:

  if (/\b(this|Function|eval)\b/.test(body))

While this is still a hack, we should look for keywords rather than random
substrings.

And of course we should never generate code dynamically - already because CSP
restrictions in Chrome don't allow it. So I wonder whether creating
modifyCallExpression()/modifyNewExpression() functions that will reject new
Function(...) and eval(...) would be a better course of action here.

+    return {
+      type: "CallExpression",
+      callee: Member(ast, "bind"),
+      arguments: [
+        {
+          type: "ThisExpression"
+        }
+      ]
+    };
+  }
+  return ast;
+}
+
 function modifyYieldExpression(ast)
 {
   // Convert generators into functions returning arrays:
   // yield "foo";
   //
   // Change into:
   // _generatorResult44.push("foo");
 
   if (ast.argument)
   {
@@ skipping 71 matching lines @@
     let code = 'require.scopes["' + options.filename + '"] = (function() {\n' +
                'var exports = {};\n' +
                decompileAST(ast) +
                'return exports;\n' +
                '})();\n';
     _print(js_beautify(code, options));
   }
   else
     _print(js_beautify(decompileAST(ast), options));
 }