Reload the cached classfile sources when new source attachment is updated for them (#3207)

* Reload the cached classfile sources when new source attachment is updated for them

Signed-off-by: Jinbo Wang <jinbwan@microsoft.com>

Author: testforstephen

README.md

@@ -235,6 +235,12 @@ The following settings are supported:
 * `java.completion.lazyResolveTextEdit.enabled`: [Experimental] Enable/disable lazily resolving text edits for code completion. Defaults to `true`.
 * `java.edit.validateAllOpenBuffersOnChanges`: Specifies whether to recheck all open Java files for diagnostics when editing a Java file. Defaults to `false`.
 
+New in 1.21.0
+* `java.editor.reloadChangedSources`: Specifies whether to reload the sources of the open class files when their source jar files are changed. Defaults to `ask`.
+  - `ask`: Ask to reload the sources of the open class files
+  - `auto`: Automatically reload the sources of the open class files
+  - `manual`: Manually reload the sources of the open class files
+
 Semantic Highlighting
 ===============
 [Semantic Highlighting](https://github.com/redhat-developer/vscode-java/wiki/Semantic-Highlighting) fixes numerous syntax highlighting issues with the default Java Textmate grammar. However, you might experience a few minor issues, particularly a delay when it kicks in, as it needs to be computed by the Java Language server, when opening a new file or when typing. Semantic highlighting can be disabled for all languages using the `editor.semanticHighlighting.enabled` setting, or for Java only using [language-specific editor settings](https://code.visualstudio.com/docs/getstarted/settings#_languagespecific-editor-settings).

package.json

@@ -1139,6 +1139,22 @@
           "default": false,
           "markdownDescription": "Specifies whether to recheck all open Java files for diagnostics when editing a Java file.",
           "scope": "window"
+        },
+        "java.editor.reloadChangedSources": {
+          "type": "string",
+          "enum": [
+            "ask",
+            "auto",
+            "manual"
+          ],
+          "enumDescriptions": [
+            "Ask to reload the sources of the open class files",
+            "Automatically reload the sources of the open class files",
+            "Manually reload the sources of the open class files"
+          ],
+          "default": "ask",
+          "markdownDescription": "Specifies whether to reload the sources of the open class files when their source jar files are changed.",
+          "scope": "window"
         }
       }
     },

src/apiManager.ts

@@ -1,6 +1,6 @@
 'use strict';
 
-import { ExtensionAPI, ClasspathQueryOptions, ClasspathResult, extensionApiVersion, ClientStatus } from "./extension.api";
+import { ExtensionAPI, ClasspathQueryOptions, ClasspathResult, extensionApiVersion, ClientStatus, SourceInvalidatedEvent } from "./extension.api";
 import { RequirementsData } from "./requirements";
 import { GetDocumentSymbolsCommand, getDocumentSymbolsProvider } from "./documentSymbols";
 import { GoToDefinitionCommand, goToDefinitionProvider } from "./goToDefinition";
