Handle preLaunch task explicitly

src/debugger/configuration/resolvers/attach.ts

@@ -33,16 +33,19 @@ export class AttachResolver implements vscode.DebugConfigurationProvider {
         "Python",
     ];
 
-    public async resolveDebugConfiguration(folder: vscode.WorkspaceFolder | undefined, config: requests.IAttachRequest, token?: vscode.CancellationToken): Promise<vscode.DebugConfiguration> {
+    public async resolveDebugConfigurationWithSubstitutedVariables(folder: vscode.WorkspaceFolder | undefined, config: requests.IAttachRequest, token?: vscode.CancellationToken): Promise<vscode.DebugConfiguration> {
         // ${command:} variables only get resolved before passed to debug adapter, need to be manually resolve here
         // all ${action:} variables need to be resolved before our resolver propagates the configuration to actual debugger
+
         await this.resolveRuntimeIfNeeded(this.supportedRuntimeTypes, config);
         await this.resolveProcessIdIfNeeded(config);
         await this.resolveCommandLineIfNeeded(config);
 
         // propagate debug configuration to Python or C++ debugger depending on the chosen runtime type
         this.launchAttachSession(config as IResolvedAttachRequest);
-        return config;
+
+        // Return null as we have spawned new debug session
+        return null;
     }
 
     private async launchAttachSession(config: IResolvedAttachRequest) {
@@ -79,7 +82,7 @@ export class AttachResolver implements vscode.DebugConfigurationProvider {
                 if (os.platform() === "win32") {
                     const processOptions: child_process.ExecOptions = {
                         cwd: extension.baseDir,
-                        env: extension.env,
+                        env: await extension.resolvedEnv(),
                     };
 
                     // "ptvsd --pid" works with child_process.exec() on Windows

src/debugger/configuration/resolvers/launch.ts

@@ -14,6 +14,7 @@ import * as vscode from "vscode";
 
 import * as extension from "../../../extension";
 import * as requests from "../../requests";
+import * as utils from "../../utils";
 
 const promisifiedExec = util.promisify(child_process.exec);
 
@@ -27,13 +28,13 @@ interface ILaunchRequest {
 
 export class LaunchResolver implements vscode.DebugConfigurationProvider {
     // tslint:disable-next-line: max-line-length
-    public async resolveDebugConfiguration(folder: vscode.WorkspaceFolder | undefined, config: requests.ILaunchRequest, token?: vscode.CancellationToken) {
+    public async resolveDebugConfigurationWithSubstitutedVariables(folder: vscode.WorkspaceFolder | undefined, config: requests.ILaunchRequest, token?: vscode.CancellationToken) {
         if (!path.isAbsolute(config.target) || path.extname(config.target) !== ".launch") {
             throw new Error("Launch request requires an absolute path as target.");
         }
-
+        
         const rosExecOptions: child_process.ExecOptions = {
-            env: extension.env,
+            env: await extension.resolvedEnv(),
         };
 
         let result = await promisifiedExec(`roslaunch --dump-params ${config.target}`, rosExecOptions);
@@ -63,6 +64,7 @@ export class LaunchResolver implements vscode.DebugConfigurationProvider {
         } else if (result.stdout.length == 0) {
             throw (new Error(`roslaunch unexpectedly produced no output, please test by running \"roslaunch --dump-params ${config.target}\" in a ros terminal.`));
         }
+
         const nodes = result.stdout.trim().split(os.EOL);
         await Promise.all(nodes.map((node: string) => {
             return promisifiedExec(`roslaunch --args ${node} ${config.target}`, rosExecOptions);
@@ -73,9 +75,12 @@ export class LaunchResolver implements vscode.DebugConfigurationProvider {
             });
         });
         // @todo: error handling for Promise.all
-        return config;
+
+        // Return null as we have spawned new debug requests
+        return null;
     }
 
+
     private generateLaunchRequest(nodeName: string, command: string): ILaunchRequest {
         let parsedArgs: shell_quote.ParseEntry[];
         const isWindows = os.platform() === "win32";

src/debugger/manager.ts

@@ -23,11 +23,11 @@ class RosDebugManager implements vscode.DebugConfigurationProvider {
         return this.configProvider.provideDebugConfigurations(folder, token);
     }
 
-    public async resolveDebugConfiguration(folder: vscode.WorkspaceFolder | undefined, config: vscode.DebugConfiguration, token?: vscode.CancellationToken): Promise<vscode.DebugConfiguration> {
+    public async resolveDebugConfigurationWithSubstitutedVariables(folder: vscode.WorkspaceFolder | undefined, config: vscode.DebugConfiguration, token?: vscode.CancellationToken): Promise<vscode.DebugConfiguration> {
         if (config.request === "attach") {
-            return this.attachResolver.resolveDebugConfiguration(folder, config as requests.IAttachRequest, token);
+            return this.attachResolver.resolveDebugConfigurationWithSubstitutedVariables(folder, config as requests.IAttachRequest, token);
         } else if (config.request === "launch") {
-            return this.launchResolver.resolveDebugConfiguration(folder, config as requests.ILaunchRequest, token);
+            return this.launchResolver.resolveDebugConfigurationWithSubstitutedVariables(folder, config as requests.ILaunchRequest, token);
         }
     }
 }

src/debugger/utils.ts

@@ -2,10 +2,25 @@
 // Licensed under the MIT License.
 
 import * as vscode from "vscode";
+import * as util from "util";
 
 import * as extension from "../extension";
 import * as telemetry from "../telemetry-helper";
 
+export async function oneTimePromiseFromEvent(eventCall, filter = undefined) : Promise<any> {
+    return new Promise(resolve => {
+        let disposable: vscode.Disposable;
+        disposable = eventCall(event => {
+            if (filter && !filter(event)) {
+                return;
+            }
+
+            disposable.dispose();
+            resolve(event);
+        });
+    });
+}
+
 /**
  * Gets stringified settings to pass to the debug server.
  */

src/extension.ts

@@ -44,6 +44,13 @@ let onEnvChanged = new vscode.EventEmitter<void>();
  */
 export let onDidChangeEnv = onEnvChanged.event;
 
+export async function resolvedEnv() {
+    if (env === undefined) { // Env reload in progress
+        await debug_utils.oneTimePromiseFromEvent(onDidChangeEnv, () => env !== undefined);
+    }
+    return env
+}
+
 /**
  * Subscriptions to dispose when the environment is changed.
  */