Separate Scope into DeclarationScope and Scope

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 "src/ast/scopeinfo.h"
 
 #include <stdlib.h>
 
 #include "src/ast/context-slot-cache.h"
 #include "src/ast/scopes.h"
@@ skipping 14 matching lines @@
                                       &context_globals);
   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.
   DCHECK_EQ(scope->ContextLocalCount(), context_local_count);
   DCHECK_EQ(scope->ContextGlobalCount(), context_global_count);
 
   // Determine use and location of the "this" binding if it is present.
   VariableAllocationInfo receiver_info;
-  if (scope->has_this_declaration()) {
-    Variable* var = scope->receiver();
+  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;
     } else {
       DCHECK(var->IsParameter());
       receiver_info = STACK;
     }
   } else {
     receiver_info = NONE;
   }
 
-  bool has_new_target = scope->new_target_var() != nullptr;
+  bool has_new_target =
+      scope->is_declaration_scope() &&
+      scope->AsDeclarationScope()->new_target_var() != nullptr;
 
   // Determine use and location of the function variable if it is present.
   VariableAllocationInfo function_name_info;
   VariableMode function_variable_mode;
-  if (scope->is_function_scope() && scope->function() != NULL) {
-    Variable* var = scope->function()->proxy()->var();
+  if (scope->is_function_scope() &&
+      scope->AsDeclarationScope()->function() != nullptr) {
+    Variable* var = scope->AsDeclarationScope()->function()->proxy()->var();
     if (!var->is_used()) {
       function_name_info = UNUSED;
     } else if (var->IsContextSlot()) {
       function_name_info = CONTEXT;
     } else {
       DCHECK(var->IsStackLocal());
       function_name_info = STACK;
     }
     function_variable_mode = var->mode();
   } else {
     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);
 
   Factory* factory = isolate->factory();
   Handle<ScopeInfo> scope_info = factory->NewScopeInfo(length);
 
   bool has_simple_parameters =
-      scope->is_function_scope() && scope->has_simple_parameters();
+      scope->is_function_scope() &&
+      scope->AsDeclarationScope()->has_simple_parameters();
+  FunctionKind function_kind =
+      scope->is_declaration_scope()
+          ? scope->AsDeclarationScope()->function_kind()
+          : kNormalFunction;
 
   // Encode the flags.
   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) |
               FunctionVariableMode::encode(function_variable_mode) |
               AsmModuleField::encode(scope->asm_module()) |
               AsmFunctionField::encode(scope->asm_function()) |
               HasSimpleParametersField::encode(has_simple_parameters) |
-              FunctionKindField::encode(scope->function_kind());
+              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());
-  for (int i = 0; i < parameter_count; ++i) {
-    scope_info->set(index++, *scope->parameter(i)->name());
+  if (scope->is_declaration_scope()) {
+    for (int i = 0; i < parameter_count; ++i) {
+      scope_info->set(index++,
+                      *scope->AsDeclarationScope()->parameter(i)->name());
+    }
   }
 
   // Add stack locals' names. We are assuming that the stack locals'
   // slots are allocated in increasing order, so we can simply add
   // them to the ScopeInfo object.
   int first_slot_index;
   if (stack_local_count > 0) {
     first_slot_index = stack_locals[0]->index();
   } else {
     first_slot_index = 0;
@@ skipping 45 matching lines @@
     uint32_t value =
         ContextLocalMode::encode(var->mode()) |
         ContextLocalInitFlag::encode(var->initialization_flag()) |
         ContextLocalMaybeAssignedFlag::encode(var->maybe_assigned());
     scope_info->set(index++, Smi::FromInt(value));
   }
 
   // If the receiver is allocated, add its index.
   DCHECK(index == scope_info->ReceiverEntryIndex());
   if (has_receiver) {
-    int var_index = scope->receiver()->index();
+    int var_index = scope->AsDeclarationScope()->receiver()->index();
     scope_info->set(index++, Smi::FromInt(var_index));
     // ?? DCHECK(receiver_info != CONTEXT || var_index ==
     // scope_info->ContextLength() - 1);
   }
 
   // If present, add the function variable name and its index.
   DCHECK(index == scope_info->FunctionNameEntryIndex());
   if (has_function_name) {
-    int var_index = scope->function()->proxy()->var()->index();
-    scope_info->set(index++, *scope->function()->proxy()->name());
+    int var_index =
+        scope->AsDeclarationScope()->function()->proxy()->var()->index();
+    scope_info->set(index++,
+                    *scope->AsDeclarationScope()->function()->proxy()->name());
     scope_info->set(index++, Smi::FromInt(var_index));
     DCHECK(function_name_info != CONTEXT ||
            var_index == scope_info->ContextLength() - 1);
   }
 
   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));
@@ skipping 483 matching lines @@
               ContextLocalNameEntriesIndex() + ContextLocalCount(), this);
   }
 
   PrintF("}\n");
 }
 #endif  // DEBUG
 
 
 }  // namespace internal
 }  // namespace v8