[es6] Some renamings and minor clean-ups in parameter parsing

src/parser.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_PARSER_H_
 #define V8_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast.h"
 #include "src/compiler.h"  // TODO(titzer): remove this include dependency
@@ skipping 521 matching lines @@
   bool failed_;
 };
 
 // ----------------------------------------------------------------------------
 // JAVASCRIPT PARSING
 
 class Parser;
 class SingletonLogger;
 
 
-struct ParserFormalParameterParsingState
-    : public PreParserFormalParameterParsingState {
+struct ParserFormalParameters : public PreParserFormalParameters {
   struct Parameter {
     Parameter(Variable* var, Expression* pattern)
         : var(var), pattern(pattern) {}
     Variable* var;
     Expression* pattern;
   };
 
-  explicit ParserFormalParameterParsingState(Scope* scope)
-      : PreParserFormalParameterParsingState(scope), params(4, scope->zone()) {}
+  explicit ParserFormalParameters(Scope* scope)
+      : PreParserFormalParameters(scope), params(4, scope->zone()) {}
 
   ZoneList<Parameter> params;
 
   void AddParameter(Variable* var, Expression* pattern) {
     params.Add(Parameter(var, pattern), scope->zone());
   }
 };
 
 
 class ParserTraits {
@@ skipping 11 matching lines @@
     typedef const AstRawString* Identifier;
     typedef v8::internal::Expression* Expression;
     typedef Yield* YieldExpression;
     typedef v8::internal::FunctionLiteral* FunctionLiteral;
     typedef v8::internal::ClassLiteral* ClassLiteral;
     typedef v8::internal::Literal* Literal;
     typedef ObjectLiteral::Property* ObjectLiteralProperty;
     typedef ZoneList<v8::internal::Expression*>* ExpressionList;
     typedef ZoneList<ObjectLiteral::Property*>* PropertyList;
     typedef const v8::internal::AstRawString* FormalParameter;
-    typedef ParserFormalParameterParsingState FormalParameterParsingState;
+    typedef ParserFormalParameters FormalParameters;
     typedef ZoneList<v8::internal::Statement*>* StatementList;
 
     // For constructing objects returned by the traversing functions.
     typedef AstNodeFactory Factory;
   };
 
   explicit ParserTraits(Parser* parser) : parser_(parser) {}
 
   // Helper functions for recursive descent.
   bool IsEval(const AstRawString* identifier) const;
@@ skipping 172 matching lines @@
     return new(zone) ZoneList<v8::internal::Expression*>(size, zone);
   }
   ZoneList<ObjectLiteral::Property*>* NewPropertyList(int size, Zone* zone) {
     return new(zone) ZoneList<ObjectLiteral::Property*>(size, zone);
   }
   ZoneList<v8::internal::Statement*>* NewStatementList(int size, Zone* zone) {
     return new(zone) ZoneList<v8::internal::Statement*>(size, zone);
   }
 
   V8_INLINE void AddParameterInitializationBlock(
-      const ParserFormalParameterParsingState& formal_parameters,
+      const ParserFormalParameters& parameters,
       ZoneList<v8::internal::Statement*>* body, bool* ok);
 
   V8_INLINE Scope* NewScope(Scope* parent_scope, ScopeType scope_type,
                             FunctionKind kind = kNormalFunction);
 
   V8_INLINE void DeclareFormalParameter(
-      ParserFormalParameterParsingState* parsing_state, Expression* name,
-      ExpressionClassifier* classifier, bool is_rest);
+      ParserFormalParameters* parameters, Expression* pattern, bool is_rest,
+      ExpressionClassifier* classifier);
   void ParseArrowFunctionFormalParameters(
-      ParserFormalParameterParsingState* scope, Expression* params,
-      const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
-      bool* ok);
+      ParserFormalParameters* parameters, Expression* params,
+      const Scanner::Location& params_loc,
+      Scanner::Location* duplicate_loc, bool* ok);
 
-  void ReindexLiterals(const ParserFormalParameterParsingState& parsing_state);
+  void ReindexLiterals(const ParserFormalParameters& parameters);
 
   // Temporary glue; these functions will move to ParserBase.
   Expression* ParseV8Intrinsic(bool* ok);
   FunctionLiteral* ParseFunctionLiteral(
       const AstRawString* name, Scanner::Location function_name_location,
       FunctionNameValidity function_name_validity, FunctionKind kind,
       int function_token_position, FunctionLiteral::FunctionType type,
       FunctionLiteral::ArityRestriction arity_restriction,
       LanguageMode language_mode, bool* ok);
   V8_INLINE void SkipLazyFunctionBody(
       int* materialized_literal_count, int* expected_property_count, bool* ok,
       Scanner::BookmarkScope* bookmark = nullptr);
   V8_INLINE ZoneList<Statement*>* ParseEagerFunctionBody(
       const AstRawString* name, int pos,
-      const ParserFormalParameterParsingState& formal_parameters,
+      const ParserFormalParameters& parameters,
       Variable* fvar, Token::Value fvar_init_op, FunctionKind kind, bool* ok);
 
   ClassLiteral* ParseClassLiteral(const AstRawString* name,
                                   Scanner::Location class_name_location,
                                   bool name_is_strict_reserved, int pos,
                                   bool* ok);
 
   V8_INLINE void CheckConflictingVarDeclarations(v8::internal::Scope* scope,
                                                  bool* ok);
 
