feature(neon): API for thread-local data

crates/neon/src/instance/mod.rs

@@ -35,30 +35,33 @@ impl<T> Global<T> {
 }
 
 impl<T: Any + Send + 'static> Global<T> {
-    pub fn get<'cx, 'a, C>(&self, cx: &'a mut C) -> Option<&'a T>
+    pub fn get<'cx, 'a, C>(&self, cx: &'a mut C) -> Option<&'cx T>
     where
         C: Context<'cx>,
     {
-        InstanceData::globals(cx)
+        let r: Option<&T> = InstanceData::globals(cx)
             .get(self.id())
             .as_ref()
-            .map(|boxed| boxed.downcast_ref().unwrap())
+            .map(|boxed| boxed.downcast_ref().unwrap());
+
+        unsafe {
+            std::mem::transmute(r)
+        }
     }
 
-    pub fn get_mut<'cx, 'a, C>(&self, cx: &'a mut C) -> Option<&'a mut T>
+    pub fn get_or_init<'cx, 'a, C, F>(&self, cx: &'a mut C, f: F) -> &'cx T
     where
         C: Context<'cx>,
+        F: FnOnce() -> T,
     {
-        InstanceData::globals(cx)
+        let r: &T = InstanceData::globals(cx)
             .get(self.id())
-            .as_mut()
-            .map(|boxed| boxed.downcast_mut().unwrap())
-    }
+            .get_or_insert_with(|| Box::new(f()))
+            .downcast_ref()
+            .unwrap();
 
-    pub fn set<'cx, 'a, C>(&self, cx: &'a mut C, v: T)
-    where
-        C: Context<'cx>,
-    {
-        *InstanceData::globals(cx).get(self.id()) = Some(Box::new(v));
+        unsafe {
+            std::mem::transmute(r)
+        }
     }
 }

test/napi/lib/workers.js

@@ -5,7 +5,7 @@ const addon = require("..");
 
 // Receive a message, try that method and return the error message
 if (!isMainThread) {
-  addon.set_thread_id(threadId);
+  addon.get_or_init_thread_id(threadId);
   parentPort.once("message", (message) => {
     try {
       switch (message) {
@@ -20,7 +20,7 @@ if (!isMainThread) {
           break;
         case "get_thread_id":
           {
-            let id = addon.get_thread_id();
+            let id = addon.get_or_init_thread_id(NaN);
             parentPort.postMessage(id);
           }
           break;
@@ -40,7 +40,7 @@ if (!isMainThread) {
 // From here on, we're in the main thread.
 
 // Set the `THREAD_ID` Global value in the main thread cell.
-addon.set_thread_id(threadId);
+addon.get_or_init_thread_id(threadId);
 
 describe("Worker / Root Tagging Tests", () => {
   describe("Single Threaded", () => {
@@ -121,19 +121,22 @@ describe("Worker / Root Tagging Tests", () => {
 
 describe("Globals", () => {
   it("should be able to read an instance global from the main thread", () => {
-    let lookedUpId = addon.get_thread_id();
+    let lookedUpId = addon.get_or_init_thread_id(NaN);
+    assert(!Number.isNaN(lookedUpId));
     assert.strictEqual(lookedUpId, threadId);
   });
 
   it("should allocate separate globals for each addon instance", (cb) => {
-    let mainThreadId = addon.get_thread_id();
+    let mainThreadId = addon.get_or_init_thread_id(NaN);
+    assert(!Number.isNaN(mainThreadId));
 
     const worker = new Worker(__filename);
 
     worker.once("message", (message) => {
       assert.strictEqual(typeof message, 'number');
       assert.notStrictEqual(message, mainThreadId);
-      let mainThreadIdAgain = addon.get_thread_id();
+      let mainThreadIdAgain = addon.get_or_init_thread_id(NaN);
+      assert(!Number.isNaN(mainThreadIdAgain));
       assert.strictEqual(mainThreadIdAgain, mainThreadId);
       cb();
     });

test/napi/src/js/workers.rs

@@ -48,16 +48,8 @@ pub fn get_or_init_clone(mut cx: FunctionContext) -> JsResult<JsObject> {
 
 static THREAD_ID: Global<u32> = Global::new();
 
-pub fn set_thread_id(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+pub fn get_or_init_thread_id(mut cx: FunctionContext) -> JsResult<JsNumber> {
     let id = cx.argument::<JsNumber>(0)?.value(&mut cx) as u32;
-    THREAD_ID.set(&mut cx, id);
-    Ok(cx.undefined())
-}
-
-pub fn get_thread_id(mut cx: FunctionContext) -> JsResult<JsValue> {
-    let id = THREAD_ID.get(&mut cx).cloned();
-    Ok(match id {
-        Some(id) => cx.number(id).upcast(),
-        None => cx.undefined().upcast(),
-    })
+    let id: &u32 = THREAD_ID.get_or_init(&mut cx, || id);
+    Ok(cx.number(*id))
 }

test/napi/src/lib.rs

@@ -340,8 +340,7 @@ fn main(mut cx: ModuleContext) -> NeonResult<()> {
     cx.export_function("get_and_replace", js::workers::get_and_replace)?;
     cx.export_function("get_or_init", js::workers::get_or_init)?;
     cx.export_function("get_or_init_clone", js::workers::get_or_init_clone)?;
-    cx.export_function("get_thread_id", js::workers::get_thread_id)?;
-    cx.export_function("set_thread_id", js::workers::set_thread_id)?;
+    cx.export_function("get_or_init_thread_id", js::workers::get_or_init_thread_id)?;
 
     Ok(())
 }