Separate Scope into DeclarationScope and Scope

src/compiler/ast-graph-builder.cc

 // Copyright 2014 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/compiler/ast-graph-builder.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
@@ skipping 488 matching lines @@
       liveness_analyzer_(static_cast<size_t>(info->scope()->num_stack_slots()),
                          local_zone),
       frame_state_function_info_(common()->CreateFrameStateFunctionInfo(
           FrameStateType::kJavaScriptFunction, info->num_parameters() + 1,
           info->scope()->num_stack_slots(), info->shared_info())) {
   InitializeAstVisitor(info->isolate());
 }
 
 
 Node* AstGraphBuilder::GetFunctionClosureForContext() {
-  Scope* closure_scope = current_scope()->ClosureScope();
+  DeclarationScope* closure_scope = current_scope()->GetClosureScope();
   if (closure_scope->is_script_scope() ||
       closure_scope->is_module_scope()) {
     // Contexts nested in the native context have a canonical empty function as
     // their closure, not the anonymous closure containing the global code.
     return BuildLoadNativeContextField(Context::CLOSURE_INDEX);
   } else if (closure_scope->is_eval_scope()) {
     // Contexts nested inside eval code have the same closure as the context
     // calling eval, not the anonymous closure containing the eval code.
     const Operator* op =
         javascript()->LoadContext(0, Context::CLOSURE_INDEX, false);
@@ skipping 46 matching lines @@
     Node* node = graph()->NewNode(
         op, jsgraph()->EmptyStateValues(), jsgraph()->EmptyStateValues(),
         jsgraph()->EmptyStateValues(), jsgraph()->NoContextConstant(),
         jsgraph()->UndefinedConstant(), graph()->start());
     empty_frame_state_.set(node);
   }
   return empty_frame_state_.get();
 }
 
 bool AstGraphBuilder::CreateGraph(bool stack_check) {
-  Scope* scope = info()->scope();
+  DeclarationScope* scope = info()->scope();
   DCHECK_NOT_NULL(graph());
 
   // Set up the basic structure of the graph. Outputs for {Start} are the formal
   // parameters (including the receiver) plus new target, number of arguments,
   // context and closure.
   int actual_parameter_count = info()->num_parameters_including_this() + 4;
   graph()->SetStart(graph()->NewNode(common()->Start(actual_parameter_count)));
 
   // Initialize the top-level environment.
   Environment env(this, scope, graph()->start());
@@ skipping 39 matching lines @@
   // Compute local variable liveness information and use it to relax
   // frame states.
   ClearNonLiveSlotsInFrameStates();
 
   // Failures indicated by stack overflow.
   return !HasStackOverflow();
 }
 
 
 void AstGraphBuilder::CreateGraphBody(bool stack_check) {
-  Scope* scope = info()->scope();
+  DeclarationScope* scope = info()->scope();
 
   // Build the arguments object if it is used.
   BuildArgumentsObject(scope->arguments());
 
   // Build rest arguments array if it is used.
   int rest_index;
   Variable* rest_parameter = scope->rest_parameter(&rest_index);
   BuildRestArgumentsArray(rest_parameter, rest_index);
 
   // Build assignment to {.this_function} variable if it is used.
@@ skipping 45 matching lines @@
 }
 
 
 // Gets the bailout id just before reading a variable proxy, but only for
 // unallocated variables.
 static BailoutId BeforeId(VariableProxy* proxy) {
   return proxy->var()->IsUnallocatedOrGlobalSlot() ? proxy->BeforeId()
                                                    : BailoutId::None();
 }
 
-
-static const char* GetDebugParameterName(Zone* zone, Scope* scope, int index) {
+static const char* GetDebugParameterName(Zone* zone, DeclarationScope* scope,
+                                         int index) {
 #if DEBUG
   const AstRawString* name = scope->parameter(index)->raw_name();
   if (name && name->length() > 0) {
     char* data = zone->NewArray<char>(name->length() + 1);
     data[name->length()] = 0;
     memcpy(data, name->raw_data(), name->length());
     return data;
   }
 #endif
   return nullptr;
 }
 
 
 AstGraphBuilder::Environment::Environment(AstGraphBuilder* builder,
                                           Scope* scope,

[Michael Starzinger, 2016/08/03 13:02:19]

nit: Can we change the signature to take "DeclarationScope" instead of "Scope",
then we don't need to cast the scope below.

                                           Node* control_dependency)
     : builder_(builder),
       parameters_count_(scope->num_parameters() + 1),
       locals_count_(scope->num_stack_slots()),
       liveness_block_(IsLivenessAnalysisEnabled()
                           ? builder_->liveness_analyzer()->NewBlock()
                           : nullptr),
       values_(builder_->local_zone()),
       contexts_(builder_->local_zone()),
       control_dependency_(control_dependency),
@@ skipping 10 matching lines @@
     Node* receiver = builder->graph()->NewNode(op, builder->graph()->start());
     values()->push_back(receiver);
   } else {
     values()->push_back(builder->jsgraph()->UndefinedConstant());
   }
 
   // Bind all parameter variables. The parameter indices are shifted by 1
   // (receiver is variable index -1 but {Parameter} node index 0 and located at
   // index 0 in the environment).
   for (int i = 0; i < scope->num_parameters(); ++i) {
-    const char* debug_name = GetDebugParameterName(graph()->zone(), scope, i);
+    const char* debug_name =
+        GetDebugParameterName(graph()->zone(), scope->AsDeclarationScope(), i);

[Michael Starzinger, 2016/08/03 13:02:19]

nit: See comment above.

     const Operator* op = common()->Parameter(param_num++, debug_name);
     Node* parameter = builder->graph()->NewNode(op, builder->graph()->start());
     values()->push_back(parameter);
   }
 
   // Bind all local variables to undefined.
   Node* undefined_constant = builder->jsgraph()->UndefinedConstant();
   values()->insert(values()->end(), locals_count(), undefined_constant);
 }
 
@@ skipping 2429 matching lines @@
   Node** all = info()->zone()->NewArray<Node*>(arity);
   for (int i = arity - 1; i >= 0; --i) {
     all[i] = environment()->Pop();
   }
   Node* value = NewNode(op, arity, all);
   return value;
 }
 
 
 Node* AstGraphBuilder::BuildLocalActivationContext(Node* context) {
-  Scope* scope = info()->scope();
+  DeclarationScope* scope = info()->scope();
 
   // Allocate a new local context.
   Node* local_context = scope->is_script_scope()
                             ? BuildLocalScriptContext(scope)
                             : BuildLocalFunctionContext(scope);
 
   if (scope->has_this_declaration() && scope->receiver()->IsContextSlot()) {
     Node* receiver = environment()->RawParameterLookup(0);
     // Context variable (at bottom of the context chain).
     Variable* variable = scope->receiver();
@@ skipping 1180 matching lines @@
     // Phi does not exist yet, introduce one.
     value = NewPhi(inputs, value, control);
     value->ReplaceInput(inputs - 1, other);
   }
   return value;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8