Represent v8::Maybe<bool> in rust as Option<bool> (#73)

src/binding.cc

@@ -306,16 +306,16 @@ v8::Promise* v8__Promise__Resolver__GetPromise(v8::Promise::Resolver* self) {
   return local_to_ptr(self->GetPromise());
 }
 
-bool v8__Promise__Resolver__Resolve(v8::Promise::Resolver* self,
+MaybeBool v8__Promise__Resolver__Resolve(v8::Promise::Resolver* self,
-                                    v8::Local<v8::Context> context,
+                                         v8::Local<v8::Context> context,
-                                    v8::Local<v8::Value> value) {
+                                         v8::Local<v8::Value> value) {
-  return maybe_to_value(self->Resolve(context, value), false);
+  return maybe_to_maybe_bool(self->Resolve(context, value));
 }
 
-bool v8__Promise__Resolver__Reject(v8::Promise::Resolver* self,
+MaybeBool v8__Promise__Resolver__Reject(v8::Promise::Resolver* self,
-                                   v8::Local<v8::Context> context,
+                                        v8::Local<v8::Context> context,
-                                   v8::Local<v8::Value> value) {
+                                        v8::Local<v8::Value> value) {
-  return maybe_to_value(self->Reject(context, value), false);
+  return maybe_to_maybe_bool(self->Reject(context, value));
 }
 
 v8::Promise::PromiseState v8__Promise__State(v8::Promise* self) {

src/promise.rs

@@ -1,3 +1,4 @@
+use crate::support::MaybeBool;
 use crate::support::Opaque;
 use crate::Context;
 use crate::Function;
@@ -14,12 +15,12 @@ extern "C" {
     resolver: *mut PromiseResolver,
     context: *mut Context,
     value: *mut Value,
-  ) -> bool;
+  ) -> MaybeBool;
   fn v8__Promise__Resolver__Reject(
     resolver: *mut PromiseResolver,
     context: *mut Context,
     value: *mut Value,
-  ) -> bool;
+  ) -> MaybeBool;
   fn v8__Promise__State(promise: *mut Promise) -> PromiseState;
   fn v8__Promise__HasHandler(promise: *mut Promise) -> bool;
   fn v8__Promise__Result(promise: *mut Promise) -> *mut Value;
@@ -157,9 +158,10 @@ impl PromiseResolver {
     &mut self,
     mut context: Local<'sc, Context>,
     mut value: Local<'sc, Value>,
-  ) -> bool {
+  ) -> Option<bool> {
     unsafe {
       v8__Promise__Resolver__Resolve(&mut *self, &mut *context, &mut *value)
+        .into()
     }
   }
 
@@ -170,9 +172,10 @@ impl PromiseResolver {
     &mut self,
     mut context: Local<'sc, Context>,
     mut value: Local<'sc, Value>,
-  ) -> bool {
+  ) -> Option<bool> {
     unsafe {
       v8__Promise__Resolver__Reject(&mut *self, &mut *context, &mut *value)
+        .into()
     }
   }
 }

src/support.h

@@ -33,6 +33,19 @@ void construct_in_place(uninit_t<T>& buf, Args... args) {
   new (&buf)
       construct_in_place_helper<T, Args...>(buf, std::forward<Args>(args)...);
 }
+
+// The C-ABI compatible equivalent of V8's Maybe<bool>.
+enum class MaybeBool { JustFalse = 0, JustTrue = 1, Nothing = 2 };
+
+inline static MaybeBool maybe_to_maybe_bool(v8::Maybe<bool> maybe) {
+  if (maybe.IsNothing()) {
+    return MaybeBool::Nothing;
+  } else if (maybe.FromJust()) {
+    return MaybeBool::JustTrue;
+  } else {
+    return MaybeBool::JustFalse;
+  }
+}
 }  // namespace support
 
 template <class T>
@@ -59,9 +72,4 @@ inline static v8::MaybeLocal<T> ptr_to_maybe_local(T* ptr) {
   return *reinterpret_cast<v8::MaybeLocal<T>*>(&ptr);
 }
 
-template <class T>
-inline static T maybe_to_value(v8::Maybe<T> maybe, T default_value) {
-  return maybe.FromMaybe(default_value);
-}
-
 #endif  // SUPPORT_H_

src/support.rs

@@ -137,6 +137,24 @@ where
   }
 }
 
+#[repr(C)]
+#[derive(Debug)]
+pub enum MaybeBool {
+  JustFalse = 0,
+  JustTrue = 1,
+  Nothing = 2,
+}
+
+impl Into<Option<bool>> for MaybeBool {
+  fn into(self) -> Option<bool> {
+    match self {
+      MaybeBool::JustFalse => Some(false),
+      MaybeBool::JustTrue => Some(true),
+      MaybeBool::Nothing => None,
+    }
+  }
+}
+
 #[derive(Copy, Clone, Debug)]
 #[repr(transparent)]
 pub struct CxxVTable(pub *const Opaque);

tests/test_api.rs

@@ -432,7 +432,7 @@ fn promise_rejected() {
       v8::String::new(scope, "test", v8::NewStringType::Normal).unwrap();
     let value: Local<v8::Value> = cast(str);
     let rejected = resolver.reject(context, value);
-    assert!(rejected);
+    assert!(rejected.unwrap());
     assert_eq!(promise.state(), v8::PromiseState::Rejected);
     let result = promise.result(scope);
     let result_str: v8::Local<v8::String> = cast(result);