Merge branch 'master' into release

Author: DustinCampbell

src/features/codeActionProvider.ts

@@ -9,34 +9,25 @@ import AbstractProvider from './abstractProvider';
 import * as protocol from '../omnisharp/protocol';
 import { toRange2 } from '../omnisharp/typeConvertion';
 import * as serverUtils from '../omnisharp/utils';
-import { Options } from '../omnisharp/options';
 import { FileModificationType } from '../omnisharp/protocol';
 import { Uri } from 'vscode';
 import CompositeDisposable from '../CompositeDisposable';
+import OptionProvider from '../observers/OptionProvider';
 
 export default class CodeActionProvider extends AbstractProvider implements vscode.CodeActionProvider {
 
-    private _options: Options;
     private _commandId: string;
 
-    constructor(server: OmniSharpServer) {
+    constructor(server: OmniSharpServer, private optionProvider: OptionProvider) {
         super(server);
-
         this._commandId = 'omnisharp.runCodeAction';
-
-        this._resetCachedOptions();
-
-        let d1 = vscode.workspace.onDidChangeConfiguration(this._resetCachedOptions, this);
-        let d2 = vscode.commands.registerCommand(this._commandId, this._runCodeAction, this);
-        this.addDisposables(new CompositeDisposable(d1, d2));
-    }
-
-    private _resetCachedOptions(): void {
-        this._options = Options.Read(vscode);
+        let registerCommandDisposable = vscode.commands.registerCommand(this._commandId, this._runCodeAction, this);
+        this.addDisposables(new CompositeDisposable(registerCommandDisposable));
     }
 
     public async provideCodeActions(document: vscode.TextDocument, range: vscode.Range, context: vscode.CodeActionContext, token: vscode.CancellationToken): Promise<vscode.Command[]> {
-        if (this._options.disableCodeActions) {
+        let options = this.optionProvider.GetLatestOptions();
+        if (options.disableCodeActions) {
             return;
         }
 

src/features/codeLensProvider.ts

@@ -6,14 +6,12 @@
 import * as protocol from '../omnisharp/protocol';
 import * as serverUtils from '../omnisharp/utils';
 import * as vscode from 'vscode';
-
 import { toLocation, toRange } from '../omnisharp/typeConvertion';
-
 import AbstractProvider from './abstractProvider';
 import { OmniSharpServer } from '../omnisharp/server';
 import { Options } from '../omnisharp/options';
 import TestManager from './dotnetTest';
-import CompositeDisposable from '../CompositeDisposable';
+import OptionProvider from '../observers/OptionProvider';
 
 class OmniSharpCodeLens extends vscode.CodeLens {
 
@@ -27,19 +25,9 @@ class OmniSharpCodeLens extends vscode.CodeLens {
 
 export default class OmniSharpCodeLensProvider extends AbstractProvider implements vscode.CodeLensProvider {
 
-    private _options: Options;
-
-    constructor(server: OmniSharpServer, testManager: TestManager) {
+    constructor(server: OmniSharpServer, testManager: TestManager, private optionProvider: OptionProvider) {
         super(server);
 
-        this._resetCachedOptions();
-
-        let configChangedDisposable = vscode.workspace.onDidChangeConfiguration(this._resetCachedOptions, this);
-        this.addDisposables(new CompositeDisposable(configChangedDisposable));
-    }
-
-    private _resetCachedOptions(): void {
-        this._options = Options.Read(vscode);
     }
 
     private static filteredSymbolNames: { [name: string]: boolean } = {
@@ -50,37 +38,38 @@ export default class OmniSharpCodeLensProvider extends AbstractProvider implemen
     };
 
     async provideCodeLenses(document: vscode.TextDocument, token: vscode.CancellationToken) {
-        if (!this._options.showReferencesCodeLens && !this._options.showTestsCodeLens) {
+        let options = this.optionProvider.GetLatestOptions();
+        if (!options.showReferencesCodeLens && !options.showTestsCodeLens) {
             return [];
         }
 
         let tree = await serverUtils.currentFileMembersAsTree(this._server, { FileName: document.fileName }, token);
         let ret: vscode.CodeLens[] = [];
 
         for (let node of tree.TopLevelTypeDefinitions) {
-            await this._convertQuickFix(ret, document.fileName, node);
+            await this._convertQuickFix(ret, document.fileName, node, options);
         }
 
         return ret;
     }
 
 
-    private async _convertQuickFix(bucket: vscode.CodeLens[], fileName: string, node: protocol.Node): Promise<void> {
+    private async _convertQuickFix(bucket: vscode.CodeLens[], fileName: string, node: protocol.Node, options: Options): Promise<void> {
 
         if (node.Kind === 'MethodDeclaration' && OmniSharpCodeLensProvider.filteredSymbolNames[node.Location.Text]) {
             return;
         }
 
         let lens = new OmniSharpCodeLens(fileName, toRange(node.Location));
-        if (this._options.showReferencesCodeLens) {
+        if (options.showReferencesCodeLens) {
             bucket.push(lens);
         }
 
         for (let child of node.ChildNodes) {
-            this._convertQuickFix(bucket, fileName, child);
+            this._convertQuickFix(bucket, fileName, child, options);
         }
 
-        if (this._options.showTestsCodeLens) {
+        if (options.showTestsCodeLens) {
             await this._updateCodeLensForTest(bucket, fileName, node);
         }
     }

src/features/commands.ts

@@ -18,10 +18,11 @@ import { CommandShowOutput, CommandDotNetRestoreStart, CommandDotNetRestoreProgr
 import { EventStream } from '../EventStream';
 import { PlatformInformation } from '../platform';
 import CompositeDisposable from '../CompositeDisposable';
+import OptionProvider from '../observers/OptionProvider';
 
-export default function registerCommands(server: OmniSharpServer, eventStream: EventStream, platformInfo: PlatformInformation): CompositeDisposable {
+export default function registerCommands(server: OmniSharpServer, platformInfo: PlatformInformation, eventStream: EventStream, optionProvider: OptionProvider): CompositeDisposable {
     let d1 = vscode.commands.registerCommand('o.restart', () => restartOmniSharp(server));
-    let d2 = vscode.commands.registerCommand('o.pickProjectAndStart', () => pickProjectAndStart(server));
+    let d2 = vscode.commands.registerCommand('o.pickProjectAndStart', async () => pickProjectAndStart(server, optionProvider));
     let d3 = vscode.commands.registerCommand('o.showOutput', () => eventStream.post(new CommandShowOutput()));
     let d4 = vscode.commands.registerCommand('dotnet.restore', fileName => {
         if (fileName) {
@@ -63,9 +64,9 @@ function restartOmniSharp(server: OmniSharpServer) {
     }
 }
 
-function pickProjectAndStart(server: OmniSharpServer) {
-
-    return findLaunchTargets().then(targets => {
+async function pickProjectAndStart(server: OmniSharpServer, optionProvider: OptionProvider) {
+    let options = optionProvider.GetLatestOptions();
+    return findLaunchTargets(options).then(targets => {
 
         let currentPath = server.getSolutionPathOrFolder();
         if (currentPath) {

src/main.ts

@@ -28,9 +28,10 @@ import TelemetryReporter from 'vscode-extension-telemetry';
 import { addJSONProviders } from './features/json/jsonContributions';
 import { ProjectStatusBarObserver } from './observers/ProjectStatusBarObserver';
 import CSharpExtensionExports from './CSharpExtensionExports';
-import { Options } from './omnisharp/options';
 import { vscodeNetworkSettingsProvider, NetworkSettingsProvider } from './NetworkSettings';
 import { ErrorMessageObserver } from './observers/ErrorMessageObserver';
+import OptionStream from './observables/OptionStream';
+import  OptionProvider from './observers/OptionProvider';
 
 export async function activate(context: vscode.ExtensionContext): Promise<CSharpExtensionExports> {
 
@@ -43,6 +44,8 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     util.setExtensionPath(extension.extensionPath);
 
     const eventStream = new EventStream();
+    const optionStream = new OptionStream(vscode);
+    let optionProvider = new OptionProvider(optionStream);
 
     let dotnetChannel = vscode.window.createOutputChannel('.NET');
     let dotnetChannelObserver = new DotNetChannelObserver(dotnetChannel);
@@ -62,7 +65,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(vscode).disableMSBuildDiagnosticWarning || false);
+    let warningMessageObserver = new WarningMessageObserver(vscode, () => optionProvider.GetLatestOptions().disableMSBuildDiagnosticWarning || false);
     eventStream.subscribe(warningMessageObserver.post);
 
     let informationMessageObserver = new InformationMessageObserver(vscode);
@@ -98,16 +101,18 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
 
     let networkSettingsProvider = vscodeNetworkSettingsProvider(vscode);
     let runtimeDependenciesExist = await ensureRuntimeDependencies(extension, eventStream, platformInfo, networkSettingsProvider);
-    
+
     // activate language services
-    let omniSharpPromise = OmniSharp.activate(context, eventStream, extension.packageJSON, platformInfo, networkSettingsProvider);
+    let omniSharpPromise = OmniSharp.activate(context, extension.packageJSON, platformInfo, networkSettingsProvider, eventStream, optionProvider);
 
     // register JSON completion & hover providers for project.json
     context.subscriptions.push(addJSONProviders());
     context.subscriptions.push(vscode.window.onDidChangeActiveTextEditor(() => {
         eventStream.post(new ActiveTextEditorChanged());
     }));
 
+    context.subscriptions.push(optionStream);
+
     let coreClrDebugPromise = Promise.resolve();
     if (runtimeDependenciesExist) {
         // activate coreclr-debug
@@ -123,7 +128,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<CSharp
     };
 }
 
-async function ensureRuntimeDependencies(extension: vscode.Extension<CSharpExtensionExports>, eventStream: EventStream, platformInfo: PlatformInformation, networkSettingsProvider : NetworkSettingsProvider): Promise<boolean> {
+async function ensureRuntimeDependencies(extension: vscode.Extension<CSharpExtensionExports>, eventStream: EventStream, platformInfo: PlatformInformation, networkSettingsProvider: NetworkSettingsProvider): Promise<boolean> {
     return util.installFileExists(util.InstallFileType.Lock)
         .then(exists => {
             if (!exists) {

src/observables/OptionStream.ts

@@ -0,0 +1,34 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Options } from "../omnisharp/options";
+import { vscode } from "../vscodeAdapter";
+import 'rxjs/add/operator/take';
+import { BehaviorSubject } from 'rxjs/BehaviorSubject';
+import Disposable, { IDisposable } from "../Disposable";
+import { Subject } from "rxjs/Subject";
+
+export default class OptionStream {
+    private optionStream: Subject<Options>;
+    private disposable: IDisposable;
+
+    constructor(vscode: vscode) {
+        this.optionStream = new BehaviorSubject<Options>(Options.Read(vscode));
+        this.disposable = vscode.workspace.onDidChangeConfiguration(e => {
+            //if the omnisharp or csharp configuration are affected only then read the options
+            if (e.affectsConfiguration('omnisharp') || e.affectsConfiguration('csharp')) {
+                this.optionStream.next(Options.Read(vscode));
+            }
+        });
+    }
+
+    public dispose = () => {
+        this.disposable.dispose();
+    }
+
+    public subscribe(observer: (options: Options) => void): Disposable {
+        return new Disposable(this.optionStream.subscribe(observer));
+    }
+}

src/observers/OptionProvider.ts

@@ -0,0 +1,22 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { Options } from "../omnisharp/options";
+import OptionStream from "../observables/OptionStream";
+
+export default class OptionProvider {
+    private options: Options;
+
+    constructor(optionStream: OptionStream) {
+        optionStream.subscribe(options => this.options = options);
+    }
+
+    public GetLatestOptions(): Options {
+        if (!this.options) {
+            throw new Error("Error reading OmniSharp options");
+        }
+        return this.options;
+    }
+}

src/omnisharp/extension.ts

@@ -20,7 +20,6 @@ import FormatProvider from '../features/formattingEditProvider';
 import HoverProvider from '../features/hoverProvider';
 import ImplementationProvider from '../features/implementationProvider';
 import { OmniSharpServer } from './server';
-import { Options } from './options';
 import ReferenceProvider from '../features/referenceProvider';
 import RenameProvider from '../features/renameProvider';
 import SignatureHelpProvider from '../features/signatureHelpProvider';
@@ -34,21 +33,22 @@ import { EventStream } from '../EventStream';
 import { NetworkSettingsProvider } from '../NetworkSettings';
 import CompositeDisposable from '../CompositeDisposable';
 import Disposable from '../Disposable';
+import OptionProvider from '../observers/OptionProvider';
 
 export let omnisharp: OmniSharpServer;
 
-export async function activate(context: vscode.ExtensionContext, eventStream: EventStream, packageJSON: any, platformInfo: PlatformInformation, provider: NetworkSettingsProvider) {
+export async function activate(context: vscode.ExtensionContext, packageJSON: any, platformInfo: PlatformInformation, provider: NetworkSettingsProvider, eventStream: EventStream, optionProvider: OptionProvider) {
     const documentSelector: vscode.DocumentSelector = {
         language: 'csharp',
         scheme: 'file' // only files from disk
     };
 
-    const options = Options.Read(vscode);
-    const server = new OmniSharpServer(vscode, provider, eventStream, packageJSON, platformInfo);
+    const options = optionProvider.GetLatestOptions();
+    const server = new OmniSharpServer(vscode, provider, packageJSON, platformInfo, eventStream, optionProvider);
     omnisharp = server;
     const advisor = new Advisor(server); // create before server is started
     const disposables = new CompositeDisposable();
-    let localDisposables : CompositeDisposable;
+    let localDisposables: CompositeDisposable;
 
     disposables.add(server.onServerStart(() => {
         // register language feature provider on start
@@ -62,7 +62,7 @@ export async function activate(context: vscode.ExtensionContext, eventStream: Ev
         localDisposables.add(vscode.languages.registerImplementationProvider(documentSelector, new ImplementationProvider(server)));
         const testManager = new TestManager(server, eventStream);
         localDisposables.add(testManager);
-        localDisposables.add(vscode.languages.registerCodeLensProvider(documentSelector, new CodeLensProvider(server, testManager)));
+        localDisposables.add(vscode.languages.registerCodeLensProvider(documentSelector, new CodeLensProvider(server, testManager, optionProvider)));
         localDisposables.add(vscode.languages.registerDocumentHighlightProvider(documentSelector, new DocumentHighlightProvider(server)));
         localDisposables.add(vscode.languages.registerDocumentSymbolProvider(documentSelector, new DocumentSymbolProvider(server)));
         localDisposables.add(vscode.languages.registerReferenceProvider(documentSelector, new ReferenceProvider(server)));
@@ -75,7 +75,7 @@ export async function activate(context: vscode.ExtensionContext, eventStream: Ev
         localDisposables.add(vscode.languages.registerCompletionItemProvider(documentSelector, new CompletionItemProvider(server), '.', ' '));
         localDisposables.add(vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(server)));
         localDisposables.add(vscode.languages.registerSignatureHelpProvider(documentSelector, new SignatureHelpProvider(server), '(', ','));
-        const codeActionProvider = new CodeActionProvider(server);
+        const codeActionProvider = new CodeActionProvider(server, optionProvider);
         localDisposables.add(codeActionProvider);
         localDisposables.add(vscode.languages.registerCodeActionsProvider(documentSelector, codeActionProvider));
         localDisposables.add(reportDiagnostics(server, advisor));
@@ -90,7 +90,7 @@ export async function activate(context: vscode.ExtensionContext, eventStream: Ev
         localDisposables = null;
     }));
 
-    disposables.add(registerCommands(server, eventStream,platformInfo));
+    disposables.add(registerCommands(server, platformInfo, eventStream, optionProvider));
 
     if (!context.workspaceState.get<boolean>('assetPromptDisabled')) {
         disposables.add(server.onServerStart(() => {
@@ -164,7 +164,7 @@ export async function activate(context: vscode.ExtensionContext, eventStream: Ev
 
     context.subscriptions.push(disposables);
 
-    return new Promise<OmniSharpServer>(resolve => 
-        server.onServerStart(e => 
-            resolve(server))); 
+    return new Promise<OmniSharpServer>(resolve =>
+        server.onServerStart(e =>
+            resolve(server)));
 }

src/omnisharp/launcher.ts

@@ -36,13 +36,11 @@ export interface LaunchTarget {
  * (if it doesn't contain a `project.json` file, but `project.json` files exist). In addition, the root folder
  * is included if there are any `*.csproj` files present, but a `*.sln* file is not found.
  */
-export function findLaunchTargets(): Thenable<LaunchTarget[]> {
+export function findLaunchTargets(options: Options): Thenable<LaunchTarget[]> {
     if (!vscode.workspace.workspaceFolders) {
         return Promise.resolve([]);
     }
 
-    const options = Options.Read(vscode);
-
     return vscode.workspace.findFiles(
             /*include*/ '{**/*.sln,**/*.csproj,**/project.json,**/*.csx,**/*.cake}',
             /*exclude*/ '{**/node_modules/**,**/.git/**,**/bower_components/**}',