* always show top N snippets and conditionally show action for all surroundable snippets

* remove `canExecute` which isn't needed - the "framework" makes sure we only called when it makes sense

* tweak styles to my preference and lipstick, try to contain things over loose functions and objects,

Author: jrieken

src/vs/workbench/contrib/snippets/browser/surroundWithSnippet.ts

@@ -14,159 +14,146 @@ import { ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
 import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
 import { pickSnippet } from 'vs/workbench/contrib/snippets/browser/snippetPicker';
 import { ISnippetsService } from './snippets.contribution';
-import { CancellationToken } from 'vs/base/common/cancellation';
-import { Disposable } from 'vs/base/common/lifecycle';
+import { IDisposable } from 'vs/base/common/lifecycle';
 import { ITextModel } from 'vs/editor/common/model';
-import { CodeAction, CodeActionProvider, CodeActionContext, CodeActionList } from 'vs/editor/common/languages';
+import { CodeAction, CodeActionProvider, CodeActionList } from 'vs/editor/common/languages';
 import { CodeActionKind } from 'vs/editor/contrib/codeAction/browser/types';
 import { ILanguageFeaturesService } from 'vs/editor/common/services/languageFeatures';
 import { Range, IRange } from 'vs/editor/common/core/range';
-import { URI } from 'vs/base/common/uri';
 import { Selection } from 'vs/editor/common/core/selection';
 import { Snippet } from 'vs/workbench/contrib/snippets/browser/snippetsFile';
 import { Registry } from 'vs/platform/registry/common/platform';
 import { IWorkbenchContributionsRegistry, Extensions as WorkbenchExtensions, IWorkbenchContribution } from 'vs/workbench/common/contributions';
 import { LifecyclePhase } from 'vs/workbench/services/lifecycle/common/lifecycle';
 import { Position } from 'vs/editor/common/core/position';
-import { IEditorService } from 'vs/workbench/services/editor/common/editorService';
-import { EditorInputCapabilities } from 'vs/workbench/common/editor';
-
-const options = {
-	id: 'editor.action.surroundWithSnippet',
-	title: {
-		value: localize('label', 'Surround With Snippet...'),
-		original: 'Surround With Snippet...'
-	},
-	precondition: ContextKeyExpr.and(
-		EditorContextKeys.writable,
-		EditorContextKeys.hasNonEmptySelection
-	),
-	f1: true,
-};
-
-const MAX_SNIPPETS_ON_CODE_ACTIONS_MENU = 6;
-
-function makeCodeActionForSnippet(snippet: Snippet, resource: URI, range: IRange): CodeAction {
-	const title = localize('codeAction', "Surround With Snippet: {0}", snippet.name);
-	return {
-		title,
-		edit: {
-			edits: [
-				{
-					versionId: undefined,
-					resource: resource,
-					textEdit: {
-						insertAsSnippet: true,
-						text: snippet.body,
-						range: range
-					}
-				}
-			]
-		}
-	};
-}
-
-async function getSurroundableSnippets(accessor: ServicesAccessor, model: ITextModel | null, position: Position | null): Promise<Snippet[]> {
-	if (!model) {
-		return [];
-	}
 
-	const snippetsService = accessor.get(ISnippetsService);
+async function getSurroundableSnippets(snippetsService: ISnippetsService, model: ITextModel, position: Position): Promise<Snippet[]> {
 
-	let languageId: string;
-	if (position) {
-		const { lineNumber, column } = position;
-		model.tokenization.tokenizeIfCheap(lineNumber);
-		languageId = model.getLanguageIdAtPosition(lineNumber, column);
-	} else {
-		languageId = model.getLanguageId();
-	}
+	const { lineNumber, column } = position;
+	model.tokenization.tokenizeIfCheap(lineNumber);
+	const languageId = model.getLanguageIdAtPosition(lineNumber, column);
 
 	const allSnippets = await snippetsService.getSnippets(languageId, { includeNoPrefixSnippets: true, includeDisabledSnippets: true });
 	return allSnippets.filter(snippet => snippet.usesSelection);
 }
 
-function canExecute(accessor: ServicesAccessor): boolean {
-	const editorService = accessor.get(IEditorService);
+class SurroundWithSnippetEditorAction extends EditorAction2 {
 
-	const editor = editorService.activeEditor;
-	if (!editor || editor.hasCapability(EditorInputCapabilities.Readonly)) {
-		return false;
+	static readonly options = {
+		id: 'editor.action.surroundWithSnippet',
+		title: {
+			value: localize('label', 'Surround With Snippet...'),
+			original: 'Surround With Snippet...'
+		}
+	};
+
+	constructor() {
+		super({
+			...SurroundWithSnippetEditorAction.options,
+			precondition: ContextKeyExpr.and(
+				EditorContextKeys.writable,
+				EditorContextKeys.hasNonEmptySelection
+			),
+			f1: true,
+		});
 	}
-	const selections = editorService.activeTextEditorControl?.getSelections();
-	return !!selections && selections.length > 0;
-}
 
-async function surroundWithSnippet(accessor: ServicesAccessor, editor: ICodeEditor) {
-	const instaService = accessor.get(IInstantiationService);
-	const clipboardService = accessor.get(IClipboardService);
+	async runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor) {
+		if (!editor.hasModel()) {
+			return;
+		}
 
-	if (!canExecute(accessor)) {
-		return;
-	}
+		const instaService = accessor.get(IInstantiationService);
+		const snippetsService = accessor.get(ISnippetsService);
+		const clipboardService = accessor.get(IClipboardService);
 
-	const snippets = await getSurroundableSnippets(accessor, editor.getModel(), editor.getPosition());
-	if (!snippets.length) {
-		return;
-	}
+		const snippets = await getSurroundableSnippets(snippetsService, editor.getModel(), editor.getPosition());
+		if (!snippets.length) {
+			return;
+		}
 
-	const snippet = await instaService.invokeFunction(pickSnippet, snippets);
-	if (!snippet) {
-		return;
-	}
+		const snippet = await instaService.invokeFunction(pickSnippet, snippets);
+		if (!snippet) {
+			return;
+		}
 
-	let clipboardText: string | undefined;
-	if (snippet.needsClipboard) {
-		clipboardText = await clipboardService.readText();
-	}
+		let clipboardText: string | undefined;
+		if (snippet.needsClipboard) {
+			clipboardText = await clipboardService.readText();
+		}
 
-	SnippetController2.get(editor)?.insert(snippet.codeSnippet, { clipboardText });
+		SnippetController2.get(editor)?.insert(snippet.codeSnippet, { clipboardText });
+	}
 }
 
 
-registerAction2(class SurroundWithSnippetEditorAction extends EditorAction2 {
-	constructor() {
-		super(options);
-	}
-	async runEditorCommand(accessor: ServicesAccessor, editor: ICodeEditor, ...args: any[]) {
-		await surroundWithSnippet(accessor, editor);
-	}
-});
+class SurroundWithSnippetCodeActionProvider implements CodeActionProvider, IWorkbenchContribution {
+
+	private static readonly _MAX_CODE_ACTIONS = 4;
 
-export class SurroundWithSnippetCodeActionProvider extends Disposable implements CodeActionProvider, IWorkbenchContribution {
-	private static readonly overflowCodeAction: CodeAction = {
+	private static readonly _overflowCommandCodeAction: CodeAction = {
 		kind: CodeActionKind.Refactor.value,
-		title: options.title.value,
+		title: SurroundWithSnippetEditorAction.options.title.value,
 		command: {
-			id: options.id,
-			title: options.title.value,
+			id: SurroundWithSnippetEditorAction.options.id,
+			title: SurroundWithSnippetEditorAction.options.title.value,
 		},
 	};
 
+	private readonly _registration: IDisposable;
+
 	constructor(
+		@ISnippetsService private readonly _snippetService: ISnippetsService,
 		@ILanguageFeaturesService languageFeaturesService: ILanguageFeaturesService,
-		@IInstantiationService private readonly instaService: IInstantiationService,
 	) {
-		super();
-		this._register(languageFeaturesService.codeActionProvider.register('*', this));
+		this._registration = languageFeaturesService.codeActionProvider.register('*', this);
 	}
 
-	async provideCodeActions(model: ITextModel, range: Range | Selection, context: CodeActionContext, token: CancellationToken): Promise<CodeActionList> {
-		if (!this.instaService.invokeFunction(canExecute)) {
-			return { actions: [], dispose: () => { } };
-		}
+	dispose(): void {
+		this._registration.dispose();
+	}
 
-		const snippets = await this.instaService.invokeFunction(accessor => getSurroundableSnippets(accessor, model, range.getEndPosition()));
+	async provideCodeActions(model: ITextModel, range: Range | Selection): Promise<CodeActionList | undefined> {
+
+		const snippets = await getSurroundableSnippets(this._snippetService, model, range.getEndPosition());
 		if (!snippets.length) {
-			return { actions: [], dispose: () => { } };
+			return undefined;
+		}
+
+		const actions: CodeAction[] = [];
+		const hasMore = snippets.length > SurroundWithSnippetCodeActionProvider._MAX_CODE_ACTIONS;
+		const len = Math.min(snippets.length, SurroundWithSnippetCodeActionProvider._MAX_CODE_ACTIONS);
+
+		for (let i = 0; i < len; i++) {
+			actions.push(this._makeCodeActionForSnippet(snippets[i], model, range));
+		}
+		if (hasMore) {
+			actions.push(SurroundWithSnippetCodeActionProvider._overflowCommandCodeAction);
 		}
 		return {
-			actions: snippets.length <= MAX_SNIPPETS_ON_CODE_ACTIONS_MENU
-				? snippets.map(x => makeCodeActionForSnippet(x, model.uri, range))
-				: [SurroundWithSnippetCodeActionProvider.overflowCodeAction],
-			dispose: () => { }
+			actions,
+			dispose() { }
+		};
+	}
+
+	private _makeCodeActionForSnippet(snippet: Snippet, model: ITextModel, range: IRange): CodeAction {
+		return {
+			title: localize('codeAction', "Surround With: {0}", snippet.name),
+			kind: CodeActionKind.Refactor.value,
+			edit: {
+				edits: [{
+					versionId: model.getVersionId(),
+					resource: model.uri,
+					textEdit: {
+						range,
+						text: snippet.body,
+						insertAsSnippet: true,
+					}
+				}]
+			}
 		};
 	}
 }
 
+registerAction2(SurroundWithSnippetEditorAction);
 Registry.as<IWorkbenchContributionsRegistry>(WorkbenchExtensions.Workbench).registerWorkbenchContribution(SurroundWithSnippetCodeActionProvider, LifecyclePhase.Restored);