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());
+
+  if (array_len == 0) return constructor;
+
+  DCHECK(property_names->GetElementsKind() == FAST_ELEMENTS);
+  DCHECK(property_funcs->GetElementsKind() == FAST_ELEMENTS);
+  DCHECK(property_infos->GetElementsKind() == FAST_SMI_ELEMENTS);
+
+  Handle<FixedArray> property_names_elements(
+      FixedArray::cast(property_names->elements()));
+  Handle<FixedArray> property_funcs_elements(
+      FixedArray::cast(property_funcs->elements()));
+  Handle<FixedArray> property_infos_elements(
+      FixedArray::cast(property_infos->elements()));
+
+  for (int i = 0; i < array_len; ++i) {
+    Handle<Object> name_obj(property_names_elements->get(i), isolate);
+    DCHECK(name_obj->IsName());
+    Handle<Name> name = Handle<Name>::cast(name_obj);
+
+    Handle<Object> func_obj(property_funcs_elements->get(i), isolate);
+    DCHECK(func_obj->IsJSFunction());
+    Handle<JSFunction> func = Handle<JSFunction>::cast(func_obj);
+
+    Handle<Object> info_obj(property_infos_elements->get(i), isolate);
+    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