src,test: allow creating Function with move-only functor

Function::New fails to compile when given a move-only functor. For
example, when constructing a callback function for Promise#then, a
lambda might capture an ObjectReference. Creating a Function for such a
lambda results in a compilation error.

Tweak Function::New to work with move-only functors.

For existing users of Function::New, this commit should not change
behavior.

Author: strager

napi-inl.h

@@ -14,6 +14,7 @@
 #include <cstring>
 #include <mutex>
 #include <type_traits>
+#include <utility>
 
 namespace Napi {
 
@@ -2154,7 +2155,7 @@ inline Function Function::New(napi_env env,
                               void* data) {
   using ReturnType = decltype(cb(CallbackInfo(nullptr, nullptr)));
   using CbData = details::CallbackData<Callable, ReturnType>;
-  auto callbackData = new CbData({ cb, data });
+  auto callbackData = new CbData{std::move(cb), data};
 
   napi_value value;
   napi_status status = CreateFunction(env,

test/function.cc

@@ -1,3 +1,4 @@
+#include <memory>
 #include "napi.h"
 #include "test_helper.h"
 
@@ -271,5 +272,24 @@ Object InitFunction(Env env) {
   exports["callWithFunctionOperator"] =
       Function::New<CallWithFunctionOperator>(env);
   result["templated"] = exports;
+
+  exports = Object::New(env);
+  exports["lambdaWithNoCapture"] =
+      Function::New(env, [](const CallbackInfo& info) {
+        auto env = info.Env();
+        return Boolean::New(env, true);
+      });
+  exports["lambdaWithCapture"] =
+      Function::New(env, [data = 42](const CallbackInfo& info) {
+        auto env = info.Env();
+        return Boolean::New(env, data == 42);
+      });
+  exports["lambdaWithMoveOnlyCapture"] = Function::New(
+      env, [data = std::make_unique<int>(42)](const CallbackInfo& info) {
+        auto env = info.Env();
+        return Boolean::New(env, *data == 42);
+      });
+  result["lambda"] = exports;
+
   return result;
 }

test/function.js

@@ -5,6 +5,7 @@ const assert = require('assert');
 module.exports = require('./common').runTest(binding => {
   test(binding.function.plain);
   test(binding.function.templated);
+  testLambda(binding.function.lambda);
 });
 
 function test(binding) {
@@ -112,3 +113,9 @@ function test(binding) {
     binding.makeCallbackWithInvalidReceiver(() => {});
   });
 }
+
+function testLambda(binding) {
+  assert.ok(binding.lambdaWithNoCapture());
+  assert.ok(binding.lambdaWithCapture());
+  assert.ok(binding.lambdaWithMoveOnlyCapture());
+}