[async-functions] support await expressions in finally statements

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/ast.h"
 #include "src/ast/scopes.h"
 #include "src/parsing/parser-base.h"
@@ skipping 105 matching lines @@
 
   explicit PreParserIdentifier(Type type) : type_(type), string_(nullptr) {}
   Type type_;
   // Only non-nullptr when PreParser.track_unresolved_variables_ is true.
   const AstRawString* string_;
   friend class PreParserExpression;
   friend class PreParser;
   friend class PreParserFactory;
 };
 
-
+class PreParserStatement;
 class PreParserExpression {
  public:
   PreParserExpression()
       : code_(TypeField::encode(kEmpty)), variables_(nullptr) {}
 
   static PreParserExpression Empty() { return PreParserExpression(); }
 
   static PreParserExpression Default(
       ZoneList<VariableProxy*>* variables = nullptr) {
     return PreParserExpression(TypeField::encode(kExpression), variables);
@@ skipping 193 matching lines @@
   // and PreParser.
   PreParserExpression* operator->() { return this; }
 
   // More dummy implementations of things PreParser doesn't need to track:
   void set_index(int index) {}  // For YieldExpressions
   void SetShouldEagerCompile() {}
   void set_should_be_used_once_hint() {}
 
   int position() const { return kNoSourcePosition; }
   void set_function_token_position(int position) {}
+  void set_parameter_init_block(PreParserStatement block);
 
  private:
   enum Type {
     kEmpty,
     kExpression,
     kIdentifierExpression,
     kStringLiteralExpression,
     kSpreadExpression,
     kObjectLiteralExpression,
     kArrayLiteralExpression
@@ skipping 177 matching lines @@
     kJumpStatement,
     kStringLiteralExpressionStatement,
     kUseStrictExpressionStatement,
     kUseAsmExpressionStatement,
   };
 
   explicit PreParserStatement(Type code) : code_(code) {}
   Type code_;
 };
 
+V8_INLINE void PreParserExpression::set_parameter_init_block(
+    PreParserStatement block) {}
 
 class PreParserFactory {
  public:
   explicit PreParserFactory(AstValueFactory* ast_value_factory)
       : ast_value_factory_(ast_value_factory),
         zone_(ast_value_factory->zone()) {}
 
   void set_zone(Zone* zone) { zone_ = zone; }
 
   PreParserExpression NewStringLiteral(PreParserIdentifier identifier,
@@ skipping 79 matching lines @@
     return expression;
   }
   PreParserExpression NewAssignment(Token::Value op,
                                     PreParserExpression left,
                                     PreParserExpression right,
                                     int pos) {
     // Identifiers need to be tracked since this might be a parameter with a
     // default value inside an arrow function parameter list.
     return PreParserExpression::Assignment(left.variables_);
   }
-  PreParserExpression NewYield(PreParserExpression generator_object,
-                               PreParserExpression expression, int pos,
-                               Yield::OnException on_exception) {
+  PreParserExpression NewYield(PreParserExpression expression, int pos,
+                               Yield::OnException on_exception,
+                               Yield::YieldType type) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewConditional(PreParserExpression condition,
                                      PreParserExpression then_expression,
                                      PreParserExpression else_expression,
                                      int pos) {
     return PreParserExpression::Default();
   }
   PreParserExpression NewCountOperation(Token::Value op,
                                         bool is_prefix,
@@ skipping 353 matching lines @@
   V8_INLINE PreParserExpression
   RewriteAwaitExpression(PreParserExpression value, int pos) {
     return value;
   }
   V8_INLINE void PrepareAsyncFunctionBody(PreParserStatementList body,
                                           FunctionKind kind, int pos) {}
   V8_INLINE void RewriteAsyncFunctionBody(PreParserStatementList body,
                                           PreParserStatement block,
                                           PreParserExpression return_value,
                                           bool* ok) {}
-  V8_INLINE PreParserExpression RewriteYieldStar(PreParserExpression generator,
-                                                 PreParserExpression expression,
+  V8_INLINE PreParserExpression RewriteYieldStar(PreParserExpression expression,
                                                  int pos) {
     return PreParserExpression::Default();
   }
   V8_INLINE void RewriteNonPattern(bool* ok) { ValidateExpression(ok); }
 
   void DeclareAndInitializeVariables(
       PreParserStatement block,
       const DeclarationDescriptor* declaration_descriptor,
       const DeclarationParsingResult::Declaration* declaration,
       ZoneList<const AstRawString*>* names, bool* ok);
@@ skipping 42 matching lines @@
   V8_INLINE PreParserStatement RewriteTryStatement(
       PreParserStatement try_block, PreParserStatement catch_block,
       PreParserStatement finally_block, const CatchInfo& catch_info, int pos) {
     return PreParserStatement::Default();
   }
 
   V8_INLINE void ParseAndRewriteGeneratorFunctionBody(
       int pos, FunctionKind kind, PreParserStatementList body, bool* ok) {
     ParseStatementList(body, Token::RBRACE, ok);
   }
-  V8_INLINE void CreateFunctionNameAssignment(
+  V8_INLINE void CreateFunctionNameVariable(
       PreParserIdentifier function_name, int pos,
       FunctionLiteral::FunctionType function_type,
-      DeclarationScope* function_scope, PreParserStatementList result,
-      int index) {}
+      DeclarationScope* function_scope) {}
 
   V8_INLINE PreParserExpression RewriteDoExpression(PreParserStatement body,
                                                     int pos, bool* ok) {
     return PreParserExpression::Default();
   }
 
   // TODO(nikolaos): The preparser currently does not keep track of labels
   // and targets.
   V8_INLINE PreParserStatement LookupBreakTarget(PreParserIdentifier label,
                                                  bool* ok) {
@@ skipping 433 matching lines @@
   NewV8Intrinsic(PreParserIdentifier name, PreParserExpressionList arguments,
                  int pos, bool* ok) {
     return PreParserExpression::Default();
   }
 
   V8_INLINE PreParserStatement NewThrowStatement(PreParserExpression exception,
                                                  int pos) {
     return PreParserStatement::Jump();
   }
 
-  V8_INLINE void AddParameterInitializationBlock(
-      const PreParserFormalParameters& parameters, PreParserStatementList body,
-      bool is_async, bool* ok) {}
-
   V8_INLINE void AddFormalParameter(PreParserFormalParameters* parameters,
                                     PreParserExpression pattern,
                                     PreParserExpression initializer,
                                     int initializer_end_position,
                                     bool is_rest) {
     if (track_unresolved_variables_) {
       DCHECK(FLAG_lazy_inner_functions);
       parameters->params.Add(new (zone())
                                  PreParserFormalParameters::Parameter(pattern));
     }
@@ skipping 103 matching lines @@
     function_state_->NextMaterializedLiteralIndex();
     function_state_->NextMaterializedLiteralIndex();
   }
   return EmptyExpression();
 }
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PREPARSER_H