Move fuzzy/contiguous filtering into quick pick

Author: Tyriar

src/vs/base/parts/quickinput/browser/quickInput.ts

@@ -450,6 +450,7 @@ class QuickPick<T extends IQuickPickItem> extends QuickInput implements IQuickPi
 	private _matchOnDescription = false;
 	private _matchOnDetail = false;
 	private _matchOnLabel = true;
+	private _matchOnLabelMode: 'fuzzy' | 'contiguous' = 'fuzzy';
 	private _sortByLabel = true;
 	private _autoFocusOnList = true;
 	private _keepScrollPosition = false;
@@ -595,6 +596,15 @@ class QuickPick<T extends IQuickPickItem> extends QuickInput implements IQuickPi
 		this.update();
 	}
 
+	get matchOnLabelMode() {
+		return this._matchOnLabelMode;
+	}
+
+	set matchOnLabelMode(matchOnLabelMode: 'fuzzy' | 'contiguous') {
+		this._matchOnLabelMode = matchOnLabelMode;
+		this.update();
+	}
+
 	get sortByLabel() {
 		return this._sortByLabel;
 	}
@@ -994,6 +1004,7 @@ class QuickPick<T extends IQuickPickItem> extends QuickInput implements IQuickPi
 		this.ui.list.matchOnDescription = this.matchOnDescription;
 		this.ui.list.matchOnDetail = this.matchOnDetail;
 		this.ui.list.matchOnLabel = this.matchOnLabel;
