Make eval("arguments") work inside of lambdas.

Author: j-wing

lib/Runtime/ByteCode/ByteCodeGenerator.cpp

@@ -2488,6 +2488,16 @@ FuncInfo* PostVisitFunction(ParseNode* pnode, ByteCodeGenerator* byteCodeGenerat
         {
             top->byteCodeFunction->SetEnclosedByGlobalFunc();
         }
+
+        // In the case of lambdas defined inside of eval in param scope, argumentsSymbol can be nullptr
+        // We still get correct behavior if it is, but we need to check if that's the case.
+        if (top->GetCallsEval() && !enclosingNonLambda->IsGlobalFunction()
+            && enclosingNonLambda->GetArgumentsSymbol() != nullptr)
+        {
+            enclosingNonLambda->SetHasArguments(true);
+            enclosingNonLambda->SetHasHeapArguments(true);
+            enclosingNonLambda->GetArgumentsSymbol()->SetHasNonLocalReference();
+        }
     }
 
     // If this is a named function expression and has deferred child, mark has non-local reference.
@@ -3168,6 +3178,16 @@ void VisitNestedScopes(ParseNode* pnodeScopeList, ParseNode* pnodeParent, ByteCo
                 // Push the param scope
                 byteCodeGenerator->PushScope(paramScope);
 
+                /*
+                We need this call to happen *before* visiting the param scope. If we have a split scope,
+                and this function has parameters that default to a lambda which uses the implicit "arguments" inside
+                of eval, we need this function's argumentsSymbol to be set already, so that we can mark it as
+                non-locally referenced inside of PostVisitFunction.
+
+                See Github issue #1209 for more.
+                */
+                AddVarsToScope(pnodeScope->sxFnc.pnodeVars, byteCodeGenerator);
+
                 if (pnodeScope->sxFnc.HasNonSimpleParameterList() && !paramScope->GetCanMergeWithBodyScope())
                 {
                     // Set param scope as the current child scope.
@@ -3182,7 +3202,6 @@ void VisitNestedScopes(ParseNode* pnodeScopeList, ParseNode* pnodeParent, ByteCo
                 funcInfo->SetCurrentChildScope(bodyScope);
 
                 PreVisitBlock(pnodeScope->sxFnc.pnodeBodyScope, byteCodeGenerator);
-                AddVarsToScope(pnodeScope->sxFnc.pnodeVars, byteCodeGenerator);
 
                 if (!pnodeScope->sxFnc.HasNonSimpleParameterList() || paramScope->GetCanMergeWithBodyScope())
                 {

test/es6/default-splitscope.js

@@ -913,6 +913,23 @@ var tests = [
             }
         }
         assert.areEqual([2, 3], f16(1, undefined, 2, 3), "Rest should remain unaffected when arguments is updated");
+
+        function f18(a, b = () => eval("arguments[0]")) {
+            return b();
+        }
+        assert.areEqual(1, f18(1), "eval('arguments') inside split scope should work correctly");
+        assert.areEqual([1, 2], f18([1, 2]), "eval('arguments') inside split scope should work correctly");
+
+        function f19(a, b = eval('() => () => eval("arguments[0]"')) {
+            return b()();
+        }
+        assert.areEqual(1, f18(1), "nested eval('arguments') inside split scope should work correctly");
+        assert.areEqual([1, 2], f18([1, 2]), "nested eval('arguments') inside split scope should work correctly");
+
+        function f20(a, c = () => eval("arguments.length")) {
+            return c();
+        }
+        assert.areEqual(1, f20(1), "arguments.length is set correctly with eval in split scope lambda");
     }  
   },
   {

test/es6/lambda1.js

@@ -269,6 +269,52 @@ var tests = [
             assert.areEqual('foo', k('foo')(), "lambda captures formal parameters named arguments");
         }
     },
+    {
+        name: "eval('arguments') works correctly within lambdas",
+        body: function () {
+            var arguments = 'not arguments object';
+            assert.areEqual(arguments, (() => eval("arguments"))(), "arguments in lambda should bind to outside arguments since it is not given its own arguments binding");
+
+            function h () {
+                return () => {
+                    assert.areEqual(5, eval("arguments.length"), "captured arguments length is respected");
+                    assert.areEqual(h, eval("arguments.callee"), "arguments caller is respected");
+                    assert.areEqual(1, eval("arguments[0]"), "first argument is 1");
+                    assert.areEqual(2, eval("arguments[1]"), "second argument is 2");
+                    assert.areEqual(3, eval("arguments[2]"), "third argument is 3");
+                    assert.areEqual('abc', eval("arguments[3]"), "fourth argument is 'abc'");
+                    assert.areEqual(null, eval("arguments[4]"), "fifth argument is null");
+                };
+            }
+            h(1, 2, 3, 'abc', null)();
+
+            function i () {
+                return () => () => { return () => eval("arguments"); };
+            }
+            var args = i('a', 'b', 'c', 123, undefined)()()();
+
+            assert.areEqual(5, args.length, "captured arguments (through multiple lambdas) length is respected");
+            assert.areEqual(i, args.callee, "arguments (through multiple lambdas) caller is respected");
+            assert.areEqual('a', args[0], "first argument (through multiple lambdas) is 'a'");
+            assert.areEqual('b', args[1], "second argument (through multiple lambdas) is 'b'");
+            assert.areEqual('c', args[2], "third argument (through multiple lambdas) is 'c'");
+            assert.areEqual(123, args[3], "fourth argument (through multiple lambdas) is 123");
+            assert.areEqual(undefined, args[4], "fifth argument (through multiple lambdas) is undefined");
+
+            function j () {
+                var arguments = 'not an arguments object';
+                return () => eval("arguments");
+            }
+
+            assert.areEqual('not an arguments object', j()(), "lambda captures local variables named arguments");
+
+            function k (arguments) {
+                return () => eval("arguments");
+            }
+
+            assert.areEqual('foo', k('foo')(), "lambda captures formal parameters named arguments");
+        }
+    },
     {
         name: "Capturing dynamically scoped variables",
         body: function () {