Add FS implementation

cmd/tsgo/main.go

@@ -8,13 +8,13 @@ import (
 	"runtime"
 	"strings"
 	"time"
-	"unicode"
 
 	"github.com/microsoft/typescript-go/internal/ast"
 	ts "github.com/microsoft/typescript-go/internal/compiler"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/scanner"
 	"github.com/microsoft/typescript-go/internal/tspath"
+	"github.com/microsoft/typescript-go/internal/vfs"
 )
 
 var quiet = false
@@ -54,8 +54,22 @@ func main() {
 
 	rootPath := flag.Arg(0)
 	compilerOptions := &core.CompilerOptions{Strict: core.TSTrue, Target: core.ScriptTargetESNext, ModuleKind: core.ModuleKindNodeNext}
-	programOptions := ts.ProgramOptions{RootPath: rootPath, Options: compilerOptions, SingleThreaded: singleThreaded}
-	useCaseSensitiveFileNames := isFileSystemCaseSensitive()
+	currentDirectory, err := os.Getwd()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "Error getting current directory: %v\n", err)
+		os.Exit(1)
+	}
+	fs := vfs.FromOS()
+	useCaseSensitiveFileNames := fs.UseCaseSensitiveFileNames()
+	host := ts.NewCompilerHost(compilerOptions, singleThreaded, currentDirectory, fs)
+
+	normalizedRootPath := tspath.ResolvePath(currentDirectory, rootPath)
+	if !fs.DirectoryExists(normalizedRootPath) {
+		fmt.Fprintf(os.Stderr, "Error: The directory %v does not exist.\n", normalizedRootPath)
+		os.Exit(1)
+	}
+
+	programOptions := ts.ProgramOptions{RootPath: normalizedRootPath, Options: compilerOptions, SingleThreaded: singleThreaded, Host: host}
 
 	startTime := time.Now()
 	program := ts.NewProgram(programOptions)
