[stack_trace]: Implement Error.stack parsing for V8 strings

This CL re-implements Error.stack parsing. Compared to the existing
parser, we produce a fully structured frame instead of a prefix, link
info and suffix.

The advantage is twofold:
  * We disentangle the Error.stack format a bit more from the UI.
  * We can source map the "eval origin" now as well.

Follow-up changes will wire-up the parsing to the trie and the
StackTraceModel.

R=pfaffe@chromium.org

Bug: 485142682
Change-Id: Iff98b82a27ae3ddd1256d5c8e5a50aecae350b2a
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/7754102
Reviewed-by: Philip Pfaffe <pfaffe@chromium.org>
Commit-Queue: Simon Zünd <szuend@chromium.org>

Author: szuend

config/gni/devtools_grd_files.gni

@@ -1234,6 +1234,7 @@ grd_files_unbundled_sources = [
   "front_end/models/source_map_scopes/FunctionCodeResolver.js",
   "front_end/models/source_map_scopes/NamesResolver.js",
   "front_end/models/source_map_scopes/ScopeChainModel.js",
+  "front_end/models/stack_trace/DetailedErrorStackParser.js",
   "front_end/models/stack_trace/ErrorStackParser.js",
   "front_end/models/stack_trace/StackTrace.js",
   "front_end/models/stack_trace/StackTraceImpl.js",

front_end/models/stack_trace/BUILD.gn

@@ -30,6 +30,7 @@ devtools_entrypoint("bundle") {
 
 devtools_foundation_module("stack_trace_impl") {
   sources = [
+    "DetailedErrorStackParser.ts",
     "StackTraceImpl.ts",
     "StackTraceModel.ts",
     "Trie.ts",
@@ -62,6 +63,7 @@ devtools_foundation_module("unittests") {
   testonly = true
 
   sources = [
+    "DetailedErrorStackParser.test.ts",
     "ErrorStackParser.test.ts",
     "StackTrace.test.ts",
     "StackTraceImpl.test.ts",

front_end/models/stack_trace/DetailedErrorStackParser.test.ts

@@ -0,0 +1,194 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// eslint-disable-next-line @devtools/es-modules-import
+import * as StackTraceImpl from './stack_trace_impl.js';
+
+describe('DetailedErrorStackParser', () => {
+  describe('parseRawFramesFromErrorStack', () => {
+    it('parses standard V8 stack frames', () => {
+      const stack = `Error: foo
+          at functionName (http://www.example.org/script.js:10:5)
+          at Class.methodName (http://www.example.org/script.js:20:1)
+          at new Constructor (http://www.example.org/script.js:30:1)
+          at async asyncFunction (http://www.example.org/script.js:40:1)
+          at http://www.example.org/script.js:50:1`;
+      const frames = StackTraceImpl.DetailedErrorStackParser.parseRawFramesFromErrorStack(stack);
+
+      assert.lengthOf(frames, 5);
+      assert.deepEqual(frames[0], {
+        url: 'http://www.example.org/script.js',
+        functionName: 'functionName',
+        lineNumber: 9,
+        columnNumber: 4,
+        parsedFrameInfo: {
+          isAsync: false,
+          isConstructor: false,
+          isEval: false,
+          isWasm: false,
+          wasmModuleName: undefined,
+          wasmFunctionIndex: undefined,
+          typeName: undefined,
+          methodName: undefined,
+          promiseIndex: undefined,
+          evalOrigin: undefined,
+        },
+      });
+      assert.deepEqual(frames[1], {
+        url: 'http://www.example.org/script.js',
+        functionName: 'Class.methodName',
+        lineNumber: 19,
+        columnNumber: 0,
+        parsedFrameInfo: {
+          isAsync: false,
+          isConstructor: false,
+          isEval: false,
+          isWasm: false,
+          wasmModuleName: undefined,
+          wasmFunctionIndex: undefined,
+          typeName: 'Class',
+          methodName: 'methodName',
+          promiseIndex: undefined,
+          evalOrigin: undefined,
+        },
+      });
+      assert.deepEqual(frames[2], {
+        url: 'http://www.example.org/script.js',
+        functionName: 'Constructor',
+        lineNumber: 29,
+        columnNumber: 0,
+        parsedFrameInfo: {
+          isAsync: false,
+          isConstructor: true,
+          isEval: false,
+          isWasm: false,
+          wasmModuleName: undefined,
+          wasmFunctionIndex: undefined,
+          typeName: undefined,
+          methodName: undefined,
+          promiseIndex: undefined,
+          evalOrigin: undefined,
+        },
+      });
+      assert.deepEqual(frames[3], {
+        url: 'http://www.example.org/script.js',
+        functionName: 'asyncFunction',
+        lineNumber: 39,
+        columnNumber: 0,
+        parsedFrameInfo: {
+          isAsync: true,
+          isConstructor: false,
+          isEval: false,
+          isWasm: false,
+          wasmModuleName: undefined,
+          wasmFunctionIndex: undefined,
+          typeName: undefined,
+          methodName: undefined,
+          promiseIndex: undefined,
+          evalOrigin: undefined,
+        },
+      });
+      assert.deepEqual(frames[4], {
+        url: 'http://www.example.org/script.js',
+        functionName: '',
+        lineNumber: 49,
+        columnNumber: 0,
+        parsedFrameInfo: {
+          isAsync: false,
+          isConstructor: false,
+          isEval: false,
+          isWasm: false,
+          wasmModuleName: undefined,
+          wasmFunctionIndex: undefined,
+          typeName: undefined,
+          methodName: undefined,
+          promiseIndex: undefined,
+          evalOrigin: undefined,
+        },
+      });
+    });
+
+    it('parses eval frames', () => {
+      const stack = `Error: foo
+          at eval (eval at <anonymous> (http://www.example.org/script.js:10:5), <anonymous>:1:1)`;
+      const frames = StackTraceImpl.DetailedErrorStackParser.parseRawFramesFromErrorStack(stack);
+
+      assert.lengthOf(frames, 1);
+      assert.isTrue(frames[0].parsedFrameInfo?.isEval);
+      assert.strictEqual(frames[0].url, '<anonymous>');
+      assert.strictEqual(frames[0].lineNumber, 0);
+      assert.strictEqual(frames[0].columnNumber, 0);
+
+      assert.exists(frames[0].parsedFrameInfo?.evalOrigin);
+      assert.strictEqual(frames[0].parsedFrameInfo?.evalOrigin?.url, 'http://www.example.org/script.js');
+      assert.strictEqual(frames[0].parsedFrameInfo?.evalOrigin?.lineNumber, 9);
+      assert.strictEqual(frames[0].parsedFrameInfo?.evalOrigin?.columnNumber, 4);
+      assert.strictEqual(frames[0].parsedFrameInfo?.evalOrigin?.functionName, '<anonymous>');
+    });
+
+    it('parses deeply nested eval frames with actual function names', () => {
+      const stack = `Error: foo
+          at innerEval (eval at outerEval (eval at topEval (http://www.example.org/script.js:10:5)), <anonymous>:1:1)`;
+      const frames = StackTraceImpl.DetailedErrorStackParser.parseRawFramesFromErrorStack(stack);
+
+      assert.lengthOf(frames, 1);
+      assert.isTrue(frames[0].parsedFrameInfo?.isEval);
+      assert.strictEqual(frames[0].url, '<anonymous>');
+      assert.strictEqual(frames[0].lineNumber, 0);
+      assert.strictEqual(frames[0].columnNumber, 0);
+
+      // Level 1: outerEval
+      const outerEvalOrigin = frames[0].parsedFrameInfo?.evalOrigin;
+      assert.exists(outerEvalOrigin);
+      assert.isTrue(outerEvalOrigin?.parsedFrameInfo?.isEval);
+      assert.strictEqual(outerEvalOrigin?.functionName, 'outerEval');
+      assert.strictEqual(outerEvalOrigin?.url, '');  // no <anonymous> suffix
+      assert.strictEqual(outerEvalOrigin?.lineNumber, -1);
+      assert.strictEqual(outerEvalOrigin?.columnNumber, -1);
+
+      // Level 2: topEval
+      const topEvalOrigin = outerEvalOrigin?.parsedFrameInfo?.evalOrigin;
+      assert.exists(topEvalOrigin);
+      assert.isFalse(topEvalOrigin?.parsedFrameInfo?.isEval);
+      assert.strictEqual(topEvalOrigin?.functionName, 'topEval');
+      assert.strictEqual(topEvalOrigin?.url, 'http://www.example.org/script.js');
+      assert.strictEqual(topEvalOrigin?.lineNumber, 9);
+      assert.strictEqual(topEvalOrigin?.columnNumber, 4);
+    });
+
+    it('parses aliased method calls', () => {
+      const stack = `Error: foo
+          at Type.method [as alias] (http://www.example.org/script.js:10:5)`;
+      const frames = StackTraceImpl.DetailedErrorStackParser.parseRawFramesFromErrorStack(stack);
+
+      assert.lengthOf(frames, 1);
+      assert.strictEqual(frames[0].parsedFrameInfo?.typeName, 'Type');
+      assert.strictEqual(frames[0].parsedFrameInfo?.methodName, 'alias');
+    });
+
+    it('parses wasm frames', () => {
+      const stack = `Error: foo
+          at wasmModule.wasmFunc (http://www.example.org/script.js:wasm-function[123]:0xabc)`;
+      const frames = StackTraceImpl.DetailedErrorStackParser.parseRawFramesFromErrorStack(stack);
+
+      assert.lengthOf(frames, 1);
+      assert.isTrue(frames[0].parsedFrameInfo?.isWasm);
+      assert.strictEqual(frames[0].url, 'http://www.example.org/script.js');
+      assert.strictEqual(frames[0].parsedFrameInfo?.wasmModuleName, 'wasmModule');
+      assert.strictEqual(frames[0].parsedFrameInfo?.wasmFunctionIndex, 123);
+      assert.strictEqual(frames[0].columnNumber, 0xabc);
+    });
+
+    it('parses promise.all index', () => {
+      const stack = `Error: foo
+          at Promise.all (index 2)`;
+      const frames = StackTraceImpl.DetailedErrorStackParser.parseRawFramesFromErrorStack(stack);
+
+      assert.lengthOf(frames, 1);
+      assert.strictEqual(frames[0].parsedFrameInfo?.promiseIndex, 2);
+      assert.strictEqual(frames[0].url, '');
+      assert.strictEqual(frames[0].functionName, 'Promise.all');
+    });
+  });
+});

front_end/models/stack_trace/DetailedErrorStackParser.ts

@@ -0,0 +1,142 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
+
+import type {RawFrame} from './Trie.js';
+
+/**
+ * Takes a V8 Error#stack string and extracts structured information.
+ */
+export function parseRawFramesFromErrorStack(stack: string): RawFrame[] {
+  const lines = stack.split('\n');
+  const rawFrames: RawFrame[] = [];
+  for (const line of lines) {
+    const match = /^\s*at\s+(.*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+
+    let lineContent = match[1];
+    let isAsync = false;
+    if (lineContent.startsWith('async ')) {
+      isAsync = true;
+      lineContent = lineContent.substring(6);
+    }
+
+    let isConstructor = false;
+    if (lineContent.startsWith('new ')) {
+      isConstructor = true;
+      lineContent = lineContent.substring(4);
+    }
+
+    let functionName = '';
+    let url = '';
+    let lineNumber = -1;
+    let columnNumber = -1;
+    let typeName: string|undefined;
+    let methodName: string|undefined;
+    let isEval = false;
+    let isWasm = false;
+    let wasmModuleName: string|undefined;
+    let wasmFunctionIndex: number|undefined;
+    let promiseIndex: number|undefined;
+    let evalOrigin: RawFrame|undefined;
+
+    const openParenIndex = lineContent.indexOf(' (');
+    if (lineContent.endsWith(')') && openParenIndex !== -1) {
+      functionName = lineContent.substring(0, openParenIndex).trim();
+      let location = lineContent.substring(openParenIndex + 2, lineContent.length - 1);
+
+      if (location.startsWith('eval at ')) {
+        isEval = true;
+        const commaIndex = location.lastIndexOf(', ');
+        let evalOriginStr = location;
+        if (commaIndex !== -1) {
+          evalOriginStr = location.substring(0, commaIndex);
+          location = location.substring(commaIndex + 2);
+        } else {
+          location = '';
+        }
+
+        if (evalOriginStr.startsWith('eval at ')) {
+          evalOriginStr = evalOriginStr.substring(8);
+        }
+        const innerOpenParen = evalOriginStr.indexOf(' (');
+        let evalFunctionName = evalOriginStr;
+        let evalLocation = '';
+        if (innerOpenParen !== -1) {
+          evalFunctionName = evalOriginStr.substring(0, innerOpenParen).trim();
+          evalLocation = evalOriginStr.substring(innerOpenParen + 2, evalOriginStr.length - 1);
+          evalOrigin = parseRawFramesFromErrorStack(`    at ${evalFunctionName} (${evalLocation})`)[0];
+        } else {
+          evalOrigin = parseRawFramesFromErrorStack(`    at ${evalFunctionName}`)[0];
+        }
+      }
+
+      if (location.startsWith('index ')) {
+        promiseIndex = parseInt(location.substring(6), 10);
+        url = '';
+      } else if (location.includes(':wasm-function[')) {
+        isWasm = true;
+        const wasmMatch = /^(.*):wasm-function\[(\d+)\]:(0x[0-9a-fA-F]+)$/.exec(location);
+        if (wasmMatch) {
+          url = wasmMatch[1];
+          wasmFunctionIndex = parseInt(wasmMatch[2], 10);
+          columnNumber = parseInt(wasmMatch[3], 16);
+        }
+      } else {
+        const splitResult = Common.ParsedURL.ParsedURL.splitLineAndColumn(location);
+        url = splitResult.url;
+        lineNumber = splitResult.lineNumber ?? -1;
+        columnNumber = splitResult.columnNumber ?? -1;
+      }
+    } else {
+      const splitResult = Common.ParsedURL.ParsedURL.splitLineAndColumn(lineContent);
+      url = splitResult.url;
+      lineNumber = splitResult.lineNumber ?? -1;
+      columnNumber = splitResult.columnNumber ?? -1;
+    }
+
+    // Handle "typeName.methodName [as alias]"
+    if (functionName) {
+      const aliasMatch = /(.*)\s+\[as\s+(.*)\]/.exec(functionName);
+      if (aliasMatch) {
+        methodName = aliasMatch[2];
+        functionName = aliasMatch[1];
+      }
+
+      const dotIndex = functionName.indexOf('.');
+      if (dotIndex !== -1) {
+        typeName = functionName.substring(0, dotIndex);
+        methodName = methodName ?? functionName.substring(dotIndex + 1);
+      }
+
+      if (isWasm && typeName) {
+        wasmModuleName = typeName;
+      }
+    }
+
+    rawFrames.push({
+      url: url as Platform.DevToolsPath.UrlString,
+      functionName,
+      lineNumber,
+      columnNumber,
+      parsedFrameInfo: {
+        isAsync,
+        isConstructor,
+        isEval,
+        evalOrigin,
+        isWasm,
+        wasmModuleName,
+        wasmFunctionIndex,
+        typeName,
+        methodName,
+        promiseIndex,
+      },
+    });
+  }
+  return rawFrames;
+}

front_end/models/stack_trace/stack_trace_impl.ts

@@ -2,11 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as DetailedErrorStackParser from './DetailedErrorStackParser.js';
 import * as StackTraceImpl from './StackTraceImpl.js';
 import * as StackTraceModel from './StackTraceModel.js';
 import * as Trie from './Trie.js';
 
 export {
+  DetailedErrorStackParser,
   StackTraceImpl,
   StackTraceModel,
   Trie,