Store mtime to the nanosecond so a same-second rewrite is re-hashed (closes #12)

scan recorded mtime in whole seconds, so a file rewritten in place at
the same size within the same second as its recorded mtime was classed
unchanged and kept its old hashes. The files table keeps mtime as whole
Unix seconds and gains mtime_nsec, the nanoseconds within that second.
scan holds the mtime as a time.Time and decides "newer" by comparing
Unix() and then Nanosecond(), so any time a filesystem can record
compares in the right order; After would misorder one too late for a
time.Time to hold without wrapping. The walk, a file given as an
operand, and the content phase's recheck all move over. PRAGMA
user_version stays 1, per the owner's ruling. README states what both
columns hold.

Model: opus-5-5

scan.go

@@ -416,7 +416,7 @@ func (s *scanState) walkPhase(
 		old, ok := s.existing[ev.rec.path]
 
 		switch {
-		case !ok || old.size != ev.rec.size || ev.rec.mtime.After(old.mtime):
+		case !ok || old.size != ev.rec.size || mtimeAfter(ev.rec.mtime, old.mtime):
 			changed = append(changed, ev.rec)
 		case old.hashed:
 			delete(s.existing, ev.rec.path)
@@ -808,7 +808,7 @@ func unchangedFile(r scanRec) (fileRec, bool, error) {
 	}
 
 	if !fi.Mode().IsRegular() || fi.Size() != r.size ||
-		fi.ModTime().After(r.mtime) {
+		mtimeAfter(fi.ModTime(), r.mtime) {
 		return fileRec{}, false, nil
 	}
 
@@ -819,6 +819,16 @@ func unchangedFile(r scanRec) (fileRec, bool, error) {
 	}, true, nil
 }
 
+// mtimeAfter reports whether mtime a is later than mtime b.
+// Not a.After(b): time.Time wraps an mtime past year 292 billion; Unix() undoes it.
+func mtimeAfter(a, b time.Time) bool {
+	if a.Unix() != b.Unix() {
+		return a.Unix() > b.Unix()
+	}
+
+	return a.Nanosecond() > b.Nanosecond()
+}
+
 // underAnyRoot reports whether path is any of the roots or lies under
 // one of them.
 func underAnyRoot(path string, roots []string) bool {

scan_test.go

@@ -1446,12 +1446,30 @@ func TestSyncScanOperandSameSecondRewrite(t *testing.T) {
 	assertWholeFileHashed(t, db, a, rewritten)
 }
 
-// TestSyncScanRewriteAfter2262 rewrites a file in place at the same
+// TestSyncScanRewriteAfter2262 runs assertLateRewriteRehashed with an
-// size and sets its mtime after 2262, a time too late to count in
+// mtime after 2262, a time too late to count in nanoseconds in an int64.
-// nanoseconds in an int64: the next scan must still re-hash it.
 func TestSyncScanRewriteAfter2262(t *testing.T) {
 	t.Parallel()
 
+	assertLateRewriteRehashed(t, time.Date(2300, 1, 2, 3, 4, 5, 0, time.UTC))
+}
+
+// TestSyncScanRewritePastTimeLimit runs assertLateRewriteRehashed with an
+// mtime one second past the latest a time.Time holds without wrapping it
+// to a time far in the past.
+func TestSyncScanRewritePastTimeLimit(t *testing.T) {
+	t.Parallel()
+
+	assertLateRewriteRehashed(t, time.Unix(9223371974719179008, 0))
+}
+
+// assertLateRewriteRehashed scans a directory, rewrites a file in it in
+// place at the same size, sets its mtime to late, and fails unless the
+// next scan re-hashes the file. It skips where late does not fit the
+// platform's timespec or the filesystem does not store it.
+func assertLateRewriteRehashed(t *testing.T, late time.Time) {
+	t.Helper()
+
 	dir := t.TempDir()
 	db := openTestDB(t)
 	a := writeFile(t, dir, "a.bin", pattern(1, 500))
@@ -1464,12 +1482,11 @@ func TestSyncScanRewriteAfter2262(t *testing.T) {
 	rewritten := pattern(3, 500)
 	writeFile(t, dir, "a.bin", rewritten)
 
-	// os.Chtimes cannot set this time: it converts through UnixNano.
+	// os.Chtimes cannot set such a time: it converts through UnixNano.
-	late := time.Date(2300, 1, 2, 3, 4, 5, 0, time.UTC)
-
 	ts, err := unix.TimeToTimespec(late)
 	if err != nil {
-		t.Skipf("%v does not fit this platform's timespec: %v", late, err)
+		t.Skipf("an mtime %d seconds after 1970 does not fit this platform's "+
+			"timespec: %v", late.Unix(), err)
 	}
 
 	err = unix.UtimesNano(a, []unix.Timespec{ts, ts})
@@ -1482,9 +1499,9 @@ func TestSyncScanRewriteAfter2262(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	if !fi.ModTime().Equal(late) {
+	if fi.ModTime().Unix() != late.Unix() {
-		t.Skipf("the filesystem stored mtime %v instead of %v",
+		t.Skipf("the filesystem stored the mtime as %d seconds after 1970, "+
-			fi.ModTime().UTC(), late)
+			"not %d", fi.ModTime().Unix(), late.Unix())
 	}
 
 	st := syncTree(t, db, dir)