process: make process.nextTick() awaitable

doc/api/process.md

@@ -1639,7 +1639,7 @@ console.log(process.memoryUsage.rss());
 // 35655680
 ```
 
-## `process.nextTick(callback[, ...args])`
+## `process.nextTick([callback][, ...args])`
 <!-- YAML
 added: v0.1.26
 changes:
@@ -1650,6 +1650,7 @@ changes:
 
 * `callback` {Function}
 * `...args` {any} Additional arguments to pass when invoking the `callback`
+* Returns: {Promise} containing {undefined} if no `callback` provided
 
 `process.nextTick()` adds `callback` to the "next tick queue". This queue is
 fully drained after the current operation on the JavaScript stack runs to
@@ -1669,6 +1670,20 @@ console.log('scheduled');
 // nextTick callback
 ```
 
+If no `callback` function is provided, a `Promise` will be returned.
+
+```js
+async function output() {
+  await process.nextTick();
+  console.log('scheduled');
+}
+output();
+console.log('immediately');
+// Output:
+// immediately
+// scheduled
+```
+
 This is important when developing APIs in order to give users the opportunity
 to assign event handlers *after* an object has been constructed but before any
 I/O has occurred:

lib/internal/process/task_queues.js

@@ -40,6 +40,10 @@ const {
   validateFunction,
 } = require('internal/validators');
 
+const {
+  createDeferredPromise,
+} = require('internal/util');
+
 const { AsyncResource } = require('async_hooks');
 
 // *Must* match Environment::TickInfo::Fields in src/env.h.
@@ -99,16 +103,30 @@ function processTicksAndRejections() {
   setHasRejectionToWarn(false);
 }
 
+function nextTickDefaultCallback(resolve) {
+  resolve();
+}
+
 // `nextTick()` will not enqueue any callback when the process is about to
 // exit since the callback would not have a chance to be executed.
 function nextTick(callback) {
+  let promise;
+
+  if (!arguments.length) {
+    const defered = createDeferredPromise();
+    promise = defered.promise;
+    const { resolve } = defered;
+    callback = nextTickDefaultCallback.bind(undefined, resolve);
+  }
+
   validateCallback(callback);
 
   if (process._exiting)
     return;
 
   let args;
   switch (arguments.length) {
+    case 0:
     case 1: break;
     case 2: args = [arguments[1]]; break;
     case 3: args = [arguments[1], arguments[2]]; break;
@@ -132,6 +150,8 @@ function nextTick(callback) {
   if (initHooksExist())
     emitInit(asyncId, 'TickObject', triggerAsyncId, tickObject);
   queue.push(tickObject);
+
+  if (promise) return promise;
 }
 
 function runMicrotask() {

test/parallel/test-next-tick.js

@@ -54,10 +54,21 @@ process.nextTick(function() {
   assert.strictEqual(this, undefined);
 }, 1, 2, 3, 4);
 
-process.nextTick(() => {
+assert.strictEqual(process.nextTick(() => {
   assert.deepStrictEqual(this, {});
-}, 1, 2, 3, 4);
+}, 1, 2, 3, 4), undefined);
+
+const array = [];
+async function schedule() {
+  const p = process.nextTick();
+  assert(p instanceof Promise);
+  await p;
+  array.push(1);
+}
+schedule();
+array.push(2);
 
 process.on('exit', function() {
+  assert.deepStrictEqual(array, [ 2, 1 ]);
   process.nextTick(common.mustNotCall());
 });