Chain ScopeInfos together

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 {
 
 // An entry in ModuleVariableEntries consists of several slots:
 enum ModuleVariableEntryOffset {
   kModuleVariableNameOffset,
   kModuleVariableIndexOffset,
   kModuleVariablePropertiesOffset,
   kModuleVariableEntryLength  // Sentinel value.
 };
 
-Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone,
-                                    Scope* scope) {
+#ifdef DEBUG
+bool ScopeInfo::Equals(ScopeInfo* other) const {
+  if (length() != other->length()) return false;
+  for (int index = 0; index < length(); ++index) {
+    Object* entry = get(index);
+    Object* other_entry = other->get(index);
+    if (entry->IsSmi()) {
+      if (entry != other_entry) return false;
+    } else {
+      if (HeapObject::cast(entry)->map()->instance_type() !=
+          HeapObject::cast(other_entry)->map()->instance_type()) {
+        return false;
+      }
+      if (entry->IsString()) {
+        if (!String::cast(entry)->Equals(String::cast(other_entry))) {
+          return false;
+        }
+      } else if (entry->IsScopeInfo()) {
+        if (!ScopeInfo::cast(entry)->Equals(ScopeInfo::cast(other_entry))) {
+          return false;
+        }
+      } else if (entry->IsModuleInfo()) {
+        if (!ModuleInfo::cast(entry)->Equals(ModuleInfo::cast(other_entry))) {
+          return false;
+        }
+      } else {
+        UNREACHABLE();
+        return false;
+      }
+    }
+  }
+  return true;
+}
+#endif
+
+Handle<ScopeInfo> ScopeInfo::Create(Isolate* isolate, Zone* zone, Scope* scope,
+                                    MaybeHandle<ScopeInfo> outer_scope) {
   // Collect variables.
   ZoneList<Variable*>* locals = scope->locals();
   int stack_local_count = 0;
   int context_local_count = 0;
   int module_vars_count = 0;
   // Stack allocated block scope variables are allocated in the parent
   // declaration scope, but are recorded in the block scope's scope info. First
   // slot index indicates at which offset a particular scope starts in the
   // parent declaration scope.
   int first_slot_index = 0;
@@ skipping 53 matching lines @@
       DCHECK(var->IsStackLocal());
       function_name_info = STACK;
     }
   } else {
     function_name_info = NONE;
   }
 
   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 bool has_outer_scope_info = !outer_scope.is_null();
   const int length = kVariablePartIndex + parameter_count +
                      (1 + stack_local_count) + 2 * context_local_count +
                      (has_receiver ? 1 : 0) + (has_function_name ? 2 : 0) +
+                     (has_outer_scope_info ? 1 : 0) +
                      (scope->is_module_scope()
                           ? 2 + kModuleVariableEntryLength * 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;
@@ skipping 10 matching lines @@
   int flags = ScopeTypeField::encode(scope->scope_type()) |
               CallsEvalField::encode(scope->calls_eval()) |
               LanguageModeField::encode(scope->language_mode()) |
               DeclarationScopeField::encode(scope->is_declaration_scope()) |
               ReceiverVariableField::encode(receiver_info) |
               HasNewTargetField::encode(has_new_target) |
               FunctionVariableField::encode(function_name_info) |
               AsmModuleField::encode(asm_module) |
               AsmFunctionField::encode(asm_function) |
               HasSimpleParametersField::encode(has_simple_parameters) |
-              FunctionKindField::encode(function_kind);
+              FunctionKindField::encode(function_kind) |
+              HasOuterScopeInfoField::encode(has_outer_scope_info);
   scope_info->SetFlags(flags);
 
   scope_info->SetParameterCount(parameter_count);
   scope_info->SetStackLocalCount(stack_local_count);
   scope_info->SetContextLocalCount(context_local_count);
 
   int index = kVariablePartIndex;
   // Add parameters.
   DCHECK_EQ(index, scope_info->ParameterEntriesIndex());
   if (scope->is_declaration_scope()) {
@@ skipping 74 matching lines @@
   DCHECK_EQ(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);
   }
 
+  // If present, add the outer scope info.
+  DCHECK(index == scope_info->OuterScopeInfoEntryIndex());
+  if (has_outer_scope_info) {
+    scope_info->set(index++, *outer_scope.ToHandleChecked());
+  }
+
   // Module-specific information (only for module scopes).
   if (scope->is_module_scope()) {
     Handle<ModuleInfo> module_info =
         ModuleInfo::New(isolate, scope->AsModuleScope()->module());
     DCHECK_EQ(index, scope_info->ModuleInfoEntryIndex());
     scope_info->set(index++, *module_info);
     DCHECK_EQ(index, scope_info->ModuleVariableCountIndex());
     scope_info->set(index++, Smi::FromInt(module_vars_count));
     DCHECK_EQ(index, scope_info->ModuleVariableEntriesIndex());
     // The variable entries themselves have already been written above.
     index += kModuleVariableEntryLength * module_vars_count;
   }
 
   DCHECK_EQ(index, scope_info->length());
   DCHECK_EQ(scope->num_parameters(), scope_info->ParameterCount());
   DCHECK_EQ(scope->num_heap_slots(), scope_info->ContextLength());
   return scope_info;
 }
 
