[modules] Partial scope info support of modules

src/ast/scopeinfo.cc

 // Copyright 2011 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 <stdlib.h>
 
 #include "src/ast/context-slot-cache.h"
 #include "src/ast/scopes.h"
 #include "src/bootstrapper.h"
 
 namespace v8 {
 namespace internal {
 
 
 Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone,
                                     Scope* scope) {
   // Collect variables.
   ZoneList<Variable*> stack_locals(scope->StackLocalCount(), zone);
   ZoneList<Variable*> context_locals(scope->ContextLocalCount(), zone);
   ZoneList<Variable*> context_globals(scope->ContextGlobalCount(), zone);
-  scope->CollectVariables(&stack_locals, &context_locals, &context_globals);
+  ZoneList<Variable*> module_vars(0, zone);
+  scope->CollectVariables(&stack_locals, &context_locals, &context_globals,
+                          &module_vars);
   const int stack_local_count = stack_locals.length();
   const int context_local_count = context_locals.length();
   const int context_global_count = context_globals.length();
-  // Make sure we allocate the correct amount.
+  const int module_vars_count = module_vars.length();
   DCHECK_EQ(scope->ContextLocalCount(), context_local_count);
   DCHECK_EQ(scope->ContextGlobalCount(), context_global_count);
+  DCHECK(module_vars_count == 0 || scope->is_module_scope());
 
   // Determine use and location of the "this" binding if it is present.
   VariableAllocationInfo receiver_info;
   if (scope->is_declaration_scope() &&
       scope->AsDeclarationScope()->has_this_declaration()) {
     Variable* var = scope->AsDeclarationScope()->receiver();
     if (!var->is_used()) {
       receiver_info = UNUSED;
     } else if (var->IsContextSlot()) {
       receiver_info = CONTEXT;
@@ skipping 28 matching lines @@
     function_name_info = NONE;
     function_variable_mode = VAR;
   }
   DCHECK(context_global_count == 0 || scope->scope_type() == SCRIPT_SCOPE);
 
   const bool has_function_name = function_name_info != NONE;
   const bool has_receiver = receiver_info == STACK || receiver_info == CONTEXT;
   const int parameter_count = scope->num_parameters();
   const int length = kVariablePartIndex + parameter_count +
                      (1 + stack_local_count) + 2 * context_local_count +
-                     2 * context_global_count +
-                     (has_receiver ? 1 : 0) + (has_function_name ? 2 : 0);
+                     2 * context_global_count + (has_receiver ? 1 : 0) +
+                     (has_function_name ? 2 : 0) +
+                     (scope->is_module_scope() ? 2 + 3 * module_vars_count : 0);
 
   Factory* factory = isolate->factory();
   Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length);
 
   bool has_simple_parameters = false;
   bool asm_module = false;
   bool asm_function = false;
   FunctionKind function_kind = kNormalFunction;
   if (scope->is_function_scope()) {
     DeclarationScope* function_scope = scope->AsDeclarationScope();
@@ skipping 10 matching lines @@
               DeclarationScopeField::encode(scope->is_declaration_scope()) |
               ReceiverVariableField::encode(receiver_info) |
               HasNewTargetField::encode(has_new_target) |
               FunctionVariableField::encode(function_name_info) |
               FunctionVariableMode::encode(function_variable_mode) |
               AsmModuleField::encode(asm_module) |
               AsmFunctionField::encode(asm_function) |
               HasSimpleParametersField::encode(has_simple_parameters) |
               FunctionKindField::encode(function_kind);
   scope_info->SetFlags(flags);
+
   scope_info->SetParameterCount(parameter_count);
   scope_info->SetStackLocalCount(stack_local_count);
   scope_info->SetContextLocalCount(context_local_count);
   scope_info->SetContextGlobalCount(context_global_count);
 
   int index = kVariablePartIndex;
   // Add parameters.
   DCHECK(index == scope_info->ParameterEntriesIndex());
   if (scope->is_declaration_scope()) {
     for (int i = 0; i < parameter_count; ++i) {
@@ skipping 73 matching lines @@
   DCHECK(index == scope_info->FunctionNameEntryIndex());
   if (has_function_name) {
     int var_index = scope->AsDeclarationScope()->function_var()->index();
     scope_info->set(index++,
                     *scope->AsDeclarationScope()->function_var()->name());
     scope_info->set(index++, Smi::FromInt(var_index));
     DCHECK(function_name_info != CONTEXT ||
            var_index == scope_info->ContextLength() - 1);
   }
 
+  // Module-specific information (only for module scopes).
+  DCHECK_EQ(index, scope_info->ModuleInfoEntryIndex());
+  if (scope->is_module_scope()) {
+    Handle<ModuleInfo> module_info =
+        ModuleInfo::New(isolate, scope->AsModuleScope()->module());
+    scope_info->set(index++, *module_info);
+    scope_info->set(index++, Smi::FromInt(module_vars_count));
+    for (int i = 0; i < module_vars_count; ++i) {
+      Variable* var = module_vars[i];
+      scope_info->set(index++, *var->name());
+      scope_info->set(index++, Smi::FromInt(var->index()));
+      uint32_t value = VariableModeField::encode(var->mode()) |
+                       InitFlagField::encode(var->initialization_flag()) |
+                       MaybeAssignedFlagField::encode(var->maybe_assigned());
+      scope_info->set(index++, Smi::FromInt(value));
+    }
+  }
+
   DCHECK(index == scope_info->length());
   DCHECK(scope->num_parameters() == scope_info->ParameterCount());
   DCHECK(scope->num_heap_slots() == scope_info->ContextLength() ||
          (scope->num_heap_slots() == kVariablePartIndex &&
           scope_info->ContextLength() == 0));
   return scope_info;
 }
 
 
 Handle<ScopeInfo> ScopeInfo::CreateGlobalThisBinding(Isolate* isolate) {
@@ skipping 171 matching lines @@
 bool ScopeInfo::HasContext() {
   return ContextLength() > 0;
 }
 
 
 String* ScopeInfo::FunctionName() {
   DCHECK(HasFunctionName());
   return String::cast(get(FunctionNameEntryIndex()));
 }
 
+ModuleInfo* ScopeInfo::ModuleDescriptorInfo() {
+  DCHECK(scope_type() == MODULE_SCOPE);
+  return static_cast<ModuleInfo*>(get(ModuleInfoEntryIndex()));
+}
 
 String* ScopeInfo::ParameterName(int var) {
   DCHECK(0 <= var && var < ParameterCount());
   int info_index = ParameterEntriesIndex() + var;
   return String::cast(get(info_index));
 }
 
 
 String* ScopeInfo::LocalName(int var) {
   DCHECK(0 <= var && var < LocalCount());
@@ skipping 66 matching lines @@
     int end = start + StackLocalCount();
     for (int i = start; i < end; ++i) {
       if (name == get(i)) {
         return i - start + first_slot_index;
       }
     }
   }
   return -1;
 }
 
+int ScopeInfo::ModuleIndex(Handle<ScopeInfo> scope_info, Handle<String> name,

[adamk, 2016/08/26 16:54:44]

This function is full of magic constants. Is there some way to add either more
helper methods or constants to clean it up?

+                           VariableMode* mode, InitializationFlag* init_flag,
+                           MaybeAssignedFlag* maybe_assigned_flag) {
+  DCHECK_EQ(scope_info->scope_type(), MODULE_SCOPE);
+  DCHECK(name->IsInternalizedString());
+  DCHECK_NOT_NULL(mode);
+  DCHECK_NOT_NULL(init_flag);
+  DCHECK_NOT_NULL(maybe_assigned_flag);
+
+  int base = scope_info->ModuleInfoEntryIndex();
+  int module_vars_count = Smi::cast(scope_info->get(base + 1))->value();
+  int start = base + 2;
+  int end = start + 3 * module_vars_count;
+  for (int i = start; i < end; i += 3) {
+    if (*name == scope_info->get(i)) {
+      int index = Smi::cast(scope_info->get(i + 1))->value();
+      int properties = Smi::cast(scope_info->get(i + 2))->value();
+      *mode = VariableModeField::decode(properties);
+      *init_flag = InitFlagField::decode(properties);
+      *maybe_assigned_flag = MaybeAssignedFlagField::decode(properties);
+      return index;
+    }
+  }
+
+  return -1;
+}
 
 int ScopeInfo::ContextSlotIndex(Handle<ScopeInfo> scope_info,
                                 Handle<String> name, VariableMode* mode,
                                 InitializationFlag* init_flag,
                                 MaybeAssignedFlag* maybe_assigned_flag) {
   DCHECK(name->IsInternalizedString());
   DCHECK_NOT_NULL(mode);
   DCHECK_NOT_NULL(init_flag);
   DCHECK_NOT_NULL(maybe_assigned_flag);
 
@@ skipping 155 matching lines @@
 
 int ScopeInfo::ReceiverEntryIndex() {
   return ContextGlobalInfoEntriesIndex() + ContextGlobalCount();
 }
 
 
 int ScopeInfo::FunctionNameEntryIndex() {
   return ReceiverEntryIndex() + (HasAllocatedReceiver() ? 1 : 0);
 }
 
+int ScopeInfo::ModuleInfoEntryIndex() {
+  return FunctionNameEntryIndex() + (HasFunctionName() ? 2 : 0);
+}
+
 #ifdef DEBUG
 
 static void PrintList(const char* list_name,
                       int nof_internal_slots,
                       int start,
                       int end,
                       ScopeInfo* scope_info) {
   if (start < end) {
     PrintF("\n  // %s\n", list_name);
     if (nof_internal_slots > 0) {
@@ skipping 24 matching lines @@
               StackLocalEntriesIndex() + StackLocalCount(), this);
     PrintList("context slots", Context::MIN_CONTEXT_SLOTS,
               ContextLocalNameEntriesIndex(),
               ContextLocalNameEntriesIndex() + ContextLocalCount(), this);
   }
 
   PrintF("}\n");
 }
 #endif  // DEBUG
 
+Handle<ModuleInfo> ModuleInfo::New(Isolate* isolate, ModuleDescriptor* descr) {
+  // Serialize special exports.
+  Handle<FixedArray> special_exports =
+      isolate->factory()->NewFixedArray(descr->special_exports().length());
+  {
+    int i = 0;

[adamk, 2016/08/26 16:54:44]

Not anything wrong with your CL, but it makes me sad that C++11 doesn't have a
nicer way to mix range-based and indexed for loops.

+    for (auto entry : descr->special_exports()) {
+      special_exports->set(i++, *entry->Serialize(isolate));
+    }
+  }
+
+  // Serialize regular exports.
+  Handle<FixedArray> regular_exports = isolate->factory()->NewFixedArray(
+      static_cast<int>(descr->regular_exports().size()));
+  {
+    int i = 0;
+    for (const auto& it : descr->regular_exports()) {
+      regular_exports->set(i++, *it.second->Serialize(isolate));
+    }
+  }
+
+  Handle<ModuleInfo> result = isolate->factory()->NewModuleInfo();
+  result->set(0, *special_exports);
+  result->set(1, *regular_exports);
+  return result;
+}
 
 }  // namespace internal
 }  // namespace v8