From 834187b187a72914a7f5f06903ce8e643cdbe5d2 Mon Sep 17 00:00:00 2001
From: Ethan Arrowood <ethan.arrowood@vercel.com>
Date: Fri, 10 Nov 2023 10:13:59 -0700
Subject: [PATCH] src: add `--disable-warnings` option

---
 doc/api/cli.md                           |  57 ++++++++++
 lib/internal/process/warning.js          |  10 ++
 src/node_options.cc                      |   3 +
 src/node_options.h                       |   1 +
 test/fixtures/disable-warnings-worker.js |   3 +
 test/fixtures/disable-warnings.js        |  11 ++
 test/parallel/test-process-warnings.mjs  | 131 +++++++++++++++++++++++
 7 files changed, 216 insertions(+)
 create mode 100644 test/fixtures/disable-warnings-worker.js
 create mode 100644 test/fixtures/disable-warnings.js
 create mode 100644 test/parallel/test-process-warnings.mjs

diff --git a/doc/api/cli.md b/doc/api/cli.md
index 1f5136ce69442f..46827e0a2f3b3b 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -443,6 +443,59 @@ Affects the default output directory of:
 * [`--heap-prof-dir`][]
 * [`--redirect-warnings`][]
 
+### `--disable-warnings=code-or-type`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+Disable specific process warnings by `code` or `type`.
+
+Warnings emitted from [`process.emitWarning()`][emit_warning] may contain a
+`code` and a `type`. This option will not-emit warnings that have a matching
+`code` or `type`.
+
+List of [deprecation warnings][].
+
+The Node.js core warning types are: `DeprecationWarning` and
+`ExperimentalWarning`
+
+For example, the following script will not emit
+[DEP0025 `require('node:sys')`][DEP0025 warning] when executed with
+`node --disable-warnings=DEP0025`:
+
+<!-- eslint-skip -->
+```mjs
+import sys from 'node:sys';
+```
+
+<!-- eslint-skip -->
+```cjs
+const sys = require('node:sys');
+```
+
+For example, the following script will emit the
+[DEP0025 `require('node:sys')`][DEP0025 warning], but not any Experimental
+Warnings (such as
+[ExperimentalWarning: `vm.measureMemory` is an experimental feature][]
+in <=v21) when executed with `node --disable-warnings=ExperimentalWarnings`:
+
+<!-- eslint-skip -->
+```mjs
+import sys from 'node:sys';
+import vm from 'node:vm';
+
+vm.measureMemory();
+```
+
+<!-- eslint-skip -->
+```cjs
+const sys = require('node:sys');
+const vm = require('node:vm');
+
+vm.measureMemory();
+```
+
 ### `--disable-proto=mode`
 
 <!-- YAML
@@ -2327,6 +2380,7 @@ Node.js options that are allowed are:
 * `--conditions`, `-C`
 * `--diagnostic-dir`
 * `--disable-proto`
+* `--disable-warnings`
 * `--dns-result-order`
 * `--enable-fips`
 * `--enable-network-family-autoselection`
@@ -2779,7 +2833,9 @@ done
 [CommonJS]: modules.md
 [CommonJS module]: modules.md
 [CustomEvent Web API]: https://dom.spec.whatwg.org/#customevent
+[DEP0025 warning]: deprecations.md#dep0025-requirenodesys
 [ECMAScript module]: esm.md#modules-ecmascript-modules
+[ExperimentalWarning: `vm.measureMemory` is an experimental feature]: vm.md#vmmeasurememoryoptions
 [Fetch API]: https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
 [File System Permissions]: permissions.md#file-system-permissions
 [Module customization hooks]: module.md#customization-hooks
@@ -2835,6 +2891,7 @@ done
 [context-aware]: addons.md#context-aware-addons
 [debugger]: debugger.md
 [debugging security implications]: https://nodejs.org/en/docs/guides/debugging-getting-started/#security-implications
