Split the stat pass back out of the walk

Phases are strictly sequential again — walk, stat, hash, update per
operand — with parallelism only inside each phase. The walk
enumerates paths with per-directory workers (no lstat of file
entries); the stat pass lstats every collected path with per-file
workers, restoring its exact-total/ETA progress bar and per-file
parallelism inside wide flat directories.

scan_test.go

@@ -110,33 +110,6 @@ func TestHashHeadTailErrors(t *testing.T) {
 	}
 }
 
-// walkedPaths returns the sorted paths of walked records.
-func walkedPaths(recs []fileRec) []string {
-	paths := make([]string, 0, len(recs))
-	for _, r := range recs {
-		paths = append(paths, r.path)
-	}
-
-	slices.Sort(paths)
-
-	return paths
-}
-
-// walkedByPath finds the walked record with the given path.
-func walkedByPath(t *testing.T, recs []fileRec, path string) fileRec {
-	t.Helper()
-
-	for _, r := range recs {
-		if r.path == path {
-			return r
-		}
-	}
-
-	t.Fatalf("no walked record for %q", path)
-
-	return fileRec{}
-}
-
 func TestWalkPass(t *testing.T) {
 	t.Parallel()
 
@@ -158,18 +131,15 @@ func TestWalkPass(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	recs, errs := walkPass(dir, false, 4)
+	paths, errs := walkPass(dir, false, 4)
 	if errs != 0 {
 		t.Fatalf("errs = %d, want 0", errs)
 	}
 
-	if got := walkedPaths(recs); !slices.Equal(got, want) {
-		t.Fatalf("paths = %q, want %q", got, want)
-	}
+	slices.Sort(paths)
 
-	// The walk records lstat sizes and mtimes.
-	if r := walkedByPath(t, recs, want[0]); r.size != 1 || r.mtime <= 0 {
-		t.Fatalf("rec = %+v, want size 1 and a positive mtime", r)
+	if !slices.Equal(paths, want) {
+		t.Fatalf("paths = %q, want %q", paths, want)
 	}
 }
 
@@ -191,13 +161,15 @@ func TestWalkPassDeepAndWide(t *testing.T) {
 
 	slices.Sort(want)
 
-	recs, errs := walkPass(dir, false, 8)
+	paths, errs := walkPass(dir, false, 8)
 	if errs != 0 {
 		t.Fatalf("errs = %d, want 0", errs)
 	}
 
-	if got := walkedPaths(recs); !slices.Equal(got, want) {
-		t.Fatalf("walked %d paths, want %d", len(got), len(want))
+	slices.Sort(paths)
+
+	if !slices.Equal(paths, want) {
+		t.Fatalf("walked %d paths, want %d", len(paths), len(want))
 	}
 }
 
@@ -215,15 +187,15 @@ func TestWalkPassFileAndSymlinkOperands(t *testing.T) {
 	}
 
 	// A regular-file operand is emitted as itself.
-	recs, errs := walkPass(f, false, 2)
-	if errs != 0 || len(recs) != 1 || recs[0].path != f || recs[0].size != 4 {
-		t.Fatalf("file operand: recs = %+v, errs = %d", recs, errs)
+	paths, errs := walkPass(f, false, 2)
+	if errs != 0 || !slices.Equal(paths, []string{f}) {
+		t.Fatalf("file operand: paths = %q, errs = %d", paths, errs)
 	}
 
 	// A symlink operand is not followed and yields nothing.
-	recs, errs = walkPass(link, false, 2)
-	if errs != 0 || len(recs) != 0 {
-		t.Fatalf("symlink operand: recs = %+v, errs = %d", recs, errs)
+	paths, errs = walkPass(link, false, 2)
+	if errs != 0 || len(paths) != 0 {
+		t.Fatalf("symlink operand: paths = %q, errs = %d", paths, errs)
 	}
 }
 
@@ -237,13 +209,41 @@ func TestWalkPassOneFilesystemSameFS(t *testing.T) {
 		writeFile(t, dir, "sub/deep/b", []byte("b")),
 	}
 
-	recs, errs := walkPass(dir, true, 4)
+	paths, errs := walkPass(dir, true, 4)
 	if errs != 0 {
 		t.Fatalf("errs = %d, want 0", errs)
 	}
 
-	if got := walkedPaths(recs); !slices.Equal(got, want) {
-		t.Fatalf("paths = %q, want %q", got, want)
+	slices.Sort(paths)
+
+	if !slices.Equal(paths, want) {
+		t.Fatalf("paths = %q, want %q", paths, want)
+	}
+}
+
+func TestStatPass(t *testing.T) {
+	t.Parallel()
+
+	dir := t.TempDir()
+	a := writeFile(t, dir, "a", pattern(1, 10))
+	b := writeFile(t, dir, "b", pattern(2, 20))
+	missing := filepath.Join(dir, "vanished")
+
+	recs, errs := statPass([]string{a, b, missing}, 2)
+	if errs != 1 {
+		t.Fatalf("errs = %d, want 1 for the vanished file", errs)
+	}
+
+	slices.SortFunc(recs, func(x, y fileRec) int {
+		return strings.Compare(x.path, y.path)
+	})
+
+	if len(recs) != 2 || recs[0].size != 10 || recs[1].size != 20 {
+		t.Fatalf("recs = %+v, want sizes 10 and 20", recs)
+	}
+
+	if recs[0].mtime <= 0 || recs[1].mtime <= 0 {
+		t.Fatalf("recs = %+v, want positive mtimes", recs)
 	}
 }