+		this.ui.list.matchOnLabelMode = this.matchOnLabelMode;
 		this.ui.list.sortByLabel = this.sortByLabel;
 		if (this.itemsUpdated) {
 			this.itemsUpdated = false;

src/vs/base/parts/quickinput/browser/quickInputList.ts

@@ -17,10 +17,11 @@ import { compareAnything } from 'vs/base/common/comparers';
 import { memoize } from 'vs/base/common/decorators';
 import { Emitter, Event } from 'vs/base/common/event';
 import { IMatch } from 'vs/base/common/filters';
-import { matchesFuzzyIconAware, parseLabelWithIcons } from 'vs/base/common/iconLabels';
+import { IParsedLabelWithIcons, matchesFuzzyIconAware, parseLabelWithIcons } from 'vs/base/common/iconLabels';
 import { KeyCode } from 'vs/base/common/keyCodes';
 import { dispose, IDisposable } from 'vs/base/common/lifecycle';
 import * as platform from 'vs/base/common/platform';
+import { ltrim } from 'vs/base/common/strings';
 import { withNullAsUndefined } from 'vs/base/common/types';
 import { IQuickInputOptions } from 'vs/base/parts/quickinput/browser/quickInput';
 import { getIconClass } from 'vs/base/parts/quickinput/browser/quickInputUtils';
@@ -258,6 +259,7 @@ export class QuickInputList {
 	matchOnDescription = false;
 	matchOnDetail = false;
 	matchOnLabel = true;
+	matchOnLabelMode: 'fuzzy' | 'contiguous' = 'fuzzy';
 	matchOnMeta = true;
 	sortByLabel = true;
 	private readonly _onChangedAllVisibleChecked = new Emitter<boolean>();
@@ -628,7 +630,12 @@ export class QuickInputList {
 		else {
 			let currentSeparator: IQuickPickSeparator | undefined;
 			this.elements.forEach(element => {
-				const labelHighlights = this.matchOnLabel ? withNullAsUndefined(matchesFuzzyIconAware(query, parseLabelWithIcons(element.saneLabel))) : undefined;
+				let labelHighlights: IMatch[] | undefined;
+				if (this.matchOnLabelMode === 'fuzzy') {
+					labelHighlights = this.matchOnLabel ? withNullAsUndefined(matchesFuzzyIconAware(query, parseLabelWithIcons(element.saneLabel))) : undefined;
+				} else {
+					labelHighlights = this.matchOnLabel ? withNullAsUndefined(matchesContiguousIconAware(query, parseLabelWithIcons(element.saneLabel))) : undefined;
+				}
 				const descriptionHighlights = this.matchOnDescription ? withNullAsUndefined(matchesFuzzyIconAware(query, parseLabelWithIcons(element.saneDescription || ''))) : undefined;
 				const detailHighlights = this.matchOnDetail ? withNullAsUndefined(matchesFuzzyIconAware(query, parseLabelWithIcons(element.saneDetail || ''))) : undefined;
 				const metaHighlights = this.matchOnMeta ? withNullAsUndefined(matchesFuzzyIconAware(query, parseLabelWithIcons(element.saneMeta || ''))) : undefined;
@@ -726,6 +733,43 @@ export class QuickInputList {
 	}
 }
 
+export function matchesContiguousIconAware(query: string, target: IParsedLabelWithIcons, enableSeparateSubstringMatching = false): IMatch[] | null {
+
+	const { text, iconOffsets } = target;
+
+	// Return early if there are no icon markers in the word to match against
+	if (!iconOffsets || iconOffsets.length === 0) {
+		return matchesContiguous(query, text, enableSeparateSubstringMatching);
+	}
+
+	// Trim the word to match against because it could have leading
+	// whitespace now if the word started with an icon
+	const wordToMatchAgainstWithoutIconsTrimmed = ltrim(text, ' ');
+	const leadingWhitespaceOffset = text.length - wordToMatchAgainstWithoutIconsTrimmed.length;
+
+	// match on value without icon
+	const matches = matchesContiguous(query, wordToMatchAgainstWithoutIconsTrimmed, enableSeparateSubstringMatching);
+
+	// Map matches back to offsets with icon and trimming
+	if (matches) {
+		for (const match of matches) {
+			const iconOffset = iconOffsets[match.start + leadingWhitespaceOffset] /* icon offsets at index */ + leadingWhitespaceOffset /* overall leading whitespace offset */;
+			match.start += iconOffset;
+			match.end += iconOffset;
+		}
+	}
+
+	return matches;
+}
+
+function matchesContiguous(word: string, wordToMatchAgainst: string, enableSeparateSubstringMatching = false): IMatch[] | null {
+	const matchIndex = wordToMatchAgainst.indexOf(word);
+	if (matchIndex !== -1) {
+		return [{ start: matchIndex, end: matchIndex + word.length }];
+	}
+	return null;
+}
+
 function compareEntries(elementA: ListElement, elementB: ListElement, lookFor: string): number {
 
 	const labelHighlightsA = elementA.labelHighlights || [];

src/vs/base/parts/quickinput/common/quickInput.ts

@@ -292,6 +292,13 @@ export interface IQuickPick<T extends IQuickPickItem> extends IQuickInput {
 
 	matchOnLabel: boolean;
 
+	/**
+	 * The mode to filter label with. Fuzzy will use fuzzy searching and
+	 * contiguous will make filter entries that do not contain the exact string
+	 * (including whitespace). This defaults to `'fuzzy'`.
+	 */
+	matchOnLabelMode: 'fuzzy' | 'contiguous';
+
 	sortByLabel: boolean;
 
 	autoFocusOnList: boolean;

src/vs/workbench/contrib/terminal/browser/terminalInstance.ts

@@ -970,31 +970,14 @@ export class TerminalInstance extends Disposable implements ITerminalInstance {
 		quickPick.sortByLabel = false;
 		quickPick.placeholder = placeholder;
 		quickPick.customButton = true;
-		quickPick.matchOnLabel = filterMode === 'fuzzy';
+		quickPick.matchOnLabelMode = filterMode || 'contiguous';
 		if (filterMode === 'fuzzy') {
 			quickPick.customLabel = nls.localize('terminal.contiguousSearch', 'Use Contiguous Search');
 			quickPick.onDidCustom(() => {
 				quickPick.hide();
 				this.runRecent(type, 'contiguous', quickPick.value);
 			});
 		} else {
-			// contiguous is the default for command
-			quickPick.onDidChangeValue(value => {
-				quickPick.items = originalItems.filter(item => {
-					if (item.type === 'separator') {
-						return true;
-					}
-					item.highlights = undefined;
-					const matchIndex = item.label.indexOf(value);
-					if (matchIndex !== -1) {
-						item.highlights = {
-							label: [{ start: matchIndex, end: matchIndex + value.length }]
-						};
-						return true;
-					}
-					return false;
-				});
-			});
 			quickPick.customLabel = nls.localize('terminal.fuzzySearch', 'Use Fuzzy Search');
 			quickPick.onDidCustom(() => {
 				quickPick.hide();