test: add LSP integration tests for TypeScriptSupport (JS + TS)

Cover the desktop LSP end to end against the real vtsls server:
- a .ts file reports a real type error,
- a JS project that opts into checkJs (jsconfig) shows implicit-any (kept),
- a plain JS project does NOT show implicit-any (suppressed) - with a checkJs
  precondition so the negative assertion reflects gating, not timing.

The tests live in the extension's unittests.js (previously an empty shim) and
follow the standard createTestWindowAndRun + brackets.test.* integration pattern;
they require core modules via brackets.getModule and are gated to the desktop
build (Phoenix.isNativeApp), skipped in the browser. main.js sets a
_TypeScriptSupportReadyToIntegTest flag so the tests can await server startup.
Fixtures are tiny and need no node_modules. Verified 3/3 passing.

Author: abose

src/extensions/default/TypeScriptSupport/main.js

@@ -264,6 +264,9 @@ define(function (require, exports, module) {
         _refreshCheckJs();
         start().catch(function (err) {
             console.error("[TypeScriptSupport] init failed", err && (err.message || err));
+        }).finally(function () {
+            // Signal for integration tests that the server start has been attempted/settled.
+            window._TypeScriptSupportReadyToIntegTest = true;
         });
 
         // Restart the server against the new workspace root when the project changes, and

src/extensions/default/TypeScriptSupport/unittests.js

@@ -0,0 +1,115 @@
+/*
+ * GNU AGPL-3.0 License
+ *
+ * Copyright (c) 2021 - present core.ai . All rights reserved.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see https://opensource.org/licenses/AGPL-3.0.
+ *
+ */
+
+/*global describe, it, expect, beforeAll, afterAll, awaitsFor, awaitsForDone */
+
+define(function (require, exports, module) {
+
+    const SpecRunnerUtils = brackets.getModule("spec/SpecRunnerUtils");
+
+    const IMPLICIT_ANY_MESSAGE = "implicitly has an 'any' type";
+
+    describe("integration:TypeScript LSP", function () {
+        const testRootSpec = "/spec/TypeScriptSupport-test-files/";
+        let testFolder = SpecRunnerUtils.getTestPath(testRootSpec),
+            testWindow,
+            $,
+            EditorManager,
+            CommandManager,
+            Commands,
+            CodeInspection;
+
+        // The LSP runs only in the desktop app (it spawns the vtsls Node process), so these tests
+        // are meaningless in the browser build - register a single skipped placeholder and bail.
+        if (!Phoenix.isNativeApp) {
+            it("is desktop-only - skipped in the browser build", function () {
+                expect(Phoenix.isNativeApp).toBeFalsy();
+            });
+            return;
+        }
+
+        beforeAll(async function () {
+            testWindow = await SpecRunnerUtils.createTestWindowAndRun();
+            $ = testWindow.$;
+            EditorManager = testWindow.brackets.test.EditorManager;
+            CommandManager = testWindow.brackets.test.CommandManager;
+            Commands = testWindow.brackets.test.Commands;
+            CodeInspection = testWindow.brackets.test.CodeInspection;
+            CodeInspection.toggleEnabled(true);
+            // Wait until the extension has attempted to start the language server.
+            await awaitsFor(function () {
+                return testWindow._TypeScriptSupportReadyToIntegTest;
+            }, "TypeScript LSP server to start", 30000);
+        }, 30000);
+
+        afterAll(async function () {
+            testWindow = null;
+            $ = null;
+            EditorManager = null;
+            CommandManager = null;
+            Commands = null;
+            CodeInspection = null;
+            await SpecRunnerUtils.closeTestWindow();
+        }, 30000);
+
+        function panelText() {
+            return $("#problems-panel").text();
+        }
+
+        async function _openInProject(subFolder, fileName) {
+            await SpecRunnerUtils.loadProjectInTestWindow(testFolder + subFolder);
+            await awaitsForDone(SpecRunnerUtils.openProjectFiles([fileName]), "open " + fileName);
+        }
+
+        it("should report TypeScript type errors from the language server", async function () {
+            await _openInProject("ts/", "type-error.ts");
+            // type-error.ts assigns a string to a `number` -> TS2322 "... not assignable ...".
+            await awaitsFor(function () {
+                return panelText().includes("not assignable");
+            }, "TypeScript type error to be reported", 20000);
+        }, 30000);
+
+        it("should report implicit-any in a JS project that opts into checkJs", async function () {
+            // js-checkjs has a jsconfig.json with checkJs + noImplicitAny, so the untyped parameter
+            // in implicit.js IS flagged - and our diagnostic filter keeps it (the project opted in).
+            await _openInProject("js-checkjs/", "implicit.js");
+            await awaitsFor(function () {
+                return panelText().includes(IMPLICIT_ANY_MESSAGE);
+            }, "implicit-any to be reported under checkJs", 20000);
+        }, 30000);
+
+        it("should NOT report implicit-any in a plain JS project", async function () {
+            // Precondition: confirm the server actually produces implicit-any for this exact code
+            // (under checkJs), so the plain-project assertion below reflects gating, not just timing.
+            await _openInProject("js-checkjs/", "implicit.js");
+            await awaitsFor(function () {
+                return panelText().includes(IMPLICIT_ANY_MESSAGE);
+            }, "implicit-any under checkJs (precondition)", 20000);
+
+            // Same code in a plain JS project (no jsconfig / no @ts-check): the "go add types" nag
+            // must not appear. Wait for inspection to settle clean, then assert it is absent.
+            await _openInProject("js-plain/", "implicit.js");
+            await awaitsFor(function () {
+                return $("#status-inspection").hasClass("inspection-valid");
+            }, "plain JS inspection to settle with no problems", 20000);
+            expect(panelText().includes(IMPLICIT_ANY_MESSAGE)).toBe(false);
+        }, 30000);
+    });
+});

test/spec/TypeScriptSupport-test-files/js-checkjs/implicit.js

@@ -0,0 +1,5 @@
+// Same untyped parameter as js-plain, but this project opts into type-checking via jsconfig
+// (checkJs + noImplicitAny), so the LSP SHOULD report the implicit "any".
+export function identity(value) {
+    return value;
+}

test/spec/TypeScriptSupport-test-files/js-checkjs/jsconfig.json

@@ -0,0 +1,7 @@
+{
+    "compilerOptions": {
+        "checkJs": true,
+        "noImplicitAny": true
+    },
+    "include": ["**/*.js"]
+}

test/spec/TypeScriptSupport-test-files/js-plain/implicit.js

@@ -0,0 +1,5 @@
+// Plain JavaScript (no jsconfig/tsconfig, no @ts-check). The untyped parameter would be an
+// "implicit any" under type-checking, but a pure-JS project must NOT be nagged about it.
+export function identity(value) {
+    return value;
+}

test/spec/TypeScriptSupport-test-files/ts/type-error.ts

@@ -0,0 +1,6 @@
+// A deliberate TypeScript type error for the LSP integration test.
+const aNumber: number = "this is a string";
+
+export function getValue(): number {
+    return aNumber;
+}