avoid slice-calls, avoid searching for best result when you know it, microsoft#18682

jrieken · jrieken · commit 528682cd60d4 · 2017-06-15T18:46:29.000+02:00
diff --git a/src/vs/base/common/filters.ts b/src/vs/base/common/filters.ts
@@ -551,31 +551,26 @@ export function fuzzyScore(pattern: string, word: string): [number, number[]] {
 		console.log(printTable(_scores, pattern, patternLen, word, wordLen));
 	}
 
+	// _bucket is an array of [PrefixArray] we use to keep
+	// track of scores and matches. After calling `_findAllMatches`
+	// the best match (if available) is the first item in the array
 	_bucket.length = 0;
+	_topScore = -100;
 	_patternStartPos = patternStartPos;
-	_findAllMatches(patternLen, wordLen, 0, [], false);
+	_findAllMatches(patternLen, wordLen, 0, new LazyArray(), false);
 
 	if (_bucket.length === 0) {
 		return undefined;
 	}
 
-	let topMatch = _bucket[0];
-	for (let i = 1; i < _bucket.length; i++) {
-		let match = _bucket[i];
-		if (topMatch[0] < match[0]) {
-			topMatch = match;
-		}
-	}
-	if (_debug) {
-		console.log(`${pattern} & ${word} => ${topMatch[0]} points for ${topMatch[1]}`);
-	}
-	return topMatch;
+	return [_topScore, _bucket[0].toArray()];
 }
 
-let _bucket: [number, number[]][] = [];
+let _bucket: LazyArray[] = [];
+let _topScore: number = 0;
 let _patternStartPos: number = 0;
 
-function _findAllMatches(patternPos: number, wordPos: number, total: number, matches: number[], lastMatched: boolean): void {
+function _findAllMatches(patternPos: number, wordPos: number, total: number, matches: LazyArray, lastMatched: boolean): void {
 
 	if (_bucket.length >= 10 || total < -25) {
 		// stop when having already 10 results, or
@@ -595,7 +590,7 @@ function _findAllMatches(patternPos: number, wordPos: number, total: number, mat
 			wordPos -= 1;
 			if (lastMatched) {
 				total -= 5; // new gap penalty
-			} else if (matches.length !== 0) {
+			} else if (!matches.isEmpty()) {
 				total -= 1; // gap penalty after first match
 			}
 			lastMatched = false;
@@ -608,8 +603,8 @@ function _findAllMatches(patternPos: number, wordPos: number, total: number, mat
 				_findAllMatches(
 					patternPos,
 					wordPos - 1,
-					matches.length !== 0 ? total - 1 : total,
-					matches.slice(0),
+					!matches.isEmpty() ? total - 1 : total, // gap penalty after first match
+					matches.slice(),
 					lastMatched
 				);
 			}
@@ -646,9 +641,56 @@ function _findAllMatches(patternPos: number, wordPos: number, total: number, mat
 
 	total -= wordPos >= 3 ? 9 : wordPos * 3; // late start penalty
 
-	_bucket.push([total, matches]);
+	// dynamically keep track of the current top score
+	// and insert the current best score at head, the rest at tail
+	if (total > _topScore) {
+		_topScore = total;
+		_bucket.unshift(matches);
+	} else {
+		_bucket.push(matches);
+	}
 }
 
+class LazyArray {
+
+	private _parent: LazyArray;
+	private _parentLen: number;
+	private _data: number[];
+
+	isEmpty(): boolean {
+		return !this._data && (!this._parent || this._parent.isEmpty());
+	}
+
+	unshift(n: number) {
+		if (!this._data) {
+			this._data = [n];
+		} else {
+			this._data.unshift(n);
+		}
+	}
+
+	slice(): LazyArray {
+		const ret = new LazyArray();
+		ret._parent = this;
+		ret._parentLen = this._data ? this._data.length : 0;
+		return ret;
+	}
+
+	toArray(): number[] {
+		if (!this._data) {
+			return this._parent.toArray();
+		}
+		const bucket: number[][] = [];
+		let element = <LazyArray>this;
+		while (element) {
+			if (element._parent && element._parent._data) {
+				bucket.push(element._parent._data.slice(element._parent._data.length - element._parentLen));
+			}
+			element = element._parent;
+		}
+		return Array.prototype.concat.apply(this._data, bucket);
+	}
+}
 
 export function nextTypoPermutation(pattern: string, patternPos: number) {
 
