modernize vscode.executeSignatureHelpProvider-command

src/vs/editor/browser/editorExtensions.ts

@@ -4,8 +4,6 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as nls from 'vs/nls';
-import { IPosition } from 'vs/base/browser/ui/contextview/contextview';
-import { illegalArgument } from 'vs/base/common/errors';
 import { URI } from 'vs/base/common/uri';
 import { ICodeEditor, IDiffEditor } from 'vs/editor/browser/editorBrowser';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
@@ -413,43 +411,6 @@ export function registerLanguageCommand<Args extends { [n: string]: any; }>(id:
 	CommandsRegistry.registerCommand(id, (accessor, args) => handler(accessor, args || {}));
 }
 
-interface IDefaultArgs {
-	resource: URI;
-	position: IPosition;
-	[name: string]: any;
-}
-
-export function registerDefaultLanguageCommand(id: string, handler: (model: ITextModel, position: Position, args: IDefaultArgs) => any) {
-	registerLanguageCommand(id, function (accessor, args: IDefaultArgs) {
-
-		const { resource, position } = args;
-		if (!(resource instanceof URI)) {
-			throw illegalArgument('resource');
-		}
-		if (!Position.isIPosition(position)) {
-			throw illegalArgument('position');
-		}
-
-		const model = accessor.get(IModelService).getModel(resource);
-		if (model) {
-			const editorPosition = Position.lift(position);
-			return handler(model, editorPosition, args);
-		}
-
-		return accessor.get(ITextModelService).createModelReference(resource).then(reference => {
-			return new Promise((resolve, reject) => {
-				try {
-					const result = handler(reference.object.textEditorModel, Position.lift(position), args);
-					resolve(result);
-				} catch (err) {
-					reject(err);
-				}
-			}).finally(() => {
-				reference.dispose();
-			});
-		});
-	});
-}
 
 export function registerModelAndPositionCommand(id: string, handler: (model: ITextModel, position: Position, ...args: any[]) => any) {
 	CommandsRegistry.registerCommand(id, function (accessor, ...args) {

src/vs/editor/contrib/parameterHints/provideSignatureHelp.ts

@@ -5,12 +5,15 @@
 
 import { first } from 'vs/base/common/async';
 import { onUnexpectedExternalError } from 'vs/base/common/errors';
-import { registerDefaultLanguageCommand } from 'vs/editor/browser/editorExtensions';
-import { Position } from 'vs/editor/common/core/position';
+import { IPosition, Position } from 'vs/editor/common/core/position';
 import { ITextModel } from 'vs/editor/common/model';
 import * as modes from 'vs/editor/common/modes';
 import { RawContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { CancellationToken } from 'vs/base/common/cancellation';
+import { CommandsRegistry } from 'vs/platform/commands/common/commands';
+import { URI } from 'vs/base/common/uri';
+import { assertType } from 'vs/base/common/types';
+import { ITextModelService } from 'vs/editor/common/services/resolverService';
 
 export const Context = {
 	Visible: new RawContextKey<boolean>('parameterHintsVisible', false),
@@ -32,17 +35,29 @@ export function provideSignatureHelp(
 	}));
 }
 
-registerDefaultLanguageCommand('_executeSignatureHelpProvider', async (model, position, args) => {
-	const result = await provideSignatureHelp(model, position, {
-		triggerKind: modes.SignatureHelpTriggerKind.Invoke,
-		isRetrigger: false,
-		triggerCharacter: args['triggerCharacter']
-	}, CancellationToken.None);
+CommandsRegistry.registerCommand('_executeSignatureHelpProvider', async (accessor, ...args: [URI, IPosition, string?]) => {
+	const [uri, position, triggerCharacter] = args;
+	assertType(URI.isUri(uri));
+	assertType(Position.isIPosition(position));
+	assertType(typeof triggerCharacter === 'string' || !triggerCharacter);
 
-	if (!result) {
-		return undefined;
-	}
+	const ref = await accessor.get(ITextModelService).createModelReference(uri);
+	try {
+
+		const result = await provideSignatureHelp(ref.object.textEditorModel, Position.lift(position), {
+			triggerKind: modes.SignatureHelpTriggerKind.Invoke,
+			isRetrigger: false,
+			triggerCharacter,
+		}, CancellationToken.None);
+
+		if (!result) {
+			return undefined;
+		}
 
-	setTimeout(() => result.dispose(), 0);
-	return result.value;
+		setTimeout(() => result.dispose(), 0);
+		return result.value;
+
+	} finally {
+		ref.dispose();
+	}
 });

src/vs/workbench/api/common/extHostApiCommands.ts

@@ -252,7 +252,18 @@ const newCommands: ApiCommand[] = [
 			const items = value.suggestions.map(suggestion => typeConverters.CompletionItem.to(suggestion, converter));
 			return new types.CompletionList(items, value.incomplete);
 		})
-	)
+	),
+	// --- signature help
+	new ApiCommand(
+		'vscode.executeSignatureHelpProvider', '_executeSignatureHelpProvider', 'Execute signature help provider.',
+		[ApiCommandArgument.Uri, ApiCommandArgument.Position, new ApiCommandArgument('triggerCharacter', '(optional) Trigger signature help when the user types the character, like `,` or `(`', v => typeof v === 'string' || typeof v === 'undefined', v => v)],
+		new ApiCommandResult<modes.SignatureHelp, vscode.SignatureHelp | undefined>('A promise that resolves to SignatureHelp.', value => {
+			if (value) {
+				return typeConverters.SignatureHelp.to(value);
+			}
+			return undefined;
+		})
+	),
 ];
 
 //#endregion
@@ -275,15 +286,6 @@ export class ExtHostApiCommands {
 	}
 
 	registerCommands() {
-		this._register('vscode.executeSignatureHelpProvider', this._executeSignatureHelpProvider, {
-			description: 'Execute signature help provider.',
-			args: [
-				{ name: 'uri', description: 'Uri of a text document', constraint: URI },
-				{ name: 'position', description: 'Position in a text document', constraint: types.Position },
-				{ name: 'triggerCharacter', description: '(optional) Trigger signature help when the user types the character, like `,` or `(`', constraint: (value: any) => value === undefined || typeof value === 'string' }
-			],
-			returns: 'A promise that resolves to SignatureHelp.'
-		});
 
 		this._register('vscode.executeCodeActionProvider', this._executeCodeActionProvider, {
 			description: 'Execute code action provider.',
@@ -396,20 +398,6 @@ export class ExtHostApiCommands {
 		this._disposables.add(disposable);
 	}
 
-	private _executeSignatureHelpProvider(resource: URI, position: types.Position, triggerCharacter: string): Promise<types.SignatureHelp | undefined> {
-		const args = {
-			resource,
-			position: position && typeConverters.Position.from(position),
-			triggerCharacter
-		};
-		return this._commands.executeCommand<modes.SignatureHelp>('_executeSignatureHelpProvider', args).then(value => {
-			if (value) {
-				return typeConverters.SignatureHelp.to(value);
-			}
-			return undefined;
-		});
-	}
-
 	private _executeDocumentColorProvider(resource: URI): Promise<types.ColorInformation[]> {
 		const args = {
 			resource