fix(lsp): only reuse cached completions when provably a candidate superset

The completion cache was keyed only by word context (file|line|word
start), so a list fetched at a bare position was refiltered client-side
for every later keystroke on the line. intelephense answers a bare
position with an empty list (cold index) or an arbitrary grab-bag of
symbols marked complete (warm index) - neither is a superset, so typing
is_ after a blank-line Ctrl-Space showed no completions, or is_int
vanished from its own hint list.

The cache now stores the query it was fetched with and is reused only
when the current query extends it, and the fetched query was non-empty
or anchored to a trigger char (member lists after . / -> / :: stay
cheaply cacheable; bare-position answers are never reused). Empty lists
are never cached.

Adds a PHP LSP regression spec (blank query then prefix on the same
line must surface is_int) and a test-only _getClient hook in PHPSupport.

Author: abose

src/extensions/default/PHPSupport/main.js

@@ -62,6 +62,7 @@ define(function (require, exports, module) {
 
     let lspClientPromise = null;
     let registered = false;
+    let _client = null;
     let starting = false;
     let pendingRepoint = false;
     let initErrorReported = false;
@@ -123,6 +124,7 @@ define(function (require, exports, module) {
         });
         if (client) {
             registered = true;
+            _client = client;
         }
     }
 
@@ -251,4 +253,11 @@ define(function (require, exports, module) {
     // for tests
     exports._ensureServerForActiveEditor = _ensureServerForActiveEditor;
     exports.SERVER_ID = SERVER_ID;
+    if (Phoenix.isTestWindow) {
+        // the registered LanguageClient (null until the server has started) - lets integration
+        // tests drive the LSP providers/requests directly
+        exports._getClient = function () {
+            return _client;
+        };
+    }
 });

src/extensions/default/PHPSupport/unittests.js

@@ -135,6 +135,53 @@ define(function (require, exports, module) {
             }, "cursor to land on the definition", 30000);
         }, 45000);
 
