chrome-devtools-frontend 1.0.1706026 → 1.0.1709383

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -16,13 +16,16 @@ export class SourceMapScopesInfo {
   readonly #sourceMap: SourceMap;
   readonly #originalScopes: Array<ScopesCodec.OriginalScope[]|null>;
   readonly #generatedRanges: ScopesCodec.GeneratedRange[];
+  /** Whether the scope information was derived from the AST and mappings (see {@link createFromAst}). */
+  readonly #isFromAst: boolean;
 
   #cachedVariablesAndBindingsPresent: boolean|null = null;
 
-  constructor(sourceMap: SourceMap, scopeInfo: ScopesCodec.ScopeInfo) {
+  constructor(sourceMap: SourceMap, scopeInfo: ScopesCodec.ScopeInfo, {isFromAst = false}: {isFromAst?: boolean} = {}) {
     this.#sourceMap = sourceMap;
     this.#originalScopes = scopeInfo.scopes;
     this.#generatedRanges = scopeInfo.ranges;
+    this.#isFromAst = isFromAst;
   }
 
   /**
@@ -114,7 +117,8 @@ export class SourceMapScopesInfo {
       }
     }
 
-    return new SourceMapScopesInfo(sourceMap, {scopes: scopesBySourceUrl, ranges: rootRange ? [rootRange] : []});
+    return new SourceMapScopesInfo(sourceMap, {scopes: scopesBySourceUrl, ranges: rootRange ? [rootRange] : []},
+                                   {isFromAst: true});
 
     /**
      * Finds the correct place in the tree to insert the new scope.
@@ -211,6 +215,10 @@ export class SourceMapScopesInfo {
     return noScopes && !this.#generatedRanges.length;
   }
 
+  hasGeneratedRanges(): boolean {
+    return this.#generatedRanges.length > 0;
+  }
+
   addOriginalScopesAtIndex(sourceIdx: number, scopes: ScopesCodec.OriginalScope[]): void {
     if (!this.#originalScopes[sourceIdx]?.length) {
       this.#originalScopes[sourceIdx] = scopes;
@@ -219,39 +227,17 @@ export class SourceMapScopesInfo {
     }
   }
 
-  /**
-   * @returns true, iff the function surrounding the provided position is marked as "hidden".
-   */
-  isOutlinedFrame(generatedLine: number, generatedColumn: number): boolean {
-    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
-    return this.#isOutlinedFrame(rangeChain);
-  }
-
-  #isOutlinedFrame(rangeChain: ScopesCodec.GeneratedRange[]): boolean {
-    for (let i = rangeChain.length - 1; i >= 0; --i) {
-      if (rangeChain[i].isStackFrame) {
-        return rangeChain[i].isHidden;
-      }
+  #generatedFrameKind(rangeChain: ScopesCodec.GeneratedRange[]): GeneratedFrameKind {
+    const functionRange = rangeChain.findLast(range => range.isStackFrame);
+    if (!functionRange) {
+      // Top-level code.
+      return GeneratedFrameKind.VISIBLE;
     }
-    return false;
-  }
-
-  /**
-   * @returns true, iff the range surrounding the provided position contains multiple
-   * inlined original functions.
-   */
-  hasInlinedFrames(generatedLine: number, generatedColumn: number): boolean {
-    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
-    for (let i = rangeChain.length - 1; i >= 0; --i) {
-      if (rangeChain[i].isStackFrame) {
-        // We stop looking for inlined original functions once we reach the current frame.
-        return false;
-      }
-      if (rangeChain[i].callSite) {
-        return true;
-      }
+    if (!functionRange.originalScope) {
+      // For scope information derived from the AST, we merely failed to map the function.
+      return this.#isFromAst ? GeneratedFrameKind.VISIBLE : GeneratedFrameKind.HIDDEN;
     }
-    return false;
+    return functionRange.isHidden ? GeneratedFrameKind.OUTLINED : GeneratedFrameKind.VISIBLE;
   }
 
   /**
@@ -419,54 +405,53 @@ export class SourceMapScopesInfo {
   /**
    * Returns the authored function scope of the function containing the provided generated position.
    */
-  findOriginalFunctionScope({line, column}: ScopesCodec.Position):
+  findOriginalFunctionScope(position: ScopesCodec.Position):
       {scope: ScopesCodec.OriginalScope, url?: Platform.DevToolsPath.UrlString}|null {
+    const rangeChain = this.#findGeneratedRangeChain(position.line, position.column);
+    const functionScope =
+        this.#findFunctionScopeInOriginalScopeChain(this.#innerMostOriginalScope(rangeChain, position));
+    return functionScope ? {scope: functionScope, url: this.#sourceURLOfScope(functionScope)} : null;
+  }
+
+  /**
+   * Returns the inner-most original scope containing the generated `position`. `rangeChain` must be the generated
+   * range chain of `position`.
+   */
+  #innerMostOriginalScope(rangeChain: ScopesCodec.GeneratedRange[],
+                          position: ScopesCodec.Position): ScopesCodec.OriginalScope|undefined {
     // There are 2 approaches:
     //   1) Find the inner-most generated range containing the provided generated position
-    //      and use it's OriginalScope (then walk it outwards until we hit a function).
+    //      and use its OriginalScope.
     //   2) Use the mappings to turn the generated position into an original position.
     //      Then find the inner-most original scope containing that original position.
-    //      Then walk it outwards until we hit a function.
     //
     // Both approaches should yield the same result (assuming the mappings are spec compliant
     // w.r.t. generated ranges). But in the case of "pasta" scopes and extension provided
     // scope info, we only have the OriginalScope parts and mappings without GeneratedRanges.
-
-    let originalInnerMostScope: ScopesCodec.OriginalScope|undefined;
-
     if (this.#generatedRanges.length > 0) {
-      const rangeChain = this.#findGeneratedRangeChain(line, column);
-      originalInnerMostScope = rangeChain.at(-1)?.originalScope;
-    } else {
-      // No GeneratedRanges. Try to use mappings.
-      const entry = this.#sourceMap.findEntry(line, column);
-      if (entry?.sourceIndex === undefined) {
-        return null;
-      }
-      originalInnerMostScope =
-          this.#findOriginalScopeChain(
-                  {sourceIndex: entry.sourceIndex, line: entry.sourceLineNumber, column: entry.sourceColumnNumber})
-              .at(-1);
+      return rangeChain.at(-1)?.originalScope;
     }
 
-    if (!originalInnerMostScope) {
-      return null;
-    }
-
-    const functionScope = this.#findFunctionScopeInOriginalScopeChain(originalInnerMostScope);
-    if (!functionScope) {
-      return null;
+    // No GeneratedRanges. Try to use mappings.
+    const entry = this.#sourceMap.findEntry(position.line, position.column);
+    if (entry?.sourceIndex === undefined) {
+      return undefined;
     }
+    return this
+        .#findOriginalScopeChain(
+            {sourceIndex: entry.sourceIndex, line: entry.sourceLineNumber, column: entry.sourceColumnNumber})
+        .at(-1);
+  }
 
+  /** @returns the URL of the original source that `scope` belongs to. */
+  #sourceURLOfScope(scope: ScopesCodec.OriginalScope): Platform.DevToolsPath.UrlString|undefined {
     // Find the root scope for some given original source, to get the source url.
-    let rootScope: ScopesCodec.OriginalScope = functionScope;
+    let rootScope: ScopesCodec.OriginalScope = scope;
     while (rootScope.parent) {
       rootScope = rootScope.parent;
     }
     const sourceIndex = this.#originalScopes.findIndex(scopes => scopes?.includes(rootScope));
-    const url = sourceIndex !== -1 ? this.#sourceMap.sourceURLForSourceIndex(sourceIndex) : undefined;
-
-    return functionScope ? {scope: functionScope, url} : null;
+    return sourceIndex !== -1 ? this.#sourceMap.sourceURLForSourceIndex(sourceIndex) : undefined;
   }
 
   /**
@@ -513,33 +498,54 @@ export class SourceMapScopesInfo {
   }
 
   /**
-   * Returns one or more original stack frames for this single "raw frame" or call-site.
-   *
-   * @returns An empty array if no mapping at the call-site was found, or the resulting frames
-   * in top-to-bottom order in case of inlining.
-   * @throws If this range is marked "hidden". Outlining needs to be handled externally as
-   * outlined function segments in stack traces can span across bundles.
+   * Translates a single "raw frame" or call-site, including outlined functions. It's the caller's responsibility to
+   * merge outlined frames with their caller(s) (see {@link GeneratedFrameKind}).
    */
-  translateCallSite(generatedLine: number, generatedColumn: number): TranslatedFrame[] {
+  translateRawFrame(generatedLine: number, generatedColumn: number): RawFrameTranslation {
     const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
-    if (this.#isOutlinedFrame(rangeChain)) {
-      throw new Error('SourceMapScopesInfo is unable to translate an outlined function by itself');
+    const kind = this.#generatedFrameKind(rangeChain);
+    if (kind === GeneratedFrameKind.HIDDEN) {
+      return {kind, frames: []};
     }
+    const frame = this.#translateTopFrame(generatedLine, generatedColumn, rangeChain);
+    return {kind, frames: frame ? [frame, ...this.#translateInlinedCallers(rangeChain)] : []};
+  }
+
+  /**
+   * The top-most frame is translated the same, regardless of whether we have inlined functions: The name is the
+   * original function surrounding the generated position, and the location is the mapped generated position.
+   *
+   * If the generated position has no mapping, the generated ranges may still tell which authored function (or
+   * which file, for top-level code) the position belongs to. The frame then has no position.
+   */
+  #translateTopFrame(generatedLine: number, generatedColumn: number,
+                     rangeChain: ScopesCodec.GeneratedRange[]): TranslatedFrame|null {
+    const position = {line: generatedLine, column: generatedColumn};
+    const innerMostScope = this.#innerMostOriginalScope(rangeChain, position);
+    const functionScope = this.#findFunctionScopeInOriginalScopeChain(innerMostScope);
+    const name = functionScope ? (functionScope.name ?? '') : undefined;
 
     const mapping = this.#sourceMap.findEntry(generatedLine, generatedColumn);
-    if (mapping?.sourceIndex === undefined) {
-      return [];
+    if (mapping?.sourceIndex !== undefined) {
+      return {
+        line: mapping.sourceLineNumber,
+        column: mapping.sourceColumnNumber,
+        name,
+        url: mapping.sourceURL,
+        functionStart: functionScope?.start,
+      };
     }
+    if (!innerMostScope) {
+      return null;
+    }
+    return {name, url: this.#sourceURLOfScope(functionScope ?? innerMostScope), functionStart: functionScope?.start};
+  }
 
-    // The top-most frame is translated the same even if we have inlined functions.
-    const result: TranslatedFrame[] = [{
-      line: mapping.sourceLineNumber,
-      column: mapping.sourceColumnNumber,
-      name: this.findOriginalFunctionName({line: generatedLine, column: generatedColumn}) ?? undefined,
-      url: mapping.sourceURL,
-    }];
-
-    // Walk the range chain inside out until we find a generated function and for each inlined function add a frame.
+  /**
+   * Walk the range chain inside out until we find a generated function and for each inlined function add a frame.
+   */
+  #translateInlinedCallers(rangeChain: ScopesCodec.GeneratedRange[]): TranslatedFrame[] {
+    const result: TranslatedFrame[] = [];
     for (let i = rangeChain.length - 1; i >= 0 && !rangeChain[i].isStackFrame; --i) {
       const range = rangeChain[i];
       if (!range.callSite) {
@@ -547,29 +553,160 @@ export class SourceMapScopesInfo {
       }
 
       const originalScopeChain = this.#findOriginalScopeChain(range.callSite);
+      const functionScope = this.#findFunctionScopeInOriginalScopeChain(originalScopeChain.at(-1));
       result.push({
         line: range.callSite.line,
         column: range.callSite.column,
-        name: this.#findFunctionNameInOriginalScopeChain(originalScopeChain.at(-1)) ?? undefined,
+        name: functionScope ? (functionScope.name ?? '') : undefined,
         url: this.#sourceMap.sourceURLForSourceIndex(range.callSite.sourceIndex),
+        functionStart: functionScope?.start,
       });
     }
 
     return result;
   }
+
+  /**
+   * @returns the body of the innermost inlined function at the position (the innermost range with a `callSite`
+   *          within the generated function), or null if the position is not inside an inlined function.
+   *
+   * The innermost inlined function is the logical frame the position belongs to, i.e. the analogue of the top frame
+   * of a real call stack. Stepping over its body therefore goes up exactly one logical frame: into the caller, which
+   * may itself be inlined. An outer range would leave several logical frames at once.
+   */
+  inlinedFunctionRange(generatedLine: number, generatedColumn: number): PositionRange|null {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    for (let i = rangeChain.length - 1; i >= 0 && !rangeChain[i].isStackFrame; --i) {
+      if (rangeChain[i].callSite) {
+        return {start: rangeChain[i].start, end: rangeChain[i].end};
+      }
+    }
+    return null;
+  }
+
+  /**
+   * @returns the bodies of all functions that were inlined directly into the logical function at the position
+   *          (the innermost inlined function, or else the generated function). Doesn't descend into inlined
+   *          functions or nested generated functions.
+   */
+  inlinedCalleeRanges(generatedLine: number, generatedColumn: number): PositionRange[] {
+    const rangeChain = this.#findGeneratedRangeChain(generatedLine, generatedColumn);
+    let body: ScopesCodec.GeneratedRange|undefined;
+    for (let i = rangeChain.length - 1; i >= 0 && !body; --i) {
+      if (rangeChain[i].callSite || rangeChain[i].isStackFrame) {
+        body = rangeChain[i];
+      }
+    }
+    const result: PositionRange[] = [];
+    (function walk(range: ScopesCodec.GeneratedRange) {
+      for (const child of range.children) {
+        if (child.isStackFrame) {
+          continue;
+        }
+        if (child.callSite) {
+          result.push({start: child.start, end: child.end});
+        } else {
+          walk(child);
+        }
+      }
+    })(body ?? {children: this.#generatedRanges} as ScopesCodec.GeneratedRange);
+    return result;
+  }
+
+  /**
+   * @returns true, iff any generated function is outlined, i.e. marked as "hidden" but with a definition (see
+   *          {@link GeneratedFrameKind.OUTLINED}). Hidden functions without a definition are compiler helpers.
+   */
+  hasOutlinedFunctions(): boolean {
+    const hasOutlined = (ranges: ScopesCodec.GeneratedRange[]): boolean =>
+        ranges.some(range => (range.isStackFrame && range.isHidden && range.originalScope !== undefined) ||
+                        hasOutlined(range.children));
+    return hasOutlined(this.#generatedRanges);
+  }
+
+  /**
+   * @returns the "artificial" generated functions (in the DWARF sense): functions that contain no authored code at all
+   *          (no original scope anywhere in their subtree), e.g. compiler helpers. Sorted by start position,
+   *          non-overlapping.
+   */
+  artificialFunctionRanges(): PositionRange[] {
+    const hasOriginalScope = (range: ScopesCodec.GeneratedRange): boolean =>
+        range.originalScope !== undefined || range.children.some(hasOriginalScope);
+    const result: PositionRange[] = [];
+    (function walk(ranges: ScopesCodec.GeneratedRange[]) {
+      for (const range of ranges) {
+        if (range.isStackFrame && !hasOriginalScope(range)) {
+          result.push({start: range.start, end: range.end});
+        } else {
+          walk(range.children);
+        }
+      }
+    })(this.#generatedRanges);
+    return result;
+  }
+}
+
+/** A range of generated positions, relative to the start of the script. `end` is exclusive. */
+export interface PositionRange {
+  readonly start: ScopesCodec.Position;
+  readonly end: ScopesCodec.Position;
+}
+
+/**
+ * Describes how the generated function surrounding a generated position shows up in stack traces.
+ *
+ * Compilers tend to introduce functions (and calls to them) that don't exist in the authored code. The scopes
+ * proposal distinguishes two cases:
+ *
+ *   1) The generated function contains authored code, e.g. a block scope that was turned into a function. The
+ *      generated range is marked "hidden", but links to the original scope via its definition. We can pause
+ *      in such a function, but the frame is merged with its caller(s) in stack traces: The outlined code
+ *      logically belongs to the (authored) function that transitively calls it.
+ *
+ *   2) The generated function doesn't represent any authored code, e.g. a compiler helper. The generated range
+ *      has no definition. The scopes spec is being updated to say that such a range can be ignored in stack
+ *      traces, so we drop these frames.
+ */
+export const enum GeneratedFrameKind {
+  /** A regular (possibly with inlined functions) generated function, or top-level code. */
+  VISIBLE = 'VISIBLE',
+  /** A generated function marked as "hidden" that has a definition (case 1). */
+  OUTLINED = 'OUTLINED',
+  /** A generated function without a definition (case 2). */
+  HIDDEN = 'HIDDEN',
+}
+
+/** See {@link SourceMapScopesInfo.translateRawFrame}. */
+export interface RawFrameTranslation {
+  kind: GeneratedFrameKind;
+  /**
+   * [top, ...inlinedCallers] in top-to-bottom order. Empty for {@link GeneratedFrameKind.HIDDEN} frames, or if
+   * neither the mappings nor the generated ranges know anything about the generated position.
+   *
+   * For {@link GeneratedFrameKind.OUTLINED} frames, the top frame is named after the authored function the outlined
+   * code belongs to.
+   */
+  frames: TranslatedFrame[];
 }
 
 /**
  * Represents a stack frame in original terms. It closely aligns with StackTrace.StackTrace.Frame,
  * but since we can't import that type here we mirror it here somewhat.
  *
- * Equivalent to Pick<StackTrace.StackTrace.Frame, 'line'|'column'|'name'|'url'>.
+ * Equivalent to Pick<StackTrace.StackTrace.Frame, 'line'|'column'|'name'|'url'>, except that the position is
+ * optional.
  */
 export interface TranslatedFrame {
-  line: number;
-  column: number;
+  /**
+   * `line` and `column` are undefined iff the generated position has no mapping. The frame then only identifies
+   * the authored function: `name`, `functionStart` and the `url` of the function's source.
+   */
+  line?: number;
+  column?: number;
   name?: string;
   url?: Platform.DevToolsPath.UrlString;
+  /** Start of the original function scope containing this frame's position. Undefined for top-level code. */
+  functionStart?: ScopesCodec.Position;
 }
 
 export function findExpression(range: ScopesCodec.GeneratedRange|undefined, index: number, line = 0,

package/front_end/core/text_utils/ContentData.ts

@@ -19,6 +19,23 @@ const objectUrlRegistry = new FinalizationRegistry<string>(url => {
  */
 const MAX_BLOB_SIZE_BYTES = 10 * 1024 * 1024;
 
+/**
+ * Returns `charset` if `TextDecoder` supports it, and 'utf-8' otherwise.
+ * The charset usually comes straight from a `Content-Type` header, and
+ * `TextDecoder` has no non-throwing way to check a label.
+ */
+function supportedCharsetOrUtf8(charset: string|undefined): string {
+  if (!charset) {
+    return 'utf-8';
+  }
+  try {
+    new TextDecoder(charset);
+    return charset;
+  } catch {
+    return 'utf-8';
+  }
+}
+
 /**
  * This class is a small wrapper around either raw binary or text data.
  * As the binary data can actually contain textual data, we also store the
@@ -44,7 +61,7 @@ export class ContentData {
   #imagePreviewUrl?: string;
 
   constructor(data: string, isBase64: boolean, mimeType: string, charset?: string) {
-    this.charset = charset || 'utf-8';
+    this.charset = supportedCharsetOrUtf8(charset);
     if (isBase64) {
       this.#contentAsBase64 = data;
     } else {

package/front_end/core/text_utils/TextUtils.ts

@@ -9,7 +9,7 @@ import {SearchMatch} from './ContentProvider.js';
 import type {Text} from './Text.js';
 
 const KEY_VALUE_FILTER_REGEXP = /(?:^|\s)(\-)?([\w\-]+):([^\s]+)/;
-const REGEXP_FILTER_REGEXP = /(?:^|\s)(\-)?\/([^\/\\]+(\\.[^\/]*)*)\//;
+const REGEXP_FILTER_REGEXP = /(?:^|\s)(\-)?\/((?:[^\/\\]|\\.)+)\//;
 const TEXT_FILTER_REGEXP = /(?:^|\s)(\-)?([^\s]+)/;
 const SPACE_CHAR_REGEXP = /\s/;
 

package/front_end/entrypoints/devtools_app/devtools_app.ts

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 import '../shell/shell.js';
+import '../../panels/comments/comments-meta.js';
 import '../../panels/css_overview/css_overview-meta.js';
 import '../../panels/elements/elements-meta.js';
 import '../../panels/browser_debugger/browser_debugger-meta.js';

package/front_end/entrypoints/heap_snapshot_worker/ContextAnalyzer.ts

@@ -28,6 +28,11 @@ type ScopeInfoNodeIndex = Platform.Brand.Brand<number, 'ScopeInfoNodeIndex'>;
  */
 type ContextNodeIndex = Platform.Brand.Brand<number, 'ContextNodeIndex'>;
 
+/**
+ * Index of a `system / Map` node within the heap snapshot's node array.
+ */
+type MapNodeIndex = Platform.Brand.Brand<number, 'MapNodeIndex'>;
+
 /**
  * Values addressed by scope. Since a `ScopeId` is only unique within its
  * script, scopes are keyed by script first.
@@ -74,6 +79,8 @@ interface ScopeAccumulator {
 }
 
 interface LiveClosure {
+  // The JSFunction or generator object this entry was created for.
+  ownerNodeIndex: number;
   contextNodeIndex: ContextNodeIndex;
   scriptNodeIndex: ScriptNodeIndex;
   scopeId: ScopeId;
@@ -99,6 +106,8 @@ interface HeapScan {
   scripts: Map<ScriptNodeIndex, ScriptInfo>;
   contextNodes: ContextNodeInfo[];
   liveClosures: LiveClosure[];
+  // Top-level functions of modules that finished evaluating.
+  finishedModuleFunctionNodeIndexes: Set<number>;
   // Maps a ScopeInfo to the script it belongs to. A stored `undefined` is a memoized
   // failed lookup. It is therefore not the same as an absent entry, which merely means
   // "not resolved yet".
@@ -114,7 +123,7 @@ export function analyzeContexts(snapshot: HeapSnapshot): HeapSnapshotModel.HeapS
   const scan = scanHeap(snapshot);
 
   // (3) Group live closures by function scope and record the context chains they can reach.
-  const liveFunctionsByScript = buildLiveFunctions(snapshot, scan.liveClosures);
+  const liveFunctionsByScript = buildLiveFunctions(snapshot, scan.liveClosures, scan.finishedModuleFunctionNodeIndexes);
 
   // (4) Correlate contexts and their field values with embedded scopes.
   const {scopes, scriptsWithoutScopes} = correlateContextsWithScopes(snapshot, scan, scopesByScript);
@@ -240,6 +249,9 @@ function scanHeap(snapshot: HeapSnapshot): HeapScan {
   const scripts = new Map<ScriptNodeIndex, ScriptInfo>();
   const contextNodes: ContextNodeInfo[] = [];
   const liveClosures: LiveClosure[] = [];
+  const finishedModuleFunctionNodeIndexes = new Set<number>();
+  // Caches for each map whether it belongs to a generator object. See `isGeneratorObject`.
+  const generatorMapNodeIndexes = new Map<MapNodeIndex, boolean>();
   const scopeInfoScriptNodeIndexes = new Map<ScopeInfoNodeIndex, ScriptNodeIndex|undefined>();
   const node = snapshot.createNode();
   const nodes = snapshot.nodes;
@@ -257,10 +269,12 @@ function scanHeap(snapshot: HeapSnapshot): HeapScan {
       processContext(contextNodes, node);
     } else if (node.rawType() === nodeClosureType) {
       processClosure(liveClosures, node);
+    } else if (isGeneratorObject(generatorMapNodeIndexes, node)) {
+      processGeneratorObject(liveClosures, finishedModuleFunctionNodeIndexes, node);
     }
   }
 
-  return {scripts, contextNodes, liveClosures, scopeInfoScriptNodeIndexes};
+  return {scripts, contextNodes, liveClosures, finishedModuleFunctionNodeIndexes, scopeInfoScriptNodeIndexes};
 }
 
 function processScript(scripts: Map<ScriptNodeIndex, ScriptInfo>, node: HeapSnapshotNode): void {
@@ -426,6 +440,11 @@ function processClosure(liveClosures: LiveClosure[], node: HeapSnapshotNode): vo
   if (!sharedFunctionInfo || !closureContext) {
     return;
   }
+  addLiveClosure(liveClosures, node, sharedFunctionInfo, closureContext);
+}
+
+function addLiveClosure(liveClosures: LiveClosure[], ownerNode: HeapSnapshotNode, sharedFunctionInfo: HeapSnapshotNode,
+                        contextNode: HeapSnapshotNode): void {
   const script = sharedFunctionInfo.findInternalEdgeTarget('script');
   if (!script) {
     return;
@@ -433,18 +452,97 @@ function processClosure(liveClosures: LiveClosure[], node: HeapSnapshotNode): vo
   const scopeId = sharedFunctionInfo.findInternalEdgeTarget('scope_id')?.nodeValueAsInt() as ScopeId | undefined;
   if (scopeId !== undefined) {
     liveClosures.push({
-      contextNodeIndex: closureContext.nodeIndex as ContextNodeIndex,
+      ownerNodeIndex: ownerNode.nodeIndex,
+      contextNodeIndex: contextNode.nodeIndex as ContextNodeIndex,
       scriptNodeIndex: script.nodeIndex as ScriptNodeIndex,
       scopeId,
     });
   }
 }
 
-function buildLiveFunctions(snapshot: HeapSnapshot, liveClosures: LiveClosure[]): ByScope<LiveFunction> {
+// V8's `JSGeneratorObject::kGeneratorClosed`: the generator has finished and can't be resumed.
+const GENERATOR_CLOSED = -1;
+
+/**
+ * Handles generator objects, which V8 uses for generators, async functions, async generators and
+ * the top-level code of modules.
+ */
+function processGeneratorObject(liveClosures: LiveClosure[], finishedModuleFunctionNodeIndexes: Set<number>,
+                                node: HeapSnapshotNode): void {
+  const continuation = node.findInternalEdgeTarget('continuation')?.nodeValueAsInt();
+  const generatorFunction = node.findInternalEdgeTarget('function');
+  if (continuation === undefined || generatorFunction?.rawType() !== node.snapshot.nodeClosureType) {
+    return;
+  }
+  const sharedFunctionInfo = generatorFunction.findInternalEdgeTarget('shared');
+  if (!sharedFunctionInfo) {
+    return;
+  }
+  if (continuation === GENERATOR_CLOSED) {
+    const scopeId = sharedFunctionInfo.findInternalEdgeTarget('scope_id')?.nodeValueAsInt();
+
+    // Only the top-level code of a module is both a generator and a root scope.
+    if (scopeId !== undefined && isScriptRootScopeId(scopeId)) {
+      // A module stores a reference to its generator object. The generator object then
+      // references the top-level JSFunction. Once the generator object is finished its
+      // JSFunction can't run anymore and user code can't call it. Here we record such closures
+      // in order to skip them later in buildLiveFunctions().
+      finishedModuleFunctionNodeIndexes.add(generatorFunction.nodeIndex);
+    }
+
+    // A finished generator can't run again, so it doesn't get a LiveClosure. That way the fields
+    // of its context can be reported as dead.
+    return;
+  }
+  const generatorContext = node.findInternalEdgeTarget('context');
+  if (generatorContext) {
+    // The context of the generator's function is the one the function was created in. The body
+    // of the generator, however, runs in a context of its own, which only the generator object
+    // refers to. A generator therefore counts as a closure of its function with the context
+    // it resumes in.
+    addLiveClosure(liveClosures, node, sharedFunctionInfo, generatorContext);
+  }
+}
+
+// V8's instance types of `JSGeneratorObject` and its subclasses.
+const GENERATOR_INSTANCE_TYPE_NAMES = new Set([
+  'JS_GENERATOR_OBJECT_TYPE',
+  'JS_ASYNC_FUNCTION_OBJECT_TYPE',
+  'JS_ASYNC_GENERATOR_OBJECT_TYPE',
+]);
+
+/**
+ * Checks the instance type of the object's map, so that other objects with fields of the same name
+ * aren't mistaken for generator objects. The result is cached for each map.
+ */
+function isGeneratorObject(generatorMapNodeIndexes: Map<MapNodeIndex, boolean>, node: HeapSnapshotNode): boolean {
+  if (node.rawType() !== node.snapshot.nodeObjectType) {
+    return false;
+  }
+  const map = node.findInternalEdgeTarget('map');
+  if (!map) {
+    return false;
+  }
+  const mapNodeIndex = map.nodeIndex as MapNodeIndex;
+  let isGenerator = generatorMapNodeIndexes.get(mapNodeIndex);
+  if (isGenerator === undefined) {
+    const instanceTypeName = map.findInternalEdgeTarget('instance_type_name')?.rawName();
+    isGenerator = instanceTypeName !== undefined && GENERATOR_INSTANCE_TYPE_NAMES.has(instanceTypeName);
+    generatorMapNodeIndexes.set(mapNodeIndex, isGenerator);
+  }
+  return isGenerator;
+}
+
+function buildLiveFunctions(snapshot: HeapSnapshot, liveClosures: LiveClosure[],
+                            finishedModuleFunctionNodeIndexes: Set<number>): ByScope<LiveFunction> {
   const liveFunctionsByScript: ByScope<LiveFunction> = new Map();
   const node = snapshot.createNode();
 
   for (const closure of liveClosures) {
+    if (finishedModuleFunctionNodeIndexes.has(closure.ownerNodeIndex)) {
+      // The top-level code of this module has finished and can't run anymore.
+      continue;
+    }
     let scriptFunctions = liveFunctionsByScript.get(closure.scriptNodeIndex);
     if (!scriptFunctions) {
       scriptFunctions = new Map<ScopeId, LiveFunction>();