Revert of [es6] Super call in arrows and eval

src/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/v8.h"
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
 #include "src/messages.h"
 #include "src/parser.h"
@@ skipping 142 matching lines @@
   scope_type_ = scope_type;
   function_kind_ = function_kind;
   block_scope_is_class_scope_ = false;
   scope_name_ = ast_value_factory_->empty_string();
   dynamics_ = nullptr;
   receiver_ = nullptr;
   new_target_ = nullptr;
   function_ = nullptr;
   arguments_ = nullptr;
   home_object_ = nullptr;
-  this_function_ = nullptr;
   illegal_redecl_ = nullptr;
   scope_inside_with_ = false;
   scope_contains_with_ = false;
   scope_calls_eval_ = false;
   scope_uses_arguments_ = false;
   scope_uses_super_property_ = false;
   asm_module_ = false;
   asm_function_ = outer_scope != NULL && outer_scope->asm_module_;
   // Inherit the language mode from the parent scope.
   language_mode_ = outer_scope != NULL ? outer_scope->language_mode_ : SLOPPY;
@@ skipping 128 matching lines @@
 
   // Add this scope as a new inner scope of the outer scope.
   if (outer_scope_ != NULL) {
     outer_scope_->inner_scopes_.Add(this, zone());
     scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
   } else {
     scope_inside_with_ = is_with_scope();
   }
 
   // Declare convenience variables and the receiver.
-  if (is_declaration_scope() && has_this_declaration()) {
-    Variable* var = variables_.Declare(
-        this, ast_value_factory_->this_string(),
-        subclass_constructor ? CONST : VAR, Variable::THIS,
-        subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
-    receiver_ = var;
-  }
-
-  if (is_function_scope()) {
-    if (!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);
+  if (is_declaration_scope()) {
+    DCHECK(!subclass_constructor || is_function_scope());
+    if (has_this_declaration()) {
+      Variable* var = variables_.Declare(
+          this, ast_value_factory_->this_string(),
+          subclass_constructor ? CONST : VAR, Variable::THIS,
+          subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
+      receiver_ = var;
     }
 
     if (subclass_constructor) {
-      DCHECK(!is_arrow_scope());
-      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::NEW_TARGET, kCreatedInitialized);
+      new_target_->AllocateTo(Variable::PARAMETER, -2);
+      new_target_->set_is_used();
     }
+  }
 
-    if (IsConciseMethod(function_kind_) || IsConstructor(function_kind_) ||
-        IsAccessorFunction(function_kind_)) {
-      DCHECK(!is_arrow_scope());
-      // Declare '.home_object' variable which exists in all methods.
-      // Note that it might never be accessed, in which case it won't be
-      // allocated during variable allocation.
-      variables_.Declare(this, ast_value_factory_->home_object_string(), CONST,
-                         Variable::NORMAL, kCreatedInitialized);
-    }
+  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);
+  }
 
-    if (IsSubclassConstructor(function_kind_)) {
-      DCHECK(!is_arrow_scope());
-      variables_.Declare(this, ast_value_factory_->this_function_string(),
-                         CONST, Variable::NORMAL, kCreatedInitialized);
-    }
+  if (is_function_scope() &&
+      (IsConciseMethod(function_kind_) || IsConstructor(function_kind_) ||
+       IsAccessorFunction(function_kind_))) {
+    DCHECK(!is_arrow_scope());
+    // Declare '.home_object' variable which exists in all methods.
+    // Note that it might never be accessed, in which case it won't be
+    // allocated during variable allocation.
+    variables_.Declare(this, ast_value_factory_->home_object_string(), VAR,
+                       Variable::NORMAL, kCreatedInitialized);
   }
 }
 
 
 Scope* Scope::FinalizeBlockScope() {
   DCHECK(is_block_scope());
   DCHECK(internals_.is_empty());
   DCHECK(temps_.is_empty());
   DCHECK(params_.is_empty());
 
@@ skipping 944 matching lines @@
       inner->asm_function_ = true;
     }
   }
 }
 
 
 bool Scope::MustAllocate(Variable* var) {
   // Give var a read/write use if there is a chance it might be accessed
   // via an eval() call.  This is only possible if the variable has a
   // visible name.
-  if ((var->is_this() || !var->raw_name()->IsEmpty()) &&
+  if ((var->is_this() || var->is_new_target() || !var->raw_name()->IsEmpty()) &&
       (var->has_forced_context_allocation() || scope_calls_eval_ ||
        inner_scope_calls_eval_ || scope_contains_with_ || is_catch_scope() ||
        is_block_scope() || is_module_scope() || is_script_scope())) {
     var->set_is_used();
     if (scope_calls_eval_ || inner_scope_calls_eval_) var->set_maybe_assigned();
   }
   // Global variables do not need to be allocated.
   return !var->IsGlobalObjectProperty() && var->is_used();
 }
 
@@ skipping 71 matching lines @@
     // In strict mode 'arguments' does not alias formal parameters.
     // Therefore in strict mode we allocate parameters as if 'arguments'
     // were not used.
     uses_sloppy_arguments = is_sloppy(language_mode());
   }
 
   if (rest_parameter_ && !MustAllocate(rest_parameter_)) {
     rest_parameter_ = NULL;
   }
 
+  Variable* home_object_var =
+      LookupLocal(ast_value_factory_->home_object_string());
+  if (home_object_var != nullptr && uses_super_property() &&
+      MustAllocate(home_object_var)) {
+    // TODO(arv): super() uses a SuperReference so it generates a VariableProxy
+    // for the .home_object which makes it look like we need to allocate the
+    // home_object_var.
+    // Consider splitting the AST node into 2 different nodes since the
+    // semantics is just so different.
+    home_object_ = home_object_var;
+  }
+
   // 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;
 
     DCHECK(var->scope() == this);
     if (uses_sloppy_arguments || has_forced_context_allocation()) {
@@ skipping 68 matching lines @@
   vars.Sort(VarAndOrder::Compare);
   int var_count = vars.length();
   for (int i = 0; i < var_count; i++) {
     AllocateNonParameterLocal(isolate, vars[i].var());
   }
 
   // For now, function_ must be allocated at the very end.  If it gets
   // allocated in the context, it must be the last slot in the context,
   // because of the current ScopeInfo implementation (see
   // ScopeInfo::ScopeInfo(FunctionScope* scope) constructor).
-  if (function_ != nullptr) {
+  if (function_ != NULL) {
     AllocateNonParameterLocal(isolate, function_->proxy()->var());
   }
 
-  if (rest_parameter_ != nullptr) {
+  if (rest_parameter_) {
     AllocateNonParameterLocal(isolate, rest_parameter_);
   }
-
-  Variable* home_object_var =
-      LookupLocal(ast_value_factory_->home_object_string());
-  if (home_object_var != nullptr && MustAllocate(home_object_var)) {
-    home_object_ = home_object_var;
-  }
-
-  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;
-  }
-
-  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;
-  }
 }
 
 
 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++) {
     inner_scopes_[i]->AllocateVariablesRecursively(isolate);
@@ skipping 50 matching lines @@
       (function_ != NULL && function_->proxy()->var()->IsStackLocal() ? 1 : 0);
 }
 
 
 int Scope::ContextLocalCount() const {
   if (num_heap_slots() == 0) return 0;
   return num_heap_slots() - Context::MIN_CONTEXT_SLOTS -
       (function_ != NULL && function_->proxy()->var()->IsContextSlot() ? 1 : 0);
 }
 } }  // namespace v8::internal