Reconstruct structured stack traces from Error.stack strings

This CL adds a new 'createFromErrorStackLikeString' to StackTraceModel
that wires up the new Error.stack parser to the stack trace
machinery.

We also wire up translating of eval origin positions.

R=pfaffe@chromium.org

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

Author: szuend

front_end/models/stack_trace/StackTraceModel.test.ts

@@ -501,4 +501,100 @@ describe('StackTraceModel', () => {
       assert.strictEqual(stackTrace.syncFragment.frames[2].rawName, 'foo');
     });
   });
+
+  describe('createFromErrorStackLikeString', () => {
+    it('correctly handles a stack trace with sync and async fragments', async () => {
+      const {model} = setup();
+
+      const stackTrace = await model.createFromErrorStackLikeString(
+          `Error: foo
+              at foo (foo.js:1:10)
+              at bar (foo.js:2:20)`,
+          identityTranslateFn, {
+            exceptionId: 1,
+            text: 'Uncaught Error: foo',
+            lineNumber: 0,
+            columnNumber: 0,
+            stackTrace: {
+              callFrames: [
+                {
+                  functionName: 'foo',
+                  url: 'foo.js',
+                  scriptId: 'id1' as Protocol.Runtime.ScriptId,
+                  lineNumber: 0,
+                  columnNumber: 9,
+                },
+                {
+                  functionName: 'bar',
+                  url: 'foo.js',
+                  scriptId: 'id1' as Protocol.Runtime.ScriptId,
+                  lineNumber: 1,
+                  columnNumber: 19,
+                },
+              ],
+              parent: {
+                description: 'setTimeout',
+                callFrames: [
+                  {
+                    functionName: 'barFnX',
+                    url: 'bar.js',
+                    scriptId: 'id2' as Protocol.Runtime.ScriptId,
+                    lineNumber: 0,
+                    columnNumber: 9,
+                  },
+                ],
+              },
+            },
+          });
+
+      assert.strictEqual(stringifyStackTrace(stackTrace), [
+        'at foo (foo.js:0:9)',
+        'at bar (foo.js:1:19)',
+        '--- setTimeout -------------------------',
+        'at barFnX (bar.js:0:9)',
+      ].join('\n'));
+    });
+
+    it('correctly translates evalOrigin frames', async () => {
+      const {model} = setup();
+
+      const translateFn: StackTraceImpl.StackTraceModel.TranslateRawFrames = (frames, _target) => {
+        // Expand the evalOrigin into 2 frames to simulate inlining.
+        return Promise.resolve(frames.map(f => {
+          if (f.functionName === 'outerEval') {  // the evalOrigin frame
+            return [
+              {url: 'inlined.js', name: 'inlinedFn', line: 5, column: 5},
+              {url: f.url, name: f.functionName, line: f.lineNumber, column: f.columnNumber},
+            ];
+          }
+          return [{
+            url: f.url,
+            name: f.functionName,
+            line: f.lineNumber,
+            column: f.columnNumber,
+          }];
+        }));
+      };
+
+      const stackTrace = await model.createFromErrorStackLikeString(
+          `Error: foo
+              at eval (eval at outerEval (foo.js:10:5), <anonymous>:1:1)`,
+          translateFn);
+
+      const frames = stackTrace.syncFragment.frames as StackTrace.StackTrace.ParsedErrorStackFrame[];
+      assert.lengthOf(frames, 1);
+      assert.strictEqual(frames[0].url, '<anonymous>');
+      assert.strictEqual(frames[0].line, 0);
+
+      assert.exists(frames[0].evalOrigin);
+      // The evalOrigin is represented as a single ParsedErrorStackFrame that points to the top-most inlined frame
+      assert.strictEqual(frames[0].evalOrigin?.url, 'inlined.js');
+      assert.strictEqual(frames[0].evalOrigin?.name, 'inlinedFn');
+      assert.strictEqual(frames[0].evalOrigin?.line, 5);
+
+      // NOTE: Because evalOrigin only surfaces a single ParsedErrorStackFrame,
+      // the remaining inlined frames ('outerEval' at 'foo.js:10:5') are technically dropped in the public API!
+      // This is a known limitation of having evalOrigin as a single frame rather than an array.
+    });
+  });
 });