@@ -18,6 +18,7 @@ class ApiManager {
     private onDidServerModeChangeEmitter: Emitter<ServerMode> = new Emitter<ServerMode>();
     private onDidProjectsImportEmitter: Emitter<Uri[]> = new Emitter<Uri[]>();
     private traceEventEmitter: Emitter<any> = new Emitter<any>();
+    private sourceInvalidatedEventEmitter: Emitter<SourceInvalidatedEvent> = new Emitter<SourceInvalidatedEvent>();
     private serverReadyPromiseResolve: (result: boolean) => void;
 
     public initialize(requirements: RequirementsData, serverMode: ServerMode): void {
@@ -65,6 +66,7 @@ class ApiManager {
             serverReady,
             onDidRequestEnd,
             trackEvent: traceEvent,
+            onDidSourceInvalidate: this.sourceInvalidatedEventEmitter.event,
         };
     }
 
@@ -92,6 +94,10 @@ class ApiManager {
         this.traceEventEmitter.fire(event);
     }
 
+    public fireSourceInvalidatedEvent(event: SourceInvalidatedEvent): void {
+        this.sourceInvalidatedEventEmitter.fire(event);
+    }
+
     public updateServerMode(mode: ServerMode): void {
         this.api.serverMode = mode;
     }

src/extension.api.ts

@@ -92,7 +92,18 @@ export interface TraceEvent {
 	resultLength?: number | undefined;
 }
 
-export const extensionApiVersion = '0.9';
+export interface SourceInvalidatedEvent {
+	/**
+	 * The paths of the jar files that are linked to new source attachments.
+	 */
+	affectedRootPaths: string[];
+	/**
+	 * The opened editors with updated source.
+	 */
+	affectedEditorDocuments?: Uri[];
+}
+
+export const extensionApiVersion = '0.10';
 
 export interface ExtensionAPI {
 	readonly apiVersion: string;
@@ -152,4 +163,14 @@ export interface ExtensionAPI {
 	 * @since extension version 1.20.0
 	 */
 	readonly trackEvent: Event<any>;
+
+	/**
+	 * An event that occurs when the package fragment roots have updated source attachments.
+	 * The client should refresh the new source if it has previously requested the source
+	 * from them.
+	 *
+	 * @since API version 0.10
+	 * @since extension version 1.21.0
+	 */
+	readonly onDidSourceInvalidate: Event<SourceInvalidatedEvent>;
 }

src/protocol.ts

@@ -59,7 +59,8 @@ export enum EventType {
     classpathUpdated = 100,
     projectsImported = 200,
     incompatibleGradleJdkIssue = 300,
-	upgradeGradleWrapper = 400,
+    upgradeGradleWrapper = 400,
+    sourceInvalidated = 500,
 }
 
 export enum CompileWorkspaceStatus {
@@ -76,25 +77,25 @@ export enum AccessorKind {
 }
 
 export interface StatusReport {
-	message: string;
-	type: string;
+    message: string;
+    type: string;
 }
 
 export interface ProgressReport {
-	id: string;
-	task: string;
-	subTask: string;
-	status: string;
-	workDone: number;
-	totalWork: number;
-	complete: boolean;
+    id: string;
+    task: string;
+    subTask: string;
+    status: string;
+    workDone: number;
+    totalWork: number;
+    complete: boolean;
 }
 
 export interface ActionableMessage {
-	severity: MessageType;
-	message: string;
-	data?: any;
-	commands?: Command[];
+    severity: MessageType;
+    message: string;
+    data?: any;
+    commands?: Command[];
 }
 
 export interface EventNotification {
@@ -103,11 +104,11 @@ export interface EventNotification {
 }
 
 export namespace StatusNotification {
-	export const type = new NotificationType<StatusReport>('language/status');
+    export const type = new NotificationType<StatusReport>('language/status');
 }
 
 export namespace ProgressReportNotification {
-	export const type = new NotificationType<ProgressReport>('language/progressReport');
+    export const type = new NotificationType<ProgressReport>('language/progressReport');
 }
 
 export namespace ClassFileContentsRequest {
@@ -179,8 +180,8 @@ export interface OverridableMethod {
 }
 
 export interface OverridableMethodsResponse {
-	type: string;
-	methods: OverridableMethod[];
+    type: string;
+    methods: OverridableMethod[];
 }
 
 export namespace ListOverridableMethodsRequest {
@@ -443,9 +444,9 @@ export interface GradleCompatibilityInfo {
 }
 
 export interface UpgradeGradleWrapperInfo {
-	projectUri: string;
-	message: string;
-	recommendedGradleVersion: string;
+    projectUri: string;
+    message: string;
+    recommendedGradleVersion: string;
 }
 
 export interface Member {
@@ -470,5 +471,14 @@ export interface ValidateDocumentParams {
 }
 
 export namespace ValidateDocumentNotification {
-	export const type = new NotificationType<ValidateDocumentParams>('java/validateDocument');
+    export const type = new NotificationType<ValidateDocumentParams>('java/validateDocument');
+}
+
+export interface SourceInvalidatedEvent {
+    /**
+     * The package fragment roots that get new source attachments.
+     * The key is its root path, the value means if its source is
+     * automatically downloaded.
+     */
+    affectedRootPaths: { [key: string]: boolean };
 }

src/standardLanguageClient.ts

@@ -22,7 +22,7 @@ import * as pasteAction from './pasteAction';
 import { registerPasteEventHandler } from './pasteEventHandler';
 import { collectBuildFilePattern, onExtensionChange } from "./plugin";
 import { pomCodeActionMetadata, PomCodeActionProvider } from "./pom/pomCodeActionProvider";
-import { ActionableNotification, BuildProjectParams, BuildProjectRequest, CompileWorkspaceRequest, CompileWorkspaceStatus, EventNotification, EventType, ExecuteClientCommandRequest, FeatureStatus, FindLinks, GradleCompatibilityInfo, LinkLocation, ProgressReportNotification, ServerNotification, SourceAttachmentAttribute, SourceAttachmentRequest, SourceAttachmentResult, StatusNotification, UpgradeGradleWrapperInfo } from "./protocol";
+import { ActionableNotification, BuildProjectParams, BuildProjectRequest, CompileWorkspaceRequest, CompileWorkspaceStatus, EventNotification, EventType, ExecuteClientCommandRequest, FeatureStatus, FindLinks, GradleCompatibilityInfo, LinkLocation, ProgressReportNotification, ServerNotification, SourceAttachmentAttribute, SourceAttachmentRequest, SourceAttachmentResult, SourceInvalidatedEvent, StatusNotification, UpgradeGradleWrapperInfo } from "./protocol";
 import * as refactorAction from './refactorAction';
 import { getJdkUrl, RequirementsData, sortJdksBySource, sortJdksByVersion } from "./requirements";
 import { serverStatus, ServerStatusKind } from "./serverStatus";
@@ -237,6 +237,23 @@ export class StandardLanguageClient {
 						});
 					}
 					break;
+				case EventType.sourceInvalidated:
+					const result = notification.data as SourceInvalidatedEvent;
+					const triggeredByUser: string[] = [];
+					const triggeredByAutoDownloadedSource: string[] = [];
+					Object.entries(result.affectedRootPaths || {})?.forEach(([key, value]) => {
+						if (value) {
+							triggeredByAutoDownloadedSource.push(key);
+						} else {
+							triggeredByUser.push(key);
+						}
+					});
+					if (triggeredByUser?.length) {
+						this.handleSourceInvalidatedEvent(triggeredByUser, false, jdtEventEmitter);
+					}
+					if (triggeredByAutoDownloadedSource?.length) {
+						this.handleSourceInvalidatedEvent(triggeredByAutoDownloadedSource, true, jdtEventEmitter);
+					}
 				default:
 					break;
 			}
@@ -652,6 +669,55 @@ export class StandardLanguageClient {
 	public getClientStatus(): ClientStatus {
 		return this.status;
 	}
+
+	private async handleSourceInvalidatedEvent(jars: string[], isAutoDownloadSource: boolean, jdtContentProviderEventEmitter: EventEmitter<Uri>): Promise<void> {
+		const changedJarNames: Set<string> = new Set();
+		for (const jar of jars) {
+			const path = jar.split(/\/|\\/);
+			if (path?.length) {
+				changedJarNames.add(path[path.length - 1]);
+			}
+		}
+
+		const affectedDocumentUris: Uri[] = [];
+		const affectedDocumentNames: string[] = [];
+		workspace.textDocuments.forEach(document => {
+			// Here is a sample jdt uri for classfile:
+			// jdt://contents/rt.jar/java.lang/System.class?...
+			if (document.uri.scheme === "jdt") {
+				const paths = document.uri.path?.split(/\/|\\/);
+				if (paths?.[1] && changedJarNames.has(paths[1])) {
+					affectedDocumentNames.push(paths[paths.length - 1]);
+					affectedDocumentUris.push(document.uri);
+				}
+			}
+		});
+		if (affectedDocumentUris.length) {
+			if (isAutoDownloadSource) {
+				const reloadSources = workspace.getConfiguration().get("java.editor.reloadChangedSources");
+				if (reloadSources === "manual") {
+					return;
+				}
+
+				if (reloadSources === "ask") {
+					const choice = await window.showWarningMessage(`The following class(es): ${affectedDocumentNames.map(name => `'${name}'`).join(", ")} ` +
+						"have new source jar available on the local Maven repository. Do you want to reload them?", "Yes", "Always", "No");
+					if (choice === "Always") {
+						workspace.getConfiguration().update("java.editor.reloadChangedSources", "auto", ConfigurationTarget.Global);
+					} else if (choice !== "Yes") {
+						return;
+					}
+				}
+			}
+			affectedDocumentUris.forEach(classFileUri => {
+				jdtContentProviderEventEmitter.fire(classFileUri);
+			});
+		}
+		apiManager.fireSourceInvalidatedEvent({
+			affectedRootPaths: jars,
+			affectedEditorDocuments: affectedDocumentUris,
+		});
+	}
 }
 
 async function showImportFinishNotification(context: ExtensionContext) {