[strong] Implement static restrictions on binding 'undefined' in arrow functions

src/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/v8.h"
 
 #include "src/api.h"
 #include "src/ast.h"
 #include "src/bailout-reason.h"
 #include "src/base/platform/platform.h"
@@ skipping 3688 matching lines @@
 }
 
 
 Handle<FixedArray> CompileTimeValue::GetElements(Handle<FixedArray> value) {
   return Handle<FixedArray>(FixedArray::cast(value->get(kElementsSlot)));
 }
 
 
 bool CheckAndDeclareArrowParameter(ParserTraits* traits, Expression* expression,
                                    Scope* scope, int* num_params,
+                                   Scanner::Location* undefined_loc,
                                    Scanner::Location* dupe_loc) {
   // Case for empty parameter lists:
   //   () => ...
   if (expression == NULL) return true;
 
   // Too many parentheses around expression:
   //   (( ... )) => ...
   if (expression->is_multi_parenthesized()) return false;
 
   // Case for a single parameter:
   //   (foo) => ...
   //   foo => ...
   if (expression->IsVariableProxy()) {
     if (expression->AsVariableProxy()->is_this()) return false;
 
     const AstRawString* raw_name = expression->AsVariableProxy()->raw_name();
     if (traits->IsEvalOrArguments(raw_name) ||
         traits->IsFutureStrictReserved(raw_name))
       return false;
-
+    if (traits->IsUndefined(raw_name) && !undefined_loc->IsValid()) {
+      *undefined_loc = Scanner::Location(
+          expression->position(), expression->position() + raw_name->length());
+    }
     if (scope->IsDeclared(raw_name)) {
       *dupe_loc = Scanner::Location(
           expression->position(), expression->position() + raw_name->length());
       return false;
     }
 
     // When the variable was seen, it was recorded as unresolved in the outer
     // scope. But it's really not unresolved.
     scope->outer_scope()->RemoveUnresolved(expression->AsVariableProxy());
 
     scope->DeclareParameter(raw_name, VAR);
     ++(*num_params);
     return true;
   }
 
   // Case for more than one parameter:
   //   (foo, bar [, ...]) => ...
   if (expression->IsBinaryOperation()) {
     BinaryOperation* binop = expression->AsBinaryOperation();
     if (binop->op() != Token::COMMA || binop->left()->is_parenthesized() ||
         binop->right()->is_parenthesized())
       return false;
 
     return CheckAndDeclareArrowParameter(traits, binop->left(), scope,
-                                         num_params, dupe_loc) &&
+                                         num_params, undefined_loc, dupe_loc) &&
            CheckAndDeclareArrowParameter(traits, binop->right(), scope,
-                                         num_params, dupe_loc);
+                                         num_params, undefined_loc, dupe_loc);
   }
 
   // Any other kind of expression is not a valid parameter list.
   return false;
 }
 
 
 int ParserTraits::DeclareArrowParametersFromExpression(
-    Expression* expression, Scope* scope, Scanner::Location* dupe_loc,
-    bool* ok) {
+    Expression* expression, Scope* scope, Scanner::Location* undefined_loc,
+    Scanner::Location* dupe_loc, bool* ok) {
   int num_params = 0;
   // Always reset the flag: It only needs to be set for the first expression
-  // parsed as arrow function parameter list, becauseonly top-level functions
+  // parsed as arrow function parameter list, because only top-level functions
   // are parsed lazily.
   parser_->parsing_lazy_arrow_parameters_ = false;
   *ok = CheckAndDeclareArrowParameter(this, expression, scope, &num_params,
-                                      dupe_loc);
+                                      undefined_loc, dupe_loc);
   return num_params;
 }
 
 
 FunctionLiteral* Parser::ParseFunctionLiteral(
     const AstRawString* function_name, Scanner::Location function_name_location,
     bool name_is_strict_reserved, FunctionKind kind, int function_token_pos,
     FunctionLiteral::FunctionType function_type,
     FunctionLiteral::ArityRestriction arity_restriction, bool* ok) {
   // Function ::
@@ skipping 87 matching lines @@
     }
 
     //  FormalParameterList ::
     //    '(' (Identifier)*[','] ')'
     Expect(Token::LPAREN, CHECK_OK);
     scope->set_start_position(scanner()->location().beg_pos);
 
     // We don't yet know if the function will be strict, so we cannot yet
     // produce errors for parameter names or duplicates. However, we remember
     // the locations of these errors if they occur and produce the errors later.
