Add clock implementation to vfs and tsc test

Author: sheetalkamat

internal/execute/testsys_test.go

@@ -9,6 +9,7 @@ import (
 	"slices"
 	"strconv"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/microsoft/typescript-go/internal/collections"
@@ -54,6 +55,26 @@ interface Symbol {
 declare const console: { log(msg: any): void; };
 `)
 
+type TestClock struct {
+	start time.Time
+	now   time.Time
+	nowMu sync.Mutex
+}
+
+func (t *TestClock) Now() time.Time {
+	t.nowMu.Lock()
+	defer t.nowMu.Unlock()
+	if t.now.IsZero() {
+		t.now = t.start
+	}
+	t.now = t.now.Add(1 * time.Second) // Simulate some time passing
+	return t.now
+}
+
+func (t *TestClock) SinceStart() time.Duration {
+	return t.Now().Sub(t.start)
+}
+
 func newTestSys(tscInput *tscInput) *testSys {
 	cwd := tscInput.cwd
 	if cwd == "" {
@@ -64,10 +85,11 @@ func newTestSys(tscInput *tscInput) *testSys {
 		libPath = tscInput.windowsStyleRoot + libPath[1:]
 	}
 	currentWrite := &strings.Builder{}
+	clock := &TestClock{start: time.Now()}
 	sys := &testSys{
 		fs: &incrementaltestutil.FsHandlingBuildInfo{
 			FS: &testFs{
-				FS: vfstest.FromMap(tscInput.files, !tscInput.ignoreCase),
+				FS: vfstest.FromMapWithClock(tscInput.files, !tscInput.ignoreCase, clock),
 			},
 		},
 		defaultLibraryPath: libPath,
@@ -77,7 +99,7 @@ func newTestSys(tscInput *tscInput) *testSys {
 			UseCaseSensitiveFileNames: !tscInput.ignoreCase,
 			CurrentDirectory:          cwd,
 		}, currentWrite),
-		start: time.Now(),
+		clock: clock,
 		env:   tscInput.env,
 	}
 
@@ -113,8 +135,7 @@ type testSys struct {
 	defaultLibraryPath string
 	cwd                string
 	env                map[string]string
-
-	start time.Time
+	clock              *TestClock
 }
 
 var (
@@ -123,12 +144,11 @@ var (
 )
 
 func (s *testSys) Now() time.Time {
-	// todo: make a "test time" structure
-	return time.Now()
+	return s.clock.Now()
 }
 
 func (s *testSys) SinceStart() time.Duration {
-	return time.Since(s.start)
+	return s.clock.SinceStart()
 }
 
 func (s *testSys) FS() vfs.FS {
@@ -143,6 +163,10 @@ func (s *testSys) fsFromFileMap() iovfs.FsWithSys {
 	return s.testFs().FS.(iovfs.FsWithSys)
 }
 
+func (s *testSys) mapFs() *vfstest.MapFS {
+	return s.fsFromFileMap().FSys().(*vfstest.MapFS)
+}
+
 func (s *testSys) ensureLibPathExists(path string) {
 	path = s.defaultLibraryPath + "/" + path
 	if _, ok := s.fsFromFileMap().ReadFile(path); !ok {
@@ -368,7 +392,7 @@ func (s *testSys) baselineFSwithDiff(baseline io.Writer) {
 
 		fileInfo := d.Type()
 		if fileInfo&fs.ModeSymlink != 0 {
-			target, ok := s.fsFromFileMap().FSys().(*vfstest.MapFS).GetTargetOfSymlink(path)
+			target, ok := s.mapFs().GetTargetOfSymlink(path)
 			if !ok {
 				panic("Failed to resolve symlink target: " + path)
 			}

internal/vfs/vfstest/vfstest.go

@@ -28,6 +28,25 @@ type MapFS struct {
 	useCaseSensitiveFileNames bool
 
 	symlinks map[canonicalPath]canonicalPath
+
+	clock Clock
+}
+
+type Clock interface {
+	Now() time.Time
+	SinceStart() time.Duration
+}
+
+type clockImpl struct {
+	start time.Time
+}
+
+func (c *clockImpl) Now() time.Time {
+	return time.Now()
+}
+
+func (c *clockImpl) SinceStart() time.Duration {
+	return time.Since(c.start)
 }
 
 var (
@@ -47,6 +66,16 @@ type sys struct {
 // without trailing directory separators.
 // The paths must be all POSIX-style or all Windows-style, but not both.
 func FromMap[File any](m map[string]File, useCaseSensitiveFileNames bool) vfs.FS {
+	return FromMapWithClock(m, useCaseSensitiveFileNames, &clockImpl{start: time.Now()})
+}
+
+// FromMap creates a new [vfs.FS] from a map of paths to file contents.
+// Those file contents may be strings, byte slices, or [fstest.MapFile]s.
+//
+// The paths must be normalized absolute paths according to the tspath package,
+// without trailing directory separators.
+// The paths must be all POSIX-style or all Windows-style, but not both.
+func FromMapWithClock[File any](m map[string]File, useCaseSensitiveFileNames bool, clock Clock) vfs.FS {
 	posix := false
 	windows := false
 
@@ -67,17 +96,23 @@ func FromMap[File any](m map[string]File, useCaseSensitiveFileNames bool) vfs.FS
 	}
 
 	mfs := make(fstest.MapFS, len(m))
-	for p, f := range m {
+	// Sorted creation to ensure times are always guaranteed to be in order.
+	keys := slices.Collect(maps.Keys(m))
+	slices.SortFunc(keys, comparePathsByParts)
+	for _, p := range keys {
+		f := m[p]
 		checkPath(p)
 
 		var file *fstest.MapFile
 		switch f := any(f).(type) {
 		case string:
-			file = &fstest.MapFile{Data: []byte(f)}
+			file = &fstest.MapFile{Data: []byte(f), ModTime: clock.Now()}
 		case []byte:
-			file = &fstest.MapFile{Data: f}
+			file = &fstest.MapFile{Data: f, ModTime: clock.Now()}
 		case *fstest.MapFile:
-			file = f
+			fCopy := *f
+			fCopy.ModTime = clock.Now()
+			file = &fCopy
 		default:
 			panic(fmt.Sprintf("invalid file type %T", f))
 		}
@@ -100,13 +135,17 @@ func FromMap[File any](m map[string]File, useCaseSensitiveFileNames bool) vfs.FS
 		panic("mixed posix and windows paths")
 	}
 
-	return iovfs.From(convertMapFS(mfs, useCaseSensitiveFileNames), useCaseSensitiveFileNames)
+	return iovfs.From(convertMapFS(mfs, useCaseSensitiveFileNames, clock), useCaseSensitiveFileNames)
 }
 
-func convertMapFS(input fstest.MapFS, useCaseSensitiveFileNames bool) *MapFS {
+func convertMapFS(input fstest.MapFS, useCaseSensitiveFileNames bool, clock Clock) *MapFS {
+	if clock == nil {
+		clock = &clockImpl{start: time.Now()}
+	}
 	m := &MapFS{
 		m:                         make(fstest.MapFS, len(input)),
 		useCaseSensitiveFileNames: useCaseSensitiveFileNames,
+		clock:                     clock,
 	}
 
 	// Verify that the input is well-formed.
@@ -320,7 +359,8 @@ func (m *MapFS) mkdirAll(p string, perm fs.FileMode) error {
 
 	for _, dir := range toCreate {
 		m.setEntry(dir, m.getCanonicalPath(dir), fstest.MapFile{
-			Mode: fs.ModeDir | perm&^umask,
+			Mode:    fs.ModeDir | perm&^umask,
+			ModTime: m.clock.Now(),
 		})
 	}
 
@@ -482,7 +522,7 @@ func (m *MapFS) WriteFile(path string, data []byte, perm fs.FileMode) error {
 
 	m.setEntry(path, cp, fstest.MapFile{
 		Data:    data,
-		ModTime: time.Now(),
+		ModTime: m.clock.Now(),
 		Mode:    perm &^ umask,
 	})
 

internal/vfs/vfstest/vfstest_test.go

@@ -34,7 +34,7 @@ func TestInsensitive(t *testing.T) {
 			Data: contents,
 			Sys:  1234,
 		},
-	}, false /*useCaseSensitiveFileNames*/)
+	}, false /*useCaseSensitiveFileNames*/, nil)
 
 	sensitive, err := fs.ReadFile(vfs, "foo/bar/baz")
 	assert.NilError(t, err)
@@ -97,7 +97,7 @@ func TestInsensitiveUpper(t *testing.T) {
 			Data: contents,
 			Sys:  1234,
 		},
-	}, false /*useCaseSensitiveFileNames*/)
+	}, false /*useCaseSensitiveFileNames*/, nil)
 
 	sensitive, err := fs.ReadFile(vfs, "foo/bar/baz")
 	assert.NilError(t, err)
@@ -142,7 +142,7 @@ func TestSensitive(t *testing.T) {
 			Data: contents,
 			Sys:  1234,
 		},
-	}, true /*useCaseSensitiveFileNames*/)
+	}, true /*useCaseSensitiveFileNames*/, nil)
 
 	sensitive, err := fs.ReadFile(vfs, "foo/bar/baz")
 	assert.NilError(t, err)
@@ -170,7 +170,7 @@ func TestSensitiveDuplicatePath(t *testing.T) {
 	}
 
 	testutil.AssertPanics(t, func() {
-		convertMapFS(testfs, false /*useCaseSensitiveFileNames*/)
+		convertMapFS(testfs, false /*useCaseSensitiveFileNames*/, nil)
 	}, `duplicate path: "Foo" and "foo" have the same canonical path`)
 }
 
@@ -186,7 +186,7 @@ func TestInsensitiveDuplicatePath(t *testing.T) {
 		},
 	}
 
-	convertMapFS(testfs, true /*useCaseSensitiveFileNames*/)
+	convertMapFS(testfs, true /*useCaseSensitiveFileNames*/, nil)
 }
 
 func dirEntriesToNames(entries []fs.DirEntry) []string {
@@ -303,7 +303,7 @@ func TestParentDirFile(t *testing.T) {
 	}
 
 	testutil.AssertPanics(t, func() {
-		convertMapFS(testfs, false /*useCaseSensitiveFileNames*/)
+		convertMapFS(testfs, false /*useCaseSensitiveFileNames*/, nil)
 	}, `failed to create intermediate directories for "foo/oops": mkdir "foo": path exists but is not a directory`)
 }