Install the 'name' property in classes at runtime

src/interpreter/bytecode-generator.cc

 // Copyright 2015 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/interpreter/bytecode-generator.h"
 
 #include "src/ast/compile-time-value.h"
 #include "src/ast/scopes.h"
 #include "src/code-stubs.h"
 #include "src/compilation-info.h"
@@ skipping 553 matching lines @@
       global_declarations_(0, info->zone()),
       function_literals_(0, info->zone()),
       native_function_literals_(0, info->zone()),
       execution_control_(nullptr),
       execution_context_(nullptr),
       execution_result_(nullptr),
       generator_resume_points_(info->literal()->yield_count(), info->zone()),
       generator_state_(),
       loop_depth_(0),
       home_object_symbol_(info->isolate()->factory()->home_object_symbol()),
-      prototype_string_(info->isolate()->factory()->prototype_string()) {
-}
+      prototype_string_(info->isolate()->factory()->prototype_string()),
+      name_string_(info->isolate()->factory()->name_string()) {}
 
 Handle<BytecodeArray> BytecodeGenerator::FinalizeBytecode(Isolate* isolate) {
   AllocateDeferredConstants();
   if (HasStackOverflow()) return Handle<BytecodeArray>();
   return builder()->ToBytecodeArray(isolate);
 }
 
 void BytecodeGenerator::AllocateDeferredConstants() {
   // Build global declaration pair arrays.
   for (GlobalDeclarationsBuilder* globals_builder : global_declarations_) {
@@ skipping 789 matching lines @@
                                              scope()->is_function_scope());
   size_t entry = builder()->AllocateConstantPoolEntry();
   builder()->CreateClosure(entry, flags);
   function_literals_.push_back(std::make_pair(expr, entry));
 }
 
 void BytecodeGenerator::VisitClassLiteral(ClassLiteral* expr) {
   VisitClassLiteralForRuntimeDefinition(expr);
 
   // Load the "prototype" from the constructor.
-  RegisterList args = register_allocator()->NewRegisterList(2);
+  RegisterList args = register_allocator()->NewRegisterList(3);
   Register literal = args[0];
   Register prototype = args[1];
   FeedbackVectorSlot slot = expr->PrototypeSlot();
   builder()
       ->StoreAccumulatorInRegister(literal)
       .LoadNamedProperty(literal, prototype_string(), feedback_index(slot))
       .StoreAccumulatorInRegister(prototype);
 
-  VisitClassLiteralProperties(expr, literal, prototype);
+  Register needs_name = args[2];

[rmcilroy, 2016/11/28 10:28:59]

This shouldn't be allocated in the same RegisterList as args since it's never
passed to a runtime call (actually looking at this, I'm not sure why we use a
RegisterList for this at all any more). It should just be a single register.
Saying that, I'm not keen on this approach of passing a register as a boolean
value (see below).

+  VisitClassLiteralProperties(expr, literal, prototype, needs_name);
+  BuildClassLiteralNameProperty(expr, literal, needs_name);
   builder()->CallRuntime(Runtime::kToFastProperties, literal);
   // Assign to class variable.
   if (expr->class_variable_proxy() != nullptr) {
     Variable* var = expr->class_variable_proxy()->var();
     FeedbackVectorSlot slot = expr->NeedsProxySlot()
                                   ? expr->ProxySlot()
                                   : FeedbackVectorSlot::Invalid();
     VisitVariableAssignment(var, Token::INIT, slot);
   }
 }
 
 void BytecodeGenerator::VisitClassLiteralForRuntimeDefinition(
     ClassLiteral* expr) {
   RegisterAllocationScope register_scope(this);
   RegisterList args = register_allocator()->NewRegisterList(4);
   VisitForAccumulatorValueOrTheHole(expr->extends());
   builder()->StoreAccumulatorInRegister(args[0]);
   VisitForRegisterValue(expr->constructor(), args[1]);
   builder()
       ->LoadLiteral(Smi::FromInt(expr->start_position()))
       .StoreAccumulatorInRegister(args[2])
       .LoadLiteral(Smi::FromInt(expr->end_position()))
       .StoreAccumulatorInRegister(args[3])
       .CallRuntime(Runtime::kDefineClass, args);
 }
 
 void BytecodeGenerator::VisitClassLiteralProperties(ClassLiteral* expr,
                                                     Register literal,
-                                                    Register prototype) {
+                                                    Register prototype,
+                                                    Register needs_name) {
   RegisterAllocationScope register_scope(this);
   RegisterList args = register_allocator()->NewRegisterList(5);
   Register receiver = args[0], key = args[1], value = args[2], attr = args[3],
            set_function_name = args[4];
 
   bool attr_assigned = false;
   Register old_receiver = Register::invalid_value();
 
+  // Initialize has_name_static_property.
+  bool check_name = !expr->has_name_static_property() &&

[Toon Verwaest, 2016/11/28 10:40:58]

Isn't the general case that we don't have a static computed property name? If
so, we should avoid this additional work in that case.

+                    !expr->constructor()->raw_name()->IsEmpty();
+  if (check_name) {
+    builder()->LoadTrue().StoreAccumulatorInRegister(needs_name);
+  }
+
   // Create nodes to store method values into the literal.
   for (int i = 0; i < expr->properties()->length(); i++) {
     ClassLiteral::Property* property = expr->properties()->at(i);
 
     // Set-up receiver.
     Register new_receiver = property->is_static() ? literal : prototype;
     if (new_receiver != old_receiver) {
       builder()->MoveRegister(new_receiver, receiver);
       old_receiver = new_receiver;
     }
 
     VisitForAccumulatorValue(property->key());
     builder()->ConvertAccumulatorToName(key);
 
     if (property->is_static() && property->is_computed_name()) {
+      // Check for a static property called "name".
+      if (check_name) {
+        BytecodeLabel has_name;
+        builder()
+            ->LoadAccumulatorWithRegister(needs_name)
+            .JumpIfFalse(&has_name)
+            .LoadLiteral(name_string())
+            .CompareOperation(Token::Value::EQ_STRICT, key)
+            .LogicalNot()
+            .StoreAccumulatorInRegister(needs_name)
+            .Bind(&has_name);
+      }

[rmcilroy, 2016/11/28 10:28:59]

I'm not keen on this extra code added to every property initialization. Do we
need it, or could we just rely on the compile time checks (e.g.,
expr->constructor()->raw_name()->IsEmpty() etc.) and have the runtime call check
if there was a computed property name which added the name property ?

[Toon Verwaest, 2016/11/28 10:40:58]

I agree, we should just do something more expensive in the runtime if this was
the case. It shouldn't be the common case anyway.

We can add it if we decide we it's common enough to avoid the runtime call
altogether.

+
       // The static prototype property is read only. We handle the non computed
       // property name case in the parser. Since this is the only case where we
       // need to check for an own read only property we special case this so we
       // do not need to do this for every property.
       BytecodeLabel done;
       builder()
           ->LoadLiteral(prototype_string())
           .CompareOperation(Token::Value::EQ_STRICT, key)
           .JumpIfFalse(&done)
           .CallRuntime(Runtime::kThrowStaticPrototypeError)
@@ skipping 29 matching lines @@
         break;
       }
       case ClassLiteral::Property::FIELD: {
         UNREACHABLE();
         break;
       }
     }
   }
 }
 
