[ignition] desugar async functions/generators/modules in BytecodeGenerator

src/ast/scopes.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/scopes.h"
 
 #include <set>
 
 #include "src/accessors.h"
 #include "src/ast/ast.h"
@@ skipping 280 matching lines @@
   asm_function_ = false;
   force_eager_compilation_ = false;
   has_arguments_parameter_ = false;
   scope_uses_super_property_ = false;
   has_rest_ = false;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
   this_function_ = nullptr;
+  generator_object_ = nullptr;
+  promise_ = nullptr;
   should_eager_compile_ = false;
   was_lazily_parsed_ = false;
 #ifdef DEBUG
   DeclarationScope* outer_declaration_scope =
       outer_scope_ ? outer_scope_->GetDeclarationScope() : nullptr;
   is_being_lazily_parsed_ =
       outer_declaration_scope ? outer_declaration_scope->is_being_lazily_parsed_
                               : false;
 #endif
 }
@@ skipping 385 matching lines @@
   function_ =
       new (zone()) Variable(this, name, CONST, kind, kCreatedInitialized);
   if (calls_sloppy_eval()) {
     NonLocal(name, DYNAMIC);
   } else {
     variables_.Add(zone(), function_);
   }
   return function_;
 }
 
+Variable* DeclarationScope::DeclareGeneratorObjectVar(
+    const AstRawString* name) {
+  DCHECK(is_function_scope() || is_module_scope());
+  DCHECK_NULL(generator_object_);
+  generator_object_ = NewTemporary(name);
+  return generator_object_;
+}
+
+Variable* DeclarationScope::DeclarePromiseVar(const AstRawString* name) {
+  DCHECK(is_function_scope());
+  DCHECK_NULL(promise_);
+  promise_ = NewTemporary(name);
+  return promise_;
+}
+
 bool Scope::HasBeenRemoved() const {
   if (sibling() == this) {
     DCHECK_NULL(inner_scope_);
     DCHECK(is_block_scope());
     return true;
   }
   return false;
 }
 
 Scope* Scope::GetUnremovedScope() {
@@ skipping 634 matching lines @@
 }
 
 Scope* Scope::GetOuterScopeWithContext() {
   Scope* scope = outer_scope_;
   while (scope && !scope->NeedsContext()) {
     scope = scope->outer_scope();
   }
   return scope;
 }
 
+bool Scope::HasLazilyParsedInnerFunctionScope() const {
+  for (Scope* scope = inner_scope_; scope; scope = scope->sibling_) {
+    if (scope->is_function_scope()) {
+      DCHECK(scope->is_declaration_scope_);
+      if (static_cast<DeclarationScope*>(scope)->was_lazily_parsed()) {
+        return true;
+      }
+      if (scope->HasLazilyParsedInnerFunctionScope()) return true;
+    }
+  }
+  return false;
+}
+
 Handle<StringSet> DeclarationScope::CollectNonLocals(
     ParseInfo* info, Handle<StringSet> non_locals) {
   VariableProxy* free_variables = FetchFreeVariables(this, info);
   for (VariableProxy* proxy = free_variables; proxy != nullptr;
        proxy = proxy->next_unresolved()) {
     non_locals = StringSet::Add(non_locals, proxy->name());
   }
   return non_locals;
 }
 
@@ skipping 862 matching lines @@
   Variable* function =
       is_function_scope() ? AsDeclarationScope()->function_var() : nullptr;
   bool is_function_var_in_context =
       function != nullptr && function->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
          (is_function_var_in_context ? 1 : 0);
 }
 
 }  // namespace internal
 }  // namespace v8