feat(lsp): drop untagged hint diagnostics, style unused/deprecated code

Hint-severity (4) LSP diagnostics without tags are refactoring
suggestions (e.g. tsserver's "File is a CommonJS module; it may be
converted to an ES module") - drop them in the publishDiagnostics path
so they never reach the problems panel or the quickfix layer.

Tagged hints stay: unused symbols (tag Unnecessary) and deprecated
usages (tag Deprecated) keep their panel row and squiggle, and now
additionally render faded / struck-through in the editor via new
editor-text-fragment-unnecessary/-deprecated mark classes applied from
the diagnostic tags.

Specs: tagged hints survive with panel rows + text marks; the untagged
CommonJS suggestion never comes through (publish-level capture).

Author: abose

src/extensions/default/TypeScriptSupport/unittests.js

@@ -18,7 +18,7 @@
  *
  */
 
-/*global describe, it, expect, beforeAll, afterAll, afterEach, awaitsFor, awaitsForDone, path, jsPromise */
+/*global describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, awaitsFor, awaitsForDone, path, jsPromise */
 
 define(function (require, exports, module) {
 
@@ -864,5 +864,87 @@ define(function (require, exports, module) {
                 }, "parameter hint popup to show again", 30000);
             }, 90000);
         });
+
+        // ----- hint-severity diagnostics: untagged suggestions dropped, tagged ones styled -----
+        describe("hint diagnostics and tags", function () {
+            let publishedByFile;
+            let origSetInspectionResults;
+
+            beforeAll(function () {
+                // Capture what actually reaches the linting layer (post the LSPClient hint filter)
+                // so the specs can await/assert on publishes deterministically instead of relying
+                // only on problems-panel text.
+                const DefaultProviders = testWindow.require("languageTools/DefaultProviders");
+                const proto = DefaultProviders.LintingProvider.prototype;
+                publishedByFile = {};
+                origSetInspectionResults = proto.setInspectionResults;
+                proto.setInspectionResults = function (msgObj) {
+                    const name = msgObj.uri.substring(msgObj.uri.lastIndexOf("/") + 1);
+                    publishedByFile[name] = publishedByFile[name] || [];
+                    publishedByFile[name].push(msgObj.diagnostics || []);
+                    return origSetInspectionResults.call(this, msgObj);
+                };
+            });
+
+            afterAll(function () {
+                const DefaultProviders = testWindow.require("languageTools/DefaultProviders");
+                DefaultProviders.LintingProvider.prototype.setInspectionResults = origSetInspectionResults;
+            });
+
+            beforeEach(async function () {
+                // Isolate from whatever earlier specs left behind (dirty documents, an open
+                // parameter-hint popup, stale panel state).
+                await awaitsForDone(CommandManager.execute(Commands.FILE_CLOSE_ALL, { _forceClose: true }),
+                    "close all files");
+            });
+
+            it("should keep tagged hints (unused/deprecated) in the panel and style the text", async function () {
+                await _openInProject("ts/", "type-error.ts");
+                const editor = EditorManager.getActiveEditor();
+                editor.document.setText(
+                    "const unusedVar: number = 1;\n" +
+                    "/** @deprecated use newFn */\n" +
+                    "function oldFn(): number { return 1; }\n" +
+                    "oldFn();\n" +
+                    "export {};\n"
+                );
+                // tagged hints (unused tag 1, deprecated tag 2) must survive the hint filter
+                await awaitsFor(function () {
+                    const all = (publishedByFile["type-error.ts"] || []).flat();
+                    return all.some(function (d) { return d.tags && d.tags.indexOf(1) !== -1; }) &&
+                        all.some(function (d) { return d.tags && d.tags.indexOf(2) !== -1; });
+                }, "tagged unused + deprecated diagnostics to be published", 30000);
+                await awaitsFor(function () {
+                    return panelText().includes("never read") && panelText().includes("deprecated");
+                }, "unused + deprecated hint rows in the problems panel", 30000);
+                // the marked text carries the tag styles on top of the info squiggle
+                await awaitsFor(function () {
+                    return $(".editor-text-fragment-unnecessary").length > 0 &&
+                        $(".editor-text-fragment-deprecated").length > 0;
+                }, "faded + strikethrough text marks in the editor", 30000);
+            }, 90000);
+
+            it("should drop untagged hint suggestions like the CommonJS to ESM nag", async function () {
+                await _openInProject("js-plain/", "implicit.js");
+                const editor = EditorManager.getActiveEditor();
+                const publishesBeforeEdit = (publishedByFile["implicit.js"] || []).length;
+                // "require(" is concatenated so RequireJS's static dependency scan of this module's
+                // source doesn't read the string literal as an AMD dependency named "http" - that
+                // fails the whole file's load and silently unregisters every suite in it.
+                const requireCall = "require";
+                editor.document.setText("const http = " + requireCall + "('http');\nconsole.log(http);\n");
+                // the server re-publishes (possibly empty) diagnostics after the edit - wait for
+                // one, then assert the untagged 80001 CommonJS suggestion never came through
+                await awaitsFor(function () {
+                    return (publishedByFile["implicit.js"] || []).length > publishesBeforeEdit;
+                }, "a diagnostics publish for implicit.js after the edit", 30000);
+                const all = (publishedByFile["implicit.js"] || []).flat();
+                expect(all.some(function (d) { return d.message.indexOf("CommonJS") !== -1; })).toBe(false);
+                expect(all.some(function (d) {
+                    return d.severity === 4 && !(d.tags && d.tags.length);
+                })).toBe(false);
+                expect(panelText().includes("CommonJS")).toBe(false);
+            }, 90000);
+        });
     });
 });

