[modules] Introduce new VariableLocation for module imports/exports.

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 1066 matching lines @@
       break;
     case VariableLocation::CONTEXT:
       PrintF("context[%d]", var->index());
       break;
     case VariableLocation::GLOBAL:
       PrintF("global[%d]", var->index());
       break;
     case VariableLocation::LOOKUP:
       PrintF("lookup");
       break;
+    case VariableLocation::MODULE:
+      PrintF("module");
+      break;
   }
 }
 
 
 static void PrintVar(int indent, Variable* var) {
   if (var->is_used() || !var->IsUnallocated()) {
     Indent(indent, Variable::Mode2String(var->mode()));
     PrintF(" ");
     if (var->raw_name()->IsEmpty())
       PrintF(".%p", reinterpret_cast<void*>(var));
@@ skipping 388 matching lines @@
       force_eager_compilation_ = true;
     }
     if (asm_module_ && inner->scope_type() == FUNCTION_SCOPE) {
       inner->asm_function_ = true;
     }
   }
 }
 
 
 bool Scope::MustAllocate(Variable* var) {
+  DCHECK(var->location() != VariableLocation::MODULE);
   // Give var a read/write use if there is a chance it might be accessed
   // via an eval() call.  This is only possible if the variable has a
   // visible name.
   if ((var->is_this() || !var->raw_name()->IsEmpty()) &&
       (var->has_forced_context_allocation() || scope_calls_eval_ ||
        inner_scope_calls_eval_ || is_catch_scope() || is_block_scope() ||
        is_module_scope() || is_script_scope())) {
     var->set_is_used();
     if (scope_calls_eval_ || inner_scope_calls_eval_) var->set_maybe_assigned();
   }
@@ skipping 199 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() {
+  for (auto entry : module()->imports()) {
+    if (entry->local_name == nullptr) continue;
+    if (entry->import_name == nullptr) continue;  // Namespace import.
+    Variable* var = LookupLocal(entry->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);
+    var->AllocateTo(VariableLocation::MODULE, 42);
+  }
+}
+
 void Scope::AllocateVariablesRecursively(AstValueFactory* ast_value_factory) {
   if (!already_resolved()) {
     num_stack_slots_ = 0;
   }
   // Allocate variables for inner scopes.
   for (Scope* scope = inner_scope_; scope != nullptr; scope = scope->sibling_) {
     scope->AllocateVariablesRecursively(ast_value_factory);
   }
 
   // If scope is already resolved, we still need to allocate
   // variables in inner scopes which might not have been resolved yet.
   if (already_resolved()) return;
   // The number of slots required for variables.
   num_heap_slots_ = Context::MIN_CONTEXT_SLOTS;
 
   // Allocate variables for this scope.
   // Parameters must be allocated first, if any.
   if (is_declaration_scope()) {
-    if (is_function_scope()) AsDeclarationScope()->AllocateParameterLocals();
+    if (is_module_scope()) {
+      AsDeclarationScope()->AllocateModuleVariables();
+    } else if (is_function_scope()) {
+      AsDeclarationScope()->AllocateParameterLocals();
+    }
     AsDeclarationScope()->AllocateReceiver();
   }
   AllocateNonParameterLocalsAndDeclaredGlobals(ast_value_factory);
 
   // 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.
   // Likewise for modules.
   bool must_have_context =
       is_with_scope() || is_module_scope() ||
@@ skipping 27 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