Declare the arguments object before creating the function var, to make sure it masks it

src/parsing/parser.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 2824 matching lines @@
       expected_property_count = function_state.expected_property_count();
       if (use_temp_zone) {
         // If the preconditions are correct the function body should never be
         // accessed, but do this anyway for better behaviour if they're wrong.
         body = nullptr;
       }
     }
 
     // Parsing the body may change the language mode in our scope.
     language_mode = scope->language_mode();
-    scope->DeclareArguments(ast_value_factory());
-    if (main_scope != scope) {
-      main_scope->DeclareArguments(ast_value_factory());
-    }
 
     // Validate name and parameter names. We can do this only after parsing the
     // function, since the function can declare itself strict.
     CheckFunctionName(language_mode, function_name, function_name_validity,
                       function_name_location, CHECK_OK);
     const bool allow_duplicate_parameters =
         is_sloppy(language_mode) && formals.is_simple && !IsConciseMethod(kind);
     ValidateFormalParameters(language_mode, allow_duplicate_parameters,
                              CHECK_OK);
 
@@ skipping 568 matching lines @@
 
     result->Add(init_block, zone());
     result->Add(inner_block, zone());
   } else {
     DCHECK_EQ(inner_scope, function_scope);
     if (is_sloppy(function_scope->language_mode())) {
       InsertSloppyBlockFunctionVarBindings(function_scope);
     }
   }
 
+  if (!IsArrowFunction(kind)) {
+    // Declare arguments after parsing the function since lexical 'arguments'
+    // masks the arguments object. Declare arguments before declaring the
+    // function var since the arguments object masks 'function arguments'.
+    function_scope->DeclareArguments(ast_value_factory());
+  }
+
   if (function_type == FunctionLiteral::kNamedExpression) {
     Statement* statement;
     if (function_scope->LookupLocal(function_name) == nullptr) {
       // Now that we know the language mode, we can create the const assignment
       // in the previously reserved spot.
       DCHECK_EQ(function_scope, scope());
       Variable* fvar = function_scope->DeclareFunctionVar(function_name);
       VariableProxy* fproxy = factory()->NewVariableProxy(fvar);
       statement = factory()->NewExpressionStatement(
           factory()->NewAssignment(Token::INIT, fproxy,
@@ skipping 2156 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8