From 414ea74781d941fc1faa1a03afa6b6db02cdf67b Mon Sep 17 00:00:00 2001
From: bcoe <bencoe@google.com>
Date: Mon, 2 Nov 2020 16:57:33 -0800
Subject: [PATCH 01/10] module: refactor to use iterable-weak-map

Using an iterable WeakMap (a data-structure that uses WeakRef and
WeakMap), we are able to: stop relying on Module._cache to
serialize source maps; stop requiring an error object when calling
findSourceMap().
---
 doc/api/module.md                             | 10 +--
 .../source_map/prepare_stack_trace.js         |  2 +-
 lib/internal/source_map/source_map_cache.js   | 88 ++++++++-----------
 lib/internal/util/iterable-weak-map.js        | 69 +++++++++++++++
 node.gyp                                      |  1 +
 test/parallel/test-bootstrap-modules.js       |  1 +
 test/parallel/test-source-map-api.js          |  2 +-
 7 files changed, 112 insertions(+), 61 deletions(-)
 create mode 100644 lib/internal/util/iterable-weak-map.js

diff --git a/doc/api/module.md b/doc/api/module.md
index 2fb6ca884b4443..aa47181b4055cc 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -135,7 +135,7 @@ import { findSourceMap, SourceMap } from 'module';
 const { findSourceMap, SourceMap } = require('module');
 ```
 
-### `module.findSourceMap(path[, error])`
+### `module.findSourceMap(path)`
 <!-- YAML
 added:
  - v13.7.0
@@ -143,18 +143,11 @@ added:
 -->
 
 * `path` {string}
-* `error` {Error}
 * Returns: {module.SourceMap}
 
 `path` is the resolved path for the file for which a corresponding source map
 should be fetched.
 
-The `error` instance should be passed as the second parameter to `findSourceMap`
-in exceptional flows, such as when an overridden
-[`Error.prepareStackTrace(error, trace)`][] is invoked. Modules are not added to
-the module cache until they are successfully loaded. In these cases, source maps
-are associated with the `error` instance along with the `path`.
-
 ### Class: `module.SourceMap`
 <!-- YAML
 added:
@@ -204,7 +197,6 @@ consists of the following keys:
 [ES Modules]: esm.md
 [Source map v3 format]: https://sourcemaps.info/spec.html#h.mofvlxcwqzej
 [`--enable-source-maps`]: cli.md#cli_enable_source_maps
-[`Error.prepareStackTrace(error, trace)`]: https://v8.dev/docs/stack-trace-api#customizing-stack-traces
 [`NODE_V8_COVERAGE=dir`]: cli.md#cli_node_v8_coverage_dir
 [`SourceMap`]: #module_class_module_sourcemap
 [`createRequire()`]: #module_module_createrequire_filename
diff --git a/lib/internal/source_map/prepare_stack_trace.js b/lib/internal/source_map/prepare_stack_trace.js
index e9c3536c963504..2bf7eb4ee3a35f 100644
--- a/lib/internal/source_map/prepare_stack_trace.js
+++ b/lib/internal/source_map/prepare_stack_trace.js
@@ -53,7 +53,7 @@ const prepareStackTrace = (globalThis, error, trace) => {
     let str = i !== 0 ? '\n    at ' : '';
     str = `${str}${t}`;
     try {
-      const sm = findSourceMap(t.getFileName(), error);
+      const sm = findSourceMap(t.getFileName());
       if (sm) {
         // Source Map V3 lines/columns use zero-based offsets whereas, in
         // stack traces, they start at 1/1.
diff --git a/lib/internal/source_map/source_map_cache.js b/lib/internal/source_map/source_map_cache.js
index f94ffa8387a451..3b8375e046a952 100644
--- a/lib/internal/source_map/source_map_cache.js
+++ b/lib/internal/source_map/source_map_cache.js
@@ -1,6 +1,7 @@
 'use strict';
 
 const {
+  ArrayPrototypeMap,
   JSONParse,
   ObjectCreate,
   ObjectKeys,
@@ -8,8 +9,10 @@ const {
   ObjectPrototypeHasOwnProperty,
   Map,
   MapPrototypeEntries,
-  WeakMap,
-  WeakMapPrototypeGet,
+  RegExpPrototypeTest,
+  SafeMap,
+  StringPrototypeMatch,
+  StringPrototypeSplit,
   uncurryThis,
 } = primordials;
 
@@ -27,17 +30,17 @@ let debug = require('internal/util/debuglog').debuglog('source_map', (fn) => {
 });
 const fs = require('fs');
 const { getOptionValue } = require('internal/options');
+const { IterableWeakMap } = require('internal/util/iterable-weak-map');
 const {
   normalizeReferrerURL,
 } = require('internal/modules/cjs/helpers');
-// For cjs, since Module._cache is exposed to users, we use a WeakMap
-// keyed on module, facilitating garbage collection.
-const cjsSourceMapCache = new WeakMap();
-// The esm cache is not exposed to users, so we can use a Map keyed
-// on filenames.
-const esmSourceMapCache = new Map();
-const { fileURLToPath, URL } = require('url');
-let Module;
+// Since the CJS module cache is mutable, which leads to memory leaks when
+// modules are deleted, we use a WeakMap so that the source map cache will
+// be purged automatically:
+const cjsSourceMapCache = new IterableWeakMap();
+// The esm cache is not mutable, so we can use a Map without memory concerns:
+const esmSourceMapCache = new SafeMap();
+const { fileURLToPath, pathToFileURL, URL } = require('internal/url');
 let SourceMap;
 
 let sourceMapsEnabled;
@@ -70,13 +73,14 @@ function maybeCacheSourceMap(filename, content, cjsModuleInstance) {
     debug(err.stack);
     return;
   }
-
-  const match = content.match(/\/[*/]#\s+sourceMappingURL=(?<sourceMappingURL>[^\s]+)/);
+  const match = StringPrototypeMatch(
+    content,
+    /\/[*/]#\s+sourceMappingURL=(?<sourceMappingURL>[^\s]+)/
+  );
   if (match) {
     const data = dataFromUrl(filename, match.groups.sourceMappingURL);
     const url = data ? null : match.groups.sourceMappingURL;
     if (cjsModuleInstance) {
-      if (!Module) Module = require('internal/modules/cjs/loader').Module;
       cjsSourceMapCache.set(cjsModuleInstance, {
         filename,
         lineLengths: lineLengths(content),
@@ -120,7 +124,7 @@ function lineLengths(content) {
   // We purposefully keep \r as part of the line-length calculation, in
   // cases where there is a \r\n separator, so that this can be taken into
   // account in coverage calculations.
-  return content.split(/\n|\u2028|\u2029/).map((line) => {
+  return ArrayPrototypeMap(StringPrototypeSplit(content, /\n|\u2028|\u2029/), (line) => {
     return line.length;
   });
 }
@@ -139,8 +143,8 @@ function sourceMapFromFile(mapURL) {
 // data:[<mediatype>][;base64],<data> see:
 // https://tools.ietf.org/html/rfc2397#section-2
 function sourceMapFromDataUrl(sourceURL, url) {
-  const [format, data] = url.split(',');
-  const splitFormat = format.split(';');
+  const [format, data] = StringPrototypeSplit(url, ',');
+  const splitFormat = StringPrototypeSplit(format, ';');
   const contentType = splitFormat[0];
   const base64 = splitFormat[splitFormat.length - 1] === 'base64';
   if (contentType === 'application/json') {
@@ -207,48 +211,32 @@ function sourceMapCacheToObject() {
   return obj;
 }
 
-// Since WeakMap can't be iterated over, we use Module._cache's
-// keys to facilitate Source Map serialization.
-//
-// TODO(bcoe): this means we don't currently serialize source-maps attached
-// to error instances, only module instances.
 function appendCJSCache(obj) {
-  if (!Module) return;
-  const cjsModuleCache = ObjectGetValueSafe(Module, '_cache');
-  const cjsModules = ObjectKeys(cjsModuleCache);
-  for (let i = 0; i < cjsModules.length; i++) {
-    const key = cjsModules[i];
-    const module = ObjectGetValueSafe(cjsModuleCache, key);
-    const value = WeakMapPrototypeGet(cjsSourceMapCache, module);
-    if (value) {
-      // This is okay because `obj` has a null prototype.
-      obj[`file://${key}`] = {
-        lineLengths: ObjectGetValueSafe(value, 'lineLengths'),
-        data: ObjectGetValueSafe(value, 'data'),
-        url: ObjectGetValueSafe(value, 'url')
-      };
-    }
+  for (const [, value] of cjsSourceMapCache) {
+    obj[ObjectGetValueSafe(value, 'filename')] = {
+      lineLengths: ObjectGetValueSafe(value, 'lineLengths'),
+      data: ObjectGetValueSafe(value, 'data'),
+      url: ObjectGetValueSafe(value, 'url')
+    };
   }
 }
 
