fix: stabilize JavaScript hints and desktop tests

Serialize queued Tern initializations and finish background indexing when
directories disappear. Exclude HTML/PHP host markup from background parsing
and supply extracted JavaScript with completion requests.

Add initialization regressions, improve completion timeout diagnostics, and
clean up fake-clock toast transitions. Pin Pro to the tested Design Mode,
dialog, and locale fixes.

Validated macOS Tauri categories: unit 2905, integration 1106 twice,
LegacyInteg 556, livepreview 279, and mainview 307. Lint passed.

Author: abose

src/JSUtils/ScopeManager.js

@@ -378,16 +378,31 @@ define(function (require, exports, module) {
     }
 
     /**
-     * Get the text of a document, applying any size restrictions
-     * if necessary
+     * Prepare a background file read or update for Tern's JavaScript parser.
+     * HTML and PHP start empty: getFileInfo() supplies their extracted scripts with each hint
+     * request. Parsing host markup here can throw and strand Tern's pending reads.
+     * @private
+     * @param {string} path - full path of the file.
+     * @param {string} text - unfiltered file contents.
+     * @return {string} JavaScript source, or an empty placeholder for HTML/PHP.
+     */
+    function filterTernFileText(path, text) {
+        const languageId = LanguageManager.getLanguageForPath(path).getId();
+        if (languageId === "html" || languageId === "php") {
+            return "";
+        }
+        return filterText(text);
+    }
+
+    /**
+     * Get a document's source for a background Tern update, excluding host markup
+     * and applying the configured size limit.
      * @private
      * @param {Document} document - the document to get the text from
-     * @return {string} the text, or the empty text if the original was too long
+     * @return {string} JavaScript source, or empty text for HTML/PHP or an oversized file.
      */
     function getTextFromDocument(document) {
-        var text = document.getText();
-        text = filterText(text);
-        return text;
+        return filterTernFileText(document.file.fullPath, document.getText());
     }
 
     /**
@@ -606,14 +621,14 @@ define(function (require, exports, module) {
      * @return {{type: string, name: string, offsetLines: number, text: string}}
      */
     function getFileInfo(session, preventPartialUpdates) {
+        const languageId = LanguageManager.getLanguageForPath(session.editor.document.file.fullPath).getId();
         var start = session.getCursor(),
             end = start,
             document = session.editor.document,
             path = document.file.fullPath,
-            isHtmlFile = LanguageManager.getLanguageForPath(path).getId() === "html",
             result;
 
-        if (isHtmlFile) {
+        if (languageId === "html" || languageId === "php") {
             result = {type: MessageIds.TERN_FILE_INFO_TYPE_FULL,
                 name: path,
                 text: session.getJavascriptText()};
@@ -946,7 +961,7 @@ define(function (require, exports, module) {
                 promise.done(function (docText) {
                     resolvedFiles[name] = filePath;
                     numResolvedFiles++;
-                    replyWith(name, filterText(docText));
+                    replyWith(name, filterTernFileText(filePath, docText));
                 });
                 return promise;
             }
@@ -1075,8 +1090,8 @@ define(function (require, exports, module) {
          *  to tern.
          * @private
          * @param {string} dir - the root directory to add.
-         * @param {function ()} doneCallback - called when all files have been
-         * added to tern.
+         * @param {function ()} doneCallback - called when traversal finishes, including
+         * when the directory can no longer be resolved.
          */
         function addAllFilesAndSubdirectories(dir, doneCallback) {
             FileSystem.resolve(dir, function (err, directory) {
@@ -1093,6 +1108,9 @@ define(function (require, exports, module) {
                 }
 
                 if (err) {
+                    // The directory can disappear before background indexing starts.
+                    // Release initialization so later editors do not wait on it indefinitely.
+                    doneCallback();
                     return;
                 }
 
@@ -1326,12 +1344,14 @@ define(function (require, exports, module) {
          * @param {?Document} previousDocument - the document of the editor is changing from
          */
         function handleEditorChange(session, document, previousDocument) {
-            if (addFilesPromise === null) {
-                doEditorChange(session, document, previousDocument);
-            } else {
+            if (addFilesPromise && addFilesPromise.state() === "pending") {
                 addFilesPromise.done(function () {
-                    doEditorChange(session, document, previousDocument);
+                    // An earlier queued editor may have started another initialization.
+                    // Recheck the current promise so only one worker-ready handler owns it.
+                    handleEditorChange(session, document, previousDocument);
                 });
+            } else {
+                doEditorChange(session, document, previousDocument);
             }
         }
 

src/JSUtils/Session.js

@@ -742,15 +742,16 @@ define(function (require, exports, module) {
 
     /**
      * Get the javascript text of the file open in the editor for this Session.
-     * For a javascript file, this is just the text of the file.  For an HTML file,
+     * For a javascript file, this is just the text of the file.  For an HTML/PHP file,
      * this will be only the text in the script tags.  This is so that we can pass
      * just the javascript text to tern, and avoid confusing it with HTML tags, since it
      * only knows how to parse javascript.
      * @return {String} - the "javascript" text that can be sent to Tern.
      */
     Session.prototype.getJavascriptText = function () {
-        if (LanguageManager.getLanguageForPath(this.editor.document.file.fullPath).getId() === "html") {
-            // HTML file - need to send back only the bodies of the
+        const languageId = LanguageManager.getLanguageForPath(this.editor.document.file.fullPath).getId();
+        if (languageId === "html" || languageId === "php") {
+            // HTML/PHP file - need to send back only the bodies of the
             // script tags
             var text = "",
                 editor = this.editor,

src/extensions/default/TypeScriptSupport/unittests.js

@@ -430,24 +430,28 @@ define(function (require, exports, module) {
             const jsCodeHints = await new Promise(function (resolve, reject) {
                 ExtensionLoader.getRequireContextForExtension("JavaScriptCodeHints")(["main"], resolve, reject);
             });
-            let hintText = "";
+            let hintText = "", hintState = "not requested";
             await awaitsFor(async function () {
                 if (!jsCodeHints.jsHintProvider.hasHints(editor, null)) {
+                    hintState = "provider declined the editor context";
                     return false; // Tern session/worker may still be starting up
                 }
                 // The provider returns a Deferred for fresh hints and an object for
                 // cached hints. Await either result before checking this request.
                 let result;
                 try {
+                    hintState = "waiting for the Tern response";
                     result = await jsCodeHints.jsHintProvider.getHints(null);
                 } catch (err) {
+                    hintState = "request rejected: " + String(err);
                     return false; // A project/session change can cancel a pending request.
                 }
                 hintText = ((result && result.hints) || []).map(function (h) {
                     return $(h).text();
                 }).join("|");
+                hintState = "returned hints: " + hintText;
                 return hintText.indexOf("push") !== -1;
-            }, "Tern Array-member completions at arr. inside the <script>", 30000, 500);
+            }, () => "Tern Array-member completions at arr. inside the <script>: " + hintState, 30000, 500);
             expect(hintText).toContain("push");
 
             await awaitsForDone(CommandManager.execute(Commands.FILE_CLOSE, { _forceClose: true }),

test/spec/NotificationUI-test.js

@@ -110,10 +110,11 @@ define(function (require, exports, module) {
             // Mock time from the start so the auto-close timer itself is under the clock. The close
             // itself is observed on the notification, since the removal waits for a CSS transition.
             jasmine.clock().install();
+            let notification, $popup;
             try {
-                const notification = NotificationUI.createToastFromTemplate("hello", "world", {autoCloseTimeS: 1});
+                notification = NotificationUI.createToastFromTemplate("hello", "world", {autoCloseTimeS: 1});
+                $popup = notification.$notification;
                 spyOn(notification, "close").and.callThrough();
-                const $popup = $("#toast-notification-container").children().last();
                 expect($popup.length).toBe(1);
                 $popup.trigger("mouseenter");
                 jasmine.clock().tick(1500);
@@ -125,6 +126,13 @@ define(function (require, exports, module) {
                 jasmine.clock().tick(200);
                 expect(notification.close).toHaveBeenCalledWith(NotificationUI.CLOSE_REASON.TIMEOUT);
             } finally {
+                if (notification) {
+                    notification.close("test-cleanup");
+                    // The fake clock does not advance CSS transitions. Complete this
+                    // toast's removal so the next spec starts without a closing toast.
+                    $popup.trigger("transitionend");
+                    expect($popup[0].isConnected).toBeFalse();
+                }
                 jasmine.clock().uninstall();
             }
         });

test/spec/ScopeManager-integ-test.js

@@ -7,17 +7,19 @@
 
 define(function (require, exports, module) {
     const SpecRunnerUtils = require("spec/SpecRunnerUtils"),
-        FileSystemError = require("filesystem/FileSystemError");
+        FileSystemError = require("filesystem/FileSystemError"),
+        MessageIds = JSON.parse(require("text!JSUtils/MessageIds.json"));
 
     describe("integration:JavaScript hint initialization", function () {
-        let testWindow, FileSystem, ScopeManager, EditorManager, Session, testFolder;
+        let testWindow, FileSystem, ScopeManager, EditorManager, Session, IndexingWorker, testFolder;
 
         beforeAll(async function () {
             testWindow = await SpecRunnerUtils.createTestWindowAndRun();
             FileSystem = testWindow.brackets.test.FileSystem;
             EditorManager = testWindow.brackets.test.EditorManager;
             ScopeManager = testWindow.brackets.getModule("JSUtils/ScopeManager");
             Session = testWindow.brackets.getModule("JSUtils/Session");
+            IndexingWorker = testWindow.brackets.getModule("worker/IndexingWorker");
         }, 30000);
 
         beforeEach(async function () {
@@ -95,5 +97,150 @@ define(function (require, exports, module) {
                 reads.restore();
             }
         });
+
+        it("should finish initialization when a background directory disappears", async function () {
+            await SpecRunnerUtils.createTextFileAsync(testFolder + "/hints.js", "const arr = [1, 2, 3];\narr.");
+            await awaitsForDone(SpecRunnerUtils.openProjectFiles(["hints.js"]), "open JavaScript fixture");
+            const editor = EditorManager.getCurrentFullEditor();
+            editor.setCursorPos(1, 4);
+            const session = new Session(editor);
+            await awaitsForDone(ScopeManager.requestHints(session, editor.document), "initialize Tern");
+
+            const directoryPath = editor.document.file.parentPath;
+            const resolve = FileSystem.resolve;
+            let directoryReads = 0, interruptedLookup;
+            const lookup = spyOn(FileSystem, "resolve").and.callFake(function (filePath, callback) {
+                if (filePath === directoryPath && ++directoryReads === 2) {
+                    // The first lookup initializes Tern. The second starts its background scan,
+                    // after the directory could have been deleted during a project switch.
+                    interruptedLookup = callback;
+                    callback(FileSystemError.NOT_FOUND);
+                    return;
+                }
+                return resolve.apply(this, arguments);
+            });
+            const ready = ScopeManager._maybeReset(session, editor.document, true);
+            try {
+                await awaitsFor(() => !!interruptedLookup, "background directory lookup");
+                await awaitsFor(() => ready.state() !== "pending", "initialization after a missing directory", 5000);
+                await awaitsForDone(ready, "initialization after a missing directory");
+                const hints = ScopeManager.requestHints(session, editor.document);
+                await awaitsForDone(hints, "hints after a missing directory");
+                expect(session.ternHints.some(hint => hint.value === "push")).toBeTrue();
+            } finally {
+                lookup.and.callThrough();
+                if (interruptedLookup && ready.state() === "pending") {
+                    // Release the injected failure even if an assertion fails, so subsequent
+                    // specs are not left behind the same unfinished initialization.
+                    resolve.call(FileSystem, directoryPath, interruptedLookup);
+                    await awaitsForDone(ready, "finish test cleanup");
+                }
+            }
+        });
+
+        it("should initialize HTML without parsing markup as JavaScript", async function () {
+            const worker = spyOn(IndexingWorker, "execPeer").and.callThrough();
+            await awaitsForDone(SpecRunnerUtils.openProjectFiles(["embedded.html"]), "open embedded script");
+            const editor = EditorManager.getCurrentFullEditor();
+            editor.setCursorPos(6, 4);
+            const session = new Session(editor);
+            await awaitsForDone(ScopeManager.requestHints(session, editor.document), "embedded script hints");
+
+            const reads = worker.calls.allArgs().filter(args => args[0] === "invokeTernCommand" &&
+                args[1].type === MessageIds.TERN_GET_FILE_MSG && args[1].file.endsWith("/embedded.html"));
+            expect(reads.length).toBeGreaterThan(0);
+            reads.forEach(args => expect(args[1].text).not.toContain("<html>"));
+            expect(session.ternHints.some(hint => hint.value === "push")).toBeTrue();
+        });
+
+        it("should serialize editor changes queued behind initialization", async function () {
+            await awaitsForDone(SpecRunnerUtils.openProjectFiles(["embedded.html"]), "open embedded script");
+            const editor = EditorManager.getCurrentFullEditor();
+            editor.setCursorPos(6, 4);
+            const session = new Session(editor);
+            await awaitsForDone(ScopeManager.requestHints(session, editor.document), "initialize Tern");
+
+            const documents = [];
+            for (const name of ["queued-a.html", "queued-b.html", "queued-c.html"]) {
+                const path = testFolder + "/" + name;
+                await SpecRunnerUtils.createTextFileAsync(path, editor.document.getText());
+                documents.push(await testWindow.brackets.test.DocumentManager.getDocumentForPath(path));
+            }
+
+            const directoryPath = editor.document.file.parentPath;
+            const resolve = FileSystem.resolve;
+            const callbacks = [];
+            const lookup = spyOn(FileSystem, "resolve").and.callFake(function (filePath, callback) {
+                if (filePath === directoryPath) {
+                    callbacks.push(callback);
+                    return;
+                }
+                return resolve.apply(this, arguments);
+            });
+            try {
+                documents.forEach(document => ScopeManager.handleEditorChange(session, document, null));
+                expect(callbacks.length).toBe(1);
+                resolve.call(FileSystem, directoryPath, callbacks.shift());
+                await awaitsFor(() => callbacks.length > 0, "next queued editor initialization");
+                // Waking several queued changes must start only the next initialization.
+                // Concurrent initializations replace each other's worker-ready handler.
+                expect(callbacks.length).toBe(1);
+            } finally {
+                // Fail held lookups before restoring them, including any cleanup queues.
+                while (callbacks.length) {
+                    callbacks.shift()(FileSystemError.NOT_FOUND);
+                }
+                lookup.and.callThrough();
+            }
+
+            await awaitsForDone(SpecRunnerUtils.openProjectFiles(["queued-c.html"]), "open last queued editor");
+            const finalEditor = EditorManager.getCurrentFullEditor();
+            finalEditor.setCursorPos(6, 4);
+            const finalSession = new Session(finalEditor);
+            await awaitsForDone(ScopeManager.requestHints(finalSession, finalEditor.document), "hints after queued editors");
+            expect(finalSession.ternHints.some(hint => hint.value === "push")).toBeTrue();
+        });
+
+        it("should exclude markup when updating a dirty HTML document before switching editors", async function () {
+            await awaitsForDone(SpecRunnerUtils.openProjectFiles(["embedded.html"]), "open embedded script");
+            const previousEditor = EditorManager.getCurrentFullEditor();
+            previousEditor.setCursorPos(6, 4);
+            await awaitsForDone(ScopeManager.requestHints(new Session(previousEditor), previousEditor.document),
+                "initialize embedded script");
+            await SpecRunnerUtils.createTextFileAsync(testFolder + "/other.html", previousEditor.document.getText());
+
+            const worker = spyOn(IndexingWorker, "execPeer").and.callThrough();
+            previousEditor.document.setText(previousEditor.document.getText() + "\n<!-- unsaved edit -->");
+            await awaitsForDone(SpecRunnerUtils.openProjectFiles(["other.html"]), "switch embedded script");
+            const editor = EditorManager.getCurrentFullEditor();
+            editor.setCursorPos(6, 4);
+            const session = new Session(editor);
+            await awaitsForDone(ScopeManager.requestHints(session, editor.document), "hints after dirty HTML update");
+
+            const updates = worker.calls.allArgs().filter(args => args[0] === "invokeTernCommand" &&
+                args[1].type === MessageIds.TERN_UPDATE_FILE_MSG &&
+                args[1].path === previousEditor.document.file.fullPath);
+            expect(updates.length).toBeGreaterThan(0);
+            updates.forEach(args => expect(args[1].text).not.toContain("<html>"));
+            expect(session.ternHints.some(hint => hint.value === "push")).toBeTrue();
+        });
+
+        it("should analyze embedded JavaScript without sending PHP host code to Tern", async function () {
+            const html = await SpecRunnerUtils.readTextFileAsync(testFolder + "/embedded.html");
+            await SpecRunnerUtils.createTextFileAsync(testFolder + "/embedded.php", '<?php echo "header"; ?>\n' + html);
+            const worker = spyOn(IndexingWorker, "execPeer").and.callThrough();
+            await awaitsForDone(SpecRunnerUtils.openProjectFiles(["embedded.php"]), "open PHP embedded script");
+            const editor = EditorManager.getCurrentFullEditor();
+            editor.setCursorPos(7, 4);
+            const session = new Session(editor);
+            await awaitsForDone(ScopeManager.requestHints(session, editor.document), "PHP embedded script hints");
+
+            const reads = worker.calls.allArgs().filter(args => args[0] === "invokeTernCommand" &&
+                args[1].type === MessageIds.TERN_GET_FILE_MSG && args[1].file.endsWith("/embedded.php"));
+            expect(reads.length).toBeGreaterThan(0);
+            reads.forEach(args => expect(args[1].text).not.toContain("<?php"));
+            expect(session.ternHints.some(hint => hint.value === "push")).toBeTrue();
+        });
+
     });
 });

tracking-repos.json

@@ -1,5 +1,5 @@
 {
   "phoenixPro": {
-    "commitID": "24695997878195f3499c60e453060591f6079b18"
+    "commitID": "c991a453739841abeeacf7711127df553e39578e"
   }
 }