Remove synthetic unresolved variables from async/await desugaring

src/parsing/parser.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/parsing/parser.h"
 
 #include <memory>
 
 #include "src/api.h"
 #include "src/ast/ast-expression-rewriter.h"
@@ skipping 3344 matching lines @@
       if (param_scope != nullptr) {
         CheckConflictingVarDeclarations(param_scope, CHECK_OK);
       }
       init_block->statements()->Add(param_block, zone());
     }
   }
   return init_block;
 }
 
 Block* Parser::BuildRejectPromiseOnException(Block* inner_block, bool* ok) {
-  // var .promise = %CreatePromise();
-  // var .debug_is_active = %_DebugIsActive();
+  // .promise = %CreatePromise();
+  // .debug_is_active = %_DebugIsActive();
   // if (.debug_is_active) %DebugPushPromise(.promise);
   // try {
   //   <inner_block>
   // } catch (.catch) {
   //   %RejectPromise(.promise, .catch);
   //   return .promise;
   // } finally {
   //   if (.debug_is_active) %DebugPopPromise();
   // }
   Block* result = factory()->NewBlock(nullptr, 4, true, kNoSourcePosition);
 
-  // var .promise = %CreatePromise();
+  // .promise = %CreatePromise();
   Statement* set_promise;
   {
-    DeclareVariable(ast_value_factory()->dot_promise_string(), VAR,
-                    kNoSourcePosition, CHECK_OK);
     Expression* create_promise = factory()->NewCallRuntime(
         Context::PROMISE_CREATE_INDEX,
         new (zone()) ZoneList<Expression*>(0, zone()), kNoSourcePosition);
     Assignment* assign_promise = factory()->NewAssignment(
-        Token::INIT, BuildDotPromise(), create_promise, kNoSourcePosition);
+        Token::INIT, factory()->NewVariableProxy(PromiseVariable()),
+        create_promise, kNoSourcePosition);
     set_promise =
         factory()->NewExpressionStatement(assign_promise, kNoSourcePosition);
   }
   result->statements()->Add(set_promise, zone());
 
