add ActionWidgetService

src/vs/editor/contrib/codeAction/browser/codeAction.ts

@@ -33,9 +33,6 @@ export const sourceActionCommandId = 'editor.action.sourceAction';
 export const organizeImportsCommandId = 'editor.action.organizeImports';
 export const fixAllCommandId = 'editor.action.fixAll';
 
-export const acceptSelectedCodeActionCommand = 'acceptSelectedCodeAction';
-export const previewSelectedCodeActionCommand = 'previewSelectedCodeAction';
-
 class ManagedCodeActionSet extends Disposable implements CodeActionSet {
 
 	private static codeActionsPreferredComparator(a: languages.CodeAction, b: languages.CodeAction): number {

src/vs/editor/contrib/codeAction/browser/codeActionCommands.ts

@@ -16,12 +16,10 @@ import { IEditorContribution } from 'vs/editor/common/editorCommon';
 import { EditorContextKeys } from 'vs/editor/common/editorContextKeys';
 import { CodeActionTriggerType } from 'vs/editor/common/languages';
 import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
-import { acceptSelectedCodeActionCommand, applyCodeAction, ApplyCodeActionReason, codeActionCommandId, fixAllCommandId, organizeImportsCommandId, previewSelectedCodeActionCommand, refactorCommandId, refactorPreviewCommandId, sourceActionCommandId } from 'vs/editor/contrib/codeAction/browser/codeAction';
+import { applyCodeAction, ApplyCodeActionReason, codeActionCommandId, fixAllCommandId, organizeImportsCommandId, refactorCommandId, refactorPreviewCommandId, sourceActionCommandId } from 'vs/editor/contrib/codeAction/browser/codeAction';
 import { CodeActionUi } from 'vs/editor/contrib/codeAction/browser/codeActionUi';
-import { CodeActionWidget, Context } from 'vs/editor/contrib/codeAction/browser/codeActionWidget';
 import { MessageController } from 'vs/editor/contrib/message/browser/messageController';
 import * as nls from 'vs/nls';
-import { Action2, registerAction2 } from 'vs/platform/actions/common/actions';
 import { ContextKeyExpr, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
@@ -102,7 +100,7 @@ export class CodeActionController extends Disposable implements IEditorContribut
 		@IContextKeyService contextKeyService: IContextKeyService,
 		@IEditorProgressService progressService: IEditorProgressService,
 		@IInstantiationService private readonly _instantiationService: IInstantiationService,
-		@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
+		@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService
 	) {
 		super();
 
@@ -416,117 +414,3 @@ export class AutoFixAction extends EditorAction {
 			CodeActionAutoApply.IfSingle, undefined, CodeActionTriggerSource.AutoFix);
 	}
 }
-
-const weight = KeybindingWeight.EditorContrib + 1000;
-
-registerAction2(class extends Action2 {
-	constructor() {
-		super({
-			id: 'hideCodeActionWidget',
-			title: {
-				value: nls.localize('hideCodeActionWidget.title', "Hide code action widget"),
-				original: 'Hide code action widget'
-			},
-			precondition: Context.Visible,
-			keybinding: {
-				weight,
-				primary: KeyCode.Escape,
-				secondary: [KeyMod.Shift | KeyCode.Escape]
-			},
-		});
-	}
-
-	run(): void {
-		CodeActionWidget.INSTANCE?.hide();
-	}
-});
-
-registerAction2(class extends Action2 {
-	constructor() {
-		super({
-			id: 'selectPrevCodeAction',
-			title: {
-				value: nls.localize('selectPrevCodeAction.title', "Select previous code action"),
-				original: 'Select previous code action'
-			},
-			precondition: Context.Visible,
-			keybinding: {
-				weight,
-				primary: KeyCode.UpArrow,
-				secondary: [KeyMod.CtrlCmd | KeyCode.UpArrow],
-				mac: { primary: KeyCode.UpArrow, secondary: [KeyMod.CtrlCmd | KeyCode.UpArrow, KeyMod.WinCtrl | KeyCode.KeyP] },
-			}
-		});
-	}
-
-	run(): void {
-		CodeActionWidget.INSTANCE?.focusPrevious();
-	}
-});
-
-registerAction2(class extends Action2 {
-	constructor() {
-		super({
-			id: 'selectNextCodeAction',
-			title: {
-				value: nls.localize('selectNextCodeAction.title', "Select next code action"),
-				original: 'Select next code action'
-			},
-			precondition: Context.Visible,
-			keybinding: {
-				weight,
-				primary: KeyCode.DownArrow,
-				secondary: [KeyMod.CtrlCmd | KeyCode.DownArrow],
-				mac: { primary: KeyCode.DownArrow, secondary: [KeyMod.CtrlCmd | KeyCode.DownArrow, KeyMod.WinCtrl | KeyCode.KeyN] }
-			}
-		});
-	}
-
-	run(): void {
-		CodeActionWidget.INSTANCE?.focusNext();
-	}
-});
-
-registerAction2(class extends Action2 {
-	constructor() {
-		super({
-			id: acceptSelectedCodeActionCommand,
-			title: {
-				value: nls.localize('acceptSelected.title', "Accept selected code action"),
-				original: 'Accept selected code action'
-			},
-			precondition: Context.Visible,
-			keybinding: {
-				weight,
-				primary: KeyCode.Enter,
-				secondary: [KeyMod.CtrlCmd | KeyCode.Period],
-			}
-		});
-	}
-
-	run(): void {
-		CodeActionWidget.INSTANCE?.acceptSelected();
-	}
-});
-
-registerAction2(class extends Action2 {
-	constructor() {
-		super({
-			id: previewSelectedCodeActionCommand,
-			title: {
-				value: nls.localize('previewSelected.title', "Preview selected code action"),
-				original: 'Preview selected code action'
-			},
-			precondition: Context.Visible,
-			keybinding: {
-				weight,
-				primary: KeyMod.CtrlCmd | KeyCode.Enter,
-			}
-		});
-	}
-
-	run(): void {
-		CodeActionWidget.INSTANCE?.acceptSelected({ preview: true });
-	}
-});
-

src/vs/editor/contrib/codeAction/browser/codeActionKeybindingResolver.ts

@@ -8,6 +8,7 @@ import { Lazy } from 'vs/base/common/lazy';
 import { CodeAction } from 'vs/editor/common/languages';
 import { codeActionCommandId, fixAllCommandId, organizeImportsCommandId, refactorCommandId, sourceActionCommandId } from 'vs/editor/contrib/codeAction/browser/codeAction';
 import { CodeActionAutoApply, CodeActionCommandArgs, CodeActionKind } from 'vs/editor/contrib/codeAction/common/types';
+import { IActionKeybindingResolver } from 'vs/platform/actionWidget/common/actionWidget';
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 
 interface ResolveCodeActionKeybinding {
@@ -16,7 +17,7 @@ interface ResolveCodeActionKeybinding {
 	readonly resolvedKeybinding: ResolvedKeybinding;
 }
 
-export class CodeActionKeybindingResolver {
+export class CodeActionKeybindingResolver implements IActionKeybindingResolver {
 	private static readonly codeActionCommands: readonly string[] = [
 		refactorCommandId,
 		codeActionCommandId,

src/vs/editor/contrib/codeAction/browser/codeActionMenuItems.ts

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import 'vs/base/browser/ui/codicons/codiconStyles'; // The codicon symbol styles are defined here and must be loaded
+import { Codicon } from 'vs/base/common/codicons';
+import { ActionListItemKind, IListMenuItem } from 'vs/platform/actionWidget/browser/actionWidget';
+import { CodeActionItem, CodeActionKind } from 'vs/editor/contrib/codeAction/common/types';
+import 'vs/editor/contrib/symbolIcons/browser/symbolIcons'; // The codicon symbol colors are defined here and must be loaded to get colors
+import { localize } from 'vs/nls';
+
+export interface ActionGroup {
+	readonly kind: CodeActionKind;
+	readonly title: string;
+	readonly icon?: { readonly codicon: Codicon; readonly color?: string };
+}
+
+const uncategorizedCodeActionGroup = Object.freeze<ActionGroup>({ kind: CodeActionKind.Empty, title: localize('codeAction.widget.id.more', 'More Actions...') });
+
+const codeActionGroups = Object.freeze<ActionGroup[]>([
+	{ kind: CodeActionKind.QuickFix, title: localize('codeAction.widget.id.quickfix', 'Quick Fix...') },
+	{ kind: CodeActionKind.RefactorExtract, title: localize('codeAction.widget.id.extract', 'Extract...'), icon: { codicon: Codicon.wrench } },
+	{ kind: CodeActionKind.RefactorInline, title: localize('codeAction.widget.id.inline', 'Inline...'), icon: { codicon: Codicon.wrench } },
+	{ kind: CodeActionKind.RefactorRewrite, title: localize('codeAction.widget.id.convert', 'Rewrite...'), icon: { codicon: Codicon.wrench } },
+	{ kind: CodeActionKind.RefactorMove, title: localize('codeAction.widget.id.move', 'Move...'), icon: { codicon: Codicon.wrench } },
+	{ kind: CodeActionKind.SurroundWith, title: localize('codeAction.widget.id.surround', 'Surround With...'), icon: { codicon: Codicon.symbolSnippet } },
+	{ kind: CodeActionKind.Source, title: localize('codeAction.widget.id.source', 'Source Action...'), icon: { codicon: Codicon.symbolFile } },
+	uncategorizedCodeActionGroup,
+]);
+
+export function toMenuItems(inputCodeActions: readonly CodeActionItem[], showHeaders: boolean): IListMenuItem<CodeActionItem>[] {
+	if (!showHeaders) {
+		return inputCodeActions.map((action): IListMenuItem<CodeActionItem> => {
+			return {
+				kind: ActionListItemKind.Action,
+				item: action,
+				group: uncategorizedCodeActionGroup,
+				disabled: !!action.action.disabled,
+				label: action.action.disabled || action.action.title
+			};
+		});
+	}
+
+	// Group code actions
+	const menuEntries = codeActionGroups.map(group => ({ group, actions: [] as CodeActionItem[] }));
+
+	for (const action of inputCodeActions) {
+		const kind = action.action.kind ? new CodeActionKind(action.action.kind) : CodeActionKind.None;
+		for (const menuEntry of menuEntries) {
+			if (menuEntry.group.kind.contains(kind)) {
+				menuEntry.actions.push(action);
+				break;
+			}
+		}
+	}
+
+	const allMenuItems: IListMenuItem<CodeActionItem>[] = [];
+	for (const menuEntry of menuEntries) {
+		if (menuEntry.actions.length) {
+			allMenuItems.push({ kind: ActionListItemKind.Header, group: menuEntry.group });
+			for (const action of menuEntry.actions) {
+				allMenuItems.push({ kind: ActionListItemKind.Action, item: action, group: menuEntry.group, label: action.action.title, disabled: !!action.action.disabled });
+			}
+		}
+	}
+	return allMenuItems;
+}

src/vs/editor/contrib/codeAction/browser/codeActionUi.ts

@@ -12,14 +12,14 @@ import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { IPosition, Position } from 'vs/editor/common/core/position';
 import { ScrollType } from 'vs/editor/common/editorCommon';
 import { CodeActionTriggerType } from 'vs/editor/common/languages';
+import { IActionShowOptions, IActionWidgetService, IRenderDelegate } from 'vs/platform/actionWidget/browser/actionWidget';
 import { MessageController } from 'vs/editor/contrib/message/browser/messageController';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
-import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { CodeActionAutoApply, CodeActionItem, CodeActionSet, CodeActionTrigger } from '../common/types';
 import { CodeActionsState } from './codeActionModel';
-import { CodeActionShowOptions, CodeActionWidget } from './codeActionWidget';
 import { LightBulbWidget } from './lightBulbWidget';
+import { toMenuItems } from 'vs/editor/contrib/codeAction/browser/codeActionMenuItems';
 
 export class CodeActionUi extends Disposable {
 	private readonly _lightBulbWidget: Lazy<LightBulbWidget>;
@@ -35,19 +35,19 @@ export class CodeActionUi extends Disposable {
 			applyCodeAction: (action: CodeActionItem, regtriggerAfterApply: boolean, preview: boolean) => Promise<void>;
 		},
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
-		@IContextKeyService private readonly _contextKeyService: IContextKeyService,
-		@IInstantiationService private readonly _instantiationService: IInstantiationService,
+		@IInstantiationService readonly instantiationService: IInstantiationService,
+		@IActionWidgetService private readonly _actionWidgetService: IActionWidgetService
 	) {
 		super();
 
 
 		this._lightBulbWidget = new Lazy(() => {
-			const widget = this._register(_instantiationService.createInstance(LightBulbWidget, this._editor, quickFixActionId, preferredFixActionId));
+			const widget = this._register(instantiationService.createInstance(LightBulbWidget, this._editor, quickFixActionId, preferredFixActionId));
 			this._register(widget.onClick(e => this.showCodeActionList(e.trigger, e.actions, e, { includeDisabledActions: false, fromLightbulb: true, showHeaders: this.shouldShowHeaders() })));
 			return widget;
 		});
 
-		this._register(this._editor.onDidLayoutChange(() => CodeActionWidget.INSTANCE?.hide()));
+		this._register(this._editor.onDidLayoutChange(() => this._actionWidgetService.hide()));
 	}
 
 	override dispose() {
@@ -115,7 +115,7 @@ export class CodeActionUi extends Disposable {
 			this.showCodeActionList(newState.trigger, actions, this.toCoords(newState.position), { includeDisabledActions, fromLightbulb: false, showHeaders: this.shouldShowHeaders() });
 		} else {
 			// auto magically triggered
-			if (CodeActionWidget.INSTANCE?.isVisible) {
+			if (this._actionWidgetService.isVisible) {
 				// TODO: Figure out if we should update the showing menu?
 				actions.dispose();
 			} else {
@@ -152,22 +152,31 @@ export class CodeActionUi extends Disposable {
 		return undefined;
 	}
 
-	public async showCodeActionList(trigger: CodeActionTrigger, actions: CodeActionSet, at: IAnchor | IPosition, options: CodeActionShowOptions): Promise<void> {
+	public async showCodeActionList(trigger: CodeActionTrigger, actions: CodeActionSet, at: IAnchor | IPosition, options: IActionShowOptions): Promise<void> {
 		const editorDom = this._editor.getDomNode();
 		if (!editorDom) {
 			return;
 		}
 
 		const anchor = Position.isIPosition(at) ? this.toCoords(at) : at;
 
-		CodeActionWidget.getOrCreateInstance(this._instantiationService).show(trigger, actions, anchor, editorDom, { ...options, showHeaders: this.shouldShowHeaders() }, {
-			onSelectCodeAction: async (action, trigger, options) => {
-				this.delegate.applyCodeAction(action, /* retrigger */ true, Boolean(options.preview || trigger.preview));
+		const delegate: IRenderDelegate<CodeActionItem> = {
+			onSelect: async (action: CodeActionItem, preview?: boolean) => {
+				this.delegate.applyCodeAction(action, /* retrigger */ true, !!preview ? preview : false);
+				this._actionWidgetService.hide();
 			},
 			onHide: () => {
 				this._editor?.focus();
-			},
-		}, this._contextKeyService);
+			}
+		};
+		this._actionWidgetService.show(
+			'codeActionWidget',
+			toMenuItems,
+			delegate,
+			actions,
+			anchor,
+			editorDom,
+			{ ...options, showHeaders: this.shouldShowHeaders() });
 	}
 
 	private toCoords(position: IPosition): IAnchor {