Support advanced organizeImports to resolve ambiguous imports (#850)

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

Author: testforstephen

src/commands.ts

@@ -114,4 +114,12 @@ export namespace Commands {
      * Open settings.json
      */
     export const OPEN_JSON_SETTINGS = 'workbench.action.openSettingsJson';
+    /**
+     * Organize imports.
+     */
+    export const ORGANIZE_IMPORTS = "java.action.organizeImports";
+    /**
+     * Choose type to import.
+     */
+    export const CHOOSE_IMPORTS = "java.action.organizeImports.chooseImports";
 }

src/extension.ts

@@ -75,7 +75,8 @@ export function activate(context: ExtensionContext): Promise<ExtensionAPI> {
 							progressReportProvider: getJavaConfiguration().get('progressReports.enabled'),
 							classFileContentsSupport:true,
 							overrideMethodsPromptSupport:true,
-							hashCodeEqualsPromptSupport:true
+							hashCodeEqualsPromptSupport:true,
+							advancedOrganizeImportsSupport:true
 						},
 						triggerFiles: getTriggerFiles()
 					},

src/protocol.ts

@@ -1,7 +1,7 @@
 'use strict';
 
 import { RequestType, NotificationType, TextDocumentIdentifier, ExecuteCommandParams, CodeActionParams, WorkspaceEdit } from 'vscode-languageclient';
-import { Command } from 'vscode';
+import { Command, Range } from 'vscode';
 
 /**
  * The message type. Copied from vscode protocol
@@ -173,4 +173,18 @@ export interface GenerateHashCodeEqualsParams {
 
 export namespace GenerateHashCodeEqualsRequest {
     export const type = new RequestType<GenerateHashCodeEqualsParams, WorkspaceEdit, void, void>('java/generateHashCodeEquals');
+}
+
+export namespace OrganizeImportsRequest {
+    export const type = new RequestType<CodeActionParams, WorkspaceEdit, void, void>('java/organizeImports');
+}
+
+export interface ImportCandidate {
+    fullyQualifiedName: string;
+    id: string;
+}
+
+export interface ImportSelection {
+    candidates: ImportCandidate[];
+    range: Range;
 }

src/sourceAction.ts

@@ -1,14 +1,17 @@
 'use strict';
 
-import { commands, window, ExtensionContext } from 'vscode';
+import { commands, window, ExtensionContext, Range, ViewColumn, Uri, Disposable} from 'vscode';
 import { CodeActionParams, LanguageClient } from 'vscode-languageclient';
 import { Commands } from './commands';
 import { applyWorkspaceEdit } from './extension';
-import { ListOverridableMethodsRequest, AddOverridableMethodsRequest, CheckHashCodeEqualsStatusRequest, GenerateHashCodeEqualsRequest } from './protocol';
+import { ListOverridableMethodsRequest, AddOverridableMethodsRequest, CheckHashCodeEqualsStatusRequest, GenerateHashCodeEqualsRequest,
+OrganizeImportsRequest, ImportCandidate, ImportSelection } from './protocol';
 
 export function registerCommands(languageClient: LanguageClient, context: ExtensionContext) {
     registerOverrideMethodsCommand(languageClient, context);
     registerHashCodeEqualsCommand(languageClient, context);
+    registerOrganizeImportsCommand(languageClient, context);
+    registerChooseImportCommand(context);
 }
 
 function registerOverrideMethodsCommand(languageClient: LanguageClient, context: ExtensionContext): void {
@@ -100,3 +103,58 @@ function registerHashCodeEqualsCommand(languageClient: LanguageClient, context:
         applyWorkspaceEdit(workspaceEdit, languageClient);
     }));
 }
+
+function registerOrganizeImportsCommand(languageClient: LanguageClient, context: ExtensionContext): void {
+    context.subscriptions.push(commands.registerCommand(Commands.ORGANIZE_IMPORTS, async (params: CodeActionParams) => {
+        const workspaceEdit = await languageClient.sendRequest(OrganizeImportsRequest.type, params);
+        applyWorkspaceEdit(workspaceEdit, languageClient);
+    }));
+}
+
+function registerChooseImportCommand(context: ExtensionContext): void {
+    context.subscriptions.push(commands.registerCommand(Commands.CHOOSE_IMPORTS, async (uri: string, selections: ImportSelection[]) => {
+        const chosen: ImportCandidate[] = [];
+        const fileUri: Uri = Uri.parse(uri);
+        for (let i = 0; i < selections.length; i++) {
+            const selection : ImportSelection = selections[i];
+            // Move the cursor to the code line with ambiguous import choices.
+            await window.showTextDocument(fileUri, { preserveFocus: true, selection: selection.range, viewColumn: ViewColumn.One });
+            const candidates: ImportCandidate[] = selection.candidates;
+            const items = candidates.map((item) => {
+                return {
+                    label: item.fullyQualifiedName,
+                    origin: item
+                };
+            });
+
+            const fullyQualifiedName = candidates[0].fullyQualifiedName;
+            const typeName = fullyQualifiedName.substring(fullyQualifiedName.lastIndexOf(".") + 1);
+            const disposables: Disposable[] = [];
+            try {
+                const pick = await new Promise<any>((resolve, reject) => {
+                    const input = window.createQuickPick();
+                    input.title = "Organize Imports";
+                    input.step = i + 1;
+                    input.totalSteps = selections.length;
+                    input.placeholder = `Choose type '${typeName}' to import`;
+                    input.items = items;
+                    disposables.push(
+                        input.onDidChangeSelection(items => resolve(items[0])),
+                        input.onDidHide(() => {
+                            reject(undefined);
+                        }),
+                        input
+                    );
+                    input.show();
+                });
+                chosen.push(pick ? pick.origin : null);
+            } catch (err) {
+                break;
+            } finally {
+                disposables.forEach(d => d.dispose());
+            }
+        }
+
+        return chosen;
+    }));
+}

test/extension.test.ts

@@ -43,7 +43,9 @@ suite('Java Language Extension', () => {
 				Commands.LIST_SOURCEPATHS,
 				Commands.OVERRIDE_METHODS_PROMPT,
 				Commands.HASHCODE_EQUALS_PROMPT,
-				Commands.OPEN_JSON_SETTINGS
+				Commands.OPEN_JSON_SETTINGS,
+				Commands.ORGANIZE_IMPORTS,
+				Commands.CHOOSE_IMPORTS
 			];
 			let foundJavaCommands = commands.filter(function(value){
 				return JAVA_COMMANDS.indexOf(value)>=0 || value.startsWith('java.');