diff --git a/extensions/search-result/src/extension.ts b/extensions/search-result/src/extension.ts index 6bc5a573c95..d84455a5671 100644 --- a/extensions/search-result/src/extension.ts +++ b/extensions/search-result/src/extension.ts @@ -98,7 +98,7 @@ export function activate(context: vscode.ExtensionContext) { }), vscode.languages.registerDocumentLinkProvider(SEARCH_RESULT_SELECTOR, { - async provideDocumentLinks(document: vscode.TextDocument, token: vscode.CancellationToken): Promise { + async provideDocumentLinks(document: vscode.TextDocument, token: vscode.CancellationToken): Promise { return parseSearchResults(document, token) .filter(isFileLine) .map(({ location }) => ({ range: location.originSelectionRange!, target: location.targetUri })); @@ -141,7 +141,7 @@ function relativePathToUri(path: string, resultsUri: vscode.Uri): vscode.Uri | u } const uriFromFolderWithPath = (folder: vscode.WorkspaceFolder, path: string): vscode.Uri => - vscode.Uri.joinPath(folder.uri, path); + (vscode.Uri as any).joinPath(folder.uri, path); if (vscode.workspace.workspaceFolders) { const multiRootFormattedPath = /^(.*) • (.*)$/.exec(path); diff --git a/extensions/typescript-language-features/src/languageFeatures/signatureArgumentsLabel.ts b/extensions/typescript-language-features/src/languageFeatures/signatureArgumentsLabel.ts new file mode 100644 index 00000000000..4870f30fd20 --- /dev/null +++ b/extensions/typescript-language-features/src/languageFeatures/signatureArgumentsLabel.ts @@ -0,0 +1,57 @@ +import * as vscode from 'vscode'; +import { DocumentSelector } from '../utils/documentSelector'; +import { ClientCapability, ITypeScriptServiceClient } from '../typescriptService'; +import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration'; +import FileConfigurationManager from './fileConfigurationManager'; +import { Position } from 'vscode'; + +class TypeScriptSginatureArgumentsLabelProvider implements vscode.SignatureArgumentsLabelProvider { + constructor( + private readonly client: ITypeScriptServiceClient, + private readonly fileConfigurationManager: FileConfigurationManager + ) { + if (this.client && this.fileConfigurationManager) { + // nothing + } + vscode.window.showInformationMessage("Loaded") + } + + provideSignatureArgumentsLabels(model: vscode.TextDocument, token: vscode.CancellationToken): vscode.ProviderResult { + if (model && token) { + // void + } + + vscode.window.showInformationMessage("Provided") + return { + signatures: [ + { + arguments: [ + { + name: 'foo', + positions: [ + new Position(1, 1) + ] + } + ] + } + ], + dispose() { + // nothing + } + } + } + +} + +export function register( + selector: DocumentSelector, + client: ITypeScriptServiceClient, + fileConfigurationManager: FileConfigurationManager, +) { + return conditionalRegistration([ + requireSomeCapability(client, ClientCapability.Semantic), + ], () => { + return vscode.languages.registerSignatureArgumentsLabelProvider(selector.semantic, + new TypeScriptSginatureArgumentsLabelProvider(client, fileConfigurationManager)); + }); +} diff --git a/extensions/typescript-language-features/src/languageProvider.ts b/extensions/typescript-language-features/src/languageProvider.ts index 92ab84be308..94c460058ae 100644 --- a/extensions/typescript-language-features/src/languageProvider.ts +++ b/extensions/typescript-language-features/src/languageProvider.ts @@ -82,6 +82,7 @@ export default class LanguageProvider extends Disposable { import('./languageFeatures/typeDefinitions').then(provider => this._register(provider.register(selector, this.client))), import('./languageFeatures/semanticTokens').then(provider => this._register(provider.register(selector, this.client))), import('./languageFeatures/callHierarchy').then(provider => this._register(provider.register(selector, this.client))), + import('./languageFeatures/signatureArgumentsLabel').then(provider => this._register(provider.register(selector, this.client, this.fileConfigurationManager))), ]); } diff --git a/src/vs/editor/common/config/editorOptions.ts b/src/vs/editor/common/config/editorOptions.ts index 14914608be8..c9b464dd296 100644 --- a/src/vs/editor/common/config/editorOptions.ts +++ b/src/vs/editor/common/config/editorOptions.ts @@ -3759,8 +3759,6 @@ export const enum EditorOption { wrappingIndent, wrappingStrategy, showDeprecated, - signatureArgumentsLabel, - // Leave these at the end (because they have dependencies!) editorClassName, pixelRatio, diff --git a/src/vs/editor/contrib/signatureArgumentsLabel/signatureArgumentsLabel.ts b/src/vs/editor/contrib/signatureArgumentsLabel/signatureArgumentsLabel.ts index c70d89279cf..a10494465db 100644 --- a/src/vs/editor/contrib/signatureArgumentsLabel/signatureArgumentsLabel.ts +++ b/src/vs/editor/contrib/signatureArgumentsLabel/signatureArgumentsLabel.ts @@ -1,135 +1,253 @@ -import { CancelablePromise, createCancelablePromise, RunOnceScheduler } from 'vs/base/common/async'; -import { CancellationToken } from 'vs/base/common/cancellation'; -import { onUnexpectedError, onUnexpectedExternalError } from 'vs/base/common/errors'; -import { DisposableStore } from 'vs/base/common/lifecycle'; +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +import { CancelablePromise, TimeoutTimer, createCancelablePromise } from 'vs/base/common/async'; +import { onUnexpectedError } from 'vs/base/common/errors'; +import { hash } from 'vs/base/common/hash'; +import { Disposable, DisposableStore } from 'vs/base/common/lifecycle'; import { ICodeEditor } from 'vs/editor/browser/editorBrowser'; import { registerEditorContribution } from 'vs/editor/browser/editorExtensions'; -import { EditorOption } from 'vs/editor/common/config/editorOptions'; +import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService'; import { IEditorContribution } from 'vs/editor/common/editorCommon'; -import { ITextModel } from 'vs/editor/common/model'; -import { SignatureArgumentsLabelProviderRegistry, SignatureArgumentsLabelProvider, SignatureArgumentsSignature, SignatureArgumentsLabelList } from 'vs/editor/common/modes'; -import { LanguageFeatureRequestDelays } from 'vs/editor/common/modes/languageFeatureRegistry'; +import { IModelDeltaDecoration, ITextModel } from 'vs/editor/common/model'; +import { ModelDecorationOptions } from 'vs/editor/common/model/textModel'; +import { SignatureArgumentsLabelProvider, SignatureArgumentsLabelProviderRegistry, SignautreArguments } from 'vs/editor/common/modes'; +import { EditorOption } from 'vs/editor/common/config/editorOptions'; +import { CancellationToken } from 'vscode'; +import { flatten } from 'vs/base/common/arrays';; +import { INotificationService } from 'vs/platform/notification/common/notification'; -export interface SignatureArgumentsLabelItem { - signature: SignatureArgumentsSignature; +const MAX_DECORATORS = 500; + +export interface SignatureArgumentsLabelData { + arguments: SignautreArguments[]; provider: SignatureArgumentsLabelProvider; } - -class SignatureArgumentsLabelModel { - signatures: SignatureArgumentsLabelItem[] = []; - - private readonly _disposables = new DisposableStore(); - - dispose(): void { - this._disposables.dispose(); - } - - add(list: SignatureArgumentsLabelList, provider: SignatureArgumentsLabelProvider): void { - this._disposables.add(list); - for (const signature of list.signatures) { - this.signatures.push({ signature, provider }); - } - } -} - -async function getSignatureArgumentsLabelModel(model: ITextModel, token: CancellationToken) { - const provider = SignatureArgumentsLabelProviderRegistry.ordered(model); - const providerRanks = new Map(); - const result = new SignatureArgumentsLabelModel(); - - const promises = provider.map(async (provider, i) => { - - providerRanks.set(provider, i); - - try { - const list = await Promise.resolve(provider.provideSignatureArgumentsLabels(model, token)); - if (list) { - result.add(list, provider); +export function getSignatures(model: ITextModel, token: CancellationToken): Promise { + const datas: SignatureArgumentsLabelData[] = []; + const providers = SignatureArgumentsLabelProviderRegistry.ordered(model).reverse(); + const promises = providers.map(provider => Promise.resolve(provider.provideSignatureArgumentsLabels(model, token)).then(result => { + if (result) { + for (let signature of result.signatures) { + datas.push({ arguments: signature.arguments, provider }); } - } catch (err) { - onUnexpectedExternalError(err); } - }); + })); - await Promise.all(promises); - return result; + return Promise.all(promises).then(() => datas); } -class SignatureArgumentsLabelController implements IEditorContribution { +export class SignatureArgumentsLabelDetector extends Disposable implements IEditorContribution { - public static readonly ID = 'editor.contrib.signatureArgumentsLabel'; + public static readonly ID: string = 'editor.contrib.signatureArgumentsLabel'; - static get(editor: ICodeEditor): SignatureArgumentsLabelController { - return editor.getContribution(SignatureArgumentsLabelController.ID); - } + static readonly RECOMPUTE_TIME = 1000; // ms - private readonly _disposables = new DisposableStore(); + private readonly _localToDispose = this._register(new DisposableStore()); + private _computePromise: CancelablePromise | null; + private _timeoutTimer: TimeoutTimer | null; - private readonly _getSignatureArgumentsLabelModelDelays = new LanguageFeatureRequestDelays(SignatureArgumentsLabelProviderRegistry, 250, 2500); - private _getSignatureArgumentsLabelModelPromise: CancelablePromise | undefined; - private _oldSignatureArgumentsLabelModels = new DisposableStore(); - private _currentSignatureArgumentsLabelModel: SignatureArgumentsLabelModel | undefined; + private _decorationsIds: string[] = []; + private _labelDatas = new Map(); - constructor( - private readonly _editor: ICodeEditor + private _labelDecoratorIds: string[] = []; + private readonly _decorationsTypes = new Set(); + + private _isEnabled: boolean; + + constructor(private readonly _editor: ICodeEditor, + @ICodeEditorService private readonly _codeEditorService: ICodeEditorService, + @INotificationService private readonly _notificationService: INotificationService, ) { - this._disposables.add(this._editor.onDidChangeModel(() => this._onModelChange())); - this._disposables.add(this._editor.onDidChangeModelLanguage(() => this._onModelChange())); - this._disposables.add(this._editor.onDidChangeConfiguration((e) => { - + super(); + this._notificationService.info("wtf"); + this._register(_editor.onDidChangeModel(() => { + this._isEnabled = this.isEnabled(); + this.onModelChanged(); })); - this._disposables.add(SignatureArgumentsLabelProviderRegistry.onDidChange(this._onModelChange, this)); - this._onModelChange(); + this._register(_editor.onDidChangeModelLanguage(() => this.onModelChanged())); + this._register(SignatureArgumentsLabelProviderRegistry.onDidChange(() => this.onModelChanged())); + this._register(_editor.onDidChangeConfiguration(() => { + let prevIsEnabled = this._isEnabled; + this._isEnabled = this.isEnabled(); + if (prevIsEnabled !== this._isEnabled) { + if (this._isEnabled) { + this.onModelChanged(); + } else { + this.removeAllDecorations(); + } + } + })); + + this._timeoutTimer = null; + this._computePromise = null; + this._isEnabled = this.isEnabled(); + this.onModelChanged(); } - dispose(): void { - this._localDispose(); - this._disposables.dispose(); - } - - private _localDispose(): void { - - } - - private _onModelChange(): void { - this._localDispose(); - + isEnabled(): boolean { const model = this._editor.getModel(); if (!model) { - return; + return false; } - if (!this._editor.getOption(EditorOption.signatureArgumentsLabel)) { - return; - } - - const scheduler = new RunOnceScheduler(() => { - const t1 = Date.now(); - - this._getSignatureArgumentsLabelModelPromise?.cancel(); - this._getSignatureArgumentsLabelModelPromise = createCancelablePromise(token => getSignatureArgumentsLabelModel(model, token)); - - this._getSignatureArgumentsLabelModelPromise.then(result => { - if (this._currentSignatureArgumentsLabelModel) { - this._oldSignatureArgumentsLabelModels.add(this._currentSignatureArgumentsLabelModel); - } - this._currentSignatureArgumentsLabelModel = result; - - // update moving average - const newDelay = this._getSignatureArgumentsLabelModelDelays.update(model, Date.now() - t1); - scheduler.delay = newDelay; - - // render lenses - this._renderSignatureArgumentsLabels(result); - }, onUnexpectedError); - - }, this._getSignatureArgumentsLabelModelDelays.get(model)); + return this._editor.getOption(EditorOption.colorDecorators); } - _renderSignatureArgumentsLabels(result: SignatureArgumentsLabelModel) { + static get(editor: ICodeEditor): SignatureArgumentsLabelDetector { + return editor.getContribution(this.ID); + } + dispose(): void { + this.stop(); + this.removeAllDecorations(); + super.dispose(); + } + + private onModelChanged(): void { + this.stop(); + + if (!this._isEnabled) { + return; + } + const model = this._editor.getModel(); + + if (!model || !SignatureArgumentsLabelProviderRegistry.has(model)) { + return; + } + + this._localToDispose.add(this._editor.onDidChangeModelContent(() => { + if (!this._timeoutTimer) { + this._timeoutTimer = new TimeoutTimer(); + this._timeoutTimer.cancelAndSet(() => { + this._timeoutTimer = null; + + this.beginCompute(); + }, SignatureArgumentsLabelDetector.RECOMPUTE_TIME); + } + })); + this.beginCompute(); + } + + private beginCompute(): void { + this._computePromise = createCancelablePromise(token => { + const model = this._editor.getModel(); + if (!model) { + return Promise.resolve([]); + } + return getSignatures(model, token); + }); + this._computePromise.then((labelData) => { + this.updateDecorations(labelData); + this.updateLabelDecorators(labelData); + this._computePromise = null; + }, onUnexpectedError); + } + + private stop(): void { + if (this._timeoutTimer) { + this._timeoutTimer.cancel(); + this._timeoutTimer = null; + } + if (this._computePromise) { + this._computePromise.cancel(); + this._computePromise = null; + } + this._localToDispose.clear(); + } + + private updateDecorations(labelData: SignatureArgumentsLabelData[]): void { + + this._notificationService.info("updateDecorations"); + + const decorations = flatten(flatten(labelData.map(args => args.arguments.map(arg => { + return arg.positions.map(pos => { + return { + range: { + startLineNumber: pos.lineNumber, + startColumn: pos.column, + endLineNumber: pos.lineNumber, + endColumn: pos.column + }, + options: ModelDecorationOptions.EMPTY + } + }) + })))); + + this._decorationsIds = this._editor.deltaDecorations(this._decorationsIds, decorations); + + this._labelDatas = new Map(); + this._decorationsIds.forEach((id, i) => this._labelDatas.set(id, labelData[i])); + } + + private updateLabelDecorators(signatures: SignatureArgumentsLabelData[]): void { + + this._notificationService.info("updateLabelDecorators"); + + let decorations: IModelDeltaDecoration[] = []; + let newDecorationsTypes: { [key: string]: boolean } = {}; + + for (let i = 0; i < signatures.length; i++) { + const args = signatures[i].arguments; + for (let j = 0; j < args.length && decorations.length < MAX_DECORATORS; j++) { + const { name, positions } = args[j] + + const subKey = hash(name).toString(16); + let key = 'signatureArgumentsLabel-' + subKey; + + if (!this._decorationsTypes.has(key) && !newDecorationsTypes[key]) { + this._codeEditorService.registerDecorationType(key, { + before: { + contentText: `${name}:`, + border: 'solid 1px gray', + backgroundColor: '#333', + margin: '1px', + color: 'white' + } + }, undefined, this._editor); + } + + newDecorationsTypes[key] = true; + + + for (let k = 0; k < positions.length && decorations.length < MAX_DECORATORS; ++k) { + const pos = positions[k] + decorations.push({ + range: { + startLineNumber: pos.lineNumber, + startColumn: pos.column, + endLineNumber: pos.lineNumber, + endColumn: pos.column + }, + options: this._codeEditorService.resolveDecorationOptions(key, true) + }); + } + } + } + + + this._notificationService.info(`${decorations.length} length`) + + this._decorationsTypes.forEach(subType => { + if (!newDecorationsTypes[subType]) { + this._codeEditorService.removeDecorationType(subType); + } + }); + + this._labelDecoratorIds = this._editor.deltaDecorations(this._labelDecoratorIds, decorations); + } + + private removeAllDecorations(): void { + this._decorationsIds = this._editor.deltaDecorations(this._decorationsIds, []); + this._labelDecoratorIds = this._editor.deltaDecorations(this._labelDecoratorIds, []); + + this._decorationsTypes.forEach(subType => { + this._codeEditorService.removeDecorationType(subType); + }); } } -registerEditorContribution(SignatureArgumentsLabelController.ID, SignatureArgumentsLabelController); +registerEditorContribution(SignatureArgumentsLabelDetector.ID, SignatureArgumentsLabelDetector); diff --git a/src/vs/editor/editor.all.ts b/src/vs/editor/editor.all.ts index 904283213ac..19b3b7637f3 100644 --- a/src/vs/editor/editor.all.ts +++ b/src/vs/editor/editor.all.ts @@ -46,6 +46,7 @@ import 'vs/editor/contrib/viewportSemanticTokens/viewportSemanticTokens'; import 'vs/editor/contrib/wordHighlighter/wordHighlighter'; import 'vs/editor/contrib/wordOperations/wordOperations'; import 'vs/editor/contrib/wordPartOperations/wordPartOperations'; +import 'vs/editor/contrib/signatureArgumentsLabel/signatureArgumentsLabel'; // Load up these strings even in VSCode, even if they are not used // in order to get them translated diff --git a/src/vs/monaco.d.ts b/src/vs/monaco.d.ts index 64ddb94e92b..8f9294e6996 100644 --- a/src/vs/monaco.d.ts +++ b/src/vs/monaco.d.ts @@ -6361,6 +6361,24 @@ declare namespace monaco.languages { resolveCodeLens?(model: editor.ITextModel, codeLens: CodeLens, token: CancellationToken): ProviderResult; } + export interface SignautreArguments { + name: string; + positions: IPosition[]; + } + + export interface SignatureArgumentsSignature { + arguments: SignautreArguments[]; + } + + export interface SignatureArgumentsLabelList { + signatures: SignatureArgumentsSignature[]; + dispose(): void; + } + + export interface SignatureArgumentsLabelProvider { + provideSignatureArgumentsLabels(model: editor.ITextModel, token: CancellationToken): ProviderResult; + } + export interface SemanticTokensLegend { readonly tokenTypes: string[]; readonly tokenModifiers: string[]; diff --git a/src/vs/vscode.d.ts b/src/vs/vscode.d.ts index 028a0430040..a1609c987d0 100644 --- a/src/vs/vscode.d.ts +++ b/src/vs/vscode.d.ts @@ -10853,6 +10853,8 @@ declare module 'vscode' { export function registerSignatureHelpProvider(selector: DocumentSelector, provider: SignatureHelpProvider, ...triggerCharacters: string[]): Disposable; export function registerSignatureHelpProvider(selector: DocumentSelector, provider: SignatureHelpProvider, metadata: SignatureHelpProviderMetadata): Disposable; + export function registerSignatureArgumentsLabelProvider(selector: DocumentSelector, provider: SignatureArgumentsLabelProvider): Disposable; + /** * Register a document link provider. * diff --git a/src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts b/src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts index a0f4b2def79..451605681d0 100644 --- a/src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts +++ b/src/vs/workbench/api/browser/mainThreadLanguageFeatures.ts @@ -499,10 +499,20 @@ export class MainThreadLanguageFeatures implements MainThreadLanguageFeaturesSha // --- parameter labels - $registerSignatureArgumentsLabelSupport(handle: number, selector: IDocumentFilterDto[]): void { + $registerSignatureArgumentsLabelProvider(handle: number, selector: IDocumentFilterDto[]): void { this._registrations.set(handle, modes.SignatureArgumentsLabelProviderRegistry.register(selector, { provideSignatureArgumentsLabels: async (model: ITextModel, token: CancellationToken): Promise => { - return this._proxy.$provideSignatureArgumentsLabel(handle, model.uri, token); + const result = await this._proxy.$provideSignatureArgumentsLabel(handle, model.uri, token); + + if (!result) { + return undefined + } + return { + signatures: result.signatures, + dispose: () => { + + } + } } })); } diff --git a/src/vs/workbench/api/common/extHost.api.impl.ts b/src/vs/workbench/api/common/extHost.api.impl.ts index 6d6bdd4bd2d..35e00f2bb1e 100644 --- a/src/vs/workbench/api/common/extHost.api.impl.ts +++ b/src/vs/workbench/api/common/extHost.api.impl.ts @@ -482,6 +482,9 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I getTokenInformationAtPosition(doc: vscode.TextDocument, pos: vscode.Position) { checkProposedApiEnabled(extension); return extHostLanguages.tokenAtPosition(doc, pos); + }, + registerSignatureArgumentsLabelProvider(selector: vscode.DocumentSelector, provider: vscode.SignatureArgumentsLabelProvider): vscode.Disposable { + return extHostLanguageFeatures.registerSignatureArgumentsLabelProvider(extension, selector, provider) } }; diff --git a/src/vs/workbench/api/common/extHost.protocol.ts b/src/vs/workbench/api/common/extHost.protocol.ts index e133a331a3c..9dbc36a5b1c 100644 --- a/src/vs/workbench/api/common/extHost.protocol.ts +++ b/src/vs/workbench/api/common/extHost.protocol.ts @@ -399,6 +399,7 @@ export interface MainThreadLanguageFeaturesShape extends IDisposable { $registerDocumentRangeSemanticTokensProvider(handle: number, selector: IDocumentFilterDto[], legend: modes.SemanticTokensLegend): void; $registerSuggestSupport(handle: number, selector: IDocumentFilterDto[], triggerCharacters: string[], supportsResolveDetails: boolean, displayName: string): void; $registerSignatureHelpProvider(handle: number, selector: IDocumentFilterDto[], metadata: ISignatureHelpProviderMetadataDto): void; + $registerSignatureArgumentsLabelProvider(handle: number, selector: IDocumentFilterDto[]): void; $registerDocumentLinkProvider(handle: number, selector: IDocumentFilterDto[], supportsResolve: boolean): void; $registerDocumentColorProvider(handle: number, selector: IDocumentFilterDto[]): void; $registerFoldingRangeProvider(handle: number, selector: IDocumentFilterDto[], eventHandle: number | undefined): void; diff --git a/src/vs/workbench/api/common/extHostLanguageFeatures.ts b/src/vs/workbench/api/common/extHostLanguageFeatures.ts index 086811373a6..d57bbcd508c 100644 --- a/src/vs/workbench/api/common/extHostLanguageFeatures.ts +++ b/src/vs/workbench/api/common/extHostLanguageFeatures.ts @@ -1075,7 +1075,7 @@ class SignatureArgumentsLabelAdapter { return asPromise(() => this._provider.provideSignatureArgumentsLabels(doc, token)).then(value => { if (value) { const id = this._cache.add([value]); - return { ...typeConvert.SignatrueArgumentsLabelList.from(value), id }; + return { signatures: value.signatures.map(typeConvert.SignatureArgumentsSignature.from), id }; } return undefined; }); @@ -1340,7 +1340,7 @@ type Adapter = DocumentSymbolAdapter | CodeLensAdapter | DefinitionAdapter | Hov | SuggestAdapter | SignatureHelpAdapter | LinkProviderAdapter | ImplementationAdapter | TypeDefinitionAdapter | ColorProviderAdapter | FoldingProviderAdapter | DeclarationAdapter | SelectionRangeAdapter | CallHierarchyAdapter | DocumentSemanticTokensAdapter | DocumentRangeSemanticTokensAdapter | EvaluatableExpressionAdapter - | LinkedEditingRangeAdapter; + | LinkedEditingRangeAdapter | SignatureArgumentsLabelAdapter; class AdapterData { constructor( @@ -1782,6 +1782,12 @@ export class ExtHostLanguageFeatures implements extHostProtocol.ExtHostLanguageF return this._createDisposable(handle); } + registerSignatureArgumentsLabelProvider(extension: IExtensionDescription, selector: vscode.DocumentSelector, provider: vscode.SignatureArgumentsLabelProvider): vscode.Disposable { + const handle = this._addNewAdapter(new SignatureArgumentsLabelAdapter(this._documents, provider), extension); + this._proxy.$registerSignatureArgumentsLabelProvider(handle, this._transformDocumentSelector(selector)); + return this._createDisposable(handle); + } + $provideSignatureHelp(handle: number, resource: UriComponents, position: IPosition, context: extHostProtocol.ISignatureHelpContextDto, token: CancellationToken): Promise { return this._withAdapter(handle, SignatureHelpAdapter, adapter => adapter.provideSignatureHelp(URI.revive(resource), position, context, token), undefined); } diff --git a/src/vs/workbench/api/common/extHostTypeConverters.ts b/src/vs/workbench/api/common/extHostTypeConverters.ts index 9ce93ea7dd5..53f078dfd7a 100644 --- a/src/vs/workbench/api/common/extHostTypeConverters.ts +++ b/src/vs/workbench/api/common/extHostTypeConverters.ts @@ -1015,13 +1015,14 @@ export namespace SignatureHelp { } } -export namespace SignatrueArgumentsLabelList { - export function from(labels: vscode.SignatureArgumentsLabelList): modes.SignatureArgumentsLabelList { - - } - - export function to(labels: modes.SignatureArgumentsLabelList): vscode.SignatureArgumentsLabelList { - +export namespace SignatureArgumentsSignature { + export function from(signature: vscode.SignatureArgumentsSignature): modes.SignatureArgumentsSignature { + return { + arguments: signature.arguments.map(arg => ({ + name: arg.name, + positions: arg.positions.map(pos => Position.from(pos)) + })) + } } }