Fix FormalParameterErrorLocations member names

src/preparser.h

 // 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.
 
 #ifndef V8_PREPARSER_H
 #define V8_PREPARSER_H
 
 #include "src/v8.h"
 
 #include "src/bailout-reason.h"
 #include "src/func-name-inferrer.h"
 #include "src/hashmap.h"
 #include "src/scanner.h"
 #include "src/scopes.h"
 #include "src/token.h"
 
 namespace v8 {
 namespace internal {
 
 
 // When parsing the formal parameters of a function, we usually don't yet know
 // if the function will be strict, so we cannot yet produce errors for
 // parameter names or duplicates.  Instead, we remember the locations of these
 // errors if they occur and produce the errors later.
 class FormalParameterErrorLocations BASE_EMBEDDED {
  public:
   FormalParameterErrorLocations()
-      : eval_or_arguments_(Scanner::Location::invalid()),
-        undefined_(Scanner::Location::invalid()),
-        duplicate_(Scanner::Location::invalid()),
-        reserved_(Scanner::Location::invalid()) {}
+      : eval_or_arguments(Scanner::Location::invalid()),
+        undefined(Scanner::Location::invalid()),
+        duplicate(Scanner::Location::invalid()),
+        reserved(Scanner::Location::invalid()) {}
 
-  Scanner::Location eval_or_arguments_;
-  Scanner::Location undefined_;
-  Scanner::Location duplicate_;
-  Scanner::Location reserved_;
+  Scanner::Location eval_or_arguments;
+  Scanner::Location undefined;
+  Scanner::Location duplicate;
+  Scanner::Location reserved;
 };
 
 
 // Common base class shared between parser and pre-parser. Traits encapsulate
 // the differences between Parser and PreParser:
 
 // - Return types: For example, Parser functions return Expression* and
 // PreParser functions return PreParserExpression.
 
 // - Creating parse tree nodes: Parser generates an AST during the recursive
@@ skipping 468 matching lines @@
     }
   }
 
   // Checking the parameter names of a function literal. This has to be done
   // after parsing the function, since the function can declare itself strict.
   void CheckFunctionParameterNames(LanguageMode language_mode,
                                    bool strict_params,
                                    const FormalParameterErrorLocations& locs,
                                    bool* ok) {
     if (is_sloppy(language_mode) && !strict_params) return;
-    if (is_strict(language_mode) && locs.eval_or_arguments_.IsValid()) {
-      Traits::ReportMessageAt(locs.eval_or_arguments_, "strict_eval_arguments");
+    if (is_strict(language_mode) && locs.eval_or_arguments.IsValid()) {
+      Traits::ReportMessageAt(locs.eval_or_arguments, "strict_eval_arguments");
       *ok = false;
       return;
     }
-    if (is_strict(language_mode) && locs.reserved_.IsValid()) {
-      Traits::ReportMessageAt(locs.reserved_, "unexpected_strict_reserved");
+    if (is_strict(language_mode) && locs.reserved.IsValid()) {
+      Traits::ReportMessageAt(locs.reserved, "unexpected_strict_reserved");
       *ok = false;
       return;
     }
-    if (is_strong(language_mode) && locs.undefined_.IsValid()) {
-      Traits::ReportMessageAt(locs.undefined_, "strong_undefined");
+    if (is_strong(language_mode) && locs.undefined.IsValid()) {
+      Traits::ReportMessageAt(locs.undefined, "strong_undefined");
       *ok = false;
       return;
     }
     // TODO(arv): When we add support for destructuring in setters we also need
     // to check for duplicate names.
-    if (locs.duplicate_.IsValid()) {
-      Traits::ReportMessageAt(locs.duplicate_, "strict_param_dupe");
+    if (locs.duplicate.IsValid()) {
+      Traits::ReportMessageAt(locs.duplicate, "strict_param_dupe");
       *ok = false;
       return;
     }
   }
 
   // Determine precedence of given token.
   static int Precedence(Token::Value token, bool accept_IN) {
     if (token == Token::IN && !accept_IN)
       return 0;  // 0 precedence will terminate binary expression parsing
     return Token::Precedence(token);
@@ skipping 385 matching lines @@
   bool IsValidArrowParamList(FormalParameterErrorLocations* locs,
                              const Scanner::Location& params_loc) const {
     ValidArrowParam valid = ValidateArrowParams();
     if (ParenthesizationField::decode(code_) == kMultiParenthesizedExpression) {
       return false;
     }
     switch (valid) {
       case kInvalidArrowParam:
         return false;
       case kInvalidStrongArrowParam:
-        locs->undefined_ = params_loc;
+        locs->undefined = params_loc;
         return true;
       case kInvalidStrictReservedArrowParam:
-        locs->reserved_ = params_loc;
+        locs->reserved = params_loc;
         return true;
       case kInvalidStrictEvalArgumentsArrowParam:
-        locs->eval_or_arguments_ = params_loc;
+        locs->eval_or_arguments = params_loc;
         return true;
       default:
         DCHECK_EQ(valid, kValidArrowParam);
         return true;
     }
   }
 
   // At the moment PreParser doesn't track these expression types.
   bool IsFunctionLiteral() const { return false; }
   bool IsCallNew() const { return false; }
@@ skipping 2130 matching lines @@
                                          FormalParameterErrorLocations* locs,
                                          bool* ok) {
   // FormalParameter[Yield,GeneratorParameter] :
   //   BindingElement[?Yield, ?GeneratorParameter]
   bool is_strict_reserved;
   IdentifierT name =
       ParseIdentifierOrStrictReservedWord(&is_strict_reserved, ok);
   if (!*ok) return this->EmptyFormalParameter();
 
   // Store locations for possible future error reports.
-  if (!locs->eval_or_arguments_.IsValid() && this->IsEvalOrArguments(name)) {
-    locs->eval_or_arguments_ = scanner()->location();
+  if (!locs->eval_or_arguments.IsValid() && this->IsEvalOrArguments(name)) {
+    locs->eval_or_arguments = scanner()->location();
   }
-  if (!locs->undefined_.IsValid() && this->IsUndefined(name)) {
-    locs->undefined_ = scanner()->location();
+  if (!locs->undefined.IsValid() && this->IsUndefined(name)) {
+    locs->undefined = scanner()->location();
   }
-  if (!locs->reserved_.IsValid() && is_strict_reserved) {
-    locs->reserved_ = scanner()->location();
+  if (!locs->reserved.IsValid() && is_strict_reserved) {
+    locs->reserved = scanner()->location();
   }
-  if (!locs->duplicate_.IsValid() && duplicate_finder != nullptr) {
+  if (!locs->duplicate.IsValid() && duplicate_finder != nullptr) {
     int prev_value = scanner()->FindSymbol(duplicate_finder, 1);
-    if (prev_value != 0) locs->duplicate_ = scanner()->location();
+    if (prev_value != 0) locs->duplicate = scanner()->location();
   }
 
   return name;
 }
 
 
 template <class Traits>
 typename ParserBase<Traits>::FormalParameterListT
 ParserBase<Traits>::ParseFormalParameterList(
     FormalParameterErrorLocations* locs, bool* is_rest, bool* ok) {
@@ skipping 341 matching lines @@
       *ok = false;
       return;
     }
     has_seen_constructor_ = true;
     return;
   }
 }
 } }  // v8::internal
 
 #endif  // V8_PREPARSER_H