-  // var .debug_is_active = %_DebugIsActive();
+  Variable* debug_is_active =
+      scope()->NewTemporary(ast_value_factory()->empty_string());
+  // .debug_is_active = %_DebugIsActive();
   Statement* set_debug_is_active;
   {
-    DeclareVariable(ast_value_factory()->dot_debug_is_active_string(), VAR,
-                    kNoSourcePosition, CHECK_OK);
-    Expression* debug_is_active = factory()->NewCallRuntime(
+    Expression* call_debug_is_active = factory()->NewCallRuntime(
         Runtime::kInlineDebugIsActive,
         new (zone()) ZoneList<Expression*>(0, zone()), kNoSourcePosition);
-    Assignment* assign_debug_is_active =
-        factory()->NewAssignment(Token::INIT, BuildDotDebugIsActive(),
-                                 debug_is_active, kNoSourcePosition);
+    Assignment* assign_debug_is_active = factory()->NewAssignment(
+        Token::INIT, factory()->NewVariableProxy(debug_is_active),
+        call_debug_is_active, kNoSourcePosition);
     set_debug_is_active = factory()->NewExpressionStatement(
         assign_debug_is_active, kNoSourcePosition);
   }
   result->statements()->Add(set_debug_is_active, zone());
 
   //   if (.debug_is_active) %DebugPushPromise(.promise);
   Statement* conditionally_debug_push_promise;
   {
     ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(1, zone());
-    args->Add(BuildDotPromise(), zone());
+    args->Add(factory()->NewVariableProxy(PromiseVariable()), zone());
     Expression* call_push_promise = factory()->NewCallRuntime(
         Runtime::kDebugPushPromise, args, kNoSourcePosition);
     Statement* debug_push_promise =
         factory()->NewExpressionStatement(call_push_promise, kNoSourcePosition);
     conditionally_debug_push_promise = factory()->NewIfStatement(
-        BuildDotDebugIsActive(), debug_push_promise,
+        factory()->NewVariableProxy(debug_is_active), debug_push_promise,
         factory()->NewEmptyStatement(kNoSourcePosition), kNoSourcePosition);
   }
   result->statements()->Add(conditionally_debug_push_promise, zone());
 
   // catch (.catch) { return %RejectPromise(.promise, .catch), .promise }
   Scope* catch_scope = NewScope(CATCH_SCOPE);
   catch_scope->set_is_hidden();
   Variable* catch_variable =
       catch_scope->DeclareLocal(ast_value_factory()->dot_catch_string(), VAR,
                                 kCreatedInitialized, NORMAL_VARIABLE);
@@ skipping 18 matching lines @@
   // finally { if (.debug_is_active) %DebugPopPromise(); }
   Block* finally_block =
       factory()->NewBlock(nullptr, 1, true, kNoSourcePosition);
   {
     ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(0, zone());
     Expression* call_pop_promise = factory()->NewCallRuntime(
         Runtime::kDebugPopPromise, args, kNoSourcePosition);
     Statement* debug_pop_promise =
         factory()->NewExpressionStatement(call_pop_promise, kNoSourcePosition);
     Statement* conditionally_debug_pop_promise = factory()->NewIfStatement(
-        BuildDotDebugIsActive(), debug_pop_promise,
+        factory()->NewVariableProxy(debug_is_active), debug_pop_promise,
         factory()->NewEmptyStatement(kNoSourcePosition), kNoSourcePosition);
     finally_block->statements()->Add(conditionally_debug_pop_promise, zone());
   }
 
   Statement* try_finally_statement = factory()->NewTryFinallyStatement(
       outer_try_block, finally_block, kNoSourcePosition);
 
   result->statements()->Add(try_finally_statement, zone());
   return result;
 }
 
 Expression* Parser::BuildCreateJSGeneratorObject(int pos, FunctionKind kind) {
   DCHECK_NOT_NULL(function_state_->generator_object_variable());
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
   args->Add(factory()->NewThisFunction(pos), zone());
   args->Add(IsArrowFunction(kind) ? GetLiteralUndefined(pos)
                                   : ThisExpression(kNoSourcePosition),
             zone());
   return factory()->NewCallRuntime(Runtime::kCreateJSGeneratorObject, args,
                                    pos);
 }
 
 Expression* Parser::BuildResolvePromise(Expression* value, int pos) {
   // %ResolvePromise(.promise, value), .promise
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
-  args->Add(BuildDotPromise(), zone());
+  args->Add(factory()->NewVariableProxy(PromiseVariable()), zone());
   args->Add(value, zone());
   Expression* call_runtime =
       factory()->NewCallRuntime(Context::PROMISE_RESOLVE_INDEX, args, pos);
-  return factory()->NewBinaryOperation(Token::COMMA, call_runtime,
-                                       BuildDotPromise(), pos);
+  return factory()->NewBinaryOperation(
+      Token::COMMA, call_runtime,
+      factory()->NewVariableProxy(PromiseVariable()), pos);
 }
 
 Expression* Parser::BuildRejectPromise(Expression* value, int pos) {
   // %RejectPromiseNoDebugEvent(.promise, value, true), .promise
   // The NoDebugEvent variant disables the additional debug event for the
   // rejection since a debug event already happened for the exception that got
   // us here.
   ZoneList<Expression*>* args = new (zone()) ZoneList<Expression*>(2, zone());
-  args->Add(BuildDotPromise(), zone());
+  args->Add(factory()->NewVariableProxy(PromiseVariable()), zone());
   args->Add(value, zone());
   Expression* call_runtime = factory()->NewCallRuntime(
       Context::REJECT_PROMISE_NO_DEBUG_EVENT_INDEX, args, pos);
-  return factory()->NewBinaryOperation(Token::COMMA, call_runtime,
-                                       BuildDotPromise(), pos);
+  return factory()->NewBinaryOperation(
+      Token::COMMA, call_runtime,
+      factory()->NewVariableProxy(PromiseVariable()), pos);
 }
 
