Merge pull request #2254 from OmniSharp/master

Merge master into release

Author: DustinCampbell

CHANGELOG.md

@@ -19,24 +19,36 @@
   * Fixes async call stacks with the .NET Core 2.1 runtime. ([#1892](https://github.com/OmniSharp/omnisharp-vscode/issues/1892))
   * Fixes the debugger's browser launch code when launching projects configured to use Application Insights. ([2177](https://github.com/OmniSharp/omnisharp-vscode/issues/2177))
 
-#### Specify OmniSharp Version
-Enables the use of pre-release builds of Omnisharp. Downloading a pre-release build of Omnisharp allows the C# extension for VS Code to use features that have been merged into the "master" branch of omnisharp-roslyn(https://github.com/OmniSharp/omnisharp-roslyn) but that have not been officially released
-* Adds support to use the "omnisharp.path" option to download a specific copy of OmniSharp. The possible values for this option are:
-  * `<Path to the omnisharp executable>` - Use a local copy of OmniSharp. The value must point to a directory which contains OmniSharp, typically a user's build output directory for the OmniSharp-Roslyn project. Example: C:\omnisharp-roslyn\artifacts\publish\OmniSharp.Stdio\win7-x64\OmniSharp.exe.
-  * `latest` - Use the latest CI build
-  * `<version>` - Use a specific version of OmniSharp. Example: `1.29.2-beta.60`
+#### Options
 
-#### Editor
+* "omnisharp.path": This option has been updated to enable the user to specify different versions of OmniSharp, including prerelease versions. ([#1909](https://github.com/OmniSharp/omnisharp-vscode/issues/1909), PR: [#2039](https://github.com/OmniSharp/omnisharp-vscode/pull/2039))
+
+  Possible values for this option are:
+  * `<Path to the omnisharp executable>`: Use a local copy of OmniSharp. The value must point directly to the OmniSharp executable. This is typically the build output directory of the [omnisharp-roslyn](https://github.com/OmniSharp/omnisharp-roslyn) project on the current machine, for example, `C:/omnisharp-roslyn/artifacts/publish/OmniSharp.Stdio/win7-x64/OmniSharp.exe`.
+  * `latest`: Use the latest CI build from [omnisharp-roslyn](https://github.com/OmniSharp/omnisharp-roslyn).
+  * `<version>`: Use a specific version of OmniSharp. Example: `1.29.2-beta.60`
+  If "omnisharp.path" is not set, the defalut version of OmniSharp for the current release of C# for VS Code is used.
+
+* "omnisharp.useGlobalMono": This option replaces the old "omnisharp.useMono" option and controls whether or not OmniSharp will be launched with a globally-installed version of Mono. (PR: [#2244](https://github.com/OmniSharp/omnisharp-vscode/pull/2244))
 
-* Splits the OmniSharp status bar item into two parts, both of which appear on the left and have specific responsibilities. ([#2146](https://github.com/OmniSharp/omnisharp-vscode/issues/2146), PR: [@2133](https://github.com/OmniSharp/omnisharp-vscode/pull/2133))
-  * OmniSharp server status bar item - Shows the various stages that the OmniSharp server initialization might be in (eg: Downloading, Installing, etc). The flame icon is green when the server is initialized and running properly, or red if there is an error.
-  * Project Information status bar item - 
-    * Displays the name of the selected project regardless of the currently active document.  
-    * If a project is already selected, it displays the name of the selected project. Clicking on it displays a menu to switch to other projects in the workspace. 
+  There are three possible values:
+  * "auto": Automatically launch OmniSharp with `mono` if version 5.2.0 or greater is available on the PATH.
+  * "always": Always launch OmniSharp with `mono`. If version 5.2.0 or greater is not available on the PATH, an error will be printed.
+  * "never": Never launch OmniSharp on a globally-installed Mono.
+
+#### Status Bar
+
+* Splits the OmniSharp status bar item into two parts, both of which appear on the left side of VS Code's status bar and have specific responsibilities. ([#2146](https://github.com/OmniSharp/omnisharp-vscode/issues/2146), PR: [#2133](https://github.com/OmniSharp/omnisharp-vscode/pull/2133))
+  * OmniSharp Server info:
+    * Displays the current state of the  OmniSharp server, such as Downloading, Installing, etc. The flame icon is green when the server is initialized and running properly, or red if there is an error.
+  * Selected Project info:
+    * Displays the name of the selected project regardless of the currently active document.
+    * If a project is already selected, it displays the name of the selected project. Clicking on it displays a menu to switch to other projects in the workspace.
     * If there are multiple possible launch targets, it displays 'Select Project'. Clicking on it displays a menu to select one.
 
 #### Misc
-* Enables suppressing the "some projects had trouble loading" popup using the `omnisharp.disableMsBuildDiagnosticWarning` option ([#2110]https://github.com/OmniSharp/omnisharp-vscode/issues/2110)
+
+* Enables suppressing the "Some projects have trouble loading" popup using the `omnisharp.disableMSBuildDiagnosticWarning` option ([#2110]https://github.com/OmniSharp/omnisharp-vscode/issues/2110)
 
 ## 1.14.0 (February 14, 2018)
 

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/features/codeActionProvider.ts

@@ -32,7 +32,7 @@ export default class CodeActionProvider extends AbstractProvider implements vsco
     }
 
     private _resetCachedOptions(): void {
-        this._options = Options.Read();
+        this._options = Options.Read(vscode);
     }
 
     public async provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken): Promise<vscode.Command[]> {

src/features/codeLensProvider.ts

@@ -39,7 +39,7 @@ export default class OmniSharpCodeLensProvider extends AbstractProvider implemen
     }
 
     private _resetCachedOptions(): void {
-        this._options = Options.Read();
+        this._options = Options.Read(vscode);
     }
 
     private static filteredSymbolNames: { [name: string]: boolean } = {

src/main.ts

@@ -61,7 +61,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     eventStream.subscribe(omnisharpLogObserver.post);
     eventStream.subscribe(omnisharpChannelObserver.post);
 
-    let warningMessageObserver = new WarningMessageObserver(vscode, () => Options.Read().disableMSBuildDiagnosticWarning || false);
+    let warningMessageObserver = new WarningMessageObserver(vscode, () => Options.Read(vscode).disableMSBuildDiagnosticWarning || false);
     eventStream.subscribe(warningMessageObserver.post);
 
     let informationMessageObserver = new InformationMessageObserver(vscode);

src/omnisharp/OmnisharpDownloader.ts

@@ -3,14 +3,12 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as fs from 'fs';
 import { GetPackagesFromVersion } from './OmnisharpPackageCreator';
 import { PlatformInformation } from '../platform';
 import { PackageInstallation, LogPlatformInfo, InstallationSuccess, InstallationFailure, LatestBuildDownloadStart } from './loggingEvents';
 import { EventStream } from '../EventStream';
 import { NetworkSettingsProvider } from '../NetworkSettings';
 import { DownloadAndInstallPackages } from '../packageManager/PackageManager';
-import { CreateTmpFile, TmpAsset } from '../CreateTmpAsset';
 import { DownloadFile } from '../packageManager/FileDownloader';
 import { ResolveFilePaths } from '../packageManager/PackageFilePathResolver';
 
@@ -43,23 +41,16 @@ export class OmnisharpDownloader {
     }
 
     public async GetLatestVersion(serverUrl: string, latestVersionFileServerPath: string): Promise<string> {
-        let description = "Latest Omnisharp Version Information";
+        let description = "Latest OmniSharp Version Information";
         let url = `${serverUrl}/${latestVersionFileServerPath}`;
-        let tmpFile: TmpAsset;
         try {
             this.eventStream.post(new LatestBuildDownloadStart());
-            tmpFile = await CreateTmpFile();
-            await DownloadFile(tmpFile.fd, description, this.eventStream, this.networkSettingsProvider, url);
-            return fs.readFileSync(tmpFile.name, 'utf8');
+            let versionBuffer = await DownloadFile(description, this.eventStream, this.networkSettingsProvider, url);
+            return versionBuffer.toString('utf8');
         }
         catch (error) {
             this.eventStream.post(new InstallationFailure('getLatestVersionInfoFile', error));
             throw error;
         }
-        finally {
-            if (tmpFile) {
-                tmpFile.dispose();
-            }
-        }
     }
 }

src/omnisharp/extension.ts

@@ -43,7 +43,7 @@ export async function activate(context: vscode.ExtensionContext, eventStream: Ev
         scheme: 'file' // only files from disk
     };
 
-    const options = Options.Read();
+    const options = Options.Read(vscode);
     const server = new OmniSharpServer(vscode, provider, eventStream, packageJSON, platformInfo);
     omnisharp = server;
     const advisor = new Advisor(server); // create before server is started

src/omnisharp/launcher.ts

@@ -41,7 +41,7 @@ export function findLaunchTargets(): Thenable<LaunchTarget[]> {
         return Promise.resolve([]);
     }
 
-    const options = Options.Read();
+    const options = Options.Read(vscode);
 
     return vscode.workspace.findFiles(
             /*include*/ '{**/*.sln,**/*.csproj,**/project.json,**/*.csx,**/*.cake}',
@@ -204,9 +204,9 @@ export interface LaunchResult {
     monoVersion?: string;
 }
 
-export async function launchOmniSharp(cwd: string, args: string[], launchInfo: LaunchInfo, platformInfo: PlatformInformation): Promise<LaunchResult> {
+export async function launchOmniSharp(cwd: string, args: string[], launchInfo: LaunchInfo, platformInfo: PlatformInformation, options: Options): Promise<LaunchResult> {
     return new Promise<LaunchResult>((resolve, reject) => {
-        launch(cwd, args, launchInfo, platformInfo)
+        launch(cwd, args, launchInfo, platformInfo, options)
             .then(result => {
                 // async error - when target not not ENEOT
                 result.process.on('error', err => {
@@ -222,9 +222,7 @@ export async function launchOmniSharp(cwd: string, args: string[], launchInfo: L
     });
 }
 
-async function launch(cwd: string, args: string[], launchInfo: LaunchInfo, platformInfo: PlatformInformation): Promise<LaunchResult> {
-    const options = Options.Read();
-
+async function launch(cwd: string, args: string[], launchInfo: LaunchInfo, platformInfo: PlatformInformation, options: Options): Promise<LaunchResult> {
     if (options.useEditorFormattingSettings) {
         let globalConfig = vscode.workspace.getConfiguration();
         let csharpConfig = vscode.workspace.getConfiguration('[csharp]');
@@ -242,16 +240,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

@@ -3,47 +3,43 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import * as vscode from 'vscode';
+import { vscode, WorkspaceConfiguration } from '../vscodeAdapter';
 
 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 static Read(): Options {
+        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(vscode: vscode): 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);
 
         // support the legacy "verbose" level as "debug"
-        let loggingLevel = omnisharpConfig.get<string>('loggingLevel');
-        if (loggingLevel.toLowerCase() === 'verbose') {
+        let loggingLevel = omnisharpConfig.get<string>('loggingLevel', 'information');
+        if (loggingLevel && loggingLevel.toLowerCase() === 'verbose') {
             loggingLevel = 'debug';
         }
 
@@ -60,10 +56,11 @@ export class Options {
 
         const disableCodeActions = csharpConfig.get<boolean>('disableCodeActions', false);
 
-        const disableMSBuildDiagnosticWarning = omnisharpConfig.get<boolean>('disableMSBuildDiagnosticWarning');
+        const disableMSBuildDiagnosticWarning = omnisharpConfig.get<boolean>('disableMSBuildDiagnosticWarning', false);
 
-        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: WorkspaceConfiguration, omnisharpConfig: 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>('omnisharp');
+        }
+        else {
+            // Otherwise, null.
+            return null;
+        }
+    }
+
+    private static readUseGlobalMonoOption(omnisharpConfig: WorkspaceConfiguration, csharpConfig: 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', "auto");
+        }
+        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";
+        }
+    }
 }