Move caching to tryParsePatterns, avoid creating an intermediate array entirely.

Author: DanielRosenwasser

src/compiler/commandLineParser.ts

@@ -3042,7 +3042,6 @@ function parseJsonConfigFileContentWorker(
             validatedFilesSpecBeforeSubstitution,
             validatedIncludeSpecsBeforeSubstitution,
             validatedExcludeSpecsBeforeSubstitution,
-            pathPatterns: undefined, // Initialized on first use
             isDefaultIncludeSpec,
         };
     }

src/compiler/moduleNameResolver.ts

@@ -79,9 +79,9 @@ import {
     normalizeSlashes,
     PackageId,
     packageIdToString,
+    ParsedPatterns,
     Path,
     pathIsRelative,
-    Pattern,
     patternText,
     readJson,
     removeExtension,
@@ -1559,7 +1559,7 @@ function tryLoadModuleUsingOptionalResolutionSettings(extensions: Extensions, mo
 }
 
 function tryLoadModuleUsingPathsIfEligible(extensions: Extensions, moduleName: string, loader: ResolutionKindSpecificLoader, state: ModuleResolutionState) {
-    const { baseUrl, paths, configFile } = state.compilerOptions;
+    const { baseUrl, paths } = state.compilerOptions;
     if (paths && !pathIsRelative(moduleName)) {
         if (state.traceEnabled) {
             if (baseUrl) {
@@ -1568,7 +1568,8 @@ function tryLoadModuleUsingPathsIfEligible(extensions: Extensions, moduleName: s
             trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
         }
         const baseDirectory = getPathsBasePath(state.compilerOptions, state.host)!; // Always defined when 'paths' is defined
-        const pathPatterns = configFile?.configFileSpecs ? configFile.configFileSpecs.pathPatterns ??= tryParsePatterns(paths) : undefined;
+        // TODO: do we need to sort by aggregate length?
+        const pathPatterns = tryParsePatterns(paths);
         return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, /*onlyRecordFailures*/ false, state);
     }
 }
@@ -2524,7 +2525,9 @@ function loadNodeModuleFromDirectoryWorker(extensions: Extensions, candidate: st
         if (state.traceEnabled) {
             trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, moduleName);
         }
-        const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, /*pathPatterns*/ undefined, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
+        // TODO: do we need to sort by aggregate length?
+        const pathPatterns = tryParsePatterns(versionPaths.paths);
+        const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, pathPatterns, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
         if (result) {
             return removeIgnoredPackageId(result.value);
         }
@@ -3118,22 +3121,17 @@ function loadModuleFromSpecificNodeModulesDirectory(extensions: Extensions, modu
             trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, rest);
         }
         const packageDirectoryExists = nodeModulesDirectoryExists && directoryProbablyExists(packageDirectory, state.host);
-        const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, versionPaths.paths, /*pathPatterns*/ undefined, loader, !packageDirectoryExists, state);
+        // TODO: do we need to sort by aggregate length?
+        const pathPatterns = tryParsePatterns(versionPaths.paths);
+        const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, versionPaths.paths, pathPatterns, loader, !packageDirectoryExists, state);
         if (fromPaths) {
             return fromPaths.value;
         }
     }
     return loader(extensions, candidate, !nodeModulesDirectoryExists, state);
 }
 