-Handle<ScopeInfo> ScopeInfo::CreateForWithScope(Isolate* isolate) {
-  const int length = kVariablePartIndex + 1;
+Handle<ScopeInfo> ScopeInfo::CreateForWithScope(
+    Isolate* isolate, MaybeHandle<ScopeInfo> outer_scope) {
+  const bool has_outer_scope_info = !outer_scope.is_null();
+  const int length = kVariablePartIndex + 1 + (has_outer_scope_info ? 1 : 0);
 
   Factory* factory = isolate->factory();
   Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length);
 
   // Encode the flags.
   int flags =
       ScopeTypeField::encode(WITH_SCOPE) | CallsEvalField::encode(false) |
       LanguageModeField::encode(SLOPPY) | DeclarationScopeField::encode(false) |
       ReceiverVariableField::encode(NONE) | HasNewTargetField::encode(false) |
       FunctionVariableField::encode(NONE) | AsmModuleField::encode(false) |
       AsmFunctionField::encode(false) | HasSimpleParametersField::encode(true) |
-      FunctionKindField::encode(kNormalFunction);
+      FunctionKindField::encode(kNormalFunction) |
+      HasOuterScopeInfoField::encode(has_outer_scope_info);
   scope_info->SetFlags(flags);
 
   scope_info->SetParameterCount(0);
   scope_info->SetStackLocalCount(0);
   scope_info->SetContextLocalCount(0);
 
   int index = kVariablePartIndex;
   DCHECK_EQ(index, scope_info->ParameterEntriesIndex());
   DCHECK_EQ(index, scope_info->StackLocalFirstSlotIndex());
   scope_info->set(index++, Smi::FromInt(0));
   DCHECK_EQ(index, scope_info->StackLocalEntriesIndex());
   DCHECK_EQ(index, scope_info->ReceiverEntryIndex());
   DCHECK_EQ(index, scope_info->FunctionNameEntryIndex());
+  DCHECK(index == scope_info->OuterScopeInfoEntryIndex());
+  if (has_outer_scope_info) {
+    scope_info->set(index++, *outer_scope.ToHandleChecked());
+  }
   DCHECK_EQ(index, scope_info->length());
   DCHECK_EQ(0, scope_info->ParameterCount());
   DCHECK_EQ(Context::MIN_CONTEXT_SLOTS, scope_info->ContextLength());
   return scope_info;
 }
 
 Handle<ScopeInfo> ScopeInfo::CreateGlobalThisBinding(Isolate* isolate) {
   DCHECK(isolate->bootstrapper()->IsActive());
 
   const int stack_local_count = 0;
   const int context_local_count = 1;
   const bool has_simple_parameters = true;
   const VariableAllocationInfo receiver_info = CONTEXT;
   const VariableAllocationInfo function_name_info = NONE;
   const bool has_function_name = false;
   const bool has_receiver = true;
+  const bool has_outer_scope_info = false;
   const int parameter_count = 0;
   const int length = kVariablePartIndex + parameter_count +
                      (1 + stack_local_count) + 2 * context_local_count +
-                     (has_receiver ? 1 : 0) + (has_function_name ? 2 : 0);
+                     (has_receiver ? 1 : 0) + (has_function_name ? 2 : 0) +
+                     (has_outer_scope_info ? 1 : 0);
 
   Factory* factory = isolate->factory();
   Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length);
 
   // Encode the flags.