src/language/CodeInspection.js

@@ -423,11 +423,24 @@ define(function (require, exports, module) {
     }
 
     function _getMarkOptions(error){
+        let options;
         switch (error.type) {
-        case Type.ERROR: return Editor.getMarkOptionUnderlineError();
-        case Type.WARNING: return Editor.getMarkOptionUnderlineWarn();
-        case Type.META: return Editor.getMarkOptionUnderlineInfo();
+        case Type.ERROR: options = Editor.getMarkOptionUnderlineError(); break;
+        case Type.WARNING: options = Editor.getMarkOptionUnderlineWarn(); break;
+        case Type.META: options = Editor.getMarkOptionUnderlineInfo(); break;
         }
+        // LSP DiagnosticTag values on the error (1 Unnecessary - unused symbol, 2 Deprecated)
+        // add a text style on top of the squiggle: faded for unused, strikethrough for
+        // deprecated. Panel row and squiggle treatment stay unchanged.
+        if (options && Array.isArray(error.tags)) {
+            if (error.tags.indexOf(1) !== -1) {
+                options.className += " editor-text-fragment-unnecessary";
+            }
+            if (error.tags.indexOf(2) !== -1) {
+                options.className += " editor-text-fragment-deprecated";
+            }
+        }
+        return options;
     }
 
     function _getMarkTypePriority(type){

src/languageTools/DefaultProviders.js

@@ -943,7 +943,10 @@ define(function (require, exports, module) {
                     ch: obj.range.end.character
                 },
                 message: obj.message,
-                type: (obj.severity === 1 ? CodeInspection.Type.ERROR : (obj.severity === 2 ? CodeInspection.Type.WARNING : CodeInspection.Type.META))
+                type: (obj.severity === 1 ? CodeInspection.Type.ERROR : (obj.severity === 2 ? CodeInspection.Type.WARNING : CodeInspection.Type.META)),
+                // LSP DiagnosticTag values (1 Unnecessary, 2 Deprecated) - CodeInspection styles
+                // the marked text off these (faded / strikethrough) on top of the squiggle.
+                tags: obj.tags
             };
         });
 

src/languageTools/LSPClient.js

@@ -212,6 +212,14 @@ define(function (require, exports, module) {
             if (filterFn && diagnostics.length) {
                 diagnostics = filterFn(diagnostics, { languageId: langId, filePath: vfsPath });
             }
+            // Severity 4 (Hint) without tags is a refactoring suggestion (e.g. tsserver's "File is
+            // a CommonJS module; it may be converted to an ES module") - noise in a problems panel,
+            // so drop it (this also drops its quickfix). Tagged hints stay: tag 1 Unnecessary
+            // (unused symbol) and tag 2 Deprecated are real signal - they keep their panel row and
+            // squiggle, and additionally drive the faded/strikethrough text styling.
+            diagnostics = diagnostics.filter(function (d) {
+                return d.severity !== 4 || (d.tags && d.tags.length);
+            });
             client.lintingProvider.setInspectionResults({
                 uri: vfsUri,
                 diagnostics: diagnostics

src/styles/brackets.less

@@ -217,6 +217,17 @@ html, body {
     background: url('images/wavy-info.svg') repeat-x bottom left;
 }
 
+// LSP DiagnosticTag text styles, added on top of the squiggle classes above:
+// unused symbols (tag Unnecessary) render faded, deprecated usages (tag Deprecated)
+// render struck through.
+.editor-text-fragment-unnecessary {
+    opacity: 0.6;
+}
+
+.editor-text-fragment-deprecated {
+    text-decoration: line-through;
+}
+
 .hidden-element{
     display: none !important;
 }