Merge branch 'master' into patch-1

Author: JoeRobich

package-lock.json

@@ -91,12 +91,12 @@
     "@types/gulp": "4.0.5",
     "@types/minimist": "1.2.1",
     "@types/mocha": "5.2.5",
-    "@types/node": "10.12.24",
+    "@types/node": "16.11.38",
     "@types/semver": "5.5.0",
     "@types/tmp": "0.0.33",
     "@types/unzipper": "^0.9.1",
     "@types/vscode": "1.66.0",
-    "@types/yauzl": "2.9.1",
+    "@types/yauzl": "2.10.0",
     "@vscode/test-electron": "2.1.3",
     "archiver": "5.3.0",
     "chai": "4.3.4",
@@ -4095,4 +4095,4 @@
       }
     ]
   }
-}
+}

package.json

@@ -62,6 +62,7 @@ export default class CodeActionProvider extends AbstractProvider implements vsco
 
                 return {
                     title: codeAction.Name,
+                    kind: this.mapOmniSharpCodeActionKindToVSCodeCodeActionKind(codeAction.CodeActionKind),
                     command: {
                         title: codeAction.Name,
                         command: this._commandId,
@@ -74,6 +75,21 @@ export default class CodeActionProvider extends AbstractProvider implements vsco
         }
     }
 
