src/vs/workbench/api/common/extHostSearch.ts
232 LOC · 165 covered · 67 uncovered · 26 ranges · 60 concepts · 6 introducers · 32 tests
File neighbourhood
The centred file is linked to every concept that introduces one of its ranges, every test that runs code from the file, and the gray connector concepts standing between those tests and the file's own introducer concepts. Undirected links join concepts to every file where they introduce source and concepts to the tests they introduce; arrows show specialization between the displayed concepts and bridge only concepts omitted from this view. Concept colors match the source ranges below; connector concepts have no source color and are shown in gray.
Focused file, its introducer and connector concepts, their introduced files, and tests that run code from the file
In the embedded map, ordinary wheel input scrolls the page; use the visible controls to zoom and drag to pan. Open the full-screen map for canvas navigation: wheel pans, Ctrl/Command plus wheel zooms, and arrow keys pan when this region is focused. On touch screens, open the full-screen map to pan or pinch. If JavaScript or WebGL is unavailable, use the related-file, concept, and source links on this page.
Graph controls are ready.
Interactive rendering requires JavaScript and WebGL. Use the related-file, concept, and source links on this page while the interactive map is unavailable.
1
>
/*---------------------------------------------------------------------------------------------
fileSearch.ts ×31
2
>
* Copyright (c) Microsoft Corporation. All rights reserved.
3
>
* Licensed under the MIT License. See License.txt in the project root for license information.
4
>
*--------------------------------------------------------------------------------------------*/
5
>
6
>
import { IDisposable, toDisposable } from '../../../base/common/lifecycle.js';
7
>
import type * as vscode from 'vscode';
8
>
import { ExtHostSearchShape, MainThreadSearchShape, MainContext } from './extHost.protocol.js';
9
>
import { createDecorator } from '../../../platform/instantiation/common/instantiation.js';
10
>
import { FileSearchManager } from '../../services/search/common/fileSearchManager.js';
11
>
import { IExtHostRpcService } from './extHostRpcService.js';
12
>
import { IURITransformerService } from './extHostUriTransformerService.js';
13
>
import { ILogService } from '../../../platform/log/common/log.js';
14
>
import { IRawFileQuery, ISearchCompleteStats, IFileQuery, IRawTextQuery, IRawQuery, ITextQuery, IFolderQuery, IRawAITextQuery, IAITextQuery } from '../../services/search/common/search.js';
15
>
import { URI, UriComponents } from '../../../base/common/uri.js';
16
>
import { TextSearchManager } from '../../services/search/common/textSearchManager.js';
17
>
import { CancellationToken } from '../../../base/common/cancellation.js';
18
>
import { revive } from '../../../base/common/marshalling.js';
19
>
import { OldFileSearchProviderConverter, OldTextSearchProviderConverter } from '../../services/search/common/searchExtConversionTypes.js';
20
>
21
>
export interface IExtHostSearch extends ExtHostSearchShape {
22
>
registerTextSearchProviderOld(scheme: string, provider: vscode.TextSearchProvider): IDisposable;
23
>
registerFileSearchProviderOld(scheme: string, provider: vscode.FileSearchProvider): IDisposable;
24
>
registerTextSearchProvider(scheme: string, provider: vscode.TextSearchProvider2): IDisposable;
25
>
registerAITextSearchProvider(scheme: string, provider: vscode.AITextSearchProvider): IDisposable;
26
>
registerFileSearchProvider(scheme: string, provider: vscode.FileSearchProvider2): IDisposable;
27
>
doInternalFileSearchWithCustomCallback(query: IFileQuery, token: CancellationToken, handleFileMatch: (data: URI[]) => void): Promise<ISearchCompleteStats>;
28
>
}
29
>
30
>
export const IExtHostSearch = createDecorator<IExtHostSearch>('IExtHostSearch');
31
>
32
>
export class ExtHostSearch implements IExtHostSearch {
33
>
34
>
protected readonly _proxy: MainThreadSearchShape;
35
>
protected _handlePool: number;
36
>
37
>
private readonly _textSearchProvider: Map<number, vscode.TextSearchProvider2>;
38
>
private readonly _textSearchUsedSchemes: Set<string>;
39
>
40
>
private readonly _aiTextSearchProvider: Map<number, vscode.AITextSearchProvider>;
41
>
private readonly _aiTextSearchUsedSchemes: Set<string>;
42
>
43
>
private readonly _fileSearchProvider: Map<number, vscode.FileSearchProvider2>;
44
>
private readonly _fileSearchUsedSchemes: Set<string>;
45
>
46
>
private readonly _fileSearchManager: FileSearchManager;
47
>
48
>
constructor(
49
>
@IExtHostRpcService private extHostRpc: IExtHostRpcService,
50
>
@IURITransformerService protected _uriTransformer: IURITransformerService,
51
>
@ILogService protected _logService: ILogService,
52
>
) {
53
>
this._proxy = this.extHostRpc.getProxy(MainContext.MainThreadSearch);
54
>
this._handlePool = 0;
55
>
this._textSearchProvider = new Map<number, vscode.TextSearchProvider2>();
56
>
this._textSearchUsedSchemes = new Set<string>();
57
>
this._aiTextSearchProvider = new Map<number, vscode.AITextSearchProvider>();
58
>
this._aiTextSearchUsedSchemes = new Set<string>();
59
>
this._fileSearchProvider = new Map<number, vscode.FileSearchProvider2>();
60
>
this._fileSearchUsedSchemes = new Set<string>();
61
>
this._fileSearchManager = new FileSearchManager();
62
>
}
63
>
64
>
protected _transformScheme(scheme: string): string {
65
>
return this._uriTransformer.transformOutgoingScheme(scheme);
66
>
}
67
>
68
>
registerTextSearchProviderOld(scheme: string, provider: vscode.TextSearchProvider): IDisposable {
70
throw new Error(`a text search provider for the scheme '${scheme}' is already registered`);
71
}
73
>
this._textSearchUsedSchemes.add(scheme);
74
>
const handle = this._handlePool++;
75
>
this._textSearchProvider.set(handle, new OldTextSearchProviderConverter(provider));
76
>
this._proxy.$registerTextSearchProvider(handle, this._transformScheme(scheme));
77
>
return toDisposable(() => {
78
>
this._textSearchUsedSchemes.delete(scheme);
79
>
this._textSearchProvider.delete(handle);
80
>
this._proxy.$unregisterProvider(handle);
81
>
});
82
>
}
84
>
registerTextSearchProvider(scheme: string, provider: vscode.TextSearchProvider2): IDisposable {
85
>
if (this._textSearchUsedSchemes.has(scheme)) {
86
throw new Error(`a text search provider for the scheme '${scheme}' is already registered`);
87
}
89
>
this._textSearchUsedSchemes.add(scheme);
90
>
const handle = this._handlePool++;
91
>
this._textSearchProvider.set(handle, provider);
92
>
this._proxy.$registerTextSearchProvider(handle, this._transformScheme(scheme));
93
>
return toDisposable(() => {
94
>
this._textSearchUsedSchemes.delete(scheme);
95
>
this._textSearchProvider.delete(handle);
96
>
this._proxy.$unregisterProvider(handle);
97
>
});
98
>
}
99
>
100
>
registerAITextSearchProvider(scheme: string, provider: vscode.AITextSearchProvider): IDisposable {
101
if (this._aiTextSearchUsedSchemes.has(scheme)) {
102
throw new Error(`an AI text search provider for the scheme '${scheme}'is already registered`);
103
}
104
105
this._aiTextSearchUsedSchemes.add(scheme);
106
const handle = this._handlePool++;
107
this._aiTextSearchProvider.set(handle, provider);
108
this._proxy.$registerAITextSearchProvider(handle, this._transformScheme(scheme));
109
return toDisposable(() => {
110
this._aiTextSearchUsedSchemes.delete(scheme);
111
this._aiTextSearchProvider.delete(handle);
112
this._proxy.$unregisterProvider(handle);
113
});
114
}
116
>
registerFileSearchProviderOld(scheme: string, provider: vscode.FileSearchProvider): IDisposable {
118
throw new Error(`a file search provider for the scheme '${scheme}' is already registered`);
119
}
121
>
this._fileSearchUsedSchemes.add(scheme);
122
>
const handle = this._handlePool++;
123
>
this._fileSearchProvider.set(handle, new OldFileSearchProviderConverter(provider));
124
>
this._proxy.$registerFileSearchProvider(handle, this._transformScheme(scheme));
125
>
return toDisposable(() => {
126
>
this._fileSearchUsedSchemes.delete(scheme);
127
>
this._fileSearchProvider.delete(handle);
128
>
this._proxy.$unregisterProvider(handle);
129
>
});
130
>
}
132
>
registerFileSearchProvider(scheme: string, provider: vscode.FileSearchProvider2): IDisposable {
133
if (this._fileSearchUsedSchemes.has(scheme)) {
134
throw new Error(`a file search provider for the scheme '${scheme}' is already registered`);
135
}
136
137
this._fileSearchUsedSchemes.add(scheme);
138
const handle = this._handlePool++;
139
this._fileSearchProvider.set(handle, provider);
140
this._proxy.$registerFileSearchProvider(handle, this._transformScheme(scheme));
141
return toDisposable(() => {
142
this._fileSearchUsedSchemes.delete(scheme);
143
this._fileSearchProvider.delete(handle);
144
this._proxy.$unregisterProvider(handle);
145
});
146
}
148
>
$provideFileSearchResults(handle: number, session: number, rawQuery: IRawFileQuery, token: vscode.CancellationToken): Promise<ISearchCompleteStats> {
150
>
const provider = this._fileSearchProvider.get(handle);
151
>
if (provider) {
152
>
return this._fileSearchManager.fileSearch(query, provider, batch => {
153
>
this._proxy.$handleFileMatch(handle, session, batch.map(p => p.resource));
fileSearchManager.ts ×10
155
>
} else {
156
throw new Error('unknown provider: ' + handle);
157
}
160
>
async doInternalFileSearchWithCustomCallback(query: IFileQuery, token: CancellationToken, handleFileMatch: (data: URI[]) => void): Promise<ISearchCompleteStats> {
161
return { messages: [] };
162
}
164
>
$clearCache(cacheKey: string): Promise<void> {
166
>
167
>
return Promise.resolve(undefined);
168
>
}
170
>
$provideTextSearchResults(handle: number, session: number, rawQuery: IRawTextQuery, token: vscode.CancellationToken): Promise<ISearchCompleteStats> {
172
>
if (!provider || !provider.provideTextSearchResults) {
173
throw new Error(`Unknown Text Search Provider ${handle}`);
174
}
176
>
const query = reviveQuery(rawQuery);
177
>
const engine = this.createTextSearchManager(query, provider);
178
>
return engine.search(progress => this._proxy.$handleTextMatch(handle, session, progress), token);
179
>
}
181
>
$provideAITextSearchResults(handle: number, session: number, rawQuery: IRawAITextQuery, token: vscode.CancellationToken): Promise<ISearchCompleteStats> {
182
const provider = this._aiTextSearchProvider.get(handle);
183
if (!provider || !provider.provideAITextSearchResults) {
184
throw new Error(`Unknown AI Text Search Provider ${handle}`);
185
}
186
187
const query = reviveQuery(rawQuery);
188
const engine = this.createAITextSearchManager(query, provider);
189
return engine.search(progress => this._proxy.$handleTextMatch(handle, session, progress), token, result => this._proxy.$handleKeywordResult(handle, session, result));
190
}
192
>
$enableExtensionHostSearch(): void { }
193
>
194
>
async $getAIName(handle: number): Promise<string | undefined> {
195
const provider = this._aiTextSearchProvider.get(handle);
196
if (!provider || !provider.provideAITextSearchResults) {
197
return undefined;
198
}
199
200
// if the provider is defined, but has no name, use default name
201
return provider.name ?? 'AI';
202
}
204
>
protected createTextSearchManager(query: ITextQuery, provider: vscode.TextSearchProvider2): TextSearchManager {
205
return new TextSearchManager({ query, provider }, {
206
readdir: resource => Promise.resolve([]),
207
toCanonicalName: encoding => encoding
208
}, 'textSearchProvider');
209
}
211
>
protected createAITextSearchManager(query: IAITextQuery, provider: vscode.AITextSearchProvider): TextSearchManager {
212
return new TextSearchManager({ query, provider }, {
213
readdir: resource => Promise.resolve([]),
214
toCanonicalName: encoding => encoding
215
}, 'aiTextSearchProvider');
216
}
218
>
219
>
export function reviveQuery<U extends IRawQuery>(rawQuery: U): U extends IRawTextQuery ? ITextQuery : U extends IRawAITextQuery ? IAITextQuery : IFileQuery {
220
>
return {
221
>
// eslint-disable-next-line local/code-no-any-casts
222
>
...<any>rawQuery, // TODO@rob ???
223
>
...{
224
>
folderQueries: rawQuery.folderQueries && rawQuery.folderQueries.map(reviveFolderQuery),
225
>
extraFileResources: rawQuery.extraFileResources && rawQuery.extraFileResources.map(components => URI.revive(components))
226
>
}
227
>
};
228
>
}
229
>
230
>
function reviveFolderQuery(rawFolderQuery: IFolderQuery<UriComponents>): IFolderQuery<URI> {
extHostSearch.ts ×1
231
>
return revive(rawFolderQuery);
232
>
}