perf: prune gitignored directories during gap-file discovery (#1100)

Author: fansenze

cmd/rslint/cmd.go

@@ -911,8 +911,8 @@ func executeLintPipeline(args lintArgs, ctx context.Context, dispatch linter.Esl
 			//
 			// Config ignores are passed so that directories which are
 			// directory-level blocked (e.g. **/tests/**) are pruned during
-			// the .gitignore scan. This is safe because isDirPathBlocked is
-			// the same function used by the linter — blocked dirs' files
+			// the .gitignore scan. This is safe because isDirAbsolutelyBlocked is
+			// the same predicate used by the linter — blocked dirs' files
 			// are never linted, so their .gitignore patterns are irrelevant.
 			//
 			// Concurrency:

internal/config/config.go

@@ -336,50 +336,6 @@ func registerAllCoreEslintRules() {
 	}
 }
 
-// isFileIgnored checks if a file is matched by ignore patterns, evaluated sequentially.
-// Later patterns override earlier ones; a `!` prefix negates (re-includes) a previously
-// ignored file. This aligns with ESLint v10's ignore semantics.
-//
-// For directory-level blocking (dir/** prevents traversal entirely), use isDirPathBlocked.
-func isFileIgnored(filePath string, ignorePatterns []string, cwd string) bool {
-	if cwd == "" {
-		return isFileIgnoredSimple(filePath, ignorePatterns)
-	}
-
-	// Normalize the file path relative to cwd
-	normalizedPath := normalizePath(filePath, cwd)
-	unixPath := strings.ReplaceAll(normalizedPath, "\\", "/")
-
-	// Evaluate patterns sequentially. Later patterns override earlier ones.
-	// A `!` prefix negates (re-includes) a previously ignored file.
-	// This aligns with ESLint v10's ignore semantics.
-	ignored := false
-	for _, pattern := range ignorePatterns {
-		negated := false
-		if strings.HasPrefix(pattern, "!") {
-			negated = true
-			pattern = pattern[1:]
-		}
-
-		normalizedPattern := normalizePattern(pattern)
-
-		// Match against the relative path only. Do NOT fall back to the
-		// absolute filePath — patterns with **/ prefix (e.g., **/tmp/**/*)
-		// would incorrectly match system directory names in the absolute path
-		// (e.g., /tmp/ on Linux/macOS).
-		matched := matchGlob(normalizedPattern, normalizedPath)
-		// Windows path separator fallback.
-		if !matched && unixPath != normalizedPath {
-			matched = matchGlob(normalizedPattern, unixPath)
-		}
-
-		if matched {
-			ignored = !negated
-		}
-	}
-	return ignored
-}
-
 // normalizePattern cleans up a glob pattern to match paths produced by normalizePath.
 // normalizePath uses tspath.NormalizePath on file paths (strips leading "./", collapses
 // "/./", resolves ".."), so patterns must undergo the same transformation.
@@ -389,24 +345,16 @@ func matchGlob(pattern, path string) bool {
 	return err == nil && m
 }
 
-// isFileLevelPattern returns true if the pattern only matches files (not directories).
-// File-level patterns end with /**/* or /* (but not /**).
-// These do NOT block directory traversal in ESLint v10's isDirectoryIgnored.
-func isFileLevelPattern(pattern string) bool {
-	return strings.HasSuffix(pattern, "/**/*") ||
-		(strings.HasSuffix(pattern, "/*") && !strings.HasSuffix(pattern, "/**"))
-}
-
 func normalizePattern(pattern string) string {
 	return tspath.NormalizePath(pattern)
 }
 
 // isDirBlockedByIgnores checks if the file's directory is blocked by a
-// directory-level ignore pattern (e.g., `dir/**`). File-level patterns
-// (`dir/**/*`, `dir/*`) and negation patterns are skipped.
-// This aligns with ESLint v10: `dir/**` blocks directory traversal entirely,
-// and `!` negation cannot undo it.
-func isDirBlockedByIgnores(filePath string, ignorePatterns []string, cwd string) bool {
+// directory-level ignore pattern (e.g., `dir/**`). File-level patterns and
+// negation patterns are excluded (by Kind) in isDirAbsolutelyBlocked. This
+// aligns with ESLint v10: `dir/**` blocks directory traversal entirely, and
+// `!` negation cannot undo it.
+func isDirBlockedByIgnores(filePath string, patterns []IgnorePattern, cwd string) bool {
 	var dirPath string
 	if cwd != "" {
 		dirPath = normalizePath(tspath.GetDirectoryPath(filePath), cwd)
@@ -418,39 +366,7 @@ func isDirBlockedByIgnores(filePath string, ignorePatterns []string, cwd string)
 	if dirPath == "" || dirPath == "." {
 		return false
 	}
-	return isDirPathBlocked(dirPath, ignorePatterns)
-}
-
-// isDirPathBlocked checks if a directory path is blocked by any directory-level ignore
-// pattern. Shared between GetConfigForFile and DiscoverGapFiles.
-//
-// A directory is blocked if a pattern matches the path itself or any parent segment.
-// For example, pattern "dir1/**" blocks "dir1", "dir1/sub", and "dir1/sub/deep".
-// File-level patterns (ending with /**/* or /*) and negation (!) patterns are skipped —
-// directory blocking is absolute and cannot be negated.
-func isDirPathBlocked(dirPath string, ignorePatterns []string) bool {
-	for _, pattern := range ignorePatterns {
-		if pattern == "" || strings.HasPrefix(pattern, "!") {
-			continue
-		}
-		if isFileLevelPattern(pattern) {
-			continue
-		}
-
-		normalizedPattern := normalizePattern(pattern)
-
-		if matchGlob(normalizedPattern, dirPath) || matchGlob(normalizedPattern, dirPath+"/x") {
-			return true
-		}
-		segments := strings.Split(dirPath, "/")
-		for i := 1; i < len(segments); i++ {
-			partial := strings.Join(segments[:i], "/")
-			if matchGlob(normalizedPattern, partial) || matchGlob(normalizedPattern, partial+"/x") {
-				return true
-			}
-		}
-	}
-	return false
+	return isDirAbsolutelyBlocked(dirPath, patterns)
 }
 
 // normalizePath converts file path to be relative to cwd for consistent matching
@@ -461,23 +377,6 @@ func normalizePath(filePath, cwd string) string {
 	}))
 }
 
