src: add support for addon instance data

Support `napi_get_instance_data()` and `napi_set_instance_data()`.
Fixes: #654

napi-inl.h

@@ -322,6 +322,32 @@ inline Value Env::RunScript(String script) {
   return Value(_env, result);
 }
 
+#ifdef NAPI_EXPERIMENTAL
+template <typename T, Env::Finalizer<T> fini = Env::DefaultFini<T>>
+inline void Env::SetInstanceData(T* data) {
+  napi_status status =
+      napi_set_instance_data(_env, data, [](napi_env, void* data, void*) {
+        fini(static_cast<T*>(data));
+      }, nullptr);
+  NAPI_THROW_IF_FAILED_VOID(_env, status);
+}
+
+template <typename T>
+inline T* Env::GetInstanceData() {
+  void* data = nullptr;
+
+  napi_status status = napi_get_instance_data(_env, &data);
+  NAPI_THROW_IF_FAILED(_env, status, nullptr);
+
+  return static_cast<T*>(data);
+}
+
+template <typename T> void Env::DefaultFini(T* data) {
+  delete data;
+}
+
+#endif  // NAPI_EXPERIMENTAL
+
 ////////////////////////////////////////////////////////////////////////////////
 // Value class
 ////////////////////////////////////////////////////////////////////////////////

napi.h

@@ -173,6 +173,10 @@ namespace Napi {
   ///
   /// In the V8 JavaScript engine, a N-API environment approximately corresponds to an Isolate.
   class Env {
+#ifdef NAPI_EXPERIMENTAL
+  private:
+    template <typename T> static void DefaultFini(T* data);
+#endif
   public:
     Env(napi_env env);
 
@@ -189,6 +193,13 @@ namespace Napi {
     Value RunScript(const std::string& utf8script);
     Value RunScript(String script);
 
+#ifdef NAPI_EXPERIMENTAL
+    template <typename T> using Finalizer = void (*)(T*);
+    template <typename T, Finalizer<T> fini = Env::DefaultFini<T>>
+    void SetInstanceData(T* data);
+    template <typename T> T* GetInstanceData();
+#endif
+
   private:
     napi_env _env;
   };

test/addon_data.cc

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#define NAPI_EXPERIMENTAL
+#include "napi.h"
+
+class Addon {
+ public:
+  Addon() {}
+  bool verbose = false;
+  ~Addon() {
+    if (verbose) {
+      fprintf(stderr, "addon_data: Addon::~Addon\n");
+    }
+  }
+};
+
+static Napi::Value Getter(const Napi::CallbackInfo& info) {
+  return Napi::Boolean::New(info.Env(),
+                            info.Env().GetInstanceData<Addon>()->verbose);
+}
+
+static void Setter(const Napi::CallbackInfo& info) {
+  info.Env().GetInstanceData<Addon>()->verbose = info[0].As<Napi::Boolean>();
+}
+
+Napi::Object InitAddonData(Napi::Env env) {
+  env.SetInstanceData(new Addon());
+  Napi::Object result = Napi::Object::New(env);
+
+  result.DefineProperties({
+    Napi::PropertyDescriptor::Accessor<Getter, Setter>("verbose"),
+  });
+
+  return result;
+}

test/addon_data.js

@@ -0,0 +1,35 @@
+'use strict';
+const buildType = process.config.target_defaults.default_configuration;
+const assert = require('assert');
+const { spawn } = require('child_process');
+const readline = require('readline');
+const path = require('path');
+
+test(path.resolve(__dirname, `./build/${buildType}/binding.node`));
+test(path.resolve(__dirname, `./build/${buildType}/binding_noexcept.node`));
+
+function test(bindingName) {
+  const binding = require(bindingName);
+
+  // Make sure it is possible to get/set instance data.
+  assert.strictEqual(binding.addon_data.verbose, false);
+  binding.addon_data.verbose = true;
+  assert.strictEqual(binding.addon_data.verbose, true);
+  binding.addon_data.verbose = false;
+  assert.strictEqual(binding.addon_data.verbose, false);
+
+  // Make sure the instance data finalizer is called at process exit.
+  const child = spawn(process.execPath, [
+    '-e',
+    `require('${bindingName}').addon_data.verbose = true;`
+  ]);
+  let foundMessage = false;
+  readline
+    .createInterface({ input: child.stderr })
+    .on('line', (line) => {
+      if (line.match('addon_data: Addon::~Addon')) {
+        foundMessage = true;
+      }
+    })
+    .on('close', () => assert.strictEqual(foundMessage, true));
+}

test/binding.cc

@@ -2,6 +2,7 @@
 
 using namespace Napi;
 
+Object InitAddonData(Env env);
 Object InitArrayBuffer(Env env);
 Object InitAsyncContext(Env env);
 #if (NAPI_VERSION > 3)
@@ -57,6 +58,7 @@ Object InitVersionManagement(Env env);
 Object InitThunkingManual(Env env);
 
 Object Init(Env env, Object exports) {
+  exports.Set("addon_data", InitAddonData(env));
   exports.Set("arraybuffer", InitArrayBuffer(env));
   exports.Set("asynccontext", InitAsyncContext(env));
 #if (NAPI_VERSION > 3)

test/binding.gyp

@@ -2,6 +2,7 @@
   'target_defaults': {
     'includes': ['../common.gypi'],
     'sources': [
+        'addon_data.cc',
         'arraybuffer.cc',
         'asynccontext.cc',
         'asyncprogressworker.cc',

test/index.js

@@ -8,6 +8,7 @@ process.config.target_defaults.default_configuration =
 // FIXME: We might need a way to load test modules automatically without
 // explicit declaration as follows.
 let testModules = [
+  'addon_data',
   'arraybuffer',
   'asynccontext',
   'asyncprogressworker',