[parser] Clean up (pre)parser traits

src/parsing/preparser.cc

 // Copyright 2011 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 <cmath>
 
 #include "src/allocation.h"
 #include "src/base/logging.h"
 #include "src/conversions-inl.h"
 #include "src/conversions.h"
@@ skipping 76 matching lines @@
 }
 
 PreParserExpression ParserBaseTraits<PreParser>::ExpressionFromString(
     int pos, Scanner* scanner, PreParserFactory* factory) const {
   if (scanner->UnescapedLiteralMatches("use strict", 10)) {
     return PreParserExpression::UseStrictStringLiteral();
   }
   return PreParserExpression::StringLiteral();
 }
 
-PreParserExpression ParserBaseTraits<PreParser>::ParseV8Intrinsic(bool* ok) {
-  return delegate()->ParseV8Intrinsic(ok);
-}
-
-PreParserExpression ParserBaseTraits<PreParser>::ParseFunctionLiteral(
-    PreParserIdentifier name, Scanner::Location function_name_location,
-    FunctionNameValidity function_name_validity, FunctionKind kind,
-    int function_token_position, FunctionLiteral::FunctionType type,
-    LanguageMode language_mode, bool* ok) {
-  return delegate()->ParseFunctionLiteral(
-      name, function_name_location, function_name_validity, kind,
-      function_token_position, type, language_mode, ok);
-}
-
 PreParser::PreParseResult PreParser::PreParseLazyFunction(
     LanguageMode language_mode, FunctionKind kind, bool has_simple_parameters,
     bool parsing_module, ParserRecorder* log, Scanner::BookmarkScope* bookmark,
     int* use_counts) {
   parsing_module_ = parsing_module;
   log_ = log;
   use_counts_ = use_counts;
   // Lazy functions always have trivial outer scopes (no with/catch scopes).
   DCHECK_NULL(scope_state_);
   DeclarationScope* top_scope = NewScriptScope();
@@ skipping 20 matching lines @@
     if (is_strict(scope()->language_mode())) {
       int end_pos = scanner()->location().end_pos;
       CheckStrictOctalLiteral(start_position, end_pos, &ok);
       CheckDecimalLiteralWithLeadingZero(use_counts, start_position, end_pos);
       if (!ok) return kPreParseSuccess;
     }
   }
   return kPreParseSuccess;
 }
 
-PreParserExpression ParserBaseTraits<PreParser>::ParseClassLiteral(
-    Type::ExpressionClassifier* classifier, PreParserIdentifier name,
-    Scanner::Location class_name_location, bool name_is_strict_reserved,
-    int pos, bool* ok) {
-  return delegate()->ParseClassLiteral(classifier, name, class_name_location,
-                                       name_is_strict_reserved, pos, ok);
-}
-
 
 // Preparsing checks a JavaScript program and emits preparse-data that helps
 // a later parsing to be faster.
 // See preparser-data.h for the data.
 
 // 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,
@@ skipping 1098 matching lines @@
   //     do '{' StatementList '}'
   Expect(Token::DO, CHECK_OK);
   Expect(Token::LBRACE, CHECK_OK);
   while (peek() != Token::RBRACE) {
     ParseStatementListItem(CHECK_OK);
   }
   Expect(Token::RBRACE, CHECK_OK);
   return PreParserExpression::Default();
 }
 
-void ParserBaseTraits<PreParser>::ParseAsyncArrowSingleExpressionBody(
+void PreParser::ParseAsyncArrowSingleExpressionBody(
     PreParserStatementList body, bool accept_IN,
-    Type::ExpressionClassifier* classifier, int pos, bool* ok) {
-  Scope* scope = delegate()->scope();
-  scope->ForceContextAllocation();
+    ExpressionClassifier* classifier, int pos, bool* ok) {
+  scope()->ForceContextAllocation();
 
-  PreParserExpression return_value = delegate()->ParseAssignmentExpression(
-      accept_IN, classifier, CHECK_OK_CUSTOM(Void));
+  PreParserExpression return_value =
+      ParseAssignmentExpression(accept_IN, classifier, CHECK_OK_CUSTOM(Void));
 
   body->Add(PreParserStatement::ExpressionStatement(return_value), zone());
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 
 
 }  // namespace internal
 }  // namespace v8