handle outdated vs environment

Author: bobbrow

Extension/src/Debugger/configurationProvider.ts

@@ -15,6 +15,7 @@ import * as util from '../common';
 import { isWindows } from '../constants';
 import { expandAllStrings, ExpansionOptions, ExpansionVars } from '../expand';
 import { CppBuildTask, CppBuildTaskDefinition, cppBuildTaskProvider } from '../LanguageServer/cppBuildTaskProvider';
+import { canFindCl } from '../LanguageServer/devcmd';
 import { configPrefix } from '../LanguageServer/extension';
 import { CppSettings, OtherSettings } from '../LanguageServer/settings';
 import * as logger from '../logger';
@@ -590,20 +591,34 @@ export class DebugConfigurationProvider implements vscode.DebugConfigurationProv
      * `false` if the VS developer environment is available or the user chose to apply it.
      */
     private async showErrorIfClNotAvailable(_configurationLabel: string): Promise<boolean> {
-        if (util.hasMsvcEnvironment()) {
-            return false; // No error to show
+        const hasEnvironment = util.hasMsvcEnvironment();
+        if (hasEnvironment) {
+            if (await canFindCl()) {
+                return false; // No error to show
+            }
+            // The user has an environment but cl.exe cannot be found. Prompt the user to update the environment.
         }
 
-        const applyDevEnv = localize("apply.dev.env", "Apply Developer Environment");
-        const cancel = localize("cancel", "Cancel");
-        const response = await vscode.window.showErrorMessage(
-            localize({
+        const applyButton = localize("apply.dev.env", "Apply Developer Environment");
+        const applyMessage = localize(
+            {
                 key: "cl.exe.not.available",
                 comment: ["{0} is a command option in a menu."]
-            }, "{0} requires the Visual Studio developer environment.", `cl.exe ${this.buildAndDebugActiveFileStr()}`),
-            applyDevEnv,
+            },
+            "{0} requires the Visual Studio developer environment.", `cl.exe ${this.buildAndDebugActiveFileStr()}`);
+        const updateButton = localize("update.dev.env", "Update Developer Environment");
+        const updateMessage = localize(
+            {
+                key: "update.dev.env",
+                comment: ["{0} is a command option in a menu."]
+            },
+            "{0} requires the Visual Studio developer environment to be updated.", `cl.exe ${this.buildAndDebugActiveFileStr()}`);
+        const cancel = localize("cancel", "Cancel");
+        const response = await vscode.window.showErrorMessage(
+            hasEnvironment ? updateMessage : applyMessage,
+            hasEnvironment ? updateButton : applyButton,
             cancel);
-        if (response === applyDevEnv) {
+        if (response === applyButton || response === updateButton) {
             try {
                 await vscode.commands.executeCommand('C_Cpp.SetVsDeveloperEnvironment', 'buildAndDebug');
             } catch (e: any) {
@@ -615,11 +630,12 @@ export class DebugConfigurationProvider implements vscode.DebugConfigurationProv
             return true;
         }
 
-        if (util.hasMsvcEnvironment()) {
+        if (util.hasMsvcEnvironment() && await canFindCl()) {
             return false;
         }
-        void vscode.window.showErrorMessage(
-            localize('dev.env.not.applied', 'The source code could not be built because the Visual Studio developer environment was not applied.'));
+        const notAppliedMessage = localize("dev.env.not.applied", "The source code could not be built because the Visual Studio developer environment was not applied.");
+        const notFoundMessage = localize("dev.env.not.found", "The source code could not be built because the Visual C++ compiler could not be found.");
+        void vscode.window.showErrorMessage(hasEnvironment ? notFoundMessage : notAppliedMessage);
         return true;
     }
 

Extension/src/LanguageServer/cppBuildTaskProvider.ts

@@ -6,13 +6,13 @@
 import * as cp from "child_process";
 import * as os from 'os';
 import * as path from 'path';
-import { CustomExecution, Disposable, EnvironmentVariableMutator, Event, EventEmitter, ProcessExecution, Pseudoterminal, ShellExecution, Task, TaskDefinition, TaskEndEvent, TaskExecution, TaskGroup, TaskProvider, tasks, TaskScope, TerminalDimensions, TextEditor, window, workspace, WorkspaceFolder } from 'vscode';
+import { CustomExecution, Disposable, Event, EventEmitter, ProcessExecution, Pseudoterminal, ShellExecution, Task, TaskDefinition, TaskEndEvent, TaskExecution, TaskGroup, TaskProvider, tasks, TaskScope, TerminalDimensions, TextEditor, window, workspace, WorkspaceFolder } from 'vscode';
 import * as nls from 'vscode-nls';
 import * as util from '../common';
 import * as telemetry from '../telemetry';
 import { Client } from './client';
 import * as configs from './configurations';
-import { isEnvironmentOverrideApplied } from "./devcmd";
+import { getEffectiveEnvironment, isEnvironmentOverrideApplied } from "./devcmd";
 import * as ext from './extension';
 import { OtherSettings } from './settings';
 
@@ -431,20 +431,11 @@ class CustomBuildTaskTerminal implements Pseudoterminal {
             }
         }
 
-        if (isEnvironmentOverrideApplied(util.extensionContext)) {
+        if (isEnvironmentOverrideApplied()) {
             // If the user has applied the developer environment to this workspace, it should apply to all newly opened terminals.
             // However, this does not apply to processes that we spawn ourselves in the Pseudoterminal, so we need to specify the
             // correct environment in order to emulate the terminal behavior properly.
-            const env = { ...process.env };
-            util.extensionContext?.environmentVariableCollection.forEach((variable: string, mutator: EnvironmentVariableMutator) => {
-                if (variable.toLowerCase() === "path") {
-                    // Path is special because it has a placeholder to insert the current Path into.
-                    env[variable] = util.resolveVariables(mutator.value);
-                } else {
-                    env[variable] = mutator.value;
-                }
-            });
-            this.options.env = env;
+            this.options.env = getEffectiveEnvironment();
         }
 
         const splitWriteEmitter = (lines: string | Buffer) => {

Extension/src/LanguageServer/devcmd.ts

@@ -9,6 +9,7 @@ import { vswhere } from 'node-vswhere';
 import * as path from 'path';
 import * as vscode from 'vscode';
 import * as nls from 'vscode-nls';
+import { extensionContext, isString, resolveVariables, whichAsync } from '../common';
 import { isWindows } from '../constants';
 import { CppSettings } from './settings';
 
@@ -27,8 +28,31 @@ const advancedOptionsDescription = localize('advanced.options.desc', 'Select a s
 const selectToolsetVersion = localize('select.toolset', 'Select a toolset version');
 const selectHostTargetArch = localize('select.host.target', 'Select a host and target architecture');
 
-export function isEnvironmentOverrideApplied(context?: vscode.ExtensionContext) {
-    return context?.environmentVariableCollection.get('VCToolsInstallDir') !== undefined;
+export function isEnvironmentOverrideApplied(): boolean {
+    return extensionContext?.environmentVariableCollection.get('VCToolsInstallDir') !== undefined;
+}
+
+export function getEffectiveEnvironment(): { [key: string]: string | undefined } {
+    const env = { ...process.env };
+    extensionContext?.environmentVariableCollection.forEach((variable: string, mutator: vscode.EnvironmentVariableMutator) => {
+        if (variable.toLowerCase() === "path") {
+            // Path is special because it has a placeholder to insert the current Path into.
+            env[variable] = resolveVariables(mutator.value);
+        } else {
+            env[variable] = mutator.value;
+        }
+    });
+    return env;
+}
+
+export async function canFindCl(): Promise<boolean> {
+    if (!isWindows) {
+        return false;
+    }
+    const pathOverride = resolveVariables(extensionContext?.environmentVariableCollection.get('Path')?.value);
+    const path = pathOverride ?? process.env['Path'];
+    const found = await whichAsync('cl.exe', path);
+    return isString(found);
 }
 
 export async function setEnvironment(context?: vscode.ExtensionContext) {

Extension/src/common.ts

@@ -1515,9 +1515,9 @@ export interface ISshLocalForwardInfo {
     remoteSocket?: string;
 }
 
-export function whichAsync(name: string): Promise<string | undefined> {
+export function whichAsync(name: string, path?: string): Promise<string | undefined> {
     return new Promise<string | undefined>(resolve => {
-        which(name, (err, resolved) => {
+        which(name, path ? { path } : {}, (err, resolved) => {
             if (err) {
                 resolve(undefined);
             } else {