Merge branch 'main' into wenyt/fixui

Author: wenytang-ms

package-lock.json

@@ -26,6 +26,8 @@ export namespace Commands {
 
     export const VIEW_PACKAGE_INTERNAL_REFRESH = "_java.view.package.internal.refresh";
 
+    export const VIEW_PACKAGE_INTERNAL_ADD_PROJECTS = "_java.view.package.internal.addProjects";
+
     export const VIEW_PACKAGE_OUTLINE = "java.view.package.outline";
 
     export const VIEW_PACKAGE_REVEAL_FILE_OS = "java.view.package.revealFileInOS";

src/commands.ts

@@ -13,6 +13,8 @@ class LanguageServerApiManager {
     private extensionApi: any;
 
     private isServerReady: boolean = false;
+    private isServerRunning: boolean = false;
+    private serverReadyWaitStarted: boolean = false;
 
     public async ready(): Promise<boolean> {
         if (this.isServerReady) {
@@ -28,11 +30,49 @@ class LanguageServerApiManager {
             return false;
         }
 
+        // Use serverRunning() if available (API >= 0.14) for progressive loading.
+        // This resolves when the server process is alive and can handle requests,
+        // even if project imports haven't completed yet. This enables the tree view
+        // to show projects incrementally as they are imported.
+        if (!this.isServerRunning && this.extensionApi.serverRunning) {
+            await this.extensionApi.serverRunning();
+            this.isServerRunning = true;
+            return true;
+        }
+        if (this.isServerRunning) {
+            return true;
+        }
+
+        // Fallback for older API versions: wait for full server readiness
         await this.extensionApi.serverReady();
         this.isServerReady = true;
         return true;
     }
 
+    /**
+     * Start a background wait for full server readiness (import complete).
+     * When the server finishes importing, trigger a full refresh to replace
+     * progressive placeholder items with proper data from the server.
+     * Guarded so it only starts once regardless of call order.
+     */
+    private startServerReadyWait(): void {
+        if (this.serverReadyWaitStarted || this.isServerReady) {
+            return;
+        }
+        if (this.extensionApi?.serverReady) {
+            this.serverReadyWaitStarted = true;
+            this.extensionApi.serverReady()
+                .then(() => {
+                    this.isServerReady = true;
+                    commands.executeCommand(Commands.VIEW_PACKAGE_INTERNAL_REFRESH, /* debounce = */false);
+                })
+                .catch((_error: unknown) => {
+                    // Server failed to become ready (e.g., startup failure).
+                    // Leave isServerReady as false; progressive items remain as-is.
+                });
+        }
+    }
+
     public async initializeJavaLanguageServerApis(): Promise<void> {
         if (this.isApiInitialized()) {
             return;
@@ -49,18 +89,39 @@ class LanguageServerApiManager {
             }
 
             this.extensionApi = extensionApi;
+            // Start background wait for full server readiness unconditionally.
+            // This ensures isServerReady is set and final refresh fires even
+            // if onDidProjectsImport sets isServerRunning before ready() runs.
+            this.startServerReadyWait();
+
             if (extensionApi.onDidClasspathUpdate) {
                 const onDidClasspathUpdate: Event<Uri> = extensionApi.onDidClasspathUpdate;
-                contextManager.context.subscriptions.push(onDidClasspathUpdate(() => {
-                    commands.executeCommand(Commands.VIEW_PACKAGE_INTERNAL_REFRESH, /* debounce = */true);
+                contextManager.context.subscriptions.push(onDidClasspathUpdate((uri: Uri) => {
+                    if (this.isServerReady) {
+                        // Server is fully ready — do a normal refresh to get full project data.
+                        commands.executeCommand(Commands.VIEW_PACKAGE_INTERNAL_REFRESH, /* debounce = */true);
+                    } else {
+                        // During import, the server is blocked and can't respond to queries.
+                        // Don't clear progressive items. Try to add the project if not
+                        // already present (typically a no-op since ProjectsImported fires first).
+                        commands.executeCommand(Commands.VIEW_PACKAGE_INTERNAL_ADD_PROJECTS, [uri.toString()]);
+                    }
                     syncHandler.updateFileWatcher(Settings.autoRefresh());
                 }));
             }
 
             if (extensionApi.onDidProjectsImport) {
                 const onDidProjectsImport: Event<Uri[]> = extensionApi.onDidProjectsImport;
-                contextManager.context.subscriptions.push(onDidProjectsImport(() => {
-                    commands.executeCommand(Commands.VIEW_PACKAGE_INTERNAL_REFRESH, /* debounce = */true);
+                contextManager.context.subscriptions.push(onDidProjectsImport((uris: Uri[]) => {
+                    // Server is sending project data, so it's definitely running.
+                    // Mark as running so ready() returns immediately on subsequent calls.
+                    this.isServerRunning = true;
+                    // During import, the JDTLS server is blocked by Eclipse workspace
+                    // operations and cannot respond to queries. Instead of triggering
+                    // a refresh (which queries the server), directly add projects to
+                    // the tree view from the notification data.
+                    const projectUris = uris.map(u => u.toString());
+                    commands.executeCommand(Commands.VIEW_PACKAGE_INTERNAL_ADD_PROJECTS, projectUris);
                     syncHandler.updateFileWatcher(Settings.autoRefresh());
                 }));
             }
@@ -91,6 +152,14 @@ class LanguageServerApiManager {
         return this.extensionApi !== undefined;
     }
 
+    /**
+     * Returns true if the server has fully completed initialization (import finished).
+     * During progressive loading, this returns false even though ready() has resolved.
+     */
+    public isFullyReady(): boolean {
+        return this.isServerReady;
+    }
+
     /**
      * Check if the language server is ready in the given timeout.
      * @param timeout the timeout in milliseconds to wait