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

package/vscode/src/vs/workbench/contrib/searchEditor/browser/searchEditorSerialization.js

@@ -1,293 +0,0 @@
-import { coalesce, flatten } from 'vscode/vscode/vs/base/common/arrays';
-import './media/searchEditor.css.js';
-import { Range } from 'vscode/vscode/vs/editor/common/core/range';
-import { localizeWithPath } from 'vscode/vscode/vs/nls';
-import { searchMatchComparer } from 'vscode/vscode/vs/workbench/contrib/search/browser/searchModel';
-import { ITextFileService } from 'vscode/vscode/vs/workbench/services/textfile/common/textfiles';
-
-const lineDelimiter = '\n';
-const translateRangeLines = (n) => (range) => ( new Range(
-    range.startLineNumber + n,
-    range.startColumn,
-    range.endLineNumber + n,
-    range.endColumn
-));
-const matchToSearchResultFormat = (match, longestLineNumber) => {
-    const getLinePrefix = (i) => `${match.range().startLineNumber + i}`;
-    const fullMatchLines = match.fullPreviewLines();
-    const results = [];
-    fullMatchLines
-        .forEach((sourceLine, i) => {
-        const lineNumber = getLinePrefix(i);
-        const paddingStr = ' '.repeat(longestLineNumber - lineNumber.length);
-        const prefix = `  ${paddingStr}${lineNumber}: `;
-        const prefixOffset = prefix.length;
-        const line = prefix + (sourceLine.split(/\r?\n?$/, 1)[0] || '');
-        const rangeOnThisLine = ({ start, end }) => ( new Range(
-            1,
-            (start ?? 1) + prefixOffset,
-            1,
-            (end ?? sourceLine.length + 1) + prefixOffset
-        ));
-        const matchRange = match.rangeInPreview();
-        const matchIsSingleLine = matchRange.startLineNumber === matchRange.endLineNumber;
-        let lineRange;
-        if (matchIsSingleLine) {
-            lineRange = (rangeOnThisLine({ start: matchRange.startColumn, end: matchRange.endColumn }));
-        }
-        else if (i === 0) {
-            lineRange = (rangeOnThisLine({ start: matchRange.startColumn }));
-        }
-        else if (i === fullMatchLines.length - 1) {
-            lineRange = (rangeOnThisLine({ end: matchRange.endColumn }));
-        }
-        else {
-            lineRange = (rangeOnThisLine({}));
-        }
-        results.push({ lineNumber: lineNumber, line, ranges: [lineRange] });
-    });
-    return results;
-};
-function fileMatchToSearchResultFormat(fileMatch, labelFormatter) {
-    const textSerializations = fileMatch.textMatches().length > 0 ? matchesToSearchResultFormat(fileMatch.resource, fileMatch.textMatches().sort(searchMatchComparer), fileMatch.context, labelFormatter) : undefined;
-    const cellSerializations = ( fileMatch.cellMatches().sort((a, b) => a.cellIndex - b.cellIndex).sort().filter(cellMatch => cellMatch.contentMatches.length > 0).map(
-        (cellMatch, index) => cellMatchToSearchResultFormat(cellMatch, labelFormatter, index === 0)
-    ));
-    return [textSerializations, ...cellSerializations].filter(x => !!x);
-}
-function matchesToSearchResultFormat(resource, sortedMatches, matchContext, labelFormatter, shouldUseHeader = true) {
-    const longestLineNumber = ( sortedMatches[sortedMatches.length - 1].range().endLineNumber.toString()).length;
-    const text = shouldUseHeader ? [`${labelFormatter(resource)}:`] : [];
-    const matchRanges = [];
-    const targetLineNumberToOffset = {};
-    const context = [];
-    matchContext.forEach((line, lineNumber) => context.push({ line, lineNumber }));
-    context.sort((a, b) => a.lineNumber - b.lineNumber);
-    let lastLine = undefined;
-    const seenLines = ( new Set());
-    sortedMatches.forEach(match => {
-        matchToSearchResultFormat(match, longestLineNumber).forEach(match => {
-            if (!( seenLines.has(match.lineNumber))) {
-                while (context.length && context[0].lineNumber < +match.lineNumber) {
-                    const { line, lineNumber } = context.shift();
-                    if (lastLine !== undefined && lineNumber !== lastLine + 1) {
-                        text.push('');
-                    }
-                    text.push(`  ${' '.repeat(longestLineNumber - `${lineNumber}`.length)}${lineNumber}  ${line}`);
-                    lastLine = lineNumber;
-                }
-                targetLineNumberToOffset[match.lineNumber] = text.length;
-                seenLines.add(match.lineNumber);
-                text.push(match.line);
-                lastLine = +match.lineNumber;
-            }
-            matchRanges.push(...( match.ranges.map(translateRangeLines(targetLineNumberToOffset[match.lineNumber]))));
-        });
-    });
-    while (context.length) {
-        const { line, lineNumber } = context.shift();
-        text.push(`  ${lineNumber}  ${line}`);
-    }
-    return { text, matchRanges };
-}
-function cellMatchToSearchResultFormat(cellMatch, labelFormatter, shouldUseHeader) {
-    return matchesToSearchResultFormat(cellMatch.cell?.uri ?? cellMatch.parent.resource, cellMatch.contentMatches.sort(searchMatchComparer), cellMatch.context, labelFormatter, shouldUseHeader);
-}
-const contentPatternToSearchConfiguration = (pattern, includes, excludes, contextLines) => {
-    return {
-        query: pattern.contentPattern.pattern,
-        isRegexp: !!pattern.contentPattern.isRegExp,
-        isCaseSensitive: !!pattern.contentPattern.isCaseSensitive,
-        matchWholeWord: !!pattern.contentPattern.isWordMatch,
-        filesToExclude: excludes, filesToInclude: includes,
-        showIncludesExcludes: !!(includes || excludes || pattern?.userDisabledExcludesAndIgnoreFiles),
-        useExcludeSettingsAndIgnoreFiles: (pattern?.userDisabledExcludesAndIgnoreFiles === undefined ? true : !pattern.userDisabledExcludesAndIgnoreFiles),
-        contextLines,
-        onlyOpenEditors: !!pattern.onlyOpenEditors,
-        notebookSearchConfig: {
-            includeMarkupInput: !!pattern.contentPattern.notebookInfo?.isInNotebookMarkdownInput,
-            includeMarkupPreview: !!pattern.contentPattern.notebookInfo?.isInNotebookMarkdownPreview,
-            includeCodeInput: !!pattern.contentPattern.notebookInfo?.isInNotebookCellInput,
-            includeOutput: !!pattern.contentPattern.notebookInfo?.isInNotebookCellOutput,
-        }
-    };
-};
-const serializeSearchConfiguration = (config) => {
-    const removeNullFalseAndUndefined = (a) => a.filter(a => a !== false && a !== null && a !== undefined);
-    const escapeNewlines = (str) => str.replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
-    return removeNullFalseAndUndefined([
-        `# Query: ${escapeNewlines(config.query ?? '')}`,
-        (config.isCaseSensitive || config.matchWholeWord || config.isRegexp || config.useExcludeSettingsAndIgnoreFiles === false)
-            && `# Flags: ${coalesce([
-                config.isCaseSensitive && 'CaseSensitive',
-                config.matchWholeWord && 'WordMatch',
-                config.isRegexp && 'RegExp',
-                config.onlyOpenEditors && 'OpenEditors',
-                (config.useExcludeSettingsAndIgnoreFiles === false) && 'IgnoreExcludeSettings'
-            ]).join(' ')}`,
-        config.filesToInclude ? `# Including: ${config.filesToInclude}` : undefined,
-        config.filesToExclude ? `# Excluding: ${config.filesToExclude}` : undefined,
-        config.contextLines ? `# ContextLines: ${config.contextLines}` : undefined,
-        ''
-    ]).join(lineDelimiter);
-};
-const defaultSearchConfig = () => ({
-    query: '',
-    filesToInclude: '',
-    filesToExclude: '',
-    isRegexp: false,
-    isCaseSensitive: false,
-    useExcludeSettingsAndIgnoreFiles: true,
-    matchWholeWord: false,
-    contextLines: 0,
-    showIncludesExcludes: false,
-    onlyOpenEditors: false,
-    notebookSearchConfig: {
-        includeMarkupInput: true,
-        includeMarkupPreview: false,
-        includeCodeInput: true,
-        includeOutput: true,
-    }
-});
-const extractSearchQueryFromLines = (lines) => {
-    const query = defaultSearchConfig();
-    const unescapeNewlines = (str) => {
-        let out = '';
-        for (let i = 0; i < str.length; i++) {
-            if (str[i] === '\\') {
-                i++;
-                const escaped = str[i];
-                if (escaped === 'n') {
-                    out += '\n';
-                }
-                else if (escaped === '\\') {
-                    out += '\\';
-                }
-                else {
-                    throw Error(localizeWithPath('vs/workbench/contrib/searchEditor/browser/searchEditorSerialization', 'invalidQueryStringError', "All backslashes in Query string must be escaped (\\\\)"));
-                }
-            }
-            else {
-                out += str[i];
-            }
-        }
-        return out;
-    };
-    const parseYML = /^# ([^:]*): (.*)$/;
-    for (const line of lines) {
-        const parsed = parseYML.exec(line);
-        if (!parsed) {
-            continue;
-        }
-        const [, key, value] = parsed;
-        switch (key) {
-            case 'Query':
-                query.query = unescapeNewlines(value);
-                break;
-            case 'Including':
-                query.filesToInclude = value;
-                break;
-            case 'Excluding':
-                query.filesToExclude = value;
-                break;
-            case 'ContextLines':
-                query.contextLines = +value;
-                break;
-            case 'Flags': {
-                query.isRegexp = value.indexOf('RegExp') !== -1;
-                query.isCaseSensitive = value.indexOf('CaseSensitive') !== -1;
-                query.useExcludeSettingsAndIgnoreFiles = value.indexOf('IgnoreExcludeSettings') === -1;
-                query.matchWholeWord = value.indexOf('WordMatch') !== -1;
-                query.onlyOpenEditors = value.indexOf('OpenEditors') !== -1;
-            }
-        }
-    }
-    query.showIncludesExcludes = !!(query.filesToInclude || query.filesToExclude || !query.useExcludeSettingsAndIgnoreFiles);
-    return query;
-};
-const serializeSearchResultForEditor = (searchResult, rawIncludePattern, rawExcludePattern, contextLines, labelFormatter, sortOrder, limitHit) => {
-    if (!searchResult.query) {
-        throw Error('Internal Error: Expected query, got null');
-    }
-    const config = contentPatternToSearchConfiguration(searchResult.query, rawIncludePattern, rawExcludePattern, contextLines);
-    const filecount = searchResult.fileCount() > 1 ? ( localizeWithPath(
-        'vs/workbench/contrib/searchEditor/browser/searchEditorSerialization',
-        'numFiles',
-        "{0} files",
-        searchResult.fileCount()
-    )) : ( localizeWithPath(
-        'vs/workbench/contrib/searchEditor/browser/searchEditorSerialization',
-        'oneFile',
-        "1 file"
-    ));
-    const resultcount = searchResult.count() > 1 ? ( localizeWithPath(
-        'vs/workbench/contrib/searchEditor/browser/searchEditorSerialization',
-        'numResults',
-        "{0} results",
-        searchResult.count()
-    )) : ( localizeWithPath(
-        'vs/workbench/contrib/searchEditor/browser/searchEditorSerialization',
-        'oneResult',
-        "1 result"
-    ));
-    const info = [
-        searchResult.count()
-            ? `${resultcount} - ${filecount}`
-            : ( localizeWithPath(
-            'vs/workbench/contrib/searchEditor/browser/searchEditorSerialization',
-            'noResults',
-            "No Results"
-        )),
-    ];
-    if (limitHit) {
-        info.push(( localizeWithPath(
-            'vs/workbench/contrib/searchEditor/browser/searchEditorSerialization',
-            'searchMaxResultsWarning',
-            "The result set only contains a subset of all matches. Be more specific in your search to narrow down the results."
-        )));
-    }
-    info.push('');
-    const matchComparer = (a, b) => searchMatchComparer(a, b, sortOrder);
-    const allResults = flattenSearchResultSerializations(flatten(( searchResult.folderMatches().sort(matchComparer)
-        .map(folderMatch => folderMatch.allDownstreamFileMatches().sort(matchComparer)
-        .flatMap(fileMatch => fileMatchToSearchResultFormat(fileMatch, labelFormatter))))));
-    return {
-        matchRanges: ( allResults.matchRanges.map(translateRangeLines(info.length))),
-        text: info.concat(allResults.text).join(lineDelimiter),
-        config
-    };
-};
-const flattenSearchResultSerializations = (serializations) => {
-    const text = [];
-    const matchRanges = [];
-    serializations.forEach(serialized => {
-        ( serialized.matchRanges.map(translateRangeLines(text.length))).forEach(range => matchRanges.push(range));
-        serialized.text.forEach(line => text.push(line));
-        text.push('');
-    });
-    return { text, matchRanges };
-};
-const parseSavedSearchEditor = async (accessor, resource) => {
-    const textFileService = accessor.get(ITextFileService);
-    const text = (await textFileService.read(resource)).value;
-    return parseSerializedSearchEditor(text);
-};
-const parseSerializedSearchEditor = (text) => {
-    const headerlines = [];
-    const bodylines = [];
-    let inHeader = true;
-    for (const line of text.split(/\r?\n/g)) {
-        if (inHeader) {
-            headerlines.push(line);
-            if (line === '') {
-                inHeader = false;
-            }
-        }
-        else {
-            bodylines.push(line);
-        }
-    }
-    return { config: extractSearchQueryFromLines(headerlines), text: bodylines.join('\n') };
-};
-
-export { defaultSearchConfig, extractSearchQueryFromLines, parseSavedSearchEditor, parseSerializedSearchEditor, serializeSearchConfiguration, serializeSearchResultForEditor };

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

