feat: support renamed sourcemap identifiers

Closes microsoft/vscode#12066

CHANGELOG.md

@@ -4,6 +4,8 @@ This changelog records changes to stable releases since 1.50.2. "TBA" changes he
 
 ## Nightly
 
+- feat: support renamed sourcemap identifiers ([ref](https://github.com/microsoft/vscode/issues/12066))
+- feat: support DAP `hitBreakpointIds` ([#994](https://github.com/microsoft/vscode-js-debug/issues/994))
 - refactor: include a mandator path in the CDP proxy ([#987](https://github.com/microsoft/vscode-js-debug/issues/987))
 - fix: make sure servers are listening before returning
 - fix: don't send infinite telemetry requests for React Native ([#981](https://github.com/microsoft/vscode-js-debug/issues/981))
@@ -12,7 +14,6 @@ This changelog records changes to stable releases since 1.50.2. "TBA" changes he
 - chore: log errors activating auto attach
 - fix: intermittent debug failures with browsers, especially Electron ([ref](https://github.com/microsoft/vscode/issues/123420)))
 - fix: add additional languages for browser debugging ([ref](https://github.com/microsoft/vscode/issues/123484))
-- feat: support DAP `hitBreakpointIds` ([#994](https://github.com/microsoft/vscode-js-debug/issues/994))
 - feat: allow limited adjustment of launch config options during restart ([ref](https://github.com/microsoft/vscode/issues/118196))
 
 ## v1.56 (April 2021)

demos/node/.vscode/launch.json

@@ -11,6 +11,13 @@
       "name": "[Node] Launch program",
       "program": "${workspaceFolder}/main.js",
     },
+    {
+      "type": "node",
+      "request": "launch",
+      "trace": true,
+      "name": "[Node] Launch Minified program",
+      "program": "${workspaceFolder}/main.min.js",
+    },
     {
       "name": "[Node] Launch File with Deno",
       "type": "pwa-node",

demos/node/package.json

@@ -1,5 +1,9 @@
 {
   "scripts": {
-    "start": "node main"
+    "start": "node main",
+    "minify": "terser main.js -m -o main.min.js --source-map \"url=main.min.js.map\" --toplevel"
+  },
+  "devDependencies": {
+    "terser": "^5.7.0"
   }
 }

src/adapter/completions.ts

@@ -9,8 +9,9 @@ import { Identifier, MemberExpression, Node, Program } from 'estree';
 import { inject, injectable } from 'inversify';
 import Cdp from '../cdp/api';
 import { ICdpApi } from '../cdp/connection';
+import { IPosition } from '../common/positions';
 import { getEnd, getStart, getText, parseProgram } from '../common/sourceCodeManipulations';
-import { positionToOffset } from '../common/sourceUtils';
+import { PositionToOffset } from '../common/stringUtils';
 import Dap from '../dap/api';
 import { IEvaluator, returnValueStr } from './evaluator';
 import { StackFrame } from './stackTrace';
@@ -30,8 +31,7 @@ export interface ICompletionContext {
  */
 export interface ICompletionExpression {
   expression: string;
-  line: number;
-  column: number;
+  position: IPosition;
 }
 
 export interface ICompletionWithSort extends Dap.CompletionItem {
@@ -141,8 +141,7 @@ export class Completions {
     options: ICompletionContext & ICompletionExpression,
   ): Promise<Dap.CompletionItem[]> {
     const source = parseProgram(options.expression);
-
-    const offset = positionToOffset(options.expression, options.line, options.column);
+    const offset = new PositionToOffset(options.expression).convert(options.position);
     let candidate: () => Promise<ICompletionWithSort[]> = () => Promise.resolve([]);
 
     traverse(source, {
@@ -310,6 +309,7 @@ export class Completions {
     const callFrameId = stackFrame && stackFrame.callFrameId();
     const objRefResult = await this.evaluator.evaluate(
       callFrameId ? { ...params, callFrameId } : { ...params, contextId: executionContextId },
+      { stackFrame },
     );
 
     if (!objRefResult || objRefResult.exceptionDetails) {

src/adapter/debugAdapter.ts

@@ -8,6 +8,7 @@ import { Cdp } from '../cdp/api';
 import { DisposableList, IDisposable } from '../common/disposable';
 import { ILogger, LogTag } from '../common/logging';
 import { getDeferred, IDeferred } from '../common/promiseUtil';
+import { IRenameProvider } from '../common/sourceMaps/renameProvider';
 import * as sourceUtils from '../common/sourceUtils';
 import * as urlUtils from '../common/urlUtils';
 import { AnyLaunchConfiguration } from '../configuration';
@@ -308,6 +309,7 @@ export class DebugAdapter implements IDisposable {
       cdp,
       this.dap,
       delegate,
+      this._services.get(IRenameProvider),
       this._services.get(ILogger),
       this._services.get(IEvaluator),
       this._services.get(ICompletions),

src/adapter/evaluator.ts

@@ -6,11 +6,14 @@ import { Node as AcornNode } from 'acorn';
 import { generate } from 'astring';
 import { randomBytes } from 'crypto';
 import { replace } from 'estraverse';
-import { ConditionalExpression } from 'estree';
+import { ConditionalExpression, Expression } from 'estree';
 import { inject, injectable } from 'inversify';
 import Cdp from '../cdp/api';
 import { ICdpApi } from '../cdp/connection';
+import { IPosition } from '../common/positions';
 import { parseProgram } from '../common/sourceCodeManipulations';
+import { IRenameProvider, RenameMapping } from '../common/sourceMaps/renameProvider';
+import { StackFrame } from './stackTrace';
 import { getSourceSuffix } from './templates';
 
 export const returnValueStr = '$returnValue';
@@ -97,14 +100,27 @@ export interface IPrepareOptions extends IEvaluatorBaseOptions {
    * given remote objects.
    */
   hoist?: ReadonlyArray<string>;
+
+  /**
+   * Optional information used to rename identifiers.
+   */
+  renames?: RenamePrepareOptions;
 }
 
+export type RenamePrepareOptions = { position: IPosition; mapping: RenameMapping };
+
 export interface IEvaluateOptions extends IEvaluatorBaseOptions {
   /**
    * Replaces the identifiers in the associated script with references to the
    * given remote objects.
    */
-  hoist?: { [key: string]: Cdp.Runtime.RemoteObject };
+  hoist?: ReadonlyArray<string>;
+
+  /**
+   * Stack frame object on which the evaluation is being run. This is
+   * necessary to allow for renamed properties.
+   */
+  stackFrame?: StackFrame;
 }
 
 /**
@@ -121,7 +137,10 @@ export class Evaluator implements IEvaluator {
     return !!this.returnValue;
   }
 
-  constructor(@inject(ICdpApi) private readonly cdp: Cdp.Api) {}
+  constructor(
+    @inject(ICdpApi) private readonly cdp: Cdp.Api,
+    @inject(IRenameProvider) private readonly renameProvider: IRenameProvider,
+  ) {}
 
   /**
    * @inheritdoc
@@ -135,9 +154,9 @@ export class Evaluator implements IEvaluator {
    */
   public prepare(
     expression: string,
-    options: IPrepareOptions = {},
+    { isInternalScript, hoist, renames }: IPrepareOptions = {},
   ): { canEvaluateDirectly: boolean; invoke: PreparedCallFrameExpr } {
-    if (options.isInternalScript !== false) {
+    if (isInternalScript !== false) {
       expression += getSourceSuffix();
     }
 
@@ -147,15 +166,16 @@ export class Evaluator implements IEvaluator {
     // evalute the expression and unhoist it from the globals.
     const toHoist = new Map<string, string>();
     toHoist.set(returnValueStr, makeHoistedName());
-    for (const key of options.hoist ?? []) {
+    for (const key of hoist ?? []) {
       toHoist.set(key, makeHoistedName());
     }
 
-    const { transformed, hoisted } = this.replaceVariableInExpression(expression, toHoist);
+    const { transformed, hoisted } = this.replaceVariableInExpression(expression, toHoist, renames);
     if (!hoisted.size) {
       return {
         canEvaluateDirectly: true,
-        invoke: params => this.cdp.Debugger.evaluateOnCallFrame({ ...params, expression }),
+        invoke: params =>
+          this.cdp.Debugger.evaluateOnCallFrame({ ...params, expression: transformed }),
       };
     }
 
@@ -178,18 +198,27 @@ export class Evaluator implements IEvaluator {
   ): Promise<Cdp.Debugger.EvaluateOnCallFrameResult>;
   public evaluate(
     params: Cdp.Runtime.EvaluateParams,
-    options?: IPrepareOptions,
+    options?: IEvaluateOptions,
   ): Promise<Cdp.Runtime.EvaluateResult>;
   public async evaluate(
     params: Cdp.Debugger.EvaluateOnCallFrameParams | Cdp.Runtime.EvaluateParams,
-    options?: IPrepareOptions,
+    options?: IEvaluateOptions,
   ) {
     // no call frame means there will not be any relevant $returnValue to reference
     if (!('callFrameId' in params)) {
       return this.cdp.Runtime.evaluate(params);
     }
 
-    return this.prepare(params.expression, options).invoke(params);
+    let prepareOptions: IPrepareOptions | undefined = options;
+    if (options?.stackFrame) {
+      const mapping = await this.renameProvider.provideOnStackframe(options.stackFrame);
+      prepareOptions = {
+        ...prepareOptions,
+        renames: { mapping, position: options.stackFrame.rawPosition },
+      };
+    }
+
+    return this.prepare(params.expression, prepareOptions).invoke(params);
   }
 
   /**
@@ -221,9 +250,12 @@ export class Evaluator implements IEvaluator {
   private replaceVariableInExpression(
     expr: string,
     hoistMap: Map<string /* identifier */, string /* hoised */>,
+    renames: RenamePrepareOptions | undefined,
   ): { hoisted: Set<string>; transformed: string } {
     const hoisted = new Set<string>();
-    const replacement = (name: string): ConditionalExpression => ({
+    let mutated = false;
+
+    const replacement = (name: string, fallback: Expression): ConditionalExpression => ({
       type: 'ConditionalExpression',
       test: {
         type: 'BinaryExpression',
@@ -237,30 +269,42 @@ export class Evaluator implements IEvaluator {
         right: { type: 'Literal', value: 'undefined' },
       },
       consequent: { type: 'Identifier', name },
-      alternate: {
-        type: 'Identifier',
-        name: 'undefined',
-      },
+      alternate: fallback,
     });
 
     const parents: Node[] = [];
     const transformed = replace(parseProgram(expr), {
-      enter: node => {
+      enter(node) {
         const asAcorn = node as AcornNode;
-        if (
-          node.type === 'Identifier' &&
-          hoistMap.has(node.name) &&
-          expr[asAcorn.start - 1] !== '.'
-        ) {
+        if (node.type !== 'Identifier' || expr[asAcorn.start - 1] === '.') {
+          return;
+        }
+
+        const hoistName = hoistMap.get(node.name);
+        if (hoistName) {
           hoisted.add(node.name);
-          return replacement(hoistMap.get(node.name) as string);
+          mutated = true;
+          this.skip();
+          return replacement(hoistName, undefinedExpression);
+        }
+
+        const cname = renames?.mapping.getCompiledName(node.name, renames.position);
+        if (cname) {
+          mutated = true;
+          this.skip();
+          return replacement(cname, node);
         }
       },
       leave: () => {
         parents.pop();
       },
     });
 
-    return { hoisted, transformed: hoisted.size ? generate(transformed) : expr };
+    return { hoisted, transformed: mutated ? generate(transformed) : expr };
   }
 }
+
+const undefinedExpression: Expression = {
+  type: 'Identifier',
+  name: 'undefined',
+};

src/adapter/stackTrace.ts

@@ -5,6 +5,7 @@
 import * as nls from 'vscode-nls';
 import Cdp from '../cdp/api';
 import { once } from '../common/objUtils';
+import { Base0Position } from '../common/positions';
 import Dap from '../dap/api';
 import { asyncScopesNotAvailable } from '../dap/errors';
 import { ProtocolError } from '../dap/protocolError';
@@ -181,6 +182,11 @@ export class StackFrame {
   private _scope: IScope | undefined;
   private _thread: Thread;
 
+  public get rawPosition() {
+    // todo: move RawLocation to use Positions, then just return that.
+    return new Base0Position(this._rawLocation.lineNumber, this._rawLocation.columnNumber);
+  }
+
   static fromRuntime(
     thread: Thread,
     callFrame: Cdp.Runtime.CallFrame,
@@ -376,7 +382,12 @@ export class StackFrame {
       return existing;
     }
 
-    const scopeRef: IScopeRef = { callFrameId: scope.callFrameId, scopeNumber };
+    const scopeRef: IScopeRef = {
+      stackFrame: this,
+      callFrameId: scope.callFrameId,
+      scopeNumber,
+    };
+
     const extraProperties: IExtraProperty[] = [];
     if (scopeNumber === 0) {
       extraProperties.push({ name: 'this', value: scope.thisObject });