Merge remote-tracking branch 'upstream/main' into watch-cli-efficiency

Author: johnfav03

README.md

@@ -34,12 +34,12 @@ This is still a work in progress and is not yet at full feature parity with Type
 | Type checking | done | Same errors, locations, and messages as TS 6.0. Types printback in errors may display differently. |
 | JavaScript-specific inference and JSDoc | in progress | Mostly complete, but intentionally lacking some features. Declaration emit not complete. |
 | JSX | done | - |
-| Declaration emit | in progress | Most common features are in place, but some edge cases and feature flags are still unhandled. |
-| Emit (JS output) | in progress | `target: esnext` well-supported, other targets may have gaps. |
+| Declaration emit | in progress | Done for TypeScript files. Not yet complete for JavaScript files. |
+| Emit (JS output) | done | - |
 | Watch mode | prototype | Watches files and rebuilds, but no incremental rechecking. Not optimized. |
 | Build mode / project references | done | - |
 | Incremental build | done | - |
-| Language service (LSP) | in progress | Most functionality. More features coming soon. |
+| Language service (LSP) | in progress | Nearly all features implemented. |
 | API | not ready | - |
 
 Definitions:

internal/ast/diagnostic.go

@@ -11,6 +11,23 @@ import (
 	"github.com/microsoft/typescript-go/internal/locale"
 )
 