+    private mapOmniSharpCodeActionKindToVSCodeCodeActionKind(kind: string): vscode.CodeActionKind {
+        switch (kind) {
+            case 'QuickFix':
+                return vscode.CodeActionKind.QuickFix;
+            case 'Refactor':
+                return vscode.CodeActionKind.Refactor;
+            case 'RefactorExtract':
+                return vscode.CodeActionKind.RefactorExtract;
+            case 'RefactorInline':
+                return vscode.CodeActionKind.RefactorInline;
+            default:
+                return vscode.CodeActionKind.Empty;
+        }
+    }
+
     private async _runCodeAction(req: protocol.V2.RunCodeActionRequest, token: vscode.CancellationToken): Promise<boolean | string | {}> {
         try {
             const response = await serverUtils.runCodeAction(this._server, req);

src/features/codeActionProvider.ts

@@ -6,11 +6,18 @@
 import AbstractSupport from './abstractProvider';
 import * as protocol from '../omnisharp/protocol';
 import * as serverUtils from '../omnisharp/utils';
-import {createRequest, toLocation} from '../omnisharp/typeConversion';
+import {createRequest, toLocation, toLocationFromUri} from '../omnisharp/typeConversion';
 import {ReferenceProvider, Location, TextDocument, CancellationToken, Position} from 'vscode';
+import { OmniSharpServer } from '../omnisharp/server';
+import { LanguageMiddlewareFeature } from '../omnisharp/LanguageMiddlewareFeature';
+import SourceGeneratedDocumentProvider from './sourceGeneratedDocumentProvider';
 
 export default class OmnisharpReferenceProvider extends AbstractSupport implements ReferenceProvider {
 
+    public constructor(server: OmniSharpServer, languageMiddlewareFeature: LanguageMiddlewareFeature, private generatedDocumentProvider: SourceGeneratedDocumentProvider) {
+        super(server, languageMiddlewareFeature);
+    }
+
     public async provideReferences(document: TextDocument, position: Position, options: { includeDeclaration: boolean;}, token: CancellationToken): Promise<Location[]> {
 
         let req = createRequest<protocol.FindUsagesRequest>(document, position);
@@ -20,8 +27,8 @@ export default class OmnisharpReferenceProvider extends AbstractSupport implemen
         try {
             let res = await serverUtils.findUsages(this._server, req, token);
             if (res && Array.isArray(res.QuickFixes)) {
-                const references = res.QuickFixes.map(toLocation);
-                
+                const references = res.QuickFixes.map(l => this.mapToLocationWithGeneratedInfoPopulation(l));
+
                 // Allow language middlewares to re-map its edits if necessary.
                 const result = await this._languageMiddlewareFeature.remap("remapLocations", references, token);
                 return result;
@@ -31,4 +38,13 @@ export default class OmnisharpReferenceProvider extends AbstractSupport implemen
             return [];
         }
     }
+
+    private mapToLocationWithGeneratedInfoPopulation(symbolLocation: protocol.SymbolLocation): Location {
+        if (symbolLocation.GeneratedFileInfo) {
+            const uri = this.generatedDocumentProvider.addSourceGeneratedFileWithoutInitialContent(symbolLocation.GeneratedFileInfo, symbolLocation.FileName);
+            return toLocationFromUri(uri, symbolLocation);
+        }
+
+        return toLocation(symbolLocation);
+    }
 }

src/features/referenceProvider.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as serverUtils from '../omnisharp/utils';
-import { Event, EventEmitter, TextDocument, TextDocumentContentProvider, TextEditor, Uri, window, workspace } from 'vscode';
+import { CancellationToken, Event, EventEmitter, TextDocument, TextDocumentContentProvider, TextEditor, Uri, window, workspace } from 'vscode';
 import { IDisposable } from '../Disposable';
 import { SourceGeneratedFileInfo, SourceGeneratedFileResponse, UpdateType } from '../omnisharp/protocol';
 import { OmniSharpServer } from '../omnisharp/server';
@@ -89,6 +89,27 @@ export default class SourceGeneratedDocumentProvider implements TextDocumentCont
         return undefined;
     }
 
+    public addSourceGeneratedFileWithoutInitialContent(fileInfo: SourceGeneratedFileInfo, fileName: string): Uri {
+        if (this._documents.has(fileInfo)) {
+            // Raced with something, return the existing one
+            return this.tryGetExistingSourceGeneratedFile(fileInfo);
+        }
+
+        const uri = this.getUriForName(fileName);
+        const uriString = uri.toString();
+
+        if (this._uriToDocumentInfo.has(uriString)) {
+            this._documents.delete(fileInfo);
+            this._uriToDocumentInfo.delete(uriString);
+        }
+
+        // Provide will see the null and retrieve the file when asked.
+        this._documents.set(fileInfo, null);
+        this._uriToDocumentInfo.set(uriString, fileInfo);
+
+        return uri;
+    }
+
     public addSourceGeneratedFile(fileInfo: SourceGeneratedFileInfo, response: SourceGeneratedFileResponse): Uri {
         if (this._documents.has(fileInfo)) {
             // Raced with something, return the existing one
@@ -117,8 +138,17 @@ export default class SourceGeneratedDocumentProvider implements TextDocumentCont
         return uri;
     }
 
-    public provideTextDocumentContent(uri: Uri): string {
-        return this._documents.get(this._uriToDocumentInfo.get(uri.toString())).Source;
+    public async provideTextDocumentContent(uri: Uri, token: CancellationToken): Promise<string> {
+        const fileInfo = this._uriToDocumentInfo.get(uri.toString());
+        let response = this._documents.get(fileInfo);
+
+        if (response === null) {
+            // No content yet, get it
+            response = await serverUtils.getSourceGeneratedFile(this.server, fileInfo, token);
+            this._documents.set(fileInfo, response);
+        }
+
+        return response.Source;
     }
 
     private getUriForName(sourceName: string): Uri {

src/features/sourceGeneratedDocumentProvider.ts

@@ -9,13 +9,18 @@ import OptionProvider from '../observers/OptionProvider';
 import * as protocol from '../omnisharp/protocol';
 import * as serverUtils from '../omnisharp/utils';
 import { toRange } from '../omnisharp/typeConversion';
-import { CancellationToken, Uri, WorkspaceSymbolProvider, SymbolInformation, SymbolKind } from 'vscode';
+import { CancellationToken, Uri, WorkspaceSymbolProvider, SymbolInformation, SymbolKind, Location } from 'vscode';
 import { LanguageMiddlewareFeature } from '../omnisharp/LanguageMiddlewareFeature';
+import SourceGeneratedDocumentProvider from './sourceGeneratedDocumentProvider';
 
 
 export default class OmnisharpWorkspaceSymbolProvider extends AbstractSupport implements WorkspaceSymbolProvider {
 
-    constructor(server: OmniSharpServer, private optionProvider: OptionProvider, languageMiddlewareFeature: LanguageMiddlewareFeature) {
+    constructor(
+        server: OmniSharpServer,
+        private optionProvider: OptionProvider,
+        languageMiddlewareFeature: LanguageMiddlewareFeature,
+        private sourceGeneratedDocumentProvider: SourceGeneratedDocumentProvider) {
         super(server, languageMiddlewareFeature);
     }
 
@@ -32,19 +37,30 @@ export default class OmnisharpWorkspaceSymbolProvider extends AbstractSupport im
         try {
             let res = await serverUtils.findSymbols(this._server, { Filter: search, MaxItemsToReturn: maxItemsToReturn, FileName: '' }, token);
             if (res && Array.isArray(res.QuickFixes)) {
-                return res.QuickFixes.map(OmnisharpWorkspaceSymbolProvider._asSymbolInformation);
+                return res.QuickFixes.map(symbol => this._asSymbolInformation(symbol));
             }
         }
         catch (error) {
             return [];
         }
     }
 
-    private static _asSymbolInformation(symbolInfo: protocol.SymbolLocation): SymbolInformation {
+    private _asSymbolInformation(symbolInfo: protocol.SymbolLocation): SymbolInformation {
+        let uri: Uri;
+        if (symbolInfo.GeneratedFileInfo) {
+            uri = this.sourceGeneratedDocumentProvider.addSourceGeneratedFileWithoutInitialContent(symbolInfo.GeneratedFileInfo, symbolInfo.FileName);
+        }
+        else {
+            uri = Uri.file(symbolInfo.FileName);
+        }
+
+        const location = new Location(uri, toRange(symbolInfo));
 
-        return new SymbolInformation(symbolInfo.Text, OmnisharpWorkspaceSymbolProvider._toKind(symbolInfo),
-            toRange(symbolInfo),
-            Uri.file(symbolInfo.FileName));
+        return new SymbolInformation(
+            symbolInfo.Text,
+            OmnisharpWorkspaceSymbolProvider._toKind(symbolInfo),
+            symbolInfo.ContainingSymbolName ?? "",
+            location);
     }
 
     private static _toKind(symbolInfo: protocol.SymbolLocation): SymbolKind {

src/features/workspaceSymbolProvider.ts

@@ -15,12 +15,11 @@ export class BackgroundWorkStatusBarObserver extends BaseStatusBarItemObserver {
 
             if (asProjectEvent.message.Status === DiagnosticStatus.Processing) {
                 let projectFile = asProjectEvent.message.ProjectFilePath.replace(/^.*[\\\/]/, '');
-                this.SetAndShowStatusBar(`$(sync~spin) Analyzing ${projectFile}`, 'o.showOutput', null, `Analyzing ${projectFile}`);
+                this.SetAndShowStatusBar(`$(sync~spin) Analyzing ${projectFile}`, 'o.showOutput', undefined, `Analyzing ${projectFile}`);
             }
             else {
                 this.ResetAndHideStatusBar();
             }
         }
     }
 }
-

src/observers/BackgroundWorkStatusBarObserver.ts

@@ -20,12 +20,12 @@ export abstract class BaseStatusBarItemObserver {
     }
 
     public ResetAndHideStatusBar() {
-        this.statusBarItem.text = undefined;
+        this.statusBarItem.text = '';
         this.statusBarItem.command = undefined;
         this.statusBarItem.color = undefined;
         this.statusBarItem.tooltip = undefined;
         this.statusBarItem.hide();
     }
 
     abstract post: (event: BaseEvent) => void;
-}
+}

src/observers/BaseStatusBarItemObserver.ts

@@ -9,7 +9,7 @@ import { PackageError } from "../packageManager/PackageError";
 import { EventType } from "../omnisharp/EventType";
 
 export class CsharpLoggerObserver extends BaseLoggerObserver {
-    private dots: number;
+    private dots: number = 0;
 
     public post = (event: Event.BaseEvent) => {
         switch (event.type) {
@@ -146,4 +146,4 @@ export class CsharpLoggerObserver extends BaseLoggerObserver {
     private handleDocumentSynchronizationFailure(event: Event.DocumentSynchronizationFailure) {
         this.logger.appendLine(`Failed to synchronize document '${event.documentPath}': ${event.errorMessage}`);
     }
-}
+}

src/observers/CsharpLoggerObserver.ts

@@ -83,7 +83,7 @@ export class OmnisharpLoggerObserver extends BaseLoggerObserver {
         this.logger.append(`OmniSharp server started`);
         if (event.hostVersion) {
             this.logger.append(` with ${event.hostIsMono ? 'Mono' : '.NET'} ${event.hostVersion}`);
-            if (event.hostPath?.length > 0) {
+            if (event.hostPath && event.hostPath.length > 0) {
                 this.logger.append(` (${event.hostPath})`);
             }
         }