+        it("should offer completions after typing a prefix where a blank-position query was empty", async function () {
+            // Regression: intelephense returns ZERO completions at a bare blank position but a full
+            // list once a prefix exists. The empty result used to be cached under the word-context
+            // key (file|line|text-before-word-start), which is IDENTICAL for the blank position and
+            // the typed prefix - so every later Ctrl-Space on the line replayed "no completions".
+            const phpMain = await _phpModule("main");
+            const client = phpMain._getClient();
+            expect(client).toBeTruthy();
+            await _openFile("funcs.php");
+            const editor = EditorManager.getActiveEditor();
+            const lines = editor.document.getText().split("\n");
+            const defLine = lines.findIndex(function (l) { return l.indexOf("function computeTotal") !== -1; });
+            // fresh blank line inside the <?php block, right above the function
+            editor.document.replaceRange("    \n", { line: defLine, ch: 0 });
+            const blankLine = defLine;
+            const filePath = editor.document.file._path;
+
+            function _hintLabels(cursorPos) {
+                return new Promise(function (resolve) {
+                    client.requestHints({ filePath: filePath, cursorPos: cursorPos })
+                        .done(function (r) {
+                            resolve(r.items.map(function (i) { return i.label; }));
+                        })
+                        .fail(function () { resolve(null); });
+                });
+            }
+
+            // 1. query the bare blank position - primes the completion cache with whatever the
+            //    server answers there (an empty list, for intelephense)
+            await _hintLabels({ line: blankLine, ch: 4 });
+            // 2. type a prefix on the SAME line (same context key) and query again - the server's
+            //    real list must come through, not a stale cached answer
+            editor.document.replaceRange("is_", { line: blankLine, ch: 4 });
+            editor.setCursorPos(blankLine, 7);
+            let labels = null;
+            await awaitsFor(function () {
+                return _hintLabels({ line: blankLine, ch: 7 }).then(function (result) {
+                    labels = result;
+                    return !!(labels && labels.length);
+                });
+            }, "completions for the is_ prefix on the previously-blank line", 30000);
+            expect(labels).toContain("is_int");
+
+            await awaitsForDone(CommandManager.execute(Commands.FILE_CLOSE,
+                { fullPath: testFolder + "/funcs.php", _forceClose: true }));
+        }, 45000);
+
         it("should keep Tern serving embedded <script> JS inside php files", async function () {
             await _openFile("embedded.php");
             const editor = EditorManager.getActiveEditor();

src/languageTools/LSPClient.js

@@ -364,12 +364,13 @@ define(function (require, exports, module) {
         return { line: cursorPos.line, character: cursorPos.ch };
     }
 
-    // Build a cache key identifying the current completion "context": the file, line, the column
-    // where the word under the cursor starts, and the text on the line before that word. While the
-    // user types/moves within the same word, this key stays constant, so we can reuse the server's
-    // (complete) result and filter client-side instead of re-querying. That avoids slow late
-    // responses rebuilding the list mid-navigation.
-    function _completionContextKey(filePath, pos) {
+    // Describe the completion "context" at a position:
+    //  - key: identifies the word being typed - file, line, and the text on the line before the
+    //    column where that word starts. Stays constant while typing/moving within one word.
+    //  - query: the part of the word already typed before the cursor.
+    //  - anchored: whether the word start sits directly after a trigger-ish non-space character
+    //    (".", "->", "::") rather than after whitespace/line start.
+    function _completionContext(filePath, pos) {
         const doc = DocumentManager.getOpenDocumentForPath(filePath);
         if (!doc) {
             return null;
@@ -379,19 +380,35 @@ define(function (require, exports, module) {
         while (start > 0 && /[\w$]/.test(lineText.charAt(start - 1))) {
             start--;
         }
-        return filePath + "|" + pos.line + "|" + lineText.substring(0, start);
+        return {
+            key: filePath + "|" + pos.line + "|" + lineText.substring(0, start),
+            query: lineText.substring(start, pos.ch),
+            anchored: start > 0 && /\S/.test(lineText.charAt(start - 1))
+        };
     }
 
     LanguageClient.prototype.requestHints = function (params) {
         const self = this;
         const deferred = $.Deferred();
         (async function () {
             try {
-                // Reuse the cached (complete) completion list while still in the same completion
-                // context, so typing/cursor-moves within a word don't re-hit the server.
-                const ctxKey = _completionContextKey(params.filePath, params.cursorPos);
-                if (ctxKey && self._completionCache && self._completionCache.key === ctxKey) {
-                    deferred.resolve({ items: self._completionCache.items });
+                // Reuse the cached completion list while typing forward within one word, so every
+                // keystroke doesn't re-hit the server. Reuse is only sound when the cached list is
+                // a candidate SUPERSET of what the current query would return, so it needs ALL of:
+                //  - the same context key (same file/line/word-start),
+                //  - the current query extending the query the list was fetched with, and
+                //  - that fetched query being non-empty OR anchored to a trigger char: a member
+                //    list after "." / "->" is a closed set, but what a server answers at a BARE
+                //    position is an arbitrary relevance selection, NOT a superset. intelephense
+                //    answers a blank line with a grab-bag of symbols (marked complete!) which,
+                //    if reused, swallows every later keystroke on that line (e.g. typing is_int
+                //    showed no is_int because a stale blank-line list was being refiltered).
+                const ctx = _completionContext(params.filePath, params.cursorPos);
+                const cached = self._completionCache;
+                if (ctx && cached && cached.key === ctx.key &&
+                        ctx.query.startsWith(cached.query) &&
+                        (cached.query || cached.anchored)) {
+                    deferred.resolve({ items: cached.items });
                     return;
                 }
                 await DocumentSync.flush(self, params.filePath);
@@ -406,8 +423,13 @@ define(function (require, exports, module) {
                     // just coerce documentation to a string for inline display.
                     item.documentation = _markupToString(item.documentation);
                 });
-                // Only cache a complete list (an incomplete one must be re-queried as the user types).
-                self._completionCache = (ctxKey && !isIncomplete) ? { key: ctxKey, items: items } : null;
+                // Only cache a complete, NON-EMPTY list (an incomplete one must be re-queried as
+                // the user types; an empty one has nothing to refilter - and some servers answer
+                // empty at a bare position yet answer fully once a prefix exists). The fetched
+                // query + anchoring are stored so the reuse check above can prove superset-ness.
+                self._completionCache = (ctx && !isIncomplete && items.length)
+                    ? { key: ctx.key, query: ctx.query, anchored: ctx.anchored, items: items }
+                    : null;
                 deferred.resolve({ items: items });
             } catch (err) {
                 console.warn("[LSP] request failed:", err && (err.message || err));