chrome-devtools-frontend 1.0.1697595 → 1.0.1698733

package/front_end/core/sdk/SourceMapScopeChainEntry.ts

@@ -27,6 +27,10 @@ const UIStrings = {
    * @description Title of a section in the debugger showing JavaScript variables from the global scope.
    */
   global: 'Global',
+  /**
+   * @description Text in Scope Chain section of the Sources panel.
+   */
+  exception: 'Exception',
   /**
    * @description Text in Scope Chain section of the Sources panel.
    */
@@ -60,12 +64,18 @@ export class SourceMapScopeChainEntry implements ScopeChainEntry {
   }
 
   extraProperties(): RemoteObjectProperty[] {
+    const extraProperties = [];
+    if (this.#isInnerMostFunction && this.#callFrame.exception) {
+      extraProperties.push(new RemoteObjectProperty(i18nString(UIStrings.exception), this.#callFrame.exception,
+                                                    undefined, undefined, undefined, undefined, undefined,
+                                                    /* synthetic */ true));
+    }
     if (this.#returnValue) {
-      return [new RemoteObjectProperty(
+      extraProperties.push(new RemoteObjectProperty(
           i18nString(UIStrings.returnValue), this.#returnValue, undefined, undefined, undefined, undefined, undefined,
-          /* synthetic */ true)];
+          /* synthetic */ true, this.#callFrame.setReturnValue.bind(this.#callFrame)));
     }
-    return [];
+    return extraProperties;
   }
 
   callFrame(): CallFrame {
@@ -144,23 +154,55 @@ class SourceMapScopeRemoteObject extends RemoteObjectImpl {
       return {properties: [], internalProperties: []};
     }
 
-    const properties: RemoteObjectProperty[] = [];
-    for (const [index, variable] of this.#scope.variables.entries()) {
-      const expression = this.#findExpression(index);
-      if (expression === null) {
-        properties.push(SourceMapScopeRemoteObject.#unavailableProperty(variable));
-        continue;
+    if (this.#scope.variables.length === 0) {
+      return {properties: [], internalProperties: []};
+    }
+
+    const expressions = this.#scope.variables.map((_, index) => this.#findExpression(index));
+
+    if (expressions.every(expr => expr === null)) {
+      const properties = this.#scope.variables.map(v => SourceMapScopeRemoteObject.#unavailableProperty(v));
+      return {properties, internalProperties: []};
+    }
+
+    const spreadEntries: string[] = [];
+    for (const [index, expr] of expressions.entries()) {
+      if (expr !== null) {
+        spreadEntries.push(`...(() => { try { return {${index}: eval(${JSON.stringify(expr)})}; } catch {} })()`);
       }
+    }
+
+    const batchExpression = `({ __proto__: null, ${spreadEntries.join(', ')} })`;
+    const result = await this.#callFrame.evaluate({
+      expression: batchExpression,
+      generatePreview: false,
+      scopeNumber: this.#scopeNumber,
+    });
+
+    if ('error' in result || result.exceptionDetails || !result.object) {
+      const properties = this.#scope.variables.map(v => SourceMapScopeRemoteObject.#unavailableProperty(v));
+      return {properties, internalProperties: []};
+    }
+
+    const {properties: objectProperties} = await result.object.getOwnProperties(generatePreview);
+    result.object.release();
 
-      const result = await this.#callFrame.evaluate({expression, generatePreview, scopeNumber: this.#scopeNumber});
-      if ('error' in result || result.exceptionDetails) {
-        // TODO(crbug.com/40277685): Make these errors user-visible to aid tooling developers.
-        //         E.g. show the error on hover or expose it in the developer resources panel.
+    const propertyMap = new Map<string, RemoteObjectProperty>();
+    if (objectProperties) {
+      for (const prop of objectProperties) {
+        propertyMap.set(prop.name, prop);
+      }
+    }
+
+    const properties: RemoteObjectProperty[] = [];
+    for (const [index, variable] of this.#scope.variables.entries()) {
+      const prop = propertyMap.get(String(index));
+      if (!prop || !prop.value) {
         properties.push(SourceMapScopeRemoteObject.#unavailableProperty(variable));
       } else {
-        properties.push(new RemoteObjectProperty(
-            variable, result.object, /* enumerable */ false, /* writable */ false, /* isOwn */ true,
-            /* wasThrown */ false));
+        properties.push(new RemoteObjectProperty(variable, prop.value, /* enumerable */ false, /* writable */ false,
+                                                 /* isOwn */ true,
+                                                 /* wasThrown */ false));
       }
     }
 
@@ -177,7 +219,7 @@ class SourceMapScopeRemoteObject extends RemoteObjectImpl {
     if (typeof expressionOrSubRanges === 'string') {
       return expressionOrSubRanges;
     }
-    if (expressionOrSubRanges === null) {
+    if (expressionOrSubRanges === null || expressionOrSubRanges === undefined) {
       return null;
     }
 

package/front_end/core/sdk/SourceMapScopesInfo.ts

@@ -355,9 +355,10 @@ export class SourceMapScopesInfo {
     //         w.r.t. each other.
 
     let seenFunctionScope = false;
-    const result: SourceMapScopeChainEntry[] = [];
+    const result: ScopeChainEntry[] = [];
     // Walk the original scope chain outwards and try to find the corresponding generated range along the way.
-    for (let originalScope = rangeChain.at(-1)?.originalScope; originalScope; originalScope = originalScope.parent) {
+    for (let originalScope: ScopesCodec.OriginalScope|null|undefined = innerMostOriginalScope; originalScope;
+         originalScope = originalScope.parent) {
       const range = rangeChain.findLast(r => r.originalScope === originalScope);
       // `kind` is just a label for scope UI views and has no semantic significance, so `isStackFrame`
       // decides whether this scope is a function scope.
@@ -370,6 +371,11 @@ export class SourceMapScopesInfo {
       seenFunctionScope ||= isFunctionScope;
     }
 
+    const globalScope = callFrame.scopeChain()?.find(s => s.type() === Protocol.Debugger.ScopeType.Global);
+    if (globalScope) {
+      result.push(globalScope);
+    }
+
     // If we are paused on a return statement, we need to drop inner block scopes. This is because V8 only emits a
     // single return bytecode and "gotos" at the functions' end, where we are now paused.
     if (callFrame.returnValue() !== null) {