Optimize path mapping lookups

src/compiler/core.ts

@@ -2532,12 +2532,12 @@ export function matchedText(pattern: Pattern, candidate: string): string {
  *
  * @internal
  */
-export function findBestPatternMatch<T>(values: readonly T[], getPattern: (value: T) => Pattern, candidate: string): T | undefined {
+export function findBestPatternMatch<T>(values: readonly T[], getPattern: (value: T) => Pattern, candidate: string, endIndex: number = values.length): T | undefined {
     let matchedValue: T | undefined;
     // use length of prefix as betterness criteria
     let longestMatchPrefixLength = -1;
 
-    for (let i = 0; i < values.length; i++) {
+    for (let i = 0; i < endIndex; i++) {
         const v = values[i];
         const pattern = getPattern(v);
         if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {

src/compiler/utilities.ts

@@ -28,6 +28,7 @@ import {
     BarBarEqualsToken,
     BinaryExpression,
     binarySearch,
+    binarySearchKey,
     BindableObjectDefinePropertyCall,
     BindableStaticAccessExpression,
     BindableStaticElementAccessExpression,
@@ -339,6 +340,7 @@ import {
     isParameterPropertyDeclaration,
     isParenthesizedExpression,
     isParenthesizedTypeNode,
+    isPatternMatch,
     isPrefixUnaryExpression,
     isPrivateIdentifier,
     isPropertyAccessExpression,
@@ -10061,6 +10063,13 @@ export const emptyFileSystemEntries: FileSystemEntries = {
     directories: emptyArray,
 };
 
+interface MatchPatternOrExactCacheEntry {
+    matchableStringSet: Set<string>;
+    sortedPatterns: Pattern[];
+}
+
+const patternOrStringsCache = new WeakMap<readonly (string | Pattern)[], MatchPatternOrExactCacheEntry>();
+
 /**
  * patternOrStrings contains both patterns (containing "*") and regular strings.
  * Return an exact match if possible, or a pattern match, or undefined.
@@ -10069,18 +10078,95 @@ export const emptyFileSystemEntries: FileSystemEntries = {
  * @internal
  */
 export function matchPatternOrExact(patternOrStrings: readonly (string | Pattern)[], candidate: string): string | Pattern | undefined {
-    const patterns: Pattern[] = [];
-    for (const patternOrString of patternOrStrings) {
-        if (patternOrString === candidate) {
-            return candidate;
+    let matchableStringSet: Set<string>;
+    let sortedPatterns: Pattern[];
+
+    const cacheEntry = patternOrStringsCache.get(patternOrStrings);
+    if (cacheEntry !== undefined) {
+        ({ matchableStringSet, sortedPatterns } = cacheEntry);
+    }
+    else {
+        matchableStringSet = new Set();
+        sortedPatterns = [];
+
+        for (const patternOrString of patternOrStrings) {
+            if (typeof patternOrString === "string") {
+                matchableStringSet.add(patternOrString);
+            }
+            else {
+                sortedPatterns.push(patternOrString);
+            }
+        }
+
+        sortedPatterns.sort((a, b) => compareStringsCaseSensitive(a.prefix, b.prefix));
+
+        patternOrStringsCache.set(patternOrStrings, {
+            matchableStringSet,
+            sortedPatterns,
+        });
+    }
+
+    if (matchableStringSet.has(candidate)) {
+        return candidate;
+    }
+    if (sortedPatterns.length === 0) {
+        return undefined;
+    }
+
+    let index = binarySearchKey(sortedPatterns, candidate, getPatternPrefix, compareStringsCaseSensitive);
+    if (index < 0) {
+        index = ~index;
+    }
+
+    if (index >= sortedPatterns.length) {
+        // If we are past the end of the array, then the candidate length just exceeds the last prefix.
+        // Bump us back into a reasonable range.
+        index--;
+    }
+
+    // `sortedPatterns` is sorted by prefixes, where longer prefixes should occur later;
+    // however, the sort is stable, so the original input order of patterns is preserved within each group.
+    // So for something like
+    //
+    //  { prefix: "foo/", suffix: "bar"}, { "prefix: "", suffix: "" }, { prefix: "foo/", suffix: "" }, { "prefix: "", suffix: "bar" },
+    //
+    // we will end up with
+    //
+    //  { "prefix: "", suffix: "" }, { "prefix: "", suffix: "bar" }, { prefix: "foo/", suffix: "bar"}, { prefix: "foo/", suffix: "" }
+    //
+    // guaranteeing that within a group, the first match is ideal.
+    //
+    // Now the binary search may have landed us in the very middle of a group. If we are searching for "foo/" in
+    //
+    //  ..., { prefix: "foo/", suffix: "" }, { prefix: "foo/", suffix: "my-suffix" }, ...
+    //
+    // then we could have ended up on an exact match. Keep walking backwards on exact matches until we find the first.
+    // This will allow us to try out all patterns with an identical prefix, while maintaining the relative original order of the
+    // patterns as specified.
+    const groupPrefix = sortedPatterns[index].prefix;
+    while (index > 0 && groupPrefix === sortedPatterns[index - 1].prefix) {
+        index--;
+    }
+
+    for (let i = index; i < sortedPatterns.length; i++) {
+        const currentPattern = sortedPatterns[i];
+        if (currentPattern.prefix !== groupPrefix) {
+            break;
         }
 
-        if (!isString(patternOrString)) {
-            patterns.push(patternOrString);
+        if (isPatternMatch(currentPattern, candidate)) {
+            return currentPattern;
         }
     }
 
-    return findBestPatternMatch(patterns, _ => _, candidate);
+    // We could not find a pattern within the group that matched.
+    // Technically we could walk backwards from here and find likely matches.
+    // For now, we'll just do a simple linear search up to the current group index.
+    return findBestPatternMatch(sortedPatterns, _ => _, candidate, /*endIndex*/ index);
+}
+
+function getPatternPrefix(pattern: Pattern) {
+    return pattern.prefix;
 }
 
 /** @internal */