+void BytecodeGenerator::BuildClassLiteralNameProperty(ClassLiteral* expr,
+                                                      Register literal,
+                                                      Register needs_name) {
+  bool check_name = !expr->has_name_static_property() &&
+                    !expr->constructor()->raw_name()->IsEmpty();
+  if (check_name) {
+    BytecodeLabel has_name;
+    builder()
+        ->LoadAccumulatorWithRegister(needs_name)
+        .JumpIfFalse(&has_name)
+        .CallRuntime(Runtime::kInstallClassNameAccessor, literal)
+        .Bind(&has_name);
+  }
+}
+
 void BytecodeGenerator::VisitNativeFunctionLiteral(
     NativeFunctionLiteral* expr) {
   size_t entry = builder()->AllocateConstantPoolEntry();
   builder()->CreateClosure(entry, NOT_TENURED);
   native_function_literals_.push_back(std::make_pair(expr, entry));
 }
 
 void BytecodeGenerator::VisitDoExpression(DoExpression* expr) {
   VisitBlock(expr->block());
   VisitVariableProxy(expr->result());
@@ skipping 1681 matching lines @@
 }
 
 Runtime::FunctionId BytecodeGenerator::StoreKeyedToSuperRuntimeId() {
   return is_strict(language_mode()) ? Runtime::kStoreKeyedToSuper_Strict
                                     : Runtime::kStoreKeyedToSuper_Sloppy;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8