[parser] Apply an adaptation of the CRTP

src/parsing/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_PARSING_PARSER_H_
 #define V8_PARSING_PARSER_H_
 
 #include "src/allocation.h"
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
@@ skipping 342 matching lines @@
 
   explicit ParserFormalParameters(DeclarationScope* scope)
       : FormalParametersBase(scope), params(4, scope->zone()) {}
   ZoneList<Parameter> params;
 
   int Arity() const { return params.length(); }
   const Parameter& at(int i) const { return params[i]; }
 };
 
 
-class ParserTraits {
+template <>
+class ParserBaseTraits<Parser> {
  public:
+  typedef ParserBaseTraits<Parser> ParserTraits;
+
   struct Type {
-    // TODO(marja): To be removed. The Traits object should contain all the data
-    // it needs.
-    typedef v8::internal::Parser* Parser;
-
     typedef Variable GeneratorVariable;
 
     typedef v8::internal::AstProperties AstProperties;
 
     typedef v8::internal::ExpressionClassifier<ParserTraits>
         ExpressionClassifier;
 
     // Return types for traversing functions.
     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 ParserFormalParameters::Parameter FormalParameter;
     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) {}
+  // TODO(nikolaos): The traits methods should not need to call methods
+  // of the implementation object.
+  Parser* delegate() { return reinterpret_cast<Parser*>(this); }
+  const Parser* delegate() const {
+    return reinterpret_cast<const Parser*>(this);
+  }
 
   // Helper functions for recursive descent.
   bool IsEval(const AstRawString* identifier) const;
   bool IsArguments(const AstRawString* identifier) const;
   bool IsEvalOrArguments(const AstRawString* identifier) const;
   bool IsUndefined(const AstRawString* identifier) const;
   bool IsAwait(const AstRawString* identifier) const;
   V8_INLINE bool IsFutureStrictReserved(const AstRawString* identifier) const;
 
   // Returns true if the expression is of type "this.foo".
@@ skipping 278 matching lines @@
                                    bool* ok);
 
   V8_INLINE ZoneList<typename Type::ExpressionClassifier::Error>*
       GetReportedErrorList() const;
   V8_INLINE Zone* zone() const;
 
   V8_INLINE ZoneList<Expression*>* GetNonPatternList() const;
 
   V8_INLINE Expression* RewriteYieldStar(Expression* generator,
                                          Expression* expression, int pos);
-
- private:
-  Parser* parser_;
 };
 
 
