WIP: new.target

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/scopes.h"
 
 #include "src/accessors.h"
 #include "src/bootstrapper.h"
@@ skipping 138 matching lines @@
   new_target_ = nullptr;
   function_ = NULL;
   arguments_ = NULL;
   illegal_redecl_ = NULL;
   scope_inside_with_ = false;
   scope_contains_with_ = false;
   scope_calls_eval_ = false;
   scope_uses_arguments_ = false;
   scope_uses_super_property_ = false;
   scope_uses_this_ = false;
+  scope_uses_new_target_ = 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;
   outer_scope_calls_sloppy_eval_ = false;
   inner_scope_calls_eval_ = false;
   inner_scope_uses_arguments_ = false;
   inner_scope_uses_this_ = false;
+  inner_scope_uses_new_target_ = false;
   inner_scope_uses_super_property_ = false;
   force_eager_compilation_ = false;
   force_context_allocation_ = (outer_scope != NULL && !is_function_scope())
       ? outer_scope->has_forced_context_allocation() : false;
   num_var_or_const_ = 0;
   num_stack_slots_ = 0;
   num_heap_slots_ = 0;
   num_modules_ = 0;
   module_var_ = NULL,
   rest_parameter_ = NULL;
@@ skipping 111 matching lines @@
     scope_inside_with_ = outer_scope_->scope_inside_with_ || is_with_scope();
   } else {
     scope_inside_with_ = is_with_scope();
   }
 
   // Declare convenience variables.
   // Declare and allocate receiver (even for the script scope, and even
   // if naccesses_ == 0).
   // NOTE: When loading parameters in the script scope, we must take
   // care not to access them as properties of the global object, but
