Typings Intaller initial work (#844)

Author: sheetalkamat

cmd/tsgo/lsp.go

@@ -4,11 +4,13 @@ import (
 	"flag"
 	"fmt"
 	"os"
+	"runtime"
 
 	"github.com/microsoft/typescript-go/internal/bundled"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/lsp"
 	"github.com/microsoft/typescript-go/internal/pprof"
+	"github.com/microsoft/typescript-go/internal/tspath"
 	"github.com/microsoft/typescript-go/internal/vfs/osvfs"
 )
 
@@ -37,6 +39,7 @@ func runLSP(args []string) int {
 
 	fs := bundled.WrapFS(osvfs.FS())
 	defaultLibraryPath := bundled.LibPath()
+	typingsLocation := getGlobalTypingsCacheLocation()
 
 	s := lsp.NewServer(&lsp.ServerOptions{
 		In:                 os.Stdin,
@@ -45,10 +48,78 @@ func runLSP(args []string) int {
 		Cwd:                core.Must(os.Getwd()),
 		FS:                 fs,
 		DefaultLibraryPath: defaultLibraryPath,
+		TypingsLocation:    typingsLocation,
 	})
 
 	if err := s.Run(); err != nil {
 		return 1
 	}
 	return 0
 }
+
+func getGlobalTypingsCacheLocation() string {
+	switch runtime.GOOS {
+	case "windows":
+		return tspath.CombinePaths(tspath.CombinePaths(getWindowsCacheLocation(), "Microsoft/TypeScript"), core.VersionMajorMinor())
+	case "openbsd", "freebsd", "netbsd", "darwin", "linux", "android":
+		return tspath.CombinePaths(tspath.CombinePaths(getNonWindowsCacheLocation(), "typescript"), core.VersionMajorMinor())
+	default:
+		panic("unsupported platform: " + runtime.GOOS)
+	}
+}
+
+func getWindowsCacheLocation() string {
+	basePath, err := os.UserCacheDir()
+	if err != nil {
+		if basePath, err = os.UserConfigDir(); err != nil {
+			if basePath, err = os.UserHomeDir(); err != nil {
+				if userProfile := os.Getenv("USERPROFILE"); userProfile != "" {
+					basePath = userProfile
+				} else if homeDrive, homePath := os.Getenv("HOMEDRIVE"), os.Getenv("HOMEPATH"); homeDrive != "" && homePath != "" {
+					basePath = homeDrive + homePath
+				} else {
+					basePath = os.TempDir()
+				}
+			}
+		}
+	}
+	return basePath
+}
+
+func getNonWindowsCacheLocation() string {
+	if xdgCacheHome := os.Getenv("XDG_CACHE_HOME"); xdgCacheHome != "" {
+		return xdgCacheHome
+	}
+	const platformIsDarwin = runtime.GOOS == "darwin"
+	var usersDir string
+	if platformIsDarwin {
+		usersDir = "Users"
+	} else {
+		usersDir = "home"
+	}
+	homePath, err := os.UserHomeDir()
+	if err != nil {
+		if home := os.Getenv("HOME"); home != "" {
+			homePath = home
+		} else {
+			var userName string
+			if logName := os.Getenv("LOGNAME"); logName != "" {
+				userName = logName
+			} else if user := os.Getenv("USER"); user != "" {
+				userName = user
+			}
+			if userName != "" {
+				homePath = "/" + usersDir + "/" + userName
+			} else {
+				homePath = os.TempDir()
+			}
+		}
+	}
+	var cacheFolder string
+	if platformIsDarwin {
+		cacheFolder = "Library/Caches"
+	} else {
+		cacheFolder = ".cache"
+	}
+	return tspath.CombinePaths(homePath, cacheFolder)
+}

internal/api/api.go

@@ -73,6 +73,11 @@ func (api *API) DefaultLibraryPath() string {
 	return api.host.DefaultLibraryPath()
 }
 
+// TypingsInstaller implements ProjectHost
+func (api *API) TypingsInstaller() *project.TypingsInstaller {
+	return nil
+}
+
 // DocumentRegistry implements ProjectHost.
 func (api *API) DocumentRegistry() *project.DocumentRegistry {
 	return api.documentRegistry

internal/compiler/program.go

@@ -28,6 +28,9 @@ type ProgramOptions struct {
 	ProjectReference             []core.ProjectReference
 	ConfigFileParsingDiagnostics []*ast.Diagnostic
 	CreateCheckerPool            func(*Program) CheckerPool
+
+	TypingsLocation string
+	ProjectName     string
 }
 
 type Program struct {
@@ -189,7 +192,7 @@ func NewProgram(options ProgramOptions) *Program {
 	// tracing?.push(tracing.Phase.Program, "createProgram", { configFilePath: options.configFilePath, rootDir: options.rootDir }, /*separateBeginAndEnd*/ true);
 	// performance.mark("beforeProgram");
 
-	p.resolver = module.NewResolver(p.host, p.compilerOptions)
+	p.resolver = module.NewResolver(p.host, p.compilerOptions, p.programOptions.TypingsLocation, p.programOptions.ProjectName)
 
 	var libs []string
 

internal/core/nodemodules.go

@@ -0,0 +1,88 @@
+package core
+
+import (
+	"maps"
+	"sync"
+)
+
+var UnprefixedNodeCoreModules = map[string]bool{
+	"assert":              true,
+	"assert/strict":       true,
+	"async_hooks":         true,
+	"buffer":              true,
+	"child_process":       true,
+	"cluster":             true,
+	"console":             true,
+	"constants":           true,
+	"crypto":              true,
+	"dgram":               true,
+	"diagnostics_channel": true,
+	"dns":                 true,
+	"dns/promises":        true,
+	"domain":              true,
+	"events":              true,
+	"fs":                  true,
+	"fs/promises":         true,
+	"http":                true,
+	"http2":               true,
+	"https":               true,
+	"inspector":           true,
+	"inspector/promises":  true,
+	"module":              true,
+	"net":                 true,
+	"os":                  true,
+	"path":                true,
+	"path/posix":          true,
+	"path/win32":          true,
+	"perf_hooks":          true,
+	"process":             true,
+	"punycode":            true,
+	"querystring":         true,
+	"readline":            true,
+	"readline/promises":   true,
+	"repl":                true,
+	"stream":              true,
+	"stream/consumers":    true,
+	"stream/promises":     true,
+	"stream/web":          true,
+	"string_decoder":      true,
+	"sys":                 true,
+	"test/mock_loader":    true,
+	"timers":              true,
+	"timers/promises":     true,
+	"tls":                 true,
+	"trace_events":        true,
+	"tty":                 true,
+	"url":                 true,
+	"util":                true,
+	"util/types":          true,
+	"v8":                  true,
+	"vm":                  true,
+	"wasi":                true,
+	"worker_threads":      true,
+	"zlib":                true,
+}
+
+var ExclusivelyPrefixedNodeCoreModules = map[string]bool{
+	"node:sea":            true,
+	"node:sqlite":         true,
+	"node:test":           true,
+	"node:test/reporters": true,
+}
+
+var nodeCoreModules = sync.OnceValue(func() map[string]bool {
+	nodeCoreModules := make(map[string]bool, len(UnprefixedNodeCoreModules)*2+len(ExclusivelyPrefixedNodeCoreModules))
+	for unprefixed := range UnprefixedNodeCoreModules {
+		nodeCoreModules[unprefixed] = true
+		nodeCoreModules["node:"+unprefixed] = true
+	}
+	maps.Copy(nodeCoreModules, ExclusivelyPrefixedNodeCoreModules)
+	return nodeCoreModules
+})
+
+func NonRelativeModuleNameForTypingCache(moduleName string) string {
+	if nodeCoreModules()[moduleName] {
+		return "node"
+	}
+	return moduleName
+}

internal/ls/completions_test.go

@@ -2029,7 +2029,7 @@ func assertIncludesItem(t *testing.T, actual *lsproto.CompletionList, expected *
 }
 
 func createLanguageService(ctx context.Context, fileName string, files map[string]any) (*ls.LanguageService, func()) {
-	projectService, _ := projecttestutil.Setup(files)
+	projectService, _ := projecttestutil.Setup(files, nil)
 	projectService.OpenFile(fileName, files[fileName].(string), core.ScriptKindTS, "")
 	project := projectService.Projects()[0]
 	return project.GetLanguageServiceForRequest(ctx)

internal/lsp/server.go

@@ -30,6 +30,7 @@ type ServerOptions struct {
 	NewLine            core.NewLineKind
 	FS                 vfs.FS
 	DefaultLibraryPath string
+	TypingsLocation    string
 }
 
 func NewServer(opts *ServerOptions) *Server {
@@ -48,6 +49,7 @@ func NewServer(opts *ServerOptions) *Server {
 		newLine:               opts.NewLine,
 		fs:                    opts.FS,
 		defaultLibraryPath:    opts.DefaultLibraryPath,
+		typingsLocation:       opts.TypingsLocation,
 	}
 }
 
@@ -79,6 +81,7 @@ type Server struct {
 	newLine            core.NewLineKind
 	fs                 vfs.FS
 	defaultLibraryPath string
+	typingsLocation    string
 
 	initializeParams *lsproto.InitializeParams
 	positionEncoding lsproto.PositionEncodingKind
@@ -100,6 +103,11 @@ func (s *Server) DefaultLibraryPath() string {
 	return s.defaultLibraryPath
 }
 
+// TypingsLocation implements project.ServiceHost.
+func (s *Server) TypingsLocation() string {
+	return s.typingsLocation
+}
+
 // GetCurrentDirectory implements project.ServiceHost.
 func (s *Server) GetCurrentDirectory() string {
 	return s.cwd
@@ -477,6 +485,10 @@ func (s *Server) handleInitialized(ctx context.Context, req *lsproto.RequestMess
 		Logger:           s.logger,
 		WatchEnabled:     s.watchEnabled,
 		PositionEncoding: s.positionEncoding,
+		TypingsInstallerOptions: project.TypingsInstallerOptions{
+			ThrottleLimit: 5,
+			NpmInstall:    project.NpmInstall,
+		},
 	})
 
 	return nil

internal/module/resolver.go

@@ -109,17 +109,23 @@ type Resolver struct {
 	caches
 	host            ResolutionHost
 	compilerOptions *core.CompilerOptions
+	typingsLocation string
+	projectName     string
 	// reportDiagnostic: DiagnosticReporter
 }
 
 func NewResolver(
 	host ResolutionHost,
 	options *core.CompilerOptions,
+	typingsLocation string,
+	projectName string,
 ) *Resolver {
 	return &Resolver{
 		host:            host,
 		caches:          newCaches(host.GetCurrentDirectory(), host.FS().UseCaseSensitiveFileNames(), options),
 		compilerOptions: options,
+		typingsLocation: typingsLocation,
+		projectName:     projectName,
 	}
 }
 
@@ -229,6 +235,36 @@ func (r *Resolver) ResolveModuleName(moduleName string, containingFile string, r
 		}
 	}
 
+	return r.tryResolveFromTypingsLocation(moduleName, containingDirectory, result)
+}
+
+func (r *Resolver) tryResolveFromTypingsLocation(moduleName string, containingDirectory string, originalResult *ResolvedModule) *ResolvedModule {
+	if r.typingsLocation == "" ||
+		tspath.IsExternalModuleNameRelative(moduleName) ||
+		(originalResult.ResolvedFileName != "" && tspath.ExtensionIsOneOf(originalResult.Extension, tspath.SupportedTSExtensionsWithJsonFlat)) {
+		return originalResult
+	}
+
+	state := newResolutionState(
+		moduleName,
+		containingDirectory,
+		false,               /*isTypeReferenceDirective*/
+		core.ModuleKindNone, // resolutionMode,
+		r.compilerOptions,
+		nil, // redirectedReference,
+		r,
+	)
+	if r.traceEnabled() {
+		r.host.Trace(diagnostics.Auto_discovery_for_typings_is_enabled_in_project_0_Running_extra_resolution_pass_for_module_1_using_cache_location_2.Format(r.projectName, moduleName, r.typingsLocation))
+	}
+	globalResolved := state.loadModuleFromImmediateNodeModulesDirectory(extensionsDeclaration, r.typingsLocation, false)
+	if globalResolved == nil {
+		return originalResult
+	}
+	result := state.createResolvedModule(globalResolved, true)
+	result.FailedLookupLocations = append(originalResult.FailedLookupLocations, result.FailedLookupLocations...)
+	result.AffectingLocations = append(originalResult.AffectingLocations, result.AffectingLocations...)
+	result.ResolutionDiagnostics = append(originalResult.ResolutionDiagnostics, result.ResolutionDiagnostics...)
 	return result
 }
 
@@ -1718,7 +1754,7 @@ func extensionIsOk(extensions extensions, extension string) bool {
 }
 
 func ResolveConfig(moduleName string, containingFile string, host ResolutionHost) *ResolvedModule {
-	resolver := NewResolver(host, &core.CompilerOptions{ModuleResolution: core.ModuleResolutionKindNodeNext})
+	resolver := NewResolver(host, &core.CompilerOptions{ModuleResolution: core.ModuleResolutionKindNodeNext}, "", "")
 	return resolver.resolveConfig(moduleName, containingFile)
 }
 

internal/module/resolver_test.go

@@ -280,7 +280,7 @@ func runTraceBaseline(t *testing.T, test traceTestCase) {
 		t.Parallel()
 
 		host := newVFSModuleResolutionHost(test.files, test.currentDirectory)
-		resolver := module.NewResolver(host, test.compilerOptions)
+		resolver := module.NewResolver(host, test.compilerOptions, "", "")
 
 		for _, call := range test.calls {
 			doCall(t, resolver, call, false /*skipLocations*/)
@@ -291,7 +291,7 @@ func runTraceBaseline(t *testing.T, test traceTestCase) {
 
 		t.Run("concurrent", func(t *testing.T) {
 			concurrentHost := newVFSModuleResolutionHost(test.files, test.currentDirectory)
-			concurrentResolver := module.NewResolver(concurrentHost, test.compilerOptions)
+			concurrentResolver := module.NewResolver(concurrentHost, test.compilerOptions, "", "")
 
 			var wg sync.WaitGroup
 			for _, call := range test.calls {

internal/packagejson/packagejson.go

@@ -22,6 +22,7 @@ type PathFields struct {
 
 type DependencyFields struct {
 	Dependencies         Expected[map[string]string] `json:"dependencies"`
+	DevDependencies      Expected[map[string]string] `json:"devDependencies"`
 	PeerDependencies     Expected[map[string]string] `json:"peerDependencies"`
 	OptionalDependencies Expected[map[string]string] `json:"optionalDependencies"`
 }