chrome-devtools-frontend 1.0.1704172 → 1.0.1706026

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -14,7 +14,7 @@ import {SourceMapScopeChainEntry} from './SourceMapScopeChainEntry.js';
 
 export class SourceMapScopesInfo {
   readonly #sourceMap: SourceMap;
-  readonly #originalScopes: Array<ScopesCodec.OriginalScope|null>;
+  readonly #originalScopes: Array<ScopesCodec.OriginalScope[]|null>;
   readonly #generatedRanges: ScopesCodec.GeneratedRange[];
 
   #cachedVariablesAndBindingsPresent: boolean|null = null;
@@ -35,20 +35,10 @@ export class SourceMapScopesInfo {
       sourceMap: SourceMap, scopeTree: Formatter.FormatterWorkerPool.ScopeTreeNode,
       text: TextUtils.Text.Text): SourceMapScopesInfo {
     const numSourceUrls = sourceMap.sourceURLs().length;
-    const scopeBySourceUrl: ScopesCodec.OriginalScope[] = [];
-    for (let i = 0; i < numSourceUrls; i++) {
-      const scope: ScopesCodec.OriginalScope = {
-        start: {line: 0, column: 0},
-        end: {line: Number.POSITIVE_INFINITY, column: Number.POSITIVE_INFINITY},
-        isStackFrame: false,
-        variables: [],
-        children: [],
-      };
-      scopeBySourceUrl.push(scope);
-    }
+    const scopesBySourceUrl: ScopesCodec.OriginalScope[][] = Array.from({length: numSourceUrls}, () => []);
 
     // Convert the entire scopeTree. Returns a root range that encompasses everything,
-    // and inserts scopes by sourceIndex into the above scopeBySourceUrl.
+    // and inserts scopes by sourceIndex into the above scopesBySourceUrl.
     const stack: Array<{
       node: Formatter.FormatterWorkerPool.ScopeTreeNode,
       parentRange?: ScopesCodec.GeneratedRange,
@@ -114,10 +104,8 @@ export class SourceMapScopesInfo {
 
       let nextParentScopeHint = parentScopeHint;
       if (canMapOriginalPosition && scope) {
-        const rootScope = scopeBySourceUrl[sourceIndex];
-        const startSearchFrom =
-            (parentScopeHint && containsOriginal(parentScopeHint, scope)) ? parentScopeHint : rootScope;
-        insertInScope(startSearchFrom, scope);
+        const startParent = (parentScopeHint && containsOriginal(parentScopeHint, scope)) ? parentScopeHint : undefined;
+        insertInScope(sourceIndex, startParent, scope);
         nextParentScopeHint = scope;
       }
 
@@ -126,20 +114,21 @@ export class SourceMapScopesInfo {
       }
     }
 
-    return new SourceMapScopesInfo(sourceMap, {scopes: scopeBySourceUrl, ranges: rootRange ? [rootRange] : []});
+    return new SourceMapScopesInfo(sourceMap, {scopes: scopesBySourceUrl, ranges: rootRange ? [rootRange] : []});
 
     /**
      * Finds the correct place in the tree to insert the new scope.
      * Maintains the invariant that children are sorted and contained by their parent.
      */
-    function insertInScope(rootScope: ScopesCodec.OriginalScope, newScope: ScopesCodec.OriginalScope): void {
-      let parent = rootScope;
+    function insertInScope(sourceIndex: number, parent: ScopesCodec.OriginalScope|undefined,
+                           newScope: ScopesCodec.OriginalScope): void {
+      let children = parent ? parent.children : scopesBySourceUrl[sourceIndex];
       // Check if the newScope fits strictly inside any of the existing children.
       // We iterate to find the deepest parent to avoid Maximum Call Stack Size Exceeded
       // errors on highly nested scripts.
       while (true) {
         let deeperParent: ScopesCodec.OriginalScope|null = null;
-        for (const child of parent.children) {
+        for (const child of children) {
           if (containsOriginal(child, newScope)) {
             deeperParent = child;
             break;
@@ -147,17 +136,18 @@ export class SourceMapScopesInfo {
         }
         if (deeperParent) {
           parent = deeperParent;
+          children = deeperParent.children;
         } else {
           break;
         }
       }
 
-      // When here, newScope belongs directly in parent.
-      // However, newScope might encompass some of parent's existing children (due
+      // When here, newScope belongs directly in parent (or at the root of the source file).
+      // However, newScope might encompass some of the existing children (due
       // to compiler transform quirks or arbitrary insertion order). We must move
       // those children inside newScope.
       const childrenToKeep: ScopesCodec.OriginalScope[] = [];
-      for (const child of parent.children) {
+      for (const child of children) {
         if (containsOriginal(newScope, child)) {
           // child is actually inside newScope, so re-parent it.
           newScope.children.push(child);
@@ -177,8 +167,12 @@ export class SourceMapScopesInfo {
         childrenToKeep.splice(insertIndex, 0, newScope);
       }
 
-      // Update parent's children to only be the ones that don't belong to newScope.
-      parent.children = childrenToKeep;
+      // Update parent's children (or root scopes) to only be the ones that don't belong to newScope.
+      if (parent) {
+        parent.children = childrenToKeep;
+      } else {
+        scopesBySourceUrl[sourceIndex] = childrenToKeep;
+      }
       newScope.parent = parent;
     }
 
@@ -196,7 +190,7 @@ export class SourceMapScopesInfo {
     }
   }
 
-  addOriginalScopes(scopes: Array<ScopesCodec.OriginalScope|null>): void {
+  addOriginalScopes(scopes: Array<ScopesCodec.OriginalScope[]|null>): void {
     for (const scope of scopes) {
       this.#originalScopes.push(scope);
     }
@@ -209,17 +203,17 @@ export class SourceMapScopesInfo {
   }
 
   hasOriginalScopes(sourceIdx: number): boolean {
-    return Boolean(this.#originalScopes[sourceIdx]);
+    return Boolean(this.#originalScopes[sourceIdx]?.length);
   }
 
   isEmpty(): boolean {
-    const noScopes = this.#originalScopes.every(scope => scope === null);
+    const noScopes = this.#originalScopes.every(scopes => scopes === null || scopes.length === 0);
     return noScopes && !this.#generatedRanges.length;
   }
 
-  addOriginalScopesAtIndex(sourceIdx: number, scope: ScopesCodec.OriginalScope): void {
-    if (!this.#originalScopes[sourceIdx]) {
-      this.#originalScopes[sourceIdx] = scope;
+  addOriginalScopesAtIndex(sourceIdx: number, scopes: ScopesCodec.OriginalScope[]): void {
+    if (!this.#originalScopes[sourceIdx]?.length) {
+      this.#originalScopes[sourceIdx] = scopes;
     } else {
       throw new Error(`Trying to re-augment existing scopes for source at index: ${sourceIdx}`);
     }
@@ -262,9 +256,10 @@ export class SourceMapScopesInfo {
 
   /**
    * Given a generated position, this returns all the surrounding generated ranges from outer
-   * to inner.
+   * to inner. When `inlineFrameIndex > 0`, drops inner ranges up to the specified virtual
+   * call frame.
    */
-  #findGeneratedRangeChain(line: number, column: number): ScopesCodec.GeneratedRange[] {
+  #findGeneratedRangeChain(line: number, column: number, inlineFrameIndex = 0): ScopesCodec.GeneratedRange[] {
     const result: ScopesCodec.GeneratedRange[] = [];
 
     (function walkRanges(ranges: ScopesCodec.GeneratedRange[]) {
@@ -277,6 +272,17 @@ export class SourceMapScopesInfo {
       }
     })(this.#generatedRanges);
 
+    // Drop ranges in the chain until we reach our desired inlined range.
+    for (let inlineIndex = 0; inlineIndex < inlineFrameIndex;) {
+      const range = result.pop();
+      if (!range) {
+        break;
+      }
+      if (range.callSite) {
+        ++inlineIndex;
+      }
+    }
+
     return result;
   }
 
@@ -295,12 +301,8 @@ export class SourceMapScopesInfo {
     // We check whether any original scope has a non-empty list of variables, and
     // generated ranges with a non-empty binding list.
 
-    function walkTree(nodes: Array<ScopesCodec.OriginalScope|null>|ScopesCodec.GeneratedRange[]): boolean {
+    function walkTree(nodes: ScopesCodec.OriginalScope[]|ScopesCodec.GeneratedRange[]): boolean {
       for (const node of nodes) {
-        if (!node) {
-          continue;
-        }
-
         if ('variables' in node && node.variables.length > 0) {
           return true;
         }
@@ -315,7 +317,7 @@ export class SourceMapScopesInfo {
       }
       return false;
     }
-    return walkTree(this.#originalScopes) && walkTree(this.#generatedRanges);
+    return this.#originalScopes.some(scopes => scopes !== null && walkTree(scopes)) && walkTree(this.#generatedRanges);
   }
 
   /**
@@ -387,28 +389,14 @@ export class SourceMapScopesInfo {
     return result;
   }
 
-  /** Similar to #findGeneratedRangeChain, but takes inlineFrameIndex of virtual call frames into account */
   #findGeneratedRangeChainForFrame(callFrame: CallFrame): ScopesCodec.GeneratedRange[] {
     const {line, column} = scriptRelativePosition(callFrame.location());
-    const rangeChain = this.#findGeneratedRangeChain(line, column);
-    if (callFrame.inlineFrameIndex === 0) {
-      return rangeChain;
-    }
-
-    // Drop ranges in the chain until we reach our desired inlined range.
-    for (let inlineIndex = 0; inlineIndex < callFrame.inlineFrameIndex;) {
-      const range = rangeChain.pop();
-      if (range?.callSite) {
-        ++inlineIndex;
-      }
-    }
-
-    return rangeChain;
+    return this.#findGeneratedRangeChain(line, column, callFrame.inlineFrameIndex);
   }
 
-  resolveMappedVariablesAtPosition(line: number, column: number,
-                                   ignoreInnerBlockScopes = false): Array<Map<string, string|null>>|null {
-    const rangeChain = this.#findGeneratedRangeChain(line, column);
+  resolveMappedVariablesAtPosition(line: number, column: number, ignoreInnerBlockScopes = false,
+                                   inlineFrameIndex = 0): Array<Map<string, string|null>>|null {
+    const rangeChain = this.#findGeneratedRangeChain(line, column, inlineFrameIndex);
     const startScope = rangeChain.at(-1)?.originalScope;
     const innerMostScope =
         (startScope && ignoreInnerBlockScopes && this.#findFunctionScopeInOriginalScopeChain(startScope)) || startScope;
@@ -475,7 +463,7 @@ export class SourceMapScopesInfo {
     while (rootScope.parent) {
       rootScope = rootScope.parent;
     }
-    const sourceIndex = this.#originalScopes.indexOf(rootScope);
+    const sourceIndex = this.#originalScopes.findIndex(scopes => scopes?.includes(rootScope));
     const url = sourceIndex !== -1 ? this.#sourceMap.sourceURLForSourceIndex(sourceIndex) : undefined;
 
     return functionScope ? {scope: functionScope, url} : null;
@@ -486,8 +474,8 @@ export class SourceMapScopesInfo {
    * to inner.
    */
   #findOriginalScopeChain({sourceIndex, line, column}: ScopesCodec.OriginalPosition): ScopesCodec.OriginalScope[] {
-    const scope = this.#originalScopes[sourceIndex];
-    if (!scope) {
+    const scopes = this.#originalScopes[sourceIndex];
+    if (!scopes) {
       return [];
     }
 
@@ -500,7 +488,7 @@ export class SourceMapScopesInfo {
         result.push(scope);
         walkScopes(scope.children);
       }
-    })([scope]);
+    })(scopes);
 
     return result;
   }

package/front_end/entrypoints/formatter_actions/formatter_actions.ts

@@ -51,6 +51,24 @@ export const enum ScopeKind {
   ARROW_FUNCTION = 4,
 }
 
+/**
+ * Describes a single scope for `javaScriptSubstitute`.
+ */
+export interface ScopeVariableMapping {
+  /**
+   * Authored variable name -> generated binding expression, or `null` if the variable is unavailable.
+   */
+  bindings: Map<string, string|null>;
+  /**
+   * Generated identifiers declared by this scope. Together with the free identifiers of `bindings`, these
+   * shadow bindings of outer scopes that refer to the same generated identifiers.
+   *
+   * This is needed when a generated identifier doesn't show up in any binding expression, e.g. because
+   * multiple generated identifiers map to the same authored name, or the authored name is unknown.
+   */
+  generatedNames: string[];
+}
+
 export interface ScopeTreeNode {
   variables: Array<{name: string, kind: DefinitionKind, offsets: number[]}>;
   start: number;

package/front_end/entrypoints/formatter_worker/Substitute.ts

@@ -3,13 +3,13 @@
 // found in the LICENSE file.
 
 import * as Acorn from '../../third_party/acorn/acorn.js';
-import {DefinitionKind} from '../formatter_actions/formatter_actions.js';
+import {DefinitionKind, type ScopeVariableMapping} from '../formatter_actions/formatter_actions.js';
 
 import {ECMA_VERSION} from './AcornTokenizer.js';
 import {ScopeVariableAnalysis, type VariableUses} from './ScopeParser.js';
 
-export function substituteExpression(expression: string, nameMaps: Array<Map<string, string|null>>): string {
-  const replacements = computeSubstitution(expression, nameMaps);
+export function substituteExpression(expression: string, scopes: ScopeVariableMapping[]): string {
+  const replacements = computeSubstitution(expression, scopes);
   return applySubstitution(expression, replacements);
 }
 
@@ -52,12 +52,12 @@ function parseBindingExpression(expression: string): {
 }
 
 /**
- * Given an |expression| and a mapping from names to new names, the |computeSubstitution|
+ * Given an |expression| and a list of |scopes| (from inner-most to outer-most), the |computeSubstitution|
  * function returns a list of replacements sorted by the offset. The function throws if
  * it cannot parse the expression or the substitution is impossible to perform (for example
  * if the substitution target is 'this' within a function, it would become bound there).
  **/
-function computeSubstitution(expression: string, nameMaps: Array<Map<string, string|null>>): Replacement[] {
+function computeSubstitution(expression: string, scopes: ScopeVariableMapping[]): Replacement[] {
   // Parse the expression and find variables and scopes.
   const root = Acorn.parse(expression, {
     ecmaVersion: ECMA_VERSION,
@@ -75,10 +75,11 @@ function computeSubstitution(expression: string, nameMaps: Array<Map<string, str
   const allNames = scopeVariables.getAllNames();
   const nameMap = new Map<string, string|null>();
   const parsedBindings = new Map<string, ReturnType<typeof parseBindingExpression>>();
+  // Generated identifiers declared by the scopes visited so far. Outer bindings referring to them are shadowed.
   const shadowedNames = new Set<string>();
-  for (const scopeMap of nameMaps) {
-    const scopeNames = new Set<string>();
-    for (const [name, rename] of scopeMap.entries()) {
+  for (const {bindings, generatedNames} of scopes) {
+    const scopeNames = new Set<string>(generatedNames);
+    for (const [name, rename] of bindings.entries()) {
       let parsed: ReturnType<typeof parseBindingExpression>|undefined;
       if (rename !== null) {
         try {

package/front_end/entrypoints/formatter_worker/formatter_worker-entrypoint.ts

@@ -3,7 +3,7 @@
 // found in the LICENSE file.
 
 import * as Platform from '../../core/platform/platform.js';
-import {FormatterActions} from '../formatter_actions/formatter_actions.js';
+import {FormatterActions, type ScopeVariableMapping} from '../formatter_actions/formatter_actions.js';
 
 import * as FormatterWorker from './formatter_worker.js';
 
@@ -13,7 +13,7 @@ Platform.HostRuntime.HOST_RUNTIME.workerScope.onmessage = function(event): void
     indentString: string,
     content: string,
     mimeType: string,
-    mapping: Array<Map<string, string|null>>,
+    mapping: ScopeVariableMapping[],
     sourceType: 'module'|'script',
   } = event.data.params;
   if (!method) {
@@ -29,8 +29,13 @@ Platform.HostRuntime.HOST_RUNTIME.workerScope.onmessage = function(event): void
       FormatterWorker.CSSRuleParser.parseCSS(params.content, self.postMessage);
       break;
     case FormatterActions.JAVASCRIPT_SUBSTITUTE: {
-      Platform.HostRuntime.HOST_RUNTIME.workerScope.postMessage(
-          FormatterWorker.Substitute.substituteExpression(params.content, params.mapping));
+      let result: string|{error: string};
+      try {
+        result = FormatterWorker.Substitute.substituteExpression(params.content, params.mapping);
+      } catch (error) {
+        result = {error: error instanceof Error ? error.message : String(error)};
+      }
+      Platform.HostRuntime.HOST_RUNTIME.workerScope.postMessage(result);
       break;
     }
     case FormatterActions.JAVASCRIPT_SCOPE_TREE: {

package/front_end/entrypoints/heap_snapshot_worker/ContextAnalyzer.ts

@@ -99,14 +99,9 @@ interface HeapScan {
   scripts: Map<ScriptNodeIndex, ScriptInfo>;
   contextNodes: ContextNodeInfo[];
   liveClosures: LiveClosure[];
-  // Maps a ScopeInfo to the script it belongs to. Only contains the ScopeInfos
-  // directly referenced by a SharedFunctionInfo, the remaining ones are resolved
-  // and memoized on demand by `resolveScopeInfoScriptNodeIndex`.
-  //
-  // A stored `undefined` is a memoized failed lookup, i.e. walking the
-  // `outer_scope_info` chain of that ScopeInfo did not reach a script. It is
-  // therefore not the same as an absent entry, which merely means "not resolved
-  // yet", so lookups have to distinguish the two through `has()`.
+  // 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".
   scopeInfoScriptNodeIndexes: Map<ScopeInfoNodeIndex, ScriptNodeIndex|undefined>;
 }
 
@@ -257,12 +252,11 @@ function scanHeap(snapshot: HeapSnapshot): HeapScan {
 
     if (rawName.startsWith('system / Script')) {
       processScript(scripts, node);
+      processScriptScopeInfos(scopeInfoScriptNodeIndexes, node);
     } else if (snapshot.isContextObject(node)) {
       processContext(contextNodes, node);
     } else if (node.rawType() === nodeClosureType) {
       processClosure(liveClosures, node);
-    } else if (rawName.startsWith('system / SharedFunctionInfo')) {
-      processSharedFunctionInfo(scopeInfoScriptNodeIndexes, node);
     }
   }
 
@@ -283,6 +277,137 @@ function processScript(scripts: Map<ScriptNodeIndex, ScriptInfo>, node: HeapSnap
   });
 }
 
+function processScriptScopeInfos(
+    scopeInfoScriptNodeIndexes: Map<ScopeInfoNodeIndex, ScriptNodeIndex|undefined>,
+    scriptNode: HeapSnapshotNode,
+    ): void {
+  const infos = scriptNode.findInternalEdgeTarget('infos');
+  if (!infos) {
+    return;
+  }
+
+  const scriptNodeIndex = scriptNode.nodeIndex as ScriptNodeIndex;
+  const scopeInfoNode = scriptNode.snapshot.createNode();
+
+  // A script created by a direct `eval` records the scope its `eval` call appeared in. That scope
+  // and the ones enclosing it belong to the calling script, so walks from this script's ScopeInfos
+  // have to stop there. This is like V8's `Scope::DeserializeScopeChain` detecting eval boundaries.
+  //
+  // Stopping at the root scope (see `attributeScopeInfoChain`) is not enough here: the eval scope
+  // only gets a ScopeInfo if it needs a context. Without one, the ScopeInfo chains of this script's
+  // functions skip it and lead straight to the call-site scope, without passing a root scope.
+  //
+  // The call-site scope itself is assigned by the calling script, which lists it in its `infos`.
+  const evalFromScopeInfo = scriptNode.findInternalEdgeTarget('eval_from_scope_info');
+  const stopAtNodeIndex = evalFromScopeInfo?.rawName() === 'system / ScopeInfo' ?
+      evalFromScopeInfo.nodeIndex as ScopeInfoNodeIndex :
+      undefined;
+
+  for (let iter = infos.edges(); iter.hasNext(); iter.next()) {
+    const info = iter.edge.node();
+    const infoName = info.rawName();
+
+    // Besides SharedFunctionInfos, V8 lists the ScopeInfo of the innermost scope with a context
+    // around each direct `eval` call of this script. It belongs to this script, as do the scopes
+    // enclosing it up to the root scope of this script.
+    if (infoName === 'system / ScopeInfo') {
+      attributeScopeInfoChain(scopeInfoScriptNodeIndexes, info.nodeIndex as ScopeInfoNodeIndex, stopAtNodeIndex,
+                              scriptNodeIndex, scopeInfoNode);
+      continue;
+    }
+
+    if (!infoName.startsWith('system / SharedFunctionInfo')) {
+      continue;
+    }
+    const sharedFunctionInfo = info;
+
+    // A compiled function has a ScopeInfo of its own in `name_or_scope_info`. It belongs to this
+    // script, as do the scopes enclosing it up to the root scope of this script.
+    const scopeInfo = sharedFunctionInfo.findInternalEdgeTarget('name_or_scope_info');
+    if (scopeInfo?.rawName() === 'system / ScopeInfo') {
+      attributeScopeInfoChain(scopeInfoScriptNodeIndexes, scopeInfo.nodeIndex as ScopeInfoNodeIndex, stopAtNodeIndex,
+                              scriptNodeIndex, scopeInfoNode);
+      continue;
+    }
+
+    // While a function is uncompiled it has no ScopeInfo of its own, so use the ScopeInfo of its
+    // enclosing scope instead. A script's root function is always compiled, but if it weren't, its
+    // enclosing scope would lie outside of this script, so skip it.
+    const scopeId = sharedFunctionInfo.findInternalEdgeTarget('scope_id')?.nodeValueAsInt();
+    if (scopeId === undefined || isScriptRootScopeId(scopeId)) {
+      continue;
+    }
+
+    // Except for the root function, the enclosing ScopeInfo belongs to this script. The exception
+    // is a function in eval'd code whose eval scope has no context: its enclosing ScopeInfo is then
+    // the scope around the `eval` call in the calling script (`eval_from_scope_info`), where
+    // `attributeScopeInfoChain` stops.
+    const outerScopeInfo = sharedFunctionInfo.findInternalEdgeTarget('raw_outer_scope_info_or_feedback_metadata');
+    if (outerScopeInfo?.rawName() === 'system / ScopeInfo') {
+      attributeScopeInfoChain(scopeInfoScriptNodeIndexes, outerScopeInfo.nodeIndex as ScopeInfoNodeIndex,
+                              stopAtNodeIndex, scriptNodeIndex, scopeInfoNode);
+    }
+  }
+}
+
+/**
+ * Assigns the ScopeInfo at `scopeInfoNodeIndex` and the ones enclosing it to the script at
+ * `scriptNodeIndex`. Stops at the root scope of the script, or at `stopAtNodeIndex`, the
+ * `eval_from_scope_info` of the script, which belongs to the calling script.
+ *
+ * Only this function assigns ScopeInfos while scanning the heap, and it always continues up to
+ * such a boundary. An already assigned ScopeInfo therefore means that its enclosing ScopeInfos
+ * are assigned as well, so the walk can stop there too.
+ */
+function attributeScopeInfoChain(
+    scopeInfoScriptNodeIndexes: Map<ScopeInfoNodeIndex, ScriptNodeIndex|undefined>,
+    scopeInfoNodeIndex: ScopeInfoNodeIndex,
+    stopAtNodeIndex: ScopeInfoNodeIndex|undefined,
+    scriptNodeIndex: ScriptNodeIndex,
+    scopeInfoNode: HeapSnapshotNode,
+    ): void {
+  let currentNodeIndex = scopeInfoNodeIndex;
+  for (;;) {
+    if (currentNodeIndex === stopAtNodeIndex) {
+      // This is the call site of the `eval` that created this script. It belongs to the calling
+      // script.
+      return;
+    }
+    if (scopeInfoScriptNodeIndexes.has(currentNodeIndex)) {
+      // This scope info was already assigned to a script.
+      return;
+    }
+    scopeInfoScriptNodeIndexes.set(currentNodeIndex, scriptNodeIndex);
+
+    scopeInfoNode.nodeIndex = currentNodeIndex;
+    // A root scope's `outer_scope_info` leads into another script (e.g. the one calling `eval`), so
+    // stop here. This only catches root scopes that have a context. The call site of a context-less
+    // eval scope is caught through `stopAtNodeIndex` above.
+    if (isScriptRootScopeInfo(scopeInfoNode)) {
+      return;
+    }
+    // The outer scope of a non-root scope can be assigned to the same script.
+    const outerScopeInfo = scopeInfoNode.findInternalEdgeTarget('outer_scope_info');
+    if (!outerScopeInfo) {
+      return;
+    }
+    currentNodeIndex = outerScopeInfo.nodeIndex as ScopeInfoNodeIndex;
+  }
+}
+
+function isScriptRootScopeInfo(node: HeapSnapshotNode): boolean {
+  const scopeId = node.findInternalEdgeTarget('scope_id')?.nodeValueAsInt();
+  return scopeId !== undefined && isScriptRootScopeId(scopeId);
+}
+
+function isScriptRootScopeId(scopeId: number): boolean {
+  // -2 is the scope id V8 gives the outermost scope of a script: its script, eval or module scope.
+  // V8 derives scope ids from source positions and uses negative ids for scopes that would otherwise
+  // start at position 0. The other one is -1 for a wrapped function (`ScriptCompiler::CompileFunction`),
+  // which is still enclosed by an eval scope of the same script.
+  return scopeId === -2;
+}
+
 function processContext(contextNodes: ContextNodeInfo[], node: HeapSnapshotNode): void {
   const scopeInfoNodeIndex = node.findInternalEdgeTarget('scope_info')?.nodeIndex as ScopeInfoNodeIndex | undefined;
   if (scopeInfoNodeIndex === undefined) {
@@ -315,16 +440,6 @@ function processClosure(liveClosures: LiveClosure[], node: HeapSnapshotNode): vo
   }
 }
 
-function processSharedFunctionInfo(scopeInfoScriptNodeIndexes: Map<ScopeInfoNodeIndex, ScriptNodeIndex|undefined>,
-                                   node: HeapSnapshotNode): void {
-  const scopeInfo = node.findInternalEdgeTarget('name_or_scope_info');
-  const script = node.findInternalEdgeTarget('script');
-  if (scopeInfo?.rawName() !== 'system / ScopeInfo' || !script?.rawName().startsWith('system / Script')) {
-    return;
-  }
-  scopeInfoScriptNodeIndexes.set(scopeInfo.nodeIndex as ScopeInfoNodeIndex, script.nodeIndex as ScriptNodeIndex);
-}
-
 function buildLiveFunctions(snapshot: HeapSnapshot, liveClosures: LiveClosure[]): ByScope<LiveFunction> {
   const liveFunctionsByScript: ByScope<LiveFunction> = new Map();
   const node = snapshot.createNode();
@@ -482,6 +597,11 @@ function resolveScopeInfoScriptNodeIndex(
     seen.add(currentNodeIndex);
     visited.push(currentNodeIndex);
     node.nodeIndex = currentNodeIndex;
+    if (isScriptRootScopeInfo(node)) {
+      // This scope belongs to a script of its own, so leaving it through
+      // `outer_scope_info` would attribute it to the wrong script.
+      break;
+    }
     const outerScopeInfo = node.findInternalEdgeTarget('outer_scope_info');
     if (!outerScopeInfo) {
       break;

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotLoader.ts

@@ -60,16 +60,22 @@ export class HeapSnapshotLoader {
     return result;
   }
 
-  #parseUintArray(): boolean {
+  /**
+   * Parses (possibly negative) integers from `#json` into `#array`. Assumes
+   * valid input. Returns true if more input is needed and false once the
+   * closing bracket was reached.
+   */
+  #parseIntArray(): boolean {
     let index = 0;
     const char0 = '0'.charCodeAt(0);
     const char9 = '9'.charCodeAt(0);
+    const minus = '-'.charCodeAt(0);
     const closingBracket = ']'.charCodeAt(0);
     const length = this.#json.length;
     while (true) {
       while (index < length) {
         const code = this.#json.charCodeAt(index);
-        if (char0 <= code && code <= char9) {
+        if ((char0 <= code && code <= char9) || code === minus) {
           break;
         } else if (code === closingBracket) {
           this.#json = this.#json.slice(index + 1);
@@ -81,8 +87,13 @@ export class HeapSnapshotLoader {
         this.#json = '';
         return true;
       }
-      let nextNumber = 0;
       const startIndex = index;
+      let negative = false;
+      if (this.#json.charCodeAt(index) === minus) {
+        negative = true;
+        ++index;
+      }
+      let nextNumber = 0;
       while (index < length) {
         const code = this.#json.charCodeAt(index);
         if (char0 > code || code > char9) {
@@ -99,7 +110,7 @@ export class HeapSnapshotLoader {
       if (!this.#array) {
         throw new Error('Array not instantiated');
       }
-      this.#array.setValue(this.#arrayIndex++, nextNumber);
+      this.#array.setValue(this.#arrayIndex++, negative ? -nextNumber : nextNumber);
     }
   }
 
@@ -170,7 +181,7 @@ export class HeapSnapshotLoader {
     this.#array = length === undefined ? Platform.TypedArrayUtilities.createExpandableBigUint32Array() :
                                          Platform.TypedArrayUtilities.createFixedBigUint32Array(length);
     this.#arrayIndex = 0;
-    while (this.#parseUintArray()) {
+    while (this.#parseIntArray()) {
       if (length) {
         this.#progress.updateProgress(title, this.#arrayIndex, this.#array.length);
       } else {

package/front_end/entrypoints/inspector_main/nodeIcon.css

@@ -8,7 +8,7 @@
   width: var(--sys-size-12);
   height: 26px;
   /* stylelint-disable-next-line custom-property-pattern */
-  background-image: var(--image-file-nodeIcon);
+  background-image: var(--image-file-nodejsHex);
   background-size: 17px 17px;
   background-repeat: no-repeat;
   background-position: center;

package/front_end/foundation/Universe.ts

@@ -21,6 +21,7 @@ import * as LiveMetrics from '../models/live-metrics/live-metrics.js';
 import * as Logs from '../models/logs/logs.js';
 import * as Persistence from '../models/persistence/persistence.js';
 import * as ProjectSettings from '../models/project_settings/project_settings.js';
+import * as SourceMapScopes from '../models/source_map_scopes/source_map_scopes.js';
 import * as Workspace from '../models/workspace/workspace.js';
 import * as WorkspaceDiff from '../models/workspace_diff/workspace_diff.js';
 
@@ -160,6 +161,10 @@ export class Universe {
         resourceMapping, targetManager, ignoreListManager, workspace);
     context.set(Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding, debuggerWorkspaceBinding);
 
+    const scopeChainResolver =
+        new SourceMapScopes.ScopeChainResolver.ScopeChainResolver(targetManager, debuggerWorkspaceBinding);
+    context.set(SourceMapScopes.ScopeChainResolver.ScopeChainResolver, scopeChainResolver);
+
     const presentationConsoleMessageManager =
         new Bindings.PresentationConsoleMessageHelper.PresentationConsoleMessageManager(
             targetManager, workspace, debuggerWorkspaceBinding, cssWorkspaceBinding);
@@ -383,6 +388,10 @@ export class Universe {
                                           null;
   }
 
+  get scopeChainResolver(): SourceMapScopes.ScopeChainResolver.ScopeChainResolver {
+    return this.context.get(SourceMapScopes.ScopeChainResolver.ScopeChainResolver);
+  }
+
   get settings(): Common.Settings.Settings {
     return this.context.get(Common.Settings.Settings);
   }