fix(lsp): consume text after cursor when completion textEdit range covers it

JSON key completion inside autoclosed quotes (`"|"`) inserted
`"author": {}"` - the server's textEdit range covers both quotes, but
insertHint always clamped the replacement end to the cursor, leaving the
closing quote dangling. Now a range.end beyond the cursor is honored;
an end at/before the cursor is still clamped so cached completion lists
served while typing forward keep working as before.

Adds a JSON LSP regression spec driving the hint provider directly (the
popup UI needs OS window focus the embedded test window may not have),
plus a test-only _getClient hook in JsonLsp.

Author: abose

package-lock.json

@@ -235,4 +235,12 @@ define(function (require, exports, module) {
     exports.canRun = canRun;
     exports.SERVER_ID = SERVER_ID;
     exports._setTestSchemaAssociations = _setTestSchemaAssociations;
+    if (Phoenix.isTestWindow) {
+        // Test hook - the registered LanguageClient (null until the server has started). Lets
+        // integration tests drive the LSP providers (e.g. codeHints) directly, since the hint UI
+        // needs OS window focus that the embedded test window may not have.
+        exports._getClient = function () {
+            return client;
+        };
+    }
 });

src/extensionsIntegrated/JSONSupport/JsonLsp.js

@@ -642,12 +642,19 @@ define(function (require, exports, module) {
         // That start is stable as the user types forward (word/member starts don't move) and, crucially,
         // for member completions it points AT the trigger "." while newText itself includes the dot
         // (e.g. "console." + item ".log" -> replace from the "." -> "console.log", not "console..log").
-        // We deliberately end at the CURRENT cursor rather than token.textEdit.range.end: that end is
-        // stale when completions are served from cache while typing continues, which would otherwise
-        // replace only part of the word (e.g. "conso"+enter -> "consolenso").
         if (textEditRange && textEditRange.start.line === cursor.line &&
                 textEditRange.start.character <= cursor.ch) {
             startCh = textEditRange.start.character;
+            // Honor a range.end BEYOND the cursor: the server wants existing text after the caret
+            // overwritten because newText includes it (e.g. JSON key completion inside autoclosed
+            // quotes `"|"` - newText `"author": {$1}` covers both quotes; keeping the closing quote
+            // would leave a dangling `"` behind the insert). A range.end at/before the cursor is
+            // clamped TO the cursor instead: that end is stale when completions are served from
+            // cache while typing continues, which would otherwise replace only part of the word
+            // (e.g. "conso"+enter -> "consolenso").
+            if (textEditRange.end.line === cursor.line && textEditRange.end.character > cursor.ch) {
+                endCh = textEditRange.end.character;
+            }
         } else {
             startCh = cursor.ch;
             while (startCh > 0 && /[\w$]/.test(lineText.charAt(startCh - 1))) {

src/languageTools/DefaultProviders.js

@@ -88,6 +88,71 @@ define(function (require, exports, module) {
             JsonLsp._setTestSchemaAssociations(null);
         }, 45000);
 
+        it("should consume the autoclosed closing quote when inserting a key completion", async function () {
+            // Regression: typing `"` autocloses to `"|"`; the server's completion textEdit range
+            // covers BOTH quotes (its end is past the cursor) and newText is a full `"key": {$1}`
+            // snippet. insertHint used to clamp the replacement end to the cursor, leaving the
+            // closing quote dangling -> `"key": {}"` (invalid JSON).
+            const JsonLsp = testWindow.require("extensionsIntegrated/JSONSupport/JsonLsp");
+            const EditorManager = testWindow.brackets.test.EditorManager;
+            JsonLsp._setTestSchemaAssociations([{
+                fileMatch: ["appsettings.json"],
+                schema: {
+                    type: "object",
+                    properties: {
+                        serverConfig: { type: "object" }
+                    }
+                }
+            }]);
+            await _openFile("appsettings.json");
+            const editor = EditorManager.getActiveEditor();
+            editor.document.setText('{\n  ""\n}');
+            editor.setCursorPos(1, 3);      // between the quotes: `  "|"`
+
+            // Drive the LSP hint provider directly (the popup UI needs OS window focus that the
+            // embedded test window may not have). Poll fresh requests until the schema completion
+            // shows up - the pushed schema association may take a moment to apply server-side.
+            await awaitsFor(function () {
+                return !!JsonLsp._getClient();
+            }, "JSON language client registered", 30000);
+            const client = JsonLsp._getClient();
+            let $targetHint = null,
+                requestInFlight = false;
+            await awaitsFor(function () {
+                if ($targetHint) {
+                    return true;
+                }
+                if (!requestInFlight) {
+                    requestInFlight = true;
+                    client._completionCache = null; // context key is stable here - don't reuse stale lists
+                    client.codeHints.getHints(null).done(function (result) {
+                        requestInFlight = false;
+                        const hints = (result && result.hints) || [];
+                        $targetHint = hints.find(function ($hint) {
+                            const token = $hint.data("token");
+                            return token && token.label === "serverConfig";
+                        }) || null;
+                    }).fail(function () {
+                        requestInFlight = false;
+                    });
+                }
+                return false;
+            }, "serverConfig schema completion from the JSON server", 30000);
+
+            client.codeHints.insertHint($targetHint); // what selecting the hint with Enter does
+            await awaitsFor(function () {
+                return editor.document.getLine(1).indexOf("serverConfig") !== -1;
+            }, "completion inserted into the document", 30000);
+
+            expect(editor.document.getLine(1)).toBe('  "serverConfig": {}');
+            // the whole document must stay valid JSON - no dangling quote after the insert
+            expect(function () { JSON.parse(editor.document.getText()); }).not.toThrow();
+
+            JsonLsp._setTestSchemaAssociations(null);
+            await awaitsForDone(CommandManager.execute(Commands.FILE_CLOSE,
+                { fullPath: testFolder + "/appsettings.json", _forceClose: true }));
+        }, 45000);
+
         it("should squiggle vulnerable dependencies using advisory data", async function () {
             const NpmRegistry = testWindow.require("extensionsIntegrated/JSONSupport/NpmRegistry");
             NpmRegistry._setFetcherForTests(function (url, options) {