feat: add ConstructorTraitTag to allow constructor return overridding

napi-inl.h

@@ -4630,9 +4630,11 @@ inline napi_value InstanceWrap<T>::WrappedMethod(
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename T>
-inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo) {
+template <typename ConstructorTraitTag>
+inline ObjectWrap<T>::ObjectWrap(const Napi::CallbackInfo& callbackInfo,
+                                 ConstructorTraitTag) {
   napi_env env = callbackInfo.Env();
-  napi_value wrapper = callbackInfo.This();
+  napi_value wrapper = ConstructorTraitTag::GetThis(callbackInfo);
   napi_status status;
   napi_ref ref;
   T* instance = static_cast<T*>(this);
@@ -5026,11 +5028,12 @@ inline napi_value ObjectWrap<T>::ConstructorCallbackWrapper(
       Error e = callbackInfo.Env().GetAndClearPendingException();
       delete instance;
       e.ThrowAsJavaScriptException();
+      return Object();
     } else {
       instance->_construction_failed = false;
     }
 #endif  // NODE_ADDON_API_CPP_EXCEPTIONS
-    return callbackInfo.This();
+    return instance->Value();
   });
 
   return wrapper;

napi.h

@@ -2359,6 +2359,10 @@ class InstanceWrap {
   }
 };
 
+struct ConstructorTraitTag {
+  static napi_value GetThis(const CallbackInfo& info) { return info.This(); }
+};
+
 /// Base class to be extended by C++ classes exposed to JavaScript; each C++
 /// class instance gets "wrapped" by a JavaScript object that is managed by this
 /// class.
@@ -2389,7 +2393,9 @@ class InstanceWrap {
 template <typename T>
 class ObjectWrap : public InstanceWrap<T>, public Reference<Object> {
  public:
-  ObjectWrap(const CallbackInfo& callbackInfo);
+  template <typename ConstructorTraitTag = struct ConstructorTraitTag>
+  ObjectWrap(const CallbackInfo& callbackInfo,
+             ConstructorTraitTag = ConstructorTraitTag());
   virtual ~ObjectWrap();
 
   static T* Unwrap(Object wrapper);

test/binding.cc

@@ -69,6 +69,7 @@ Object InitTypedArray(Env env);
 Object InitGlobalObject(Env env);
 Object InitObjectWrap(Env env);
 Object InitObjectWrapConstructorException(Env env);
+Object InitObjectWrapConstructorTraitTag(Env env);
 Object InitObjectWrapFunction(Env env);
 Object InitObjectWrapRemoveWrap(Env env);
 Object InitObjectWrapMultipleInheritance(Env env);
@@ -168,6 +169,8 @@ Object Init(Env env, Object exports) {
   exports.Set("objectwrap", InitObjectWrap(env));
   exports.Set("objectwrapConstructorException",
               InitObjectWrapConstructorException(env));
+  exports.Set("objectwrap_constructor_trait_tag",
+              InitObjectWrapConstructorTraitTag(env));
   exports.Set("objectwrap_function", InitObjectWrapFunction(env));
   exports.Set("objectwrap_removewrap", InitObjectWrapRemoveWrap(env));
   exports.Set("objectwrap_multiple_inheritance",

test/binding.gyp

@@ -73,6 +73,7 @@
         'typedarray.cc',
         'objectwrap.cc',
         'objectwrap_constructor_exception.cc',
+        'objectwrap_constructor_trait_tag.cc',
         'objectwrap_function.cc',
         'objectwrap_removewrap.cc',
         'objectwrap_multiple_inheritance.cc',

test/objectwrap_constructor_trait_tag.cc

@@ -0,0 +1,39 @@
+#include <napi.h>
+#include "test_helper.h"
+
+struct EventTargetConstructorTraitTag {
+  static napi_value GetThis(const Napi::CallbackInfo& info) {
+    Napi::Function eventTargetCons =
+        MaybeUnwrap(info.Env().Global().Get("EventTarget"))
+            .As<Napi::Function>();
+    Napi::Object eventTarget = MaybeUnwrap(eventTargetCons.New({}));
+    return eventTarget;
+  }
+};
+
+class TestOverride : public Napi::ObjectWrap<TestOverride> {
+ public:
+  TestOverride(const Napi::CallbackInfo& info)
+      : Napi::ObjectWrap<TestOverride>(info, EventTargetConstructorTraitTag()) {
+  }
+
+  Napi::Value IsTestOverride(const Napi::CallbackInfo& info) {
+    TestOverride* self = Unwrap(info.This().As<Napi::Object>());
+    return Napi::Boolean::New(info.Env(), self != nullptr);
+  }
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+    Napi::Function cons = DefineClass(
+        env,
+        "TestOverride",
+        {InstanceAccessor<&TestOverride::IsTestOverride>("isTestOverride")});
+
+    exports.Set("TestOverride", cons);
+  }
+};
+
+Napi::Object InitObjectWrapConstructorTraitTag(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  TestOverride::Initialize(env, exports);
+  return exports;
+}

test/objectwrap_constructor_trait_tag.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const assert = require('assert');
+
+const test = bindingName => {
+  const binding = require(bindingName);
+  const TestOverride = binding.objectwrap_constructor_trait_tag.TestOverride;
+  // TODO(legendecas): Expose Object.setPrototypeOf in node-api.
+  Object.setPrototypeOf(TestOverride, EventTarget);
+  Object.setPrototypeOf(TestOverride.prototype, EventTarget.prototype);
+
+  const test = new TestOverride();
+  Object.setPrototypeOf(test, TestOverride.prototype);
+
+  // Verify that the TestOverride class is an EventTarget instance and has both
+  // EventTarget brand and TestOverride brand.
+  assert(test instanceof EventTarget);
+  assert(test instanceof TestOverride);
+  // Verify TestOverride brand.
+  assert.strictEqual(test.isTestOverride, true);
+  // Verify EventTarget brand.
+  test.addEventListener('test', () => {});
+};
+
+module.exports = require('./common').runTestWithBindingPath(test);