Merge from master

src/vs/workbench/api/node/extHostSearch.fileIndex.ts

@@ -2,143 +2,27 @@
  *  Copyright (c) Microsoft Corporation. All rights reserved.
  *  Licensed under the Source EULA. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
-'use strict';
 
 import * as path from 'path';
 import * as arrays from 'vs/base/common/arrays';
-import { CancellationTokenSource } from 'vs/base/common/cancellation';
-import { toErrorMessage } from 'vs/base/common/errorMessage';
+import { CancelablePromise, createCancelablePromise } from 'vs/base/common/async';
+import { CancellationToken, CancellationTokenSource } from 'vs/base/common/cancellation';
+import { canceled } from 'vs/base/common/errors';
 import * as glob from 'vs/base/common/glob';
 import * as resources from 'vs/base/common/resources';
+import { StopWatch } from 'vs/base/common/stopwatch';
 import * as strings from 'vs/base/common/strings';
-import URI from 'vs/base/common/uri';
-import { TPromise } from 'vs/base/common/winjs.base';
+import { URI } from 'vs/base/common/uri';
 import { compareItemsByScore, IItemAccessor, prepareQuery, ScorerCache } from 'vs/base/parts/quickopen/common/quickOpenScorer';
-import { IFileMatch, IFolderQuery, IRawSearchQuery, ISearchCompleteStats, ISearchQuery } from 'vs/platform/search/common/search';
+import { ICachedSearchStats, IFileIndexProviderStats, IFileMatch, IFileQuery, IFileSearchStats, IFolderQuery, ISearchCompleteStats } from 'vs/platform/search/common/search';
+import { IDirectoryEntry, IDirectoryTree, IInternalFileMatch } from 'vs/workbench/services/search/node/fileSearchManager';
+import { QueryGlobTester, resolvePatternsForProvider } from 'vs/workbench/services/search/node/search';
 import * as vscode from 'vscode';
 
