chrome-devtools-frontend 1.0.1642899 → 1.0.1643855

package/front_end/models/bindings/DebuggerWorkspaceBinding.ts

@@ -24,7 +24,6 @@ import {
   isErrorLike,
   type SymbolizedError,
   SymbolizedErrorObject,
-  SymbolizedSyntaxError,
   UnparsableError,
 } from './SymbolizedError.js';
 
@@ -238,14 +237,6 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
       ]);
       fetchedExceptionDetails = details;
       causeRemoteObject = causeRemote;
-
-      if (remoteObject.className === 'SyntaxError' && fetchedExceptionDetails) {
-        const syntaxError = await SymbolizedSyntaxError.fromExceptionDetails(
-            remoteObject.runtimeModel().target(), this, fetchedExceptionDetails);
-        if (syntaxError) {
-          return syntaxError;
-        }
-      }
     } else if (remoteObject.type === 'string') {
       errorStack = remoteObject.description || '';
       if (!isErrorLike(errorStack)) {
@@ -271,6 +262,12 @@ export class DebuggerWorkspaceBinding implements SDK.TargetManager.SDKModelObser
     }
 
     const message = StackTraceImpl.DetailedErrorStackParser.parseMessage(errorStack);
+
+    if (remoteObject.subtype === 'error' && remoteObject.className === 'SyntaxError' && fetchedExceptionDetails) {
+      return await SymbolizedErrorObject.createForSyntaxError(remoteObject.runtimeModel().target(), this, message,
+                                                              fetchedExceptionDetails, stackTrace, cause);
+    }
+
     return new SymbolizedErrorObject(message, stackTrace, cause);
   }
 

package/front_end/models/bindings/DefaultScriptMapping.ts

@@ -107,7 +107,8 @@ export class DefaultScriptMapping implements DebuggerSourceMapping {
     }
     this.#uiSourceCodeToScript.set(uiSourceCode, script);
     this.#scriptToUISourceCode.set(script, uiSourceCode);
-    this.#project.addUISourceCodeWithProvider(uiSourceCode, script, null, 'text/javascript');
+    const mimeType = script.isWasm() ? 'application/wasm' : 'text/javascript';
+    this.#project.addUISourceCodeWithProvider(uiSourceCode, script, null, mimeType);
     void this.#debuggerWorkspaceBinding.updateLocations(script);
   }
 

package/front_end/models/bindings/SymbolizedError.ts

@@ -15,7 +15,7 @@ export function isErrorLike(stack: string): boolean {
   return /\n\s*at\s/.test(stack) || stack.startsWith('SyntaxError:');
 }
 
-export type SymbolizedError = SymbolizedErrorObject|SymbolizedSyntaxError|UnparsableError;
+export type SymbolizedError = SymbolizedErrorObject|UnparsableError;
 
 export class UnparsableError extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
   readonly errorStack: string;
@@ -45,6 +45,7 @@ export class SymbolizedErrorObject extends Common.ObjectWrapper.ObjectWrapper<Ev
   readonly message: string;
   readonly stackTrace: StackTrace.StackTrace.ParsedErrorStackTrace;
   readonly cause: SymbolizedError|null;
+  #syntaxErrorLocation: Workspace.UISourceCode.UILocation|null = null;
 
   constructor(message: string, stackTrace: StackTrace.StackTrace.ParsedErrorStackTrace, cause: SymbolizedError|null) {
     super();
@@ -64,53 +65,62 @@ export class SymbolizedErrorObject extends Common.ObjectWrapper.ObjectWrapper<Ev
     }
   }
 
