Put wrappers around functions that return JS::Values

Author: Alan Jeffrey

src/glue.rs

@@ -233,7 +233,7 @@ extern "C" {
                           aHandler: *const ::libc::c_void)
      -> *mut JSObject;
     pub fn GetWindowProxyClass() -> *const Class;
-    pub fn GetProxyReservedSlot(obj: *mut JSObject, slot: u32) -> JS::Value;
+    pub fn GetProxyReservedSlot(obj: *mut JSObject, slot: u32, dest: *mut JS::Value);
     pub fn GetProxyPrivate(obj: *mut JSObject) -> Value;
     pub fn SetProxyReservedSlot(obj: *mut JSObject, slot: u32, val: *const JS::Value);
     pub fn SetProxyPrivate(obj: *mut JSObject, expando: *const JS::Value);
@@ -339,4 +339,12 @@ extern "C" {
     pub fn GetLengthOfJSStructuredCloneData(data: *mut JSStructuredCloneData) -> usize;
     pub fn CopyJSStructuredCloneData(src: *const JSStructuredCloneData, dest: *mut u8);
     pub fn WriteBytesToJSStructuredCloneData(src: *const u8, len: usize, dest: *mut JSStructuredCloneData);
+    pub fn JS_ComputeThis (cx: *mut JSContext , vp: *mut JS::Value, dest: *mut JS::Value);
+    pub fn JS_GetModuleHostDefinedField (module: *mut JSObject, dest: *mut JS::Value);
+    pub fn JS_GetPromiseResult (promise: JS::HandleObject, dest: *mut JS::Value);
+    pub fn JS_THIS (cx: *mut JSContext , vp: *mut JS::Value, dest: *mut JS::Value);
+    pub fn JS_GetNaNValue (cx: *mut JSContext, dest: *mut JS::Value);
+    pub fn JS_GetPositiveInfinityValue (cx: *mut JSContext, dest: *mut JS::Value);
+    pub fn JS_GetEmptyStringValue (cx: *mut JSContext, dest: *mut JS::Value);
+    pub fn JS_GetReservedSlot (obj: *mut JSObject , index: u32, dest: *mut JS::Value);
 }

src/jsglue.cpp

@@ -574,10 +574,10 @@ GetWindowProxyClass()
     return &WindowProxyClass;
 }
 
-JS::Value
-GetProxyReservedSlot(JSObject* obj, uint32_t slot)
+void
+GetProxyReservedSlot(JSObject* obj, uint32_t slot, JS::Value* dest)
 {
-    return js::GetProxyReservedSlot(obj, slot);
+    *dest = js::GetProxyReservedSlot(obj, slot);
 }
 
 void
@@ -952,4 +952,52 @@ WriteBytesToJSStructuredCloneData(const uint8_t* src, size_t len, JSStructuredCl
     return dest->WriteBytes(reinterpret_cast<const char*>(src), len);
 }
 
+// MSVC uses a different calling conventions for functions
+// that return non-POD values. Unfortunately, this includes anything
+// with a constructor, such as JS::Value, so we can't call these
+// from Rust. These wrapper functions are only here to
+// ensure the calling convention is right.
+// https://docs.microsoft.com/en-us/cpp/build/return-values-cpp
+// https://mozilla.logbot.info/jsapi/20180622#c14918658
+
+void
+JS_ComputeThis(JSContext* cx, JS::Value* vp, JS::Value* dest) {
+  *dest = JS::detail::ComputeThis(cx, vp);
+}
+
+void
+JS_GetModuleHostDefinedField(JSObject* module, JS::Value* dest) {
+  *dest = JS::GetModuleHostDefinedField(module);
+}
+
+void
+JS_GetPromiseResult(JS::HandleObject promise, JS::Value* dest) {
+  *dest = JS::GetPromiseResult(promise);
+}
+
+void
+JS_THIS(JSContext* cx, JS::Value* vp, JS::Value* dest) {
+  *dest = JS_THIS(cx, vp);
+}
+
+void
+JS_GetNaNValue(JSContext* cx, JS::Value* dest) {
+  *dest = JS_GetNaNValue(cx);
+}
+
+void
+JS_GetPositiveInfinityValue(JSContext* cx, JS::Value* dest) {
+  *dest = JS_GetPositiveInfinityValue(cx);
+}
+
+void
+JS_GetEmptyStringValue(JSContext* cx, JS::Value* dest) {
+  *dest = JS_GetEmptyStringValue(cx);
+}
+
+void
+JS_GetReservedSlot(JSObject* obj, uint32_t index, JS::Value* dest) {
+  *dest = JS_GetReservedSlot(obj, index);
+}
+
 } // extern "C"