front_end/models/stack_trace/StackTraceModel.ts

@@ -6,6 +6,7 @@ import * as Common from '../../core/common/common.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 
+import {augmentRawFramesWithScriptIds, parseRawFramesFromErrorStack} from './DetailedErrorStackParser.js';
 // eslint-disable-next-line @devtools/es-modules-import
 import * as StackTrace from './stack_trace.js';
 import {
@@ -14,6 +15,7 @@ import {
   DebuggableFragmentImpl,
   FragmentImpl,
   FrameImpl,
+  ParsedErrorStackFragmentImpl,
   StackTraceImpl
 } from './StackTraceImpl.js';
 import {type FrameNode, type RawFrame, Trie} from './Trie.js';
@@ -54,6 +56,23 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
     return new StackTraceImpl(syncFragment, asyncFragments);
   }
 
+  async createFromErrorStackLikeString(
+      stack: string, rawFramesToUIFrames: TranslateRawFrames,
+      exceptionDetails?: Protocol.Runtime.ExceptionDetails): Promise<StackTrace.StackTrace.ParsedErrorStackTrace> {
+    const rawFrames = parseRawFramesFromErrorStack(stack);
+    if (exceptionDetails?.stackTrace) {
+      augmentRawFramesWithScriptIds(rawFrames, exceptionDetails.stackTrace);
+    }
+
+    const [syncFragment, asyncFragments] = await Promise.all([
+      this.#createFragment(rawFrames, rawFramesToUIFrames),
+      exceptionDetails?.stackTrace ? this.#createAsyncFragments(exceptionDetails.stackTrace, rawFramesToUIFrames) :
+                                     Promise.resolve([]),
+    ]);
+
+    return new StackTraceImpl(new ParsedErrorStackFragmentImpl(syncFragment), asyncFragments);
+  }
+
   async createFromDebuggerPaused(
       pausedDetails: SDK.DebuggerModel.DebuggerPausedDetails,
       rawFramesToUIFrames: TranslateRawFrames): Promise<StackTrace.StackTrace.DebuggableStackTrace> {
@@ -162,12 +181,32 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
     const uiFrames = await rawFramesToUIFrames(rawFrames, this.target());
     console.assert(rawFrames.length === uiFrames.length, 'Broken rawFramesToUIFrames implementation');
 
+    const evalOriginPromises: Array<ReturnType<TranslateRawFrames>> = [];
+    for (const node of fragment.node.getCallStack()) {
+      if (node.parsedFrameInfo?.evalOrigin) {
+        // Evaluate each eval origin individually, as they are not a contiguous stack trace.
+        evalOriginPromises.push(rawFramesToUIFrames([node.parsedFrameInfo.evalOrigin], this.target()));
+      }
+    }
+
+    const evalUiFrames = await Promise.all(evalOriginPromises);
+
     let i = 0;
+    let evalI = 0;
     for (const node of fragment.node.getCallStack()) {
       node.frames = uiFrames[i++].map(
           frame => new FrameImpl(
               frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo,
               node.rawFrame.functionName));
+
+      if (node.parsedFrameInfo?.evalOrigin) {
+        const evalOriginRawFrame = node.parsedFrameInfo.evalOrigin;
+        // evalUiFrames[evalI] is Array<Array<Frame>>, and since we passed a 1-element array, we take [0]
+        node.evalOriginFrames = evalUiFrames[evalI++][0].map(
+            frame => new FrameImpl(
+                frame.url, frame.uiSourceCode, frame.name, frame.line, frame.column, frame.missingDebugInfo,
+                evalOriginRawFrame.functionName));
+      }
     }
   }