Remove ast_value_factory_ and usages from scope

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 "src/accessors.h"
 #include "src/ast/scopeinfo.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
@@ skipping 65 matching lines @@
   }
   Vector* delegates = static_cast<Vector*>(p->value);
   delegates->push_back(stmt);
 }
 
 
 // ----------------------------------------------------------------------------
 // Implementation of Scope
 
 Scope::Scope(Zone* zone, Scope* outer_scope, ScopeType scope_type,
-             AstValueFactory* ast_value_factory, FunctionKind function_kind)
+             FunctionKind function_kind)
     : inner_scopes_(4, zone),
       variables_(zone),
       temps_(4, zone),
       params_(4, zone),
       unresolved_(nullptr),
       decls_(4, zone),
       module_descriptor_(scope_type == MODULE_SCOPE ? new (zone)
                                                           ModuleDescriptor(zone)
                                                     : NULL),
       sloppy_block_function_map_(zone),
       already_resolved_(false),
-      ast_value_factory_(ast_value_factory),
       zone_(zone) {
   SetDefaults(scope_type, outer_scope, Handle<ScopeInfo>::null(),
               function_kind);
   // The outermost scope must be a script scope.
   DCHECK(scope_type == SCRIPT_SCOPE || outer_scope != NULL);
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
-             Handle<ScopeInfo> scope_info, AstValueFactory* value_factory)
+             Handle<ScopeInfo> scope_info)
     : inner_scopes_(4, zone),
       variables_(zone),
       temps_(4, zone),
       params_(4, zone),
       unresolved_(nullptr),
       decls_(4, zone),
       module_descriptor_(NULL),
       sloppy_block_function_map_(zone),
       already_resolved_(true),
-      ast_value_factory_(value_factory),
       zone_(zone) {
   SetDefaults(scope_type, NULL, scope_info);
   if (!scope_info.is_null()) {
     num_heap_slots_ = scope_info_->ContextLength();
   }
   // Ensure at least MIN_CONTEXT_SLOTS to indicate a materialized context.
   num_heap_slots_ = Max(num_heap_slots_,
                         static_cast<int>(Context::MIN_CONTEXT_SLOTS));
   AddInnerScope(inner_scope);
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope,
-             const AstRawString* catch_variable_name,
-             AstValueFactory* value_factory)
+             const AstRawString* catch_variable_name)
     : inner_scopes_(1, zone),
       variables_(zone),
       temps_(0, zone),
       params_(0, zone),
       unresolved_(nullptr),
       decls_(0, zone),
       module_descriptor_(NULL),
       sloppy_block_function_map_(zone),
       already_resolved_(true),
-      ast_value_factory_(value_factory),
       zone_(zone) {
   SetDefaults(CATCH_SCOPE, NULL, Handle<ScopeInfo>::null());
   AddInnerScope(inner_scope);
   ++num_var_;
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
   Variable* variable = variables_.Declare(this,
                                           catch_variable_name,
                                           VAR,
                                           Variable::NORMAL,
                                           kCreatedInitialized);
   AllocateHeapSlot(variable);
 }
 
 
 void Scope::SetDefaults(ScopeType scope_type, Scope* outer_scope,
                         Handle<ScopeInfo> scope_info,
                         FunctionKind function_kind) {
   outer_scope_ = outer_scope;
   scope_type_ = scope_type;
   is_declaration_scope_ =
       is_eval_scope() || is_function_scope() ||
       is_module_scope() || is_script_scope();
   function_kind_ = function_kind;
-  scope_name_ = ast_value_factory_->empty_string();
+  scope_name_ = nullptr;
   dynamics_ = nullptr;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
   this_function_ = nullptr;
   scope_inside_with_ = false;
   scope_calls_eval_ = false;
   scope_uses_arguments_ = false;
   scope_uses_super_property_ = false;
@@ skipping 23 matching lines @@
   end_position_ = kNoSourcePosition;
   is_hidden_ = false;
   if (!scope_info.is_null()) {
     scope_calls_eval_ = scope_info->CallsEval();
     language_mode_ = scope_info->language_mode();
     is_declaration_scope_ = scope_info->is_declaration_scope();
     function_kind_ = scope_info->function_kind();
   }
 }
 
