Introduce ModuleScope subclass of DeclarationScope

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/bootstrapper.h"
@@ skipping 93 matching lines @@
 
 DeclarationScope::DeclarationScope(Zone* zone, Scope* outer_scope,
                                    ScopeType scope_type,
                                    FunctionKind function_kind)
     : Scope(zone, outer_scope, scope_type),
       function_kind_(function_kind),
       temps_(4, zone),
       params_(4, zone),
       sloppy_block_function_map_(zone) {
   SetDefaults();
-  if (scope_type == MODULE_SCOPE) {
-    module_descriptor_ = new (zone) ModuleDescriptor(zone);
-    language_mode_ = STRICT;
-  }
+}
+
+ModuleScope::ModuleScope(Zone* zone, DeclarationScope* script_scope,
+                         AstValueFactory* ast_value_factory)
+    : DeclarationScope(zone, script_scope, MODULE_SCOPE) {
+  module_descriptor_ = new (zone) ModuleDescriptor(zone);
+  set_language_mode(STRICT);
+  DeclareThis(ast_value_factory);
 }
 
 Scope::Scope(Zone* zone, Scope* inner_scope, ScopeType scope_type,
              Handle<ScopeInfo> scope_info)
     : zone_(zone),
       outer_scope_(nullptr),
       variables_(zone),
       decls_(0, zone),
       scope_info_(scope_info),
       scope_type_(scope_type) {
@@ skipping 46 matching lines @@
   is_declaration_scope_ = true;
   has_simple_parameters_ = true;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
   this_function_ = nullptr;
   arity_ = 0;
   rest_parameter_ = nullptr;
   rest_index_ = -1;
-  module_descriptor_ = nullptr;
 }
 
 void Scope::SetDefaults() {
 #ifdef DEBUG
   scope_name_ = nullptr;
   already_resolved_ = false;
 #endif
   inner_scope_ = nullptr;
   sibling_ = nullptr;
   unresolved_ = nullptr;
@@ skipping 164 matching lines @@
 DeclarationScope* Scope::AsDeclarationScope() {
   DCHECK(is_declaration_scope());
   return static_cast<DeclarationScope*>(this);
 }
 
 const DeclarationScope* Scope::AsDeclarationScope() const {
   DCHECK(is_declaration_scope());
   return static_cast<const DeclarationScope*>(this);
 }
 
+ModuleScope* Scope::AsModuleScope() {
+  DCHECK(is_module_scope());
+  return static_cast<ModuleScope*>(this);
+}
+
+const ModuleScope* Scope::AsModuleScope() const {
+  DCHECK(is_module_scope());
+  return static_cast<const ModuleScope*>(this);
+}
+
 int Scope::num_parameters() const {
   return is_declaration_scope() ? AsDeclarationScope()->num_parameters() : 0;
 }
 
 void Scope::Analyze(ParseInfo* info) {
   DCHECK(info->literal() != NULL);
   DeclarationScope* scope = info->literal()->scope();
 
   // We are compiling one of three cases:
   // 1) top-level code,
@@ skipping 1304 matching lines @@
 
   if (new_target_ != nullptr && !MustAllocate(new_target_)) {
     new_target_ = nullptr;
   }
 
   if (this_function_ != nullptr && !MustAllocate(this_function_)) {
     this_function_ = nullptr;
   }
 }
 
-void DeclarationScope::AllocateModuleVariables() {
+void ModuleScope::AllocateModuleVariables() {
   for (auto it = module()->regular_imports().begin();
        it != module()->regular_imports().end(); ++it) {
     Variable* var = LookupLocal(it->second->local_name);
     // TODO(neis): Use a meaningful index.
     var->AllocateTo(VariableLocation::MODULE, 42);
   }
 
   for (auto entry : module()->exports()) {
     if (entry->local_name == nullptr) continue;
     Variable* var = LookupLocal(entry->local_name);
@@ skipping 10 matching lines @@
     scope->AllocateVariablesRecursively();
   }
 
   DCHECK(!already_resolved_);
   DCHECK_EQ(Context::MIN_CONTEXT_SLOTS, num_heap_slots_);
 
   // Allocate variables for this scope.
   // Parameters must be allocated first, if any.
   if (is_declaration_scope()) {
     if (is_module_scope()) {
-      AsDeclarationScope()->AllocateModuleVariables();
+      AsModuleScope()->AllocateModuleVariables();
     } else if (is_function_scope()) {
       AsDeclarationScope()->AllocateParameterLocals();
     }
     AsDeclarationScope()->AllocateReceiver();
   }
   AllocateNonParameterLocalsAndDeclaredGlobals();
 
   // Force allocation of a context for this scope if necessary. For a 'with'
   // scope and for a function scope that makes an 'eval' call we need a context,
   // even if no local variables were statically allocated in the scope.
@@ skipping 30 matching lines @@
       function != nullptr && function->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