Split VFS implementations apart for easier platform-specific additions (#173)

Author: jakebailey

internal/vfs/iofs.go

@@ -0,0 +1,86 @@
+package vfs
+
+import (
+	"fmt"
+	"io/fs"
+	"strings"
+
+	"github.com/microsoft/typescript-go/internal/tspath"
+)
+
+type RealpathFS interface {
+	fs.FS
+	Realpath(path string) (string, error)
+}
+
+// FromIOFS creates a new FS from an [fs.FS].
+//
+// For paths like `c:/foo/bar`, fsys will be used as though it's rooted at `/` and the path is `/c:/foo/bar`.
+//
+// If the provided [fs.FS] implements [RealpathFS], it will be used to implement the Realpath method.
+//
+// Deprecated: FromIOFS does not actually handle case-insensitivity; ensure the passed in [fs.FS]
+// respects case-insensitive file names if needed. Consider using [vfstest.FromMapFS] for testing.
+func FromIOFS(fsys fs.FS, useCaseSensitiveFileNames bool) FS {
+	var realpath func(path string) (string, error)
+	if fsys, ok := fsys.(RealpathFS); ok {
+		realpath = func(path string) (string, error) {
+			rest, hadSlash := strings.CutPrefix(path, "/")
+			rp, err := fsys.Realpath(rest)
+			if err != nil {
+				return "", err
+			}
+			if hadSlash {
+				return "/" + rp, nil
+			}
+			return rp, nil
+		}
+	} else {
+		realpath = func(path string) (string, error) {
+			return path, nil
+		}
+	}
+
+	return &ioFS{
+		common: common{
+			rootFor: func(root string) fs.FS {
+				if root == "/" {
+					return fsys
+				}
+
+				p := tspath.RemoveTrailingDirectorySeparator(root)
+				sub, err := fs.Sub(fsys, p)
+				if err != nil {
+					panic(fmt.Sprintf("vfs: failed to create sub file system for %q: %v", p, err))
+				}
+				return sub
+			},
+		},
+		useCaseSensitiveFileNames: useCaseSensitiveFileNames,
+		realpath:                  realpath,
+	}
+}
+
+type ioFS struct {
+	common
+
+	useCaseSensitiveFileNames bool
+	realpath                  func(path string) (string, error)
+}
+
+var _ FS = (*ioFS)(nil)
+
+func (vfs *ioFS) UseCaseSensitiveFileNames() bool {
+	return vfs.useCaseSensitiveFileNames
+}
+
+func (vfs *ioFS) Realpath(path string) string {
+	root, rest := splitPath(path)
+	// splitPath normalizes the path into parts (e.g. "c:/foo/bar" -> "c:/", "foo/bar")
+	// Put them back together to call realpath.
+	realpath, err := vfs.realpath(root + rest)
+	if err != nil {
+		return path
+	}
+	return realpath
+}

internal/vfs/iofs_test.go

@@ -0,0 +1,134 @@
+package vfs_test
+
+import (
+	"slices"
+	"testing"
+	"testing/fstest"
+
+	"github.com/microsoft/typescript-go/internal/testutil"
+	"github.com/microsoft/typescript-go/internal/vfs"
+	"gotest.tools/v3/assert"
+)
+
+func TestIOFS(t *testing.T) {
+	t.Parallel()
+
+	testfs := fstest.MapFS{
+		"foo.ts": &fstest.MapFile{
+			Data: []byte("hello, world"),
+		},
+		"dir1/file1.ts": &fstest.MapFile{
+			Data: []byte("export const foo = 42;"),
+		},
+		"dir1/file2.ts": &fstest.MapFile{
+			Data: []byte("export const foo = 42;"),
+		},
+		"dir2/file1.ts": &fstest.MapFile{
+			Data: []byte("export const foo = 42;"),
+		},
+	}
+
+	fs := vfs.FromIOFS(testfs, true)
+
+	t.Run("ReadFile", func(t *testing.T) {
+		t.Parallel()
+
+		content, ok := fs.ReadFile("/foo.ts")
+		assert.Assert(t, ok)
+		assert.Equal(t, content, "hello, world")
+
+		content, ok = fs.ReadFile("/does/not/exist.ts")
+		assert.Assert(t, !ok)
+		assert.Equal(t, content, "")
+	})
+
+	t.Run("ReadFileUnrooted", func(t *testing.T) {
+		t.Parallel()
+
+		testutil.AssertPanics(t, func() { fs.ReadFile("bar") }, `vfs: path "bar" is not absolute`)
+	})
+
+	t.Run("FileExists", func(t *testing.T) {
+		t.Parallel()
+
+		assert.Assert(t, fs.FileExists("/foo.ts"))
+		assert.Assert(t, !fs.FileExists("/bar"))
+	})
+
+	t.Run("DirectoryExists", func(t *testing.T) {
+		t.Parallel()
+
+		assert.Assert(t, fs.DirectoryExists("/"))
+		assert.Assert(t, fs.DirectoryExists("/dir1"))
+		assert.Assert(t, fs.DirectoryExists("/dir1/"))
+		assert.Assert(t, fs.DirectoryExists("/dir1/./"))
+		assert.Assert(t, !fs.DirectoryExists("/bar"))
+	})
+
+	t.Run("GetDirectories", func(t *testing.T) {
+		t.Parallel()
+
+		dirs := fs.GetDirectories("/")
+		slices.Sort(dirs)
+
+		assert.DeepEqual(t, dirs, []string{"dir1", "dir2"})
+	})
+
+	t.Run("WalkDir", func(t *testing.T) {
+		t.Parallel()
+
+		var files []string
+		err := fs.WalkDir("/", func(path string, d vfs.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if !d.IsDir() {
+				files = append(files, path)
+			}
+			return nil
+		})
+		assert.NilError(t, err)
+
+		slices.Sort(files)
+
+		assert.DeepEqual(t, files, []string{"/dir1/file1.ts", "/dir1/file2.ts", "/dir2/file1.ts", "/foo.ts"})
+	})
+
+	t.Run("WalkDirSkip", func(t *testing.T) {
+		t.Parallel()
+
+		var files []string
+		err := fs.WalkDir("/", func(path string, d vfs.DirEntry, err error) error {
+			if err != nil {
+				return err
+			}
+			if !d.IsDir() {
+				files = append(files, path)
+			}
+
+			if path == "/" {
+				return nil
+			}
+
+			return vfs.SkipDir
+		})
+		assert.NilError(t, err)
+
+		slices.Sort(files)
+
+		assert.DeepEqual(t, files, []string{"/foo.ts"})
+	})
+
+	t.Run("Realpath", func(t *testing.T) {
+		t.Parallel()
+
+		realpath := fs.Realpath("/foo.ts")
+		assert.Equal(t, realpath, "/foo.ts")
+	})
+
+	t.Run("UseCaseSensitiveFileNames", func(t *testing.T) {
+		t.Parallel()
+
+		assert.Assert(t, fs.UseCaseSensitiveFileNames())
+	})
+}

internal/vfs/os.go

@@ -0,0 +1,81 @@
+package vfs
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"strings"
+	"sync"
+	"unicode"
+
+	"github.com/microsoft/typescript-go/internal/tspath"
+)
+
+// FromOS creates a new FS from the OS file system.
+func FromOS() FS {
+	return osVFS
+}
+
+var osVFS FS = &osFS{
+	common: common{
+		rootFor: os.DirFS,
+	},
+}
+
+type osFS struct {
+	common
+}
+
+var isFileSystemCaseSensitive = sync.OnceValue(func() bool {
+	// win32/win64 are case insensitive platforms
+	if runtime.GOOS == "windows" {
+		return false
+	}
+
+	// If the current executable exists under a different case, we must be case-insensitve.
+	if _, err := os.Stat(swapCase(os.Args[0])); os.IsNotExist(err) {
+		return false
+	}
+	return true
+})
+
+// Convert all lowercase chars to uppercase, and vice-versa
+func swapCase(str string) string {
+	return strings.Map(func(r rune) rune {
+		upper := unicode.ToUpper(r)
+		if upper == r {
+			return unicode.ToLower(r)
+		} else {
+			return upper
+		}
+	}, str)
+}
+
+func (vfs *osFS) UseCaseSensitiveFileNames() bool {
+	return isFileSystemCaseSensitive()
+}
+
+var osReadSema = make(chan struct{}, 128)
+
+func (vfs *osFS) ReadFile(path string) (contents string, ok bool) {
+	osReadSema <- struct{}{}
+	defer func() { <-osReadSema }()
+
+	return vfs.common.ReadFile(path)
+}
+
+func (vfs *osFS) Realpath(path string) string {
+	_ = rootLength(path) // Assert path is rooted
+
+	orig := path
+	path = filepath.FromSlash(path)
+	path, err := filepath.EvalSymlinks(path)
+	if err != nil {
+		return orig
+	}
+	path, err = filepath.Abs(path)
+	if err != nil {
+		return orig
+	}
+	return tspath.NormalizeSlashes(path)
+}