-    Scanner::Location eval_args_error_loc = Scanner::Location::invalid();
-    Scanner::Location dupe_error_loc = Scanner::Location::invalid();
-    Scanner::Location reserved_error_loc = Scanner::Location::invalid();
+    Scanner::Location eval_args_loc = Scanner::Location::invalid();
+    Scanner::Location dupe_loc = Scanner::Location::invalid();
+    Scanner::Location reserved_loc = Scanner::Location::invalid();
 
     // Similarly for strong mode.
-    Scanner::Location undefined_error_loc = Scanner::Location::invalid();
+    Scanner::Location undefined_loc = Scanner::Location::invalid();
 
     bool is_rest = false;
     bool done = arity_restriction == FunctionLiteral::GETTER_ARITY ||
         (peek() == Token::RPAREN &&
          arity_restriction != FunctionLiteral::SETTER_ARITY);
     while (!done) {
       bool is_strict_reserved = false;
       is_rest = peek() == Token::ELLIPSIS && allow_harmony_rest_params();
       if (is_rest) {
         Consume(Token::ELLIPSIS);
       }
 
       const AstRawString* param_name =
           ParseIdentifierOrStrictReservedWord(&is_strict_reserved, CHECK_OK);
 
       // Store locations for possible future error reports.
-      if (!eval_args_error_loc.IsValid() && IsEvalOrArguments(param_name)) {
-        eval_args_error_loc = scanner()->location();
+      if (!eval_args_loc.IsValid() && IsEvalOrArguments(param_name)) {
+        eval_args_loc = scanner()->location();
       }
-      if (!undefined_error_loc.IsValid() && IsUndefined(param_name)) {
-        undefined_error_loc = scanner()->location();
+      if (!undefined_loc.IsValid() && IsUndefined(param_name)) {
+        undefined_loc = scanner()->location();
       }
-      if (!reserved_error_loc.IsValid() && is_strict_reserved) {
-        reserved_error_loc = scanner()->location();
+      if (!reserved_loc.IsValid() && is_strict_reserved) {
+        reserved_loc = scanner()->location();
       }
-      if (!dupe_error_loc.IsValid() &&
+      if (!dupe_loc.IsValid() &&
           scope_->IsDeclaredParameter(param_name)) {
         duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
-        dupe_error_loc = scanner()->location();
+        dupe_loc = scanner()->location();
       }
 
       Variable* var = scope_->DeclareParameter(param_name, VAR, is_rest);
       if (is_sloppy(scope->language_mode())) {
         // TODO(sigurds) Mark every parameter as maybe assigned. This is a
         // conservative approximation necessary to account for parameters
         // that are assigned via the arguments array.
         var->set_maybe_assigned();
       }
 
@@ skipping 91 matching lines @@
       handler_count = function_state.handler_count();
     }
 
     // Validate name and parameter names. We can do this only after parsing the
     // function, since the function can declare itself strict.
     CheckFunctionName(language_mode(), kind, function_name,
                       name_is_strict_reserved, function_name_location,
                       CHECK_OK);
     const bool use_strict_params = is_rest || IsConciseMethod(kind);
     CheckFunctionParameterNames(language_mode(), use_strict_params,
-                                eval_args_error_loc, undefined_error_loc,
-                                dupe_error_loc, reserved_error_loc, CHECK_OK);
+                                eval_args_loc, undefined_loc, dupe_loc,
+                                reserved_loc, CHECK_OK);
 
     if (is_strict(language_mode())) {
       CheckStrictOctalLiteral(scope->start_position(), scope->end_position(),
                               CHECK_OK);
     }
     if (is_strict(language_mode())) {
       CheckConflictingVarDeclarations(scope, CHECK_OK);
     }
     if (is_strong(language_mode()) && IsSubclassConstructor(kind)) {
       if (!function_state.super_call_location().IsValid()) {
@@ skipping 1717 matching lines @@
 
 Expression* Parser::SpreadCallNew(Expression* function,
                                   ZoneList<v8::internal::Expression*>* args,
                                   int pos) {
   args->InsertAt(0, function, zone());
 
   return factory()->NewCallRuntime(
       ast_value_factory()->reflect_construct_string(), NULL, args, pos);
 }
 } }  // namespace v8::internal