From 0e06bc1333f77952e2ea687312ff3a7d847c89ba Mon Sep 17 00:00:00 2001 From: Tyler Leonhardt Date: Mon, 10 Apr 2023 14:59:19 -0700 Subject: [PATCH 1/4] introduce a SemanticSimilarity provider model --- .../api/browser/extensionHost.contribution.ts | 1 + .../browser/mainThreadSemanticSimilarity.ts | 36 ++++++ .../workbench/api/common/extHost.api.impl.ts | 11 ++ .../workbench/api/common/extHost.protocol.ts | 13 ++- .../api/common/extHostSemanticSimilarity.ts | 47 ++++++++ .../browser/commandsQuickAccess.ts | 2 +- .../common/extensionsApiProposals.ts | 1 + .../common}/semanticSimilarityService.ts | 110 ++++++++++++++++-- .../vscode.proposed.semanticSimilarity.d.ts | 22 ++++ 9 files changed, 232 insertions(+), 11 deletions(-) create mode 100644 src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts create mode 100644 src/vs/workbench/api/common/extHostSemanticSimilarity.ts rename src/vs/workbench/{contrib/quickaccess/browser => services/semanticSimilarity/common}/semanticSimilarityService.ts (53%) create mode 100644 src/vscode-dts/vscode.proposed.semanticSimilarity.d.ts diff --git a/src/vs/workbench/api/browser/extensionHost.contribution.ts b/src/vs/workbench/api/browser/extensionHost.contribution.ts index f6db1757e3421..de3b9096221ae 100644 --- a/src/vs/workbench/api/browser/extensionHost.contribution.ts +++ b/src/vs/workbench/api/browser/extensionHost.contribution.ts @@ -81,6 +81,7 @@ import './mainThreadTimeline'; import './mainThreadTesting'; import './mainThreadSecretState'; import './mainThreadProfilContentHandlers'; +import './mainThreadSemanticSimilarity'; export class ExtensionPoints implements IWorkbenchContribution { diff --git a/src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts b/src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts new file mode 100644 index 0000000000000..c954d6da775b4 --- /dev/null +++ b/src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts @@ -0,0 +1,36 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +import { Disposable, DisposableMap } from 'vs/base/common/lifecycle'; +import { ExtHostContext, ExtHostSemanticSimilarityShape, MainContext, MainThreadSemanticSimilarityShape } from 'vs/workbench/api/common/extHost.protocol'; +import { IExtHostContext, extHostNamedCustomer } from 'vs/workbench/services/extensions/common/extHostCustomers'; +import { ISemanticSimilarityProvider, ISemanticSimilarityService } from 'vs/workbench/services/semanticSimilarity/common/semanticSimilarityService'; + +@extHostNamedCustomer(MainContext.MainThreadSemanticSimilarity) +export class MainThreadSemanticSimilarity extends Disposable implements MainThreadSemanticSimilarityShape { + private readonly _proxy: ExtHostSemanticSimilarityShape; + private readonly _registrations = this._register(new DisposableMap()); + + constructor( + context: IExtHostContext, + @ISemanticSimilarityService private readonly _semanticSimilarityService: ISemanticSimilarityService + ) { + super(); + this._proxy = context.getProxy(ExtHostContext.ExtHostSemanticSimilarity); + } + + $registerSemanticSimilarityProvider(handle: number, extensionId: string): void { + const provider: ISemanticSimilarityProvider = { + provideSimilarityScore: (string1, comparisons, token) => { + return this._proxy.$provideSimilarityScore(handle, string1, comparisons, token); + }, + }; + this._registrations.set(handle, this._semanticSimilarityService.registerSemanticSimilarityProvider(provider)); + } + + $unregisterSemanticSimilarityProvider(handle: number): void { + this._registrations.deleteAndDispose(handle); + } +} diff --git a/src/vs/workbench/api/common/extHost.api.impl.ts b/src/vs/workbench/api/common/extHost.api.impl.ts index fd74bfba4e3b4..5eb7eaf0fda46 100644 --- a/src/vs/workbench/api/common/extHost.api.impl.ts +++ b/src/vs/workbench/api/common/extHost.api.impl.ts @@ -100,6 +100,7 @@ import { ExtHostQuickDiff } from 'vs/workbench/api/common/extHostQuickDiff'; import { ExtHostInteractiveSession } from 'vs/workbench/api/common/extHostInteractiveSession'; import { ExtHostInteractiveEditor } from 'vs/workbench/api/common/extHostInteractiveEditor'; import { ExtHostNotebookDocumentSaveParticipant } from 'vs/workbench/api/common/extHostNotebookDocumentSaveParticipant'; +import { ExtHostSemanticSimilarity } from 'vs/workbench/api/common/extHostSemanticSimilarity'; export interface IExtensionRegistries { mine: ExtensionDescriptionRegistry; @@ -197,6 +198,7 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I rpcProtocol.set(ExtHostContext.ExtHostInteractive, new ExtHostInteractive(rpcProtocol, extHostNotebook, extHostDocumentsAndEditors, extHostCommands, extHostLogService)); const extHostInteractiveEditor = rpcProtocol.set(ExtHostContext.ExtHostInteractiveEditor, new ExtHostInteractiveEditor(rpcProtocol, extHostDocuments, extHostLogService)); const extHostInteractiveSession = rpcProtocol.set(ExtHostContext.ExtHostInteractiveSession, new ExtHostInteractiveSession(rpcProtocol, extHostLogService)); + const extHostSemanticSimilarity = rpcProtocol.set(ExtHostContext.ExtHostSemanticSimilarity, new ExtHostSemanticSimilarity(rpcProtocol)); // Check that no named customers are missing const expected = Object.values>(ExtHostContext); @@ -1248,9 +1250,18 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I } }; + // namespace: ai + const ai: typeof vscode.ai = { + registerSemanticSimilarityProvider(provider: vscode.SemanticSimilarityProvider) { + checkProposedApiEnabled(extension, 'semanticSimilarity'); + return extHostSemanticSimilarity.registerSemanticSimilarityProvider(extension, provider); + } + }; + return { version: initData.version, // namespaces + ai, authentication, commands, comments, diff --git a/src/vs/workbench/api/common/extHost.protocol.ts b/src/vs/workbench/api/common/extHost.protocol.ts index fe9fc961c4c63..a96916fe50e04 100644 --- a/src/vs/workbench/api/common/extHost.protocol.ts +++ b/src/vs/workbench/api/common/extHost.protocol.ts @@ -1555,6 +1555,15 @@ export interface ExtHostAuthenticationShape { $setProviders(providers: AuthenticationProviderInformation[]): Promise; } +export interface ExtHostSemanticSimilarityShape { + $provideSimilarityScore(handle: number, string1: string, comparisons: string[], token: CancellationToken): Promise; +} + +export interface MainThreadSemanticSimilarityShape extends IDisposable { + $registerSemanticSimilarityProvider(handle: number, extensionId: string): void; + $unregisterSemanticSimilarityProvider(handle: number): void; +} + export interface ExtHostSecretStateShape { $onDidChangePassword(e: { extensionId: string; key: string }): Promise; } @@ -2452,7 +2461,8 @@ export const MainContext = { MainThreadTunnelService: createProxyIdentifier('MainThreadTunnelService'), MainThreadTimeline: createProxyIdentifier('MainThreadTimeline'), MainThreadTesting: createProxyIdentifier('MainThreadTesting'), - MainThreadLocalization: createProxyIdentifier('MainThreadLocalizationShape') + MainThreadLocalization: createProxyIdentifier('MainThreadLocalizationShape'), + MainThreadSemanticSimilarity: createProxyIdentifier('MainThreadSemanticSimilarity') }; export const ExtHostContext = { @@ -2506,6 +2516,7 @@ export const ExtHostContext = { ExtHostInteractive: createProxyIdentifier('ExtHostInteractive'), ExtHostInteractiveEditor: createProxyIdentifier('ExtHostInteractiveEditor'), ExtHostInteractiveSession: createProxyIdentifier('ExtHostInteractiveSession'), + ExtHostSemanticSimilarity: createProxyIdentifier('ExtHostSemanticSimilarity'), ExtHostTheming: createProxyIdentifier('ExtHostTheming'), ExtHostTunnelService: createProxyIdentifier('ExtHostTunnelService'), ExtHostAuthentication: createProxyIdentifier('ExtHostAuthentication'), diff --git a/src/vs/workbench/api/common/extHostSemanticSimilarity.ts b/src/vs/workbench/api/common/extHostSemanticSimilarity.ts new file mode 100644 index 0000000000000..253a3ec2b843c --- /dev/null +++ b/src/vs/workbench/api/common/extHostSemanticSimilarity.ts @@ -0,0 +1,47 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +import { IExtensionDescription } from 'vs/platform/extensions/common/extensions'; +import { ExtHostSemanticSimilarityShape, IMainContext, MainContext, MainThreadSemanticSimilarityShape } from 'vs/workbench/api/common/extHost.protocol'; +import type { CancellationToken, SemanticSimilarityProvider } from 'vscode'; +import { Disposable } from 'vs/workbench/api/common/extHostTypes'; + +export class ExtHostSemanticSimilarity implements ExtHostSemanticSimilarityShape { + private _semanticSimilarityProviders: Map = new Map(); + private _nextHandle = 0; + + private readonly _proxy: MainThreadSemanticSimilarityShape; + + constructor( + mainContext: IMainContext + ) { + this._proxy = mainContext.getProxy(MainContext.MainThreadSemanticSimilarity); + } + + async $provideSimilarityScore(handle: number, string1: string, comparisons: string[], token: CancellationToken): Promise { + if (this._semanticSimilarityProviders.size === 0) { + throw new Error('No semantic similarity providers registered'); + } + + const provider = this._semanticSimilarityProviders.get(handle); + if (!provider) { + throw new Error('Semantic similarity provider not found'); + } + + const result = await provider.provideSimilarityScore(string1, comparisons, token); + return result; + } + + registerSemanticSimilarityProvider(extension: IExtensionDescription, provider: SemanticSimilarityProvider): Disposable { + const handle = this._nextHandle; + this._nextHandle++; + this._semanticSimilarityProviders.set(handle, provider); + this._proxy.$registerSemanticSimilarityProvider(handle, extension.identifier.value); + return new Disposable(() => { + this._proxy.$unregisterSemanticSimilarityProvider(handle); + this._semanticSimilarityProviders.delete(handle); + }); + } +} diff --git a/src/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.ts b/src/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.ts index a0245cb457ef0..a637abcb1136d 100644 --- a/src/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.ts +++ b/src/vs/workbench/contrib/quickaccess/browser/commandsQuickAccess.ts @@ -33,7 +33,7 @@ import { IPreferencesService } from 'vs/workbench/services/preferences/common/pr import { stripIcons } from 'vs/base/common/iconLabels'; import { isFirefox } from 'vs/base/browser/browser'; import { IProductService } from 'vs/platform/product/common/productService'; -import { ISemanticSimilarityService } from 'vs/workbench/contrib/quickaccess/browser/semanticSimilarityService'; +import { ISemanticSimilarityService } from 'vs/workbench/services/semanticSimilarity/common/semanticSimilarityService'; import { timeout } from 'vs/base/common/async'; export class CommandsQuickAccessProvider extends AbstractEditorCommandsQuickAccessProvider { diff --git a/src/vs/workbench/services/extensions/common/extensionsApiProposals.ts b/src/vs/workbench/services/extensions/common/extensionsApiProposals.ts index c59f8bbbb8216..75ef2592428d2 100644 --- a/src/vs/workbench/services/extensions/common/extensionsApiProposals.ts +++ b/src/vs/workbench/services/extensions/common/extensionsApiProposals.ts @@ -62,6 +62,7 @@ export const allApiProposals = Object.freeze({ scmActionButton: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.scmActionButton.d.ts', scmSelectedProvider: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.scmSelectedProvider.d.ts', scmValidation: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.scmValidation.d.ts', + semanticSimilarity: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.semanticSimilarity.d.ts', showLocal: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.showLocal.d.ts', tabInputTextMerge: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.tabInputTextMerge.d.ts', taskPresentationGroup: 'https://raw.githubusercontent.com/microsoft/vscode/main/src/vscode-dts/vscode.proposed.taskPresentationGroup.d.ts', diff --git a/src/vs/workbench/contrib/quickaccess/browser/semanticSimilarityService.ts b/src/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.ts similarity index 53% rename from src/vs/workbench/contrib/quickaccess/browser/semanticSimilarityService.ts rename to src/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.ts index fd394f391aaa3..c16e792af5d70 100644 --- a/src/vs/workbench/contrib/quickaccess/browser/semanticSimilarityService.ts +++ b/src/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.ts @@ -5,25 +5,118 @@ import { CommandsRegistry, ICommandService } from 'vs/platform/commands/common/commands'; import { IFileService } from 'vs/platform/files/common/files'; -import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions'; import { createDecorator } from 'vs/platform/instantiation/common/instantiation'; import { URI } from 'vs/base/common/uri'; import { CancellationToken } from 'vs/base/common/cancellation'; -import { raceCancellation } from 'vs/base/common/async'; +import { CancelablePromise, createCancelablePromise, raceCancellablePromises, raceCancellation, timeout } from 'vs/base/common/async'; +import { IDisposable } from 'vs/base/common/lifecycle'; +import { InstantiationType, registerSingleton } from 'vs/platform/instantiation/common/extensions'; -export const ISemanticSimilarityService = createDecorator('IEmbeddingsService'); +export const ISemanticSimilarityService = createDecorator('ISemanticSimilarityService'); export interface ISemanticSimilarityService { + readonly _serviceBrand: undefined; + isEnabled(): boolean; getSimilarityScore(string1: string, comparisons: string[], token: CancellationToken): Promise; + registerSemanticSimilarityProvider(provider: ISemanticSimilarityProvider): IDisposable; + unregisterSemanticSimilarityProvider(provider: ISemanticSimilarityProvider): void; +} + +export interface ISemanticSimilarityProvider { + provideSimilarityScore(string1: string, comparisons: string[], token: CancellationToken): Promise; } +export class SemanticSimilarityService implements ISemanticSimilarityService { + readonly _serviceBrand: undefined; + + static readonly DEFAULT_TIMEOUT = 1000 * 10; // 30 seconds + + private readonly _providers: ISemanticSimilarityProvider[] = []; + // remove when we move over to API + private readonly oldService: OldSemanticSimilarityService; + + constructor( + // for the old service + @ICommandService commandService: ICommandService, + @IFileService fileService: IFileService + ) { + this.oldService = new OldSemanticSimilarityService(commandService, fileService); + } + + isEnabled(): boolean { + return this._providers.length > 0; + } + + registerSemanticSimilarityProvider(provider: ISemanticSimilarityProvider): IDisposable { + this._providers.push(provider); + return { + dispose: () => { + const index = this._providers.indexOf(provider); + if (index >= 0) { + this._providers.splice(index, 1); + } + } + }; + } + + unregisterSemanticSimilarityProvider(provider: ISemanticSimilarityProvider): void { + const index = this._providers.indexOf(provider); + if (index >= 0) { + this._providers.splice(index, 1); + } + } + + async getSimilarityScore(string1: string, comparisons: string[], token: CancellationToken): Promise { + if (this._providers.length === 0) { + // Remove when we have a provider shipping in extensions + if (this.oldService.isEnabled()) { + return this.oldService.getSimilarityScore(string1, comparisons, token); + } + throw new Error('No semantic similarity providers registered'); + } + + const cancellablePromises: Array> = []; + + const timer = timeout(SemanticSimilarityService.DEFAULT_TIMEOUT); + const disposible = token.onCancellationRequested(() => { + disposible.dispose(); + timer.cancel(); + }); + + for (const provider of this._providers) { + cancellablePromises.push(createCancelablePromise(async t => { + try { + return await provider.provideSimilarityScore(string1, comparisons, t); + } catch (e) { + // logged in extension host + } + await timer; + throw new Error('Semantic similarity provider timed out'); + })); + } + + cancellablePromises.push(createCancelablePromise(async (t) => { + const disposible = t.onCancellationRequested(() => { + timer.cancel(); + disposible.dispose(); + }); + await timer; + throw new Error('Semantic similarity provider timed out'); + })); + + const result = await raceCancellablePromises(cancellablePromises); + return result; + } +} + +// TODO: remove this when the extensions are updated + interface ICommandsEmbeddingsCache { [commandId: string]: { embedding: number[] }; } -// TODO: use proper API for this instead of commands -export class SemanticSimilarityService implements ISemanticSimilarityService { +class OldSemanticSimilarityService { declare _serviceBrand: undefined; static readonly CALCULATE_EMBEDDING_COMMAND_ID = '_vscode.ai.calculateEmbedding'; @@ -39,7 +132,7 @@ export class SemanticSimilarityService implements ISemanticSimilarityService { } private async loadCache(): Promise { - const path = await this.commandService.executeCommand(SemanticSimilarityService.COMMAND_EMBEDDING_CACHE_COMMAND_ID); + const path = await this.commandService.executeCommand(OldSemanticSimilarityService.COMMAND_EMBEDDING_CACHE_COMMAND_ID); if (!path) { return {}; } @@ -48,11 +141,10 @@ export class SemanticSimilarityService implements ISemanticSimilarityService { } isEnabled(): boolean { - return !!CommandsRegistry.getCommand(SemanticSimilarityService.CALCULATE_EMBEDDING_COMMAND_ID); + return !!CommandsRegistry.getCommand(OldSemanticSimilarityService.CALCULATE_EMBEDDING_COMMAND_ID); } async getSimilarityScore(str: string, comparisons: string[], token: CancellationToken): Promise { - const embedding1 = await this.computeEmbedding(str, token); const scores: number[] = []; for (const comparison of comparisons) { @@ -74,7 +166,7 @@ export class SemanticSimilarityService implements ISemanticSimilarityService { if (!this.isEnabled()) { throw new Error('Embeddings are not enabled'); } - const result = await raceCancellation(this.commandService.executeCommand(SemanticSimilarityService.CALCULATE_EMBEDDING_COMMAND_ID, text), token); + const result = await raceCancellation(this.commandService.executeCommand(OldSemanticSimilarityService.CALCULATE_EMBEDDING_COMMAND_ID, text), token); if (!result) { throw new Error('No result'); } diff --git a/src/vscode-dts/vscode.proposed.semanticSimilarity.d.ts b/src/vscode-dts/vscode.proposed.semanticSimilarity.d.ts new file mode 100644 index 0000000000000..d2ffb82338652 --- /dev/null +++ b/src/vscode-dts/vscode.proposed.semanticSimilarity.d.ts @@ -0,0 +1,22 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +declare module 'vscode' { + export interface SemanticSimilarityProvider { + /** + * Computes the semantic similarity score between two strings. + * @param string1 The string to compare to all other strings. + * @param comparisons An array of strings to compare string1 to. An array allows you to batch multiple comparisons in one call. + * @param token A cancellation token. + * @return A promise that resolves to the semantic similarity scores between string1 and each string in comparisons. + * The score should be a number between 0 and 1, where 0 means no similarity and 1 means + * perfect similarity. + */ + provideSimilarityScore(string1: string, comparisons: string[], token: CancellationToken): Thenable; + } + export namespace ai { + export function registerSemanticSimilarityProvider(provider: SemanticSimilarityProvider): Disposable; + } +} From 6699e3070becf039e99f3fb080223b4f6d649ec2 Mon Sep 17 00:00:00 2001 From: Tyler Leonhardt Date: Mon, 10 Apr 2023 15:35:29 -0700 Subject: [PATCH 2/4] have raceCancellablePromises also cancel if it rejects --- src/vs/base/common/async.ts | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/src/vs/base/common/async.ts b/src/vs/base/common/async.ts index 2c189c4f788b7..c476468e7fec9 100644 --- a/src/vs/base/common/async.ts +++ b/src/vs/base/common/async.ts @@ -94,18 +94,21 @@ export function raceCancellationError(promise: Promise, token: Cancellatio } /** - * Returns as soon as one of the promises is resolved and cancels remaining promises + * Returns as soon as one of the promises resolves or rejects and cancels remaining promises */ export async function raceCancellablePromises(cancellablePromises: CancelablePromise[]): Promise { let resolvedPromiseIndex = -1; const promises = cancellablePromises.map((promise, index) => promise.then(result => { resolvedPromiseIndex = index; return result; })); - const result = await Promise.race(promises); - cancellablePromises.forEach((cancellablePromise, index) => { - if (index !== resolvedPromiseIndex) { - cancellablePromise.cancel(); - } - }); - return result; + try { + const result = await Promise.race(promises); + return result; + } finally { + cancellablePromises.forEach((cancellablePromise, index) => { + if (index !== resolvedPromiseIndex) { + cancellablePromise.cancel(); + } + }); + } } export function raceTimeout(promise: Promise, timeout: number, onTimeout?: () => void): Promise { From 02c3028ac7651dd68defdc5dcadaf38bbb480ae2 Mon Sep 17 00:00:00 2001 From: Tyler Leonhardt Date: Mon, 10 Apr 2023 15:45:23 -0700 Subject: [PATCH 3/4] remove extensionId for now --- src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts | 2 +- src/vs/workbench/api/common/extHost.protocol.ts | 2 +- src/vs/workbench/api/common/extHostSemanticSimilarity.ts | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts b/src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts index c954d6da775b4..07f11ad954ea2 100644 --- a/src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts +++ b/src/vs/workbench/api/browser/mainThreadSemanticSimilarity.ts @@ -21,7 +21,7 @@ export class MainThreadSemanticSimilarity extends Disposable implements MainThre this._proxy = context.getProxy(ExtHostContext.ExtHostSemanticSimilarity); } - $registerSemanticSimilarityProvider(handle: number, extensionId: string): void { + $registerSemanticSimilarityProvider(handle: number): void { const provider: ISemanticSimilarityProvider = { provideSimilarityScore: (string1, comparisons, token) => { return this._proxy.$provideSimilarityScore(handle, string1, comparisons, token); diff --git a/src/vs/workbench/api/common/extHost.protocol.ts b/src/vs/workbench/api/common/extHost.protocol.ts index a96916fe50e04..818ef20a56d36 100644 --- a/src/vs/workbench/api/common/extHost.protocol.ts +++ b/src/vs/workbench/api/common/extHost.protocol.ts @@ -1560,7 +1560,7 @@ export interface ExtHostSemanticSimilarityShape { } export interface MainThreadSemanticSimilarityShape extends IDisposable { - $registerSemanticSimilarityProvider(handle: number, extensionId: string): void; + $registerSemanticSimilarityProvider(handle: number): void; $unregisterSemanticSimilarityProvider(handle: number): void; } diff --git a/src/vs/workbench/api/common/extHostSemanticSimilarity.ts b/src/vs/workbench/api/common/extHostSemanticSimilarity.ts index 253a3ec2b843c..430ee4c9367ac 100644 --- a/src/vs/workbench/api/common/extHostSemanticSimilarity.ts +++ b/src/vs/workbench/api/common/extHostSemanticSimilarity.ts @@ -38,7 +38,7 @@ export class ExtHostSemanticSimilarity implements ExtHostSemanticSimilarityShape const handle = this._nextHandle; this._nextHandle++; this._semanticSimilarityProviders.set(handle, provider); - this._proxy.$registerSemanticSimilarityProvider(handle, extension.identifier.value); + this._proxy.$registerSemanticSimilarityProvider(handle); return new Disposable(() => { this._proxy.$unregisterSemanticSimilarityProvider(handle); this._semanticSimilarityProviders.delete(handle); From 6171ba5a8bf55b91954c6d121a920fa9f83bff29 Mon Sep 17 00:00:00 2001 From: Tyler Leonhardt Date: Mon, 10 Apr 2023 15:51:09 -0700 Subject: [PATCH 4/4] remove unused code --- .../common/semanticSimilarityService.ts | 8 -------- 1 file changed, 8 deletions(-) diff --git a/src/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.ts b/src/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.ts index c16e792af5d70..186290ed87ede 100644 --- a/src/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.ts +++ b/src/vs/workbench/services/semanticSimilarity/common/semanticSimilarityService.ts @@ -20,7 +20,6 @@ export interface ISemanticSimilarityService { isEnabled(): boolean; getSimilarityScore(string1: string, comparisons: string[], token: CancellationToken): Promise; registerSemanticSimilarityProvider(provider: ISemanticSimilarityProvider): IDisposable; - unregisterSemanticSimilarityProvider(provider: ISemanticSimilarityProvider): void; } export interface ISemanticSimilarityProvider { @@ -60,13 +59,6 @@ export class SemanticSimilarityService implements ISemanticSimilarityService { }; } - unregisterSemanticSimilarityProvider(provider: ISemanticSimilarityProvider): void { - const index = this._providers.indexOf(provider); - if (index >= 0) { - this._providers.splice(index, 1); - } - } - async getSimilarityScore(string1: string, comparisons: string[], token: CancellationToken): Promise { if (this._providers.length === 0) { // Remove when we have a provider shipping in extensions