-  int flags = ScopeTypeField::encode(SCRIPT_SCOPE) |
-              CallsEvalField::encode(false) |
-              LanguageModeField::encode(SLOPPY) |
-              DeclarationScopeField::encode(true) |
-              ReceiverVariableField::encode(receiver_info) |
-              FunctionVariableField::encode(function_name_info) |
-              AsmModuleField::encode(false) | AsmFunctionField::encode(false) |
-              HasSimpleParametersField::encode(has_simple_parameters) |
-              FunctionKindField::encode(FunctionKind::kNormalFunction);
+  int flags =
+      ScopeTypeField::encode(SCRIPT_SCOPE) | CallsEvalField::encode(false) |
+      LanguageModeField::encode(SLOPPY) | DeclarationScopeField::encode(true) |
+      ReceiverVariableField::encode(receiver_info) |
+      FunctionVariableField::encode(function_name_info) |
+      AsmModuleField::encode(false) | AsmFunctionField::encode(false) |
+      HasSimpleParametersField::encode(has_simple_parameters) |
+      FunctionKindField::encode(FunctionKind::kNormalFunction) |
+      HasOuterScopeInfoField::encode(has_outer_scope_info);
   scope_info->SetFlags(flags);
   scope_info->SetParameterCount(parameter_count);
   scope_info->SetStackLocalCount(stack_local_count);
   scope_info->SetContextLocalCount(context_local_count);
 
   int index = kVariablePartIndex;
   const int first_slot_index = 0;
   DCHECK_EQ(index, scope_info->StackLocalFirstSlotIndex());
   scope_info->set(index++, Smi::FromInt(first_slot_index));
   DCHECK_EQ(index, scope_info->StackLocalEntriesIndex());
 
   // Here we add info for context-allocated "this".
   DCHECK_EQ(index, scope_info->ContextLocalNameEntriesIndex());
   scope_info->set(index++, *isolate->factory()->this_string());
   DCHECK_EQ(index, scope_info->ContextLocalInfoEntriesIndex());
   const uint32_t value = VariableModeField::encode(CONST) |
                          InitFlagField::encode(kCreatedInitialized) |
                          MaybeAssignedFlagField::encode(kNotAssigned);
   scope_info->set(index++, Smi::FromInt(value));
 
   // And here we record that this scopeinfo binds a receiver.
   DCHECK_EQ(index, scope_info->ReceiverEntryIndex());
   const int receiver_index = Context::MIN_CONTEXT_SLOTS + 0;
   scope_info->set(index++, Smi::FromInt(receiver_index));
 
   DCHECK_EQ(index, scope_info->FunctionNameEntryIndex());
+  DCHECK_EQ(index, scope_info->OuterScopeInfoEntryIndex());
 
   DCHECK_EQ(index, scope_info->length());
   DCHECK_EQ(scope_info->ParameterCount(), 0);
   DCHECK_EQ(scope_info->ContextLength(), Context::MIN_CONTEXT_SLOTS + 1);
 
   return scope_info;
 }
 
 
 ScopeInfo* ScopeInfo::Empty(Isolate* isolate) {
@@ skipping 81 matching lines @@
 
 
 bool ScopeInfo::HasFunctionName() {
   if (length() > 0) {
     return NONE != FunctionVariableField::decode(Flags());
   } else {
     return false;
   }
 }
 
+bool ScopeInfo::HasOuterScopeInfo() {
+  if (length() > 0) {
+    return HasOuterScopeInfoField::decode(Flags());
+  } else {
+    return false;
+  }
+}
 
 bool ScopeInfo::HasHeapAllocatedLocals() {
   if (length() > 0) {
     return ContextLocalCount() > 0;
   } else {
     return false;
   }
 }
 
 
 bool ScopeInfo::HasContext() {
   return ContextLength() > 0;
 }
 
 
 String* ScopeInfo::FunctionName() {
   DCHECK(HasFunctionName());
   return String::cast(get(FunctionNameEntryIndex()));
 }
 
+ScopeInfo* ScopeInfo::OuterScopeInfo() {
+  DCHECK(HasOuterScopeInfo());
+  return ScopeInfo::cast(get(OuterScopeInfoEntryIndex()));
+}
+
 ModuleInfo* ScopeInfo::ModuleDescriptorInfo() {
   DCHECK(scope_type() == MODULE_SCOPE);
   return static_cast<ModuleInfo*>(get(ModuleInfoEntryIndex()));
 }
 
 String* ScopeInfo::ParameterName(int var) {
   DCHECK_LE(0, var);
   DCHECK_LT(var, ParameterCount());
   int info_index = ParameterEntriesIndex() + var;
   return String::cast(get(info_index));
@@ skipping 231 matching lines @@
 }
 
 int ScopeInfo::ReceiverEntryIndex() {
   return ContextLocalInfoEntriesIndex() + ContextLocalCount();
 }
 
 int ScopeInfo::FunctionNameEntryIndex() {
   return ReceiverEntryIndex() + (HasAllocatedReceiver() ? 1 : 0);
 }
 
+int ScopeInfo::OuterScopeInfoEntryIndex() {
+  return FunctionNameEntryIndex() + (HasFunctionName() ? 2 : 0);
+}
+
 int ScopeInfo::ModuleInfoEntryIndex() {
-  return FunctionNameEntryIndex() + (HasFunctionName() ? 2 : 0);
+  return OuterScopeInfoEntryIndex() + (HasOuterScopeInfo() ? 1 : 0);
 }
 
 int ScopeInfo::ModuleVariableCountIndex() { return ModuleInfoEntryIndex() + 1; }
 
 int ScopeInfo::ModuleVariableEntriesIndex() {
   return ModuleVariableCountIndex() + 1;
 }
 
 #ifdef DEBUG
 
@@ skipping 61 matching lines @@
   }
 
   Handle<ModuleInfo> result = isolate->factory()->NewModuleInfo();
   result->set(kSpecialExportsIndex, *special_exports);
   result->set(kRegularExportsIndex, *regular_exports);
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8