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 1374 matching lines @@
   RegisterList args = register_allocator()->NewRegisterList(2);
   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);
+  BuildClassLiteralNameProperty(expr, literal);
   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);
   }
 }
@@ skipping 81 matching lines @@
         break;
       }
       case ClassLiteral::Property::FIELD: {
         UNREACHABLE();
         break;
       }
     }
   }
 }
 
+void BytecodeGenerator::BuildClassLiteralNameProperty(ClassLiteral* expr,
+                                                      Register literal) {
+  if (!expr->has_name_static_property() &&
+      !expr->constructor()->raw_name()->IsEmpty()) {
+    RegisterList args = register_allocator()->NewRegisterList(2);
+    builder()
+        ->MoveRegister(literal, args[0])
+        .LoadBoolean(expr->has_static_computed_names())
+        .StoreAccumulatorInRegister(args[1])

[rmcilroy, 2016/11/29 13:05:23]

Rather than storing a compile time known boolean as an argument to the runtime
call, how about just creating two different runtime calls - one which does the
check and one which doesn't? Then the code here could be something like:

RuntimeId runtime_id = expr->has_static_computed_names() 
  ? Runtime::kInstallClassNameAccessorWithComputedNameCheck
  : Runtime::kInstallClassNameAccessor
builder()->CallRuntime(runtime_id, literal);

Which would be much fewer bytes. 

Toon - any objection to having two runtime calls for with and without the check
? 

+        .CallRuntime(Runtime::kInstallClassNameAccessor, args);
+  }
+}
+
 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