[async-functions] support await expressions in finally statements

src/ast/ast-numbering.cc

 // 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.
 
 #include "src/ast/ast-numbering.h"
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/objects-inl.h"
@@ skipping 202 matching lines @@
   IncrementNodeCount();
   Visit(node->expression());
 }
 
 
 void AstNumberingVisitor::VisitYield(Yield* node) {
   node->set_yield_id(yield_count_);
   yield_count_++;
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Yield::num_ids()));
-  Visit(node->generator_object());
   Visit(node->expression());
 }
 
 
 void AstNumberingVisitor::VisitThrow(Throw* node) {
   IncrementNodeCount();
   node->set_base_id(ReserveIdRange(Throw::num_ids()));
   Visit(node->exception());
 }
 
@@ skipping 181 matching lines @@
 }
 
 void AstNumberingVisitor::VisitGetIterator(GetIterator* node) {
   IncrementNodeCount();
   DisableFullCodegenAndCrankshaft(kGetIterator);
   node->set_base_id(ReserveIdRange(GetIterator::num_ids()));
   Visit(node->iterable());
   ReserveFeedbackSlots(node);
 }
 
+void AstNumberingVisitor::VisitInternalVariable(InternalVariable* node) {
+  IncrementNodeCount();
+  DisableFullCodegenAndCrankshaft(kNoReason);
+}
+
 void AstNumberingVisitor::VisitForInStatement(ForInStatement* node) {
   IncrementNodeCount();
   DisableSelfOptimization();
   node->set_base_id(ReserveIdRange(ForInStatement::num_ids()));
   Visit(node->enumerable());  // Not part of loop.
   node->set_first_yield_id(yield_count_);
   Visit(node->each());
   Visit(node->body());
   node->set_yield_count(yield_count_ - node->first_yield_id());
   ReserveFeedbackSlots(node);
@@ skipping 199 matching lines @@
   }
 
   if (IsResumableFunction(node->kind())) {
     DisableFullCodegenAndCrankshaft(kGenerator);
   }
 
   if (IsClassConstructor(node->kind())) {
     DisableFullCodegenAndCrankshaft(kClassConstructorFunction);
   }
 
+  if (scope->is_function_scope()) {
+    Variable* function_var = scope->function_var();
+    if (function_var != nullptr && !function_var->IsUnallocated()) {
+      // Initialization of local function-named variable is no longer part of
+      // the AST, and this initialization is not handled in full-codegen or
+      // crankshaft.
+      DisableFullCodegenAndCrankshaft(kNoReason);
+    }
+  }
+
+  if (IsGeneratorFunction(node->kind()) || scope->is_module_scope()) {
+    // Generator functions and Modules have an initial yield which is not
+    // included in the AST.
+    DCHECK_EQ(0, yield_count_);
+    yield_count_ = 1;
+  }
+
   VisitDeclarations(scope->declarations());
+  if (node->parameter_init_block() != nullptr) {
+    DisableFullCodegenAndCrankshaft(kNonSimpleParameters);
+    VisitBlock(node->parameter_init_block());
+  }
   VisitStatements(node->body());
 
   node->set_ast_properties(&properties_);
   node->set_dont_optimize_reason(dont_optimize_reason());
   node->set_yield_count(yield_count_);
 
   if (FLAG_trace_opt) {
     if (disable_crankshaft_reason_ != kNoReason) {
       // TODO(leszeks): This is a quick'n'dirty fix to allow the debug name of
       // the function to be accessed in the below print. This DCHECK will fail
@@ skipping 16 matching lines @@
     Compiler::EagerInnerFunctionLiterals* eager_literals) {
   DisallowHeapAllocation no_allocation;
   DisallowHandleAllocation no_handles;
   DisallowHandleDereference no_deref;
 
   AstNumberingVisitor visitor(stack_limit, zone, eager_literals);
   return visitor.Renumber(function);
 }
 }  // namespace internal
 }  // namespace v8