-class Parser : public ParserBase<ParserTraits> {
+class Parser : public ParserBase<Parser> {
  public:
   explicit Parser(ParseInfo* info);
   ~Parser() {
     delete reusable_preparser_;
     reusable_preparser_ = NULL;
     delete cached_parse_data_;
     cached_parse_data_ = NULL;
   }
 
   // Parses the source code represented by the compilation info and sets its
   // function literal.  Returns false (and deallocates any allocated AST
   // nodes) if parsing failed.
   static bool ParseStatic(ParseInfo* info);
   bool Parse(ParseInfo* info);
   void ParseOnBackground(ParseInfo* info);
 
   void DeserializeScopeChain(ParseInfo* info, Handle<Context> context,
                              Scope::DeserializationMode deserialization_mode);
 
   // Handle errors detected during parsing, move statistics to Isolate,
   // internalize strings (move them to the heap).
   void Internalize(Isolate* isolate, Handle<Script> script, bool error);
   void HandleSourceURLComments(Isolate* isolate, Handle<Script> script);
 
  private:
-  friend class ParserTraits;
+  // TODO(nikolaos): This should not be necessary. It will be removed
+  // when the traits object stops delegating to the implementation object.
+  friend class ParserBaseTraits<Parser>;
 
   // Runtime encoding of different completion modes.
   enum CompletionKind {
     kNormalCompletion,
     kThrowCompletion,
     kAbruptCompletion
   };
 
   enum class FunctionBodyType { kNormal, kSingleExpression };
 
@@ skipping 442 matching lines @@
   HistogramTimer* pre_parse_timer_;
 
   bool parsing_on_main_thread_;
 
 #ifdef DEBUG
   void Print(AstNode* node);
 #endif  // DEBUG
 };
 
 
-bool ParserTraits::IsFutureStrictReserved(
+bool ParserBaseTraits<Parser>::IsFutureStrictReserved(
     const AstRawString* identifier) const {
-  return parser_->scanner()->IdentifierIsFutureStrictReserved(identifier);
+  return delegate()->scanner()->IdentifierIsFutureStrictReserved(identifier);
 }
 
-const AstRawString* ParserTraits::EmptyIdentifierString() const {
-  return parser_->ast_value_factory()->empty_string();
+const AstRawString* ParserBaseTraits<Parser>::EmptyIdentifierString() const {
+  return delegate()->ast_value_factory()->empty_string();
+}
+
+void ParserBaseTraits<Parser>::SkipLazyFunctionBody(
+    int* materialized_literal_count, int* expected_property_count, bool* ok,
+    Scanner::BookmarkScope* bookmark) {
+  return delegate()->SkipLazyFunctionBody(
+      materialized_literal_count, expected_property_count, ok, bookmark);
 }
 
 
-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*>* ParserBaseTraits<Parser>::ParseEagerFunctionBody(
+    const AstRawString* name, int pos, const ParserFormalParameters& parameters,
+    FunctionKind kind, FunctionLiteral::FunctionType function_type, bool* ok) {
+  return delegate()->ParseEagerFunctionBody(name, pos, parameters, kind,
+                                            function_type, ok);
+}
+
+void ParserBaseTraits<Parser>::CheckConflictingVarDeclarations(Scope* scope,
+                                                               bool* ok) {
+  delegate()->CheckConflictingVarDeclarations(scope, ok);
 }
 
 
-ZoneList<Statement*>* ParserTraits::ParseEagerFunctionBody(
-    const AstRawString* name, int pos, const ParserFormalParameters& parameters,
-    FunctionKind kind, FunctionLiteral::FunctionType function_type, bool* ok) {
-  return parser_->ParseEagerFunctionBody(name, pos, parameters, kind,
-                                         function_type, ok);
-}
-
-void ParserTraits::CheckConflictingVarDeclarations(Scope* scope, bool* ok) {
-  parser_->CheckConflictingVarDeclarations(scope, ok);
-}
-
-
 // Support for handling complex values (array and object literals) that
 // can be fully handled at compile time.
 class CompileTimeValue: public AllStatic {
  public:
   enum LiteralType {
     OBJECT_LITERAL_FAST_ELEMENTS,
     OBJECT_LITERAL_SLOW_ELEMENTS,
     ARRAY_LITERAL
   };
 
   static bool IsCompileTimeValue(Expression* expression);
 
   // Get the value as a compile time value.
   static Handle<FixedArray> GetValue(Isolate* isolate, Expression* expression);
 
   // Get the type of a compile time value returned by GetValue().
   static LiteralType GetLiteralType(Handle<FixedArray> value);
 
   // Get the elements array of a compile time value returned by GetValue().
   static Handle<FixedArray> GetElements(Handle<FixedArray> value);
 
  private:
   static const int kLiteralTypeSlot = 0;
   static const int kElementsSlot = 1;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(CompileTimeValue);
 };
 
-
-ParserTraits::TemplateLiteralState ParserTraits::OpenTemplateLiteral(int pos) {
-  return parser_->OpenTemplateLiteral(pos);
+ParserBaseTraits<Parser>::TemplateLiteralState
+ParserBaseTraits<Parser>::OpenTemplateLiteral(int pos) {
+  return delegate()->OpenTemplateLiteral(pos);
 }
 
-
-void ParserTraits::AddTemplateSpan(TemplateLiteralState* state, bool tail) {
-  parser_->AddTemplateSpan(state, tail);
+void ParserBaseTraits<Parser>::AddTemplateSpan(TemplateLiteralState* state,
+                                               bool tail) {
+  delegate()->AddTemplateSpan(state, tail);
 }
 
-
-void ParserTraits::AddTemplateExpression(TemplateLiteralState* state,
-                                         Expression* expression) {
-  parser_->AddTemplateExpression(state, expression);
+void ParserBaseTraits<Parser>::AddTemplateExpression(
+    TemplateLiteralState* state, Expression* expression) {
+  delegate()->AddTemplateExpression(state, expression);
 }
 
-
-Expression* ParserTraits::CloseTemplateLiteral(TemplateLiteralState* state,
-                                               int start, Expression* tag) {
-  return parser_->CloseTemplateLiteral(state, start, tag);
+Expression* ParserBaseTraits<Parser>::CloseTemplateLiteral(
+    TemplateLiteralState* state, int start, Expression* tag) {
+  return delegate()->CloseTemplateLiteral(state, start, tag);
 }
 
-
-ZoneList<v8::internal::Expression*>* ParserTraits::PrepareSpreadArguments(
-    ZoneList<v8::internal::Expression*>* list) {
-  return parser_->PrepareSpreadArguments(list);
+ZoneList<v8::internal::Expression*>* ParserBaseTraits<
+    Parser>::PrepareSpreadArguments(ZoneList<v8::internal::Expression*>* list) {
+  return delegate()->PrepareSpreadArguments(list);
 }
 
-
-Expression* ParserTraits::SpreadCall(Expression* function,
-                                     ZoneList<v8::internal::Expression*>* args,
-                                     int pos) {
-  return parser_->SpreadCall(function, args, pos);
+Expression* ParserBaseTraits<Parser>::SpreadCall(
+    Expression* function, ZoneList<v8::internal::Expression*>* args, int pos) {
+  return delegate()->SpreadCall(function, args, pos);
 }
 
-
-Expression* ParserTraits::SpreadCallNew(
+Expression* ParserBaseTraits<Parser>::SpreadCallNew(
     Expression* function, ZoneList<v8::internal::Expression*>* args, int pos) {
-  return parser_->SpreadCallNew(function, args, pos);
+  return delegate()->SpreadCallNew(function, args, pos);
 }
 
-
-void ParserTraits::AddFormalParameter(ParserFormalParameters* parameters,
-                                      Expression* pattern,
-                                      Expression* initializer,
-                                      int initializer_end_position,
-                                      bool is_rest) {
+void ParserBaseTraits<Parser>::AddFormalParameter(
+    ParserFormalParameters* parameters, Expression* pattern,
+    Expression* initializer, int initializer_end_position, bool is_rest) {
   bool is_simple = pattern->IsVariableProxy() && initializer == nullptr;
-  const AstRawString* name = is_simple
-                                 ? pattern->AsVariableProxy()->raw_name()
-                                 : parser_->ast_value_factory()->empty_string();
+  const AstRawString* name =
+      is_simple ? pattern->AsVariableProxy()->raw_name()
+                : delegate()->ast_value_factory()->empty_string();
   parameters->params.Add(
       ParserFormalParameters::Parameter(name, pattern, initializer,
                                         initializer_end_position, is_rest),
       parameters->scope->zone());
 }
 
-void ParserTraits::DeclareFormalParameter(
+void ParserBaseTraits<Parser>::DeclareFormalParameter(
     DeclarationScope* scope, const ParserFormalParameters::Parameter& parameter,
     Type::ExpressionClassifier* classifier) {
   bool is_duplicate = false;
   bool is_simple = classifier->is_simple_parameter_list();
   auto name = is_simple || parameter.is_rest
                   ? parameter.name
-                  : parser_->ast_value_factory()->empty_string();
+                  : delegate()->ast_value_factory()->empty_string();
   auto mode = is_simple || parameter.is_rest ? VAR : TEMPORARY;
   if (!is_simple) scope->SetHasNonSimpleParameters();
   bool is_optional = parameter.initializer != nullptr;
   Variable* var =
       scope->DeclareParameter(name, mode, is_optional, parameter.is_rest,
-                              &is_duplicate, parser_->ast_value_factory());
+                              &is_duplicate, delegate()->ast_value_factory());
   if (is_duplicate) {
     classifier->RecordDuplicateFormalParameterError(
-        parser_->scanner()->location());
+        delegate()->scanner()->location());
   }
   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();
   }
 }
 
-void ParserTraits::AddParameterInitializationBlock(
+void ParserBaseTraits<Parser>::AddParameterInitializationBlock(
     const ParserFormalParameters& parameters,
     ZoneList<v8::internal::Statement*>* body, bool is_async, bool* ok) {
   if (!parameters.is_simple) {
     auto* init_block =
-        parser_->BuildParameterInitializationBlock(parameters, ok);
+        delegate()->BuildParameterInitializationBlock(parameters, ok);
     if (!*ok) return;
 
     if (is_async) {
-      init_block = parser_->BuildRejectPromiseOnException(init_block);
+      init_block = delegate()->BuildRejectPromiseOnException(init_block);
     }
 
     if (init_block != nullptr) {
-      body->Add(init_block, parser_->zone());
+      body->Add(init_block, delegate()->zone());
     }
   }
 }
 
-Expression* ParserTraits::ParseAsyncFunctionExpression(bool* ok) {
-  return parser_->ParseAsyncFunctionExpression(ok);
+Expression* ParserBaseTraits<Parser>::ParseAsyncFunctionExpression(bool* ok) {
+  return delegate()->ParseAsyncFunctionExpression(ok);
 }
 
-DoExpression* ParserTraits::ParseDoExpression(bool* ok) {
-  return parser_->ParseDoExpression(ok);
+DoExpression* ParserBaseTraits<Parser>::ParseDoExpression(bool* ok) {
+  return delegate()->ParseDoExpression(ok);
 }
 
-Expression* ParserTraits::RewriteYieldStar(Expression* generator,
-                                           Expression* iterable, int pos) {
-  return parser_->RewriteYieldStar(generator, iterable, pos);
+Expression* ParserBaseTraits<Parser>::RewriteYieldStar(Expression* generator,
+                                                       Expression* iterable,
+                                                       int pos) {
+  return delegate()->RewriteYieldStar(generator, iterable, pos);
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_H_