@codingame/monaco-vscode-search-service-override 4.1.0 → 4.1.2

package/vscode/src/vs/workbench/services/search/common/searchService.js

@@ -0,0 +1,416 @@
+import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
+import { coalesce, flatten, uniqueFilter } from 'vscode/vscode/vs/base/common/arrays';
+import { raceCancellationError, DeferredPromise } from 'vscode/vscode/vs/base/common/async';
+import { CancellationError } from 'vscode/vscode/vs/base/common/errors';
+import { Disposable, toDisposable } from 'vscode/vscode/vs/base/common/lifecycle';
+import { ResourceMap, ResourceSet } from 'vscode/vscode/vs/base/common/map';
+import { Schemas } from 'vscode/vscode/vs/base/common/network';
+import { StopWatch } from 'vscode/vscode/vs/base/common/stopwatch';
+import { isNumber } from 'vscode/vscode/vs/base/common/types';
+import { IModelService } from 'vscode/vscode/vs/editor/common/services/model';
+import { IFileService } from 'vscode/vscode/vs/platform/files/common/files';
+import { ILogService } from 'vscode/vscode/vs/platform/log/common/log';
+import { ITelemetryService } from 'vscode/vscode/vs/platform/telemetry/common/telemetry';
+import { IUriIdentityService } from 'vscode/vscode/vs/platform/uriIdentity/common/uriIdentity';
+import { EditorResourceAccessor, SideBySideEditor } from 'vscode/vscode/vs/workbench/common/editor';
+import { IEditorService } from 'vscode/vscode/vs/workbench/services/editor/common/editorService';
+import { IExtensionService } from 'vscode/vscode/vs/workbench/services/extensions/common/extensions';
+import { deserializeSearchError, SearchErrorCode, SEARCH_RESULT_LANGUAGE_ID, FileMatch, pathIncludedInQuery, isFileMatch, isProgressMessage } from 'vscode/vscode/vs/workbench/services/search/common/search';
+import { editorMatchesToTextSearchResults, getTextSearchMatchWithModelContext } from 'vscode/vscode/vs/workbench/services/search/common/searchHelpers';
+
+let SearchService = class SearchService extends Disposable {
+    constructor(modelService, editorService, telemetryService, logService, extensionService, fileService, uriIdentityService) {
+        super();
+        this.modelService = modelService;
+        this.editorService = editorService;
+        this.telemetryService = telemetryService;
+        this.logService = logService;
+        this.extensionService = extensionService;
+        this.fileService = fileService;
+        this.uriIdentityService = uriIdentityService;
+        this.fileSearchProviders = ( new Map());
+        this.textSearchProviders = ( new Map());
+        this.aiTextSearchProviders = ( new Map());
+        this.deferredFileSearchesByScheme = ( new Map());
+        this.deferredTextSearchesByScheme = ( new Map());
+        this.deferredAITextSearchesByScheme = ( new Map());
+        this.loggedSchemesMissingProviders = ( new Set());
+    }
+    registerSearchResultProvider(scheme, type, provider) {
+        let list;
+        let deferredMap;
+        if (type === 0 ) {
+            list = this.fileSearchProviders;
+            deferredMap = this.deferredFileSearchesByScheme;
+        }
+        else if (type === 1 ) {
+            list = this.textSearchProviders;
+            deferredMap = this.deferredTextSearchesByScheme;
+        }
+        else if (type === 2 ) {
+            list = this.aiTextSearchProviders;
+            deferredMap = this.deferredAITextSearchesByScheme;
+        }
+        else {
+            throw new Error('Unknown SearchProviderType');
+        }
+        list.set(scheme, provider);
+        if (( deferredMap.has(scheme))) {
+            deferredMap.get(scheme).complete(provider);
+            deferredMap.delete(scheme);
+        }
+        return toDisposable(() => {
+            list.delete(scheme);
+        });
+    }
+    async textSearch(query, token, onProgress) {
+        const results = this.textSearchSplitSyncAsync(query, token, onProgress);
+        const openEditorResults = results.syncResults;
+        const otherResults = await results.asyncResults;
+        return {
+            limitHit: otherResults.limitHit || openEditorResults.limitHit,
+            results: [...otherResults.results, ...openEditorResults.results],
+            messages: [...otherResults.messages, ...openEditorResults.messages]
+        };
+    }
+    async aiTextSearch(query, token, onProgress) {
+        const onProviderProgress = (progress) => {
+            if (onProgress) {
+                if (isFileMatch(progress)) {
+                    onProgress(progress);
+                }
+                else {
+                    onProgress(progress);
+                }
+            }
+            if (isProgressMessage(progress)) {
+                this.logService.debug('SearchService#search', progress.message);
+            }
+        };
+        return this.doSearch(query, token, onProviderProgress);
+    }
+    textSearchSplitSyncAsync(query, token, onProgress, notebookFilesToIgnore, asyncNotebookFilesToIgnore) {
+        const openEditorResults = this.getOpenEditorResults(query);
+        if (onProgress) {
+            coalesce([...( openEditorResults.results.values())]).filter(e => !(notebookFilesToIgnore && ( notebookFilesToIgnore.has(e.resource)))).forEach(onProgress);
+        }
+        const syncResults = {
+            results: coalesce([...( openEditorResults.results.values())]),
+            limitHit: openEditorResults.limitHit ?? false,
+            messages: []
+        };
+        const getAsyncResults = async () => {
+            const resolvedAsyncNotebookFilesToIgnore = (await asyncNotebookFilesToIgnore) ?? ( new ResourceSet());
+            const onProviderProgress = (progress) => {
+                if (isFileMatch(progress)) {
+                    if (!( openEditorResults.results.has(progress.resource)) && !( resolvedAsyncNotebookFilesToIgnore.has(progress.resource)) && onProgress) {
+                        onProgress(progress);
+                    }
+                }
+                else if (onProgress) {
+                    onProgress(progress);
+                }
+                if (isProgressMessage(progress)) {
+                    this.logService.debug('SearchService#search', progress.message);
+                }
+            };
+            return await this.doSearch(query, token, onProviderProgress);
+        };
+        return {
+            syncResults,
+            asyncResults: getAsyncResults()
+        };
+    }
+    fileSearch(query, token) {
+        return this.doSearch(query, token);
+    }
+    doSearch(query, token, onProgress) {
+        this.logService.trace('SearchService#search', JSON.stringify(query));
+        const schemesInQuery = this.getSchemesInQuery(query);
+        const providerActivations = [Promise.resolve(null)];
+        schemesInQuery.forEach(scheme => providerActivations.push(this.extensionService.activateByEvent(`onSearch:${scheme}`)));
+        providerActivations.push(this.extensionService.activateByEvent('onSearch:file'));
+        const providerPromise = (async () => {
+            await Promise.all(providerActivations);
+            await this.extensionService.whenInstalledExtensionsRegistered();
+            if (token && token.isCancellationRequested) {
+                return Promise.reject(( new CancellationError()));
+            }
+            const progressCallback = (item) => {
+                if (token && token.isCancellationRequested) {
+                    return;
+                }
+                onProgress?.(item);
+            };
+            const exists = await Promise.all(( query.folderQueries.map(query => this.fileService.exists(query.folder))));
+            query.folderQueries = query.folderQueries.filter((_, i) => exists[i]);
+            let completes = await this.searchWithProviders(query, progressCallback, token);
+            completes = coalesce(completes);
+            if (!completes.length) {
+                return {
+                    limitHit: false,
+                    results: [],
+                    messages: [],
+                };
+            }
+            return {
+                limitHit: completes[0] && completes[0].limitHit,
+                stats: completes[0].stats,
+                messages: coalesce(flatten(( completes.map(i => i.messages)))).filter(uniqueFilter(message => message.type + message.text + message.trusted)),
+                results: flatten(( completes.map((c) => c.results)))
+            };
+        })();
+        return token ? raceCancellationError(providerPromise, token) : providerPromise;
+    }
+    getSchemesInQuery(query) {
+        const schemes = ( new Set());
+        query.folderQueries?.forEach(fq => schemes.add(fq.folder.scheme));
+        query.extraFileResources?.forEach(extraFile => schemes.add(extraFile.scheme));
+        return schemes;
+    }
+    async waitForProvider(queryType, scheme) {
+        const deferredMap = this.getDeferredTextSearchesByScheme(queryType);
+        if (( deferredMap.has(scheme))) {
+            return deferredMap.get(scheme).p;
+        }
+        else {
+            const deferred = ( new DeferredPromise());
+            deferredMap.set(scheme, deferred);
+            return deferred.p;
+        }
+    }
+    getSearchProvider(type) {
+        switch (type) {
+            case 1 :
+                return this.fileSearchProviders;
+            case 2 :
+                return this.textSearchProviders;
+            case 3 :
+                return this.aiTextSearchProviders;
+            default:
+                throw new Error(`Unknown query type: ${type}`);
+        }
+    }
+    getDeferredTextSearchesByScheme(type) {
+        switch (type) {
+            case 1 :
+                return this.deferredFileSearchesByScheme;
+            case 2 :
+                return this.deferredTextSearchesByScheme;
+            case 3 :
+                return this.deferredAITextSearchesByScheme;
+            default:
+                throw new Error(`Unknown query type: ${type}`);
+        }
+    }
+    async searchWithProviders(query, onProviderProgress, token) {
+        const e2eSW = StopWatch.create(false);
+        const searchPs = [];
+        const fqs = this.groupFolderQueriesByScheme(query);
+        const someSchemeHasProvider = ( [...( fqs.keys())].some(scheme => {
+            return ( this.getSearchProvider(query.type).has(scheme));
+        }));
+        if (query.type === 3  && !someSchemeHasProvider) {
+            return [];
+        }
+        await Promise.all(( [...( fqs.keys())].map(async (scheme) => {
+            const schemeFQs = fqs.get(scheme);
+            let provider = this.getSearchProvider(query.type).get(scheme);
+            if (!provider) {
+                if (someSchemeHasProvider) {
+                    if (!( this.loggedSchemesMissingProviders.has(scheme))) {
+                        this.logService.warn(`No search provider registered for scheme: ${scheme}. Another scheme has a provider, not waiting for ${scheme}`);
+                        this.loggedSchemesMissingProviders.add(scheme);
+                    }
+                    return;
+                }
+                else {
+                    if (!( this.loggedSchemesMissingProviders.has(scheme))) {
+                        this.logService.warn(`No search provider registered for scheme: ${scheme}, waiting`);
+                        this.loggedSchemesMissingProviders.add(scheme);
+                    }
+                    provider = await this.waitForProvider(query.type, scheme);
+                }
+            }
+            const oneSchemeQuery = {
+                ...query,
+                ...{
+                    folderQueries: schemeFQs
+                }
+            };
+            const doProviderSearch = () => {
+                switch (query.type) {
+                    case 1 :
+                        return provider.fileSearch(oneSchemeQuery, token);
+                    case 2 :
+                        return provider.textSearch(oneSchemeQuery, onProviderProgress, token);
+                    default:
+                        return provider.textSearch(oneSchemeQuery, onProviderProgress, token);
+                }
+            };
+            searchPs.push(doProviderSearch());
+        })));
+        return Promise.all(searchPs).then(completes => {
+            const endToEndTime = e2eSW.elapsed();
+            this.logService.trace(`SearchService#search: ${endToEndTime}ms`);
+            completes.forEach(complete => {
+                this.sendTelemetry(query, endToEndTime, complete);
+            });
+            return completes;
+        }, err => {
+            const endToEndTime = e2eSW.elapsed();
+            this.logService.trace(`SearchService#search: ${endToEndTime}ms`);
+            const searchError = deserializeSearchError(err);
+            this.logService.trace(`SearchService#searchError: ${searchError.message}`);
+            this.sendTelemetry(query, endToEndTime, undefined, searchError);
+            throw searchError;
+        });
+    }
+    groupFolderQueriesByScheme(query) {
+        const queries = ( new Map());
+        query.folderQueries.forEach(fq => {
+            const schemeFQs = queries.get(fq.folder.scheme) || [];
+            schemeFQs.push(fq);
+            queries.set(fq.folder.scheme, schemeFQs);
+        });
+        return queries;
+    }
+    sendTelemetry(query, endToEndTime, complete, err) {
+        const fileSchemeOnly = query.folderQueries.every(fq => fq.folder.scheme === Schemas.file);
+        const otherSchemeOnly = query.folderQueries.every(fq => fq.folder.scheme !== Schemas.file);
+        const scheme = fileSchemeOnly ? Schemas.file :
+            otherSchemeOnly ? 'other' :
+                'mixed';
+        if (query.type === 1  && complete && complete.stats) {
+            const fileSearchStats = complete.stats;
+            if (fileSearchStats.fromCache) {
+                const cacheStats = fileSearchStats.detailStats;
+                this.telemetryService.publicLog2('cachedSearchComplete', {
+                    reason: query._reason,
+                    resultCount: fileSearchStats.resultCount,
+                    workspaceFolderCount: query.folderQueries.length,
+                    endToEndTime: endToEndTime,
+                    sortingTime: fileSearchStats.sortingTime,
+                    cacheWasResolved: cacheStats.cacheWasResolved,
+                    cacheLookupTime: cacheStats.cacheLookupTime,
+                    cacheFilterTime: cacheStats.cacheFilterTime,
+                    cacheEntryCount: cacheStats.cacheEntryCount,
+                    scheme
+                });
+            }
+            else {
+                const searchEngineStats = fileSearchStats.detailStats;
+                this.telemetryService.publicLog2('searchComplete', {
+                    reason: query._reason,
+                    resultCount: fileSearchStats.resultCount,
+                    workspaceFolderCount: query.folderQueries.length,
+                    endToEndTime: endToEndTime,
+                    sortingTime: fileSearchStats.sortingTime,
+                    fileWalkTime: searchEngineStats.fileWalkTime,
+                    directoriesWalked: searchEngineStats.directoriesWalked,
+                    filesWalked: searchEngineStats.filesWalked,
+                    cmdTime: searchEngineStats.cmdTime,
+                    cmdResultCount: searchEngineStats.cmdResultCount,
+                    scheme
+                });
+            }
+        }
+        else if (query.type === 2 ) {
+            let errorType;
+            if (err) {
+                errorType = err.code === SearchErrorCode.regexParseError ? 'regex' :
+                    err.code === SearchErrorCode.unknownEncoding ? 'encoding' :
+                        err.code === SearchErrorCode.globParseError ? 'glob' :
+                            err.code === SearchErrorCode.invalidLiteral ? 'literal' :
+                                err.code === SearchErrorCode.other ? 'other' :
+                                    err.code === SearchErrorCode.canceled ? 'canceled' :
+                                        'unknown';
+            }
+            this.telemetryService.publicLog2('textSearchComplete', {
+                reason: query._reason,
+                workspaceFolderCount: query.folderQueries.length,
+                endToEndTime: endToEndTime,
+                scheme,
+                error: errorType,
+            });
+        }
+    }
+    getOpenEditorResults(query) {
+        const openEditorResults = ( new ResourceMap(uri => this.uriIdentityService.extUri.getComparisonKey(uri)));
+        let limitHit = false;
+        if (query.type === 2 ) {
+            const canonicalToOriginalResources = ( new ResourceMap());
+            for (const editorInput of this.editorService.editors) {
+                const canonical = EditorResourceAccessor.getCanonicalUri(editorInput, { supportSideBySide: SideBySideEditor.PRIMARY });
+                const original = EditorResourceAccessor.getOriginalUri(editorInput, { supportSideBySide: SideBySideEditor.PRIMARY });
+                if (canonical) {
+                    canonicalToOriginalResources.set(canonical, original ?? canonical);
+                }
+            }
+            const models = this.modelService.getModels();
+            models.forEach((model) => {
+                const resource = model.uri;
+                if (!resource) {
+                    return;
+                }
+                if (limitHit) {
+                    return;
+                }
+                const originalResource = canonicalToOriginalResources.get(resource);
+                if (!originalResource) {
+                    return;
+                }
+                if (model.getLanguageId() === SEARCH_RESULT_LANGUAGE_ID && !(query.includePattern && query.includePattern['**/*.code-search'])) {
+                    return;
+                }
+                if (originalResource.scheme !== Schemas.untitled && !this.fileService.hasProvider(originalResource)) {
+                    return;
+                }
+                if (originalResource.scheme === 'git') {
+                    return;
+                }
+                if (!this.matches(originalResource, query)) {
+                    return;
+                }
+                const askMax = isNumber(query.maxResults) ? query.maxResults + 1 : Number.MAX_SAFE_INTEGER;
+                let matches = model.findMatches(query.contentPattern.pattern, false, !!query.contentPattern.isRegExp, !!query.contentPattern.isCaseSensitive, query.contentPattern.isWordMatch ? query.contentPattern.wordSeparators : null, false, askMax);
+                if (matches.length) {
+                    if (askMax && matches.length >= askMax) {
+                        limitHit = true;
+                        matches = matches.slice(0, askMax - 1);
+                    }
+                    const fileMatch = ( new FileMatch(originalResource));
+                    openEditorResults.set(originalResource, fileMatch);
+                    const textSearchResults = editorMatchesToTextSearchResults(matches, model, query.previewOptions);
+                    fileMatch.results = getTextSearchMatchWithModelContext(textSearchResults, model, query);
+                }
+                else {
+                    openEditorResults.set(originalResource, null);
+                }
+            });
+        }
+        return {
+            results: openEditorResults,
+            limitHit
+        };
+    }
+    matches(resource, query) {
+        return pathIncludedInQuery(query, resource.fsPath);
+    }
+    async clearCache(cacheKey) {
+        const clearPs = ( Array.from(( this.fileSearchProviders.values()))
+            .map(provider => provider && provider.clearCache(cacheKey)));
+        await Promise.all(clearPs);
+    }
+};
+SearchService = ( __decorate([
+    ( __param(0, IModelService)),
+    ( __param(1, IEditorService)),
+    ( __param(2, ITelemetryService)),
+    ( __param(3, ILogService)),
+    ( __param(4, IExtensionService)),
+    ( __param(5, IFileService)),
+    ( __param(6, IUriIdentityService))
+], SearchService));
+
+export { SearchService };