[STEP-2135] Allow non-existent paths in compat FilterPaths

v1 pathutil.FilterPaths did not touch the filesystem, so callers could
filter synthetic or relative paths that do not exist on disk. The v2
compat adapter was stat-ing every path up-front, which surfaced a
not-exist error and broke drop-in migration for call sites that feed
lexical inputs (e.g. steps-cocoapods-install main_test.go).

Stat opportunistically instead: if the path does not exist, fall through
with a nil DirEntry. Purely path-based filters (Base, Extension, Regexp,
Component, ComponentWithExtension, InDirectory) keep working unchanged;
filters that consult the DirEntry (IsDirectory, DirectoryContainsFile,
FileContains) still error when the DirEntry is needed but unavailable.
Stat errors other than ErrNotExist continue to surface.

Tests split: one covering the v1-parity lexical case, one asserting the
DirEntry-needing filter still errors on a missing path.

Author: Badlazzor

pathutil/path_filter_compat.go

@@ -9,19 +9,27 @@ import (
 
 // FilterPaths applies filters to an explicit list of OS paths and returns
 // the ones that pass every filter, preserving input order. Each path is
-// stat-ed to build an fs.DirEntry for the filter callbacks; a missing path
-// surfaces the stat error.
+// stat-ed opportunistically so filters that consult fs.DirEntry (e.g.
+// IsDirectoryFilter) work; paths that do not exist on disk are still fed
+// to the filters with a nil DirEntry, matching v1's purely lexical
+// behavior for path-only filters. Stat errors other than "not exist"
+// surface to the caller.
 //
 // This adapter preserves the v1 go-utils pathutil.FilterPaths signature so
 // callers can migrate by import-path rename only. Prefer FilterFS in new code.
 func FilterPaths(paths []string, filters ...FilterFunc) ([]string, error) {
 	var filtered []string
 	for _, pth := range paths {
+		var d fs.DirEntry
 		info, err := os.Lstat(pth)
-		if err != nil {
+		switch {
+		case err == nil:
+			d = fs.FileInfoToDirEntry(info)
+		case errors.Is(err, fs.ErrNotExist):
+			// Leave d nil; path-only filters still work.
+		default:
 			return nil, err
 		}
-		d := fs.FileInfoToDirEntry(info)
 
 		keep, err := runFilters(pth, d, filters)
 		if err != nil {

pathutil/path_filter_compat_test.go

@@ -46,7 +46,20 @@ func TestFilterPaths(t *testing.T) {
 	}, got)
 }
 
-func TestFilterPaths_missingPathErrors(t *testing.T) {
+func TestFilterPaths_missingPath_pathOnlyFilters(t *testing.T) {
+	// v1 parity: purely lexical filters work against paths that do not
+	// exist on disk. IsDirectoryFilter is not used here so no stat is needed.
+	got, err := FilterPaths(
+		[]string{"./Podfile", "/nowhere/Podfile.lock"},
+		BaseFilter("Podfile", true),
+	)
+	require.NoError(t, err)
+	require.Equal(t, []string{"./Podfile"}, got)
+}
+
+func TestFilterPaths_missingPath_dirEntryFilterErrors(t *testing.T) {
+	// Filters that consult the DirEntry (IsDirectoryFilter) still error on
+	// missing paths because there is nothing to inspect.
 	_, err := FilterPaths([]string{"/does/not/exist/ever"}, IsDirectoryFilter(false))
 	require.Error(t, err)
 }