@@ skipping 331 matching lines @@
   // If bookmark is set, the (pre-)parser may decide to abort skipping
   // in order to force the function to be eagerly parsed, after all.
   // In this case, it'll reset the scanner using the bookmark.
   void SkipLazyFunctionBody(int* materialized_literal_count,
                             int* expected_property_count, bool* ok,
                             Scanner::BookmarkScope* bookmark = nullptr);
 
   PreParser::PreParseResult ParseLazyFunctionBodyWithPreParser(
       SingletonLogger* logger, Scanner::BookmarkScope* bookmark = nullptr);
 
-  bool IsSimpleParameterList(
-      const ParserFormalParameterParsingState& formal_parameters);
+  bool IsSimpleParameterList(const ParserFormalParameters& parameters);
   Block* BuildParameterInitializationBlock(
-      const ParserFormalParameterParsingState& formal_parameters, bool* ok);
+      const ParserFormalParameters& parameters, bool* ok);
 
   // Consumes the ending }.
   ZoneList<Statement*>* ParseEagerFunctionBody(
       const AstRawString* function_name, int pos,
-      const ParserFormalParameterParsingState& formal_parameters,
+      const ParserFormalParameters& parameters,
       Variable* fvar, Token::Value fvar_init_op, FunctionKind kind, bool* ok);
 
   void ThrowPendingError(Isolate* isolate, Handle<Script> script);
 
   TemplateLiteralState OpenTemplateLiteral(int pos);
   void AddTemplateSpan(TemplateLiteralState* state, bool tail);
   void AddTemplateExpression(TemplateLiteralState* state,
                              Expression* expression);
   Expression* CloseTemplateLiteral(TemplateLiteralState* state, int start,
                                    Expression* tag);
@@ skipping 45 matching lines @@
 void ParserTraits::SkipLazyFunctionBody(int* materialized_literal_count,
                                         int* expected_property_count, bool* ok,
                                         Scanner::BookmarkScope* bookmark) {
   return parser_->SkipLazyFunctionBody(materialized_literal_count,
                                        expected_property_count, ok, bookmark);
 }
 
 
 ZoneList<Statement*>* ParserTraits::ParseEagerFunctionBody(
     const AstRawString* name, int pos,
-    const ParserFormalParameterParsingState& formal_parameters, Variable* fvar,
+    const ParserFormalParameters& parameters, Variable* fvar,
     Token::Value fvar_init_op, FunctionKind kind, bool* ok) {
-  return parser_->ParseEagerFunctionBody(name, pos, formal_parameters, fvar,
+  return parser_->ParseEagerFunctionBody(name, pos, parameters, fvar,
                                          fvar_init_op, kind, ok);
 }
 
 void ParserTraits::CheckConflictingVarDeclarations(v8::internal::Scope* scope,
                                                    bool* ok) {
   parser_->CheckConflictingVarDeclarations(scope, ok);
 }
 
 
 // Support for handling complex values (array and object literals) that
@@ skipping 60 matching lines @@
 }
 
 
 Expression* ParserTraits::SpreadCallNew(
     Expression* function, ZoneList<v8::internal::Expression*>* args, int pos) {
   return parser_->SpreadCallNew(function, args, pos);
 }
 
 
 void ParserTraits::DeclareFormalParameter(
-    ParserFormalParameterParsingState* parsing_state, Expression* pattern,
-    ExpressionClassifier* classifier, bool is_rest) {
+    ParserFormalParameters* parameters, Expression* pattern, bool is_rest,
+    ExpressionClassifier* classifier) {
   bool is_duplicate = false;
-  bool is_simple_name = pattern->IsVariableProxy();
-  DCHECK(parser_->allow_harmony_destructuring() || is_simple_name);
+  bool is_simple = pattern->IsVariableProxy();
+  DCHECK(parser_->allow_harmony_destructuring() || is_simple);
 
-  const AstRawString* name = is_simple_name
+  const AstRawString* name = is_simple
                                  ? pattern->AsVariableProxy()->raw_name()
                                  : parser_->ast_value_factory()->empty_string();
   Variable* var =
-      parsing_state->scope->DeclareParameter(name, VAR, is_rest, &is_duplicate);
-  parsing_state->AddParameter(var, is_simple_name ? nullptr : pattern);
-  if (is_sloppy(parsing_state->scope->language_mode())) {
+      parameters->scope->DeclareParameter(name, VAR, is_rest, &is_duplicate);
+  parameters->AddParameter(var, is_simple ? nullptr : pattern);
+  if (is_duplicate) {
+    classifier->RecordDuplicateFormalParameterError(
+        parser_->scanner()->location());
+  }
+  if (is_sloppy(parameters->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();
   }
-  if (is_duplicate) {
-    classifier->RecordDuplicateFormalParameterError(
-        parser_->scanner()->location());
-  }
 }
 
 
 void ParserTraits::AddParameterInitializationBlock(
-    const ParserFormalParameterParsingState& formal_parameters,
+    const ParserFormalParameters& parameters,
     ZoneList<v8::internal::Statement*>* body, bool* ok) {
-  if (parser_->IsSimpleParameterList(formal_parameters)) return;
-  auto* init_block =
-      parser_->BuildParameterInitializationBlock(formal_parameters, ok);
-  if (!*ok) return;
-  if (init_block != nullptr) {
-    body->Add(init_block, parser_->zone());
+  if (!parser_->IsSimpleParameterList(parameters)) {
+    auto* init_block =
+        parser_->BuildParameterInitializationBlock(parameters, ok);
+    if (!*ok) return;
+    if (init_block != nullptr) {
+      body->Add(init_block, parser_->zone());
+    }
   }
 }
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_