@@ -78,11 +92,6 @@ func main() {
 	runtime.ReadMemStats(&memStats)
 	if !quiet && len(diagnostics) != 0 {
 		if pretty {
-			currentDirectory, err := os.Getwd()
-			if err != nil {
-				panic("no current directory")
-			}
-
 			var output strings.Builder
 			formatOpts := ts.DiagnosticsFormattingOptions{
 				NewLine: "\n",
@@ -107,28 +116,3 @@ func main() {
 	fmt.Printf("Compile time:  %v\n", compileTime)
 	fmt.Printf("Memory used:   %vK\n", memStats.Alloc/1024)
 }
-
-func isFileSystemCaseSensitive() 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)
-}

internal/ast/ast.go

@@ -2,6 +2,7 @@ package ast
 
 import (
 	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/tspath"
 )
 
 // Visitor
@@ -5093,7 +5094,7 @@ type SourceFile struct {
 	LocalsContainerBase
 	Text                        string
 	fileName                    string
-	path                        string
+	path                        tspath.Path
 	Statements                  *NodeList // NodeList[*Statement]
 	diagnostics                 []*Diagnostic
 	bindDiagnostics             []*Diagnostic
@@ -5132,11 +5133,11 @@ func (node *SourceFile) FileName() string {
 	return node.fileName
 }
 
-func (node *SourceFile) Path() string {
+func (node *SourceFile) Path() tspath.Path {
 	return node.path
 }
 
-func (node *SourceFile) SetPath(p string) {
+func (node *SourceFile) SetPath(p tspath.Path) {
 	node.path = p
 }
 

internal/compiler/error_reporting.go

@@ -199,9 +199,9 @@ func WriteLocation(output *strings.Builder, file *ast.SourceFile, pos int, forma
 	firstLine, firstChar := scanner.GetLineAndCharacterOfPosition(file, pos)
 	var relativeFileName string
 	if formatOpts != nil {
-		relativeFileName = tspath.ConvertToRelativePath(file.Path(), formatOpts.ComparePathsOptions)
+		relativeFileName = tspath.ConvertToRelativePath(file.FileName(), formatOpts.ComparePathsOptions)
 	} else {
-		relativeFileName = file.Path()
+		relativeFileName = file.FileName()
 	}
 
 	writeWithStyleAndReset(output, relativeFileName, foregroundColorEscapeCyan)
@@ -333,7 +333,7 @@ func prettyPathForFileError(file *ast.SourceFile, fileErrors []*ast.Diagnostic,
 	line, _ := scanner.GetLineAndCharacterOfPosition(file, fileErrors[0].Loc().Pos())
 	fileName := file.FileName()
 	if tspath.PathIsAbsolute(fileName) && tspath.PathIsAbsolute(formatOpts.CurrentDirectory) {
-		fileName = tspath.ConvertToRelativePath(file.Path(), formatOpts.ComparePathsOptions)
+		fileName = tspath.ConvertToRelativePath(file.FileName(), formatOpts.ComparePathsOptions)
 	}
 	return fmt.Sprintf("%s%s:%d%s",
 		fileName,

internal/compiler/host.go

@@ -1,24 +1,15 @@
 package compiler
 
 import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-	"io/fs"
-	"os"
-	"path/filepath"
-	"slices"
-	"strings"
 	"sync"
-	"unicode/utf16"
 
 	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/vfs"
 )
 
 type CompilerHost interface {
-	ReadFile(fileName string) (text string, ok bool)
-	ReadDirectory(rootPath string, extensions []string) []FileInfo
-	AbsFileName(fileName string) string
+	FS() vfs.FS
+	GetCurrentDirectory() string
 	RunTask(fn func())
 	WaitForTasks()
 }
@@ -29,73 +20,28 @@ type FileInfo struct {
 }
 
 type compilerHost struct {
-	options        *core.CompilerOptions
-	singleThreaded bool
-	wg             sync.WaitGroup
-	readSema       chan struct{}
+	options          *core.CompilerOptions
+	singleThreaded   bool
+	wg               sync.WaitGroup
+	currentDirectory string
+	fs               vfs.FS
 }
 
-func NewCompilerHost(options *core.CompilerOptions, singleThreaded bool) CompilerHost {
+func NewCompilerHost(options *core.CompilerOptions, singleThreaded bool, currentDirectory string, fs vfs.FS) CompilerHost {
 	h := &compilerHost{}
 	h.options = options
 	h.singleThreaded = singleThreaded
-	h.readSema = make(chan struct{}, 128)
+	h.currentDirectory = currentDirectory
+	h.fs = fs
 	return h
 }
 
-func (h *compilerHost) ReadFile(fileName string) (text string, ok bool) {
-	h.readSema <- struct{}{}
-	b, err := os.ReadFile(fileName)
-	<-h.readSema
-	if err != nil {
-		return "", false
-	}
-	var bom [2]byte
-	if len(b) >= 2 {
-		bom = [2]byte{b[0], b[1]}
-		switch bom {
-		case [2]byte{0xFF, 0xFE}:
-			return decodeUtf16(b[2:], binary.LittleEndian), true
-		case [2]byte{0xFE, 0xFF}:
-			return decodeUtf16(b[2:], binary.BigEndian), true
-		}
-	}
-	if len(b) >= 3 && b[0] == 0xEF && b[1] == 0xBB && b[2] == 0xBF {
-		b = b[3:]
-	}
-	return string(b), true
+func (h *compilerHost) FS() vfs.FS {
+	return h.fs
 }
 
-func decodeUtf16(b []byte, order binary.ByteOrder) string {
-	ints := make([]uint16, len(b)/2)
-	if err := binary.Read(bytes.NewReader(b), order, &ints); err != nil {
-		return ""
-	}
-	return string(utf16.Decode(ints))
-}
-
-func (h *compilerHost) ReadDirectory(rootDir string, extensions []string) []FileInfo {
-	var fileInfos []FileInfo
-	_ = filepath.Walk(rootDir, func(path string, info fs.FileInfo, err error) error {
-		if err != nil {
-			fmt.Println(err)
-			os.Exit(1)
-		}
-		if !info.IsDir() && slices.ContainsFunc(extensions, func(ext string) bool { return strings.HasSuffix(path, ext) }) {
-			fileInfos = append(fileInfos, FileInfo{Name: path, Size: info.Size()})
-		}
-		return nil
-	})
-	return fileInfos
-}
-
-func (h *compilerHost) AbsFileName(fileName string) string {
-	absFileName, err := filepath.Abs(fileName)
-	if err != nil {
-		fmt.Println(err)
-		os.Exit(1)
-	}
-	return absFileName
+func (h *compilerHost) GetCurrentDirectory() string {
+	return h.currentDirectory
 }
 
 func (h *compilerHost) RunTask(task func()) {

internal/compiler/module/resolver.go

@@ -357,7 +357,7 @@ func (r *resolutionState) loadModuleFromNearestNodeModulesDirectoryWorker(ext ex
 
 func (r *resolutionState) loadModuleFromImmediateNodeModulesDirectory(extensions extensions, directory string, typesScopeOnly bool) *resolved {
 	nodeModulesFolder := tspath.CombinePaths(directory, "node_modules")
-	nodeModulesFolderExists := r.resolver.host.DirectoryExists(nodeModulesFolder)
+	nodeModulesFolderExists := r.resolver.host.FS().DirectoryExists(nodeModulesFolder)
 	if !nodeModulesFolderExists && r.resolver.traceEnabled() {
 		r.resolver.host.Trace(diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it.Format(nodeModulesFolder))
 	}
@@ -370,7 +370,7 @@ func (r *resolutionState) loadModuleFromImmediateNodeModulesDirectory(extensions
 
 	if extensions&ExtensionsDeclaration != 0 {
 		nodeModulesAtTypes := tspath.CombinePaths(nodeModulesFolder, "@types")
-		nodeModulesAtTypesExists := nodeModulesFolderExists && r.resolver.host.DirectoryExists(nodeModulesAtTypes)
+		nodeModulesAtTypesExists := nodeModulesFolderExists && r.resolver.host.FS().DirectoryExists(nodeModulesAtTypes)
 		if !nodeModulesAtTypesExists && r.resolver.traceEnabled() {
 			r.resolver.host.Trace(diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it.Format(nodeModulesAtTypes))
 		}
@@ -472,7 +472,7 @@ func (r *resolutionState) loadModuleFromSpecificNodeModulesDirectory(ext extensi
 				if r.resolver.traceEnabled() {
 					r.resolver.host.Trace(diagnostics.X_package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2.Format(versionPaths.Version, core.Version, rest))
 				}
-				packageDirectoryExists := nodeModulesDirectoryExists && r.resolver.host.DirectoryExists(packageDirectory)
+				packageDirectoryExists := nodeModulesDirectoryExists && r.resolver.host.FS().DirectoryExists(packageDirectory)
 				pathPatterns := tryParsePatterns(versionPaths.GetPaths())
 				if fromPaths := r.tryLoadModuleUsingPaths(ext, rest, packageDirectory, versionPaths.GetPaths(), pathPatterns, loader, !packageDirectoryExists); fromPaths.stop {
 					return fromPaths.value
@@ -561,7 +561,7 @@ func (r *resolutionState) createResolvedModuleWithFailedLookupLocations(resolved
 func (r *resolutionState) getOriginalAndResolvedFileName(fileName string) (string, string) {
 	resolvedFileName := r.realPath(fileName)
 	comparePathsOptions := tspath.ComparePathsOptions{
-		UseCaseSensitiveFileNames: r.resolver.host.UseCaseSensitiveFileNames(),
+		UseCaseSensitiveFileNames: r.resolver.host.FS().UseCaseSensitiveFileNames(),
 		CurrentDirectory:          r.resolver.host.GetCurrentDirectory(),
 	}
 	if tspath.ComparePaths(fileName, resolvedFileName, comparePathsOptions) == 0 {
@@ -618,7 +618,7 @@ func (r *resolutionState) tryLoadModuleUsingPaths(extensions extensions, moduleN
 					})
 				}
 			}
-			if resolved := loader(extensions, candidate, onlyRecordFailures || !r.resolver.host.DirectoryExists(tspath.GetDirectoryPath(candidate))); resolved != nil {
+			if resolved := loader(extensions, candidate, onlyRecordFailures || !r.resolver.host.FS().DirectoryExists(tspath.GetDirectoryPath(candidate))); resolved != nil {
 				return newSearchResult(resolved)
 			}
 		}
@@ -633,7 +633,7 @@ func (r *resolutionState) nodeLoadModuleByRelativeName(extensions extensions, ca
 	if !tspath.HasTrailingDirectorySeparator(candidate) {
 		if !onlyRecordFailures {
 			parentOfCandidate := tspath.GetDirectoryPath(candidate)
-			if !r.resolver.host.DirectoryExists(parentOfCandidate) {
+			if !r.resolver.host.FS().DirectoryExists(parentOfCandidate) {
 				if r.resolver.traceEnabled() {
 					r.resolver.host.Trace(diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it.Format(parentOfCandidate))
 				}
@@ -651,7 +651,7 @@ func (r *resolutionState) nodeLoadModuleByRelativeName(extensions extensions, ca
 		}
 	}
 	if !onlyRecordFailures {
-		candidateExists := r.resolver.host.DirectoryExists(candidate)
+		candidateExists := r.resolver.host.FS().DirectoryExists(candidate)
 		if !candidateExists {
 			if r.resolver.traceEnabled() {
 				r.resolver.host.Trace(diagnostics.Directory_0_does_not_exist_skipping_all_lookups_in_it.Format(candidate))
@@ -704,7 +704,7 @@ func (r *resolutionState) loadModuleFromFileNoImplicitExtensions(extensions exte
 func (r *resolutionState) tryAddingExtensions(extensionless string, extensions extensions, originalExtension string, onlyRecordFailures bool) *resolved {
 	if !onlyRecordFailures {
 		directory := tspath.GetDirectoryPath(extensionless)
-		onlyRecordFailures = directory != "" && !r.resolver.host.DirectoryExists(directory)
+		onlyRecordFailures = directory != "" && !r.resolver.host.FS().DirectoryExists(directory)
 	}
 
 	switch originalExtension {
@@ -848,7 +848,7 @@ func (r *resolutionState) tryFile(fileName string, onlyRecordFailures bool) (str
 
 func (r *resolutionState) tryFileLookup(fileName string, onlyRecordFailures bool) bool {
 	if !onlyRecordFailures {
-		if r.resolver.host.FileExists(fileName) {
+		if r.resolver.host.FS().FileExists(fileName) {
 			if r.resolver.traceEnabled() {
 				r.resolver.host.Trace(diagnostics.File_0_exists_use_it_as_a_name_resolution_result.Format(fileName))
 			}
@@ -889,7 +889,7 @@ func (r *resolutionState) loadNodeModuleFromDirectoryWorker(ext extensions, cand
 	if packageInfo != nil {
 		if file, ok := r.getPackageFile(ext, packageInfo); ok {
 			packageFile = file
-			onlyRecordFailuresForPackageFile = !r.resolver.host.DirectoryExists(tspath.GetDirectoryPath(file))
+			onlyRecordFailuresForPackageFile = !r.resolver.host.FS().DirectoryExists(tspath.GetDirectoryPath(file))
 		}
 	}
 
@@ -957,7 +957,7 @@ func (r *resolutionState) loadNodeModuleFromDirectoryWorker(ext extensions, cand
 
 	// ESM mode resolutions don't do package 'index' lookups
 	if !r.esmMode {
-		return r.loadModuleFromFile(ext, indexPath, onlyRecordFailures || !r.resolver.host.DirectoryExists(candidate))
+		return r.loadModuleFromFile(ext, indexPath, onlyRecordFailures || !r.resolver.host.FS().DirectoryExists(candidate))
 	}
 	return nil
 }
@@ -1046,10 +1046,11 @@ func (r *resolutionState) getPackageJsonInfo(packageDirectory string, onlyRecord
 		}
 	}
 
-	directoryExists := r.resolver.host.DirectoryExists(packageDirectory)
-	if directoryExists && r.resolver.host.FileExists(packageJsonPath) {
+	directoryExists := r.resolver.host.FS().DirectoryExists(packageDirectory)
+	if directoryExists && r.resolver.host.FS().FileExists(packageJsonPath) {
 		// Ignore error
-		packageJsonContent, _ := packagejson.Parse([]byte(r.resolver.host.ReadFile(packageJsonPath)))
+		contents, _ := r.resolver.host.FS().ReadFile(packageJsonPath)
+		packageJsonContent, _ := packagejson.Parse([]byte(contents))
 		if r.resolver.traceEnabled() {
 			r.resolver.host.Trace(diagnostics.Found_package_json_at_0.Format(packageJsonPath))
 		}
@@ -1132,7 +1133,7 @@ func (r *resolutionState) readPackageJsonPeerDependencies(packageJsonInfo *packa
 }
 
 func (r *resolutionState) realPath(path string) string {
-	rp := tspath.NormalizePath(r.resolver.host.Realpath(path))
+	rp := tspath.NormalizePath(r.resolver.host.FS().Realpath(path))
 	if r.resolver.traceEnabled() {
 		r.resolver.host.Trace(diagnostics.Resolving_real_path_for_0_result_1.Format(path, rp))
 	}