internal/vfs/os_test.go

@@ -0,0 +1,52 @@
+package vfs_test
+
+import (
+	"os"
+	"path/filepath"
+	"runtime"
+	"testing"
+
+	"github.com/microsoft/typescript-go/internal/repo"
+	"github.com/microsoft/typescript-go/internal/tspath"
+	"github.com/microsoft/typescript-go/internal/vfs"
+	"gotest.tools/v3/assert"
+)
+
+func TestOS(t *testing.T) {
+	t.Parallel()
+
+	fs := vfs.FromOS()
+
+	goMod := filepath.Join(repo.RootPath, "go.mod")
+	goModPath := tspath.NormalizePath(goMod)
+
+	t.Run("ReadFile", func(t *testing.T) {
+		t.Parallel()
+
+		expectedRaw, err := os.ReadFile(goMod)
+		assert.NilError(t, err)
+		expected := string(expectedRaw)
+
+		contents, ok := fs.ReadFile(goModPath)
+		assert.Assert(t, ok)
+		assert.Equal(t, contents, expected)
+	})
+
+	t.Run("Realpath", func(t *testing.T) {
+		t.Parallel()
+
+		realpath := fs.Realpath(goModPath)
+		assert.Equal(t, realpath, goModPath)
+	})
+
+	t.Run("UseCaseSensitiveFileNames", func(t *testing.T) {
+		t.Parallel()
+
+		// Just check that it works.
+		fs.UseCaseSensitiveFileNames()
+
+		if runtime.GOOS == "windows" {
+			assert.Assert(t, !fs.UseCaseSensitiveFileNames())
+		}
+	})
+}