-
 Scope* Scope::DeserializeScopeChain(Isolate* isolate, Zone* zone,
-                                    Context* context, Scope* script_scope) {
+                                    Context* context, Scope* script_scope,
+                                    AstValueFactory* ast_value_factory) {
   // Reconstruct the outer scope chain from a closure's context chain.
   Scope* current_scope = NULL;
   Scope* innermost_scope = NULL;
   while (!context->IsNativeContext()) {
     if (context->IsWithContext() || context->IsDebugEvaluateContext()) {
       // For scope analysis, debug-evaluate is equivalent to a with scope.
       Scope* with_scope = new (zone)
-          Scope(zone, current_scope, WITH_SCOPE, Handle<ScopeInfo>::null(),
-                script_scope->ast_value_factory_);
+          Scope(zone, current_scope, WITH_SCOPE, Handle<ScopeInfo>::null());
       current_scope = with_scope;
       // All the inner scopes are inside a with.
       for (Scope* s = innermost_scope; s != NULL; s = s->outer_scope()) {
         s->scope_inside_with_ = true;
       }
     } else if (context->IsScriptContext()) {
       ScopeInfo* scope_info = context->scope_info();
       current_scope = new (zone) Scope(zone, current_scope, SCRIPT_SCOPE,
-                                       Handle<ScopeInfo>(scope_info),
-                                       script_scope->ast_value_factory_);
+                                       Handle<ScopeInfo>(scope_info));
     } else if (context->IsFunctionContext()) {
       ScopeInfo* scope_info = context->closure()->shared()->scope_info();
       current_scope = new (zone) Scope(zone, current_scope, FUNCTION_SCOPE,
-                                       Handle<ScopeInfo>(scope_info),
-                                       script_scope->ast_value_factory_);
+                                       Handle<ScopeInfo>(scope_info));
       if (scope_info->IsAsmFunction()) current_scope->asm_function_ = true;
       if (scope_info->IsAsmModule()) current_scope->asm_module_ = true;
     } else if (context->IsBlockContext()) {
       ScopeInfo* scope_info = context->scope_info();
-      current_scope = new (zone)
-          Scope(zone, current_scope, BLOCK_SCOPE, Handle<ScopeInfo>(scope_info),
-                script_scope->ast_value_factory_);
+      current_scope = new (zone) Scope(zone, current_scope, BLOCK_SCOPE,
+                                       Handle<ScopeInfo>(scope_info));
     } else {
       DCHECK(context->IsCatchContext());
       String* name = context->catch_name();
-      current_scope = new (zone) Scope(
-          zone, current_scope,
-          script_scope->ast_value_factory_->GetString(Handle<String>(name)),
-          script_scope->ast_value_factory_);
+      current_scope =
+          new (zone) Scope(zone, current_scope,
+                           ast_value_factory->GetString(handle(name, isolate)));
     }
     if (innermost_scope == NULL) innermost_scope = current_scope;
     context = context->previous();
   }
 
   script_scope->AddInnerScope(current_scope);
   script_scope->PropagateScopeInfo(false);
   return (innermost_scope == NULL) ? script_scope : innermost_scope;
 }
 
@@ skipping 30 matching lines @@
   scope->CheckScopePositions();
 #endif
 
   info->set_scope(scope);
   return true;
 }
 
 
 void Scope::Initialize() {
   DCHECK(!already_resolved());
-
-  // Add this scope as a new inner scope of the outer scope.
-  if (outer_scope_ != NULL) {
+  if (outer_scope_ == nullptr) {
+    scope_inside_with_ = is_with_scope();
+  } else {
     outer_scope_->inner_scopes_.Add(this, zone());
     scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
-  } else {
-    scope_inside_with_ = is_with_scope();
-  }
-
-  // Declare convenience variables and the receiver.
-  if (is_declaration_scope() && has_this_declaration()) {
-    bool subclass_constructor = IsSubclassConstructor(function_kind_);
-    Variable* var = variables_.Declare(
-        this, ast_value_factory_->this_string(),
-        subclass_constructor ? CONST : VAR, Variable::THIS,
-        subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
-    receiver_ = var;
-  }
-
-  if (is_function_scope() && !is_arrow_scope()) {
-    // Declare 'arguments' variable which exists in all non arrow functions.
-    // Note that it might never be accessed, in which case it won't be
-    // allocated during variable allocation.
-    arguments_ =
-        variables_.Declare(this, ast_value_factory_->arguments_string(), VAR,
-                           Variable::ARGUMENTS, kCreatedInitialized);
-
-    new_target_ =
-        variables_.Declare(this, ast_value_factory_->new_target_string(), CONST,
-                           Variable::NORMAL, kCreatedInitialized);
-
-    if (IsConciseMethod(function_kind_) || IsClassConstructor(function_kind_) ||
-        IsAccessorFunction(function_kind_)) {
-      this_function_ =
-          variables_.Declare(this, ast_value_factory_->this_function_string(),
-                             CONST, Variable::NORMAL, kCreatedInitialized);
-    }
   }
 }
 
+void Scope::DeclareThis(AstValueFactory* ast_value_factory) {
+  DCHECK(!already_resolved());
+  DCHECK(is_declaration_scope());
+  DCHECK(has_this_declaration());
+
+  bool subclass_constructor = IsSubclassConstructor(function_kind_);
+  Variable* var = variables_.Declare(
+      this, ast_value_factory->this_string(),
+      subclass_constructor ? CONST : VAR, Variable::THIS,
+      subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
+  receiver_ = var;
+}
+
+void Scope::DeclareDefaultFunctionVariables(
+    AstValueFactory* ast_value_factory) {
+  DCHECK(is_function_scope());
+  DCHECK(!is_arrow_scope());
+  // Declare 'arguments' variable which exists in all non arrow functions.
+  // Note that it might never be accessed, in which case it won't be
+  // allocated during variable allocation.
+  arguments_ =
+      variables_.Declare(this, ast_value_factory->arguments_string(), VAR,
+                         Variable::ARGUMENTS, kCreatedInitialized);
+
+  new_target_ =
+      variables_.Declare(this, ast_value_factory->new_target_string(), CONST,
+                         Variable::NORMAL, kCreatedInitialized);
+
+  if (IsConciseMethod(function_kind_) || IsClassConstructor(function_kind_) ||
+      IsAccessorFunction(function_kind_)) {
+    this_function_ =
+        variables_.Declare(this, ast_value_factory->this_function_string(),
+                           CONST, Variable::NORMAL, kCreatedInitialized);
+  }
+}
+
 
 Scope* Scope::FinalizeBlockScope() {
   DCHECK(is_block_scope());
   DCHECK(temps_.is_empty());
   DCHECK(params_.is_empty());
 
   if (num_var() > 0 || (is_declaration_scope() && calls_sloppy_eval())) {
     return this;
   }
 
@@ skipping 1201 matching lines @@
       function_ != NULL && function_->proxy()->var()->IsContextSlot();
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS - num_global_slots() -
          (is_function_var_in_context ? 1 : 0);
 }
 
 
 int Scope::ContextGlobalCount() const { return num_global_slots(); }
 
 }  // namespace internal
 }  // namespace v8