Cache parsed path mapping patterns (#44078)

amcasey · web-flow · commit 3ffa245f07c4 · 2021-05-26T09:40:42.000-07:00
* Cache parsed path mapping patterns

If a project has many of them (e.g. 1800), parsing the patterns
repeatedly can take up a lot of time.

* Move cache to ConfigFileSpecs

* Inline constants

* Simplify cache access
diff --git a/src/compiler/binder.ts b/src/compiler/binder.ts
@@ -1977,19 +1977,17 @@ namespace ts {
                     declareModuleSymbol(node);
                 }
                 else {
-                    let pattern: Pattern | undefined;
+                    let pattern: string | Pattern | undefined;
                     if (node.name.kind === SyntaxKind.StringLiteral) {
                         const { text } = node.name;
-                        if (hasZeroOrOneAsteriskCharacter(text)) {
-                            pattern = tryParsePattern(text);
-                        }
-                        else {
+                        pattern = tryParsePattern(text);
+                        if (pattern === undefined) {
                             errorOnFirstToken(node.name, Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text);
                         }
                     }
 
                     const symbol = declareSymbolAndAddToSymbolTable(node, SymbolFlags.ValueModule, SymbolFlags.ValueModuleExcludes)!;
-                    file.patternAmbientModules = append<PatternAmbientModule>(file.patternAmbientModules, pattern && { pattern, symbol });
+                    file.patternAmbientModules = append<PatternAmbientModule>(file.patternAmbientModules, pattern && !isString(pattern) ? { pattern, symbol } : undefined);
                 }
             }
             else {
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
@@ -2533,6 +2533,7 @@ namespace ts {
                 validatedFilesSpec: filter(filesSpecs, isString),
                 validatedIncludeSpecs,
                 validatedExcludeSpecs,
+                pathPatterns: undefined, // Initialized on first use
             };
         }
 
diff --git a/src/compiler/moduleNameResolver.ts b/src/compiler/moduleNameResolver.ts
@@ -952,7 +952,7 @@ namespace ts {
     }
 
     function tryLoadModuleUsingPathsIfEligible(extensions: Extensions, moduleName: string, loader: ResolutionKindSpecificLoader, state: ModuleResolutionState) {
-        const { baseUrl, paths } = state.compilerOptions;
+        const { baseUrl, paths, configFile } = state.compilerOptions;
         if (paths && !pathIsRelative(moduleName)) {
             if (state.traceEnabled) {
                 if (baseUrl) {
@@ -961,7 +961,8 @@ namespace ts {
                 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
-            return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, loader, /*onlyRecordFailures*/ false, state);
+            const pathPatterns = configFile?.configFileSpecs ? configFile.configFileSpecs.pathPatterns ||= tryParsePatterns(paths) : undefined;
+            return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, /*onlyRecordFailures*/ false, state);
         }
     }
 
@@ -1400,7 +1401,7 @@ namespace ts {
             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, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
+            const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, /*pathPatterns*/ undefined, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
             if (result) {
                 return removeIgnoredPackageId(result.value);
             }
@@ -1536,7 +1537,7 @@ namespace ts {
                     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, packageInfo.versionPaths.version, version, rest);
                 }
                 const packageDirectoryExists = nodeModulesDirectoryExists && directoryProbablyExists(packageDirectory, state.host);
-                const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.versionPaths.paths, loader, !packageDirectoryExists, state);
+                const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.versionPaths.paths, /*pathPatterns*/ undefined, loader, !packageDirectoryExists, state);
                 if (fromPaths) {
                     return fromPaths.value;
                 }
@@ -1546,8 +1547,9 @@ namespace ts {
         return loader(extensions, candidate, !nodeModulesDirectoryExists, state);
     }
 
