Refactor class declaration logic to the parser and runtime

src/runtime/runtime-classes.cc

 // Copyright 2014 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/runtime/runtime-utils.h"
 
 #include <stdlib.h>
 #include <limits>
 
 #include "src/arguments.h"
@@ skipping 66 matching lines @@
 
 
 RUNTIME_FUNCTION(Runtime_HomeObjectSymbol) {
   DCHECK(args.length() == 0);
   return isolate->heap()->home_object_symbol();
 }
 
 static MaybeHandle<Object> DefineClass(Isolate* isolate,
                                        Handle<Object> super_class,
                                        Handle<JSFunction> constructor,
+                                       Handle<JSArray> property_names,
+                                       Handle<JSArray> property_funcs,
+                                       Handle<JSArray> property_infos,
                                        int start_position, int end_position) {
   Handle<Object> prototype_parent;
   Handle<Object> constructor_parent;
 
   if (super_class->IsTheHole(isolate)) {
     prototype_parent = isolate->initial_object_prototype();
   } else {
     if (super_class->IsNull(isolate)) {
       prototype_parent = isolate->factory()->null_value();
     } else if (super_class->IsConstructor()) {
@@ skipping 66 matching lines @@
       Object::SetProperty(
           constructor, isolate->factory()->class_start_position_symbol(),
           handle(Smi::FromInt(start_position), isolate), STRICT),
       Object);
   RETURN_ON_EXCEPTION(
       isolate, Object::SetProperty(
                    constructor, isolate->factory()->class_end_position_symbol(),
                    handle(Smi::FromInt(end_position), isolate), STRICT),
       Object);
 
+  Object* array_length_obj = property_names->length();
+  CHECK(array_length_obj->IsSmi());
+  int array_len = Smi::cast(array_length_obj)->value();
+
+  DCHECK_EQ(array_length_obj, property_funcs->length());
+  DCHECK_EQ(array_length_obj, property_infos->length());
+
+  for (int i = 0; i < array_len; ++i) {
+    Handle<Object> name_obj =
+        JSReceiver::GetElement(isolate, property_names, i).ToHandleChecked();

[adamk, 2016/07/13 20:57:32]

These are probably one of the reasons this is slow. You're going through all the
machinery of property access.

One thing to try, at least to see if it speeds this up, is to access elements()
backing store directly, though of course this is a little scary. See
EstimateElementCount in builtins.cc for some example code (good enough at least
to try out for performance).

+    DCHECK(name_obj->IsName());
+    Handle<Name> name = Handle<Name>::cast(name_obj);
+
+    Handle<Object> func_obj =
+        JSReceiver::GetElement(isolate, property_funcs, i).ToHandleChecked();
+    DCHECK(func_obj->IsJSFunction());
+    Handle<JSFunction> func = Handle<JSFunction>::cast(func_obj);
+
+    Handle<Object> info_obj =
+        JSReceiver::GetElement(isolate, property_infos, i).ToHandleChecked();
+    DCHECK(info_obj->IsSmi());
+    int info = Smi::cast(*info_obj)->value();
+
+    bool is_static = info & kIsStaticMask;
+
+    if (is_static) {
+      if (Name::Equals(name, isolate->factory()->prototype_string())) {
+        THROW_NEW_ERROR(
+            isolate, NewTypeError(MessageTemplate::kStaticPrototype), Object);
+      }
+    }
+
+    Handle<JSObject> receiver =
+        is_static ? static_cast<Handle<JSObject>>(constructor) : prototype;
+
+    if (func->shared()->needs_home_object()) {
+      RETURN_ON_EXCEPTION(isolate,
+                          JSObject::SetOwnPropertyIgnoreAttributes(
+                              func, home_object_symbol, receiver, DONT_ENUM),
+                          Object);
+    }
+
+    if (info & kIsAccessorMask) {
+      if (info & kIsSetterMask) {
+        // Setter
+        if (String::cast(func->shared()->name())->length() == 0) {
+          JSFunction::SetName(func, name, isolate->factory()->set_string());
+        }
+
+        RETURN_ON_EXCEPTION(
+            isolate, JSObject::DefineAccessor(receiver, name,
+                                              isolate->factory()->null_value(),
+                                              func, DONT_ENUM),
+            Object);
+      } else {
+        // Getter
+        if (String::cast(func->shared()->name())->length() == 0) {
+          JSFunction::SetName(func, name, isolate->factory()->get_string());
+        }
+
+        RETURN_ON_EXCEPTION(
+            isolate, JSObject::DefineAccessor(receiver, name, func,
+                                              isolate->factory()->null_value(),
+                                              DONT_ENUM),
+            Object);
+      }
+    } else {
+      // Method
+      if (String::cast(func->shared()->name())->length() == 0) {
+        JSFunction::SetName(func, name, isolate->factory()->empty_string());
+      }
+
+      LookupIterator it = LookupIterator::PropertyOrElement(
+          isolate, receiver, name, receiver, LookupIterator::OWN);
+      CHECK(JSObject::DefineOwnPropertyIgnoreAttributes(&it, func, DONT_ENUM,
+                                                        Object::DONT_THROW)
+                .IsJust());
+    }
+  }
+
   return constructor;
 }
 
 
 RUNTIME_FUNCTION(Runtime_DefineClass) {
   HandleScope scope(isolate);
-  DCHECK(args.length() == 4);
+  DCHECK(args.length() == 7);
   CONVERT_ARG_HANDLE_CHECKED(Object, super_class, 0);
   CONVERT_ARG_HANDLE_CHECKED(JSFunction, constructor, 1);
-  CONVERT_SMI_ARG_CHECKED(start_position, 2);
-  CONVERT_SMI_ARG_CHECKED(end_position, 3);
+  CONVERT_ARG_HANDLE_CHECKED(JSArray, property_names, 2);
+  CONVERT_ARG_HANDLE_CHECKED(JSArray, property_funcs, 3);
+  CONVERT_ARG_HANDLE_CHECKED(JSArray, property_infos, 4);
+  CONVERT_SMI_ARG_CHECKED(start_position, 5);
+  CONVERT_SMI_ARG_CHECKED(end_position, 6);
 
   RETURN_RESULT_OR_FAILURE(
-      isolate, DefineClass(isolate, super_class, constructor, start_position,
+      isolate, DefineClass(isolate, super_class, constructor, property_names,
+                           property_funcs, property_infos, start_position,
                            end_position));
 }
 
 
 static MaybeHandle<Object> LoadFromSuper(Isolate* isolate,
                                          Handle<Object> receiver,
                                          Handle<JSObject> home_object,
                                          Handle<Name> name) {
   if (home_object->IsAccessCheckNeeded() &&
       !isolate->MayAccess(handle(isolate->context()), home_object)) {
@@ skipping 193 matching lines @@
 
 RUNTIME_FUNCTION(Runtime_GetSuperConstructor) {
   SealHandleScope shs(isolate);
   DCHECK_EQ(1, args.length());
   CONVERT_ARG_CHECKED(JSFunction, active_function, 0);
   return active_function->map()->prototype();
 }
 
 }  // namespace internal
 }  // namespace v8