[squash] ABI/API compat

nodejs · addaleax · Jul 6, 2017 · Jul 6, 2017 · Jul 7, 2017 · Jul 11, 2017
commit 85597ca7b09b6573561312ea7aa2d93d4a3d2bee
diff --git a/src/async-wrap.cc b/src/async-wrap.cc
@@ -634,9 +634,10 @@ void AsyncWrap::AsyncReset(bool silent) {
 
   if (silent) return;
 
-  EmitAsyncInit(env(), object(),
-                env()->async_hooks()->provider_string(provider_type()),
-                async_id_, trigger_id_);
+  AsyncWrap::EmitAsyncInit(
+      env(), object(),
+      env()->async_hooks()->provider_string(provider_type()),
+      async_id_, trigger_id_);
 }
 
 
@@ -791,3 +792,56 @@ void EmitAsyncDestroy(Isolate* isolate, async_context asyncContext) {
 }  // namespace node
 
 NODE_MODULE_CONTEXT_AWARE_BUILTIN(async_wrap, node::AsyncWrap::Initialize)
+
+
+// Only legacy public API below this line.
+
+namespace node {
+
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+                               Local<Object> recv,
+                               Local<Function> callback,
+                               int argc,
+                               Local<Value>* argv,
+                               async_id asyncId,
+                               async_id triggerAsyncId) {
+  return MakeCallback(isolate, recv, callback, argc, argv,
+                      {asyncId, triggerAsyncId});
+}
+
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+                               Local<Object> recv,
+                               const char* method,
+                               int argc,
+                               Local<Value>* argv,
+                               async_id asyncId,
+                               async_id triggerAsyncId) {
+  return MakeCallback(isolate, recv, method, argc, argv,
+                      {asyncId, triggerAsyncId});
+}
+
+MaybeLocal<Value> MakeCallback(Isolate* isolate,
+                               Local<Object> recv,
+                               Local<String> symbol,
+                               int argc,
+                               Local<Value>* argv,
+                               async_id asyncId,
+                               async_id triggerAsyncId) {
+  return MakeCallback(isolate, recv, symbol, argc, argv,
+                      {asyncId, triggerAsyncId});
+}
+
+// Undo the Node-8.x-only alias from node.h
+#undef EmitAsyncInit
+
+async_uid EmitAsyncInit(Isolate* isolate,
+                        Local<Object> resource,
+                        const char* name,
+                        async_id trigger_async_id) {
+  return EmitAsyncInit__New(isolate,
+                            resource,
+                            name,
+                            trigger_async_id).async_id;
+}
+
+}  // namespace node
diff --git a/src/async-wrap.h b/src/async-wrap.h
@@ -26,6 +26,7 @@
 
 #include "base-object.h"
 #include "v8.h"
+#include "node.h"
 
 #include <stdint.h>
 

diff --git a/src/node.h b/src/node.h
@@ -521,8 +521,16 @@ typedef double async_id;
 struct async_context {
   ::node::async_id async_id;
   ::node::async_id trigger_async_id;
+
+  // Legacy, Node 8.x only.
+  NODE_DEPRECATED("Use async_context directly as returned by EmitAsyncInit()",
+                  operator ::node::async_id() const {
+    return async_id;
+  });
 };
 
+typedef async_id async_uid;  // Legacy, Node 8.x only
+
 /* Registers an additional v8::PromiseHook wrapper. This API exists because V8
  * itself supports only a single PromiseHook. */
 NODE_EXTERN void AddPromiseHook(v8::Isolate* isolate,
@@ -544,6 +552,15 @@ NODE_EXTERN async_id AsyncHooksGetTriggerAsyncId(v8::Isolate* isolate);
 NODE_EXTERN NODE_DEPRECATED("Use AsyncHooksGetTriggerAsyncId(isolate)",
                 async_id AsyncHooksGetTriggerId(v8::Isolate* isolate));
 
+// This is a legacy overload of EmitAsyncInit that has to remain for ABI
+// compatibility during Node 8.x. Do not use.
+NODE_EXTERN async_uid EmitAsyncInit(v8::Isolate* isolate,
+                                    v8::Local<v8::Object> resource,
+                                    const char* name,
+                                    async_id trigger_async_id);
+
+// From now on EmitAsyncInit always refers to the proper, new version.
+#define EmitAsyncInit EmitAsyncInit__New
 
 /* If the native API doesn't inherit from the helper class then the callbacks
  * must be triggered manually. This triggers the init() callback. The return
@@ -593,6 +610,33 @@ v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
                                        v8::Local<v8::Value>* argv,
                                        async_context asyncContext);
 
+// Legacy, Node 8.x only.
+
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       v8::Local<v8::Function> callback,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_id asyncId,
+                                       async_id triggerAsyncId);
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       const char* method,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_id asyncId,
+                                       async_id triggerAsyncId);
+NODE_EXTERN
+v8::MaybeLocal<v8::Value> MakeCallback(v8::Isolate* isolate,
+                                       v8::Local<v8::Object> recv,
+                                       v8::Local<v8::String> symbol,
+                                       int argc,
+                                       v8::Local<v8::Value>* argv,
+                                       async_id asyncId,
+                                       async_id triggerAsyncId);
+
 /* Helper class users can optionally inherit from. If
  * `AsyncResource::MakeCallback()` is used, then all four callbacks will be
  * called automatically. */

diff --git a/test/addons/async-hooks-id/binding.cc b/test/addons/async-hooks-id/binding.cc
@@ -17,9 +17,17 @@ void GetTriggerAsyncId(const FunctionCallbackInfo<Value>& args) {
     node::AsyncHooksGetTriggerAsyncId(args.GetIsolate()));
 }
 
+void EmitAsyncInit(const FunctionCallbackInfo<Value>& args) {
+  assert(args[0]->IsObject());
+  node::async_uid uid =
+      node::EmitAsyncInit(args.GetIsolate(), args[0].As<Object>(), "foobar");
+  args.GetReturnValue().Set(uid);
+}
+
 void Initialize(Local<Object> exports) {
   NODE_SET_METHOD(exports, "getExecutionAsyncId", GetExecutionAsyncId);
   NODE_SET_METHOD(exports, "getTriggerAsyncId", GetTriggerAsyncId);
+  NODE_SET_METHOD(exports, "emitAsyncInit", EmitAsyncInit);
 }
 
 }  // namespace

diff --git a/test/addons/async-hooks-id/test.js b/test/addons/async-hooks-id/test.js
@@ -13,6 +13,9 @@ assert.strictEqual(
   binding.getTriggerAsyncId(),
   async_hooks.triggerAsyncId()
 );
+assert.strictEqual(
+  typeof binding.emitAsyncInit({}), 'number'
+);
 
 process.nextTick(common.mustCall(function() {
   assert.strictEqual(