Add option to run with a custom mono installation

package.json

@@ -535,6 +535,14 @@
           ],
           "description": "Launch OmniSharp with the globally-installed Mono. If set to \"always\", \"mono\" version 5.8.1 or greater must be available on the PATH. If set to \"auto\", OmniSharp will be launched with \"mono\" if version 5.8.1 or greater is available on the PATH."
         },
+        "omnisharp.monoPath": {
+          "type": [
+            "string",
+            "null"
+          ],
+          "default": null,
+          "description": "Specifies the path to a mono installation to use when \"useGlobalMono\" is set to \"always\" or \"auto\", instead of the default system one."
+        },
         "omnisharp.waitForDebugger": {
           "type": "boolean",
           "default": false,

src/omnisharp/launcher.ts

@@ -233,7 +233,13 @@ async function launch(cwd: string, args: string[], launchInfo: LaunchInfo, platf
         return launchWindows(launchInfo.LaunchPath, cwd, args);
     }
 
-    let monoVersion = await getMonoVersion();
+    let childEnv = { ...process.env };
+    if (options.useGlobalMono !== "never" && options.monoPath !== undefined) {
+        childEnv['PATH'] = path.join(options.monoPath, 'bin') + path.delimiter + childEnv['PATH'];
+        childEnv['MONO_GAC_PREFIX'] = options.monoPath;
+    }
+
+    let monoVersion = await getMonoVersion(childEnv);
     let isValidMonoAvailable = await satisfies(monoVersion, '>=5.8.1');
 
     // If the user specifically said that they wanted to launch on Mono, respect their wishes.
@@ -244,12 +250,12 @@ async function launch(cwd: string, args: string[], launchInfo: LaunchInfo, platf
 
         const launchPath = launchInfo.MonoLaunchPath || launchInfo.LaunchPath;
 
-        return launchNixMono(launchPath, monoVersion, cwd, args);
+        return launchNixMono(launchPath, monoVersion, cwd, args, childEnv);
     }
 
     // If we can launch on the global Mono, do so; otherwise, launch directly;
     if (options.useGlobalMono === "auto" && isValidMonoAvailable && launchInfo.MonoLaunchPath) {
-        return launchNixMono(launchInfo.MonoLaunchPath, monoVersion, cwd, args);
+        return launchNixMono(launchInfo.MonoLaunchPath, monoVersion, cwd, args, childEnv);
     }
     else {
         return launchNix(launchInfo.LaunchPath, cwd, args);
@@ -306,14 +312,15 @@ function launchNix(launchPath: string, cwd: string, args: string[]): LaunchResul
     };
 }
 
-function launchNixMono(launchPath: string, monoVersion: string, cwd: string, args: string[]): LaunchResult {
+function launchNixMono(launchPath: string, monoVersion: string, cwd: string, args: string[], environment: NodeJS.ProcessEnv): LaunchResult {
     let argsCopy = args.slice(0); // create copy of details args
     argsCopy.unshift(launchPath);
     argsCopy.unshift("--assembly-loader=strict");
 
     let process = spawn('mono', argsCopy, {
         detached: false,
-        cwd: cwd
+        cwd: cwd,
+        env: environment
     });
 
     return {
@@ -323,13 +330,13 @@ function launchNixMono(launchPath: string, monoVersion: string, cwd: string, arg
     };
 }
 
-async function getMonoVersion(): Promise<string> {
+async function getMonoVersion(environment: NodeJS.ProcessEnv): Promise<string> {
     const versionRegexp = /(\d+\.\d+\.\d+)/;
 
     return new Promise<string>((resolve, reject) => {
         let childprocess: ChildProcess;
         try {
-            childprocess = spawn('mono', ['--version']);
+            childprocess = spawn('mono', ['--version'], { env: environment });
         }
         catch (e) {
             return resolve(undefined);

src/omnisharp/options.ts

@@ -20,8 +20,9 @@ export class Options {
         public showTestsCodeLens: boolean,
         public disableCodeActions: boolean,
         public disableMSBuildDiagnosticWarning: boolean,
-        public defaultLaunchSolution?: string) { }
-
+        public defaultLaunchSolution?: string,
+        public monoPath?: string) { }
+
 
     public static Read(vscode: vscode): Options {
         // Extra effort is taken below to ensure that legacy versions of options
@@ -36,6 +37,7 @@ export class Options {
 
         const path = Options.readPathOption(csharpConfig, omnisharpConfig);
         const useGlobalMono = Options.readUseGlobalMonoOption(omnisharpConfig, csharpConfig);
+        const monoPath = omnisharpConfig.get<string>('monoPath', undefined);
 
         const waitForDebugger = omnisharpConfig.get<boolean>('waitForDebugger', false);
 
@@ -75,7 +77,9 @@ export class Options {
             showTestsCodeLens,
             disableCodeActions,
             disableMSBuildDiagnosticWarning,
-            defaultLaunchSolution);
+            defaultLaunchSolution,
+            monoPath,
+        );
     }
 
     private static readPathOption(csharpConfig: WorkspaceConfiguration, omnisharpConfig: WorkspaceConfiguration): string | null {

test/unitTests/options.test.ts

@@ -16,6 +16,7 @@ suite("Options tests", () => {
         const options = Options.Read(vscode);
         expect(options.path).to.be.null;
         options.useGlobalMono.should.equal("auto");
+        expect(options.monoPath).to.be.undefined;
         options.waitForDebugger.should.equal(false);
         options.loggingLevel.should.equal("information");
         options.autoStart.should.equal(true);