Simplify Object constructor (#149)

src/binding.cc

@@ -335,9 +335,7 @@ two_pointers_t v8__ArrayBuffer__GetBackingStore(v8::ArrayBuffer& self) {
   return make_pod<two_pointers_t>(self.GetBackingStore());
 }
 
-void* v8__BackingStore__Data(v8::BackingStore& self) {
+void* v8__BackingStore__Data(v8::BackingStore& self) { return self.Data(); }
-  return self.Data();
-}
 
 size_t v8__BackingStore__ByteLength(v8::BackingStore& self) {
   return self.ByteLength();
@@ -382,7 +380,11 @@ int v8__String__WriteUtf8(const v8::String& self, v8::Isolate* isolate,
   return self.WriteUtf8(isolate, buffer, length, nchars_ref, options);
 }
 
-v8::Object* v8__Object__New(v8::Isolate* isolate,
+v8::Object* v8__Object__New(v8::Isolate* isolate) {
+  return local_to_ptr(v8::Object::New(isolate));
+}
+
+v8::Object* v8__Object__New2(v8::Isolate* isolate,
                              v8::Local<v8::Value> prototype_or_null,
                              v8::Local<v8::Name>* names,
                              v8::Local<v8::Value>* values, size_t length) {
@@ -686,7 +688,8 @@ v8::PrimitiveArray* v8__ScriptOrModule__GetHostDefinedOptions(
   return local_to_ptr(self.GetHostDefinedOptions());
 }
 
-v8::SharedArrayBuffer* v8__SharedArrayBuffer__New(v8::Isolate* isolate, size_t byte_length) {
+v8::SharedArrayBuffer* v8__SharedArrayBuffer__New(v8::Isolate* isolate,
+                                                  size_t byte_length) {
   return local_to_ptr(v8::SharedArrayBuffer::New(isolate, byte_length));
 }
 
@@ -694,7 +697,8 @@ size_t v8__SharedArrayBuffer__ByteLength(v8::SharedArrayBuffer& self) {
   return self.ByteLength();
 }
 
-two_pointers_t v8__SharedArrayBuffer__GetBackingStore(v8::SharedArrayBuffer& self) {
+two_pointers_t v8__SharedArrayBuffer__GetBackingStore(
+    v8::SharedArrayBuffer& self) {
   return make_pod<two_pointers_t>(self.GetBackingStore());
 }
 

src/object.rs

@@ -14,7 +14,8 @@ use crate::Value;
 pub struct Object(Opaque);
 
 extern "C" {
-  fn v8__Object__New(
+  fn v8__Object__New(isolate: *mut Isolate) -> *mut Object;
+  fn v8__Object__New2(
     isolate: *mut Isolate,
     prototype_or_null: *mut Value,
     names: *mut *mut Name,
@@ -43,19 +44,26 @@ extern "C" {
 }
 
 impl Object {
+  /// Creates an empty object.
+  pub fn new<'sc>(scope: &mut impl ToLocal<'sc>) -> Local<'sc, Object> {
+    let ptr = unsafe { v8__Object__New(scope.isolate()) };
+    unsafe { scope.to_local(ptr) }.unwrap()
+  }
+
   /// Creates a JavaScript object with the given properties, and
   /// a the given prototype_or_null (which can be any JavaScript
   /// value, and if it's null, the newly created object won't have
   /// a prototype at all). This is similar to Object.create().
   /// All properties will be created as enumerable, configurable
   /// and writable properties.
-  pub fn new<'sc>(
+  pub fn new2<'sc>(
     scope: &mut impl ToLocal<'sc>,
     mut prototype_or_null: Local<'sc, Value>,
     names: Vec<Local<'sc, Name>>,
     values: Vec<Local<'sc, Value>>,
-    length: usize,
   ) -> Local<'sc, Object> {
+    let length = names.len();
+    assert_eq!(length, values.len());
     let mut names_: Vec<*mut Name> = vec![];
     for mut name in names {
       let n = &mut *name;
@@ -68,7 +76,7 @@ impl Object {
       values_.push(n);
     }
     let ptr = unsafe {
-      v8__Object__New(
+      v8__Object__New2(
         scope.isolate(),
         &mut *prototype_or_null,
         names_.as_mut_ptr(),

tests/test_api.rs

@@ -725,8 +725,12 @@ fn object() {
     let v1: v8::Local<v8::Value> = v8::Number::new(scope, 1.0).into();
     let v2: v8::Local<v8::Value> = v8::Number::new(scope, 2.0).into();
     let values = vec![v1, v2];
-    let object = v8::Object::new(scope, null, names, values, 2);
+    let object = v8::Object::new2(scope, null, names, values);
     assert!(!object.is_null_or_undefined());
+
+    let object_ = v8::Object::new(scope);
+    assert!(!object_.is_null_or_undefined());
+
     context.exit();
   }
   drop(locker);