Eagerly set arguments_, new_target_ and ths_function_ in Scope

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 "src/accessors.h"
 #include "src/ast/scopeinfo.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
@@ skipping 302 matching lines @@
         this, ast_value_factory_->this_string(),
         subclass_constructor ? CONST : VAR, Variable::THIS,
         subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
     receiver_ = var;
   }
 
   if (is_function_scope() && !is_arrow_scope()) {
     // Declare 'arguments' variable which exists in all non arrow functions.
     // Note that it might never be accessed, in which case it won't be
     // allocated during variable allocation.
-    variables_.Declare(this, ast_value_factory_->arguments_string(), VAR,
-                       Variable::ARGUMENTS, kCreatedInitialized);
+    arguments_ =
+        variables_.Declare(this, ast_value_factory_->arguments_string(), VAR,
+                           Variable::ARGUMENTS, kCreatedInitialized);
 
-    variables_.Declare(this, ast_value_factory_->new_target_string(), CONST,
-                       Variable::NORMAL, kCreatedInitialized);
+    new_target_ =
+        variables_.Declare(this, ast_value_factory_->new_target_string(), CONST,
+                           Variable::NORMAL, kCreatedInitialized);
 
     if (IsConciseMethod(function_kind_) || IsClassConstructor(function_kind_) ||
         IsAccessorFunction(function_kind_)) {
-      variables_.Declare(this, ast_value_factory_->this_function_string(),
-                         CONST, Variable::NORMAL, kCreatedInitialized);
+      this_function_ =
+          variables_.Declare(this, ast_value_factory_->this_function_string(),
+                             CONST, Variable::NORMAL, kCreatedInitialized);
     }
   }
 }
 
 
 Scope* Scope::FinalizeBlockScope() {
   DCHECK(is_block_scope());
   DCHECK(temps_.is_empty());
   DCHECK(params_.is_empty());
 
@@ skipping 982 matching lines @@
 }
 
 
 void Scope::AllocateHeapSlot(Variable* var) {
   var->AllocateTo(VariableLocation::CONTEXT, num_heap_slots_++);
 }
 
 
 void Scope::AllocateParameterLocals(Isolate* isolate) {
   DCHECK(is_function_scope());
-  Variable* arguments = LookupLocal(ast_value_factory_->arguments_string());
-  // Functions have 'arguments' declared implicitly in all non arrow functions.
-  DCHECK(arguments != nullptr || is_arrow_scope());
 
   bool uses_sloppy_arguments = false;
 
-  if (arguments != nullptr && MustAllocate(arguments) &&
-      !HasArgumentsParameter(isolate)) {
+  // Functions have 'arguments' declared implicitly in all non arrow functions.
+  if (arguments_ != nullptr) {
     // 'arguments' is used. Unless there is also a parameter called
     // 'arguments', we must be conservative and allocate all parameters to
     // the context assuming they will be captured by the arguments object.
     // If we have a parameter named 'arguments', a (new) value is always
     // assigned to it via the function invocation. Then 'arguments' denotes
     // that specific parameter value and cannot be used to access the
     // parameters, which is why we don't need to allocate an arguments
     // object in that case.
+    if (MustAllocate(arguments_) && !HasArgumentsParameter(isolate)) {
+      // In strict mode 'arguments' does not alias formal parameters.
+      // Therefore in strict mode we allocate parameters as if 'arguments'
+      // were not used.
+      // If the parameter list is not simple, arguments isn't sloppy either.
+      uses_sloppy_arguments =
+          is_sloppy(language_mode()) && has_simple_parameters();
+    } else {
+      // 'arguments' is unused. Tell the code generator that it does not need to
+      // allocate the arguments object by nulling out arguments_.
+      arguments_ = nullptr;
+    }
 
-    // We are using 'arguments'. Tell the code generator that is needs to
-    // allocate the arguments object by setting 'arguments_'.
-    arguments_ = arguments;
-
-    // In strict mode 'arguments' does not alias formal parameters.
-    // Therefore in strict mode we allocate parameters as if 'arguments'
-    // were not used.
-    // If the parameter list is not simple, arguments isn't sloppy either.
-    uses_sloppy_arguments =
-        is_sloppy(language_mode()) && has_simple_parameters();
+  } else {
+    DCHECK(is_arrow_scope());
   }
 
   if (rest_parameter_ && !MustAllocate(rest_parameter_)) {
-    rest_parameter_ = NULL;
+    rest_parameter_ = nullptr;
   }
 
   // The same parameter may occur multiple times in the parameters_ list.
   // If it does, and if it is not copied into the context object, it must
   // receive the highest parameter index for that parameter; thus iteration
   // order is relevant!
   for (int i = params_.length() - 1; i >= 0; --i) {
     Variable* var = params_[i];
     if (var == rest_parameter_) continue;
 
@@ skipping 101 matching lines @@
   // because of the current ScopeInfo implementation (see
   // ScopeInfo::ScopeInfo(FunctionScope* scope) constructor).
   if (function_ != nullptr) {
     AllocateNonParameterLocal(isolate, function_->proxy()->var());
   }
 
   if (rest_parameter_ != nullptr) {
     AllocateNonParameterLocal(isolate, rest_parameter_);
   }
 
-  Variable* new_target_var =
-      LookupLocal(ast_value_factory_->new_target_string());
-  if (new_target_var != nullptr && MustAllocate(new_target_var)) {
-    new_target_ = new_target_var;
+  if (new_target_ != nullptr && !MustAllocate(new_target_)) {
+    new_target_ = nullptr;
   }
 
-  Variable* this_function_var =
-      LookupLocal(ast_value_factory_->this_function_string());
-  if (this_function_var != nullptr && MustAllocate(this_function_var)) {
-    this_function_ = this_function_var;
+  if (this_function_ != nullptr && !MustAllocate(this_function_)) {
+    this_function_ = nullptr;
   }
 }
 
 
 void Scope::AllocateVariablesRecursively(Isolate* isolate) {
   if (!already_resolved()) {
     num_stack_slots_ = 0;
   }
   // Allocate variables for inner scopes.
   for (int i = 0; i < inner_scopes_.length(); i++) {
@@ skipping 44 matching lines @@
       function_ != NULL && function_->proxy()->var()->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