[parser] Apply an adaptation of the CRTP

src/parsing/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_PARSING_PREPARSER_H
 #define V8_PARSING_PREPARSER_H
 
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
 #include "src/base/hashmap.h"
@@ skipping 567 matching lines @@
       : FormalParametersBase(scope) {}
   int arity = 0;
 
   int Arity() const { return arity; }
   PreParserIdentifier at(int i) { return PreParserIdentifier(); }  // Dummy
 };
 
 
 class PreParser;
 
-class PreParserTraits {
+template <>
+class ParserBaseTraits<PreParser> {
  public:
+  typedef ParserBaseTraits<PreParser> PreParserTraits;
+
   struct Type {
-    // TODO(marja): To be removed. The Traits object should contain all the data
-    // it needs.
-    typedef PreParser* Parser;
-
     // PreParser doesn't need to store generator variables.
     typedef void GeneratorVariable;
 
     typedef int AstProperties;
 
     typedef v8::internal::ExpressionClassifier<PreParserTraits>
         ExpressionClassifier;
 
     // Return types for traversing functions.
     typedef PreParserIdentifier Identifier;
     typedef PreParserExpression Expression;
     typedef PreParserExpression YieldExpression;
     typedef PreParserExpression FunctionLiteral;
     typedef PreParserExpression ClassLiteral;
     typedef PreParserExpression Literal;
     typedef PreParserExpression ObjectLiteralProperty;
     typedef PreParserExpressionList ExpressionList;
     typedef PreParserExpressionList PropertyList;
     typedef PreParserIdentifier FormalParameter;
     typedef PreParserFormalParameters FormalParameters;
     typedef PreParserStatementList StatementList;
 
     // For constructing objects returned by the traversing functions.
     typedef PreParserFactory Factory;
   };
 
-  explicit PreParserTraits(PreParser* pre_parser) : pre_parser_(pre_parser) {}
+  // TODO(nikolaos): The traits methods should not need to call methods
+  // of the implementation object.
+  PreParser* delegate() { return reinterpret_cast<PreParser*>(this); }
+  const PreParser* delegate() const {
+    return reinterpret_cast<const PreParser*>(this);
+  }
 
   // Helper functions for recursive descent.
   bool IsEval(PreParserIdentifier identifier) const {
     return identifier.IsEval();
   }
 
   bool IsArguments(PreParserIdentifier identifier) const {
     return identifier.IsArguments();
   }
 
@@ skipping 350 matching lines @@
                                 bool* ok);
 
   V8_INLINE ZoneList<typename Type::ExpressionClassifier::Error>*
       GetReportedErrorList() const;
   V8_INLINE Zone* zone() const;
   V8_INLINE ZoneList<PreParserExpression>* GetNonPatternList() const;
 
   inline PreParserExpression RewriteYieldStar(PreParserExpression generator,
                                               PreParserExpression expression,
                                               int pos);
-
- private:
-  PreParser* pre_parser_;
 };
 
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparse-data-format.h for the data format.
 
 // The PreParser checks that the syntax follows the grammar for JavaScript,
 // and collects some information about the program along the way.
 // The grammar check is only performed in order to understand the program
 // sufficiently to deduce some information about it, that can be used
 // to speed up later parsing. Finding errors is not the goal of pre-parsing,
 // rather it is to speed up properly written and correct programs.
 // That means that contextual checks (like a label being declared where
 // it is used) are generally omitted.
