[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 "src/accessors.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
 #include "src/parsing/parser.h"  // for ParseInfo
@@ skipping 749 matching lines @@
     outer_scope_calls_sloppy_eval =
         outer_scope_->outer_scope_calls_sloppy_eval() |
         outer_scope_->calls_sloppy_eval();
   }
   PropagateScopeInfo(outer_scope_calls_sloppy_eval);
 
   // 2) Resolve variables.
   if (!ResolveVariablesRecursively(info, factory)) return false;
 
   // 3) Allocate variables.
+  if (info->is_module()) AllocateModuleVariables();
   AllocateVariablesRecursively(info->ast_value_factory());
 
   return true;
 }
 
 
 bool Scope::HasTrivialContext() const {
   // A function scope has a trivial context if it always is the global
   // context. We iteratively scan out the context chain to see if
   // there is anything that makes this scope non-trivial; otherwise we
@@ skipping 70 matching lines @@
 
 
 Scope* Scope::ClosureScope() {
   Scope* scope = this;
   while (!scope->is_declaration_scope() || scope->is_block_scope()) {
     scope = scope->outer_scope();
   }
   return scope;
 }
 
+Scope* Scope::ModuleScope() {
+  Scope* scope = this;
+  while (!scope->is_script_scope()) scope = scope->outer_scope();
+  scope = scope->inner_scope();

[adamk, 2016/08/02 16:34:31]

Why not just walk up till you hit the module scope (or not)? They should never
be nested...

[neis, 2016/08/03 09:16:30]

Because "this" may already be the script scope. See what Analyze does before it
calls AllocateVariables:

  // Traverse the scope tree up to the first unresolved scope or the global
  // scope and start scope resolution and variable allocation from that scope.
  while (!top->is_script_scope() &&
         !top->outer_scope()->already_resolved()) {
    top = top->outer_scope();
  }

[adamk, 2016/08/03 17:51:26]

But we'll walk _down_ the scope tree as part of analysis.

Maybe my question is, why isn't AllocateModuleVariables called from
AllocateVariablesRecursively when is_module_scope() is true, like we do with
parameters for function scopes?

+  return (scope == nullptr || !scope->is_module_scope()) ? nullptr : scope;
+}
 
 Scope* Scope::ReceiverScope() {
   Scope* scope = this;
   while (!scope->is_script_scope() &&
          (!scope->is_function_scope() || scope->is_arrow_scope())) {
     scope = scope->outer_scope();
   }
   return scope;
 }
 
@@ skipping 102 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 589 matching lines @@
 
   if (new_target_ != nullptr && !MustAllocate(new_target_)) {
     new_target_ = nullptr;
   }
 
   if (this_function_ != nullptr && !MustAllocate(this_function_)) {
     this_function_ = nullptr;
   }
 }
 
+void Scope::AllocateModuleVariables() {
+  Scope* module_scope = ModuleScope();

[adamk, 2016/08/02 16:34:31]

Does this need to walk up to the ModuleScope? I would have thought it would only
make sense to call it on the module's scope itself.

[neis, 2016/08/03 09:16:30]

I'm calling AllocateModuleVariables inside AllocateVariables, which may be
called on some quasi-random scope (see above).  But I'm open for suggestions.

[adamk, 2016/08/03 17:51:26]

See above, I was imagining that we'd check is_module_scope() in
AllocateVariablesRecursively and call this method in that case.

+  ModuleDescriptor* mod = module_scope->module();
+  for (auto entry : mod->imports()) {
+    if (entry->local_name == nullptr) continue;
+    if (entry->import_name == nullptr) continue;  // Namespace import.
+    Variable* var = module_scope->LookupLocal(entry->local_name);
+    // TODO(neis): Use a meaningful index.
+    var->AllocateTo(VariableLocation::MODULE, 42);

[adamk, 2016/08/02 16:34:31]

For imports, I think we want to check Scope::MustAllocate() (and remove the
is_module_scope() logic from that method) before allocating. If an import is
unreferenced, we shouldn't need space for it (but I admit that's kind of a weird
case).

[neis, 2016/08/03 09:16:30]

Not sure I understand. Setting the VariableLocation to MODULE doesn't by itself
reserve any space for the variable. It just tells the compiler where to look it
up. Space will be have to be reserved by the exporting module, not by the module
we're analyzing.

I will have a look at MustAllocate and the module logic you mentioned, though.

[adamk, 2016/08/03 17:51:26]

My understanding may be wrong, but I thought that once we set a variable as
"allocated" it's going to get space somewhere; that is, deciding to allocate
means deciding to reserve space "somewhere". As it happens we've yet to write
any code for actually allocating slots in some heap object for MODULE variables,
though, so I guess that can wait? A TODO would be appropriate if we want to
leave this allocated-always.

+  }
+  for (auto entry : mod->exports()) {
+    if (entry->local_name == nullptr) continue;
+    Variable* var = module_scope->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
@@ skipping 40 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