feat: allow pointing to a node source file to execute

Fixes #291. Involves some churn since I wanted to avoid having to run the
breakpoint predictor twice:

- The path resolver is now created by a separate, session-level factory, rather
  than each target. This is needed since the path resolver is used in the
  predictor, which is used before we launch Node or have any targets.
- The initialize params/client capabilities are now in IOC. Cleans up a
  decent amount of code.
- Then with these changes, using the breakpoint predictor in the Node launcher
  to look up the compiled path is quite simple :P

Author: connor4312

demos/extension/.vscode/launch.json

@@ -0,0 +1,17 @@
+// A launch configuration that compiles the extension and then opens it inside a new window
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Launch Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "runtimeExecutable": "${execPath}",
+      "args": ["--extensionDevelopmentPath=${workspaceRoot}"],
+      "stopOnEntry": false,
+      "sourceMaps": true,
+      "outFiles": ["${workspaceRoot}/out/src/**/*.js"],
+      "preLaunchTask": "npm: watch"
+    }
+  ]
+}

demos/extension/.vscode/tasks.json

@@ -0,0 +1,13 @@
+{
+  // See https://go.microsoft.com/fwlink/?LinkId=733558
+  // for the documentation about the tasks.json format
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "npm",
+      "script": "watch",
+      "problemMatcher": ["$tsc-watch"],
+      "isBackground": true
+    }
+  ]
+}

src/adapter/breakpointPredictor.ts

@@ -41,6 +41,11 @@ export const IBreakpointsPredictor = Symbol('IBreakpointsPredictor');
  * by looking at source maps on disk.
  */
 export interface IBreakpointsPredictor {
+  /**
+   * Gets prediction data for the given source file path, if it exists.
+   */
+  getPredictionForSource(sourceFile: string): Promise<ReadonlySet<DiscoveredMetadata> | undefined>;
+
   /**
    * Returns a promise that resolves once maps in the root are predicted.
    */
@@ -240,6 +245,17 @@ export class BreakpointsPredictor implements IBreakpointsPredictor {
     }
   }
 
+  /**
+   * @inheritdoc
+   */
+  public async getPredictionForSource(sourcePath: string) {
+    if (!this.sourcePathToCompiled) {
+      this.sourcePathToCompiled = this.createInitialMapping();
+    }
+
+    return (await this.sourcePathToCompiled).get(sourcePath);
+  }
+
   /**
    * Returns predicted breakpoint locations for the provided source.
    */

src/binder.ts

@@ -33,7 +33,7 @@ import * as os from 'os';
 import { delay } from './common/promiseUtil';
 import { Container } from 'inversify';
 import { createTargetContainer, provideLaunchParams } from './ioc';
-import { disposeContainer } from './ioc-extras';
+import { disposeContainer, IInitializeParams } from './ioc-extras';
 
 const localize = nls.loadMessageBundle();
 