-// isFileIgnoredSimple provides fallback matching when cwd is unavailable
-func isFileIgnoredSimple(filePath string, ignorePatterns []string) bool {
-	ignored := false
-	for _, pattern := range ignorePatterns {
-		negated := false
-		if strings.HasPrefix(pattern, "!") {
-			negated = true
-			pattern = pattern[1:]
-		}
-		normalizedPattern := normalizePattern(pattern)
-		if matched, err := doublestar.Match(normalizedPattern, filePath); err == nil && matched {
-			ignored = !negated
-		}
-	}
-	return ignored
-}
-
 // MergedConfig is the final computed configuration for a single file
 type MergedConfig struct {
 	Rules           map[string]*RuleConfig
@@ -546,8 +445,10 @@ func (config RslintConfig) GetConfigForFile(filePath string, cwd string) *Merged
 			continue
 		}
 
-		// 3. Entry-level ignores
-		if isFileIgnored(filePath, entry.Ignores, cwd) {
+		// 3. Entry-level ignores. Parsed per entry; entry.Ignores is usually
+		// empty (ESLint configs put ignores in a dedicated global-ignore entry),
+		// so ParseIgnorePatterns returns nil and this is free in the common case.
+		if isFileIgnored(filePath, ParseIgnorePatterns(entry.Ignores), cwd) {
 			continue
 		}
 

internal/config/config_ignore_test.go

@@ -105,7 +105,7 @@ func TestIsFileIgnored_Negation(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := isFileIgnored(tt.filePath, tt.patterns, cwd)
+			result := isFileIgnored(tt.filePath, ParseIgnorePatterns(tt.patterns), cwd)
 			if result != tt.shouldIgnore {
 				t.Errorf("isFileIgnored(%q, %v) = %v, expected %v",
 					tt.filePath, tt.patterns, result, tt.shouldIgnore)
@@ -175,7 +175,7 @@ func TestIsFileIgnored_NegationBeforePositive(t *testing.T) {
 
 	// Negation before positive pattern: ! has nothing to negate yet,
 	// then positive pattern ignores. Result: ignored.
-	result := isFileIgnored("build/test.js", []string{"!build/test.js", "build/**"}, cwd)
+	result := isFileIgnored("build/test.js", ParseIgnorePatterns([]string{"!build/test.js", "build/**"}), cwd)
 	if !result {
 		t.Error("Expected ignored: negation before positive has no effect, positive wins")
 	}
@@ -212,7 +212,7 @@ func TestIsFileIgnored_FileExtensionNegation(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := isFileIgnored(tt.filePath, tt.patterns, cwd)
+			result := isFileIgnored(tt.filePath, ParseIgnorePatterns(tt.patterns), cwd)
 			if result != tt.shouldIgnore {
 				t.Errorf("isFileIgnored(%q, %v) = %v, expected %v",
 					tt.filePath, tt.patterns, result, tt.shouldIgnore)
@@ -240,7 +240,7 @@ func TestIsFileIgnored_MultiLevelNegateAndReIgnore(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := isFileIgnored(tt.filePath, patterns, cwd)
+			result := isFileIgnored(tt.filePath, ParseIgnorePatterns(patterns), cwd)
 			if result != tt.shouldIgnore {
 				t.Errorf("isFileIgnored(%q) = %v, expected %v", tt.filePath, result, tt.shouldIgnore)
 			}
@@ -284,7 +284,7 @@ func TestIsFileIgnoredSimple_Negation(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := isFileIgnoredSimple(tt.filePath, tt.patterns)
+			result := isFileIgnoredSimple(tt.filePath, ParseIgnorePatterns(tt.patterns))
 			if result != tt.shouldIgnore {
 				t.Errorf("isFileIgnoredSimple(%q, %v) = %v, expected %v",
 					tt.filePath, tt.patterns, result, tt.shouldIgnore)

internal/config/cwd_test.go

@@ -97,7 +97,7 @@ func TestCwdHandling(t *testing.T) {
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			result := isFileIgnored(tt.filePath, tt.patterns, originalCwd)
+			result := isFileIgnored(tt.filePath, ParseIgnorePatterns(tt.patterns), originalCwd)
 			if result != tt.shouldIgnore {
 				t.Errorf("%s: isFileIgnored(%q, %v) = %v, expected %v",
 					tt.description, tt.filePath, tt.patterns, result, tt.shouldIgnore)

internal/config/file_discovery.go

@@ -92,7 +92,7 @@ func DiscoverGapFiles(
 
 	// 2. Prepend default directory ignores so they are always active
 	// regardless of user config.
-	globalIgnores = append(utils.DefaultIgnoreDirGlobs(), globalIgnores...)
+	globalIgnores = append(ParseIgnorePatterns(utils.DefaultIgnoreDirGlobs()), globalIgnores...)
 
 	// Use non-nil empty slice to distinguish "files field present, no gaps"
 	// from "no files field" (nil).
@@ -139,6 +139,11 @@ func DiscoverGapFiles(
 		dirIgnore sync.Map // map[string]bool — pattern check cache, write-once per path
 	)
 
+	// Precompute negation reaches once. canPruneDir uses them to prune gitignore
+	// file-level directories (e.g. target/ → **/target/**/*) without ever
+	// skipping a directory a `!` pattern could re-include.
+	neg := buildNegReach(globalIgnores)
+
 	// Defer the parallelism limit to GOMAXPROCS (Go's standard knob; aligned
 	// with container CGroup CPU limits). Lower bound of 2 keeps the walker
 	// useful on single-core CI runners. singleThreaded overrides to 1 for
@@ -235,7 +240,11 @@ func DiscoverGapFiles(
 						continue
 					}
 				} else {
-					blocked := isDirPathBlocked(childPath, globalIgnores)
+					// canPruneDir unifies both directory-prune cases: absolute
+					// blocks (dir/**, bare names) and negation-aware file-level
+					// gitignore covers (dir/**/*). Sound — prunes only when every
+					// descendant file would be ignored by isFileIgnored.
+					blocked := canPruneDir(childPath, globalIgnores, neg)
 					dirIgnore.Store(childPath, blocked)
 					if blocked {
 						continue