+[deprecation warnings]: deprecations.md#list-of-deprecated-apis
 [emit_warning]: process.md#processemitwarningwarning-options
 [environment_variables]: #environment-variables
 [filtering tests by name]: test.md#filtering-tests-by-name
diff --git a/lib/internal/process/warning.js b/lib/internal/process/warning.js
index 4aa86b9df58a87..0781418c01e390 100644
--- a/lib/internal/process/warning.js
+++ b/lib/internal/process/warning.js
@@ -2,12 +2,17 @@
 
 const {
   ArrayIsArray,
+  ArrayPrototypeIncludes,
   Error,
   ErrorPrototypeToString,
   ErrorCaptureStackTrace,
   String,
 } = primordials;
 
+const {
+  getOptionValue,
+} = require('internal/options');
+
 const assert = require('internal/assert');
 const {
   codes: {
@@ -90,7 +95,12 @@ function doEmitWarning(warning) {
 }
 
 function onWarning(warning) {
+  const disableWarnings = getOptionValue('--disable-warnings');
+  if ((warning?.code && ArrayPrototypeIncludes(disableWarnings, warning.code)) ||
+  (warning?.name && ArrayPrototypeIncludes(disableWarnings, warning.name))) return;
+
   if (!(warning instanceof Error)) return;
+
   const isDeprecation = warning.name === 'DeprecationWarning';
   if (isDeprecation && process.noDeprecation) return;
   const trace = process.traceProcessWarnings ||
diff --git a/src/node_options.cc b/src/node_options.cc
index 417d4679e84ec3..2215128da57365 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -527,6 +527,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             &EnvironmentOptions::warnings,
             kAllowedInEnvvar,
             true);
+  AddOption("--disable-warnings",
+            "silence specific process warnings",
+            &EnvironmentOptions::disable_warnings);
   AddOption("--force-context-aware",
             "disable loading non-context-aware addons",
             &EnvironmentOptions::force_context_aware,
diff --git a/src/node_options.h b/src/node_options.h
index 04c8a9e438dcfb..af19dd612387ae 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -139,6 +139,7 @@ class EnvironmentOptions : public Options {
   bool allow_native_addons = true;
   bool global_search_paths = true;
   bool warnings = true;
+  std::vector<std::string> disable_warnings;
   bool force_context_aware = false;
   bool pending_deprecation = false;
   bool preserve_symlinks = false;
diff --git a/test/fixtures/disable-warnings-worker.js b/test/fixtures/disable-warnings-worker.js
new file mode 100644
index 00000000000000..6f1a92c4e13918
--- /dev/null
+++ b/test/fixtures/disable-warnings-worker.js
@@ -0,0 +1,3 @@
+const path = require('node:path');
+const { Worker } = require('node:worker_threads');
+new Worker(path.join(__dirname, './disable-warnings.js'));
\ No newline at end of file
diff --git a/test/fixtures/disable-warnings.js b/test/fixtures/disable-warnings.js
new file mode 100644
index 00000000000000..eba9917afbb74c
--- /dev/null
+++ b/test/fixtures/disable-warnings.js
@@ -0,0 +1,11 @@
+'use strict';
+
+const sys = require('sys');
+const assert = require('assert');
+const vm = require('vm');
+
+try {
+  assert.fail('a', 'b');
+} catch (e) {}
+
+vm.measureMemory();
diff --git a/test/parallel/test-process-warnings.mjs b/test/parallel/test-process-warnings.mjs
new file mode 100644
index 00000000000000..a4568104432736
--- /dev/null
+++ b/test/parallel/test-process-warnings.mjs
@@ -0,0 +1,131 @@
+import { spawnPromisified } from '../common/index.mjs';
+import * as fixtures from '../common/fixtures.mjs';
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+const fixturePath = fixtures.path('disable-warnings.js');
+const fixturePathWorker = fixtures.path('disable-warnings-worker.js');
+const dep0025Message = /\(node:\d+\) \[DEP0025\] DeprecationWarning: sys is deprecated\. Use util instead\./;
+const dep0094Message = /\(node:\d+\) \[DEP0094\] DeprecationWarning: assert\.fail\(\) with more than one argument is deprecated\. Please use assert\.strictEqual\(\) instead or only pass a message\./;
+const experimentalWarningMessage = /\(node:\d+\) ExperimentalWarning: vm\.measureMemory is an experimental feature and might change at any time/;
+
+describe('process warnings', { concurrency: true }, () => {
+
+  it('should emit all warnings by default', async () => {
+    const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+      fixturePath,
+    ]);
+
+    assert.strictEqual(stdout, '');
+    assert.match(stderr, dep0025Message);
+    assert.match(stderr, dep0094Message);
+    assert.match(stderr, experimentalWarningMessage);
+    assert.strictEqual(code, 0);
+    assert.strictEqual(signal, null);
+  });
+
+  describe('--no-warnings', { concurrency: true }, () => {
+    it('should silence all warnings by default', async () => {
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--no-warnings',
+        fixturePath,
+      ]);
+
+      assert.strictEqual(stdout, '');
+      assert.doesNotMatch(stderr, dep0025Message);
+      assert.doesNotMatch(stderr, dep0094Message);
+      assert.doesNotMatch(stderr, experimentalWarningMessage);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
+  });
+
+  describe('--no-deprecation', { concurrency: true }, () => {
+    it('should silence all deprecation warnings', async () => {
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--no-deprecation',
+        fixturePath,
+      ]);
+
+      assert.strictEqual(stdout, '');
+      assert.doesNotMatch(stderr, dep0025Message);
+      assert.doesNotMatch(stderr, dep0094Message);
+      assert.match(stderr, experimentalWarningMessage);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
+  });
+
+  describe('--disable-warnings', { concurrency: true }, () => {
+    it('should silence deprecation warning DEP0025', async () => {
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--disable-warnings=DEP0025',
+        fixturePath,
+      ]);
+
+      assert.strictEqual(stdout, '');
+      assert.doesNotMatch(stderr, dep0025Message);
+      assert.match(stderr, dep0094Message);
+      assert.match(stderr, experimentalWarningMessage);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
+
+    it('should silence deprecation warnings DEP0025 and DEP0094', async () => {
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--disable-warnings=DEP0025',
+        '--disable-warnings=DEP0094',
+        fixturePath,
+      ]);
+
+      assert.strictEqual(stdout, '');
+      assert.doesNotMatch(stderr, dep0025Message);
+      assert.doesNotMatch(stderr, dep0094Message);
+      assert.match(stderr, experimentalWarningMessage);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
+
+    it('should silence all deprecation warnings using type DeprecationWarning', async () => {
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--disable-warnings=DeprecationWarning',
+        fixturePath,
+      ]);
+
+      assert.strictEqual(stdout, '');
+      assert.doesNotMatch(stderr, dep0025Message);
+      assert.doesNotMatch(stderr, dep0094Message);
+      assert.match(stderr, experimentalWarningMessage);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
+
+    it('should silence all experimental warnings using type ExperimentalWarning', async () => {
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--disable-warnings=ExperimentalWarning',
+        fixturePath,
+      ]);
+
+      assert.strictEqual(stdout, '');
+      assert.match(stderr, dep0025Message);
+      assert.match(stderr, dep0094Message);
+      assert.doesNotMatch(stderr, experimentalWarningMessage);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
+
+    it('should pass down option to worker', async () => {
+      const { stdout, stderr, code, signal } = await spawnPromisified(process.execPath, [
+        '--disable-warnings=DEP0094',
+        fixturePathWorker,
+      ]);
+
+      assert.strictEqual(stdout, '');
+      assert.match(stderr, dep0025Message);
+      assert.doesNotMatch(stderr, dep0094Message);
+      assert.match(stderr, experimentalWarningMessage);
+      assert.strictEqual(code, 0);
+      assert.strictEqual(signal, null);
+    });
+  });
+});