@@ -51,16 +51,15 @@ export class Binder implements IDisposable {
   private _delegate: IBinderDelegate;
   private _disposables: IDisposable[];
   private _threads = new Map<ITarget, { thread: Thread; debugAdapter: DebugAdapter }>();
-  private _launchers = new Set<ILauncher>();
   private _terminationCount = 0;
   private _onTargetListChangedEmitter = new EventEmitter<void>();
   readonly onTargetListChanged = this._onTargetListChangedEmitter.event;
   private _dap: Promise<Dap.Api>;
   private _targetOrigin: ITargetOrigin;
   private _launchParams?: AnyLaunchConfiguration;
-  private _clientCapabilities: Dap.InitializeParams | undefined;
   private _asyncStackPolicy?: IAsyncStackPolicy;
   private _serviceTree = new WeakMap<ITarget, Container>();
+  private _launchers?: ReadonlySet<ILauncher>;
 
   constructor(
     delegate: IBinderDelegate,
@@ -69,7 +68,6 @@ export class Binder implements IDisposable {
     private readonly _rootServices: Container,
     targetOrigin: ITargetOrigin,
   ) {
-    this._launchers = new Set(_rootServices.getAll(ILauncher));
     this._delegate = delegate;
     this._dap = connection.dap();
     this._targetOrigin = targetOrigin;
@@ -79,23 +77,9 @@ export class Binder implements IDisposable {
       installUnhandledErrorReporter(_rootServices.get(ILogger), telemetryReporter),
     ];
 
-    for (const launcher of this._launchers) {
-      this._launchers.add(launcher);
-      launcher.onTargetListChanged(
-        () => {
-          const targets = this.targetList();
-          this._attachToNewTargets(targets, launcher);
-          this._detachOrphanThreads(targets);
-          this._onTargetListChangedEmitter.fire();
-        },
-        undefined,
-        this._disposables,
-      );
-    }
-
     this._dap.then(dap => {
       dap.on('initialize', async clientCapabilities => {
-        this._clientCapabilities = clientCapabilities;
+        this._rootServices.bind(IInitializeParams).toConstantValue(clientCapabilities);
         const capabilities = DebugAdapter.capabilities();
         if (clientCapabilities.clientID === 'vscode') {
           filterErrorsReportedToTelemetry();
@@ -141,8 +125,29 @@ export class Binder implements IDisposable {
     });
   }
 
+  private getLaunchers() {
+    if (!this._launchers) {
+      this._launchers = new Set(this._rootServices.getAll(ILauncher));
+
+      for (const launcher of this._launchers) {
+        launcher.onTargetListChanged(
+          () => {
+            const targets = this.targetList();
+            this._attachToNewTargets(targets, launcher);
+            this._detachOrphanThreads(targets);
+            this._onTargetListChangedEmitter.fire();
+          },
+          undefined,
+          this._disposables,
+        );
+      }
+    }
+
+    return this._launchers;
+  }
+
   private async _disconnect() {
-    await Promise.all([...this._launchers].map(l => l.disconnect()));
+    await Promise.all([...this.getLaunchers()].map(l => l.disconnect()));
 
     const didTerminate = () => !this.targetList.length && this._terminationCount === 0;
     if (didTerminate()) {
@@ -174,7 +179,7 @@ export class Binder implements IDisposable {
     if (params.rootPath) params.rootPath = urlUtils.platformPathToPreferredCase(params.rootPath);
     this._launchParams = params;
     let results = await Promise.all(
-      [...this._launchers].map(l => this._launch(l, params, cts.token)),
+      [...this.getLaunchers()].map(l => this._launch(l, params, cts.token)),
     );
     results = results.filter(result => !!result);
     if (results.length) return errors.createUserError(results.join('\n'));
@@ -217,7 +222,7 @@ export class Binder implements IDisposable {
   }
 
   async _restart() {
-    await Promise.all([...this._launchers].map(l => l.restart()));
+    await Promise.all([...this.getLaunchers()].map(l => l.restart()));
   }
 
   async _launch(
@@ -263,16 +268,12 @@ export class Binder implements IDisposable {
 
     let result: ILaunchResult;
     try {
-      result = await launcher.launch(
-        params,
-        {
-          telemetryReporter: this.telemetryReporter,
-          cancellationToken,
-          targetOrigin: this._targetOrigin,
-          dap: await this._dap,
-        },
-        this._clientCapabilities!,
-      );
+      result = await launcher.launch(params, {
+        telemetryReporter: this.telemetryReporter,
+        cancellationToken,
+        targetOrigin: this._targetOrigin,
+        dap: await this._dap,
+      });
     } catch (e) {
       if (e instanceof TaskCancelledError) {
         result = {
@@ -310,15 +311,16 @@ export class Binder implements IDisposable {
   dispose() {
     for (const disposable of this._disposables) disposable.dispose();
     this._disposables = [];
-    for (const launcher of this._launchers) launcher.dispose();
-    this._launchers.clear();
     disposeContainer(this._rootServices);
     this._detachOrphanThreads([]);
   }
 
   targetList(): ITarget[] {
     const result: ITarget[] = [];
-    for (const delegate of this._launchers) result.push(...delegate.targetList());
+    for (const delegate of this.getLaunchers()) {
+      result.push(...delegate.targetList());
+    }
+
     return result;
   }
 

src/ioc-extras.ts

@@ -11,6 +11,11 @@ import { promises as fsPromises } from 'fs';
  */
 export const StoragePath = Symbol('StoragePath');
 
+/**
+ * Key for the Dap.InitializeParams.
+ */
+export const IInitializeParams = Symbol('IInitializeParams');
+
 /**
  * Key for whether vs code services are available here.
  */

src/ioc.ts

@@ -56,6 +56,7 @@ import { IDebugConfigurationProvider } from './ui/configuration/configurationPro
 import execa from 'execa';
 import { promises as fsPromises } from 'fs';
 import { RemoteBrowserLauncher } from './targets/browser/remoteBrowserLauncher';
+import { SourcePathResolverFactory } from './targets/sourcePathResolverFactory';
 
 /**
  * Contains IOC container factories for the extension. We use Inverisfy, which
@@ -95,14 +96,6 @@ export const createTargetContainer = (
     .to(ScriptSkipper)
     .inSingletonScope();
 
-  // first/parent target
-  if (!parent.isBound(ITarget)) {
-    container
-      .bind(IBreakpointsPredictor)
-      .to(BreakpointsPredictor)
-      .inSingletonScope();
-  }
-
   return container;
 };
 
@@ -132,6 +125,11 @@ export const createTopLevelSessionContainer = (parent: Container) => {
     .inSingletonScope()
     .onActivation(trackDispose);
 
+  container
+    .bind(IBreakpointsPredictor)
+    .to(BreakpointsPredictor)
+    .inSingletonScope();
+
   container
     .bind(ISourceMapRepository)
     .toDynamicValue(ctx =>
@@ -273,5 +271,16 @@ export const createGlobalContainer = (options: {
   return container;
 };
 
-export const provideLaunchParams = (container: Container, params: AnyLaunchConfiguration) =>
+export const provideLaunchParams = (container: Container, params: AnyLaunchConfiguration) => {
   container.bind(AnyLaunchConfiguration).toConstantValue(params);
+
+  container
+    .bind(SourcePathResolverFactory)
+    .toSelf()
+    .inSingletonScope();
+
+  container
+    .bind(ISourcePathResolver)
+    .toDynamicValue(ctx => ctx.container.get(SourcePathResolverFactory).create())
+    .inSingletonScope();
+};

src/targets/browser/browserAttacher.ts

@@ -8,19 +8,17 @@ import * as launcher from './launcher';
 import * as nls from 'vscode-nls';
 import { BrowserTargetManager } from './browserTargets';
 import { ITarget, ILauncher, ILaunchResult, ILaunchContext, IStopMetadata } from '../targets';
-import { BrowserSourcePathResolver } from './browserPathResolver';
-import { baseURL } from './browserLaunchParams';
 import { AnyLaunchConfiguration, IChromeAttachConfiguration } from '../../configuration';
 import { DebugType } from '../../common/contributionUtils';
 import { TelemetryReporter } from '../../telemetry/telemetryReporter';
 import { createTargetFilterForConfig } from '../../common/urlUtils';
 import { delay } from '../../common/promiseUtil';
 import { CancellationToken } from 'vscode';
 import { NeverCancelled } from '../../common/cancellation';
-import { Dap } from '../../dap/api';
 import { ITargetOrigin } from '../targetOrigin';
 import { ILogger } from '../../common/logging';
 import { injectable, inject } from 'inversify';
+import { ISourcePathResolver } from '../../common/sourcePathResolver';
 
 const localize = nls.loadMessageBundle();
 
@@ -37,7 +35,10 @@ export class BrowserAttacher implements ILauncher {
   private _onTargetListChangedEmitter = new EventEmitter<void>();
   readonly onTargetListChanged = this._onTargetListChangedEmitter.event;
 
-  constructor(@inject(ILogger) private readonly logger: ILogger) {}
+  constructor(
+    @inject(ILogger) private readonly logger: ILogger,
+    @inject(ISourcePathResolver) private readonly pathResolver: ISourcePathResolver,
+  ) {}
 
   dispose() {
     for (const disposable of this._disposables) disposable.dispose();
@@ -49,7 +50,6 @@ export class BrowserAttacher implements ILauncher {
   async launch(
     params: AnyLaunchConfiguration,
     { targetOrigin, cancellationToken, telemetryReporter }: ILaunchContext,
-    clientCapabilities: Dap.InitializeParams,
   ): Promise<ILaunchResult> {
     if (params.type !== DebugType.Chrome || params.request !== 'attach') {
       return { blockSessionTermination: false };
@@ -58,27 +58,19 @@ export class BrowserAttacher implements ILauncher {
     this._launchParams = params;
     this._targetOrigin = targetOrigin;
 
-    const error = await this._attemptToAttach(
-      telemetryReporter,
-      clientCapabilities,
-      cancellationToken,
-    );
+    const error = await this._attemptToAttach(telemetryReporter, cancellationToken);
     return error ? { error } : { blockSessionTermination: false };
   }
 
-  _scheduleAttach(
-    rawTelemetryReporter: TelemetryReporter,
-    clientCapabilities: Dap.InitializeParams,
-  ) {
+  _scheduleAttach(rawTelemetryReporter: TelemetryReporter) {
     this._attemptTimer = setTimeout(() => {
       this._attemptTimer = undefined;
-      this._attemptToAttach(rawTelemetryReporter, clientCapabilities, NeverCancelled);
+      this._attemptToAttach(rawTelemetryReporter, NeverCancelled);
     }, 1000);
   }
 
   async _attemptToAttach(
     rawTelemetryReporter: TelemetryReporter,
-    clientCapabilities: Dap.InitializeParams,
     cancellationToken: CancellationToken,
   ) {
     const params = this._launchParams!;
@@ -101,29 +93,17 @@ export class BrowserAttacher implements ILauncher {
           this._onTargetListChangedEmitter.fire();
         }
         if (this._launchParams === params) {
-          this._scheduleAttach(rawTelemetryReporter, clientCapabilities);
+          this._scheduleAttach(rawTelemetryReporter);
         }
       },
       undefined,
       this._disposables,
     );
 
-    const pathResolver = new BrowserSourcePathResolver(
-      {
-        resolveSourceMapLocations: params.resolveSourceMapLocations,
-        baseUrl: baseURL(params),
-        localRoot: null,
-        remoteRoot: null,
-        pathMapping: { '/': params.webRoot, ...params.pathMapping },
-        sourceMapOverrides: params.sourceMapPathOverrides,
-        clientID: clientCapabilities.clientID,
-      },
-      this.logger,
-    );
     this._targetManager = await BrowserTargetManager.connect(
       connection,
       undefined,
-      pathResolver,
+      this.pathResolver,
       params,
       this.logger,
       rawTelemetryReporter,