public walk(folderQueries: IFolderQuery[], extraFiles: URI[], onResult: (result: IRawFileMatch) => void, onMessage: (message: IProgress) => void, done: (error: Error, isLimitHit: boolean) => void): void {
		this.fileWalkSW = StopWatch.create(false);

		// Support that the file pattern is a full path to a file that exists
		if (this.isCanceled) {
			return done(null, this.isLimitHit);
		}

		// For each extra file
		if (extraFiles) {
			extraFiles.forEach(extraFilePath => {
				const basename = path.basename(extraFilePath.fsPath);
				if (this.globalExcludePattern && this.globalExcludePattern(extraFilePath.fsPath, basename)) {
					return; // excluded
				}

				// File: Check for match on file pattern and include pattern
				this.matchFile(onResult, { relativePath: extraFilePath.fsPath /* no workspace relative path */, basename });
			});
		}

		let traverse = this.nodeJSTraversal;
		if (!this.maxFilesize) {
			if (this.useRipgrep) {
				this.traversal = Traversal.Ripgrep;
				traverse = this.cmdTraversal;
			} else if (platform.isMacintosh) {
				this.traversal = Traversal.MacFind;
				traverse = this.cmdTraversal;
			} else if (platform.isLinux) {
				this.traversal = Traversal.LinuxFind;
				traverse = this.cmdTraversal;
			}
		}

		const isNodeTraversal = traverse === this.nodeJSTraversal;
		if (!isNodeTraversal) {
			this.cmdSW = StopWatch.create(false);
		}

		// For each root folder
		flow.parallel<IFolderQuery, void>(folderQueries, (folderQuery: IFolderQuery, rootFolderDone: (err: Error, result: void) => void) => {
			this.call(traverse, this, folderQuery, onResult, onMessage, (err?: Error) => {
				if (err) {
					const errorMessage = toErrorMessage(err);
					console.error(errorMessage);
					this.errors.push(errorMessage);
					rootFolderDone(err, undefined);
				} else {
					rootFolderDone(undefined, undefined);
				}
			});
		}, (errors, result) => {
			this.fileWalkSW.stop();
			const err = errors ? errors.filter(e => !!e)[0] : null;
			done(err, this.isLimitHit);
		});
	}

	public run(accessor: ServicesAccessor, editor: ICodeEditor): void {
		if (!editor.hasModel()) {
			return;
		}
		const model = editor.getModel();
		model.flushTokens();
		const sw = new StopWatch(true);
		model.forceTokenization(model.getLineCount());
		sw.stop();
		console.log(`tokenization took ${sw.elapsed()}`);
	}

	walk(folderQueries: IFolderQuery[], extraFiles: URI[], onResult: (result: IRawFileMatch) => void, onMessage: (message: IProgressMessage) => void, done: (error: Error | null, isLimitHit: boolean) => void): void {
		this.fileWalkSW = StopWatch.create(false);

		// Support that the file pattern is a full path to a file that exists
		if (this.isCanceled) {
			return done(null, this.isLimitHit);
		}

		// For each extra file
		extraFiles.forEach(extraFilePath => {
			const basename = path.basename(extraFilePath.fsPath);
			if (this.globalExcludePattern && this.globalExcludePattern(extraFilePath.fsPath, basename)) {
				return; // excluded
			}

			// File: Check for match on file pattern and include pattern
			this.matchFile(onResult, { relativePath: extraFilePath.fsPath /* no workspace relative path */, basename });
		});

		this.cmdSW = StopWatch.create(false);

		// For each root folder
		this.parallel<IFolderQuery, void>(folderQueries, (folderQuery: IFolderQuery, rootFolderDone: (err: Error | null, result: void) => void) => {
			this.call(this.cmdTraversal, this, folderQuery, onResult, onMessage, (err?: Error) => {
				if (err) {
					const errorMessage = toErrorMessage(err);
					console.error(errorMessage);
					this.errors.push(errorMessage);
					rootFolderDone(err, undefined);
				} else {
					rootFolderDone(null, undefined);
				}
			});
		}, (errors, result) => {
			this.fileWalkSW.stop();
			const err = errors ? arrays.coalesce(errors)[0] : null;
			done(err, this.isLimitHit);
		});
	}

	constructor(taskName: string, serverName: string, databaseName: string, taskId: string = undefined, taskExecutionMode: TaskExecutionMode = TaskExecutionMode.execute, isCancelable: boolean = true) {
		this.id = taskId || generateUuid();

		this.taskName = taskName;
		this.serverName = serverName;
		this.databaseName = databaseName;
		this.timer = StopWatch.create();
		this.startTime = new Date().toLocaleTimeString();
		this.status = TaskStatus.inProgress;
		this.hasChildren = false;
		this.taskExecutionMode = taskExecutionMode;
		this.isCancelable = isCancelable;
	}

	getStats(): ISearchEngineStats {
		return {
			cmdTime: this.cmdSW && this.cmdSW.elapsed(),
			fileWalkTime: this.fileWalkSW.elapsed(),
			directoriesWalked: this.directoriesWalked,
			filesWalked: this.filesWalked,
			cmdResultCount: this.cmdResultCount
		};
	}

		let onData = (err: Error, stdout?: string, last?: boolean) => {
			if (err || last) {
				onData = () => { };

				if (this.cmdSW) {
					this.cmdSW.stop();
				}
			}
			cb(err, stdout, last);
		};