[v18.x] test: skip testing --watch with --import

.github/label-pr-config.yml

@@ -21,7 +21,7 @@ subSystemLabels:
   /^src\/tty_/: c++, tty
   /^src\/node_url/: c++, whatwg-url
   /^src\/node_util/: c++, util
-  /^src\/(?:node_v8|v8abbr)/: c++, v8 engine
+  /^src\/node_v8/: c++, v8 engine
   /^src\/node_contextify/: c++, vm
   /^src\/.*win32.*/: c++, windows
   /^src\/node_zlib/: c++, zlib

doc/api/cli.md

@@ -1529,6 +1529,53 @@ on the number of online processors.
 If the value provided is larger than V8's maximum, then the largest value
 will be chosen.
 
+### `--watch`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Starts Node.js in watch mode.
+When in watch mode, changes in the watched files cause the Node.js process to
+restart.
+By default, watch mode will watch the entry point
+and any required or imported module.
+Use `--watch-path` to specify what paths to watch.
+
+This flag cannot be combined with
+`--check`, `--eval`, `--interactive`, or the REPL.
+
+```console
+$ node --watch index.js
+```
+
+### `--watch-path`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Starts Node.js in watch mode and specifies what paths to watch.
+When in watch mode, changes in the watched paths cause the Node.js process to
+restart.
+This will turn off watching of required or imported modules, even when used in
+combination with `--watch`.
+
+This flag cannot be combined with
+`--check`, `--eval`, `--interactive`, or the REPL.
+
+```console
+$ node --watch-path=./src --watch-path=./tests index.js
+```
+
+This option is only supported on macOS and Windows.
+An `ERR_FEATURE_UNAVAILABLE_ON_PLATFORM` exception will be thrown
+when the option is used on a platform that does not support it.
+
 ### `--zero-fill-buffers`
 
 <!-- YAML
@@ -1829,6 +1876,8 @@ Node.js options that are allowed are:
 * `--use-largepages`
 * `--use-openssl-ca`
 * `--v8-pool-size`
+* `--watch-path`
+* `--watch`
 * `--zero-fill-buffers`
 
 <!-- node-options-node end -->

doc/api/diagnostics_channel.md

@@ -428,6 +428,8 @@ Emitted when server receives a request.
 
 Emitted when server sends a response.
 
+#### NET
+
 `net.client.socket`
 
 * `socket` {net.Socket}
@@ -440,13 +442,40 @@ Emitted when a new TCP or pipe client socket is created.
 
 Emitted when a new TCP or pipe connection is received.
 
+#### UDP
+
 `udp.socket`
 
 * `socket` {dgram.Socket}
 
 Emitted when a new UDP socket is created.
 
+#### Process
+
+<!-- YAML
+added: REPLACEME
+-->
+
+`child_process`
+
+* `process` {ChildProcess}
+
+Emitted when a new process is created.
+
+#### Worker Thread
+
+<!-- YAML
+added: REPLACEME
+-->
+
+`worker_threads`
+
+* `worker` [`Worker`][]
+
+Emitted when a new thread is created.
+
 [`'uncaughtException'`]: process.md#event-uncaughtexception
+[`Worker`]: worker_threads.md#class-worker
 [`channel.subscribe(onMessage)`]: #channelsubscribeonmessage
 [`diagnostics_channel.channel(name)`]: #diagnostics_channelchannelname
 [`diagnostics_channel.subscribe(name, onMessage)`]: #diagnostics_channelsubscribename-onmessage

lib/internal/assert/assertion_error.js

@@ -21,15 +21,12 @@ const { inspect } = require('internal/util/inspect');
 const {
   removeColors,
 } = require('internal/util');
+const colors = require('internal/util/colors');
 const {
   validateObject,
 } = require('internal/validators');
 const { isErrorStackTraceLimitWritable } = require('internal/errors');
 
