[modules] Partial scope info support of modules

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/scopeinfo.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
 #include "src/parsing/parse-info.h"
 
 namespace v8 {
 namespace internal {
 
 // ----------------------------------------------------------------------------
 // Implementation of LocalsMap
 //
@@ skipping 117 matching lines @@
 
 ModuleScope::ModuleScope(DeclarationScope* script_scope,
                          AstValueFactory* ast_value_factory)
     : DeclarationScope(ast_value_factory->zone(), script_scope, MODULE_SCOPE) {
   Zone* zone = ast_value_factory->zone();
   module_descriptor_ = new (zone) ModuleDescriptor(zone);
   set_language_mode(STRICT);
   DeclareThis(ast_value_factory);
 }
 
+ModuleScope::ModuleScope(Isolate* isolate, Handle<ScopeInfo> scope_info,
+                         AstValueFactory* avfactory)
+    : DeclarationScope(avfactory->zone(), MODULE_SCOPE, scope_info) {
+  Zone* zone = avfactory->zone();
+  ModuleInfo* module_info = scope_info->ModuleDescriptorInfo();
+
+  set_language_mode(STRICT);
+  module_descriptor_ = new (zone) ModuleDescriptor(zone);
+
+  // Deserialize regular exports.
+  Handle<FixedArray> regular_exports = handle(module_info->regular_exports());
+  for (int i = 0, n = regular_exports->length(); i < n; ++i) {
+    Handle<FixedArray> serialized_entry(regular_exports->get(i), isolate);
+    module_descriptor_->AddRegularExport(ModuleDescriptor::Entry::Deserialize(
+        isolate, avfactory, serialized_entry));
+  }
+}
+
 Scope::Scope(Zone* zone, ScopeType scope_type, Handle<ScopeInfo> scope_info)
     : zone_(zone),
       outer_scope_(nullptr),
       variables_(zone),
       ordered_variables_(0, zone),
       decls_(0, zone),
       scope_info_(scope_info),
       scope_type_(scope_type) {
   DCHECK(!scope_info.is_null());
   SetDefaults();
@@ skipping 136 matching lines @@
         outer_scope->AsDeclarationScope()->set_asm_module();
     } else if (context->IsBlockContext()) {
       Handle<ScopeInfo> scope_info(context->scope_info(), isolate);
       DCHECK_EQ(scope_info->scope_type(), BLOCK_SCOPE);
       if (scope_info->is_declaration_scope()) {
         outer_scope =
             new (zone) DeclarationScope(zone, BLOCK_SCOPE, scope_info);
       } else {
         outer_scope = new (zone) Scope(zone, BLOCK_SCOPE, scope_info);
       }
+    } else if (context->IsModuleContext()) {
+      ScopeInfo* scope_info = context->closure()->shared()->scope_info();
+      DCHECK_EQ(scope_info->scope_type(), MODULE_SCOPE);
+      outer_scope = new (zone) ModuleScope(
+          isolate, Handle<ScopeInfo>(scope_info), ast_value_factory);
     } else {
       DCHECK(context->IsCatchContext());
       String* name = context->catch_name();
       outer_scope = new (zone)
           Scope(zone, ast_value_factory->GetString(handle(name, isolate)));
     }
     if (current_scope != nullptr) {
       outer_scope->AddInnerScope(current_scope);
     }
     current_scope = outer_scope;
@@ skipping 107 matching lines @@
   DeclarationScope* scope = info->literal()->scope();
 
   // We are compiling one of three cases:
   // 1) top-level code,
   // 2) a function/eval/module on the top-level
   // 3) a function/eval in a scope that was already resolved.
   DCHECK(scope->scope_type() == SCRIPT_SCOPE ||
          scope->outer_scope()->scope_type() == SCRIPT_SCOPE ||
          scope->outer_scope()->already_resolved_);
 
+  // For modules, we want to start variable allocation on the surrounding script
+  // scope.
+  if (scope->is_module_scope())

[adamk, 2016/08/25 16:19:43]

Please add braces if this  doesn't fit on one line.

[neis, 2016/08/26 09:52:07]

Done.

+    scope = scope->outer_scope()->AsDeclarationScope();
+
   scope->AllocateVariables(info);
 
 #ifdef DEBUG
   if (info->script_is_native() ? FLAG_print_builtin_scopes
                                : FLAG_print_scopes) {
     scope->Print();
   }
   scope->CheckScopePositions();
   scope->CheckZones();
 #endif
@@ skipping 180 matching lines @@
       mode = DYNAMIC;
       init_flag = kCreatedInitialized;
       // Be conservative and flag parameters as maybe assigned. Better
       // information would require ScopeInfo to serialize the maybe_assigned bit
       // also for parameters.
       maybe_assigned_flag = kMaybeAssigned;
     }
   }
   if (index < 0 && scope_type() == MODULE_SCOPE) {
     location = VariableLocation::MODULE;
-    index = -1;  // TODO(neis): Find module variables in scope info.
+    index = ScopeInfo::ModuleIndex(scope_info_, name_handle, &mode, &init_flag,
+                                   &maybe_assigned_flag);
   }
   if (index < 0) return nullptr;  // Nowhere found.
 
   Variable::Kind kind = Variable::NORMAL;
   if (location == VariableLocation::CONTEXT &&
       index == scope_info_->ReceiverContextSlotIndex()) {
     kind = Variable::THIS;
   }
   // TODO(marja, rossberg): Correctly declare FUNCTION, CLASS, NEW_TARGET, and
   // ARGUMENTS bindings as their corresponding Variable::Kind.
