[async await] fix async await desugaring

src/parsing/parser-base.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_BASE_H
 #define V8_PARSING_PARSER_BASE_H
 
 #include "src/ast/ast.h"
 #include "src/ast/scopes.h"
 #include "src/bailout-reason.h"
@@ skipping 420 matching lines @@
       DCHECK_NOT_NULL(variable);
       DCHECK(IsResumableFunction(kind()));
       DCHECK(scope()->has_forced_context_allocation());
       generator_object_variable_ = variable;
     }
     typename Types::Variable* generator_object_variable() const {
       return generator_object_variable_;
     }
 
     void set_promise_variable(typename Types::Variable* variable) {
-      DCHECK(variable != NULL);
+      DCHECK_NOT_NULL(variable);
       DCHECK(IsAsyncFunction(kind()));
       promise_variable_ = variable;
     }
     typename Types::Variable* promise_variable() const {
       return promise_variable_;
     }
 
+    void set_async_return_variable(typename Types::Variable* variable) {
+      DCHECK_NOT_NULL(variable);
+      DCHECK(IsAsyncFunction(kind()));
+      async_return_variable_ = variable;
+    }
+    typename Types::Variable* async_return_variable() const {
+      return async_return_variable_;
+    }
+
     const ZoneList<DestructuringAssignment>&
         destructuring_assignments_to_rewrite() const {
       return destructuring_assignments_to_rewrite_;
     }
 
     TailCallExpressionList& tail_call_expressions() {
       return tail_call_expressions_;
     }
     void AddImplicitTailCallExpression(ExpressionT expression) {
       if (return_expr_context() ==
@@ skipping 49 matching lines @@
     // Properties count estimation.
     int expected_property_count_;
 
     // For generators, this variable may hold the generator object. It variable
     // is used by yield expressions and return statements. It is not necessary
     // for generator functions to have this variable set.
     Variable* generator_object_variable_;
     // For async functions, this variable holds a temporary for the Promise
     // being created as output of the async function.
     Variable* promise_variable_;
+    Variable* async_return_variable_;
+    Variable* is_rejection_variable_;
 
     FunctionState** function_state_stack_;
     FunctionState* outer_function_state_;
 
     ZoneList<DestructuringAssignment> destructuring_assignments_to_rewrite_;
     TailCallExpressionList tail_call_expressions_;
     ReturnExprContext return_expr_context_;
     ZoneList<ExpressionT> non_patterns_to_rewrite_;
 
     ZoneList<typename ExpressionClassifier::Error> reported_errors_;
@@ skipping 983 matching lines @@
 
 template <typename Impl>
 ParserBase<Impl>::FunctionState::FunctionState(
     FunctionState** function_state_stack, ScopeState** scope_stack,
     DeclarationScope* scope)
     : ScopeState(scope_stack, scope),
       next_materialized_literal_index_(0),
       expected_property_count_(0),
       generator_object_variable_(nullptr),
       promise_variable_(nullptr),
+      async_return_variable_(nullptr),
+      is_rejection_variable_(nullptr),
       function_state_stack_(function_state_stack),
       outer_function_state_(*function_state_stack),
       destructuring_assignments_to_rewrite_(16, scope->zone()),
       tail_call_expressions_(scope->zone()),
       return_expr_context_(ReturnExprContext::kInsideValidBlock),
       non_patterns_to_rewrite_(0, scope->zone()),
       reported_errors_(16, scope->zone()),
       next_function_is_likely_called_(false),
       previous_function_was_likely_called_(false) {
   *function_state_stack = this;
@@ skipping 2516 matching lines @@
     impl()->SetLanguageMode(function_scope, inner_scope->language_mode());
     BlockT init_block =
         impl()->BuildParameterInitializationBlock(parameters, CHECK_OK_VOID);
 
     if (is_sloppy(inner_scope->language_mode())) {
       impl()->InsertSloppyBlockFunctionVarBindings(inner_scope);
     }
 
     // TODO(littledan): Merge the two rejection blocks into one
     if (IsAsyncFunction(kind)) {
-      init_block = impl()->BuildRejectPromiseOnException(init_block);
+      init_block =
+          impl()->BuildRejectPromiseOnExceptionForParameters(init_block);
     }
 
     inner_scope->set_end_position(scanner()->location().end_pos);
     if (inner_scope->FinalizeBlockScope() != nullptr) {
       impl()->CheckConflictingVarDeclarations(inner_scope, CHECK_OK_VOID);
       impl()->InsertShadowingVarBindingInitializers(inner_block);
     }
     inner_scope = nullptr;
 
     result->Add(init_block, zone());
@@ skipping 1706 matching lines @@
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_CUSTOM
 #undef CHECK_OK_VOID
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_PARSING_PARSER_BASE_H