Add/update 'omnisharp.useGlobalMono' option

This change updates the name of the 'omnisharp.useMono' option to 'omnisharp.useGlobalMono', and makes it
a tri-state value rather than a boolean. It now has three possible values:

* "auto": Launch OmniSharp on the globally-installed Mono if it's available.
* "always": Always try to launch OmniSharp on the globally-installed Mono and error if it's not available.
* "never": Never launch OmniSharp on the globall-installed Mono.

Author: DustinCampbell

package.json

@@ -521,10 +521,20 @@
           "default": null,
           "description": "Specifies the path to OmniSharp. This can be the absolute path to an OmniSharp executable, a specific version number, or \"latest\". If a version number or \"latest\" is specified, the appropriate version of OmniSharp will be downloaded on your behalf."
         },
-        "omnisharp.useMono": {
-          "type": "boolean",
-          "default": false,
-          "description": "Launch OmniSharp with Mono."
+        "omnisharp.useGlobalMono": {
+          "type": "string",
+          "default": "auto",
+          "enum": [
+            "auto",
+            "always",
+            "never"
+          ],
+          "enumDescriptions": [
+            "Automatically launch OmniSharp with \"mono\" if version 5.2.0 or greater is available on the PATH.",
+            "Always launch OmniSharp with \"mono\". If version 5.2.0 or greater is not available on the PATH, an error will be printed.",
+            "Never launch OmniSHarp on a globally-installed Mono."
+          ],
+          "description": "Launch OmniSharp with the globally-installed Mono. If set to \"always\", \"mono\" version 5.2.0 or greater must be available on the PATH. If set to \"auto\", OmniSharp will be launched with \"mono\" if version 5.2.0 or greater is available on the PATH."
         },
         "omnisharp.waitForDebugger": {
           "type": "boolean",

src/omnisharp/launcher.ts

@@ -242,16 +242,18 @@ async function launch(cwd: string, args: string[], launchInfo: LaunchInfo, platf
     let isValidMonoAvailable = await satisfies(monoVersion, '>=5.2.0');
 
     // If the user specifically said that they wanted to launch on Mono, respect their wishes.
-    if (options.useMono) {
+    if (options.useGlobalMono === "always") {
         if (!isValidMonoAvailable) {
             throw new Error('Cannot start OmniSharp because Mono version >=5.2.0 is required.');
         }
 
-        return launchNixMono(launchInfo.LaunchPath, monoVersion, cwd, args);
+        const launchPath = launchInfo.MonoLaunchPath || launchInfo.LaunchPath;
+
+        return launchNixMono(launchPath, monoVersion, cwd, args);
     }
 
     // If we can launch on the global Mono, do so; otherwise, launch directly;
-    if (isValidMonoAvailable && launchInfo.MonoLaunchPath) {
+    if (options.useGlobalMono === "auto" && isValidMonoAvailable && launchInfo.MonoLaunchPath) {
         return launchNixMono(launchInfo.MonoLaunchPath, monoVersion, cwd, args);
     }
     else {

src/omnisharp/options.ts

@@ -7,37 +7,33 @@ import * as vscode from 'vscode';
 
 export class Options {
     constructor(
-        public path?: string,
-        public useMono?: boolean,
-        public waitForDebugger?: boolean,
-        public loggingLevel?: string,
-        public autoStart?: boolean,
-        public projectLoadTimeout?: number,
-        public maxProjectResults?: number,
-        public useEditorFormattingSettings?: boolean,
-        public useFormatting?: boolean,
-        public showReferencesCodeLens?: boolean,
-        public showTestsCodeLens?: boolean,
-        public disableCodeActions?: boolean,
-        public disableMSBuildDiagnosticWarning?: boolean) { }
+        public path: string,
+        public useGlobalMono: string,
+        public waitForDebugger: boolean,
+        public loggingLevel: string,
+        public autoStart: boolean,
+        public projectLoadTimeout: number,
+        public maxProjectResults: number,
+        public useEditorFormattingSettings: boolean,
+        public useFormatting: boolean,
+        public showReferencesCodeLens: boolean,
+        public showTestsCodeLens: boolean,
+        public disableCodeActions: boolean,
+        public disableMSBuildDiagnosticWarning: boolean) { }
 
     public static Read(): Options {
         // Extra effort is taken below to ensure that legacy versions of options
         // are supported below. In particular, these are:
         //
         // - "csharp.omnisharp" -> "omnisharp.path"
         // - "csharp.omnisharpUsesMono" -> "omnisharp.useMono"
+        // - "omnisharp.useMono" -> "omnisharp.useGlobalMono"
 
         const omnisharpConfig = vscode.workspace.getConfiguration('omnisharp');
         const csharpConfig = vscode.workspace.getConfiguration('csharp');
 
-        const path = csharpConfig.has('omnisharp')
-            ? csharpConfig.get<string>('omnisharp')
-            : omnisharpConfig.get<string>('path');
-
-        const useMono = csharpConfig.has('omnisharpUsesMono')
-            ? csharpConfig.get<boolean>('omnisharpUsesMono')
-            : omnisharpConfig.get<boolean>('useMono');
+        const path = Options.readPathOption(csharpConfig, omnisharpConfig);
+        const useGlobalMono = Options.readUseGlobalMonoOption(omnisharpConfig, csharpConfig);
 
         const waitForDebugger = omnisharpConfig.get<boolean>('waitForDebugger', false);
 
@@ -62,8 +58,9 @@ export class Options {
 
         const disableMSBuildDiagnosticWarning = omnisharpConfig.get<boolean>('disableMSBuildDiagnosticWarning');
 
-        return new Options(path, 
-            useMono, 
+        return new Options(
+            path, 
+            useGlobalMono, 
             waitForDebugger,
             loggingLevel, 
             autoStart, 
@@ -76,4 +73,43 @@ export class Options {
             disableCodeActions,
             disableMSBuildDiagnosticWarning);
     }
+
+    private static readPathOption(csharpConfig: vscode.WorkspaceConfiguration, omnisharpConfig: vscode.WorkspaceConfiguration): string | null {
+        if (omnisharpConfig.has('path')) {
+            // If 'omnisharp.path' setting was found, use it.
+            return omnisharpConfig.get<string>('path');
+        }
+        else if (csharpConfig.has('omnisharp')) {
+            // BACKCOMPAT: If 'csharp.omnisharp' setting was found, use it.
+            return csharpConfig.get<string>('path');
+        }
+        else {
+            // Otherwise, null.
+            return null;
+        }
+    }
+
+    private static readUseGlobalMonoOption(omnisharpConfig: vscode.WorkspaceConfiguration, csharpConfig: vscode.WorkspaceConfiguration): string {
+        function toUseGlobalMonoValue(value: boolean): string {
+            // True means 'always' and false means 'auto'.
+            return value ? "always" : "auto";
+        }
+
+        if (omnisharpConfig.has('useGlobalMono')) {
+            // If 'omnisharp.useGlobalMono' setting was found, just use it.
+            return omnisharpConfig.get<string>('useGlobalMono');
+        }
+        else if (omnisharpConfig.has('useMono')) {
+            // BACKCOMPAT: If 'omnisharp.useMono' setting was found, true maps to "always" and false maps to "auto"
+            return toUseGlobalMonoValue(omnisharpConfig.get<boolean>('useMono'));
+        }
+        else if (csharpConfig.has('omnisharpUsesMono')) {
+            // BACKCOMPAT: If 'csharp.omnisharpUsesMono' setting was found, true maps to "always" and false maps to "auto" 
+            return toUseGlobalMonoValue(csharpConfig.get<boolean>('omnisharpUsesMono'));
+        }
+        else {
+            // Otherwise, the default value is "auto".
+            return "auto";
+        }
+    }
 }