[1.8>1.9] [MERGE #4568 @aneeshdk] Fixing usage of arguments inside eval in arrow functions

aneeshdk · aneeshdk · commit 4336e29ca2bf · 2018-01-17T16:14:05.000-08:00
Merge pull request #4568 from aneeshdk:ArrowEvalArgumentsIssue When an inner arrow function has eval it may end up using arguments symbol. So we have to mark the parent that arguments is in use.
diff --git a/lib/Parser/Parse.cpp b/lib/Parser/Parse.cpp
@@ -3787,6 +3787,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
                             ReferenceSpecialName(wellKnownPropertyPids._newTarget);
                             ReferenceSpecialName(wellKnownPropertyPids._super);
                             ReferenceSpecialName(wellKnownPropertyPids._superConstructor);
+                            ReferenceSpecialName(wellKnownPropertyPids.arguments);
                         }
 
                         pnode->sxCall.callOfConstants = callOfConstants;
@@ -3809,6 +3810,7 @@ ParseNodePtr Parser::ParsePostfixOperators(
                             ReferenceSpecialName(wellKnownPropertyPids._newTarget);
                             ReferenceSpecialName(wellKnownPropertyPids._super);
                             ReferenceSpecialName(wellKnownPropertyPids._superConstructor);
+                            ReferenceSpecialName(wellKnownPropertyPids.arguments);
                         }
                         pToken->tk = tkNone; // This is no longer an identifier
                     }
@@ -5116,7 +5118,7 @@ ParseNodePtr Parser::ParseFncDecl(ushort flags, LPCOLESTR pNameHint, const bool
     // binding of "arguments.  To ensure the arguments object of the enclosing
     // non-lambda function is loaded propagate the UsesArguments flag up to
     // the parent function
-    if (fLambda && pnodeFnc->sxFnc.UsesArguments())
+    if (fLambda && (pnodeFnc->sxFnc.UsesArguments() || pnodeFnc->sxFnc.CallsEval()))
     {
         ParseNodePtr pnodeFncParent = GetCurrentFunctionNode();
 
diff --git a/test/es6/lambda1.js b/test/es6/lambda1.js
@@ -557,6 +557,96 @@ var tests = [
             var l = () => await (5)
             assert.areEqual('() => await (5)', '' + l, "Regular lambda should also work, though this await looks like a function call");
         }
+    },
+    {
+        name: "Accessing arguments symbol in eval inside lambda",
+        body: function () {
+            function f1(a) {
+                b = () => eval("arguments[0]");
+                assert.areEqual(b(), 1, "Eval should be able to access the arguments symbol");
+            }
+            f1(1);
+
+            function f2(a) {
+                b = (x = eval("arguments[0]")) => x;
+                assert.areEqual(b(), 2, "Eval in param scope should be able to access the arguments symbol")
+            }
+            f2(2);
+
+            function f3(arguments = [3]) {
+                b = () => eval("arguments[0]");
+                assert.areEqual(b(), 3, "Eval should be able to access the arguments param symbol");
+            }
+            f3();
+
+            function f4() {
+                var arguments = [4];
+                b = () => eval("arguments[0]");
+                assert.areEqual(b(), 4, "Eval should be able to access the arguments from the body");
+            }
+            f4(100);
+
+            function f5() {
+                b = () => {
+                    return eval("arguments()");
+                }
+                assert.areEqual(b()[0], 5, "Eval should be able to access the arguments function definition from the body");
+                function arguments() {
+                    return [5];
+                }
+            }
+            f5();
+
+            function f6() {
+                b = () => {
+                    return eval("arguments");
+                }
+                assert.areEqual(b()[0], 6, "Eval should be able to access the arguments function definition in block");
+
+                {
+                    function arguments() {
+                        return [100];
+                    }
+                }
+            }
+            f6(6);
+
+            function f7() {
+                b = () => eval("arguments[0]");
+                assert.areEqual(b(), 7, "Eval should be able to access the built-in arguments from the body");
+                var arguments = [100];
+            }
+            f7(7);
+
+            function f8() {
+                b = (arguments = [8]) => eval("arguments");
+                assert.areEqual(b()[0], 8, "Eval should be able to access the arguments lambda param");
+            }
+            f8(100);
+
+            function f9() {
+                b = (arguments = [9], c = eval("arguments")) => c;
+                assert.areEqual(b()[0], 9, "Eval should be able to access the arguments lambda param in the param scope");
+            }
+            f9();
+
+            function f10() {
+                b = () => {
+                    assert.areEqual(eval("arguments"), undefined, "Eval should access arguments from the lambda body itself");
+                    var arguments = 100;
+                }
+            }
+            f10(100);
+
+            function f11() {
+                arguments;
+                b = () => {
+                    assert.areEqual(eval("arguments"), undefined, "Eval should access arguments from the lambda body itself when the parent function uses arguments");
+                    var arguments = 100;
+                }
+            }
+            f11(100);
+        }
     }
 ];
 

Original file line number	Diff line number	Diff line change
`@@ -3787,6 +3787,7 @@ ParseNodePtr Parser::ParsePostfixOperators(`
`3787`	`3787`	`ReferenceSpecialName(wellKnownPropertyPids._newTarget);`
`3788`	`3788`	`ReferenceSpecialName(wellKnownPropertyPids._super);`
`3789`	`3789`	`ReferenceSpecialName(wellKnownPropertyPids._superConstructor);`
	`3790`	`+ ReferenceSpecialName(wellKnownPropertyPids.arguments);`
`3790`	`3791`	`}`
`3791`	`3792`
`3792`	`3793`	`pnode->sxCall.callOfConstants = callOfConstants;`
`@@ -3809,6 +3810,7 @@ ParseNodePtr Parser::ParsePostfixOperators(`
`3809`	`3810`	`ReferenceSpecialName(wellKnownPropertyPids._newTarget);`
`3810`	`3811`	`ReferenceSpecialName(wellKnownPropertyPids._super);`
`3811`	`3812`	`ReferenceSpecialName(wellKnownPropertyPids._superConstructor);`
	`3813`	`+ ReferenceSpecialName(wellKnownPropertyPids.arguments);`
`3812`	`3814`	`}`
`3813`	`3815`	`pToken->tk = tkNone; // This is no longer an identifier`
`3814`	`3816`	`}`
`@@ -5116,7 +5118,7 @@ ParseNodePtr Parser::ParseFncDecl(ushort flags, LPCOLESTR pNameHint, const bool`
`5116`	`5118`	`// binding of "arguments. To ensure the arguments object of the enclosing`
`5117`	`5119`	`// non-lambda function is loaded propagate the UsesArguments flag up to`
`5118`	`5120`	`// the parent function`
`5119`		`- if (fLambda && pnodeFnc->sxFnc.UsesArguments())`
	`5121`	`+ if (fLambda && (pnodeFnc->sxFnc.UsesArguments() \|\| pnodeFnc->sxFnc.CallsEval()))`
`5120`	`5122`	`{`
`5121`	`5123`	`ParseNodePtr pnodeFncParent = GetCurrentFunctionNode();`
`5122`	`5124`