Add a new cached VFS wrapper (#750)

Author: jakebailey

Diff for: go.mod

@@ -12,9 +12,13 @@ require (
 )
 
 require (
+	github.com/matryer/moq v0.5.3 // indirect
 	golang.org/x/mod v0.23.0 // indirect
 	golang.org/x/sync v0.11.0 // indirect
 	golang.org/x/tools v0.30.0 // indirect
 )
 
-tool golang.org/x/tools/cmd/stringer
+tool (
+	github.com/matryer/moq
+	golang.org/x/tools/cmd/stringer
+)

Diff for: go.sum

@@ -4,8 +4,12 @@ github.com/go-json-experiment/json v0.0.0-20250223041408-d3c622f1b874 h1:F8d1AJ6
 github.com/go-json-experiment/json v0.0.0-20250223041408-d3c622f1b874/go.mod h1:TiCD2a1pcmjd7YnhGH0f/zKNcCD06B029pHhzV23c2M=
 github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
 github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
+github.com/matryer/moq v0.5.3 h1:4femQCFmBUwFPYs8VfM5ID7AI67/DTEDRBbTtSWy7GU=
+github.com/matryer/moq v0.5.3/go.mod h1:8288Qkw7gMZhUP3cIN86GG7g5p9jRuZH8biXLW4RXvQ=
 github.com/pkg/diff v0.0.0-20241224192749-4e6772a4315c h1:8TRxBMS/YsupXoOiGKHr9ZOXo+5DezGWPgBAhBHEHto=
 github.com/pkg/diff v0.0.0-20241224192749-4e6772a4315c/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 golang.org/x/mod v0.23.0 h1:Zb7khfcRGKk+kqfxFaP5tZqCnDZMjC5VtUBs87Hr6QM=
 golang.org/x/mod v0.23.0/go.mod h1:6SkKJ3Xj0I0BrPOZoBy3bdMptDDU9oJrpohJ3eWZ1fY=
 golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=

Diff for: internal/vfs/cachedvfs/cachedvfs.go

@@ -0,0 +1,96 @@
+package cachedvfs
+
+import (
+	"sync"
+
+	"github.com/microsoft/typescript-go/internal/vfs"
+)
+
+type FS struct {
+	fs vfs.FS
+
+	directoryExistsCache      sync.Map // map[string]bool
+	fileExistsCache           sync.Map // map[string]bool
+	getAccessibleEntriesCache sync.Map // map[string]vfs.Entries
+	realpathCache             sync.Map // map[string]string
+	statCache                 sync.Map // map[string]vfs.FileInfo
+}
+
+var _ vfs.FS = (*FS)(nil)
+
+func From(fs vfs.FS) *FS {
+	return &FS{fs: fs}
+}
+
+func (fsys *FS) ClearCache() {
+	fsys.directoryExistsCache.Clear()
+	fsys.fileExistsCache.Clear()
+	fsys.getAccessibleEntriesCache.Clear()
+	fsys.realpathCache.Clear()
+	fsys.statCache.Clear()
+}
+
+func (fsys *FS) DirectoryExists(path string) bool {
+	if ret, ok := fsys.directoryExistsCache.Load(path); ok {
+		return ret.(bool)
+	}
+	ret := fsys.fs.DirectoryExists(path)
+	fsys.directoryExistsCache.Store(path, ret)
+	return ret
+}
+
+func (fsys *FS) FileExists(path string) bool {
+	if ret, ok := fsys.fileExistsCache.Load(path); ok {
+		return ret.(bool)
+	}
+	ret := fsys.fs.FileExists(path)
+	fsys.fileExistsCache.Store(path, ret)
+	return ret
+}
+
+func (fsys *FS) GetAccessibleEntries(path string) vfs.Entries {
+	if ret, ok := fsys.getAccessibleEntriesCache.Load(path); ok {
+		return ret.(vfs.Entries)
+	}
+	ret := fsys.fs.GetAccessibleEntries(path)
+	fsys.getAccessibleEntriesCache.Store(path, ret)
+	return ret
+}
+
+func (fsys *FS) ReadFile(path string) (contents string, ok bool) {
+	return fsys.fs.ReadFile(path)
+}
+
+func (fsys *FS) Realpath(path string) string {
+	if ret, ok := fsys.realpathCache.Load(path); ok {
+		return ret.(string)
+	}
+	ret := fsys.fs.Realpath(path)
+	fsys.realpathCache.Store(path, ret)
+	return ret
+}
+
+func (fsys *FS) Remove(path string) error {
+	return fsys.fs.Remove(path)
+}
+
+func (fsys *FS) Stat(path string) vfs.FileInfo {
+	if ret, ok := fsys.statCache.Load(path); ok {
+		return ret.(vfs.FileInfo)
+	}
+	ret := fsys.fs.Stat(path)
+	fsys.statCache.Store(path, ret)
+	return ret
+}
+
+func (fsys *FS) UseCaseSensitiveFileNames() bool {
+	return fsys.fs.UseCaseSensitiveFileNames()
+}
+
+func (fsys *FS) WalkDir(root string, walkFn vfs.WalkDirFunc) error {
+	return fsys.fs.WalkDir(root, walkFn)
+}
+
+func (fsys *FS) WriteFile(path string, data string, writeByteOrderMark bool) error {
+	return fsys.fs.WriteFile(path, data, writeByteOrderMark)
+}

Diff for: internal/vfs/cachedvfs/cachedvfs_test.go

@@ -0,0 +1,211 @@
+package cachedvfs_test
+
+import (
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/vfs"
+	"github.com/microsoft/typescript-go/internal/vfs/cachedvfs"
+	"github.com/microsoft/typescript-go/internal/vfs/vfsmock"
+	"github.com/microsoft/typescript-go/internal/vfs/vfstest"
+	"gotest.tools/v3/assert"
+)
+
+func createMockFS() *vfsmock.FSMock {
+	return vfsmock.Wrap(vfstest.FromMap(map[string]string{
+		"/some/path/file.txt": "hello world",
+	}, true))
+}
+
+func TestDirectoryExists(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	cached.DirectoryExists("/some/path")
+	assert.Equal(t, 1, len(underlying.DirectoryExistsCalls()))
+
+	cached.DirectoryExists("/some/path")
+	assert.Equal(t, 1, len(underlying.DirectoryExistsCalls()))
+
+	cached.ClearCache()
+	cached.DirectoryExists("/some/path")
+	assert.Equal(t, 2, len(underlying.DirectoryExistsCalls()))
+
+	cached.DirectoryExists("/other/path")
+	assert.Equal(t, 3, len(underlying.DirectoryExistsCalls()))
+}
+
+func TestFileExists(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	cached.FileExists("/some/path/file.txt")
+	assert.Equal(t, 1, len(underlying.FileExistsCalls()))
+
+	cached.FileExists("/some/path/file.txt")
+	assert.Equal(t, 1, len(underlying.FileExistsCalls()))
+
+	cached.ClearCache()
+	cached.FileExists("/some/path/file.txt")
+	assert.Equal(t, 2, len(underlying.FileExistsCalls()))
+
+	cached.FileExists("/other/path/file.txt")
+	assert.Equal(t, 3, len(underlying.FileExistsCalls()))
+}
+
+func TestGetAccessibleEntries(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	cached.GetAccessibleEntries("/some/path")
+	assert.Equal(t, 1, len(underlying.GetAccessibleEntriesCalls()))
+
+	cached.GetAccessibleEntries("/some/path")
+	assert.Equal(t, 1, len(underlying.GetAccessibleEntriesCalls()))
+
+	cached.ClearCache()
+	cached.GetAccessibleEntries("/some/path")
+	assert.Equal(t, 2, len(underlying.GetAccessibleEntriesCalls()))
+
+	cached.GetAccessibleEntries("/other/path")
+	assert.Equal(t, 3, len(underlying.GetAccessibleEntriesCalls()))
+}
+
+func TestRealpath(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	cached.Realpath("/some/path")
+	assert.Equal(t, 1, len(underlying.RealpathCalls()))
+
+	cached.Realpath("/some/path")
+	assert.Equal(t, 1, len(underlying.RealpathCalls()))
+
+	cached.ClearCache()
+	cached.Realpath("/some/path")
+	assert.Equal(t, 2, len(underlying.RealpathCalls()))
+
+	cached.Realpath("/other/path")
+	assert.Equal(t, 3, len(underlying.RealpathCalls()))
+}
+
+func TestStat(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	cached.Stat("/some/path")
+	assert.Equal(t, 1, len(underlying.StatCalls()))
+
+	cached.Stat("/some/path")
+	assert.Equal(t, 1, len(underlying.StatCalls()))
+
+	cached.ClearCache()
+	cached.Stat("/some/path")
+	assert.Equal(t, 2, len(underlying.StatCalls()))
+
+	cached.Stat("/other/path")
+	assert.Equal(t, 3, len(underlying.StatCalls()))
+}
+
+func TestReadFile(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	cached.ReadFile("/some/path/file.txt")
+	assert.Equal(t, 1, len(underlying.ReadFileCalls()))
+
+	cached.ReadFile("/some/path/file.txt")
+	assert.Equal(t, 2, len(underlying.ReadFileCalls()))
+
+	cached.ClearCache()
+	cached.ReadFile("/some/path/file.txt")
+	assert.Equal(t, 3, len(underlying.ReadFileCalls()))
+}
+
+func TestUseCaseSensitiveFileNames(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	cached.UseCaseSensitiveFileNames()
+	assert.Equal(t, 1, len(underlying.UseCaseSensitiveFileNamesCalls()))
+
+	cached.UseCaseSensitiveFileNames()
+	assert.Equal(t, 2, len(underlying.UseCaseSensitiveFileNamesCalls()))
+
+	cached.ClearCache()
+	cached.UseCaseSensitiveFileNames()
+	assert.Equal(t, 3, len(underlying.UseCaseSensitiveFileNamesCalls()))
+}
+
+func TestWalkDir(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	walkFn := vfs.WalkDirFunc(func(path string, info vfs.DirEntry, err error) error {
+		return nil
+	})
+
+	_ = cached.WalkDir("/some/path", walkFn)
+	assert.Equal(t, 1, len(underlying.WalkDirCalls()))
+
+	_ = cached.WalkDir("/some/path", walkFn)
+	assert.Equal(t, 2, len(underlying.WalkDirCalls()))
+
+	cached.ClearCache()
+	_ = cached.WalkDir("/some/path", walkFn)
+	assert.Equal(t, 3, len(underlying.WalkDirCalls()))
+}
+
+func TestRemove(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	_ = cached.Remove("/some/path/file.txt")
+	assert.Equal(t, 1, len(underlying.RemoveCalls()))
+
+	_ = cached.Remove("/some/path/file.txt")
+	assert.Equal(t, 2, len(underlying.RemoveCalls()))
+
+	cached.ClearCache()
+	_ = cached.Remove("/some/path/file.txt")
+	assert.Equal(t, 3, len(underlying.RemoveCalls()))
+}
+
+func TestWriteFile(t *testing.T) {
+	t.Parallel()
+
+	underlying := createMockFS()
+	cached := cachedvfs.From(underlying)
+
+	_ = cached.WriteFile("/some/path/file.txt", "new content", false)
+	assert.Equal(t, 1, len(underlying.WriteFileCalls()))
+
+	_ = cached.WriteFile("/some/path/file.txt", "another content", true)
+	assert.Equal(t, 2, len(underlying.WriteFileCalls()))
+
+	cached.ClearCache()
+	_ = cached.WriteFile("/some/path/file.txt", "third content", false)
+	assert.Equal(t, 3, len(underlying.WriteFileCalls()))
+
+	call := underlying.WriteFileCalls()[2]
+	assert.Equal(t, "/some/path/file.txt", call.Path)
+	assert.Equal(t, "third content", call.Data)
+	assert.Equal(t, false, call.WriteByteOrderMark)
+}

Diff for: internal/vfs/vfs.go

@@ -4,6 +4,8 @@ import (
 	"io/fs"
 )
 
+//go:generate go tool github.com/matryer/moq -fmt goimports -out vfsmock/mock_generated.go -pkg vfsmock . FS
+
 // FS is a file system abstraction.
 type FS interface {
 	// UseCaseSensitiveFileNames returns true if the file system is case-sensitive.