-const pathsToPatternsCache = new WeakMap<MapLike<string[]>, readonly (string | Pattern)[]>();
-
-function tryLoadModuleUsingPaths(extensions: Extensions, moduleName: string, baseDirectory: string, paths: MapLike<string[]>, pathPatterns: readonly (string | Pattern)[] | undefined, loader: ResolutionKindSpecificLoader, onlyRecordFailures: boolean, state: ModuleResolutionState): SearchResult<Resolved> {
-    pathPatterns ??= pathsToPatternsCache.get(paths);
-    if (pathPatterns === undefined) {
-        pathsToPatternsCache.set(paths, pathPatterns = tryParsePatterns(paths));
-    }
-
+function tryLoadModuleUsingPaths(extensions: Extensions, moduleName: string, baseDirectory: string, paths: MapLike<string[]>, pathPatterns: ParsedPatterns, loader: ResolutionKindSpecificLoader, onlyRecordFailures: boolean, state: ModuleResolutionState): SearchResult<Resolved> {
     const matchedPattern = matchPatternOrExact(pathPatterns, moduleName);
     if (matchedPattern) {
         const matchedStar = isString(matchedPattern) ? undefined : matchedText(matchedPattern, moduleName);

src/compiler/types.ts

@@ -7512,7 +7512,6 @@ export interface ConfigFileSpecs {
     validatedFilesSpecBeforeSubstitution: readonly string[] | undefined;
     validatedIncludeSpecsBeforeSubstitution: readonly string[] | undefined;
     validatedExcludeSpecsBeforeSubstitution: readonly string[] | undefined;
-    pathPatterns: readonly (string | Pattern)[] | undefined;
     isDefaultIncludeSpec: boolean;
 }
 

src/compiler/utilities.ts

@@ -10006,8 +10006,57 @@ export function tryParsePattern(pattern: string): string | Pattern | undefined {
 }
 
 /** @internal */
-export function tryParsePatterns(paths: MapLike<string[]>): (string | Pattern)[] {
-    return mapDefined(getOwnKeys(paths), path => tryParsePattern(path));
+export interface ParsedPatterns {
+    matchableStringSet: ReadonlySet<string> | undefined;
+    sortedPatterns: (readonly Pattern[]) | undefined;
+}
+
+const parsedPatternsCache = new WeakMap<MapLike<string[]>, ParsedPatterns>();
+
+/**
+ * Divides patterns into a set of exact specifiers and sorted patterns.
+ * NOTE that this function caches, and assumes the same `paths` argument will
+ * never be provided with a different value for `sortByAggregateLength`.
+ * 
+ * @internal
+ **/
+export function tryParsePatterns(paths: MapLike<string[]>, sortByAggregateLength: boolean = false): ParsedPatterns {
+    let result = parsedPatternsCache.get(paths)
+    if (result !== undefined) {
+        return result;
+    }
+
+    let matchableStringSet: Set<string> | undefined;
+    let sortedPatterns: Pattern[] | undefined;
+    
+    const pathList = getOwnKeys(paths);
+    for (const path of pathList) {
+        const patternOrStr = tryParsePattern(path)
+        if (patternOrStr === undefined) {
+            continue;
+        }
+        else if (typeof patternOrStr === "string") {
+            (matchableStringSet ??= new Set()).add(patternOrStr);
+        }
+        else {
+            (sortedPatterns ??= []).push(patternOrStr);
+        }
+    }
+
+    sortedPatterns?.sort((a, b) => {
+        const prefixComparison = compareStringsCaseSensitive(a.prefix, b.prefix)
+        if (prefixComparison === 0 && sortByAggregateLength) {
+            return a.suffix.length - b.suffix.length;
+        }
+        return prefixComparison;
+    });
+
+    parsedPatternsCache.set(paths, result = {
+        matchableStringSet,
+        sortedPatterns,
+    });
+
+    return result;
 }
 
 /** @internal */
@@ -10063,53 +10112,21 @@ 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.
  * (These are verified by verifyCompilerOptions to have 0 or 1 "*" characters.)
  *
  * @internal
  */
-export function matchPatternOrExact(patternOrStrings: readonly (string | Pattern)[], candidate: string): string | Pattern | undefined {
-    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));
+export function matchPatternOrExact(patternOrStrings: ParsedPatterns, candidate: string): string | Pattern | undefined {
+    const { matchableStringSet, sortedPatterns } = patternOrStrings;
 
-        patternOrStringsCache.set(patternOrStrings, {
-            matchableStringSet,
-            sortedPatterns,
-        });
-    }
-
-    if (matchableStringSet.has(candidate)) {
+    if (matchableStringSet?.has(candidate)) {
         return candidate;
     }
-    if (sortedPatterns.length === 0) {
+
+    if (sortedPatterns === undefined || sortedPatterns.length === 0) {
         return undefined;
     }