Rewrite matchFiles without regexp

internal/project/discovertypings.go

@@ -13,6 +13,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/semver"
 	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
+	"github.com/microsoft/typescript-go/internal/vfs/vfsmatch"
 )
 
 type CachedTyping struct {
@@ -220,7 +221,7 @@ func addTypingNamesAndGetFilesToWatch(
 	} else {
 		// And #2. Depth = 3 because scoped packages look like `node_modules/@foo/bar/package.json`
 		depth := 3
-		for _, manifestPath := range vfs.ReadDirectory(fs, projectRootPath, packagesFolderPath, []string{tspath.ExtensionJson}, nil, nil, &depth) {
+		for _, manifestPath := range vfsmatch.ReadDirectory(fs, projectRootPath, packagesFolderPath, []string{tspath.ExtensionJson}, nil, nil, &depth) {
 			if tspath.GetBaseFileName(manifestPath) != manifestName {
 				continue
 			}

internal/tsoptions/tsconfigparsing.go

@@ -1,13 +1,11 @@
 package tsoptions
 
 import (
-	"fmt"
 	"reflect"
 	"regexp"
 	"slices"
 	"strings"
 
-	"github.com/dlclark/regexp2"
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/core"
@@ -18,6 +16,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/scanner"
 	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
+	"github.com/microsoft/typescript-go/internal/vfs/vfsmatch"
 )
 
 type extendsResult struct {
@@ -99,36 +98,11 @@ type configFileSpecs struct {
 }
 
 func (c *configFileSpecs) matchesExclude(fileName string, comparePathsOptions tspath.ComparePathsOptions) bool {
-	if len(c.validatedExcludeSpecs) == 0 {
-		return false
-	}
-	excludePattern := vfs.GetRegularExpressionForWildcard(c.validatedExcludeSpecs, comparePathsOptions.CurrentDirectory, "exclude")
-	excludeRegex := vfs.GetRegexFromPattern(excludePattern, comparePathsOptions.UseCaseSensitiveFileNames)
-	if match, err := excludeRegex.MatchString(fileName); err == nil && match {
-		return true
-	}
-	if !tspath.HasExtension(fileName) {
-		if match, err := excludeRegex.MatchString(tspath.EnsureTrailingDirectorySeparator(fileName)); err == nil && match {
-			return true
-		}
-	}
-	return false
+	return vfsmatch.MatchesExclude(fileName, c.validatedExcludeSpecs, comparePathsOptions.CurrentDirectory, comparePathsOptions.UseCaseSensitiveFileNames)
 }
 
 func (c *configFileSpecs) matchesInclude(fileName string, comparePathsOptions tspath.ComparePathsOptions) bool {
-	if len(c.validatedIncludeSpecs) == 0 {
-		return false
-	}
-	for _, spec := range c.validatedIncludeSpecs {
-		includePattern := vfs.GetPatternFromSpec(spec, comparePathsOptions.CurrentDirectory, "files")
-		if includePattern != "" {
-			includeRegex := vfs.GetRegexFromPattern(includePattern, comparePathsOptions.UseCaseSensitiveFileNames)
-			if match, err := includeRegex.MatchString(fileName); err == nil && match {
-				return true
-			}
-		}
-	}
-	return false
+	return vfsmatch.MatchesInclude(fileName, c.validatedIncludeSpecs, comparePathsOptions.CurrentDirectory, comparePathsOptions.UseCaseSensitiveFileNames)
 }
 
 type FileExtensionInfo struct {
@@ -1571,24 +1545,15 @@ func getFileNamesFromConfigSpecs(
 		literalFileMap.Set(keyMappper(fileName), file)
 	}
 
-	var jsonOnlyIncludeRegexes []*regexp2.Regexp
+	var jsonOnlyIncludeSpecs []string
 	if len(validatedIncludeSpecs) > 0 {
-		files := vfs.ReadDirectory(host, basePath, basePath, core.Flatten(supportedExtensionsWithJsonIfResolveJsonModule), validatedExcludeSpecs, validatedIncludeSpecs, nil)
+		files := vfsmatch.ReadDirectory(host, basePath, basePath, core.Flatten(supportedExtensionsWithJsonIfResolveJsonModule), validatedExcludeSpecs, validatedIncludeSpecs, nil)
 		for _, file := range files {
 			if tspath.FileExtensionIs(file, tspath.ExtensionJson) {
-				if jsonOnlyIncludeRegexes == nil {
-					includes := core.Filter(validatedIncludeSpecs, func(include string) bool { return strings.HasSuffix(include, tspath.ExtensionJson) })
-					includeFilePatterns := core.Map(vfs.GetRegularExpressionsForWildcards(includes, basePath, "files"), func(pattern string) string { return fmt.Sprintf("^%s$", pattern) })
-					if includeFilePatterns != nil {
-						jsonOnlyIncludeRegexes = core.Map(includeFilePatterns, func(pattern string) *regexp2.Regexp {
-							return vfs.GetRegexFromPattern(pattern, host.UseCaseSensitiveFileNames())
-						})
-					} else {
-						jsonOnlyIncludeRegexes = nil
-					}
+				if jsonOnlyIncludeSpecs == nil {
+					jsonOnlyIncludeSpecs = core.Filter(validatedIncludeSpecs, func(include string) bool { return strings.HasSuffix(include, tspath.ExtensionJson) })
 				}
-				includeIndex := core.FindIndex(jsonOnlyIncludeRegexes, func(re *regexp2.Regexp) bool { return core.Must(re.MatchString(file)) })
-				if includeIndex != -1 {
+				if vfsmatch.MatchesIncludeWithJsonOnly(file, jsonOnlyIncludeSpecs, basePath, host.UseCaseSensitiveFileNames()) {
 					key := keyMappper(file)
 					if !literalFileMap.Has(key) && !wildCardJsonFileMap.Has(key) {
 						wildCardJsonFileMap.Set(key, file)

internal/tsoptions/wildcarddirectories.go

@@ -1,12 +1,10 @@
 package tsoptions
 
 import (
-	"regexp"
 	"strings"
 
-	"github.com/dlclark/regexp2"
 	"github.com/microsoft/typescript-go/internal/tspath"
-	"github.com/microsoft/typescript-go/internal/vfs"
+	"github.com/microsoft/typescript-go/internal/vfs/vfsmatch"
 )
 
 func getWildcardDirectories(include []string, exclude []string, comparePathsOptions tspath.ComparePathsOptions) map[string]bool {
@@ -27,24 +25,14 @@ func getWildcardDirectories(include []string, exclude []string, comparePathsOpti
 		return nil
 	}
 
-	rawExcludeRegex := vfs.GetRegularExpressionForWildcard(exclude, comparePathsOptions.CurrentDirectory, "exclude")
-	var excludeRegex *regexp.Regexp
-	if rawExcludeRegex != "" {
-		options := ""
-		if !comparePathsOptions.UseCaseSensitiveFileNames {
-			options = "(?i)"
-		}
-		excludeRegex = regexp.MustCompile(options + rawExcludeRegex)
-	}
-
 	wildcardDirectories := make(map[string]bool)
 	wildCardKeyToPath := make(map[string]string)
 
 	var recursiveKeys []string
 
 	for _, file := range include {
 		spec := tspath.NormalizeSlashes(tspath.CombinePaths(comparePathsOptions.CurrentDirectory, file))
-		if excludeRegex != nil && excludeRegex.MatchString(spec) {
+		if vfsmatch.MatchesExclude(spec, exclude, comparePathsOptions.CurrentDirectory, comparePathsOptions.UseCaseSensitiveFileNames) {
 			continue
 		}
 
@@ -99,9 +87,6 @@ func toCanonicalKey(path string, useCaseSensitiveFileNames bool) string {
 	return strings.ToLower(path)
 }
 
-// wildcardDirectoryPattern matches paths with wildcard characters
-var wildcardDirectoryPattern = regexp2.MustCompile(`^[^*?]*(?=\/[^/]*[*?])`, 0)
-
 // wildcardDirectoryMatch represents the result of a wildcard directory match
 type wildcardDirectoryMatch struct {
 	Key       string
@@ -110,27 +95,55 @@ type wildcardDirectoryMatch struct {
 }
 
 func getWildcardDirectoryFromSpec(spec string, useCaseSensitiveFileNames bool) *wildcardDirectoryMatch {
-	match, _ := wildcardDirectoryPattern.FindStringMatch(spec)
-	if match != nil {
-		// We check this with a few `Index` calls because it's more efficient than complex regex
-		questionWildcardIndex := strings.Index(spec, "?")
-		starWildcardIndex := strings.Index(spec, "*")
-		lastDirectorySeparatorIndex := strings.LastIndexByte(spec, tspath.DirectorySeparator)
-
-		// Determine if this should be watched recursively
-		recursive := (questionWildcardIndex != -1 && questionWildcardIndex < lastDirectorySeparatorIndex) ||
-			(starWildcardIndex != -1 && starWildcardIndex < lastDirectorySeparatorIndex)
-
-		return &wildcardDirectoryMatch{
-			Key:       toCanonicalKey(match.String(), useCaseSensitiveFileNames),
-			Path:      match.String(),
-			Recursive: recursive,
+	// Find the first occurrence of wildcards (* or ?)
+	questionWildcardIndex := strings.IndexByte(spec, '?')
+	starWildcardIndex := strings.IndexByte(spec, '*')
+
+	// Find the earliest wildcard
+	var firstWildcardIndex int
+	if questionWildcardIndex == -1 || starWildcardIndex == -1 {
+		firstWildcardIndex = max(questionWildcardIndex, starWildcardIndex)
+	} else {
+		firstWildcardIndex = min(questionWildcardIndex, starWildcardIndex)
+	}
+
+	if firstWildcardIndex != -1 {
+		// Find the last directory separator before the first wildcard
+		prefixBeforeWildcard := spec[:firstWildcardIndex]
+		lastSepIndex := strings.LastIndexByte(prefixBeforeWildcard, tspath.DirectorySeparator)
+
+		if lastSepIndex != -1 {
+			// Check if there are wildcards in the segment after this directory separator
+			segmentStart := lastSepIndex + 1
+			segmentEnd := strings.IndexByte(spec[segmentStart:], tspath.DirectorySeparator)
+			if segmentEnd == -1 {
+				segmentEnd = len(spec)
+			} else {
+				segmentEnd += segmentStart
+			}
+
+			segment := spec[segmentStart:segmentEnd]
+			if strings.ContainsAny(segment, "*?") {
+				path := spec[:lastSepIndex]
+
+				lastDirectorySeparatorIndex := strings.LastIndexByte(spec, tspath.DirectorySeparator)
+
+				// Determine if this should be watched recursively
+				lastWildcardIndex := max(questionWildcardIndex, starWildcardIndex)
+				recursive := 0 <= lastWildcardIndex && lastWildcardIndex < lastDirectorySeparatorIndex
+
+				return &wildcardDirectoryMatch{
+					Key:       toCanonicalKey(path, useCaseSensitiveFileNames),
+					Path:      path,
+					Recursive: recursive,
+				}
+			}
 		}
 	}
 
 	if lastSepIndex := strings.LastIndexByte(spec, tspath.DirectorySeparator); lastSepIndex != -1 {
 		lastSegment := spec[lastSepIndex+1:]
-		if vfs.IsImplicitGlob(lastSegment) {
+		if vfsmatch.IsImplicitGlob(lastSegment) {
 			path := tspath.RemoveTrailingDirectorySeparator(spec)
 			return &wildcardDirectoryMatch{
 				Key:       toCanonicalKey(path, useCaseSensitiveFileNames),

internal/tspath/path.go

@@ -129,9 +129,19 @@ func GetPathComponents(path string, currentDirectory string) []string {
 
 func pathComponents(path string, rootLength int) []string {
 	root := path[:rootLength]
-	rest := strings.Split(path[rootLength:], "/")
-	if len(rest) > 0 && rest[len(rest)-1] == "" {
-		rest = rest[:len(rest)-1]
+	restStr := path[rootLength:]
+	var rest []string
+	start := 0
+	for i := 0; i <= len(restStr); i++ {
+		if i == len(restStr) || restStr[i] == '/' {
+			if i > start {
+				seg := restStr[start:i]
+				if seg != "" {
+					rest = append(rest, seg)
+				}
+			}
+			start = i + 1
+		}
 	}
 	return append([]string{root}, rest...)
 }
@@ -279,21 +289,17 @@ func reducePathComponents(components []string) []string {
 	if len(components) == 0 {
 		return []string{}
 	}
-	reduced := []string{components[0]}
+	reduced := make([]string, 0, len(components))
+	reduced = append(reduced, components[0])
 	for i := 1; i < len(components); i++ {
 		component := components[i]
-		if component == "" {
-			continue
-		}
-		if component == "." {
+		if component == "" || component == "." {
 			continue
 		}
 		if component == ".." {
-			if len(reduced) > 1 {
-				if reduced[len(reduced)-1] != ".." {
-					reduced = reduced[:len(reduced)-1]
-					continue
-				}
+			if len(reduced) > 1 && reduced[len(reduced)-1] != ".." {
+				reduced = reduced[:len(reduced)-1]
+				continue
 			} else if reduced[0] != "" {
 				continue
 			}