Unherit server extra env for runnables extra env

editors/code/src/config.ts

@@ -261,8 +261,12 @@ export class Config {
     }
 
     runnablesExtraEnv(label: string): Env {
-        let extraEnv = this.get<RunnableEnvCfgItem[] | { [key: string]: { toString(): string } | null } | null>("runnables.extraEnv") ?? {};
-        if (!extraEnv) return {};
+        const serverEnv = this.serverExtraEnv;
+        let extraEnv =
+            this.get<
+                RunnableEnvCfgItem[] | { [key: string]: { toString(): string } | null } | null
+            >("runnables.extraEnv") ?? {};
+        if (!extraEnv) return serverEnv;
 
         const platform = process.platform;
         const checkPlatform = (it: RunnableEnvCfgItem) => {
@@ -283,7 +287,7 @@ export class Config {
             }
             extraEnv = env;
         }
-        return substituteVariablesInEnv(
+        const runnableExtraEnv = substituteVariablesInEnv(
             Object.fromEntries(
                 Object.entries(extraEnv).map(([k, v]) => [
                     k,
@@ -291,6 +295,7 @@ export class Config {
                 ]),
             ),
         );
+        return { ...runnableExtraEnv, ...serverEnv };
     }
 
     get restartServerOnConfigChange() {
@@ -485,11 +490,11 @@ function computeVscodeVar(varName: string): string | null {
             folder === undefined
                 ? "" // no workspace opened
                 : // could use currently opened document to detect the correct
-                // workspace. However, that would be determined by the document
-                // user has opened on Editor startup. Could lead to
-                // unpredictable workspace selection in practice.
-                // It's better to pick the first one
-                normalizeDriveLetter(folder.uri.fsPath);
+                  // workspace. However, that would be determined by the document
+                  // user has opened on Editor startup. Could lead to
+                  // unpredictable workspace selection in practice.
+                  // It's better to pick the first one
+                  normalizeDriveLetter(folder.uri.fsPath);
         return fsPath;
     };
     // https://code.visualstudio.com/docs/editor/variables-reference

editors/code/src/debug.ts

@@ -6,7 +6,14 @@ import type * as ra from "./lsp_ext";
 import { Cargo } from "./toolchain";
 import type { Ctx } from "./ctx";
 import { createTaskFromRunnable, prepareEnv } from "./run";
-import { execute, isCargoRunnableArgs, unwrapUndefinable, log, normalizeDriveLetter, Env } from "./util";
+import {
+    execute,
+    isCargoRunnableArgs,
+    unwrapUndefinable,
+    log,
+    normalizeDriveLetter,
+    Env,
+} from "./util";
 import type { Config } from "./config";
 
 // Here we want to keep track on everything that's currently running
@@ -108,9 +115,9 @@ async function getDebugConfiguration(
 
         await vscode.window.showErrorMessage(
             `Install [CodeLLDB](command:${commandCodeLLDB} "Open CodeLLDB")` +
-            `, [lldb-dap](command:${commandLLDBDap} "Open lldb-dap")` +
-            `, [C/C++](command:${commandCCpp} "Open C/C++") ` +
-            `or [Native Debug](command:${commandNativeDebug} "Open Native Debug") for debugging.`,
+                `, [lldb-dap](command:${commandLLDBDap} "Open lldb-dap")` +
+                `, [C/C++](command:${commandCCpp} "Open C/C++") ` +
+                `or [Native Debug](command:${commandNativeDebug} "Open Native Debug") for debugging.`,
         );
         return;
     }
@@ -124,7 +131,7 @@ async function getDebugConfiguration(
         !isMultiFolderWorkspace || !runnableArgs.workspaceRoot
             ? firstWorkspace
             : workspaceFolders.find((w) => runnableArgs.workspaceRoot?.includes(w.uri.fsPath)) ||
-            firstWorkspace;
+              firstWorkspace;
 
     const workspace = unwrapUndefinable(maybeWorkspace);
     const wsFolder = normalizeDriveLetter(path.normalize(workspace.uri.fsPath));
@@ -206,10 +213,7 @@ type SourceFileMap = {
     destination: string;
 };
 
-async function discoverSourceFileMap(
-    env: Env,
-    cwd: string,
-): Promise<SourceFileMap | undefined> {
+async function discoverSourceFileMap(env: Env, cwd: string): Promise<SourceFileMap | undefined> {
     const sysroot = env["RUSTC_TOOLCHAIN"];
     if (sysroot) {
         // let's try to use the default toolchain
@@ -304,10 +308,7 @@ const knownEngines: {
     },
 };
 
-async function getDebugExecutable(
-    runnableArgs: ra.CargoRunnableArgs,
-    env: Env,
-): Promise<string> {
+async function getDebugExecutable(runnableArgs: ra.CargoRunnableArgs, env: Env): Promise<string> {
     const cargo = new Cargo(runnableArgs.workspaceRoot || ".", env);
     const executable = await cargo.executableFromArgs(runnableArgs);
 

editors/code/src/run.ts

@@ -122,10 +122,7 @@ export class RunnableQuickPick implements vscode.QuickPickItem {
     }
 }
 
-export function prepareBaseEnv(
-    inheritEnv: boolean,
-    base?: Env,
-): Env {
+export function prepareBaseEnv(inheritEnv: boolean, base?: Env): Env {
     const env: Env = { RUST_BACKTRACE: "short" };
     if (inheritEnv) {
         Object.assign(env, process.env);
@@ -136,11 +133,7 @@ export function prepareBaseEnv(
     return env;
 }
 
-export function prepareEnv(
-    inheritEnv: boolean,
-    runnableEnv?: Env,
-    runnableEnvCfg?: Env,
-): Env {
+export function prepareEnv(inheritEnv: boolean, runnableEnv?: Env, runnableEnvCfg?: Env): Env {
     const env = prepareBaseEnv(inheritEnv, runnableEnv);
 
     if (runnableEnvCfg) {

editors/code/src/tasks.ts

@@ -134,11 +134,9 @@ export async function targetToExecution(
     }
     return new vscode.ProcessExecution(command, args, {
         cwd: options?.cwd,
-        env:
-            Object.fromEntries(
-                Object.entries(options?.env ?? {}).map(([key, value]) => [key, value ?? ""])
-            )
-        ,
+        env: Object.fromEntries(
+            Object.entries(options?.env ?? {}).map(([key, value]) => [key, value ?? ""]),
+        ),
     });
 }
 

editors/code/src/toolchain.ts

@@ -38,7 +38,7 @@ export class Cargo {
     constructor(
         readonly rootFolder: string,
         readonly env: Env,
-    ) { }
+    ) {}
 
     // Made public for testing purposes
     static artifactSpec(cargoArgs: string[], executableArgs?: string[]): ArtifactSpec {