Add Yarn PnP support

_extension/src/client.ts

@@ -28,7 +28,14 @@ export class Client {
         this.clientOptions = {
             documentSelector: [
                 ...jsTsLanguageModes.map(language => ({ scheme: "file", language })),
-                ...jsTsLanguageModes.map(language => ({ scheme: "untitled", language })),
+                ...jsTsLanguageModes.map(language => ({
+                    scheme: "untitled",
+                    language,
+                })),
+                ...jsTsLanguageModes.map(language => ({
+                    scheme: "zip",
+                    language,
+                })),
             ],
             outputChannel: this.outputChannel,
             traceOutputChannel: this.traceOutputChannel,

cmd/tsgo/sys.go

@@ -8,9 +8,11 @@ import (
 
 	"github.com/microsoft/typescript-go/internal/bundled"
 	"github.com/microsoft/typescript-go/internal/execute/tsc"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
 	"github.com/microsoft/typescript-go/internal/vfs/osvfs"
+	"github.com/microsoft/typescript-go/internal/vfs/pnpvfs"
 	"golang.org/x/term"
 )
 
@@ -20,6 +22,7 @@ type osSys struct {
 	defaultLibraryPath string
 	cwd                string
 	start              time.Time
+	pnpApi             *pnp.PnpApi
 }
 
 func (s *osSys) SinceStart() time.Duration {
@@ -59,18 +62,30 @@ func (s *osSys) GetEnvironmentVariable(name string) string {
 	return os.Getenv(name)
 }
 
+func (s *osSys) PnpApi() *pnp.PnpApi {
+	return s.pnpApi
+}
+
 func newSystem() *osSys {
 	cwd, err := os.Getwd()
 	if err != nil {
 		fmt.Fprintf(os.Stderr, "Error getting current directory: %v\n", err)
 		os.Exit(int(tsc.ExitStatusInvalidProject_OutputsSkipped))
 	}
 
+	var fs vfs.FS = osvfs.FS()
+
+	pnpApi := pnp.InitPnpApi(fs, tspath.NormalizePath(cwd))
+	if pnpApi != nil {
+		fs = pnpvfs.From(fs)
+	}
+
 	return &osSys{
 		cwd:                tspath.NormalizePath(cwd),
-		fs:                 bundled.WrapFS(osvfs.FS()),
+		fs:                 bundled.WrapFS(fs),
 		defaultLibraryPath: bundled.LibPath(),
 		writer:             os.Stdout,
 		start:              time.Now(),
+		pnpApi:             pnpApi,
 	}
 }

internal/api/server.go

@@ -15,10 +15,12 @@ import (
 	"github.com/microsoft/typescript-go/internal/bundled"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/lsp/lsproto"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/project"
 	"github.com/microsoft/typescript-go/internal/project/logging"
 	"github.com/microsoft/typescript-go/internal/vfs"
 	"github.com/microsoft/typescript-go/internal/vfs/osvfs"
+	"github.com/microsoft/typescript-go/internal/vfs/pnpvfs"
 )
 
 //go:generate go tool golang.org/x/tools/cmd/stringer -type=MessageType -output=stringer_generated.go
@@ -93,12 +95,19 @@ func NewServer(options *ServerOptions) *Server {
 		panic("Cwd is required")
 	}
 
+	var fs vfs.FS = osvfs.FS()
+
+	pnpApi := pnp.InitPnpApi(fs, options.Cwd)
+	if pnpApi != nil {
+		fs = pnpvfs.From(fs)
+	}
+
 	server := &Server{
 		r:                  bufio.NewReader(options.In),
 		w:                  bufio.NewWriter(options.Out),
 		stderr:             options.Err,
 		cwd:                options.Cwd,
-		fs:                 bundled.WrapFS(osvfs.FS()),
+		fs:                 bundled.WrapFS(fs),
 		defaultLibraryPath: options.DefaultLibraryPath,
 	}
 	logger := logging.NewLogger(options.Err)

internal/checker/checker_test.go

@@ -36,7 +36,7 @@ foo.bar;`
 	fs = bundled.WrapFS(fs)
 
 	cd := "/"
-	host := compiler.NewCompilerHost(cd, fs, bundled.LibPath(), nil, nil)
+	host := compiler.NewCompilerHost(cd, fs, bundled.LibPath(), nil, nil, nil)
 
 	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile("/tsconfig.json", &core.CompilerOptions{}, host, nil)
 	assert.Equal(t, len(errors), 0, "Expected no errors in parsed command line")
@@ -70,7 +70,7 @@ func TestCheckSrcCompiler(t *testing.T) {
 
 	rootPath := tspath.CombinePaths(tspath.NormalizeSlashes(repo.TypeScriptSubmodulePath), "src", "compiler")
 
-	host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil)
+	host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil, nil)
 	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), &core.CompilerOptions{}, host, nil)
 	assert.Equal(t, len(errors), 0, "Expected no errors in parsed command line")
 	p := compiler.NewProgram(compiler.ProgramOptions{
@@ -87,7 +87,7 @@ func BenchmarkNewChecker(b *testing.B) {
 
 	rootPath := tspath.CombinePaths(tspath.NormalizeSlashes(repo.TypeScriptSubmodulePath), "src", "compiler")
 
-	host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil)
+	host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil, nil)
 	parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), &core.CompilerOptions{}, host, nil)
 	assert.Equal(b, len(errors), 0, "Expected no errors in parsed command line")
 	p := compiler.NewProgram(compiler.ProgramOptions{

internal/compiler/emitHost.go

@@ -8,6 +8,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/module"
 	"github.com/microsoft/typescript-go/internal/modulespecifiers"
 	"github.com/microsoft/typescript-go/internal/outputpaths"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/printer"
 	"github.com/microsoft/typescript-go/internal/transformers/declarations"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
@@ -24,6 +25,7 @@ type EmitHost interface {
 	GetCurrentDirectory() string
 	CommonSourceDirectory() string
 	IsEmitBlocked(file string) bool
+	PnpApi() *pnp.PnpApi
 }
 
 var _ EmitHost = (*emitHost)(nil)
@@ -107,6 +109,7 @@ func (host *emitHost) Options() *core.CompilerOptions { return host.program.Opti
 func (host *emitHost) SourceFiles() []*ast.SourceFile { return host.program.SourceFiles() }
 func (host *emitHost) GetCurrentDirectory() string    { return host.program.GetCurrentDirectory() }
 func (host *emitHost) CommonSourceDirectory() string  { return host.program.CommonSourceDirectory() }
+func (host *emitHost) PnpApi() *pnp.PnpApi            { return host.program.PnpApi() }
 func (host *emitHost) UseCaseSensitiveFileNames() bool {
 	return host.program.UseCaseSensitiveFileNames()
 }

internal/compiler/host.go

@@ -4,6 +4,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/parser"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
 	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
@@ -17,6 +18,7 @@ type CompilerHost interface {
 	Trace(msg string)
 	GetSourceFile(opts ast.SourceFileParseOptions) *ast.SourceFile
 	GetResolvedProjectReference(fileName string, path tspath.Path) *tsoptions.ParsedCommandLine
+	PnpApi() *pnp.PnpApi
 }
 
 var _ CompilerHost = (*compilerHost)(nil)
@@ -27,34 +29,39 @@ type compilerHost struct {
 	defaultLibraryPath  string
 	extendedConfigCache tsoptions.ExtendedConfigCache
 	trace               func(msg string)
+	pnpApi              *pnp.PnpApi
 }
 
 func NewCachedFSCompilerHost(
 	currentDirectory string,
 	fs vfs.FS,
 	defaultLibraryPath string,
 	extendedConfigCache tsoptions.ExtendedConfigCache,
+	pnpApi *pnp.PnpApi,
 	trace func(msg string),
 ) CompilerHost {
-	return NewCompilerHost(currentDirectory, cachedvfs.From(fs), defaultLibraryPath, extendedConfigCache, trace)
+	return NewCompilerHost(currentDirectory, cachedvfs.From(fs), defaultLibraryPath, extendedConfigCache, pnpApi, trace)
 }
 
 func NewCompilerHost(
 	currentDirectory string,
 	fs vfs.FS,
 	defaultLibraryPath string,
 	extendedConfigCache tsoptions.ExtendedConfigCache,
+	pnpApi *pnp.PnpApi,
 	trace func(msg string),
 ) CompilerHost {
 	if trace == nil {
 		trace = func(msg string) {}
 	}
+
 	return &compilerHost{
 		currentDirectory:    currentDirectory,
 		fs:                  fs,
 		defaultLibraryPath:  defaultLibraryPath,
 		extendedConfigCache: extendedConfigCache,
 		trace:               trace,
+		pnpApi:              pnpApi,
 	}
 }
 
@@ -70,6 +77,10 @@ func (h *compilerHost) GetCurrentDirectory() string {
 	return h.currentDirectory
 }
 
+func (h *compilerHost) PnpApi() *pnp.PnpApi {
+	return h.pnpApi
+}
+
 func (h *compilerHost) Trace(msg string) {
 	h.trace(msg)
 }

internal/compiler/program.go

@@ -20,6 +20,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/modulespecifiers"
 	"github.com/microsoft/typescript-go/internal/outputpaths"
 	"github.com/microsoft/typescript-go/internal/parser"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/printer"
 	"github.com/microsoft/typescript-go/internal/scanner"
 	"github.com/microsoft/typescript-go/internal/sourcemap"
@@ -78,6 +79,11 @@ func (p *Program) GetCurrentDirectory() string {
 	return p.Host().GetCurrentDirectory()
 }
 
+// PnpApi implements checker.Program.
+func (p *Program) PnpApi() *pnp.PnpApi {
+	return p.Host().PnpApi()
+}
+
 // GetGlobalTypingsCacheLocation implements checker.Program.
 func (p *Program) GetGlobalTypingsCacheLocation() string {
 	return "" // !!! see src/tsserver/nodeServer.ts for strada's node-specific implementation

internal/compiler/program_test.go

@@ -243,7 +243,7 @@ func TestProgram(t *testing.T) {
 						CompilerOptions: &opts,
 					},
 				},
-				Host: compiler.NewCompilerHost("c:/dev/src", fs, bundled.LibPath(), nil, nil),
+				Host: compiler.NewCompilerHost("c:/dev/src", fs, bundled.LibPath(), nil, nil, nil),
 			})
 
 			actualFiles := []string{}
@@ -280,7 +280,7 @@ func BenchmarkNewProgram(b *testing.B) {
 						CompilerOptions: &opts,
 					},
 				},
-				Host: compiler.NewCompilerHost("c:/dev/src", fs, bundled.LibPath(), nil, nil),
+				Host: compiler.NewCompilerHost("c:/dev/src", fs, bundled.LibPath(), nil, nil, nil),
 			}
 
 			for b.Loop() {
@@ -297,7 +297,7 @@ func BenchmarkNewProgram(b *testing.B) {
 		fs := osvfs.FS()
 		fs = bundled.WrapFS(fs)
 
-		host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil)
+		host := compiler.NewCompilerHost(rootPath, fs, bundled.LibPath(), nil, nil, nil)
 
 		parsed, errors := tsoptions.GetParsedCommandLineOfConfigFile(tspath.CombinePaths(rootPath, "tsconfig.json"), nil, host, nil)
 		assert.Equal(b, len(errors), 0, "Expected no errors in parsed command line")

internal/compiler/projectreferencedtsfakinghost.go

@@ -7,6 +7,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/collections"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/module"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
 	"github.com/microsoft/typescript-go/internal/vfs/cachedvfs"
@@ -42,6 +43,11 @@ func (h *projectReferenceDtsFakingHost) GetCurrentDirectory() string {
 	return h.host.GetCurrentDirectory()
 }
 
+// PnpApi implements module.ResolutionHost.
+func (h *projectReferenceDtsFakingHost) PnpApi() *pnp.PnpApi {
+	return h.host.PnpApi()
+}
+
 type projectReferenceDtsFakingVfs struct {
 	projectReferenceFileMapper *projectReferenceFileMapper
 	dtsDirectories             collections.Set[tspath.Path]

internal/core/compileroptions.go

@@ -305,6 +305,13 @@ func (options *CompilerOptions) GetEffectiveTypeRoots(currentDirectory string) (
 	if options.TypeRoots != nil {
 		return options.TypeRoots, true
 	}
+	baseDir := options.GetBaseDirFromOptions(currentDirectory)
+
+	nmTypes, nmFromConfig := options.GetNodeModulesTypeRoots(baseDir)
+	return nmTypes, nmFromConfig
+}
+
+func (options *CompilerOptions) GetBaseDirFromOptions(currentDirectory string) string {
 	var baseDir string
 	if options.ConfigFilePath != "" {
 		baseDir = tspath.GetDirectoryPath(options.ConfigFilePath)
@@ -316,7 +323,10 @@ func (options *CompilerOptions) GetEffectiveTypeRoots(currentDirectory string) (
 			panic("cannot get effective type roots without a config file path or current directory")
 		}
 	}
+	return baseDir
+}
 
+func (options *CompilerOptions) GetNodeModulesTypeRoots(baseDir string) (result []string, fromConfig bool) {
 	typeRoots := make([]string, 0, strings.Count(baseDir, "/"))
 	tspath.ForEachAncestorDirectory(baseDir, func(dir string) (any, bool) {
 		typeRoots = append(typeRoots, tspath.CombinePaths(dir, "node_modules", "@types"))

internal/diagnostics/extraDiagnosticMessages.json

@@ -42,5 +42,41 @@
     "Project '{0}' is out of date because it has errors.": {
         "category": "Message",
         "code": 6423
+    },
+    "Your application tried to access '{0}'. While this module is usually interpreted as a Node builtin, your resolver is running inside a non-Node resolution context where such builtins are ignored. Since '{0}' isn't otherwise declared in your dependencies, this makes the require call ambiguous and unsound.\n\nRequired package: {0}{1}\nRequired by: {2}": {
+        "category": "Error",
+        "code": 110001
+    },
+    "{0} tried to access '{1}'. While this module is usually interpreted as a Node builtin, your resolver is running inside a non-Node resolution context where such builtins are ignored. Since '{1}' isn't otherwise declared in {0}'s dependencies, this makes the require call ambiguous and unsound.\n\nRequired package: {1}{2}\nRequired by: {3}": {
+        "category": "Error",
+        "code": 110002
+    },
+    "Your application tried to access '{0}', but it isn't declared in your dependencies; this makes the require call ambiguous and unsound.\n\nRequired package: {0}{1}\nRequired by: {2}": {
+        "category": "Error",
+        "code": 110003
+    },
+    "Your application tried to access '{0}' (a peer dependency); this isn't allowed as there is no ancestor to satisfy the requirement. Use a devDependency if needed.\n\nRequired package: {0}\nRequired by: {1}": {
+        "category": "Error",
+        "code": 110004
+    },
+    "{0} tried to access '{1}' (a peer dependency) but it isn't provided by its ancestors/your application; this makes the require call ambiguous and unsound.\n\nRequired package: {1}\nRequired by: {2}": {
+        "category": "Error",
+        "code": 110005
+    },
+    "no PnP manifest found": {
+        "category": "Error",
+        "code": 110006
+    },
+    "no package found for path '{0}'": {
+        "category": "Error",
+        "code": 110007
+    },
+    "Empty specifier: '{0}'": {
+        "category": "Error",
+        "code": 110008
+    },
+    "Invalid specifier: '{0}'": {
+        "category": "Error",
+        "code": 110009
     }
 }

internal/execute/build/compilerHost.go

@@ -3,6 +3,7 @@ package build
 import (
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/compiler"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/tsoptions"
 	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
@@ -27,6 +28,10 @@ func (h *compilerHost) GetCurrentDirectory() string {
 	return h.host.GetCurrentDirectory()
 }
 
+func (h *compilerHost) PnpApi() *pnp.PnpApi {
+	return h.host.PnpApi()
+}
+
 func (h *compilerHost) Trace(msg string) {
 	h.trace(msg)
 }