Issue 427 - Desugar arrow functions to normal or bound functions

scripts/abprewrite.js

Index: scripts/abprewrite.js
===================================================================
--- a/scripts/abprewrite.js
+++ b/scripts/abprewrite.js
@@ -391,34 +391,18 @@ function modifyLetStatement(ast)
 
   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()
     // {
     //   ...
@@ -454,16 +438,57 @@ function modifyFunctionExpression(ast)
   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");