-  // instead load them directly from the stack. Currently, the only
-  // such parameter is 'this' which is passed on the stack when
-  // invoking scripts
+  // instead load them directly from the stack. Currently, the only two
+  // such parameter are 'this' and 'new.target' which are passed on the stack
+  // when invoking scripts
   if (is_declaration_scope()) {
     DCHECK(!subclass_constructor || is_function_scope());
     Variable* var = variables_.Declare(
         this, ast_value_factory_->this_string(),
         subclass_constructor ? CONST : VAR, false, Variable::THIS,
         subclass_constructor ? kNeedsInitialization : kCreatedInitialized);
     var->AllocateTo(Variable::PARAMETER, -1);
     receiver_ = var;
 
-    if (subclass_constructor) {
-      new_target_ = variables_.Declare(
-          this, ast_value_factory_->new_target_string(), CONST, false,
-          Variable::NEW_TARGET, kCreatedInitialized);
-      new_target_->AllocateTo(Variable::PARAMETER, -2);
+    // TODO(arv): Can the construct call check if new target is needed?
+    // TODO(arv): Make `new.target` generate `%_IsConstruct() ? new.target :
+    // undefined
+    new_target_ =

[Dmitry Lomov (no reviews), 2015/02/25 11:28:40]

I'd prefer not declaring new.target if it is not needed.

[arv (Not doing code reviews), 2015/02/25 14:47:25]

This is where I was when I got pulled into other work. My plan was to do this
all conditionally but it fails because scope_uses_new_target_ was not getting
applied correctly. At one point I thought I could do the parsing part in one CL.
However, the parser needs new_target_ to be allocated (theres a DCHECK iirc).

This is where the CL is incomplete. The tracking of new.target is not working
correctly.

+        variables_.Declare(this, ast_value_factory_->new_target_string(), CONST,
+                           false, Variable::NEW_TARGET, kCreatedInitialized);
+    new_target_->AllocateTo(Variable::PARAMETER, -2);

[arv (Not doing code reviews), 2015/02/25 14:47:24]

Do you think this is OK for cases like?

function f() {
  print(new.target);
}
new f()

[Dmitry Lomov (no reviews), 2015/02/26 14:15:05]

Depends on the codegen we will have for such functions.

+    if (subclass_constructor || scope_uses_new_target_) {
       new_target_->set_is_used();
     }
   } else {
     DCHECK(outer_scope() != NULL);
     receiver_ = outer_scope()->receiver();
   }
 
   if (is_function_scope()) {
     // Declare 'arguments' variable which exists in all functions.
     // Note that it might never be accessed, in which case it won't be
@@ skipping 31 matching lines @@
 
   // Move unresolved variables
   for (int i = 0; i < unresolved_.length(); i++) {
     outer_scope()->unresolved_.Add(unresolved_[i], zone());
   }
 
   // Propagate usage flags to outer scope.
   if (uses_arguments()) outer_scope_->RecordArgumentsUsage();
   if (uses_super_property()) outer_scope_->RecordSuperPropertyUsage();
   if (uses_this()) outer_scope_->RecordThisUsage();
+  if (uses_new_target()) outer_scope_->RecordNewTargetUsage();
 
   return NULL;
 }
 
 
 Variable* Scope::LookupLocal(const AstRawString* name) {
   Variable* result = variables_.Lookup(name);
   if (result != NULL || scope_info_.is_null()) {
     return result;
   }
@@ skipping 508 matching lines @@
   } else if (is_strict(language_mode())) {
     Indent(n1, "// strict mode scope\n");
   }
   if (scope_inside_with_) Indent(n1, "// scope inside 'with'\n");
   if (scope_contains_with_) Indent(n1, "// scope contains 'with'\n");
   if (scope_calls_eval_) Indent(n1, "// scope calls 'eval'\n");
   if (scope_uses_arguments_) Indent(n1, "// scope uses 'arguments'\n");
   if (scope_uses_super_property_)
     Indent(n1, "// scope uses 'super' property\n");
   if (scope_uses_this_) Indent(n1, "// scope uses 'this'\n");
+  if (scope_uses_new_target_) Indent(n1, "// scope uses 'new.target'\n");
   if (inner_scope_uses_arguments_) {
     Indent(n1, "// inner scope uses 'arguments'\n");
   }
   if (inner_scope_uses_super_property_)
     Indent(n1, "// inner scope uses 'super' property\n");
   if (inner_scope_uses_this_) Indent(n1, "// inner scope uses 'this'\n");
+  if (inner_scope_uses_new_target_) {
+    Indent(n1, "// inner scope uses 'new.target'\n");
+  }
   if (outer_scope_calls_sloppy_eval_) {
     Indent(n1, "// outer scope calls 'eval' in sloppy context\n");
   }
   if (inner_scope_calls_eval_) Indent(n1, "// inner scope calls 'eval'\n");
   if (num_stack_slots_ > 0) { Indent(n1, "// ");
   PrintF("%d stack slots\n", num_stack_slots_); }
   if (num_heap_slots_ > 0) { Indent(n1, "// ");
   PrintF("%d heap slots\n", num_heap_slots_); }
 
   // Print locals.
@@ skipping 222 matching lines @@
       if (inner->scope_uses_arguments_ || inner->inner_scope_uses_arguments_) {
         inner_scope_uses_arguments_ = true;
       }
       if (inner->scope_uses_super_property_ ||
           inner->inner_scope_uses_super_property_) {
         inner_scope_uses_super_property_ = true;
       }
       if (inner->scope_uses_this_ || inner->inner_scope_uses_this_) {
         inner_scope_uses_this_ = true;
       }
+      if (inner->scope_uses_new_target_ ||
+          inner->inner_scope_uses_new_target_) {
+        inner_scope_uses_new_target_ = true;
+      }
     }
     if (inner->force_eager_compilation_) {
       force_eager_compilation_ = true;
     }
     if (asm_module_ && inner->scope_type() == FUNCTION_SCOPE) {
       inner->asm_function_ = true;
     }
   }
 }
 
@@ skipping 229 matching lines @@
 }
 
 
 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