-  #fireUpdated(): void {
-    this.dispatchEventToListeners(Events.UPDATED);
-  }
-}
-
-export class SymbolizedSyntaxError extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
-  readonly message: string;
-  #uiLocation: Workspace.UISourceCode.UILocation|null = null;
-
-  constructor(message: string) {
-    super();
-    this.message = message;
+  get syntaxErrorLocation(): Workspace.UISourceCode.UILocation|null {
+    return this.#syntaxErrorLocation;
   }
 
-  get uiLocation(): Workspace.UISourceCode.UILocation|null {
-    return this.#uiLocation;
-  }
-
-  static async fromExceptionDetails(
-      target: SDK.Target.Target, debuggerWorkspaceBinding: DebuggerWorkspaceBinding,
-      exceptionDetails: Protocol.Runtime.ExceptionDetails): Promise<SymbolizedSyntaxError|null> {
+  /**
+   * Evaluates if we should populate the `syntaxErrorLocation` based on the provided exception details.
+   *
+   * There are three primary cases for SyntaxError:
+   * 1. Programmatic `SyntaxError`: Thrown via `throw new SyntaxError('...', {cause: ...})`. Has a full stack trace,
+   *    and an optional cause. The exception details point to the `throw` statement, which is identical to the top frame.
+   *    We do NOT want to populate `syntaxErrorLocation` here to avoid redundant location rendering in the UI.
+   * 2. Script parse failure: Failed to parse a script. Has no stack trace but possesses a compile-time location.
+   *    We DO want to populate `syntaxErrorLocation` to highlight where the parse failed.
+   * 3. `eval` parse failure: Failed to parse an eval string. Has a stack trace pointing to the `eval` call site
+   *    and a compile-time location of the parse failure within the string. The exception details location differs
+   *    from the top frame. We DO want to populate `syntaxErrorLocation` here.
+   */
+  static async createForSyntaxError(target: SDK.Target.Target, debuggerWorkspaceBinding: DebuggerWorkspaceBinding,
+                                    message: string, exceptionDetails: Protocol.Runtime.ExceptionDetails,
+                                    stackTrace: StackTrace.StackTrace.ParsedErrorStackTrace,
+                                    cause: SymbolizedError|null): Promise<SymbolizedErrorObject> {
     const {exception, scriptId, lineNumber, columnNumber} = exceptionDetails;
     if (!exception || exception.subtype !== 'error' || exception.className !== 'SyntaxError') {
-      throw new Error('SymbolizedSyntaxError.fromExceptionDetails expects a SyntaxError');
+      throw new Error('SymbolizedErrorObject.createForSyntaxError expects a SyntaxError');
     }
+
+    const symbolizedError = new SymbolizedErrorObject(message, stackTrace, cause);
+
     if (!scriptId) {
-      return null;
+      return symbolizedError;
     }
 
-    const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
-    if (!debuggerModel) {
-      return null;
+    const topFrame = exceptionDetails.stackTrace?.callFrames[0];
+    const isProgrammaticThrow = topFrame && topFrame.scriptId === scriptId && topFrame.lineNumber === lineNumber &&
+        topFrame.columnNumber === columnNumber;
+
+    if (!isProgrammaticThrow) {
+      const debuggerModel = target.model(SDK.DebuggerModel.DebuggerModel);
+      if (debuggerModel) {
+        const rawLocation = debuggerModel.createRawLocationByScriptId(scriptId, lineNumber, columnNumber);
+        // We don't implement dispose here. We won't create many of these so a couple
+        // LiveLocationPools and SymbolizedErrorObject instances leaking is fine.
+        await debuggerWorkspaceBinding.createLiveLocation(
+            rawLocation, symbolizedError.#updateSyntaxErrorLocation.bind(symbolizedError), new LiveLocationPool());
+      }
     }
 
-    const rawLocation = debuggerModel.createRawLocationByScriptId(scriptId, lineNumber, columnNumber);
-    const symbolizedSyntaxError = new SymbolizedSyntaxError(exception.description || '');
-
-    // We don't implement dispose here. We won't create many of these so a couple
-    // LiveLocationPools and SymbolizedSyntaxError instances leaking is fine.
-    await debuggerWorkspaceBinding.createLiveLocation(
-        rawLocation, symbolizedSyntaxError.#update.bind(symbolizedSyntaxError), new LiveLocationPool());
+    return symbolizedError;
+  }
 
-    return symbolizedSyntaxError;
+  async #updateSyntaxErrorLocation(liveLocation: LiveLocation): Promise<void> {
+    this.#syntaxErrorLocation = await liveLocation.uiLocation();
+    this.dispatchEventToListeners(Events.UPDATED);
   }
 
-  async #update(liveLocation: LiveLocation): Promise<void> {
-    this.#uiLocation = await liveLocation.uiLocation();
+  #fireUpdated(): void {
     this.dispatchEventToListeners(Events.UPDATED);
   }
 }

package/front_end/models/extensions/ExtensionAPI.ts

@@ -1067,6 +1067,46 @@ self.injectedExtensionAPI = function(
     return typeof lastArgument === 'function' ? lastArgument as (...args: unknown[]) => unknown : undefined;
   }
 
+  /**
+   * Helper to support both callback and Promise-based APIs.
+   *
+   * @param args The arguments object of the calling function.
+   * @returns An object containing either the `callback` function, or the
+   *    `promise` and its `resolve`/`reject` functions.
+   */
+  function callbackOrPromise<ResolveT, CallbackArgsT extends unknown[] = [ResolveT]>(args: IArguments): {
+    callback?: (...args: CallbackArgsT) => void,
+    promise?: Promise<ResolveT>,
+    resolve?: (value: ResolveT) => void,
+    reject?: (error: unknown) => void,
+  } {
+    const callback = extractCallbackArgument(args);
+    if (callback) {
+      return {callback: callback as (...args: CallbackArgsT) => void};
+    }
+    const {promise, resolve, reject} = Promise.withResolvers<ResolveT>();
+    return {promise, resolve, reject};
+  }
+
+  /**
+   * Checks if the `response` from the ExtensionServer indicates an error. If an
+   * error occurred and a `Promise` `reject` function is provided, this function
+   * will reject the promise with a generic 'DevTools API encountered an error' Error.
+   *
+   * @param response The response object from the ExtensionServer.
+   * @param reject The promise reject function, if applicable.
+   * @returns `true` if an error occurred and the promise was rejected, `false`
+   *    otherwise.
+   */
+  function checkErrorAndReject(response: unknown, reject?: (error: Error) => void): boolean {
+    const res = response as {isError?: boolean, description?: string, details?: unknown[]};
+    if (res.isError && reject) {
+      reject(new Error('DevTools API encountered an error'));
+      return true;
+    }
+    return false;
+  }
+
   const LanguageServicesAPI = declareInterfaceClass(LanguageServicesAPIImpl);
   const RecorderServicesAPI = declareInterfaceClass(RecorderServicesAPIImpl);
   const Performance = declareInterfaceClass(PerformanceImpl);
@@ -1247,43 +1287,68 @@ self.injectedExtensionAPI = function(
       extensionServer.sendRequest({command: PrivateAPI.Commands.Reload, options});
     },
 
-    eval: function(
-              expression: string,
-              evaluateOptions: {scriptExecutionContext?: string, frameURL?: string, useContentScriptContext?: boolean}):
-              Object |
-        null {
-          const callback = extractCallbackArgument(arguments);
+    eval: function<E = unknown>(this: PublicAPI.Chrome.DevTools.InspectedWindow, expression: string,
+                                optionsOrCallback?: unknown,
+                                _callback?: (result: unknown, exceptionInfo: object) => void): Promise<E>|
+        void {
+          const options = (typeof optionsOrCallback === 'object' && optionsOrCallback !== null) ?
+              optionsOrCallback as PrivateAPI.EvaluateOptions :
+              undefined;
+
+          const {callback: callbackArg, promise, resolve, reject} = callbackOrPromise<E, [unknown, object?]>(arguments);
+
           function callbackWrapper(result: unknown): void {
-            const {isError, isException, value} = result as {
-              value: unknown,
+            if (checkErrorAndReject(result, reject)) {
+              return;
+            }
+
+            const res = result as {
+              value?: unknown,
               isError?: boolean,
               isException?: boolean,
             };
-            if (isError || isException) {
-              callback?.(undefined, result);
+
+            if (res.isException) {
+              reject?.(res);
+            } else {
+              resolve?.(res.value as E);
+            }
+
+            if (res.isError || res.isException) {
+              callbackArg?.(undefined, res);
             } else {
-              callback?.(value);
+              callbackArg?.(res.value);
             }
           }
           extensionServer.sendRequest(
-              {
-                command: PrivateAPI.Commands.EvaluateOnInspectedPage,
-                expression,
-                evaluateOptions: (typeof evaluateOptions === 'object' ? evaluateOptions : undefined),
-              },
-              callback && callbackWrapper);
-          return null;
-        },
+              {command: PrivateAPI.Commands.EvaluateOnInspectedPage, expression, evaluateOptions: options},
+              callbackWrapper);
 
-    getResources: function(callback?: (resources: PublicAPI.Chrome.DevTools.Resource[]) => unknown): void {
-      function wrapResource(resourceData: APIImpl.ResourceData): APIImpl.Resource {
-        return new (Constructor(Resource))(resourceData);
-      }
-      function callbackWrapper(resources: unknown): void {
-        callback?.((resources as APIImpl.ResourceData[]).map(wrapResource));
-      }
-      extensionServer.sendRequest({command: PrivateAPI.Commands.GetPageResources}, callback && callbackWrapper);
-    },
+          return promise;
+        } as PublicAPI.Chrome.DevTools.InspectedWindow['eval'],
+
+    getResources: function(this: PublicAPI.Chrome.DevTools.InspectedWindow,
+                           _callback?: (resources: PublicAPI.Chrome.DevTools.Resource[]) => void):
+                      Promise<PublicAPI.Chrome.DevTools.Resource[]>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} =
+              callbackOrPromise<PublicAPI.Chrome.DevTools.Resource[]>(arguments);
+
+          function callbackWrapper(response: unknown): void {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+
+            const wrappedResources =
+                ((response || []) as APIImpl.ResourceData[]).map(r => new (Constructor(Resource))(r));
+            resolve?.(wrappedResources);
+            callbackArg?.(wrappedResources);
+          }
+
+          extensionServer.sendRequest({command: PrivateAPI.Commands.GetPageResources}, callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.InspectedWindow['getResources'],
   };
 
   function ResourceImpl(this: APIImpl.Resource, resourceData: APIImpl.ResourceData): void {
@@ -1292,9 +1357,9 @@ self.injectedExtensionAPI = function(
     this._buildId = resourceData.buildId;
   }
 
-  (ResourceImpl.prototype as Pick<
-       APIImpl.Resource,
-       'url'|'type'|'buildId'|'getContent'|'setContent'|'setFunctionRangesForScript'|'attachSourceMapURL'>) = {
+  (ResourceImpl.prototype as
+   Pick<APIImpl.Resource,
+        'url'|'type'|'buildId'|'getContent'|'setContent'|'setFunctionRangesForScript'|'attachSourceMapURL'>) = {
     get url(): string {
       return (this as APIImpl.Resource)._url;
     },
@@ -1307,25 +1372,51 @@ self.injectedExtensionAPI = function(
       return (this as APIImpl.Resource)._buildId;
     },
 
-    getContent: function(this: APIImpl.Resource, callback?: (content: string, encoding: string) => unknown): void {
-      function callbackWrapper(response: unknown): void {
-        const {content, encoding} = response as {content: string, encoding: string};
-        callback?.(content, encoding);
-      }
+    getContent: function(this: APIImpl.Resource, _callback?: (content: string, encoding: string) => void): Promise<{
+                  content: string, encoding: string,
+                }>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} =
+              callbackOrPromise<{content: string, encoding: string}, [string, string]>(arguments);
 
-      extensionServer.sendRequest(
-          {command: PrivateAPI.Commands.GetResourceContent, url: this._url}, callback && callbackWrapper);
-    },
+          function callbackWrapper(response: unknown): void {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
 
-    setContent: function(
-        this: APIImpl.Resource, content: string, commit: boolean, callback: (error?: Object) => unknown): void {
-      extensionServer.sendRequest(
-          {command: PrivateAPI.Commands.SetResourceContent, url: this._url, content, commit},
-          callback as (response: unknown) => unknown);
-    },
+            const {content, encoding} = response as {content: string, encoding: string};
+            resolve?.({content, encoding});
+            callbackArg?.(content, encoding);
+          }
+
+          extensionServer.sendRequest({command: PrivateAPI.Commands.GetResourceContent, url: this._url},
+                                      callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.Resource['getContent'],
+
+    setContent: function(this: APIImpl.Resource, content: string, commit: boolean,
+                         _callback?: (status?: object) => void): Promise<void>|
+        void {
+          const {callback: callbackArg, promise, resolve, reject} = callbackOrPromise<void, [object]>(arguments);
+
+          function callbackWrapper(response: unknown): void {
+            if (checkErrorAndReject(response, reject)) {
+              return;
+            }
+
+            resolve?.();
+            callbackArg?.(response as object);
+          }
+
+          extensionServer.sendRequest(
+              {command: PrivateAPI.Commands.SetResourceContent, url: this._url, content, commit}, callbackWrapper);
+
+          return promise;
+        } as PublicAPI.Chrome.DevTools.Resource['setContent'],
 
-    setFunctionRangesForScript: function(
-        this: APIImpl.Resource, ranges: PublicAPI.Chrome.DevTools.NamedFunctionRange[]): Promise<void> {
+    setFunctionRangesForScript: function(this: APIImpl.Resource,
+                                         ranges: PublicAPI.Chrome.DevTools.NamedFunctionRange[]): Promise<void> {
       return new Promise(
           (resolve, reject) => extensionServer.sendRequest(
               {

package/front_end/models/har/Importer.ts

@@ -40,6 +40,7 @@ export class Importer {
       }
       const request = SDK.NetworkRequest.NetworkRequest.createWithoutBackendRequest(
           'har-' + requests.length, entry.request.url, documentURL, initiator);
+      request.setIsImportedHar(true);
       const page = pageref ? pages.get(pageref) : undefined;
       if (!pageLoad && pageref && page) {
         pageLoad = Importer.buildPageLoad(page, request);

package/front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -244,8 +244,6 @@ export class HeapSnapshotLoaderProxy extends HeapSnapshotProxyObject implements
     const snapshotProxy = await this.callFactoryMethodPromise('buildSnapshot', HeapSnapshotProxy, [channel.port1]);
     secondWorker.dispose();
     this.dispose();
-    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
-    // @ts-expect-error
     snapshotProxy.setProfileUid(this.profileUid);
     await snapshotProxy.updateStaticData();
     this.snapshotReceivedCallback(snapshotProxy);
@@ -254,7 +252,7 @@ export class HeapSnapshotLoaderProxy extends HeapSnapshotProxyObject implements
 
 export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
   staticData: HeapSnapshotModel.StaticData|null;
-  profileUid?: string;
+  profileUid?: number;
 
   constructor(worker: HeapSnapshotWorkerProxy, objectId: number) {
     super(worker, objectId);
@@ -279,7 +277,7 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
   }
 
   calculateSnapshotDiff(
-      baseSnapshotId: string,
+      baseSnapshotId: number,
       baseSnapshotAggregates: Record<string, HeapSnapshotModel.AggregateForDiff>,
       ): Promise<Record<string, HeapSnapshotModel.Diff>> {
     return this.callMethodPromise('calculateSnapshotDiff', baseSnapshotId, baseSnapshotAggregates);
@@ -301,7 +299,7 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callFactoryMethod('createRetainingEdgesProvider', HeapSnapshotProviderProxy, nodeIndex);
   }
 
-  createAddedNodesProvider(baseSnapshotId: string, classKey: string): HeapSnapshotProviderProxy {
+  createAddedNodesProvider(baseSnapshotId: number, classKey: string): HeapSnapshotProviderProxy {
     return this.callFactoryMethod('createAddedNodesProvider', HeapSnapshotProviderProxy, baseSnapshotId, classKey);
   }
 
@@ -391,11 +389,11 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.staticData.totalSize;
   }
 
-  get uid(): string|undefined {
+  get uid(): number|undefined {
     return this.profileUid;
   }
 
-  setProfileUid(profileUid: string): void {
+  setProfileUid(profileUid: number): void {
     this.profileUid = profileUid;
   }
 

package/front_end/models/source_map_scopes/FunctionCodeResolver.ts

@@ -203,7 +203,14 @@ function createFunctionCode(
 }
 
 /**
- * The input location may be a source mapped location or a raw location.
+ * Resolves the function code and its surrounding context for a given location.
+ *
+ * The input location (line, column) may be either an authored (source-mapped)
+ * location or a raw location. The function will attempt to resolve it to a
+ * raw location regardless. This is necessary because callers (such as AI
+ * assistance) may work with either format.
+ *
+ * We filter projects by `target` to prevent cross-origin leaks.
  */
 export async function getFunctionCodeFromLocation(
     target: SDK.Target.Target, url: Platform.DevToolsPath.UrlString, line: number, column: number,
@@ -213,10 +220,13 @@ export async function getFunctionCodeFromLocation(
     throw new Error('missing debugger model');
   }
 
-  let uiSourceCode;
+  let uiSourceCode: Workspace.UISourceCode.UISourceCode|null = null;
   const debuggerWorkspaceBinding = Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance();
   const projects = debuggerWorkspaceBinding.workspace.projectsForType(Workspace.Workspace.projectTypes.Network);
   for (const project of projects) {
+    if (Bindings.NetworkProject.NetworkProject.getTargetForProject(project) !== target) {
+      continue;
+    }
     uiSourceCode = project.uiSourceCodeForURL(url);
     if (uiSourceCode) {
       break;

package/front_end/models/stack_trace/DetailedErrorStackParser.ts

@@ -62,57 +62,56 @@ export function parseRawFramesFromErrorStack(stack: string): RawFrame[]|null {
     let evalOrigin: RawFrame|undefined;
 
     const openParenIndex = lineContent.indexOf(' (');
+    let location = '';
     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];
-        }
+      location = lineContent.substring(openParenIndex + 2, lineContent.length - 1);
+    } else {
+      location = lineContent;
+    }
+
+    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 (location.startsWith('index ')) {
-        promiseIndex = parseInt(location.substring(6), 10);
-        url = '';
-      } else if (location === '<anonymous>' || location === 'native') {
-        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);
-        }
+      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 {
-        const splitResult = Common.ParsedURL.ParsedURL.splitLineAndColumn(location);
-        url = splitResult.url;
-        lineNumber = splitResult.lineNumber ?? -1;
-        columnNumber = splitResult.columnNumber ?? -1;
+        evalOrigin = parseRawFramesFromErrorStack(`    at ${evalFunctionName}`)?.[0];
       }
-    } else {
-      const splitResult = Common.ParsedURL.ParsedURL.splitLineAndColumn(lineContent);
+    }
+
+    if (location.startsWith('index ')) {
+      promiseIndex = parseInt(location.substring(6), 10);
+      url = '';
+    } else if (location === '<anonymous>' || location === 'native') {
+      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);
+        lineNumber = 0;
+      }
+    } else if (location) {
+      const splitResult = Common.ParsedURL.ParsedURL.splitLineAndColumn(location);
       url = splitResult.url;
       lineNumber = splitResult.lineNumber ?? -1;
       columnNumber = splitResult.columnNumber ?? -1;
@@ -181,13 +180,7 @@ export function parseMessage(stack: string): string {
 export function augmentRawFramesWithScriptIds(
     rawFrames: RawFrame[], protocolStackTrace: Protocol.Runtime.StackTrace): void {
   function augmentFrame(rawFrame: RawFrame): void {
-    const isWasm = rawFrame.isWasm;
     const protocolFrame = protocolStackTrace.callFrames.find(frame => {
-      if (isWasm) {
-        // The parser parses Wasm offsets into the `columnNumber` field. The `lineNumber` is always -1.
-        // In the protocol trace, the `lineNumber` is 0 (for Wasm) and `columnNumber` is the bytecode offset.
-        return rawFrame.url === frame.url && rawFrame.columnNumber === frame.columnNumber;
-      }
       return rawFrame.url === frame.url && rawFrame.lineNumber === frame.lineNumber &&
           rawFrame.columnNumber === frame.columnNumber;
     });

package/front_end/models/stack_trace/StackTrace.ts

@@ -48,6 +48,13 @@ export interface Frame {
    * Whether the corresponding raw frame is JS or WASM.
    */
   readonly isWasm?: boolean;
+  /**
+   * Whether this frame is an inlined frame. Used by SymbolizedErrorWidget
+   * to render the translated name (i.e. `name`) for inlined frames, and
+   * the physical name (i.e. `rawName`) for normal frames to preserve existing
+   * behavior.
+   */
+  readonly isInline?: boolean;
 }
 
 export interface ParsedErrorStackFrame extends Frame {

package/front_end/models/stack_trace/StackTraceImpl.ts

@@ -89,11 +89,12 @@ export class FrameImpl implements StackTrace.StackTrace.Frame {
   readonly missingDebugInfo?: StackTrace.StackTrace.MissingDebugInfo;
   readonly rawName?: string;
   readonly isWasm?: boolean;
+  readonly isInline?: boolean;
 
-  constructor(
-      url: string|undefined, uiSourceCode: Workspace.UISourceCode.UISourceCode|undefined, name: string|undefined,
-      line: number, column: number, missingDebugInfo?: StackTrace.StackTrace.MissingDebugInfo, rawName?: string,
-      isWasm?: boolean) {
+  constructor(url: string|undefined, uiSourceCode: Workspace.UISourceCode.UISourceCode|undefined,
+              name: string|undefined, line: number, column: number,
+              missingDebugInfo?: StackTrace.StackTrace.MissingDebugInfo, rawName?: string, isWasm?: boolean,
+              isInline?: boolean) {
     this.url = url;
     this.uiSourceCode = uiSourceCode;
     this.name = name;
@@ -102,6 +103,7 @@ export class FrameImpl implements StackTrace.StackTrace.Frame {
     this.missingDebugInfo = missingDebugInfo;
     this.rawName = rawName;
     this.isWasm = isWasm;
+    this.isInline = isInline;
   }
 }
 
@@ -197,6 +199,9 @@ export class ParsedErrorStackFrameImpl implements StackTrace.StackTrace.ParsedEr
   get isWasm(): boolean|undefined {
     return this.#frame.isWasm;
   }
+  get isInline(): boolean|undefined {
+    return this.#frame.isInline;
+  }
   get wasmModuleName(): string|undefined {
     return this.#parsedFrameInfo?.wasmModuleName;
   }
@@ -291,6 +296,10 @@ export class DebuggableFrameImpl implements StackTrace.StackTrace.DebuggableFram
     return this.#frame.isWasm;
   }
 
+  get isInline(): boolean|undefined {
+    return this.#frame.isInline;
+  }
+
   get sdkFrame(): SDK.DebuggerModel.CallFrame {
     return this.#sdkFrame;
   }