Fadeout based on roslyn tag 'unnecessary'.

src/features/diagnosticsProvider.ts

@@ -236,7 +236,7 @@ class DiagnosticsProvider extends AbstractSupport {
         let handle = setTimeout(async () => {
             try {
                 let value = await serverUtils.codeCheck(this._server, { FileName: document.fileName }, source.token);
-                let quickFixes = value.QuickFixes.filter(DiagnosticsProvider._shouldInclude);
+                let quickFixes = value.QuickFixes;
                 // Easy case: If there are no diagnostics in the file, we can clear it quickly.
                 if (quickFixes.length === 0) {
                     if (this._diagnostics.has(document.uri)) {
@@ -247,8 +247,9 @@ class DiagnosticsProvider extends AbstractSupport {
                 }
 
                 // (re)set new diagnostics for this document
-                let diagnostics = quickFixes.map(DiagnosticsProvider._asDiagnostic);
-                this._diagnostics.set(document.uri, diagnostics);
+                let diagnostics = this._mapQuickFixesAsDiagnostics(quickFixes);
+
+                this._diagnostics.set(document.uri, diagnostics.map(x => x.diag));
             }
             catch (error) {
                 return;
@@ -259,6 +260,13 @@ class DiagnosticsProvider extends AbstractSupport {
         this._documentValidations[key] = source;
     }
 
+    private _mapQuickFixesAsDiagnostics(quickFixes: protocol.QuickFix[]): { diag: vscode.Diagnostic, fileName: string }[]
+    {
+        return quickFixes
+            .map(qf => ({ diag: this._asDiagnostic(qf), fileName: qf.FileName }))
+            .filter(item => item.diag !== undefined);
+    }
+
     private _validateProject(): void {
         // If we've already started computing for this project, cancel that work.
         if (this._projectValidation) {
@@ -275,25 +283,22 @@ class DiagnosticsProvider extends AbstractSupport {
                 let value = await serverUtils.codeCheck(this._server, { FileName: null }, this._projectValidation.token);
 
                 let quickFixes = value.QuickFixes
-                    .filter(DiagnosticsProvider._shouldInclude)
                     .sort((a, b) => a.FileName.localeCompare(b.FileName));
 
                 let entries: [vscode.Uri, vscode.Diagnostic[]][] = [];
                 let lastEntry: [vscode.Uri, vscode.Diagnostic[]];
 
-                for (let quickFix of quickFixes) {
-
-                    let diag = DiagnosticsProvider._asDiagnostic(quickFix);
-                    let uri = vscode.Uri.file(quickFix.FileName);
+                for (let quickFix of this._mapQuickFixesAsDiagnostics(quickFixes)) {
+                    let uri = vscode.Uri.file(quickFix.fileName);
 
                     if (lastEntry && lastEntry[0].toString() === uri.toString()) {
-                        lastEntry[1].push(diag);
+                        lastEntry[1].push(quickFix.diag);
                     } else {
                         // We're replacing all diagnostics in this file. Pushing an entry with undefined for
                         // the diagnostics first ensures that the previous diagnostics for this file are
                         // cleared. Otherwise, new entries will be merged with the old ones.
                         entries.push([uri, undefined]);
-                        lastEntry = [uri, [diag]];
+                        lastEntry = [uri, [quickFix.diag]];
                         entries.push(lastEntry);
                     }
                 }
@@ -319,36 +324,50 @@ class DiagnosticsProvider extends AbstractSupport {
         });
     }
 
-    private static _shouldInclude(quickFix: protocol.QuickFix): boolean {
-        const config = vscode.workspace.getConfiguration('csharp');
-        if (config.get('suppressHiddenDiagnostics', true)) {
-            return quickFix.LogLevel.toLowerCase() !== 'hidden';
-        } else {
-            return true;
+    private _asDiagnostic(quickFix: protocol.QuickFix): vscode.Diagnostic | undefined {
+        let isFadeout = (quickFix.Tags && !!quickFix.Tags.find(x => x.toLowerCase() == 'unnecessary'));
+
+        let severity = this._asDiagnosticSeverity(quickFix, isFadeout);
+
+        if(severity === undefined)
+        {
+            return undefined;
         }
-    }
 
-    // --- data converter
+        let message = `${quickFix.Text} [${quickFix.Projects.map(n => this._asProjectLabel(n)).join(', ')}]`;
 
-    private static _asDiagnostic(quickFix: protocol.QuickFix): vscode.Diagnostic {
-        let severity = DiagnosticsProvider._asDiagnosticSeverity(quickFix.LogLevel);
-        let message = `${quickFix.Text} [${quickFix.Projects.map(n => DiagnosticsProvider._asProjectLabel(n)).join(', ')}]`;
-        return new vscode.Diagnostic(toRange(quickFix), message, severity);
+        let diagnostic = new vscode.Diagnostic(toRange(quickFix), message, severity);
+
+        if(isFadeout)
+        {
+            diagnostic.tags = [vscode.DiagnosticTag.Unnecessary];
+        }
+
+        return diagnostic;
     }
 
-    private static _asDiagnosticSeverity(logLevel: string): vscode.DiagnosticSeverity {
-        switch (logLevel.toLowerCase()) {
+    private _asDiagnosticSeverity(quickFix: protocol.QuickFix, fadeOut: boolean): vscode.DiagnosticSeverity | undefined {
+        if(fadeOut && quickFix.LogLevel.toLowerCase() === 'hidden' || quickFix.LogLevel.toLowerCase() === 'none')
+        {
+            // Theres no such thing as hidden severity in VSCode,
+            // however roslyn uses commonly analyzer with hidden to fade out things.
+            // Without this any of those doesn't fade anything in vscode.
+            return vscode.DiagnosticSeverity.Hint;
+        }
+
+        switch (quickFix.LogLevel.toLowerCase()) {
             case 'error':
                 return vscode.DiagnosticSeverity.Error;
             case 'warning':
                 return vscode.DiagnosticSeverity.Warning;
-            // info and hidden
-            default:
+            case 'info':
                 return vscode.DiagnosticSeverity.Information;
+            default:
+                return undefined;
         }
     }
 
-    private static _asProjectLabel(projectName: string): string {
+    private _asProjectLabel(projectName: string): string {
         const idx = projectName.indexOf('+');
         return projectName.substr(idx + 1);
     }

src/omnisharp/protocol.ts

@@ -201,6 +201,8 @@ export interface QuickFix {
     EndColumn: number;
     Text: string;
     Projects: string[];
+    Tags: string[];
+    Id: string;
 }
 
 export interface SymbolLocation extends QuickFix {