Refactor formal parameter error locations into a class

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) {
+                                   FormalParameterErrorLocations* locs) {
   // 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(
+    if (traits->IsUndefined(raw_name) && !locs->undefined_.IsValid()) {
+      locs->undefined_ = Scanner::Location(
           expression->position(), expression->position() + raw_name->length());
     }
     if (scope->IsDeclared(raw_name)) {
-      *dupe_loc = Scanner::Location(
+      locs->duplicate_ = 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, undefined_loc, dupe_loc) &&
+                                         num_params, locs) &&
            CheckAndDeclareArrowParameter(traits, binop->right(), scope,
-                                         num_params, undefined_loc, dupe_loc);
+                                         num_params, locs);
   }
 
   // Any other kind of expression is not a valid parameter list.
   return false;
 }
 
 
 int ParserTraits::DeclareArrowParametersFromExpression(
-    Expression* expression, Scope* scope, Scanner::Location* undefined_loc,
-    Scanner::Location* dupe_loc, bool* ok) {
+    Expression* expression, Scope* scope, FormalParameterErrorLocations* locs,
+    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, because only top-level functions
   // are parsed lazily.
   parser_->parsing_lazy_arrow_parameters_ = false;
-  *ok = CheckAndDeclareArrowParameter(this, expression, scope, &num_params,
-                                      undefined_loc, dupe_loc);
+  *ok =
+      CheckAndDeclareArrowParameter(this, expression, scope, &num_params, locs);
   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 79 matching lines @@
       scope_->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
       // expressions. This also marks the FunctionState as a generator.
       Variable* temp = scope_->DeclarationScope()->NewTemporary(
           ast_value_factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
-    // 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_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_loc = Scanner::Location::invalid();
-
+    FormalParameterErrorLocations error_locs;
     bool has_rest = false;
     Expect(Token::LPAREN, CHECK_OK);
     int start_position = scanner()->location().beg_pos;
     ZoneList<const AstRawString*>* params =
-        ParseFormalParameterList(&eval_args_loc, &undefined_loc, &dupe_loc,
-                                 &reserved_loc, &has_rest, CHECK_OK);
+        ParseFormalParameterList(&error_locs, &has_rest, CHECK_OK);
     Expect(Token::RPAREN, CHECK_OK);
     int formals_end_position = scanner()->location().end_pos;
 
     CheckArityRestrictions(params->length(), arity_restriction, start_position,
                            formals_end_position, CHECK_OK);
 
     scope->set_start_position(start_position);
 
     num_parameters = params->length();
-    if (dupe_loc.IsValid()) {
+    if (error_locs.duplicate_.IsValid()) {
       duplicate_parameters = FunctionLiteral::kHasDuplicateParameters;
     }
 
     for (int i = 0; i < params->length(); i++) {
       const AstRawString* param_name = params->at(i);
       int is_rest = has_rest && i == params->length() - 1;
       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
@@ skipping 76 matching lines @@
       expected_property_count = function_state.expected_property_count();
       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 = has_rest || IsConciseMethod(kind);
-    CheckFunctionParameterNames(language_mode(), use_strict_params,
-                                eval_args_loc, undefined_loc, dupe_loc,
-                                reserved_loc, CHECK_OK);
+    CheckFunctionParameterNames(language_mode(), use_strict_params, error_locs,
+                                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