-let blue = '';
-let green = '';
-let red = '';
-let white = '';
 
 const kReadableOperator = {
   deepStrictEqual: 'Expected values to be strictly deep-equal:',
@@ -169,7 +166,7 @@ function createErrDiff(actual, expected, operator) {
     // Only remove lines in case it makes sense to collapse those.
     // TODO: Accept env to always show the full error.
     if (actualLines.length > 50) {
-      actualLines[46] = `${blue}...${white}`;
+      actualLines[46] = `${colors.blue}...${colors.white}`;
       while (actualLines.length > 47) {
         ArrayPrototypePop(actualLines);
       }
@@ -182,7 +179,7 @@ function createErrDiff(actual, expected, operator) {
   // There were at least five identical lines at the end. Mark a couple of
   // skipped.
   if (i >= 5) {
-    end = `\n${blue}...${white}${end}`;
+    end = `\n${colors.blue}...${colors.white}${end}`;
     skipped = true;
   }
   if (other !== '') {
@@ -193,15 +190,15 @@ function createErrDiff(actual, expected, operator) {
   let printedLines = 0;
   let identical = 0;
   const msg = kReadableOperator[operator] +
-        `\n${green}+ actual${white} ${red}- expected${white}`;
-  const skippedMsg = ` ${blue}...${white} Lines skipped`;
+        `\n${colors.green}+ actual${colors.white} ${colors.red}- expected${colors.white}`;
+  const skippedMsg = ` ${colors.blue}...${colors.white} Lines skipped`;
 
   let lines = actualLines;
-  let plusMinus = `${green}+${white}`;
+  let plusMinus = `${colors.green}+${colors.white}`;
   let maxLength = expectedLines.length;
   if (actualLines.length < maxLines) {
     lines = expectedLines;
-    plusMinus = `${red}-${white}`;
+    plusMinus = `${colors.red}-${colors.white}`;
     maxLength = actualLines.length;
   }
 
@@ -216,7 +213,7 @@ function createErrDiff(actual, expected, operator) {
               res += `\n  ${lines[i - 3]}`;
               printedLines++;
             } else {
-              res += `\n${blue}...${white}`;
+              res += `\n${colors.blue}...${colors.white}`;
               skipped = true;
             }
           }
@@ -272,7 +269,7 @@ function createErrDiff(actual, expected, operator) {
                 res += `\n  ${actualLines[i - 3]}`;
                 printedLines++;
               } else {
-                res += `\n${blue}...${white}`;
+                res += `\n${colors.blue}...${colors.white}`;
                 skipped = true;
               }
             }
@@ -286,8 +283,8 @@ function createErrDiff(actual, expected, operator) {
         identical = 0;
         // Add the actual line to the result and cache the expected diverging
         // line so consecutive diverging lines show up as +++--- and not +-+-+-.
-        res += `\n${green}+${white} ${actualLine}`;
-        other += `\n${red}-${white} ${expectedLine}`;
+        res += `\n${colors.green}+${colors.white} ${actualLine}`;
+        other += `\n${colors.red}-${colors.white} ${expectedLine}`;
         printedLines += 2;
       // Lines are identical
       } else {
@@ -306,8 +303,8 @@ function createErrDiff(actual, expected, operator) {
     }
     // Inspected object to big (Show ~50 rows max)
     if (printedLines > 50 && i < maxLines - 2) {
-      return `${msg}${skippedMsg}\n${res}\n${blue}...${white}${other}\n` +
-             `${blue}...${white}`;
+      return `${msg}${skippedMsg}\n${res}\n${colors.blue}...${colors.white}${other}\n` +
+             `${colors.blue}...${colors.white}`;
     }
   }
 
@@ -347,21 +344,9 @@ class AssertionError extends Error {
     if (message != null) {
       super(String(message));
     } else {
-      if (process.stderr.isTTY) {
-        // Reset on each call to make sure we handle dynamically set environment
-        // variables correct.
-        if (process.stderr.hasColors()) {
-          blue = '\u001b[34m';
-          green = '\u001b[32m';
-          white = '\u001b[39m';
-          red = '\u001b[31m';
-        } else {
-          blue = '';
-          green = '';
-          white = '';
-          red = '';
-        }
-      }
+      // Reset colors on each call to make sure we handle dynamically set environment
+      // variables correct.
+      colors.refresh();
       // Prevent the error stack from being visible by duplicating the error
       // in a very close way to the original in case both sides are actually
       // instances of Error.
@@ -393,7 +378,7 @@ class AssertionError extends Error {
         // Only remove lines in case it makes sense to collapse those.
         // TODO: Accept env to always show the full error.
         if (res.length > 50) {
-          res[46] = `${blue}...${white}`;
+          res[46] = `${colors.blue}...${colors.white}`;
           while (res.length > 47) {
             ArrayPrototypePop(res);
           }

lib/internal/child_process.js

@@ -59,6 +59,8 @@ const { convertToValidSignal, deprecate } = require('internal/util');
 const { isArrayBufferView } = require('internal/util/types');
 const spawn_sync = internalBinding('spawn_sync');
 const { kStateSymbol } = require('internal/dgram');
+const dc = require('diagnostics_channel');
+const childProcessChannel = dc.channel('child_process');
 
 const {
   UV_EACCES,
@@ -301,6 +303,11 @@ function ChildProcess() {
 
     maybeClose(this);
   };
+  if (childProcessChannel.hasSubscribers) {
+    childProcessChannel.publish({
+      process: this,
+    });
+  }
 }
 ObjectSetPrototypeOf(ChildProcess.prototype, EventEmitter.prototype);
 ObjectSetPrototypeOf(ChildProcess, EventEmitter);