u

Author: camc314

internal/tsoptions/wildcarddirectories.go

@@ -1,7 +1,6 @@
 package tsoptions
 
 import (
-	"regexp"
 	"strings"
 
 	"github.com/dlclark/regexp2"
@@ -28,13 +27,13 @@ func getWildcardDirectories(include []string, exclude []string, comparePathsOpti
 	}
 
 	rawExcludeRegex := vfs.GetRegularExpressionForWildcard(exclude, comparePathsOptions.CurrentDirectory, "exclude")
-	var excludeRegex *regexp.Regexp
+	var excludeRegex *regexp2.Regexp
 	if rawExcludeRegex != "" {
-		options := ""
+		flags := regexp2.ECMAScript
 		if !comparePathsOptions.UseCaseSensitiveFileNames {
-			options = "(?i)"
+			flags |= regexp2.IgnoreCase
 		}
-		excludeRegex = regexp.MustCompile(options + rawExcludeRegex)
+		excludeRegex = regexp2.MustCompile(rawExcludeRegex, regexp2.RegexOptions(flags))
 	}
 
 	wildcardDirectories := make(map[string]bool)
@@ -44,8 +43,10 @@ func getWildcardDirectories(include []string, exclude []string, comparePathsOpti
 
 	for _, file := range include {
 		spec := tspath.NormalizeSlashes(tspath.CombinePaths(comparePathsOptions.CurrentDirectory, file))
-		if excludeRegex != nil && excludeRegex.MatchString(spec) {
-			continue
+		if excludeRegex != nil {
+			if matched, _ := excludeRegex.MatchString(spec); matched {
+				continue
+			}
 		}
 
 		match := getWildcardDirectoryFromSpec(spec, comparePathsOptions.UseCaseSensitiveFileNames)

internal/vfs/utilities.go

@@ -2,6 +2,7 @@ package vfs
 
 import (
 	"fmt"
+	"regexp"
 	"sort"
 	"strings"
 	"sync"
@@ -74,28 +75,18 @@ func replaceWildcardCharacter(match string, singleAsteriskRegexFragment string)
 	}
 }
 
-func escapeRegexMetacharacters(s string, replaceWildcard func(string) string) string {
-	var result strings.Builder
-	result.Grow(len(s))
-	for _, ch := range s {
-		switch ch {
-		case '\\', '.', '+', '*', '?', '(', ')', '[', ']', '{', '}', '^', '$', '|', '#':
-			result.WriteString(replaceWildcard(string(ch)))
-		default:
-			result.WriteRune(ch)
-		}
-	}
-	return result.String()
-}
-
 // An "includes" path "foo" is implicitly a glob "foo/** /*" (without the space) if its last component has no extension,
 // and does not contain any glob characters itself.
 func IsImplicitGlob(lastPathComponent string) bool {
 	return !strings.ContainsAny(lastPathComponent, ".*?")
 }
 
+// Reserved characters - only escape actual regex metacharacters.
+// Go's regexp doesn't support \x escape sequences for arbitrary characters,
+// so we only escape characters that have special meaning in regex.
 var (
-	wildcardCharCodes = []rune{'*', '?'}
+	reservedCharacterPattern *regexp.Regexp = regexp.MustCompile(`[\\.\+*?()\[\]{}^$|#]`)
+	wildcardCharCodes                       = []rune{'*', '?'}
 )
 
 var (
@@ -215,7 +206,7 @@ func getSubPatternFromSpec(
 					componentPattern.WriteString("[^./]")
 					component = component[1:]
 				}
-				componentPattern.WriteString(escapeRegexMetacharacters(component, replaceWildcardCharacter))
+				componentPattern.WriteString(reservedCharacterPattern.ReplaceAllStringFunc(component, replaceWildcardCharacter))
 
 				// Patterns should not include subfolders like node_modules unless they are
 				// explicitly included as part of the path.
@@ -228,7 +219,7 @@ func getSubPatternFromSpec(
 				}
 				subpattern.WriteString(componentPattern.String())
 			} else {
-				subpattern.WriteString(escapeRegexMetacharacters(component, replaceWildcardCharacter))
+				subpattern.WriteString(reservedCharacterPattern.ReplaceAllStringFunc(component, replaceWildcardCharacter))
 			}
 		}
 		hasWrittenComponent = true