Use package.json locations for build up-to-date checks (#4301)

Co-authored-by: Sheetal Nandi <shkamat@microsoft.com>

Author: jakebailey

internal/compiler/program.go

@@ -152,6 +152,11 @@ func (p *Program) GetPackageJsonInfo(pkgJsonPath string) *packagejson.InfoCacheE
 	return nil
 }
 
+// PackageJsonCacheEntries iterates on all package json cache entries.
+func (p *Program) PackageJsonCacheEntries(f func(key tspath.Path, value *packagejson.InfoCacheEntry) bool) {
+	p.resolver.PackageJsonCacheEntries(f)
+}
+
 // GetRedirectTargets returns the list of file paths that redirect to the given path.
 // These are files from the same package (same name@version) installed in different locations.
 func (p *Program) GetRedirectTargets(path tspath.Path) []string {

internal/execute/build/buildtask.go

@@ -2,6 +2,7 @@ package build
 
 import (
 	"fmt"
+	"slices"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -63,6 +64,7 @@ type BuildTask struct {
 
 	buildInfoEntry   *buildInfoEntry
 	buildInfoEntryMu sync.Mutex
+	packageJsons     []string
 
 	errors             []*ast.Diagnostic
 	pending            atomic.Bool
@@ -231,6 +233,7 @@ func (t *BuildTask) compileAndEmit(orchestrator *Orchestrator, path tspath.Path)
 	})
 	t.result.exitStatus = result.Status
 	t.result.statistics = statistics
+	t.packageJsons = t.result.program.PackageJsonLookupPaths()
 	if (!program.Options().NoEmitOnError.IsTrue() || len(result.Diagnostics) == 0) &&
 		(len(result.EmitResult.EmittedFiles) > 0 || t.status.kind != upToDateStatusTypeOutOfDateBuildInfoWithErrors) {
 		// Update time stamps for rest of the outputs
@@ -327,6 +330,9 @@ func (t *BuildTask) getUpToDateStatus(orchestrator *Orchestrator, configPath tsp
 
 	// Check the build info
 	buildInfoPath := t.resolved.GetBuildInfoFileName()
+	getBuildInfoDirectory := core.Memoize(func() string {
+		return tspath.GetDirectoryPath(tspath.GetNormalizedAbsolutePath(buildInfoPath, orchestrator.comparePathsOptions.CurrentDirectory))
+	})
 	buildInfo, buildInfoTime := t.loadOrStoreBuildInfo(orchestrator, configPath, buildInfoPath)
 	if buildInfo == nil {
 		return &upToDateStatus{kind: upToDateStatusTypeOutputMissing, data: buildInfoPath}
@@ -363,15 +369,17 @@ func (t *BuildTask) getUpToDateStatus(orchestrator *Orchestrator, configPath tsp
 		}
 
 		// Some of the emit files like source map or dts etc are not yet done
-		if buildInfo.IsEmitPending(t.resolved, tspath.GetDirectoryPath(tspath.GetNormalizedAbsolutePath(buildInfoPath, orchestrator.comparePathsOptions.CurrentDirectory))) {
+		if buildInfo.IsEmitPending(t.resolved, getBuildInfoDirectory()) {
 			return &upToDateStatus{kind: upToDateStatusTypeOutOfDateOptions, data: buildInfoPath}
 		}
 	}
 	var inputTextUnchanged bool
 	oldestOutputFileAndTime := fileAndTime{buildInfoPath, buildInfoTime}
 	var newestInputFileAndTime fileAndTime
 	var seenRoots collections.Set[tspath.Path]
-	var buildInfoRootInfoReader *incremental.BuildInfoRootInfoReader
+	getBuildInfoRootInfoReader := core.Memoize(func() *incremental.BuildInfoRootInfoReader {
+		return buildInfo.GetBuildInfoRootInfoReader(getBuildInfoDirectory(), orchestrator.comparePathsOptions)
+	})
 	for _, inputFile := range t.resolved.FileNames() {
 		inputTime := orchestrator.host.GetMTime(inputFile)
 		if inputTime.IsZero() {
@@ -382,10 +390,7 @@ func (t *BuildTask) getUpToDateStatus(orchestrator *Orchestrator, configPath tsp
 			var version string
 			var currentVersion string
 			if buildInfo.IsIncremental() {
-				if buildInfoRootInfoReader == nil {
-					buildInfoRootInfoReader = buildInfo.GetBuildInfoRootInfoReader(tspath.GetDirectoryPath(tspath.GetNormalizedAbsolutePath(buildInfoPath, orchestrator.comparePathsOptions.CurrentDirectory)), orchestrator.comparePathsOptions)
-				}
-				buildInfoFileInfo, resolvedInputPath := buildInfoRootInfoReader.GetBuildInfoFileInfo(inputPath)
+				buildInfoFileInfo, resolvedInputPath := getBuildInfoRootInfoReader().GetBuildInfoFileInfo(inputPath)
 				if fileInfo := buildInfoFileInfo.GetFileInfo(); fileInfo != nil && fileInfo.Version() != "" {
 					version = fileInfo.Version()
 					if text, ok := orchestrator.host.FS().ReadFile(string(resolvedInputPath)); ok {
@@ -407,16 +412,54 @@ func (t *BuildTask) getUpToDateStatus(orchestrator *Orchestrator, configPath tsp
 		seenRoots.Add(inputPath)
 	}
 
-	if buildInfoRootInfoReader == nil {
-		buildInfoRootInfoReader = buildInfo.GetBuildInfoRootInfoReader(tspath.GetDirectoryPath(tspath.GetNormalizedAbsolutePath(buildInfoPath, orchestrator.comparePathsOptions.CurrentDirectory)), orchestrator.comparePathsOptions)
-	}
-	for root := range buildInfoRootInfoReader.Roots() {
+	for root := range getBuildInfoRootInfoReader().Roots() {
 		if !seenRoots.Has(root) {
 			// File was root file when project was built but its not any more
 			return &upToDateStatus{kind: upToDateStatusTypeOutOfDateRoots, data: &inputOutputName{string(root), buildInfoPath}}
 		}
 	}
 
+	if buildInfo.IsIncremental() {
+		var resolvedRoots collections.Set[tspath.Path]
+		for root := range getBuildInfoRootInfoReader().Roots() {
+			if _, resolved := getBuildInfoRootInfoReader().GetBuildInfoFileInfo(root); resolved != "" {
+				resolvedRoots.Add(resolved)
+			}
+		}
+		for index, buildInfoFileInfo := range buildInfo.FileInfos {
+			buildInfoFileName := buildInfo.FileNames[index]
+			// Lib files bundled with the compiler can change only with the version of the compiler,
+			// which is already verified with buildInfo.Version
+			if incremental.IsBuildInfoFileNameDefaultLibrary(buildInfoFileName) {
+				continue
+			}
+			inputFile := tspath.GetNormalizedAbsolutePath(buildInfoFileName, getBuildInfoDirectory())
+			inputPath := orchestrator.toPath(inputFile)
+			// Root files are already checked
+			if seenRoots.Has(inputPath) || resolvedRoots.Has(inputPath) {
+				continue
+			}
+			inputTime := orchestrator.host.GetMTime(inputFile)
+			if inputTime.IsZero() {
+				// Input file that was part of the program is missing (eg: dependency was removed)
+				return &upToDateStatus{kind: upToDateStatusTypeInputFileMissing, data: inputFile}
+			}
+			if inputTime.After(oldestOutputFileAndTime.time) {
+				var currentVersion string
+				version := buildInfoFileInfo.GetFileInfo().Version()
+				if version != "" {
+					if text, ok := orchestrator.host.FS().ReadFile(inputFile); ok {
+						currentVersion = incremental.ComputeHash(text, orchestrator.opts.Testing != nil)
+					}
+				}
+				if version == "" || version != currentVersion {
+					return &upToDateStatus{kind: upToDateStatusTypeInputFileNewer, data: &inputOutputName{inputFile, buildInfoPath}}
+				}
+				inputTextUnchanged = true
+			}
+		}
+	}
+
 	if !t.resolved.CompilerOptions().IsIncremental() {
 		// Check output file stamps
 		for outputFile := range t.resolved.GetOutputFileNames() {
@@ -493,14 +536,22 @@ func (t *BuildTask) getUpToDateStatus(orchestrator *Orchestrator, configPath tsp
 		}
 	}
 
-	// !!! sheetal TODO : watch??
-	// // Check package file time
-	// const packageJsonLookups = state.lastCachedPackageJsonLookups.get(resolvedPath);
-	// const dependentPackageFileStatus = packageJsonLookups && forEachKey(
-	//     packageJsonLookups,
-	//     path => checkConfigFileUpToDateStatus(state, path, oldestOutputFileTime, oldestOutputFileName),
-	// );
-	// if (dependentPackageFileStatus) return dependentPackageFileStatus;
+	for packageJson := range buildInfo.GetPackageJsons(getBuildInfoDirectory()) {
+		packageJsonTime := orchestrator.host.GetMTime(packageJson)
+		if packageJsonTime.IsZero() {
+			return &upToDateStatus{kind: upToDateStatusTypeInputFileMissing, data: packageJson}
+		}
+		if packageJsonTime.After(oldestOutputFileAndTime.time) {
+			return &upToDateStatus{kind: upToDateStatusTypeInputFileNewer, data: &inputOutputName{packageJson, oldestOutputFileAndTime.file}}
+		}
+	}
+	for packageJson := range buildInfo.GetMissingPackageJsons(getBuildInfoDirectory()) {
+		if !orchestrator.host.GetMTime(packageJson).IsZero() {
+			return &upToDateStatus{kind: upToDateStatusTypeInputFileNewer, data: &inputOutputName{packageJson, oldestOutputFileAndTime.file}}
+		}
+	}
+	t.packageJsons = slices.Collect(buildInfo.GetPackageJsons(getBuildInfoDirectory()))
+	t.packageJsons = append(t.packageJsons, slices.Collect(buildInfo.GetMissingPackageJsons(getBuildInfoDirectory()))...)
 
 	return &upToDateStatus{
 		kind: core.IfElse(

internal/execute/build/orchestrator.go

@@ -14,6 +14,7 @@ import (
 	"github.com/microsoft/typescript-go/internal/compiler"
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/diagnostics"
+	"github.com/microsoft/typescript-go/internal/execute/incremental"
 	"github.com/microsoft/typescript-go/internal/execute/tsc"
 	"github.com/microsoft/typescript-go/internal/execute/watchmanager"
 	"github.com/microsoft/typescript-go/internal/fswatch"
@@ -86,7 +87,7 @@ func (o *Orchestrator) toPath(fileName string) tspath.Path {
 }
 
 func (o *Orchestrator) resolveBuildInfoFileName(fileName string, buildInfoDir string) string {
-	if !strings.HasPrefix(fileName, ".") {
+	if incremental.IsBuildInfoFileNameDefaultLibrary(fileName) {
 		return tspath.CombinePaths(o.host.DefaultLibraryPath(), fileName)
 	}
 	return tspath.GetNormalizedAbsolutePath(fileName, buildInfoDir)
@@ -279,9 +280,9 @@ func (o *Orchestrator) resetCaches() {
 }
 
 func (o *Orchestrator) checkTasksForEventChanges(changedPaths map[string]fswatch.EventKind, needsConfigUpdate, needsUpdate *atomic.Bool) {
-	normalizedPaths := make(map[tspath.Path]struct{}, len(changedPaths))
-	for eventPath := range changedPaths {
-		normalizedPaths[o.toPath(eventPath)] = struct{}{}
+	normalizedPaths := make(map[tspath.Path]fswatch.EventKind, len(changedPaths))
+	for eventPath, kind := range changedPaths {
+		normalizedPaths[o.toPath(eventPath)] = kind
 	}
 
 	for i := range o.order {
@@ -348,6 +349,27 @@ func (o *Orchestrator) checkTasksForEventChanges(changedPaths map[string]fswatch
 						break
 					}
 				}
+				for packageJson := range bi.buildInfo.GetPackageJsons(buildInfoDir) {
+					if o.packageJsonLookupChanged(packageJson, normalizedPaths) {
+						task.resetStatus()
+						needsUpdate.Store(true)
+						break
+					}
+				}
+				for packageJson := range bi.buildInfo.GetMissingPackageJsons(buildInfoDir) {
+					if o.packageJsonLookupChanged(packageJson, normalizedPaths) {
+						task.resetStatus()
+						needsUpdate.Store(true)
+						break
+					}
+				}
+			}
+			for _, packageJson := range task.packageJsons {
+				if o.packageJsonLookupChanged(packageJson, normalizedPaths) {
+					task.resetStatus()
+					needsUpdate.Store(true)
+					break
+				}
 			}
 		}
 
@@ -381,6 +403,19 @@ func (o *Orchestrator) checkTasksForEventChanges(changedPaths map[string]fswatch
 	}
 }
 
+func (o *Orchestrator) packageJsonLookupChanged(packageJson string, changedPaths map[tspath.Path]fswatch.EventKind) bool {
+	packageJsonPath := o.toPath(packageJson)
+	if _, changed := changedPaths[packageJsonPath]; changed {
+		return true
+	}
+	for changedPath, kind := range changedPaths {
+		if kind == fswatch.EventDelete && tspath.ContainsPath(string(changedPath), string(packageJsonPath), o.comparePathsOptions) {
+			return true
+		}
+	}
+	return false
+}
+
 func (o *Orchestrator) computeDesiredWatches() map[string]bool {
 	desiredDirs := make(map[string]bool)
 
@@ -438,7 +473,7 @@ func (o *Orchestrator) computeDesiredWatches() map[string]bool {
 			buildInfoDir := tspath.GetDirectoryPath(string(bi.path))
 			roots := collections.NewSetFromItems(core.Map(task.resolved.FileNames(), o.toPath)...)
 			for _, fileName := range bi.buildInfo.FileNames {
-				absPath := o.resolveBuildInfoFileName(fileName, buildInfoDir)
+				absPath := o.host.FS().Realpath(o.resolveBuildInfoFileName(fileName, buildInfoDir))
 				fp := o.toPath(absPath)
 				if roots.Has(fp) {
 					continue
@@ -450,12 +485,56 @@ func (o *Orchestrator) computeDesiredWatches() map[string]bool {
 					}
 				}
 			}
+			for packageJson := range bi.buildInfo.GetPackageJsons(buildInfoDir) {
+				o.addPackageJsonWatchDirs(desiredDirs, packageJson)
+			}
+			for packageJson := range bi.buildInfo.GetMissingPackageJsons(buildInfoDir) {
+				o.addPackageJsonWatchDirs(desiredDirs, packageJson)
+			}
+		}
+		for _, packageJson := range task.packageJsons {
+			o.addPackageJsonWatchDirs(desiredDirs, packageJson)
 		}
 	}
 
 	return o.wm.ResolveDesiredDirs(desiredDirs)
 }
 
+func (o *Orchestrator) addWatchDir(desiredDirs map[string]bool, dir string) {
+	if !watchmanager.IsDirCoveredByWatch(desiredDirs, dir, o.comparePathsOptions) && watchmanager.CanWatchDirectory(dir) {
+		desiredDirs[dir] = false
+	}
+}
+
+func (o *Orchestrator) addPackageJsonWatchDirs(desiredDirs map[string]bool, packageJson string) {
+	dir := tspath.GetDirectoryPath(packageJson)
+	dirs := []string{dir}
+	foundNodeModules := false
+	for current := dir; ; {
+		parent := tspath.GetDirectoryPath(current)
+		if parent == "" || parent == current {
+			break
+		}
+		dirs = append(dirs, parent)
+		if tspath.GetBaseFileName(parent) == "node_modules" {
+			foundNodeModules = true
+			if grandparent := tspath.GetDirectoryPath(parent); grandparent != "" && grandparent != parent {
+				dirs = append(dirs, grandparent)
+			}
+			break
+		}
+		current = parent
+	}
+
+	if !foundNodeModules {
+		o.addWatchDir(desiredDirs, dir)
+		return
+	}
+	for _, dir := range dirs {
+		o.addWatchDir(desiredDirs, dir)
+	}
+}
+
 func (o *Orchestrator) DoCycle() {
 	o.wm.Lock()
 	defer o.wm.Unlock()

internal/execute/incremental/buildInfo.go

@@ -463,9 +463,11 @@ type BuildInfo struct {
 	Version string `json:"version,omitzero"`
 
 	// Common between incremental and tsc -b buildinfo for non incremental programs
-	Errors       bool             `json:"errors,omitzero"`
-	CheckPending bool             `json:"checkPending,omitzero"`
-	Root         []*BuildInfoRoot `json:"root,omitzero"`
+	Errors              bool             `json:"errors,omitzero"`
+	CheckPending        bool             `json:"checkPending,omitzero"`
+	Root                []*BuildInfoRoot `json:"root,omitzero"`
+	PackageJsons        []string         `json:"packageJsons,omitzero"`
+	MissingPackageJsons []string         `json:"missingPackageJsons,omitzero"`
 
 	// IncrementalProgram info
 	FileNames                  []string                             `json:"fileNames,omitzero"`
@@ -493,11 +495,21 @@ func (b *BuildInfo) IsIncremental() bool {
 	return b != nil && len(b.FileNames) != 0
 }
 
+func IsBuildInfoFileNameDefaultLibrary(fileName string) bool {
+	return !tspath.PathIsRelative(fileName) && !tspath.PathIsAbsolute(fileName)
+}
+
 func (b *BuildInfo) fileName(fileId BuildInfoFileId) string {
+	if fileId < 1 || int(fileId) > len(b.FileNames) {
+		return ""
+	}
 	return b.FileNames[fileId-1]
 }
 
 func (b *BuildInfo) fileInfo(fileId BuildInfoFileId) *BuildInfoFileInfo {
+	if fileId < 1 || int(fileId) > len(b.FileInfos) {
+		return nil
+	}
 	return b.FileInfos[fileId-1]
 }
 
@@ -529,6 +541,24 @@ func (b *BuildInfo) IsEmitPending(resolved *tsoptions.ParsedCommandLine, buildIn
 	return false
 }
 
+func (b *BuildInfo) GetPackageJsons(buildInfoDirectory string) iter.Seq[string] {
+	return getNormalizedPaths(b.PackageJsons, buildInfoDirectory)
+}
+
+func (b *BuildInfo) GetMissingPackageJsons(buildInfoDirectory string) iter.Seq[string] {
+	return getNormalizedPaths(b.MissingPackageJsons, buildInfoDirectory)
+}
+
+func getNormalizedPaths(paths []string, buildInfoDirectory string) iter.Seq[string] {
+	return func(yield func(string) bool) {
+		for _, path := range paths {
+			if !yield(tspath.GetNormalizedAbsolutePath(path, buildInfoDirectory)) {
+				return
+			}
+		}
+	}
+}
+
 func (b *BuildInfo) GetBuildInfoRootInfoReader(buildInfoDirectory string, comparePathOptions tspath.ComparePathsOptions) *BuildInfoRootInfoReader {
 	resolvedRootFileInfos := make(map[tspath.Path]*BuildInfoFileInfo, len(b.FileNames))
 	// Roots of the File
@@ -540,10 +570,17 @@ func (b *BuildInfo) GetBuildInfoRootInfoReader(buildInfoDirectory string, compar
 
 	// Create map from resolvedRoot to Root
 	for _, resolved := range b.ResolvedRoot {
-		resolvedToRoot[toPath(b.fileName(resolved.Resolved))] = toPath(b.fileName(resolved.Root))
+		resolvedRoot := b.fileName(resolved.Resolved)
+		root := b.fileName(resolved.Root)
+		if resolvedRoot != "" && root != "" {
+			resolvedToRoot[toPath(resolvedRoot)] = toPath(root)
+		}
 	}
 
 	addRoot := func(resolvedRoot string, fileInfo *BuildInfoFileInfo) {
+		if resolvedRoot == "" {
+			return
+		}
 		resolvedRootPath := toPath(resolvedRoot)
 		if rootPath, ok := resolvedToRoot[resolvedRootPath]; ok {
 			rootToResolved.Set(rootPath, resolvedRootPath)