[WIP] Implement 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"
 )
 
@@ -66,9 +68,16 @@ func newSystem() *osSys {
 		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(),

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/core/compileroptions.go

@@ -6,6 +6,7 @@ import (
 	"sync"
 
 	"github.com/microsoft/typescript-go/internal/collections"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/tspath"
 )
 
@@ -322,6 +323,14 @@ func (options *CompilerOptions) GetEffectiveTypeRoots(currentDirectory string) (
 		}
 	}
 
+	nmTypes, nmFromConfig := options.GetNodeModulesTypeRoots(baseDir)
+
+	typeRoots, nmFromConfig := pnp.AppendPnpTypeRoots(nmTypes, baseDir, nmFromConfig)
+
+	return typeRoots, nmFromConfig
+}
+
+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/ls/autoimports.go

@@ -18,6 +18,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/module"
 	"github.com/microsoft/typescript-go/internal/modulespecifiers"
 	"github.com/microsoft/typescript-go/internal/packagejson"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/stringutil"
 	"github.com/microsoft/typescript-go/internal/tspath"
 )
@@ -418,6 +419,11 @@ func (l *LanguageService) isImportable(
 	// }
 
 	fromPath := fromFile.FileName()
+	pnpApi := pnp.GetPnpApi(fromPath)
+	if pnpApi != nil {
+		return pnpApi.IsImportable(fromPath, toFile.FileName())
+	}
+
 	useCaseSensitiveFileNames := moduleSpecifierResolutionHost.UseCaseSensitiveFileNames()
 	globalTypingsCache := l.GetProgram().GetGlobalTypingsCacheLocation()
 	modulePaths := modulespecifiers.GetEachFileNameOfModule(

internal/ls/converters.go

@@ -128,7 +128,14 @@ func FileNameToDocumentURI(fileName string) lsproto.DocumentUri {
 		parts[i] = extraEscapeReplacer.Replace(url.PathEscape(part))
 	}
 
-	return lsproto.DocumentUri("file://" + volume + strings.Join(parts, "/"))
+	var prefix string
+	if tspath.IsZipPath(fileName) {
+		prefix = "zip:"
+	} else {
+		prefix = "file:"
+	}
+
+	return lsproto.DocumentUri(prefix + "//" + volume + strings.Join(parts, "/"))
 }
 
 func (c *Converters) LineAndCharacterToPosition(script Script, lineAndCharacter lsproto.Position) core.TextPos {

internal/ls/converters_test.go

@@ -31,6 +31,9 @@ func TestDocumentURIToFileName(t *testing.T) {
 		{"file://localhost/c%24/GitDevelopment/express", "//localhost/c$/GitDevelopment/express"},
 		{"file:///c%3A/test%20with%20%2525/c%23code", "c:/test with %25/c#code"},
 
+		{"zip:///path/to/archive.zip/file.ts", "/path/to/archive.zip/file.ts"},
+		{"zip:///d:/work/tsgo932/lib/archive.zip/utils.ts", "d:/work/tsgo932/lib/archive.zip/utils.ts"},
+
 		{"untitled:Untitled-1", "^/untitled/ts-nul-authority/Untitled-1"},
 		{"untitled:Untitled-1#fragment", "^/untitled/ts-nul-authority/Untitled-1#fragment"},
 		{"untitled:c:/Users/jrieken/Code/abc.txt", "^/untitled/ts-nul-authority/c:/Users/jrieken/Code/abc.txt"},
@@ -69,6 +72,9 @@ func TestFileNameToDocumentURI(t *testing.T) {
 		{"//localhost/c$/GitDevelopment/express", "file://localhost/c%24/GitDevelopment/express"},
 		{"c:/test with %25/c#code", "file:///c%3A/test%20with%20%2525/c%23code"},
 
+		{"/path/to/archive.zip/file.ts", "zip:///path/to/archive.zip/file.ts"},
+		{"d:/work/tsgo932/lib/archive.zip/utils.ts", "zip:///d%3A/work/tsgo932/lib/archive.zip/utils.ts"},
+
 		{"^/untitled/ts-nul-authority/Untitled-1", "untitled:Untitled-1"},
 		{"^/untitled/ts-nul-authority/c:/Users/jrieken/Code/abc.txt", "untitled:c:/Users/jrieken/Code/abc.txt"},
 		{"^/untitled/ts-nul-authority///wsl%2Bubuntu/home/jabaile/work/TypeScript-go/newfile.ts", "untitled://wsl%2Bubuntu/home/jabaile/work/TypeScript-go/newfile.ts"},

internal/ls/string_completions.go

@@ -522,6 +522,7 @@ func getStringLiteralCompletionsFromModuleNames(
 	program *compiler.Program,
 ) *stringLiteralCompletions {
 	// !!! needs `getModeForUsageLocationWorker`
+	// TODO investigate if we will need to update this for pnp, once available
 	return nil
 }
 

internal/lsp/lsproto/lsp.go

@@ -14,7 +14,7 @@ import (
 type DocumentUri string // !!!
 
 func (uri DocumentUri) FileName() string {
-	if strings.HasPrefix(string(uri), "file://") {
+	if strings.HasPrefix(string(uri), "file://") || strings.HasPrefix(string(uri), "zip:") {
 		parsed := core.Must(url.Parse(string(uri)))
 		if parsed.Host != "" {
 			return "//" + parsed.Host + parsed.Path

internal/lsp/server.go

@@ -16,11 +16,13 @@ import (
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/ls"
 	"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/ata"
 	"github.com/microsoft/typescript-go/internal/project/logging"
 	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs"
+	"github.com/microsoft/typescript-go/internal/vfs/pnpvfs"
 	"golang.org/x/sync/errgroup"
 	"golang.org/x/text/language"
 )
@@ -699,6 +701,12 @@ func (s *Server) handleInitialized(ctx context.Context, params *lsproto.Initiali
 		cwd = s.cwd
 	}
 
+	fs := s.fs
+	pnpApi := pnp.InitPnpApi(fs, cwd)
+	if pnpApi != nil {
+		fs = pnpvfs.From(fs)
+	}
+
 	s.session = project.NewSession(&project.SessionInit{
 		Options: &project.SessionOptions{
 			CurrentDirectory:   cwd,
@@ -709,7 +717,7 @@ func (s *Server) handleInitialized(ctx context.Context, params *lsproto.Initiali
 			LoggingEnabled:     true,
 			DebounceDelay:      500 * time.Millisecond,
 		},
-		FS:          s.fs,
+		FS:          fs,
 		Logger:      s.logger,
 		Client:      s,
 		NpmExecutor: s,

internal/module/resolver.go

@@ -11,6 +11,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/diagnostics"
 	"github.com/microsoft/typescript-go/internal/packagejson"
+	"github.com/microsoft/typescript-go/internal/pnp"
 	"github.com/microsoft/typescript-go/internal/semver"
 	"github.com/microsoft/typescript-go/internal/tspath"
 )
@@ -475,7 +476,7 @@ func (r *resolutionState) resolveNodeLikeWorker() *ResolvedModule {
 		resolved := r.nodeLoadModuleByRelativeName(r.extensions, candidate, false, true)
 		return r.createResolvedModule(
 			resolved,
-			resolved != nil && strings.Contains(resolved.path, "/node_modules/"),
+			resolved != nil && (tspath.IsExternalLibraryImport(resolved.path)),
 		)
 	}
 	return r.createResolvedModule(nil, false)
@@ -914,6 +915,12 @@ func (r *resolutionState) loadModuleFromNearestNodeModulesDirectory(typesScopeOn
 }
 
 func (r *resolutionState) loadModuleFromNearestNodeModulesDirectoryWorker(ext extensions, mode core.ResolutionMode, typesScopeOnly bool) *resolved {
+	pnpApi := pnp.GetPnpApi(r.containingDirectory)
+	if pnpApi != nil {
+		// !!! stop at global cache
+		return r.loadModuleFromImmediateNodeModulesDirectoryPnP(ext, r.containingDirectory, typesScopeOnly)
+	}
+
 	result, _ := tspath.ForEachAncestorDirectory(
 		r.containingDirectory,
 		func(directory string) (result *resolved, stop bool) {
@@ -953,11 +960,52 @@ func (r *resolutionState) loadModuleFromImmediateNodeModulesDirectory(extensions
 	return continueSearching()
 }
 
+/*
+With Plug and Play, we directly resolve the path of the moduleName using the PnP API, instead of searching for it in the node_modules directory
+
+See github.com/microsoft/typescript-go/internal/pnp package for more details
+*/
+func (r *resolutionState) loadModuleFromImmediateNodeModulesDirectoryPnP(extensions extensions, directory string, typesScopeOnly bool) *resolved {
+	if !typesScopeOnly {
+		if packageResult := r.loadModuleFromPnpResolution(extensions, r.name, directory); !packageResult.shouldContinueSearching() {
+			return packageResult
+		}
+	}
+
+	if extensions&extensionsDeclaration != 0 {
+		result := r.loadModuleFromPnpResolution(extensionsDeclaration, "@types/"+r.mangleScopedPackageName(r.name), directory)
+
+		return result
+	}
+
+	return nil
+}
+
+func (r *resolutionState) loadModuleFromPnpResolution(ext extensions, moduleName string, issuer string) *resolved {
+	pnpApi := pnp.GetPnpApi(issuer)
+
+	if pnpApi != nil {
+		packageName, rest := ParsePackageName(moduleName)
+		// TODO: bubble up yarn resolution errors, instead of _
+		packageDirectory, _ := pnpApi.ResolveToUnqualified(packageName, issuer)
+		if packageDirectory != "" {
+			candidate := tspath.NormalizePath(tspath.CombinePaths(packageDirectory, rest))
+			return r.loadModuleFromSpecificNodeModulesDirectoryImpl(ext, true /* nodeModulesDirectoryExists */, candidate, rest, packageDirectory)
+		}
+	}
+
+	return nil
+}
+
 func (r *resolutionState) loadModuleFromSpecificNodeModulesDirectory(ext extensions, moduleName string, nodeModulesDirectory string, nodeModulesDirectoryExists bool) *resolved {
 	candidate := tspath.NormalizePath(tspath.CombinePaths(nodeModulesDirectory, moduleName))
 	packageName, rest := ParsePackageName(moduleName)
 	packageDirectory := tspath.CombinePaths(nodeModulesDirectory, packageName)
 
+	return r.loadModuleFromSpecificNodeModulesDirectoryImpl(ext, nodeModulesDirectoryExists, candidate, rest, packageDirectory)
+}
+
+func (r *resolutionState) loadModuleFromSpecificNodeModulesDirectoryImpl(ext extensions, nodeModulesDirectoryExists bool, candidate string, rest string, packageDirectory string) *resolved {
 	var rootPackageInfo *packagejson.InfoCacheEntry
 	// First look for a nested package.json, as in `node_modules/foo/bar/package.json`
 	packageInfo := r.getPackageJsonInfo(candidate, !nodeModulesDirectoryExists)
@@ -1036,7 +1084,7 @@ func (r *resolutionState) loadModuleFromSpecificNodeModulesDirectory(ext extensi
 }
 
 func (r *resolutionState) createResolvedModuleHandlingSymlink(resolved *resolved) *ResolvedModule {
-	isExternalLibraryImport := resolved != nil && strings.Contains(resolved.path, "/node_modules/")
+	isExternalLibraryImport := resolved != nil && (tspath.IsExternalLibraryImport(resolved.path))
 	if r.compilerOptions.PreserveSymlinks != core.TSTrue &&
 		isExternalLibraryImport &&
 		resolved.originalPath == "" &&
@@ -1084,7 +1132,7 @@ func (r *resolutionState) createResolvedTypeReferenceDirective(resolved *resolve
 		resolvedTypeReferenceDirective.ResolvedFileName = resolved.path
 		resolvedTypeReferenceDirective.Primary = primary
 		resolvedTypeReferenceDirective.PackageId = resolved.packageId
-		resolvedTypeReferenceDirective.IsExternalLibraryImport = strings.Contains(resolved.path, "/node_modules/")
+		resolvedTypeReferenceDirective.IsExternalLibraryImport = tspath.IsExternalLibraryImport(resolved.path)
 
 		if r.compilerOptions.PreserveSymlinks != core.TSTrue {
 			originalPath, resolvedFileName := r.getOriginalAndResolvedFileName(resolved.path)
@@ -1740,8 +1788,19 @@ func (r *resolutionState) readPackageJsonPeerDependencies(packageJsonInfo *packa
 	}
 	nodeModules := packageDirectory[:nodeModulesIndex+len("/node_modules")] + "/"
 	builder := strings.Builder{}
+	pnpApi := pnp.GetPnpApi(packageJsonInfo.PackageDirectory)
 	for name := range peerDependencies.Value {
-		peerPackageJson := r.getPackageJsonInfo(nodeModules+name /*onlyRecordFailures*/, false)
+		var peerDependencyPath string
+
+		if pnpApi != nil {
+			peerDependencyPath, _ = pnpApi.ResolveToUnqualified(name, packageDirectory)
+		}
+
+		if peerDependencyPath == "" {
+			peerDependencyPath = nodeModules + name
+		}
+
+		peerPackageJson := r.getPackageJsonInfo(peerDependencyPath, false /*onlyRecordFailures*/)
 		if peerPackageJson != nil {
 			version := peerPackageJson.Contents.Version.Value
 			builder.WriteString("+")