-class PreParser : public ParserBase<PreParserTraits> {
+class PreParser : public ParserBase<PreParser> {
+  // TODO(nikolaos): This should not be necessary. It will be removed
+  // when the traits object stops delegating to the implementation object.
+  friend class ParserBaseTraits<PreParser>;
+
  public:
   typedef PreParserIdentifier Identifier;
   typedef PreParserExpression Expression;
   typedef PreParserStatement Statement;
 
   enum PreParseResult {
     kPreParseStackOverflow,
     kPreParseSuccess
   };
 
   PreParser(Zone* zone, Scanner* scanner, AstValueFactory* ast_value_factory,
             ParserRecorder* log, uintptr_t stack_limit)
-      : ParserBase<PreParserTraits>(zone, scanner, stack_limit, NULL,
-                                    ast_value_factory, log, this),
+      : ParserBase<PreParser>(zone, scanner, stack_limit, NULL,
+                              ast_value_factory, log),
         use_counts_(nullptr) {}
 
   // Pre-parse the program from the character stream; returns true on
   // success (even if parsing failed, the pre-parse data successfully
   // captured the syntax error), and false if a stack-overflow happened
   // during parsing.
   PreParseResult PreParseProgram(int* materialized_literals = 0,
                                  bool is_module = false) {
     DCHECK_NULL(scope_state_);
     DeclarationScope* scope = NewScriptScope();
@@ skipping 33 matching lines @@
   // At return, unless an error occurred, the scanner is positioned before the
   // the final '}'.
   PreParseResult PreParseLazyFunction(LanguageMode language_mode,
                                       FunctionKind kind,
                                       bool has_simple_parameters,
                                       bool parsing_module, ParserRecorder* log,
                                       Scanner::BookmarkScope* bookmark,
                                       int* use_counts);
 
  private:
-  friend class PreParserTraits;
-
   static const int kLazyParseTrialLimit = 200;
 
   // These types form an algebra over syntactic categories that is just
   // rich enough to let us recognize and propagate the constructs that
   // are either being counted in the preparser data, or is important
   // to throw the correct syntax error exceptions.
 
   // All ParseXXX functions take as the last argument an *ok parameter
   // which is set to false if parsing failed; it is unchanged otherwise.
   // By making the 'exception handling' explicit, we are forced to check
@@ skipping 56 matching lines @@
 
   PreParserExpression ParseClassLiteral(ExpressionClassifier* classifier,
                                         PreParserIdentifier name,
                                         Scanner::Location class_name_location,
                                         bool name_is_strict_reserved, int pos,
                                         bool* ok);
 
   int* use_counts_;
 };
 
-
-void PreParserTraits::MaterializeUnspreadArgumentsLiterals(int count) {
+void ParserBaseTraits<PreParser>::MaterializeUnspreadArgumentsLiterals(
+    int count) {
   for (int i = 0; i < count; ++i) {
-    pre_parser_->function_state_->NextMaterializedLiteralIndex();
+    delegate()->function_state_->NextMaterializedLiteralIndex();
   }
 }
 
-
-PreParserExpression PreParserTraits::SpreadCall(PreParserExpression function,
-                                                PreParserExpressionList args,
-                                                int pos) {
-  return pre_parser_->factory()->NewCall(function, args, pos);
+PreParserExpression ParserBaseTraits<PreParser>::SpreadCall(
+    PreParserExpression function, PreParserExpressionList args, int pos) {
+  return delegate()->factory()->NewCall(function, args, pos);
 }
 
-PreParserExpression PreParserTraits::SpreadCallNew(PreParserExpression function,
-                                                   PreParserExpressionList args,
-                                                   int pos) {
-  return pre_parser_->factory()->NewCallNew(function, args, pos);
+PreParserExpression ParserBaseTraits<PreParser>::SpreadCallNew(
+    PreParserExpression function, PreParserExpressionList args, int pos) {
+  return delegate()->factory()->NewCallNew(function, args, pos);
 }
 
-void PreParserTraits::ParseArrowFunctionFormalParameterList(
+void ParserBaseTraits<PreParser>::ParseArrowFunctionFormalParameterList(
     PreParserFormalParameters* parameters, PreParserExpression params,
     const Scanner::Location& params_loc, Scanner::Location* duplicate_loc,
     const Scope::Snapshot& scope_snapshot, bool* ok) {
   // TODO(wingo): Detect duplicated identifiers in paramlists.  Detect parameter
   // lists that are too long.
 }
 
-PreParserExpression PreParserTraits::ParseAsyncFunctionExpression(bool* ok) {
-  return pre_parser_->ParseAsyncFunctionExpression(ok);
+PreParserExpression ParserBaseTraits<PreParser>::ParseAsyncFunctionExpression(
+    bool* ok) {
+  return delegate()->ParseAsyncFunctionExpression(ok);
 }
 
-PreParserExpression PreParserTraits::ParseDoExpression(bool* ok) {
-  return pre_parser_->ParseDoExpression(ok);
+PreParserExpression ParserBaseTraits<PreParser>::ParseDoExpression(bool* ok) {
+  return delegate()->ParseDoExpression(ok);
 }
 
-
-void PreParserTraits::RewriteNonPattern(Type::ExpressionClassifier* classifier,
-                                        bool* ok) {
-  pre_parser_->ValidateExpression(classifier, ok);
+void ParserBaseTraits<PreParser>::RewriteNonPattern(
+    Type::ExpressionClassifier* classifier, bool* ok) {
+  delegate()->ValidateExpression(classifier, ok);
 }
 
-PreParserExpression PreParserTraits::RewriteAwaitExpression(
+PreParserExpression ParserBaseTraits<PreParser>::RewriteAwaitExpression(
     PreParserExpression value, int pos) {
   return value;
 }
 
-ZoneList<PreParserExpression>* PreParserTraits::GetNonPatternList() const {
-  return pre_parser_->function_state_->non_patterns_to_rewrite();
+ZoneList<PreParserExpression>* ParserBaseTraits<PreParser>::GetNonPatternList()
+    const {
+  return delegate()->function_state_->non_patterns_to_rewrite();
 }
 
-
-ZoneList<typename PreParserTraits::Type::ExpressionClassifier::Error>*
-PreParserTraits::GetReportedErrorList() const {
-  return pre_parser_->function_state_->GetReportedErrorList();
+ZoneList<
+    typename ParserBaseTraits<PreParser>::Type::ExpressionClassifier::Error>*
+ParserBaseTraits<PreParser>::GetReportedErrorList() const {
+  return delegate()->function_state_->GetReportedErrorList();
 }
 
-
-Zone* PreParserTraits::zone() const {
-  return pre_parser_->function_state_->scope()->zone();
+Zone* ParserBaseTraits<PreParser>::zone() const {
+  return delegate()->function_state_->scope()->zone();
 }
 
-
-PreParserExpression PreParserTraits::RewriteYieldStar(
+PreParserExpression ParserBaseTraits<PreParser>::RewriteYieldStar(
     PreParserExpression generator, PreParserExpression expression, int pos) {
   return PreParserExpression::Default();
 }
 
 PreParserStatementList PreParser::ParseEagerFunctionBody(
     PreParserIdentifier function_name, int pos,
     const PreParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
 
   Scope* inner_scope = scope();
   if (!parameters.is_simple) inner_scope = NewScope(BLOCK_SCOPE);
 
   {
     BlockState block_state(&scope_state_, inner_scope);
     ParseStatementList(Token::RBRACE, ok);
     if (!*ok) return PreParserStatementList();
   }
 
   Expect(Token::RBRACE, ok);
   return PreParserStatementList();
 }
 
-
-PreParserStatementList PreParserTraits::ParseEagerFunctionBody(
+PreParserStatementList ParserBaseTraits<PreParser>::ParseEagerFunctionBody(
     PreParserIdentifier function_name, int pos,
     const PreParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
-  return pre_parser_->ParseEagerFunctionBody(function_name, pos, parameters,
-                                             kind, function_type, ok);
+  return delegate()->ParseEagerFunctionBody(function_name, pos, parameters,
+                                            kind, function_type, ok);
 }
 
-PreParserExpression PreParserTraits::CloseTemplateLiteral(
+PreParserExpression ParserBaseTraits<PreParser>::CloseTemplateLiteral(
     TemplateLiteralState* state, int start, PreParserExpression tag) {
   if (IsTaggedTemplate(tag)) {
     // Emulate generation of array literals for tag callsite
     // 1st is array of cooked strings, second is array of raw strings
-    pre_parser_->function_state_->NextMaterializedLiteralIndex();
-    pre_parser_->function_state_->NextMaterializedLiteralIndex();
+    delegate()->function_state_->NextMaterializedLiteralIndex();
+    delegate()->function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H