@@ -1,372 +0,0 @@
-import { __decorate, __param } from '../../../../../../../external/tslib/tslib.es6.js';
-import { coalesce, flatten, uniqueFilter } from 'vscode/vscode/vs/base/common/arrays';
-import { 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.deferredFileSearchesByScheme = ( new Map());
-        this.deferredTextSearchesByScheme = ( 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 {
-            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]
-        };
-    }
-    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 ( new Promise((resolve, reject) => {
-            if (token) {
-                token.onCancellationRequested(() => {
-                    reject(( new CancellationError()));
-                });
-            }
-            providerPromise.then(resolve, reject);
-        }));
-    }
-    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 = queryType === 1  ?
-            this.deferredFileSearchesByScheme :
-            this.deferredTextSearchesByScheme;
-        if (( deferredMap.has(scheme))) {
-            return deferredMap.get(scheme).p;
-        }
-        else {
-            const deferred = ( new DeferredPromise());
-            deferredMap.set(scheme, deferred);
-            return deferred.p;
-        }
-    }
-    async searchWithProviders(query, onProviderProgress, token) {
-        const e2eSW = StopWatch.create(false);
-        const searchPs = [];
-        const fqs = this.groupFolderQueriesByScheme(query);
-        const someSchemeHasProvider = ( [...( fqs.keys())].some(scheme => {
-            return query.type === 1  ?
-                ( this.fileSearchProviders.has(scheme)) :
-                ( this.textSearchProviders.has(scheme));
-        }));
-        await Promise.all(( [...( fqs.keys())].map(async (scheme) => {
-            const schemeFQs = fqs.get(scheme);
-            let provider = query.type === 1  ?
-                this.fileSearchProviders.get(scheme) :
-                this.textSearchProviders.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
-                }
-            };
-            searchPs.push(query.type === 1  ?
-                provider.fileSearch(oneSchemeQuery, token) :
-                provider.textSearch(oneSchemeQuery, onProviderProgress, token));
-        })));
-        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 };