+// RepopulateDiagnosticKind indicates the kind of repopulation for a diagnostic chain entry.
+type RepopulateDiagnosticKind int
+
+const (
+	RepopulateModeMismatch   RepopulateDiagnosticKind = 1
+	RepopulateModuleNotFound RepopulateDiagnosticKind = 2
+)
+
+// RepopulateDiagnosticInfo stores information needed to recompute a diagnostic chain entry
+// during incremental builds when the program state may have changed.
+type RepopulateDiagnosticInfo struct {
+	Kind            RepopulateDiagnosticKind
+	ModuleReference string
+	Mode            core.ResolutionMode
+	PackageName     string
+}
+
 // Diagnostic
 
 type Diagnostic struct {
@@ -27,27 +44,30 @@ type Diagnostic struct {
 	reportsUnnecessary bool
 	reportsDeprecated  bool
 	skippedOnNoEmit    bool
+	repopulateInfo     *RepopulateDiagnosticInfo
 }
 
-func (d *Diagnostic) File() *SourceFile                 { return d.file }
-func (d *Diagnostic) Pos() int                          { return d.loc.Pos() }
-func (d *Diagnostic) End() int                          { return d.loc.End() }
-func (d *Diagnostic) Len() int                          { return d.loc.Len() }
-func (d *Diagnostic) Loc() core.TextRange               { return d.loc }
-func (d *Diagnostic) Code() int32                       { return d.code }
-func (d *Diagnostic) Category() diagnostics.Category    { return d.category }
-func (d *Diagnostic) MessageKey() diagnostics.Key       { return d.messageKey }
-func (d *Diagnostic) MessageArgs() []string             { return d.messageArgs }
-func (d *Diagnostic) MessageChain() []*Diagnostic       { return d.messageChain }
-func (d *Diagnostic) RelatedInformation() []*Diagnostic { return d.relatedInformation }
-func (d *Diagnostic) ReportsUnnecessary() bool          { return d.reportsUnnecessary }
-func (d *Diagnostic) ReportsDeprecated() bool           { return d.reportsDeprecated }
-func (d *Diagnostic) SkippedOnNoEmit() bool             { return d.skippedOnNoEmit }
-
-func (d *Diagnostic) SetFile(file *SourceFile)                  { d.file = file }
-func (d *Diagnostic) SetLocation(loc core.TextRange)            { d.loc = loc }
-func (d *Diagnostic) SetCategory(category diagnostics.Category) { d.category = category }
-func (d *Diagnostic) SetSkippedOnNoEmit()                       { d.skippedOnNoEmit = true }
+func (d *Diagnostic) File() *SourceFile                         { return d.file }
+func (d *Diagnostic) Pos() int                                  { return d.loc.Pos() }
+func (d *Diagnostic) End() int                                  { return d.loc.End() }
+func (d *Diagnostic) Len() int                                  { return d.loc.Len() }
+func (d *Diagnostic) Loc() core.TextRange                       { return d.loc }
+func (d *Diagnostic) Code() int32                               { return d.code }
+func (d *Diagnostic) Category() diagnostics.Category            { return d.category }
+func (d *Diagnostic) MessageKey() diagnostics.Key               { return d.messageKey }
+func (d *Diagnostic) MessageArgs() []string                     { return d.messageArgs }
+func (d *Diagnostic) MessageChain() []*Diagnostic               { return d.messageChain }
+func (d *Diagnostic) RelatedInformation() []*Diagnostic         { return d.relatedInformation }
+func (d *Diagnostic) ReportsUnnecessary() bool                  { return d.reportsUnnecessary }
+func (d *Diagnostic) ReportsDeprecated() bool                   { return d.reportsDeprecated }
+func (d *Diagnostic) SkippedOnNoEmit() bool                     { return d.skippedOnNoEmit }
+func (d *Diagnostic) RepopulateInfo() *RepopulateDiagnosticInfo { return d.repopulateInfo }
+
+func (d *Diagnostic) SetFile(file *SourceFile)                         { d.file = file }
+func (d *Diagnostic) SetLocation(loc core.TextRange)                   { d.loc = loc }
+func (d *Diagnostic) SetCategory(category diagnostics.Category)        { d.category = category }
+func (d *Diagnostic) SetSkippedOnNoEmit()                              { d.skippedOnNoEmit = true }
+func (d *Diagnostic) SetRepopulateInfo(info *RepopulateDiagnosticInfo) { d.repopulateInfo = info }
 
 func (d *Diagnostic) SetMessageChain(messageChain []*Diagnostic) *Diagnostic {
 	d.messageChain = messageChain

internal/binder/nameresolver.go

@@ -313,8 +313,6 @@ loop:
 			lastLocation.Kind == ast.KindSourceFile &&
 			lastLocation.AsSourceFile().CommonJSModuleIndicator != nil &&
 			name == "module" &&
-			originalLocation.Parent != nil &&
-			(ast.IsModuleExportsAccessExpression(originalLocation.Parent) || ast.IsModuleExportsQualifiedName(originalLocation.Parent)) &&
 			meaning&lastLocation.Symbol().Flags != 0 {
 			return r.GetModuleSymbol(lastLocation)
 		}

internal/checker/checker.go

@@ -554,6 +554,7 @@ type Program interface {
 	GetImpliedNodeFormatForEmit(sourceFile ast.HasFileName) core.ModuleKind
 	GetResolvedModule(currentSourceFile ast.HasFileName, moduleReference string, mode core.ResolutionMode) *module.ResolvedModule
 	GetResolvedModules() map[tspath.Path]module.ModeAwareCache[*module.ResolvedModule]
+	GetPackagesMap() map[string]bool
 	GetSourceFileMetaData(path tspath.Path) ast.SourceFileMetaData
 	GetJSXRuntimeImportSpecifier(path tspath.Path) (moduleReference string, specifier *ast.Node)
 	GetImportHelpersImportSpecifier(path tspath.Path) *ast.Node
@@ -1462,8 +1463,16 @@ func (c *Checker) getModuleSymbol(sourceFile *ast.Node) *ast.Symbol {
 	if cached, ok := c.moduleSymbols[sourceFile]; ok {
 		return cached
 	}
-	result := c.newSymbol(ast.SymbolFlagsModuleExports|ast.SymbolFlagsFunctionScopedVariable, ast.InternalSymbolNameModuleExports)
+	result := c.newSymbol(ast.SymbolFlagsModuleExports|ast.SymbolFlagsFunctionScopedVariable, "module")
+	result.Declarations = []*ast.Node{sourceFile}
 	result.ValueDeclaration = sourceFile
+	exportsSymbol := c.newSymbol(ast.SymbolFlagsModuleExports|ast.SymbolFlagsProperty, "exports")
+	exportsSymbol.Declarations = result.Declarations
+	exportsSymbol.ValueDeclaration = result.ValueDeclaration
+	exportsSymbol.Parent = result
+	members := make(ast.SymbolTable, 1)
+	members["exports"] = exportsSymbol
+	c.valueSymbolLinks.Get(result).resolvedType = c.newAnonymousType(result, members, nil, nil, nil)
 	c.moduleSymbols[sourceFile] = result
 	return result
 }
@@ -15011,39 +15020,29 @@ func (c *Checker) errorOnImplicitAnyModule(isError bool, errorNode *ast.Node, mo
 }
 
 func (c *Checker) createModuleNotFoundChain(resolvedModule *module.ResolvedModule, errorNode *ast.Node, moduleReference string, mode core.ResolutionMode, packageName string) *ast.Diagnostic {
-	if resolvedModule.AlternateResult != "" {
-		if strings.Contains(resolvedModule.AlternateResult, "/node_modules/@types/") {
-			packageName = "@types/" + module.MangleScopedPackageName(packageName)
-		}
-		return NewDiagnosticForNode(errorNode, diagnostics.There_are_types_at_0_but_this_result_could_not_be_resolved_when_respecting_package_json_exports_The_1_library_may_need_to_update_its_package_json_or_typings, resolvedModule.AlternateResult, packageName)
-	}
-	if c.typesPackageExists(packageName) {
-		return NewDiagnosticForNode(errorNode, diagnostics.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1, packageName, module.MangleScopedPackageName(packageName))
-	}
-	if c.packageBundlesTypes(packageName) {
-		return NewDiagnosticForNode(errorNode, diagnostics.If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1, packageName, moduleReference)
-	}
-	return NewDiagnosticForNode(errorNode, diagnostics.Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0, moduleReference, module.MangleScopedPackageName(packageName))
+	// Store the original packageName for repopulateInfo before any modifications
+	storedPackageName := packageName
+	if storedPackageName == moduleReference {
+		storedPackageName = ""
+	}
+
+	details := CreateModuleNotFoundChain(c.program, ast.GetSourceFileOfNode(errorNode), moduleReference, mode, packageName)
+	result := NewDiagnosticForNode(errorNode, details.Message, details.Args...)
+	result.SetRepopulateInfo(&ast.RepopulateDiagnosticInfo{
+		Kind:            ast.RepopulateModuleNotFound,
+		ModuleReference: moduleReference,
+		Mode:            mode,
+		PackageName:     storedPackageName,
+	})
+	return result
 }
 
 func (c *Checker) createModeMismatchDetails(sourceFile *ast.SourceFile, errorNode *ast.Node) *ast.Diagnostic {
-	ext := tspath.TryGetExtensionFromPath(sourceFile.FileName())
-	targetExt := core.IfElse(ext == tspath.ExtensionTs, tspath.ExtensionMts, core.IfElse(ext == tspath.ExtensionJs, tspath.ExtensionMjs, ""))
-	meta := c.program.GetSourceFileMetaData(sourceFile.Path())
-	packageJsonType := meta.PackageJsonType
-	packageJsonDirectory := meta.PackageJsonDirectory
-	var result *ast.Diagnostic
-	if packageJsonDirectory != "" && packageJsonType == "" {
-		if targetExt != "" {
-			result = NewDiagnosticForNode(errorNode, diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1, targetExt, tspath.CombinePaths(packageJsonDirectory, "package.json"))
-		} else {
-			result = NewDiagnosticForNode(errorNode, diagnostics.To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0, tspath.CombinePaths(packageJsonDirectory, "package.json"))
-		}
-	} else if targetExt != "" {
-		result = NewDiagnosticForNode(errorNode, diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module, targetExt)
-	} else {
-		result = NewDiagnosticForNode(errorNode, diagnostics.To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module)
-	}
+	details := CreateModeMismatchDetails(c.program, sourceFile)
+	result := NewDiagnosticForNode(errorNode, details.Message, details.Args...)
+	result.SetRepopulateInfo(&ast.RepopulateDiagnosticInfo{
+		Kind: ast.RepopulateModeMismatch,
+	})
 	return result
 }
 
@@ -16081,12 +16080,6 @@ func (c *Checker) getTypeOfVariableOrParameterOrPropertyWorker(symbol *ast.Symbo
 	if symbol == c.requireSymbol {
 		return c.anyType
 	}
-	if symbol.Flags&ast.SymbolFlagsModuleExports != 0 && symbol.ValueDeclaration != nil {
-		fileSymbol := c.resolveExternalModuleSymbol(symbol.ValueDeclaration.Symbol(), false /*dontResolveAlias*/)
-		members := make(ast.SymbolTable, 1)
-		members["exports"] = fileSymbol
-		return c.newAnonymousType(symbol, members, nil, nil, nil)
-	}
 	debug.Assert(symbol.ValueDeclaration != nil)
 	declaration := symbol.ValueDeclaration
 	if ast.IsSourceFile(declaration) && ast.IsJsonSourceFile(declaration.AsSourceFile()) {
@@ -16100,6 +16093,9 @@ func (c *Checker) getTypeOfVariableOrParameterOrPropertyWorker(symbol *ast.Symbo
 	if !c.pushTypeResolution(symbol, TypeSystemPropertyNameType) {
 		return c.reportCircularityError(symbol)
 	}
+	if symbol.Flags&ast.SymbolFlagsModuleExports != 0 {
+		return c.getTypeOfSymbol(c.resolveExternalModuleSymbol(symbol.ValueDeclaration.Symbol(), false /*dontResolveAlias*/))
+	}
 	var result *Type
 	switch declaration.Kind {
 	case ast.KindParameter, ast.KindPropertyDeclaration, ast.KindPropertySignature, ast.KindVariableDeclaration,
@@ -30890,9 +30886,6 @@ func (c *Checker) getSymbolOfNameOrPropertyAccessExpression(name *ast.Node) *ast
 			}
 			meaning := core.IfElse(isJSDoc, ast.SymbolFlagsValue|ast.SymbolFlagsType|ast.SymbolFlagsNamespace, ast.SymbolFlagsValue)
 			result := c.resolveEntityName(name, meaning, true /*ignoreErrors*/, true /*dontResolveAlias*/, nil /*location*/)
-			if result != nil && result.Flags&ast.SymbolFlagsModuleExports != 0 {
-				result = result.ValueDeclaration.Symbol() // Symbol of the module source file
-			}
 			if result == nil && isJSDoc {
 				if container := ast.FindAncestor(name, ast.IsClassOrInterfaceLike); container != nil {
 					symbol := c.getSymbolOfDeclaration(container)

internal/checker/utilities.go

@@ -1732,3 +1732,81 @@ func (c *Checker) isJSLiteralType(t *Type) bool {
 	}
 	return false
 }
+
+// DiagnosticDetails holds a resolved diagnostic message and its arguments,
+// used for sharing diagnostic chain computation between the checker and incremental builder.
+type DiagnosticDetails struct {
+	Message *diagnostics.Message
+	Args    []any
+}
+
+// CreateModuleNotFoundChain computes the diagnostic message and arguments for a module-not-found
+// error chain entry. This is shared between the checker (initial diagnostic creation) and the
+// incremental builder (repopulation of cached diagnostics).
+// Mirrors createModuleNotFoundChain in the TypeScript compiler's utilities.ts.
+func CreateModuleNotFoundChain(program Program, file *ast.SourceFile, moduleReference string, mode core.ResolutionMode, packageName string) DiagnosticDetails {
+	resolvedModule := program.GetResolvedModule(file, moduleReference, mode)
+
+	if resolvedModule != nil && resolvedModule.AlternateResult != "" {
+		if strings.Contains(resolvedModule.AlternateResult, "/node_modules/@types/") {
+			packageName = "@types/" + module.MangleScopedPackageName(packageName)
+		}
+		return DiagnosticDetails{
+			Message: diagnostics.There_are_types_at_0_but_this_result_could_not_be_resolved_when_respecting_package_json_exports_The_1_library_may_need_to_update_its_package_json_or_typings,
+			Args:    []any{resolvedModule.AlternateResult, packageName},
+		}
+	}
+
+	packagesMap := program.GetPackagesMap()
+	if _, ok := packagesMap[module.GetTypesPackageName(packageName)]; ok {
+		return DiagnosticDetails{
+			Message: diagnostics.If_the_0_package_actually_exposes_this_module_consider_sending_a_pull_request_to_amend_https_Colon_Slash_Slashgithub_com_SlashDefinitelyTyped_SlashDefinitelyTyped_Slashtree_Slashmaster_Slashtypes_Slash_1,
+			Args:    []any{packageName, module.MangleScopedPackageName(packageName)},
+		}
+	}
+	if packagesMap[packageName] {
+		return DiagnosticDetails{
+			Message: diagnostics.If_the_0_package_actually_exposes_this_module_try_adding_a_new_declaration_d_ts_file_containing_declare_module_1,
+			Args:    []any{packageName, moduleReference},
+		}
+	}
+	return DiagnosticDetails{
+		Message: diagnostics.Try_npm_i_save_dev_types_Slash_1_if_it_exists_or_add_a_new_declaration_d_ts_file_containing_declare_module_0,
+		Args:    []any{moduleReference, module.MangleScopedPackageName(packageName)},
+	}
+}
+
+// CreateModeMismatchDetails computes the diagnostic message and arguments for a mode-mismatch
+// error chain entry. This is shared between the checker (initial diagnostic creation) and the
+// incremental builder (repopulation of cached diagnostics).
+// Mirrors createModeMismatchDetails in the TypeScript compiler's utilities.ts.
+func CreateModeMismatchDetails(program Program, file *ast.SourceFile) DiagnosticDetails {
+	ext := tspath.TryGetExtensionFromPath(file.FileName())
+	targetExt := core.IfElse(ext == tspath.ExtensionTs, tspath.ExtensionMts, core.IfElse(ext == tspath.ExtensionJs, tspath.ExtensionMjs, ""))
+	meta := program.GetSourceFileMetaData(file.Path())
+	packageJsonType := meta.PackageJsonType
+	packageJsonDirectory := meta.PackageJsonDirectory
+
+	if packageJsonDirectory != "" && packageJsonType == "" {
+		if targetExt != "" {
+			return DiagnosticDetails{
+				Message: diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_add_the_field_type_Colon_module_to_1,
+				Args:    []any{targetExt, tspath.CombinePaths(packageJsonDirectory, "package.json")},
+			}
+		}
+		return DiagnosticDetails{
+			Message: diagnostics.To_convert_this_file_to_an_ECMAScript_module_add_the_field_type_Colon_module_to_0,
+			Args:    []any{tspath.CombinePaths(packageJsonDirectory, "package.json")},
+		}
+	}
+	if targetExt != "" {
+		return DiagnosticDetails{
+			Message: diagnostics.To_convert_this_file_to_an_ECMAScript_module_change_its_file_extension_to_0_or_create_a_local_package_json_file_with_type_Colon_module,
+			Args:    []any{targetExt},
+		}
+	}
+	return DiagnosticDetails{
+		Message: diagnostics.To_convert_this_file_to_an_ECMAScript_module_create_a_local_package_json_file_with_type_Colon_module,
+		Args:    nil,
+	}
+}

internal/compiler/program.go

@@ -109,6 +109,10 @@ type Program struct {
 	// Used by workspace/symbol
 	hasTSFileOnce sync.Once
 	hasTSFile     bool
+
+	// Cached map of package names to whether they bundle types
+	packagesMapOnce sync.Once
+	packagesMap     map[string]bool
 }
 
 // FileExists implements checker.Program.
@@ -467,6 +471,22 @@ func (p *Program) GetResolvedModules() map[tspath.Path]module.ModeAwareCache[*mo
 	return p.resolvedModules
 }
 
+// GetPackagesMap returns a lazily-cached map of package names to whether they bundle types.
+// This is used by incremental diagnostic repopulation.
+func (p *Program) GetPackagesMap() map[string]bool {
+	p.packagesMapOnce.Do(func() {
+		p.packagesMap = make(map[string]bool)
+		for _, resolvedModulesInFile := range p.resolvedModules {
+			for _, mod := range resolvedModulesInFile {
+				if mod.PackageId.Name != "" {
+					p.packagesMap[mod.PackageId.Name] = p.packagesMap[mod.PackageId.Name] || mod.Extension == tspath.ExtensionDts
+				}
+			}
+		}
+	})
+	return p.packagesMap
+}
+
 // collectDiagnostics collects diagnostics from a single file or all files.
 // If sourceFile is non-nil, returns diagnostics for just that file.
 // If sourceFile is nil, returns diagnostics for all files in the program.