-    function tryLoadModuleUsingPaths(extensions: Extensions, moduleName: string, baseDirectory: string, paths: MapLike<string[]>, loader: ResolutionKindSpecificLoader, onlyRecordFailures: boolean, state: ModuleResolutionState): SearchResult<Resolved> {
-        const matchedPattern = matchPatternOrExact(getOwnKeys(paths), moduleName);
+    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 ||= tryParsePatterns(paths);
+        const matchedPattern = matchPatternOrExact(pathPatterns, moduleName);
         if (matchedPattern) {
             const matchedStar = isString(matchedPattern) ? undefined : matchedText(matchedPattern, moduleName);
             const matchedPatternText = isString(matchedPattern) ? matchedPattern : patternText(matchedPattern);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
@@ -6195,6 +6195,7 @@ namespace ts {
         validatedFilesSpec: readonly string[] | undefined;
         validatedIncludeSpecs: readonly string[] | undefined;
         validatedExcludeSpecs: readonly string[] | undefined;
+        pathPatterns: readonly (string | Pattern)[] | undefined;
     }
 
     /* @internal */
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
@@ -6769,14 +6769,25 @@ namespace ts {
         return changeAnyExtension(path, newExtension, extensionsToRemove, /*ignoreCase*/ false) as T;
     }
 
-    export function tryParsePattern(pattern: string): Pattern | undefined {
-        // This should be verified outside of here and a proper error thrown.
-        Debug.assert(hasZeroOrOneAsteriskCharacter(pattern));
+    /**
+     * Returns the input if there are no stars, a pattern if there is exactly one,
+     * and undefined if there are more.
+     */
+    export function tryParsePattern(pattern: string): string | Pattern | undefined {
         const indexOfStar = pattern.indexOf("*");
-        return indexOfStar === -1 ? undefined : {
-            prefix: pattern.substr(0, indexOfStar),
-            suffix: pattern.substr(indexOfStar + 1)
-        };
+        if (indexOfStar === -1) {
+            return pattern;
+        }
+        return pattern.indexOf("*", indexOfStar + 1) !== -1
+            ? undefined
+            : {
+                prefix: pattern.substr(0, indexOfStar),
+                suffix: pattern.substr(indexOfStar + 1)
+            };
+    }
+
+    export function tryParsePatterns(paths: MapLike<string[]>): (string | Pattern)[] {
+        return mapDefined(getOwnKeys(paths), path => tryParsePattern(path));
     }
 
     export function positionIsSynthesized(pos: number): boolean {
@@ -6822,21 +6833,19 @@ namespace ts {
 
 
     /**
-     * patternStrings contains both pattern strings (containing "*") and regular strings.
+     * 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.)
      */
-    export function matchPatternOrExact(patternStrings: readonly string[], candidate: string): string | Pattern | undefined {
+    export function matchPatternOrExact(patternOrStrings: readonly (string | Pattern)[], candidate: string): string | Pattern | undefined {
         const patterns: Pattern[] = [];
-        for (const patternString of patternStrings) {
-            if (!hasZeroOrOneAsteriskCharacter(patternString)) continue;
-            const pattern = tryParsePattern(patternString);
-            if (pattern) {
-                patterns.push(pattern);
-            }
-            else if (patternString === candidate) {
-                // pattern was matched as is - no need to search further
-                return patternString;
+        for (const patternOrString of patternOrStrings) {
+            if (patternOrString === candidate) {
+                return candidate;
+            }
+
+            if (!isString(patternOrString)) {
+                patterns.push(patternOrString);
             }
         }
 
diff --git a/src/services/stringCompletions.ts b/src/services/stringCompletions.ts
@@ -553,8 +553,8 @@ namespace ts.Completions.StringCompletions {
             return undefined;
         }
 
-        const parsed = hasZeroOrOneAsteriskCharacter(pattern) ? tryParsePattern(pattern) : undefined;
-        if (!parsed) {
+        const parsed = tryParsePattern(pattern);
+        if (parsed === undefined || isString(parsed)) {
             return undefined;
         }
 

Original file line number	Diff line number	Diff line change
`@@ -1977,19 +1977,17 @@ namespace ts {`
`1977`	`1977`	`declareModuleSymbol(node);`
`1978`	`1978`	`}`
`1979`	`1979`	`else {`
`1980`		`- let pattern: Pattern \| undefined;`
	`1980`	`+ let pattern: string \| Pattern \| undefined;`
`1981`	`1981`	`if (node.name.kind === SyntaxKind.StringLiteral) {`
`1982`	`1982`	`const { text } = node.name;`
`1983`		`- if (hasZeroOrOneAsteriskCharacter(text)) {`
`1984`		`- pattern = tryParsePattern(text);`
`1985`		`- }`
`1986`		`- else {`
	`1983`	`+ pattern = tryParsePattern(text);`
	`1984`	`+ if (pattern === undefined) {`
`1987`	`1985`	`errorOnFirstToken(node.name, Diagnostics.Pattern_0_can_have_at_most_one_Asterisk_character, text);`
`1988`	`1986`	`}`
`1989`	`1987`	`}`
`1990`	`1988`
`1991`	`1989`	`const symbol = declareSymbolAndAddToSymbolTable(node, SymbolFlags.ValueModule, SymbolFlags.ValueModuleExcludes)!;`
`1992`		`- file.patternAmbientModules = append<PatternAmbientModule>(file.patternAmbientModules, pattern && { pattern, symbol });`
	`1990`	`+ file.patternAmbientModules = append<PatternAmbientModule>(file.patternAmbientModules, pattern && !isString(pattern) ? { pattern, symbol } : undefined);`
`1993`	`1991`	`}`
`1994`	`1992`	`}`
`1995`	`1993`	`else {`
Original file line number	Diff line number	Diff line change
`@@ -2533,6 +2533,7 @@ namespace ts {`
`2533`	`2533`	`validatedFilesSpec: filter(filesSpecs, isString),`
`2534`	`2534`	`validatedIncludeSpecs,`
`2535`	`2535`	`validatedExcludeSpecs,`
	`2536`	`+ pathPatterns: undefined, // Initialized on first use`
`2536`	`2537`	`};`
`2537`	`2538`	`}`
`2538`	`2539`
Original file line number	Diff line number	Diff line change
`@@ -952,7 +952,7 @@ namespace ts {`
`952`	`952`	`}`
`953`	`953`
`954`	`954`	`function tryLoadModuleUsingPathsIfEligible(extensions: Extensions, moduleName: string, loader: ResolutionKindSpecificLoader, state: ModuleResolutionState) {`
`955`		`- const { baseUrl, paths } = state.compilerOptions;`
	`955`	`+ const { baseUrl, paths, configFile } = state.compilerOptions;`
`956`	`956`	`if (paths && !pathIsRelative(moduleName)) {`
`957`	`957`	`if (state.traceEnabled) {`
`958`	`958`	`if (baseUrl) {`
`@@ -961,7 +961,8 @@ namespace ts {`
`961`	`961`	`trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);`
`962`	`962`	`}`
`963`	`963`	`const baseDirectory = getPathsBasePath(state.compilerOptions, state.host)!; // Always defined when 'paths' is defined`
`964`		`- return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, loader, /onlyRecordFailures/ false, state);`
	`964`	`+ const pathPatterns = configFile?.configFileSpecs ? configFile.configFileSpecs.pathPatterns \|\|= tryParsePatterns(paths) : undefined;`
	`965`	`+ return tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, /onlyRecordFailures/ false, state);`
`965`	`966`	`}`
`966`	`967`	`}`
`967`	`968`
`@@ -1400,7 +1401,7 @@ namespace ts {`
`1400`	`1401`	`if (state.traceEnabled) {`
`1401`	`1402`	`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);`
`1402`	`1403`	`}`
`1403`		`- const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, loader, onlyRecordFailuresForPackageFile \|\| onlyRecordFailuresForIndex, state);`
	`1404`	`+ const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, /pathPatterns/ undefined, loader, onlyRecordFailuresForPackageFile \|\| onlyRecordFailuresForIndex, state);`
`1404`	`1405`	`if (result) {`
`1405`	`1406`	`return removeIgnoredPackageId(result.value);`
`1406`	`1407`	`}`
`@@ -1536,7 +1537,7 @@ namespace ts {`
`1536`	`1537`	`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, packageInfo.versionPaths.version, version, rest);`
`1537`	`1538`	`}`
`1538`	`1539`	`const packageDirectoryExists = nodeModulesDirectoryExists && directoryProbablyExists(packageDirectory, state.host);`
`1539`		`- const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.versionPaths.paths, loader, !packageDirectoryExists, state);`
	`1540`	`+ const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, packageInfo.versionPaths.paths, /pathPatterns/ undefined, loader, !packageDirectoryExists, state);`
`1540`	`1541`	`if (fromPaths) {`
`1541`	`1542`	`return fromPaths.value;`
`1542`	`1543`	`}`
`@@ -1546,8 +1547,9 @@ namespace ts {`
`1546`	`1547`	`return loader(extensions, candidate, !nodeModulesDirectoryExists, state);`
`1547`	`1548`	`}`
`1548`	`1549`
`1549`		`- function tryLoadModuleUsingPaths(extensions: Extensions, moduleName: string, baseDirectory: string, paths: MapLike<string[]>, loader: ResolutionKindSpecificLoader, onlyRecordFailures: boolean, state: ModuleResolutionState): SearchResult<Resolved> {`
`1550`		`- const matchedPattern = matchPatternOrExact(getOwnKeys(paths), moduleName);`
	`1550`	`+ function tryLoadModuleUsingPaths(extensions: Extensions, moduleName: string, baseDirectory: string, paths: MapLike<string[]>, pathPatterns: readonly (string \| Pattern)[] \| undefined, loader: ResolutionKindSpecificLoader, onlyRecordFailures: boolean, state: ModuleResolutionState): SearchResult<Resolved> {`
	`1551`	`+ pathPatterns \|\|= tryParsePatterns(paths);`
	`1552`	`+ const matchedPattern = matchPatternOrExact(pathPatterns, moduleName);`
`1551`	`1553`	`if (matchedPattern) {`
`1552`	`1554`	`const matchedStar = isString(matchedPattern) ? undefined : matchedText(matchedPattern, moduleName);`
`1553`	`1555`	`const matchedPatternText = isString(matchedPattern) ? matchedPattern : patternText(matchedPattern);`
Original file line number	Diff line number	Diff line change
`@@ -6195,6 +6195,7 @@ namespace ts {`
`6195`	`6195`	`validatedFilesSpec: readonly string[] \| undefined;`
`6196`	`6196`	`validatedIncludeSpecs: readonly string[] \| undefined;`
`6197`	`6197`	`validatedExcludeSpecs: readonly string[] \| undefined;`
	`6198`	`+ pathPatterns: readonly (string \| Pattern)[] \| undefined;`
`6198`	`6199`	`}`
`6199`	`6200`
`6200`	`6201`	`/* @internal */`
Original file line number	Diff line number	Diff line change
`@@ -553,8 +553,8 @@ namespace ts.Completions.StringCompletions {`
`553`	`553`	`return undefined;`
`554`	`554`	`}`
`555`	`555`
`556`		`- const parsed = hasZeroOrOneAsteriskCharacter(pattern) ? tryParsePattern(pattern) : undefined;`
`557`		`- if (!parsed) {`
	`556`	`+ const parsed = tryParsePattern(pattern);`
	`557`	`+ if (parsed === undefined \|\| isString(parsed)) {`
`558`	`558`	`return undefined;`
`559`	`559`	`}`
`560`	`560`