-// Attempt to lookup a source map, which is either attached to a file URI, or
-// keyed on an error instance.
-// TODO(bcoe): once WeakRefs are available in Node.js, refactor to drop
-// requirement of error parameter.
-function findSourceMap(uri, error) {
-  if (!Module) Module = require('internal/modules/cjs/loader').Module;
+function findSourceMap(sourceURL) {
+  if (!RegExpPrototypeTest(/^\w+:\/\//, sourceURL)) {
+    sourceURL = pathToFileURL(sourceURL).href;
+  }
   if (!SourceMap) {
     SourceMap = require('internal/source_map/source_map').SourceMap;
   }
-  let sourceMap = cjsSourceMapCache.get(Module._cache[uri]);
-  if (!uri.startsWith('file://')) uri = normalizeReferrerURL(uri);
-  if (sourceMap === undefined) {
-    sourceMap = esmSourceMapCache.get(uri);
-  }
+  let sourceMap = esmSourceMapCache.get(sourceURL);
   if (sourceMap === undefined) {
-    const candidateSourceMap = cjsSourceMapCache.get(error);
-    if (candidateSourceMap && uri === candidateSourceMap.filename) {
-      sourceMap = candidateSourceMap;
+    for (const [, value] of cjsSourceMapCache) {
+      const filename = ObjectGetValueSafe(value, 'filename');
+      if (sourceURL === filename) {
+        sourceMap = {
+          data: ObjectGetValueSafe(value, 'data')
+        };
+      }
     }
   }
   if (sourceMap && sourceMap.data) {
diff --git a/lib/internal/util/iterable-weak-map.js b/lib/internal/util/iterable-weak-map.js
new file mode 100644
index 00000000000000..438b9a7a2482b1
--- /dev/null
+++ b/lib/internal/util/iterable-weak-map.js
@@ -0,0 +1,69 @@
+'use strict';
+
+const {
+  SafeSet,
+  SafeWeakMap,
+  Symbol,
+} = primordials;
+
+// This class is modified from the example code in the WeakRefs specification:
+// https://github.com/tc39/proposal-weakrefs
+// Licensed under ECMA's MIT-style license, see:
+// https://github.com/tc39/ecma262/blob/master/LICENSE.md
+class IterableWeakMap {
+  #weakMap = new SafeWeakMap();
+  #refSet = new SafeSet();
+  // TODO(aduh95): Add FinalizationRegistry to primordials
+  #finalizationGroup = new globalThis.FinalizationRegistry(cleanup);
+
+  set(key, value) {
+    const entry = this.#weakMap.get(key);
+    if (entry) {
+      // If there's already an entry for the object represented by "key",
+      // the value can be updated without creating a new WeakRef:
+      this.#weakMap.set(key, { value, ref: entry.ref });
+    } else {
+      // TODO(aduh95): Add WeakRef to primordials
+      const ref = new globalThis.WeakRef(key);
+      this.#weakMap.set(key, { value, ref });
+      this.#refSet.add(ref);
+      this.#finalizationGroup.register(key, {
+        set: this.#refSet,
+        ref
+      }, ref);
+    }
+  }
+
+  get(key) {
+    const entry = this.#weakMap.get(key);
+    return entry && entry.value;
+  }
+
+  delete(key) {
+    const entry = this.#weakMap.get(key);
+    if (!entry) {
+      return false;
+    }
+    this.#weakMap.delete(key);
+    this.#refSet.delete(entry.ref);
+    this.#finalizationGroup.unregister(entry.ref);
+    return true;
+  }
+
+  *[Symbol.iterator]() {
+    for (const ref of this.#refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      const { value } = this.#weakMap.get(key);
+      yield [key, value];
+    }
+  }
+}
+
+function cleanup({ set, ref }) {
+  set.delete(ref);
+}
+
+module.exports = {
+  IterableWeakMap
+};
diff --git a/node.gyp b/node.gyp
index d2f0be54e933e3..9695c829f4e887 100644
--- a/node.gyp
+++ b/node.gyp
@@ -230,6 +230,7 @@
       'lib/internal/util/debuglog.js',
       'lib/internal/util/inspect.js',
       'lib/internal/util/inspector.js',
+      'lib/internal/util/iterable-weak-map.js',
       'lib/internal/util/types.js',
       'lib/internal/http2/core.js',
       'lib/internal/http2/compat.js',
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index 2a811d65cc2633..47c9c619a2c2d9 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -92,6 +92,7 @@ const expectedModules = new Set([
   'NativeModule internal/util',
   'NativeModule internal/util/debuglog',
   'NativeModule internal/util/inspect',
+  'NativeModule internal/util/iterable-weak-map',
   'NativeModule internal/util/types',
   'NativeModule internal/validators',
   'NativeModule internal/vm/module',
diff --git a/test/parallel/test-source-map-api.js b/test/parallel/test-source-map-api.js
index 60bbb661e1c801..1a3d180619fe05 100644
--- a/test/parallel/test-source-map-api.js
+++ b/test/parallel/test-source-map-api.js
@@ -31,7 +31,7 @@ const { readFileSync } = require('fs');
   Error.prepareStackTrace = (error, trace) => {
     const throwingRequireCallSite = trace[0];
     if (throwingRequireCallSite.getFileName().endsWith('typescript-throw.js')) {
-      sourceMap = findSourceMap(throwingRequireCallSite.getFileName(), error);
+      sourceMap = findSourceMap(throwingRequireCallSite.getFileName());
       callSite = throwingRequireCallSite;
     }
   };

From 3ca2431d74c1ef2591864b173f53c29e979a241f Mon Sep 17 00:00:00 2001
From: bcoe <bencoe@google.com>
Date: Mon, 2 Nov 2020 19:48:03 -0800
Subject: [PATCH 02/10] test: add test for iterable-source-map fix

---
 lib/internal/per_context/primordials.js       |  1 +
 .../source_map/prepare_stack_trace.js         |  1 +
 lib/internal/util/iterable-weak-map.js        | 19 +++++++++++++++----
 .../source-map/throw-on-require-entry.js      |  4 ++++
 .../source-map/throw-on-require-entry.js.map  |  1 +
 test/fixtures/source-map/throw-on-require.js  | 15 +++++++++++++++
 .../source-map/throw-on-require.js.map        |  1 +
 test/fixtures/source-map/throw-on-require.ts  | 12 ++++++++++++
 test/parallel/test-source-map-enable.js       | 18 ++++++++++++++++++
 9 files changed, 68 insertions(+), 4 deletions(-)
 create mode 100644 test/fixtures/source-map/throw-on-require-entry.js
 create mode 100644 test/fixtures/source-map/throw-on-require-entry.js.map
 create mode 100644 test/fixtures/source-map/throw-on-require.js
 create mode 100644 test/fixtures/source-map/throw-on-require.js.map
 create mode 100644 test/fixtures/source-map/throw-on-require.ts

diff --git a/lib/internal/per_context/primordials.js b/lib/internal/per_context/primordials.js
index 7b17ef8353a7b4..8527e65f2ba7e1 100644
--- a/lib/internal/per_context/primordials.js
+++ b/lib/internal/per_context/primordials.js
@@ -86,6 +86,7 @@ function makeSafe(unsafe, safe) {
   Object.freeze(safe);
   return safe;
 }
+primordials.makeSafe = makeSafe;
 
 // Subclass the constructors because we need to use their prototype
 // methods later.
diff --git a/lib/internal/source_map/prepare_stack_trace.js b/lib/internal/source_map/prepare_stack_trace.js
index 2bf7eb4ee3a35f..f857dc9309fa1e 100644
--- a/lib/internal/source_map/prepare_stack_trace.js
+++ b/lib/internal/source_map/prepare_stack_trace.js
@@ -115,6 +115,7 @@ function getErrorSource(payload, originalSource, firstLine, firstColumn) {
       source = readFileSync(originalSourceNoScheme, 'utf8');
     } catch (err) {
       debug(err);
+      return '';
     }
   }
 
diff --git a/lib/internal/util/iterable-weak-map.js b/lib/internal/util/iterable-weak-map.js
index 438b9a7a2482b1..37bedb564fadc0 100644
--- a/lib/internal/util/iterable-weak-map.js
+++ b/lib/internal/util/iterable-weak-map.js
@@ -1,11 +1,24 @@
 'use strict';
 
 const {
+  makeSafe,
   SafeSet,
   SafeWeakMap,
   Symbol,
 } = primordials;
 
+// TODO(aduh95): Add FinalizationRegistry to primordials
+const SafeFinalizationRegistry = makeSafe(
+  globalThis.FinalizationRegistry,
+  class SafeFinalizationRegistry extends globalThis.FinalizationRegistry {}
+);
+
+// TODO(aduh95): Add WeakRef to primordials
+const SafeWeakRef = makeSafe(
+  globalThis.WeakRef,
+  class SafeWeakRef extends globalThis.WeakRef {}
+);
+
 // This class is modified from the example code in the WeakRefs specification:
 // https://github.com/tc39/proposal-weakrefs
 // Licensed under ECMA's MIT-style license, see:
@@ -13,8 +26,7 @@ const {
 class IterableWeakMap {
   #weakMap = new SafeWeakMap();
   #refSet = new SafeSet();
-  // TODO(aduh95): Add FinalizationRegistry to primordials
-  #finalizationGroup = new globalThis.FinalizationRegistry(cleanup);
+  #finalizationGroup = new SafeFinalizationRegistry(cleanup);
 
   set(key, value) {
     const entry = this.#weakMap.get(key);
@@ -23,8 +35,7 @@ class IterableWeakMap {
       // the value can be updated without creating a new WeakRef:
       this.#weakMap.set(key, { value, ref: entry.ref });
     } else {
-      // TODO(aduh95): Add WeakRef to primordials
-      const ref = new globalThis.WeakRef(key);
+      const ref = new SafeWeakRef(key);
       this.#weakMap.set(key, { value, ref });
       this.#refSet.add(ref);
       this.#finalizationGroup.register(key, {
diff --git a/test/fixtures/source-map/throw-on-require-entry.js b/test/fixtures/source-map/throw-on-require-entry.js
new file mode 100644
index 00000000000000..94b14810a52ef1
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require-entry.js
@@ -0,0 +1,4 @@
+"use strict";
+exports.__esModule = true;
+require("./throw-on-require");
+//# sourceMappingURL=throw-on-require-entry.js.map
diff --git a/test/fixtures/source-map/throw-on-require-entry.js.map b/test/fixtures/source-map/throw-on-require-entry.js.map
new file mode 100644
index 00000000000000..a5f0ca2253fe82
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require-entry.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"throw-on-require-entry.js","sourceRoot":"","sources":["throw-on-require-entry.ts"],"names":[],"mappings":";;AAAA,8BAA2B"}
\ No newline at end of file
diff --git a/test/fixtures/source-map/throw-on-require.js b/test/fixtures/source-map/throw-on-require.js
new file mode 100644
index 00000000000000..5654f2bfb917ab
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require.js
@@ -0,0 +1,15 @@
+var ATrue;
+(function (ATrue) {
+    ATrue[ATrue["IsTrue"] = 1] = "IsTrue";
+    ATrue[ATrue["IsFalse"] = 0] = "IsFalse";
+})(ATrue || (ATrue = {}));
+if (false) {
+    console.info('unreachable');
+}
+else if (true) {
+    throw Error('throw early');
+}
+else {
+    console.info('unreachable');
+}
+//# sourceMappingURL=throw-on-require.js.map
\ No newline at end of file
diff --git a/test/fixtures/source-map/throw-on-require.js.map b/test/fixtures/source-map/throw-on-require.js.map
new file mode 100644
index 00000000000000..94d0df9c03abbd
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require.js.map
@@ -0,0 +1 @@
+{"version":3,"file":"throw-on-require.js","sourceRoot":"","sources":["throw-on-require.ts"],"names":[],"mappings":"AAAA,IAAK,KAGJ;AAHD,WAAK,KAAK;IACR,qCAAU,CAAA;IACV,uCAAW,CAAA;AACb,CAAC,EAHI,KAAK,KAAL,KAAK,QAGT;AAED,IAAI,KAAK,EAAE;IACT,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;CAC5B;KAAM,IAAI,IAAI,EAAE;IACf,MAAM,KAAK,CAAC,aAAa,CAAC,CAAA;CAC3B;KAAM;IACL,OAAO,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;CAC5B"}
\ No newline at end of file
diff --git a/test/fixtures/source-map/throw-on-require.ts b/test/fixtures/source-map/throw-on-require.ts
new file mode 100644
index 00000000000000..4aa570302778f4
--- /dev/null
+++ b/test/fixtures/source-map/throw-on-require.ts
@@ -0,0 +1,12 @@
+enum ATrue {
+  IsTrue = 1,
+  IsFalse = 0
+}
+ 
+if (false) {
+  console.info('unreachable')
+} else if (true) {
+  throw Error('throw early')
+} else {
+  console.info('unreachable')
+}
diff --git a/test/parallel/test-source-map-enable.js b/test/parallel/test-source-map-enable.js
index 0887ae8811c45b..b65ade7900da5d 100644
--- a/test/parallel/test-source-map-enable.js
+++ b/test/parallel/test-source-map-enable.js
@@ -283,6 +283,24 @@ function nextdir() {
   assert.ok(output.stderr.toString().includes('webpack:///webpack.js:14:9'));
 }
 
+// Stores and applies source map associated with file that throws while
+// being required.
+{
+  const coverageDirectory = nextdir();
+  const output = spawnSync(process.execPath, [
+    '--enable-source-maps',
+    require.resolve('../fixtures/source-map/throw-on-require-entry.js')
+  ], { env: { ...process.env, NODE_V8_COVERAGE: coverageDirectory } });
+  const sourceMap = getSourceMapFromCache(
+    'throw-on-require.js',
+    coverageDirectory
+  );
+  // Rewritten stack trace.
+  assert.ok(output.stderr.toString().includes('throw-on-require.ts:9:9'));
+  // Source map should have been serialized.
+  assert.ok(sourceMap);
+}
+
 function getSourceMapFromCache(fixtureFile, coverageDirectory) {
   const jsonFiles = fs.readdirSync(coverageDirectory);
   for (const jsonFile of jsonFiles) {

From 9d5d45de117f90b9b4b5b585c794d96ec9e816e4 Mon Sep 17 00:00:00 2001
From: bcoe <bencoe@google.com>
Date: Mon, 2 Nov 2020 20:02:34 -0800
Subject: [PATCH 03/10] build: fix naming

---
 lib/internal/source_map/source_map_cache.js                     | 2 +-
 .../util/{iterable-weak-map.js => iterable_weak_map.js}         | 0
 node.gyp                                                        | 2 +-
 test/parallel/test-bootstrap-modules.js                         | 2 +-
 4 files changed, 3 insertions(+), 3 deletions(-)
 rename lib/internal/util/{iterable-weak-map.js => iterable_weak_map.js} (100%)

diff --git a/lib/internal/source_map/source_map_cache.js b/lib/internal/source_map/source_map_cache.js
index 3b8375e046a952..e5950e9084a6e3 100644
--- a/lib/internal/source_map/source_map_cache.js
+++ b/lib/internal/source_map/source_map_cache.js
@@ -30,7 +30,7 @@ let debug = require('internal/util/debuglog').debuglog('source_map', (fn) => {
 });
 const fs = require('fs');
 const { getOptionValue } = require('internal/options');
-const { IterableWeakMap } = require('internal/util/iterable-weak-map');
+const { IterableWeakMap } = require('internal/util/iterable_weak_map');
 const {
   normalizeReferrerURL,
 } = require('internal/modules/cjs/helpers');
diff --git a/lib/internal/util/iterable-weak-map.js b/lib/internal/util/iterable_weak_map.js
similarity index 100%
rename from lib/internal/util/iterable-weak-map.js
rename to lib/internal/util/iterable_weak_map.js
diff --git a/node.gyp b/node.gyp
index 9695c829f4e887..643c8a43c6ff9c 100644
--- a/node.gyp
+++ b/node.gyp
@@ -230,7 +230,7 @@
       'lib/internal/util/debuglog.js',
       'lib/internal/util/inspect.js',
       'lib/internal/util/inspector.js',
-      'lib/internal/util/iterable-weak-map.js',
+      'lib/internal/util/iterable_weak_map.js',
       'lib/internal/util/types.js',
       'lib/internal/http2/core.js',
       'lib/internal/http2/compat.js',
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index 47c9c619a2c2d9..b9844dc4caf683 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -92,7 +92,7 @@ const expectedModules = new Set([
   'NativeModule internal/util',
   'NativeModule internal/util/debuglog',
   'NativeModule internal/util/inspect',
-  'NativeModule internal/util/iterable-weak-map',
+  'NativeModule internal/util/iterable_weak_map',
   'NativeModule internal/util/types',
   'NativeModule internal/validators',
   'NativeModule internal/vm/module',

From e156fa1a12e90871d5c67ddfab06ceaf4d6a9fa8 Mon Sep 17 00:00:00 2001
From: "Benjamin E. Coe" <bencoe@google.com>
Date: Tue, 3 Nov 2020 10:32:49 -0500
Subject: [PATCH 04/10] Update test/parallel/test-source-map-enable.js

Co-authored-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 test/parallel/test-source-map-enable.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-source-map-enable.js b/test/parallel/test-source-map-enable.js
index b65ade7900da5d..cea597b4f7b0c0 100644
--- a/test/parallel/test-source-map-enable.js
+++ b/test/parallel/test-source-map-enable.js
@@ -296,7 +296,7 @@ function nextdir() {
     coverageDirectory
   );
   // Rewritten stack trace.
-  assert.ok(output.stderr.toString().includes('throw-on-require.ts:9:9'));
+  assert.match(output.stderr.toString(), /throw-on-require\.ts:9:9/);
   // Source map should have been serialized.
   assert.ok(sourceMap);
 }

From 5a80dfd5326beb0ed708dca1912cf9c07bcbdd49 Mon Sep 17 00:00:00 2001
From: bcoe <bencoe@google.com>
Date: Tue, 3 Nov 2020 19:37:01 -0800
Subject: [PATCH 05/10] test: add tests for iterable-weak-map

---
 lib/internal/util/iterable_weak_map.js        |  6 ++
 .../test-internal-iterable-weak-map.js        | 85 +++++++++++++++++++
 2 files changed, 91 insertions(+)
 create mode 100644 test/parallel/test-internal-iterable-weak-map.js

diff --git a/lib/internal/util/iterable_weak_map.js b/lib/internal/util/iterable_weak_map.js
index 37bedb564fadc0..c99ed6b74b3a87 100644
--- a/lib/internal/util/iterable_weak_map.js
+++ b/lib/internal/util/iterable_weak_map.js
@@ -69,6 +69,12 @@ class IterableWeakMap {
       yield [key, value];
     }
   }
+
+  *values() {
+    for (const [, value] of this) {
+      yield value;
+    }
+  }
 }
 
 function cleanup({ set, ref }) {
diff --git a/test/parallel/test-internal-iterable-weak-map.js b/test/parallel/test-internal-iterable-weak-map.js
new file mode 100644
index 00000000000000..326200213e82f7
--- /dev/null
+++ b/test/parallel/test-internal-iterable-weak-map.js
@@ -0,0 +1,85 @@
+// Flags: --expose-gc --expose-internals
+'use strict';
+
+require('../common');
+const { deepStrictEqual, strictEqual } = require('assert');
+const { IterableWeakMap } = require('internal/util/iterable_weak_map');
+
+// It drops entry if a reference is no longer held.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+    moduleC: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleB, 'discard');
+  wm.set(_cache.moduleC, 'goodbye');
+  delete _cache.moduleB;
+  setImmediate(() => {
+    _cache;
+    globalThis.gc();
+    const values = [...wm.values()];
+    deepStrictEqual(values, ['hello', 'goodbye']);
+  });
+}
+
+// It updates an existing entry, if the same key is provided twice.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleB, 'goodbye');
+  wm.set(_cache.moduleB, 'goodnight');
+  const values = [...wm.values()];
+  deepStrictEqual(values, ['hello', 'goodnight']);
+}
+
+// It allows entry to be deleted by key.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+    moduleC: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleB, 'discard');
+  wm.set(_cache.moduleC, 'goodbye');
+  wm.delete(_cache.moduleB);
+  const values = [...wm.values()];
+  deepStrictEqual(values, ['hello', 'goodbye']);
+}
+
+// It handles delete for key that does not exist.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+    moduleC: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleC, 'goodbye');
+  wm.delete(_cache.moduleB);
+  const values = [...wm.values()];
+  deepStrictEqual(values, ['hello', 'goodbye']);
+}
+
+// It allows an entry to be fetched by key.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+    moduleB: {},
+    moduleC: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  wm.set(_cache.moduleB, 'discard');
+  wm.set(_cache.moduleC, 'goodbye');
+  strictEqual(wm.get(_cache.moduleB), 'discard');
+}

From 46e0bbaad381fd519f57792b2f19dd14eadcbd61 Mon Sep 17 00:00:00 2001
From: bcoe <bencoe@google.com>
Date: Wed, 4 Nov 2020 06:33:08 -0800
Subject: [PATCH 06/10] chore: address review

---
 doc/api/module.md                      | 3 +++
 lib/internal/util/iterable_weak_map.js | 3 +--
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/doc/api/module.md b/doc/api/module.md
index aa47181b4055cc..75f9e42b3e10ba 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -135,7 +135,10 @@ import { findSourceMap, SourceMap } from 'module';
 const { findSourceMap, SourceMap } = require('module');
 ```
 
+<!-- Anchors to make sure old links find a target -->
+<a name="module_module_findsourcemap_path_error"></a>
 ### `module.findSourceMap(path)`
+
 <!-- YAML
 added:
  - v13.7.0
diff --git a/lib/internal/util/iterable_weak_map.js b/lib/internal/util/iterable_weak_map.js
index c99ed6b74b3a87..edcd25b816e4cf 100644
--- a/lib/internal/util/iterable_weak_map.js
+++ b/lib/internal/util/iterable_weak_map.js
@@ -46,8 +46,7 @@ class IterableWeakMap {
   }
 
   get(key) {
-    const entry = this.#weakMap.get(key);
-    return entry && entry.value;
+    return this.#weakMap.get(key)?.value;
   }
 
   delete(key) {

From 643445533b8a2d43e4c6ed1e55918392200187e9 Mon Sep 17 00:00:00 2001
From: "Benjamin E. Coe" <bencoe@google.com>
Date: Wed, 4 Nov 2020 10:40:19 -0500
Subject: [PATCH 07/10] fix: switch from name to id

Co-authored-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 doc/api/module.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/module.md b/doc/api/module.md
index 75f9e42b3e10ba..b686adc05f8336 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -136,7 +136,7 @@ const { findSourceMap, SourceMap } = require('module');
 ```
 
 <!-- Anchors to make sure old links find a target -->
-<a name="module_module_findsourcemap_path_error"></a>
+<a id="module_module_findsourcemap_path_error"></a>
 ### `module.findSourceMap(path)`
 
 <!-- YAML

From 0b30bc268ae657d55d0065d8ee15a21c0546b9f4 Mon Sep 17 00:00:00 2001
From: bcoe <bencoe@google.com>
Date: Wed, 4 Nov 2020 19:24:27 -0800
Subject: [PATCH 08/10] chore: address code review

---
 lib/internal/source_map/source_map_cache.js    |  4 ++--
 lib/internal/util/iterable_weak_map.js         | 13 +++++++------
 .../test-internal-iterable-weak-map.js         | 18 ++++++++++++++----
 3 files changed, 23 insertions(+), 12 deletions(-)

diff --git a/lib/internal/source_map/source_map_cache.js b/lib/internal/source_map/source_map_cache.js
index e5950e9084a6e3..ff259ee4325d1d 100644
--- a/lib/internal/source_map/source_map_cache.js
+++ b/lib/internal/source_map/source_map_cache.js
@@ -212,7 +212,7 @@ function sourceMapCacheToObject() {
 }
 
 function appendCJSCache(obj) {
-  for (const [, value] of cjsSourceMapCache) {
+  for (const value of cjsSourceMapCache) {
     obj[ObjectGetValueSafe(value, 'filename')] = {
       lineLengths: ObjectGetValueSafe(value, 'lineLengths'),
       data: ObjectGetValueSafe(value, 'data'),
@@ -230,7 +230,7 @@ function findSourceMap(sourceURL) {
   }
   let sourceMap = esmSourceMapCache.get(sourceURL);
   if (sourceMap === undefined) {
-    for (const [, value] of cjsSourceMapCache) {
+    for (const value of cjsSourceMapCache) {
       const filename = ObjectGetValueSafe(value, 'filename');
       if (sourceURL === filename) {
         sourceMap = {
diff --git a/lib/internal/util/iterable_weak_map.js b/lib/internal/util/iterable_weak_map.js
index edcd25b816e4cf..b60088030c443a 100644
--- a/lib/internal/util/iterable_weak_map.js
+++ b/lib/internal/util/iterable_weak_map.js
@@ -2,6 +2,7 @@
 
 const {
   makeSafe,
+  Object,
   SafeSet,
   SafeWeakMap,
   Symbol,
@@ -49,6 +50,10 @@ class IterableWeakMap {
     return this.#weakMap.get(key)?.value;
   }
 
+  has(key) {
+    return this.#weakMap.has(key);
+  }
+
   delete(key) {
     const entry = this.#weakMap.get(key);
     if (!entry) {
@@ -65,12 +70,6 @@ class IterableWeakMap {
       const key = ref.deref();
       if (!key) continue;
       const { value } = this.#weakMap.get(key);
-      yield [key, value];
-    }
-  }
-
-  *values() {
-    for (const [, value] of this) {
       yield value;
     }
   }
@@ -80,6 +79,8 @@ function cleanup({ set, ref }) {
   set.delete(ref);
 }
 
+Object.freeze(IterableWeakMap.prototype);
+
 module.exports = {
   IterableWeakMap
 };
diff --git a/test/parallel/test-internal-iterable-weak-map.js b/test/parallel/test-internal-iterable-weak-map.js
index 326200213e82f7..04636c20903a2e 100644
--- a/test/parallel/test-internal-iterable-weak-map.js
+++ b/test/parallel/test-internal-iterable-weak-map.js
@@ -20,7 +20,7 @@ const { IterableWeakMap } = require('internal/util/iterable_weak_map');
   setImmediate(() => {
     _cache;
     globalThis.gc();
-    const values = [...wm.values()];
+    const values = [...wm];
     deepStrictEqual(values, ['hello', 'goodbye']);
   });
 }
@@ -35,7 +35,7 @@ const { IterableWeakMap } = require('internal/util/iterable_weak_map');
   wm.set(_cache.moduleA, 'hello');
   wm.set(_cache.moduleB, 'goodbye');
   wm.set(_cache.moduleB, 'goodnight');
-  const values = [...wm.values()];
+  const values = [...wm];
   deepStrictEqual(values, ['hello', 'goodnight']);
 }
 
@@ -51,7 +51,7 @@ const { IterableWeakMap } = require('internal/util/iterable_weak_map');
   wm.set(_cache.moduleB, 'discard');
   wm.set(_cache.moduleC, 'goodbye');
   wm.delete(_cache.moduleB);
-  const values = [...wm.values()];
+  const values = [...wm];
   deepStrictEqual(values, ['hello', 'goodbye']);
 }
 
@@ -66,7 +66,7 @@ const { IterableWeakMap } = require('internal/util/iterable_weak_map');
   wm.set(_cache.moduleA, 'hello');
   wm.set(_cache.moduleC, 'goodbye');
   wm.delete(_cache.moduleB);
-  const values = [...wm.values()];
+  const values = [...wm];
   deepStrictEqual(values, ['hello', 'goodbye']);
 }
 
@@ -83,3 +83,13 @@ const { IterableWeakMap } = require('internal/util/iterable_weak_map');
   wm.set(_cache.moduleC, 'goodbye');
   strictEqual(wm.get(_cache.moduleB), 'discard');
 }
+
+// It returns true for has() if key exists.
+{
+  const wm = new IterableWeakMap();
+  const _cache = {
+    moduleA: {},
+  };
+  wm.set(_cache.moduleA, 'hello');
+  strictEqual(wm.has(_cache.moduleA), true);
+}

From e9945112d4772501bdaa5aad10814107b42c28b9 Mon Sep 17 00:00:00 2001
From: "Benjamin E. Coe" <bencoe@google.com>
Date: Thu, 5 Nov 2020 10:33:48 -0500
Subject: [PATCH 09/10] chore: address code review

Co-authored-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 lib/internal/util/iterable_weak_map.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/internal/util/iterable_weak_map.js b/lib/internal/util/iterable_weak_map.js
index b60088030c443a..7a4294bf06fb8a 100644
--- a/lib/internal/util/iterable_weak_map.js
+++ b/lib/internal/util/iterable_weak_map.js
@@ -65,7 +65,7 @@ class IterableWeakMap {
     return true;
   }
 
-  *[Symbol.iterator]() {
+  *[SymbolIterator]() {
     for (const ref of this.#refSet) {
       const key = ref.deref();
       if (!key) continue;
@@ -82,5 +82,5 @@ function cleanup({ set, ref }) {
 Object.freeze(IterableWeakMap.prototype);
 
 module.exports = {
-  IterableWeakMap
+  IterableWeakMap,
 };

From f1d088a3d9a1b679c608b5d6ae1c196acd80240f Mon Sep 17 00:00:00 2001
From: bcoe <bencoe@google.com>
Date: Thu, 5 Nov 2020 07:42:52 -0800
Subject: [PATCH 10/10] chore: address code review

---
 doc/api/modules.md                     | 2 +-
 lib/internal/util/iterable_weak_map.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/api/modules.md b/doc/api/modules.md
index 05135fb0b7dec8..03d919f37fd9b3 100644
--- a/doc/api/modules.md
+++ b/doc/api/modules.md
@@ -967,7 +967,7 @@ This section was moved to
 [Modules: `module` core module](module.md#module_source_map_v3_support).
 
 <!-- Anchors to make sure old links find a target -->
-* <a id="modules_module_findsourcemap_path_error" href="module.html#module_module_findsourcemap_path_error">`module.findSourceMap(path[, error])`</a>
+* <a id="modules_module_findsourcemap_path_error" href="module.html#module_module_findsourcemap_path">`module.findSourceMap(path)`</a>
 * <a id="modules_class_module_sourcemap" href="module.html#module_class_module_sourcemap">Class: `module.SourceMap`</a>
   * <a id="modules_new_sourcemap_payload" href="module.html#module_new_sourcemap_payload">`new SourceMap(payload)`</a>
   * <a id="modules_sourcemap_payload" href="module.html#module_sourcemap_payload">`sourceMap.payload`</a>
diff --git a/lib/internal/util/iterable_weak_map.js b/lib/internal/util/iterable_weak_map.js
index 7a4294bf06fb8a..3fa139b23e4b4e 100644
--- a/lib/internal/util/iterable_weak_map.js
+++ b/lib/internal/util/iterable_weak_map.js
@@ -5,7 +5,7 @@ const {
   Object,
   SafeSet,
   SafeWeakMap,
-  Symbol,
+  SymbolIterator,
 } = primordials;
 
 // TODO(aduh95): Add FinalizationRegistry to primordials