feat: allow easy toggling between compiled and sourcemapped sources

Fixes microsoft/vscode#151412

Author: connor4312

CHANGELOG.md

@@ -7,6 +7,7 @@ This changelog records changes to stable releases since 1.50.2. "TBA" changes he
 - feat: simplify pretty print to align with devtools ([vscode#151410](https://github.com/microsoft/vscode/issues/151410))
 - feat: add a new **Debug: Save Diagnostic JS Debug Logs** command ([#1301](https://github.com/microsoft/vscode-js-debug/issues/1301))
 - feat: use custom `toString()` methods to generate object descriptions ([#1284](https://github.com/microsoft/vscode-js-debug/issues/1284))
+- feat: allow easy toggling between compiled and sourcemapped sources ([vscode#151412](https://github.com/microsoft/vscode/issues/151412))
 - fix: debugged child processes in ext host causing teardown ([#1289](https://github.com/microsoft/vscode-js-debug/issues/1289))
 - fix: errors thrown in process tree lookup not being visible ([vscode#150754](https://github.com/microsoft/vscode/issues/150754))
 - fix: extension debugging not working with two ipv6 interfaces ([vscode#144315](https://github.com/microsoft/vscode/issues/144315))

package-lock.json

@@ -144,6 +144,14 @@ export class BreakpointManager {
 
     _breakpointsPredictor?.onLongParse(() => dap.longPrediction({}));
 
+    sourceContainer.onSourceMappedSteppingChange(() => {
+      if (this._thread) {
+        for (const bp of this.allUserBreakpoints) {
+          bp.refreshUiLocations(this._thread);
+        }
+      }
+    });
+
     this._scriptSourceMapHandler = async (script, sources) => {
       if (
         !logger.assert(

src/adapter/breakpoints.ts

@@ -136,7 +136,7 @@ export abstract class Breakpoint {
 
   /**
    * Updates the source location for the breakpoint. It is assumed that the
-   * updated location is equivalent to the original on.  This is used to move
+   * updated location is equivalent to the original one.  This is used to move
    * the breakpoints when we pretty print a source. This is dangerous with
    * sharp edges, use with caution.
    */
@@ -156,6 +156,20 @@ export abstract class Breakpoint {
     );
   }
 
+  /**
+   * Refreshes the `uiLocations` of the breakpoint. Should be used when the
+   * resolution strategy for sources change.
+   */
+  public async refreshUiLocations(thread: Thread) {
+    await Promise.all(
+      this.cdpBreakpoints
+        .filter(
+          (bp): bp is IBreakpointCdpReferenceApplied => bp.state === CdpReferenceState.Applied,
+        )
+        .map(bp => this.updateUiLocations(thread, bp.cdpId, bp.locations)),
+    );
+  }
+
   /**
    * Sets the breakpoint in the provided thread and marks the "enabled" bit.
    */
@@ -201,7 +215,7 @@ export abstract class Breakpoint {
   public async updateUiLocations(
     thread: Thread,
     cdpId: Cdp.Debugger.BreakpointId,
-    resolvedLocations: Cdp.Debugger.Location[],
+    resolvedLocations: readonly Cdp.Debugger.Location[],
   ) {
     const uiLocation = (
       await Promise.all(
@@ -219,18 +233,18 @@ export abstract class Breakpoint {
     }
 
     this.updateCdpRefs(list =>
-      list.map(bp =>
-        bp.state === CdpReferenceState.Applied && bp.cdpId === cdpId
-          ? {
-              ...bp,
-              locations: resolvedLocations,
-              uiLocations: [
-                ...bp.uiLocations,
-                ...this._manager._sourceContainer.currentSiblingUiLocations(uiLocation, source),
-              ],
-            }
-          : bp,
-      ),
+      list.map(bp => {
+        if (bp.state !== CdpReferenceState.Applied || bp.cdpId !== cdpId) {
+          return bp;
+        }
+        const locations = this._manager._sourceContainer.currentSiblingUiLocations(uiLocation);
+        const inPreferredSource = locations.filter(l => l.source === source);
+        return {
+          ...bp,
+          locations: resolvedLocations,
+          uiLocations: inPreferredSource.length ? inPreferredSource : locations,
+        };
+      }),
     );
   }
 

src/adapter/breakpoints/breakpointBase.ts

@@ -116,6 +116,14 @@ export class DebugAdapter implements IDisposable {
     this.dap.on('requestCDPProxy', () => this._requestCDPProxy());
     this.dap.on('setExcludedCallers', params => this._onSetExcludedCallers(params));
     this.dap.on('saveDiagnosticLogs', ({ toFile }) => this._saveDiagnosticLogs(toFile));
+    this.dap.on('setSourceMapStepping', params => this._setSourceMapStepping(params));
+  }
+
+  private _setSourceMapStepping({
+    enabled,
+  }: Dap.SetSourceMapSteppingParams): Promise<Dap.SetSourceMapSteppingResult> {
+    this.sourceContainer.doSourceMappedStepping = enabled;
+    return Promise.resolve({});
   }
 
   private async _saveDiagnosticLogs(toFile: string): Promise<Dap.SaveDiagnosticLogsResult> {

src/adapter/debugAdapter.ts

@@ -465,6 +465,7 @@ export class SourceContainer {
    */
   private readonly scriptsById: Map<Cdp.Runtime.ScriptId, Script> = new Map();
 
+  private onSourceMappedSteppingChangeEmitter = new EventEmitter<boolean>();
   private onScriptEmitter = new EventEmitter<Script>();
   private _dap: Dap.Api;
   private _sourceByOriginalUrl: Map<string, Source> = new MapUsingProjection(s => s.toLowerCase());
@@ -513,6 +514,30 @@ export class SourceContainer {
     return this._statistics;
   }
 
+  private _doSourceMappedStepping = this.launchConfig.sourceMaps;
+
+  /**
+   * Gets whether source stepping is enabled.
+   */
+  public get doSourceMappedStepping() {
+    return this._doSourceMappedStepping;
+  }
+
+  /**
+   * Sets whether source stepping is enabled.
+   */
+  public set doSourceMappedStepping(enabled: boolean) {
+    if (enabled !== this._doSourceMappedStepping) {
+      this._doSourceMappedStepping = enabled;
+      this.onSourceMappedSteppingChangeEmitter.fire(enabled);
+    }
+  }
+
+  /**
+   * Fires whenever `doSourceMappedStepping` is changed.
+   */
+  public readonly onSourceMappedSteppingChange = this.onSourceMappedSteppingChangeEmitter.event;
+
   constructor(
     @inject(IDapApi) dap: Dap.Api,
     @inject(ISourceMapFactory) private readonly sourceMapFactory: ISourceMapFactory,
@@ -637,32 +662,34 @@ export class SourceContainer {
   public async preferredUiLocation(uiLocation: IUiLocation): Promise<IPreferredUiLocation> {
     let isMapped = false;
     let unmappedReason: UnmappedReason | undefined = UnmappedReason.CannotMap;
-    while (true) {
-      if (!isSourceWithMap(uiLocation.source)) {
-        break;
-      }
+    if (this._doSourceMappedStepping) {
+      while (true) {
+        if (!isSourceWithMap(uiLocation.source)) {
+          break;
+        }
 
-      const sourceMap = this._sourceMaps.get(uiLocation.source.sourceMap.url);
-      if (
-        !this.logger.assert(
-          sourceMap,
-          `Expected to have sourcemap for loaded source ${uiLocation.source.sourceMap.url}`,
-        )
-      ) {
-        break;
-      }
+        const sourceMap = this._sourceMaps.get(uiLocation.source.sourceMap.url);
+        if (
+          !this.logger.assert(
+            sourceMap,
+            `Expected to have sourcemap for loaded source ${uiLocation.source.sourceMap.url}`,
+          )
+        ) {
+          break;
+        }
 
-      await Promise.race([sourceMap.loaded, delay(this._sourceMapTimeouts.resolveLocation)]);
-      if (!sourceMap.map) return { ...uiLocation, isMapped, unmappedReason };
-      const sourceMapped = this._sourceMappedUiLocation(uiLocation, sourceMap.map);
-      if (!isUiLocation(sourceMapped)) {
-        unmappedReason = isMapped ? undefined : sourceMapped;
-        break;
-      }
+        await Promise.race([sourceMap.loaded, delay(this._sourceMapTimeouts.resolveLocation)]);
+        if (!sourceMap.map) return { ...uiLocation, isMapped, unmappedReason };
+        const sourceMapped = this._sourceMappedUiLocation(uiLocation, sourceMap.map);
+        if (!isUiLocation(sourceMapped)) {
+          unmappedReason = isMapped ? undefined : sourceMapped;
+          break;
+        }
 
-      uiLocation = sourceMapped;
-      isMapped = true;
-      unmappedReason = undefined;
+        uiLocation = sourceMapped;
+        isMapped = true;
+        unmappedReason = undefined;
+      }
     }
 
     return { ...uiLocation, isMapped, unmappedReason };
@@ -711,7 +738,7 @@ export class SourceContainer {
    * Returns all UI locations the given location maps to.
    */
   private getSourceMapUiLocations(uiLocation: IUiLocation): IUiLocation[] {
-    if (!isSourceWithMap(uiLocation.source)) return [];
+    if (!isSourceWithMap(uiLocation.source) || !this._doSourceMappedStepping) return [];
     const map = this._sourceMaps.get(uiLocation.source.sourceMap.url)?.map;
     if (!map) return [];
     const sourceMapUiLocation = this._sourceMappedUiLocation(uiLocation, map);