@@ skipping 159 matching lines @@
         }
       }
       DCHECK(false);
     }
   }
   return nullptr;
 }
 
 void Scope::CollectVariables(ZoneList<Variable*>* stack_locals,
                              ZoneList<Variable*>* context_locals,
-                             ZoneList<Variable*>* context_globals) {
+                             ZoneList<Variable*>* context_globals,
+                             ZoneList<Variable*>* module_vars) {
   DCHECK(stack_locals != NULL);
   DCHECK(context_locals != NULL);
   DCHECK(context_globals != NULL);
+  DCHECK(module_vars != NULL || scope_type() != MODULE_SCOPE);
 
   // Collect temporaries which are always allocated on the stack, unless the
   // context as a whole has forced context allocation.
   if (is_declaration_scope()) {
     ZoneList<Variable*>* temps = AsDeclarationScope()->temps();
     for (int i = 0; i < temps->length(); i++) {
       Variable* var = (*temps)[i];
       if (var->is_used()) {
         if (var->IsContextSlot()) {
           DCHECK(has_forced_context_allocation());
           context_locals->Add(var, zone());
         } else if (var->IsStackLocal()) {
           stack_locals->Add(var, zone());
         } else {
           DCHECK(var->IsParameter());
         }
       }
     }
   }
 
   for (int i = 0; i < ordered_variables_.length(); i++) {
     Variable* var = ordered_variables_[i];
-    if (var->IsStackLocal()) {
+    if (var->IsStackLocal()) {  // XXX use switch

[adamk, 2016/08/25 16:19:43]

Remove this comment before landing (or switch to a switch before landing?)

[neis, 2016/08/26 09:52:07]

Turned it into a switch (above as well).

       stack_locals->Add(var, zone());
     } else if (var->IsContextSlot()) {
       context_locals->Add(var, zone());
     } else if (var->IsGlobalSlot()) {
       context_globals->Add(var, zone());
+    } else if (var->location() == VariableLocation::MODULE) {
+      module_vars->Add(var, zone());
     }
   }
 }
 
 void DeclarationScope::AllocateVariables(ParseInfo* info) {
   // 1) Propagate scope information.
   PropagateScopeInfo();
 
   // 2) Resolve variables.
   ResolveVariablesRecursively(info);
@@ skipping 817 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