-VariableProxy* Parser::BuildDotPromise() {
-  return NewUnresolved(ast_value_factory()->dot_promise_string(), VAR);
-}
-
-VariableProxy* Parser::BuildDotDebugIsActive() {
-  return NewUnresolved(ast_value_factory()->dot_debug_is_active_string(), VAR);
+Variable* Parser::PromiseVariable() {
+  // Based on the various compilation paths, there are many different code
+  // paths which may be the first to access the Promise temporary. Whichever
+  // comes first should create it and stash it in the FunctionState.
+  Variable* promise = function_state_->promise_variable();
+  if (function_state_->promise_variable() == nullptr) {
+    promise = scope()->NewTemporary(ast_value_factory()->empty_string());
+    function_state_->set_promise_variable(promise);
+  }
+  return promise;
 }
 
 ZoneList<Statement*>* Parser::ParseEagerFunctionBody(
     const AstRawString* function_name, int pos,
     const ParserFormalParameters& parameters, FunctionKind kind,
     FunctionLiteral::FunctionType function_type, bool* ok) {
   // Everything inside an eagerly parsed function will be parsed eagerly
   // (see comment above).
   ParsingModeScope parsing_mode(this, PARSE_EAGERLY);
   ZoneList<Statement*>* result = new(zone()) ZoneList<Statement*>(8, zone());
@@ skipping 1033 matching lines @@
   Expression* expr = args->at(0);
   for (int i = 1; i < args->length(); ++i) {
     expr = factory()->NewBinaryOperation(Token::COMMA, expr, args->at(i),
                                          expr->position());
   }
   return expr;
 }
 
 Expression* Parser::RewriteAwaitExpression(Expression* value, int await_pos) {
   // yield do {
-  //   promise_tmp = .promise;
   //   tmp = <operand>;
-  //   %AsyncFunctionAwait(.generator_object, tmp, promise_tmp);
-  //   promise_tmp
+  //   %AsyncFunctionAwait(.generator_object, tmp, .promise);
+  //   .promise
   // }
   // The value of the expression is returned to the caller of the async
   // function for the first yield statement; for this, .promise is the
   // appropriate return value, being a Promise that will be fulfilled or
   // rejected with the appropriate value by the desugaring. Subsequent yield
   // occurrences will return to the AsyncFunctionNext call within the
   // implemementation of the intermediate throwaway Promise's then handler.
   // This handler has nothing useful to do with the value, as the Promise is
   // ignored. If we yielded the value of the throwawayPromise that
   // AsyncFunctionAwait creates as an intermediate, it would create a memory
   // leak; we must return .promise instead;
   // The operand needs to be evaluated on a separate statement in order to get
   // a break location, and the .promise needs to be read earlier so that it
   // doesn't insert a false location.
   // TODO(littledan): investigate why this ordering is needed in more detail.
   Variable* generator_object_variable =
       function_state_->generator_object_variable();
 
   // If generator_object_variable is null,
   // TODO(littledan): Is this necessary?
   if (!generator_object_variable) return value;
 
   const int nopos = kNoSourcePosition;
 
-  Block* do_block = factory()->NewBlock(nullptr, 3, false, nopos);
+  Block* do_block = factory()->NewBlock(nullptr, 2, false, nopos);
 
-  Variable* promise_temp_var =
-      NewTemporary(ast_value_factory()->empty_string());
-  Expression* promise_assignment = factory()->NewAssignment(
-      Token::ASSIGN, factory()->NewVariableProxy(promise_temp_var),
-      BuildDotPromise(), nopos);
-  do_block->statements()->Add(
-      factory()->NewExpressionStatement(promise_assignment, nopos), zone());
+  Variable* promise = PromiseVariable();
 
   // Wrap value evaluation to provide a break location.
   Variable* temp_var = NewTemporary(ast_value_factory()->empty_string());
   Expression* value_assignment = factory()->NewAssignment(
       Token::ASSIGN, factory()->NewVariableProxy(temp_var), value, nopos);
   do_block->statements()->Add(
       factory()->NewExpressionStatement(value_assignment, value->position()),
       zone());
 
   ZoneList<Expression*>* async_function_await_args =
       new (zone()) ZoneList<Expression*>(3, zone());
   Expression* generator_object =
       factory()->NewVariableProxy(generator_object_variable);
   async_function_await_args->Add(generator_object, zone());
   async_function_await_args->Add(factory()->NewVariableProxy(temp_var), zone());
-  async_function_await_args->Add(factory()->NewVariableProxy(promise_temp_var),
-                                 zone());
+  async_function_await_args->Add(factory()->NewVariableProxy(promise), zone());
 
   // The parser emits calls to AsyncFunctionAwaitCaught, but the
   // AstNumberingVisitor will rewrite this to AsyncFunctionAwaitUncaught
   // if there is no local enclosing try/catch block.
   Expression* async_function_await =
       factory()->NewCallRuntime(Context::ASYNC_FUNCTION_AWAIT_CAUGHT_INDEX,
                                 async_function_await_args, nopos);
   do_block->statements()->Add(
       factory()->NewExpressionStatement(async_function_await, await_pos),
       zone());
 
   // Wrap await to provide a break location between value evaluation and yield.
-  Expression* do_expr =
-      factory()->NewDoExpression(do_block, promise_temp_var, nopos);
+  Expression* do_expr = factory()->NewDoExpression(do_block, promise, nopos);
 
   generator_object = factory()->NewVariableProxy(generator_object_variable);
   return factory()->NewYield(generator_object, do_expr, nopos,
                              Yield::kOnExceptionRethrow);
 }
 
 class NonPatternRewriter : public AstExpressionRewriter {
  public:
   NonPatternRewriter(uintptr_t stack_limit, Parser* parser)
       : AstExpressionRewriter(stack_limit), parser_(parser) {}
@@ skipping 1186 matching lines @@
 
   return final_loop;
 }
 
 #undef CHECK_OK
 #undef CHECK_OK_VOID
 #undef CHECK_FAILED
 
 }  // namespace internal
 }  // namespace v8