-export interface IInternalFileMatch {
-	base: URI;
-	original?: URI;
-	relativePath?: string; // Not present for extraFiles or absolute path matches
-	basename: string;
-	size?: number;
-}
-
-/**
- *  Computes the patterns that the provider handles. Discards sibling clauses and 'false' patterns
- */
-export function resolvePatternsForProvider(globalPattern: glob.IExpression, folderPattern: glob.IExpression): string[] {
-	const merged = {
-		...(globalPattern || {}),
-		...(folderPattern || {})
-	};
-
-	return Object.keys(merged)
-		.filter(key => {
-			const value = merged[key];
-			return typeof value === 'boolean' && value;
-		});
-}
-
-export class QueryGlobTester {
-
-	private _excludeExpression: glob.IExpression;
-	private _parsedExcludeExpression: glob.ParsedExpression;
-
-	private _parsedIncludeExpression: glob.ParsedExpression;
-
-	constructor(config: ISearchQuery, folderQuery: IFolderQuery) {
-		this._excludeExpression = {
-			...(config.excludePattern || {}),
-			...(folderQuery.excludePattern || {})
-		};
-		this._parsedExcludeExpression = glob.parse(this._excludeExpression);
-
-		// Empty includeExpression means include nothing, so no {} shortcuts
-		let includeExpression: glob.IExpression = config.includePattern;
-		if (folderQuery.includePattern) {
-			if (includeExpression) {
-				includeExpression = {
-					...includeExpression,
-					...folderQuery.includePattern
-				};
-			} else {
-				includeExpression = folderQuery.includePattern;
-			}
-		}
-
-		if (includeExpression) {
-			this._parsedIncludeExpression = glob.parse(includeExpression);
-		}
-	}
-
-	/**
-	 * Guaranteed sync - siblingsFn should not return a promise.
-	 */
-	public includedInQuerySync(testPath: string, basename?: string, hasSibling?: (name: string) => boolean): boolean {
-		if (this._parsedExcludeExpression && this._parsedExcludeExpression(testPath, basename, hasSibling)) {
-			return false;
-		}
-
-		if (this._parsedIncludeExpression && !this._parsedIncludeExpression(testPath, basename, hasSibling)) {
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Guaranteed async.
-	 */
-	public includedInQuery(testPath: string, basename?: string, hasSibling?: (name: string) => boolean | TPromise<boolean>): TPromise<boolean> {
-		const excludeP = this._parsedExcludeExpression ?
-			TPromise.as(this._parsedExcludeExpression(testPath, basename, hasSibling)).then(result => !!result) :
-			TPromise.wrap(false);
-
-		return excludeP.then(excluded => {
-			if (excluded) {
-				return false;
-			}
-
-			return this._parsedIncludeExpression ?
-				TPromise.as(this._parsedIncludeExpression(testPath, basename, hasSibling)).then(result => !!result) :
-				TPromise.wrap(true);
-		}).then(included => {
-			return included;
-		});
-	}
-
-	public hasSiblingExcludeClauses(): boolean {
-		return hasSiblingClauses(this._excludeExpression);
-	}
-}
-
-function hasSiblingClauses(pattern: glob.IExpression): boolean {
-	for (let key in pattern) {
-		if (typeof pattern[key] !== 'boolean') {
-			return true;
-		}
-	}
-
-	return false;
-}
-
-export interface IDirectoryEntry {
-	base: URI;
-	relativePath: string;
-	basename: string;
-}
-
-export interface IDirectoryTree {
-	rootEntries: IDirectoryEntry[];
-	pathToEntries: { [relativePath: string]: IDirectoryEntry[] };
-}
-
-// ???
-interface IInternalSearchComplete {
+interface IInternalSearchComplete<T = IFileSearchStats> {
 	limitHit: boolean;
 	results: IInternalFileMatch[];
+	stats: T;
 }
 
 export class FileIndexSearchEngine {
@@ -151,11 +35,14 @@ export class FileIndexSearchEngine {
 	private resultCount: number;
 	private isCanceled: boolean;
 
+	private filesWalked = 0;
+	private dirsWalked = 0;
+
 	private activeCancellationTokens: Set<CancellationTokenSource>;
 
 	private globalExcludePattern: glob.ParsedExpression;
 
-	constructor(private config: ISearchQuery, private provider: vscode.FileIndexProvider) {
+	constructor(private config: IFileQuery, private provider: vscode.FileIndexProvider) {
 		this.filePattern = config.filePattern;
 		this.includePattern = config.includePattern && glob.parse(config.includePattern);
 		this.maxResults = config.maxResults || null;
@@ -177,21 +64,18 @@ export class FileIndexSearchEngine {
 		this.activeCancellationTokens = new Set();
 	}
 
-	public search(_onResult: (match: IInternalFileMatch) => void): TPromise<{ isLimitHit: boolean }> {
-		if (this.config.folderQueries.length !== 1) {
-			throw new Error('Searches just one folder');
-		}
-
+	public search(_onResult: (match: IInternalFileMatch) => void): Promise<{ isLimitHit: boolean, stats: IFileIndexProviderStats }> {
+		// Searches a single folder
 		const folderQuery = this.config.folderQueries[0];
 
-		return new TPromise<{ isLimitHit: boolean }>((resolve, reject) => {
+		return new Promise<{ isLimitHit: boolean, stats: IFileIndexProviderStats }>((resolve, reject) => {
 			const onResult = (match: IInternalFileMatch) => {
 				this.resultCount++;
 				_onResult(match);
 			};
 
 			if (this.isCanceled) {
-				return resolve({ isLimitHit: this.isLimitHit });
+				throw canceled();
 			}
 
 			// For each extra file
@@ -209,22 +93,31 @@ export class FileIndexSearchEngine {
 					});
 			}
 
-			return this.searchInFolder(folderQuery, _onResult)
-				.then(() => {
-					resolve({ isLimitHit: this.isLimitHit });
-				}, (errs: Error[]) => {
-					const errMsg = errs
-						.map(err => toErrorMessage(err))
-						.filter(msg => !!msg)[0];
-
-					reject(new Error(errMsg));
+			return Promise.all(this.config.folderQueries.map(fq => this.searchInFolder(folderQuery, onResult))).then(stats => {
+				resolve({
+					isLimitHit: this.isLimitHit,
+					stats: {
+						directoriesWalked: this.dirsWalked,
+						filesWalked: this.filesWalked,
+						fileWalkTime: stats.map(s => s.fileWalkTime).reduce((s, c) => s + c, 0),
+						providerTime: stats.map(s => s.providerTime).reduce((s, c) => s + c, 0),
+						providerResultCount: stats.map(s => s.providerResultCount).reduce((s, c) => s + c, 0)
+					}
 				});
+			}, (errs: Error[]) => {
+				if (!Array.isArray(errs)) {
+					errs = [errs];
+				}
+
+				errs = errs.filter(e => !!e);
+				return Promise.reject(errs[0]);
+			});
 		});
 	}
 
-	private searchInFolder(fq: IFolderQuery<URI>, onResult: (match: IInternalFileMatch) => void): TPromise<void> {
+	private searchInFolder(fq: IFolderQuery<URI>, onResult: (match: IInternalFileMatch) => void): Promise<IFileIndexProviderStats> {
 		let cancellation = new CancellationTokenSource();
-		return new TPromise((resolve, reject) => {
+		return new Promise((resolve, reject) => {
 			const options = this.getSearchOptionsForFolder(fq);
 			const tree = this.initDirectoryTree();
 
@@ -249,12 +142,18 @@ export class FileIndexSearchEngine {
 				this.addDirectoryEntries(tree, fq.folder, relativePath, onResult);
 			};
 
-			new TPromise(resolve => process.nextTick(resolve))
+			let providerSW: StopWatch;
+			let providerTime: number;
+			let fileWalkTime: number;
+			new Promise(resolve => process.nextTick(resolve))
 				.then(() => {
 					this.activeCancellationTokens.add(cancellation);
+					providerSW = StopWatch.create();
 					return this.provider.provideFileIndex(options, cancellation.token);
 				})
 				.then(results => {
+					providerTime = providerSW.elapsed();
+					const postProcessSW = StopWatch.create();
 					this.activeCancellationTokens.delete(cancellation);
 					if (this.isCanceled) {
 						return null;
@@ -263,11 +162,17 @@ export class FileIndexSearchEngine {
 					results.forEach(onProviderResult);
 
 					this.matchDirectoryTree(tree, queryTester, onResult);
+					fileWalkTime = postProcessSW.elapsed();
 					return null;
 				}).then(
 					() => {
 						cancellation.dispose();
-						resolve(undefined);
+						resolve(<IFileIndexProviderStats>{
+							providerTime,
+							fileWalkTime,
+							directoriesWalked: this.dirsWalked,
+							filesWalked: this.filesWalked
+						});
 					},
 					err => {
 						cancellation.dispose();
@@ -284,8 +189,9 @@ export class FileIndexSearchEngine {
 			folder: fq.folder,
 			excludes,
 			includes,
-			useIgnoreFiles: !this.config.disregardIgnoreFiles,
-			followSymlinks: !this.config.ignoreSymlinks
+			useIgnoreFiles: !fq.disregardIgnoreFiles,
+			useGlobalIgnoreFiles: !fq.disregardGlobalIgnoreFiles,
+			followSymlinks: !fq.ignoreSymlinks
 		};
 	}
 
@@ -327,7 +233,7 @@ export class FileIndexSearchEngine {
 		const self = this;
 		const filePattern = this.filePattern;
 		function matchDirectory(entries: IDirectoryEntry[]) {
-			// self.directoriesWalked++;
+			self.dirsWalked++;
 			for (let i = 0, n = entries.length; i < n; i++) {
 				const entry = entries[i];
 				const { relativePath, basename } = entry;
@@ -345,7 +251,7 @@ export class FileIndexSearchEngine {
 				if (sub) {
 					matchDirectory(sub);
 				} else {
-					// self.filesWalked++;
+					self.filesWalked++;
 					if (relativePath === filePattern) {
 						continue; // ignore file if its path matches with the file pattern because that is already matched above
 					}
@@ -397,9 +303,9 @@ export class FileIndexSearchManager {
 
 	private readonly folderCacheKeys = new Map<string, Set<string>>();
 
-	public fileSearch(config: ISearchQuery, provider: vscode.FileIndexProvider, onBatch: (matches: IFileMatch[]) => void): TPromise<ISearchCompleteStats> {
+	public fileSearch(config: IFileQuery, provider: vscode.FileIndexProvider, onBatch: (matches: IFileMatch[]) => void, token: CancellationToken): Promise<ISearchCompleteStats> {
 		if (config.sortByScore) {
-			let sortedSearch = this.trySortedSearchFromCache(config);
+			let sortedSearch = this.trySortedSearchFromCache(config, token);
 			if (!sortedSearch) {
 				const engineConfig = config.maxResults ?
 					{
@@ -409,30 +315,32 @@ export class FileIndexSearchManager {
 					config;
 
 				const engine = new FileIndexSearchEngine(engineConfig, provider);
-				sortedSearch = this.doSortedSearch(engine, config);
+				sortedSearch = this.doSortedSearch(engine, config, token);
 			}
 
-			return new TPromise<ISearchCompleteStats>((c, e) => {
-				sortedSearch.then(complete => {
-					this.sendAsBatches(complete.results, onBatch, FileIndexSearchManager.BATCH_SIZE);
-					c(complete);
-				}, e, onBatch);
-			}, () => {
-				sortedSearch.cancel();
+			return sortedSearch.then(complete => {
+				this.sendAsBatches(complete.results, onBatch, FileIndexSearchManager.BATCH_SIZE);
+				return complete;
 			});
 		}
 
 		const engine = new FileIndexSearchEngine(config, provider);
-		return this.doSearch(engine)
+		return this.doSearch(engine, token)
 			.then(complete => {
 				this.sendAsBatches(complete.results, onBatch, FileIndexSearchManager.BATCH_SIZE);
 				return <ISearchCompleteStats>{
-					limitHit: complete.limitHit
+					limitHit: complete.limitHit,
+					stats: {
+						type: 'fileIndexProvider',
+						detailStats: complete.stats,
+						fromCache: false,
+						resultCount: complete.results.length
+					}
 				};
 			});
 	}
 
-	private getFolderCacheKey(config: ISearchQuery): string {
+	private getFolderCacheKey(config: IFileQuery): string {
 		const uri = config.folderQueries[0].folder.toString();
 		const folderCacheKey = config.cacheKey && `${uri}_${config.cacheKey}`;
 		if (!this.folderCacheKeys.get(config.cacheKey)) {
@@ -450,41 +358,50 @@ export class FileIndexSearchManager {
 		};
 	}
 
-	private doSortedSearch(engine: FileIndexSearchEngine, config: ISearchQuery): TPromise<IInternalSearchComplete> {
-		let searchPromise: TPromise<void>;
-		let allResultsPromise = new TPromise<IInternalSearchComplete>((c, e) => {
-			searchPromise = this.doSearch(engine).then(c, e);
-		}, () => {
-			searchPromise.cancel();
+	private doSortedSearch(engine: FileIndexSearchEngine, config: IFileQuery, token: CancellationToken): Promise<IInternalSearchComplete> {
+		let allResultsPromise = createCancelablePromise<IInternalSearchComplete<IFileIndexProviderStats>>(token => {
+			return this.doSearch(engine, token);
 		});
 
 		const folderCacheKey = this.getFolderCacheKey(config);
 		let cache: Cache;
 		if (folderCacheKey) {
 			cache = this.getOrCreateCache(folderCacheKey);
-			cache.resultsToSearchCache[config.filePattern] = allResultsPromise;
-			allResultsPromise.then(null, err => {
+			const cacheRow: ICacheRow = {
+				promise: allResultsPromise,
+				resolved: false
+			};
+			cache.resultsToSearchCache[config.filePattern] = cacheRow;
+			allResultsPromise.then(() => {
+				cacheRow.resolved = true;
+			}, err => {
 				delete cache.resultsToSearchCache[config.filePattern];
 			});
 			allResultsPromise = this.preventCancellation(allResultsPromise);
 		}
 
-		let chained: TPromise<void>;
-		return new TPromise<IInternalSearchComplete>((c, e) => {
-			chained = allResultsPromise.then(complete => {
+		return Promise.resolve<IInternalSearchComplete>(
+			allResultsPromise.then(complete => {
 				const scorerCache: ScorerCache = cache ? cache.scorerCache : Object.create(null);
-				return this.sortResults(config, complete.results, scorerCache)
+				const sortSW = (typeof config.maxResults !== 'number' || config.maxResults > 0) && StopWatch.create();
+				return this.sortResults(config, complete.results, scorerCache, token)
 					.then(sortedResults => {
-
-						c({
+						// sortingTime: -1 indicates a "sorted" search that was not sorted, i.e. populating the cache when quickopen is opened.
+						// Contrasting with findFiles which is not sorted and will have sortingTime: undefined
+						const sortingTime = sortSW ? sortSW.elapsed() : -1;
+						return <IInternalSearchComplete>{
 							limitHit: complete.limitHit || typeof config.maxResults === 'number' && complete.results.length > config.maxResults, // ??
-							results: sortedResults
-						});
+							results: sortedResults,
+							stats: {
+								detailStats: complete.stats,
+								fromCache: false,
+								resultCount: sortedResults.length,
+								sortingTime,
+								type: 'fileIndexProvider'
+							}
+						};
 					});
-			}, e);
-		}, () => {
-			chained.cancel();
-		});
+			}));
 	}
 
 	private getOrCreateCache(cacheKey: string): Cache {
@@ -495,34 +412,41 @@ export class FileIndexSearchManager {
 		return this.caches[cacheKey] = new Cache();
 	}
 
-	private trySortedSearchFromCache(config: ISearchQuery): TPromise<IInternalSearchComplete> {
+	private trySortedSearchFromCache(config: IFileQuery, token: CancellationToken): Promise<IInternalSearchComplete> {
 		const folderCacheKey = this.getFolderCacheKey(config);
 		const cache = folderCacheKey && this.caches[folderCacheKey];
 		if (!cache) {
 			return undefined;
 		}
 
-		const cached = this.getResultsFromCache(cache, config.filePattern);
+		const cached = this.getResultsFromCache(cache, config.filePattern, token);
 		if (cached) {
-			let chained: TPromise<void>;
-			return new TPromise<IInternalSearchComplete>((c, e) => {
-				chained = cached.then(complete => {
-					return this.sortResults(config, complete.results, cache.scorerCache)
-						.then(sortedResults => {
-							c({
-								limitHit: complete.limitHit || typeof config.maxResults === 'number' && complete.results.length > config.maxResults,
-								results: sortedResults
-							});
-						});
-				}, e);
-			}, () => {
-				chained.cancel();
+			return cached.then(complete => {
+				const sortSW = StopWatch.create();
+				return this.sortResults(config, complete.results, cache.scorerCache, token)
+					.then(sortedResults => {
+						if (token && token.isCancellationRequested) {
+							throw canceled();
+						}
+
+						return <IInternalSearchComplete<IFileSearchStats>>{
+							limitHit: complete.limitHit || typeof config.maxResults === 'number' && complete.results.length > config.maxResults,
+							results: sortedResults,
+							stats: {
+								fromCache: true,
+								detailStats: complete.stats,
+								type: 'fileIndexProvider',
+								resultCount: sortedResults.length,
+								sortingTime: sortSW.elapsed()
+							}
+						};
+					});
 			});
 		}
 		return undefined;
 	}
 
-	private sortResults(config: IRawSearchQuery, results: IInternalFileMatch[], scorerCache: ScorerCache): TPromise<IInternalFileMatch[]> {
+	private sortResults(config: IFileQuery, results: IInternalFileMatch[], scorerCache: ScorerCache, token: CancellationToken): Promise<IInternalFileMatch[]> {
 		// we use the same compare function that is used later when showing the results using fuzzy scoring
 		// this is very important because we are also limiting the number of results by config.maxResults
 		// and as such we want the top items to be included in this result set if the number of items
@@ -530,7 +454,7 @@ export class FileIndexSearchManager {
 		const query = prepareQuery(config.filePattern);
 		const compare = (matchA: IInternalFileMatch, matchB: IInternalFileMatch) => compareItemsByScore(matchA, matchB, query, true, FileMatchItemAccessor, scorerCache);
 
-		return arrays.topAsync(results, compare, config.maxResults, 10000);
+		return arrays.topAsync(results, compare, config.maxResults, 10000, token);
 	}
 
 	private sendAsBatches(rawMatches: IInternalFileMatch[], onBatch: (batch: IFileMatch[]) => void, batchSize: number) {
@@ -544,14 +468,16 @@ export class FileIndexSearchManager {
 		}
 	}
 
-	private getResultsFromCache(cache: Cache, searchValue: string): TPromise<IInternalSearchComplete> {
+	private getResultsFromCache(cache: Cache, searchValue: string, token: CancellationToken): Promise<IInternalSearchComplete<ICachedSearchStats>> {
+		const cacheLookupSW = StopWatch.create();
+
 		if (path.isAbsolute(searchValue)) {
 			return null; // bypass cache if user looks up an absolute path where matching goes directly on disk
 		}
 
 		// Find cache entries by prefix of search value
 		const hasPathSep = searchValue.indexOf(path.sep) >= 0;
-		let cached: TPromise<IInternalSearchComplete>;
+		let cacheRow: ICacheRow;
 		for (let previousSearch in cache.resultsToSearchCache) {
 
 			// If we narrow down, we might be able to reuse the cached results
@@ -560,18 +486,30 @@ export class FileIndexSearchManager {
 					continue; // since a path character widens the search for potential more matches, require it in previous search too
 				}
 
-				const c = cache.resultsToSearchCache[previousSearch];
-				cached = this.preventCancellation(c);
+				const row = cache.resultsToSearchCache[previousSearch];
+				cacheRow = {
+					promise: this.preventCancellation(row.promise),
+					resolved: row.resolved
+				};
 				break;
 			}
 		}
 
-		if (!cached) {
+		if (!cacheRow) {
 			return null;
 		}
 
-		return new TPromise<IInternalSearchComplete>((c, e) => {
-			cached.then(complete => {
+		const cacheLookupTime = cacheLookupSW.elapsed();
+		const cacheFilterSW = StopWatch.create();
+
+		return new Promise<IInternalSearchComplete<ICachedSearchStats>>((c, e) => {
+			token.onCancellationRequested(() => e(canceled()));
+
+			cacheRow.promise.then(complete => {
+				if (token && token.isCancellationRequested) {
+					e(canceled());
+				}
+
 				// Pattern match on results
 				let results: IInternalFileMatch[] = [];
 				const normalizedSearchValueLowercase = strings.stripWildcards(searchValue).toLowerCase();
@@ -586,34 +524,37 @@ export class FileIndexSearchManager {
 					results.push(entry);
 				}
 
-				c({
+				c(<IInternalSearchComplete<ICachedSearchStats>>{
 					limitHit: complete.limitHit,
-					results
+					results,
+					stats: {
+						cacheWasResolved: cacheRow.resolved,
+						cacheLookupTime,
+						cacheFilterTime: cacheFilterSW.elapsed(),
+						cacheEntryCount: complete.results.length
+					}
 				});
 			}, e);
-		}, () => {
-			cached.cancel();
 		});
 	}
 
-	private doSearch(engine: FileIndexSearchEngine): TPromise<IInternalSearchComplete> {
+	private doSearch(engine: FileIndexSearchEngine, token: CancellationToken): Promise<IInternalSearchComplete<IFileIndexProviderStats>> {
+		token.onCancellationRequested(() => engine.cancel());
 		const results: IInternalFileMatch[] = [];
 		const onResult = match => results.push(match);
-		return new TPromise<IInternalSearchComplete>((c, e) => {
-			engine.search(onResult).then(result => {
-				c({
-					limitHit: result.isLimitHit,
-					results
-				});
-			}, e);
-		}, () => {
-			engine.cancel();
+
+		return engine.search(onResult).then(result => {
+			return <IInternalSearchComplete<IFileIndexProviderStats>>{
+				limitHit: result.isLimitHit,
+				results,
+				stats: result.stats
+			};
 		});
 	}
 
-	public clearCache(cacheKey: string): TPromise<void> {
+	public clearCache(cacheKey: string): void {
 		if (!this.folderCacheKeys.has(cacheKey)) {
-			return TPromise.wrap(undefined);
+			return undefined;
 		}
 
 		const expandedKeys = this.folderCacheKeys.get(cacheKey);
@@ -621,24 +562,32 @@ export class FileIndexSearchManager {
 
 		this.folderCacheKeys.delete(cacheKey);
 
-		return TPromise.as(undefined);
+		return undefined;
 	}
 
-	private preventCancellation<C>(promise: TPromise<C>): TPromise<C> {
-		return new TPromise<C>((c, e) => {
-			// Allow for piled up cancellations to come through first.
-			process.nextTick(() => {
-				promise.then(c, e);
-			});
-		}, () => {
-			// Do not propagate.
-		});
+	private preventCancellation<C>(promise: CancelablePromise<C>): CancelablePromise<C> {
+		return new class implements CancelablePromise<C> {
+			cancel() {
+				// Do nothing
+			}
+			then(resolve, reject) {
+				return promise.then(resolve, reject);
+			}
+			catch(reject?) {
+				return this.then(undefined, reject);
+			}
+		};
 	}
 }
 
+interface ICacheRow {
+	promise: CancelablePromise<IInternalSearchComplete<IFileIndexProviderStats>>;
+	resolved: boolean;
+}
+
 class Cache {
 
-	public resultsToSearchCache: { [searchValue: string]: TPromise<IInternalSearchComplete>; } = Object.create(null);
+	public resultsToSearchCache: { [searchValue: string]: ICacheRow; } = Object.create(null);
 
 	public scorerCache: ScorerCache = Object.create(null);
 }