Merge branch 'main' into guyllian.gomez/yarn-pnp

Author: GGomez99

internal/ast/diagnostic.go

@@ -7,16 +7,20 @@ import (
 
 	"github.com/microsoft/typescript-go/internal/core"
 	"github.com/microsoft/typescript-go/internal/diagnostics"
+	"github.com/microsoft/typescript-go/internal/locale"
 )
 
 // Diagnostic
 
 type Diagnostic struct {
-	file               *SourceFile
-	loc                core.TextRange
-	code               int32
-	category           diagnostics.Category
-	message            string
+	file     *SourceFile
+	loc      core.TextRange
+	code     int32
+	category diagnostics.Category
+	// Original message; may be nil.
+	message            *diagnostics.Message
+	messageKey         diagnostics.Key
+	messageArgs        []string
 	messageChain       []*Diagnostic
 	relatedInformation []*Diagnostic
 	reportsUnnecessary bool
@@ -31,7 +35,8 @@ 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) Message() string                   { return d.message }
+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 }
@@ -72,12 +77,22 @@ func (d *Diagnostic) Clone() *Diagnostic {
 	return &result
 }
 
-func NewDiagnosticWith(
+func (d *Diagnostic) Localize(locale locale.Locale) string {
+	return diagnostics.Localize(locale, d.message, d.messageKey, d.messageArgs...)
+}
+
+// For debugging only.
+func (d *Diagnostic) String() string {
+	return diagnostics.Localize(locale.Default, d.message, d.messageKey, d.messageArgs...)
+}
+
+func NewDiagnosticFromSerialized(
 	file *SourceFile,
 	loc core.TextRange,
 	code int32,
 	category diagnostics.Category,
-	message string,
+	messageKey diagnostics.Key,
+	messageArgs []string,
 	messageChain []*Diagnostic,
 	relatedInformation []*Diagnostic,
 	reportsUnnecessary bool,
@@ -89,7 +104,8 @@ func NewDiagnosticWith(
 		loc:                loc,
 		code:               code,
 		category:           category,
-		message:            message,
+		messageKey:         messageKey,
+		messageArgs:        messageArgs,
 		messageChain:       messageChain,
 		relatedInformation: relatedInformation,
 		reportsUnnecessary: reportsUnnecessary,
@@ -104,7 +120,9 @@ func NewDiagnostic(file *SourceFile, loc core.TextRange, message *diagnostics.Me
 		loc:                loc,
 		code:               message.Code(),
 		category:           message.Category(),
-		message:            message.Format(args...),
+		message:            message,
+		messageKey:         message.Key(),
+		messageArgs:        diagnostics.StringifyArgs(args),
 		reportsUnnecessary: message.ReportsUnnecessary(),
 		reportsDeprecated:  message.ReportsDeprecated(),
 	}
@@ -185,13 +203,13 @@ func EqualDiagnosticsNoRelatedInfo(d1, d2 *Diagnostic) bool {
 	return getDiagnosticPath(d1) == getDiagnosticPath(d2) &&
 		d1.Loc() == d2.Loc() &&
 		d1.Code() == d2.Code() &&
-		d1.Message() == d2.Message() &&
+		slices.Equal(d1.MessageArgs(), d2.MessageArgs()) &&
 		slices.EqualFunc(d1.MessageChain(), d2.MessageChain(), equalMessageChain)
 }
 
 func equalMessageChain(c1, c2 *Diagnostic) bool {
 	return c1.Code() == c2.Code() &&
-		c1.Message() == c2.Message() &&
+		slices.Equal(c1.MessageArgs(), c2.MessageArgs()) &&
 		slices.EqualFunc(c1.MessageChain(), c2.MessageChain(), equalMessageChain)
 }
 
@@ -211,7 +229,7 @@ func compareMessageChainSize(c1, c2 []*Diagnostic) int {
 
 func compareMessageChainContent(c1, c2 []*Diagnostic) int {
 	for i := range c1 {
-		c := strings.Compare(c1[i].Message(), c2[i].Message())
+		c := slices.Compare(c1[i].MessageArgs(), c2[i].MessageArgs())
 		if c != 0 {
 			return c
 		}
@@ -256,7 +274,7 @@ func CompareDiagnostics(d1, d2 *Diagnostic) int {
 	if c != 0 {
 		return c
 	}
-	c = strings.Compare(d1.Message(), d2.Message())
+	c = slices.Compare(d1.MessageArgs(), d2.MessageArgs())
 	if c != 0 {
 		return c
 	}

internal/bundled/embed.go

@@ -131,7 +131,7 @@ func (vfs *wrappedFS) walkDir(rest string, walkFn vfs.WalkDirFunc) error {
 			return err
 		}
 		if entry.IsDir() {
-			if err := vfs.walkDir(name, walkFn); err != nil {
+			if err := vfs.walkDir(strings.TrimPrefix(name, "/"), walkFn); err != nil {
 				return err
 			}
 		}

internal/bundled/generate.go

@@ -14,6 +14,7 @@ import (
 
 	"github.com/microsoft/typescript-go/internal/ast"
 	"github.com/microsoft/typescript-go/internal/core"
+	"github.com/microsoft/typescript-go/internal/locale"
 	"github.com/microsoft/typescript-go/internal/parser"
 	"github.com/microsoft/typescript-go/internal/repo"
 	"github.com/microsoft/typescript-go/internal/tspath"
@@ -150,7 +151,7 @@ func readLibs() []lib {
 
 	if len(diags) > 0 {
 		for _, diag := range diags {
-			log.Printf("%s", diag.Message())
+			log.Printf("%s", diag.Localize(locale.Default))
 		}
 		log.Fatalf("failed to parse libs.json")
 	}

internal/checker/checker.go

@@ -4271,7 +4271,7 @@ func (c *Checker) checkClassLikeDeclaration(node *ast.Node) {
 	}
 	c.checkIndexConstraints(classType, symbol, false /*isStaticIndex*/)
 	c.checkIndexConstraints(staticType, symbol, true /*isStaticIndex*/)
-	c.checkTypeForDuplicateIndexSignatures(node)
+	c.checkClassOrInterfaceForDuplicateIndexSignatures(node)
 	c.checkPropertyInitialization(node)
 }
 
@@ -4758,14 +4758,15 @@ func (c *Checker) checkIndexConstraintForIndexSignature(t *Type, checkInfo *Inde
 	}
 }
 
-func (c *Checker) checkTypeForDuplicateIndexSignatures(node *ast.Node) {
-	if ast.IsInterfaceDeclaration(node) {
-		// in case of merging interface declaration it is possible that we'll enter this check procedure several times for every declaration
-		// to prevent this run check only for the first declaration of a given kind
-		if symbol := c.getSymbolOfDeclaration(node); len(symbol.Declarations) != 0 && symbol.Declarations[0] != node {
-			return
-		}
+func (c *Checker) checkClassOrInterfaceForDuplicateIndexSignatures(node *ast.Node) {
+	// Only check the type once
+	if links := c.declaredTypeLinks.Get(c.getSymbolOfDeclaration(node)); !links.indexSignaturesChecked {
+		links.indexSignaturesChecked = true
+		c.checkTypeForDuplicateIndexSignatures(node)
 	}
+}
+
+func (c *Checker) checkTypeForDuplicateIndexSignatures(node *ast.Node) {
 	// TypeScript 1.0 spec (April 2014)
 	// 3.7.4: An object type can contain at most one string index signature and one numeric index signature.
 	// 8.5: A class declaration can have at most one string index member declaration and one numeric index member declaration
@@ -4865,8 +4866,8 @@ func (c *Checker) checkInterfaceDeclaration(node *ast.Node) {
 	symbol := c.getSymbolOfDeclaration(node)
 	c.checkTypeParameterListsIdentical(symbol)
 	// Only check this symbol once
-	firstInterfaceDecl := ast.GetDeclarationOfKind(symbol, ast.KindInterfaceDeclaration)
-	if node == firstInterfaceDecl {
+	if links := c.declaredTypeLinks.Get(symbol); !links.interfaceChecked {
+		links.interfaceChecked = true
 		t := c.getDeclaredTypeOfSymbol(symbol)
 		typeWithThis := c.getTypeWithThisArgument(t, nil, false)
 		// run subsequent checks only if first set succeeded
@@ -4886,7 +4887,7 @@ func (c *Checker) checkInterfaceDeclaration(node *ast.Node) {
 		c.checkTypeReferenceNode(heritageElement)
 	}
 	c.checkSourceElements(node.Members())
-	c.checkTypeForDuplicateIndexSignatures(node)
+	c.checkClassOrInterfaceForDuplicateIndexSignatures(node)
 	c.registerForUnusedIdentifiersCheck(node)
 }
 

internal/checker/grammarchecks.go

@@ -2191,7 +2191,7 @@ func (c *Checker) checkGrammarImportCallExpression(node *ast.Node) bool {
 
 	nodeArguments := nodeAsCall.Arguments
 	argumentNodes := nodeArguments.Nodes
-	if c.moduleKind != core.ModuleKindESNext && c.moduleKind != core.ModuleKindNodeNext && c.moduleKind != core.ModuleKindNode16 && c.moduleKind != core.ModuleKindPreserve {
+	if !(core.ModuleKindNode16 <= c.moduleKind && c.moduleKind <= core.ModuleKindNodeNext) && c.moduleKind != core.ModuleKindESNext && c.moduleKind != core.ModuleKindPreserve {
 		// We are allowed trailing comma after proposal-import-assertions.
 		c.checkGrammarForDisallowedTrailingComma(nodeArguments, diagnostics.Trailing_comma_not_allowed)
 

internal/checker/jsx.go

@@ -297,7 +297,7 @@ func (c *Checker) elaborateJsxComponents(node *ast.Node, source *Type, target *T
 		if !ast.IsJsxSpreadAttribute(prop) && !isHyphenatedJsxName(prop.Name().Text()) {
 			nameType := c.getStringLiteralType(prop.Name().Text())
 			if nameType != nil && nameType.flags&TypeFlagsNever == 0 {
-				reportedError = c.elaborateElement(source, target, relation, prop.Name(), prop.Initializer(), nameType, nil, diagnosticOutput) || reportedError
+				reportedError = c.elaborateElement(source, target, relation, prop.Name(), prop.Initializer(), nameType, nil, nil, diagnosticOutput) || reportedError
 			}
 		}
 	}
@@ -326,13 +326,14 @@ func (c *Checker) elaborateJsxComponents(node *ast.Node, source *Type, target *T
 			nonArrayLikeTargetParts = c.filterType(childrenTargetType, func(t *Type) bool { return !c.isArrayOrTupleLikeType(t) })
 		}
 		var invalidTextDiagnostic *diagnostics.Message
-		getInvalidTextualChildDiagnostic := func() *diagnostics.Message {
+		var invalidTextDiagnosticArgs []any
+		getInvalidTextualChildDiagnostic := func() (*diagnostics.Message, []any) {
 			if invalidTextDiagnostic == nil {
 				tagNameText := scanner.GetTextOfNode(node.Parent.TagName())
-				diagnostic := diagnostics.X_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2
-				invalidTextDiagnostic = diagnostics.FormatMessage(diagnostic, tagNameText, childrenPropName, c.TypeToString(childrenTargetType))
+				invalidTextDiagnostic = diagnostics.X_0_components_don_t_accept_text_as_child_elements_Text_in_JSX_has_the_type_string_but_the_expected_type_of_1_is_2
+				invalidTextDiagnosticArgs = []any{tagNameText, childrenPropName, c.TypeToString(childrenTargetType)}
 			}
-			return invalidTextDiagnostic
+			return invalidTextDiagnostic, invalidTextDiagnosticArgs
 		}
 		if moreThanOneRealChildren {
 			if arrayLikeTargetParts != c.neverType {
@@ -350,7 +351,7 @@ func (c *Checker) elaborateJsxComponents(node *ast.Node, source *Type, target *T
 				child := validChildren[0]
 				e := c.getElaborationElementForJsxChild(child, childrenNameType, getInvalidTextualChildDiagnostic)
 				if e.errorNode != nil {
-					reportedError = c.elaborateElement(source, target, relation, e.errorNode, e.innerExpression, e.nameType, e.errorMessage, diagnosticOutput) || reportedError
+					reportedError = c.elaborateElement(source, target, relation, e.errorNode, e.innerExpression, e.nameType, nil, e.createDiagnostic, diagnosticOutput) || reportedError
 				}
 			} else if !c.isTypeRelatedTo(c.getIndexedAccessType(source, childrenNameType), childrenTargetType, relation) {
 				// arity mismatch
@@ -364,13 +365,13 @@ func (c *Checker) elaborateJsxComponents(node *ast.Node, source *Type, target *T
 }
 
 type JsxElaborationElement struct {
-	errorNode       *ast.Node
-	innerExpression *ast.Node
-	nameType        *Type
-	errorMessage    *diagnostics.Message
+	errorNode        *ast.Node
+	innerExpression  *ast.Node
+	nameType         *Type
+	createDiagnostic func(prop *ast.Node) *ast.Diagnostic // Optional: creates a custom diagnostic for this element
 }
 
-func (c *Checker) generateJsxChildren(node *ast.Node, getInvalidTextDiagnostic func() *diagnostics.Message) iter.Seq[JsxElaborationElement] {
+func (c *Checker) generateJsxChildren(node *ast.Node, getInvalidTextDiagnostic func() (*diagnostics.Message, []any)) iter.Seq[JsxElaborationElement] {
 	return func(yield func(JsxElaborationElement) bool) {
 		memberOffset := 0
 		for i, child := range node.Children().Nodes {
@@ -387,7 +388,7 @@ func (c *Checker) generateJsxChildren(node *ast.Node, getInvalidTextDiagnostic f
 	}
 }
 
-func (c *Checker) getElaborationElementForJsxChild(child *ast.Node, nameType *Type, getInvalidTextDiagnostic func() *diagnostics.Message) JsxElaborationElement {
+func (c *Checker) getElaborationElementForJsxChild(child *ast.Node, nameType *Type, getInvalidTextDiagnostic func() (*diagnostics.Message, []any)) JsxElaborationElement {
 	switch child.Kind {
 	case ast.KindJsxExpression:
 		// child is of the type of the expression
@@ -398,7 +399,15 @@ func (c *Checker) getElaborationElementForJsxChild(child *ast.Node, nameType *Ty
 			return JsxElaborationElement{}
 		}
 		// child is a string
-		return JsxElaborationElement{errorNode: child, innerExpression: nil, nameType: nameType, errorMessage: getInvalidTextDiagnostic()}
+		return JsxElaborationElement{
+			errorNode:       child,
+			innerExpression: nil,
+			nameType:        nameType,
+			createDiagnostic: func(prop *ast.Node) *ast.Diagnostic {
+				errorMessage, errorArgs := getInvalidTextDiagnostic()
+				return NewDiagnosticForNode(prop, errorMessage, errorArgs...)
+			},
+		}
 	case ast.KindJsxElement, ast.KindJsxSelfClosingElement, ast.KindJsxFragment:
 		// child is of type JSX.Element
 		return JsxElaborationElement{errorNode: child, innerExpression: child, nameType: nameType}
@@ -448,18 +457,21 @@ func (c *Checker) elaborateIterableOrArrayLikeTargetElementwise(iterator iter.Se
 				if next != nil {
 					specificSource = c.checkExpressionForMutableLocationWithContextualType(next, sourcePropType)
 				}
-				if c.exactOptionalPropertyTypes && c.isExactOptionalPropertyMismatch(specificSource, targetPropType) {
+				if e.createDiagnostic != nil {
+					// Use the custom diagnostic factory if provided (e.g., for JSX text children with dynamic error messages)
+					c.reportDiagnostic(e.createDiagnostic(prop), diagnosticOutput)
+				} else if c.exactOptionalPropertyTypes && c.isExactOptionalPropertyMismatch(specificSource, targetPropType) {
 					diag := createDiagnosticForNode(prop, diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target, c.TypeToString(specificSource), c.TypeToString(targetPropType))
 					c.reportDiagnostic(diag, diagnosticOutput)
 				} else {
 					targetIsOptional := propName != ast.InternalSymbolNameMissing && core.OrElse(c.getPropertyOfType(tupleOrArrayLikeTargetParts, propName), c.unknownSymbol).Flags&ast.SymbolFlagsOptional != 0
 					sourceIsOptional := propName != ast.InternalSymbolNameMissing && core.OrElse(c.getPropertyOfType(source, propName), c.unknownSymbol).Flags&ast.SymbolFlagsOptional != 0
 					targetPropType = c.removeMissingType(targetPropType, targetIsOptional)
 					sourcePropType = c.removeMissingType(sourcePropType, targetIsOptional && sourceIsOptional)
-					result := c.checkTypeRelatedToEx(specificSource, targetPropType, relation, prop, e.errorMessage, diagnosticOutput)
+					result := c.checkTypeRelatedToEx(specificSource, targetPropType, relation, prop, nil, diagnosticOutput)
 					if result && specificSource != sourcePropType {
 						// If for whatever reason the expression type doesn't yield an error, make sure we still issue an error on the sourcePropType
-						c.checkTypeRelatedToEx(sourcePropType, targetPropType, relation, prop, e.errorMessage, diagnosticOutput)
+						c.checkTypeRelatedToEx(sourcePropType, targetPropType, relation, prop, nil, diagnosticOutput)
 					}
 				}
 			}

internal/checker/relater.go

@@ -503,10 +503,10 @@ func (c *Checker) elaborateObjectLiteral(node *ast.Node, source *Type, target *T
 		}
 		switch prop.Kind {
 		case ast.KindSetAccessor, ast.KindGetAccessor, ast.KindMethodDeclaration, ast.KindShorthandPropertyAssignment:
-			reportedError = c.elaborateElement(source, target, relation, prop.Name(), nil, nameType, nil, diagnosticOutput) || reportedError
+			reportedError = c.elaborateElement(source, target, relation, prop.Name(), nil, nameType, nil, nil, diagnosticOutput) || reportedError
 		case ast.KindPropertyAssignment:
 			message := core.IfElse(ast.IsComputedNonLiteralName(prop.Name()), diagnostics.Type_of_computed_property_s_value_is_0_which_is_not_assignable_to_type_1, nil)
-			reportedError = c.elaborateElement(source, target, relation, prop.Name(), prop.Initializer(), nameType, message, diagnosticOutput) || reportedError
+			reportedError = c.elaborateElement(source, target, relation, prop.Name(), prop.Initializer(), nameType, message, nil, diagnosticOutput) || reportedError
 		}
 	}
 	return reportedError
@@ -531,12 +531,12 @@ func (c *Checker) elaborateArrayLiteral(node *ast.Node, source *Type, target *Ty
 		}
 		nameType := c.getNumberLiteralType(jsnum.Number(i))
 		checkNode := c.getEffectiveCheckNode(element)
-		reportedError = c.elaborateElement(source, target, relation, checkNode, checkNode, nameType, nil, diagnosticOutput) || reportedError
+		reportedError = c.elaborateElement(source, target, relation, checkNode, checkNode, nameType, nil, nil, diagnosticOutput) || reportedError
 	}
 	return reportedError
 }
 
-func (c *Checker) elaborateElement(source *Type, target *Type, relation *Relation, prop *ast.Node, next *ast.Node, nameType *Type, errorMessage *diagnostics.Message, diagnosticOutput *[]*ast.Diagnostic) bool {
+func (c *Checker) elaborateElement(source *Type, target *Type, relation *Relation, prop *ast.Node, next *ast.Node, nameType *Type, errorMessage *diagnostics.Message, diagnosticFactory func(prop *ast.Node) *ast.Diagnostic, diagnosticOutput *[]*ast.Diagnostic) bool {
 	targetPropType := c.getBestMatchIndexedAccessTypeOrUndefined(source, target, nameType)
 	if targetPropType == nil || targetPropType.flags&TypeFlagsIndexedAccess != 0 {
 		// Don't elaborate on indexes on generic variables
@@ -557,7 +557,10 @@ func (c *Checker) elaborateElement(source *Type, target *Type, relation *Relatio
 	if next != nil {
 		specificSource = c.checkExpressionForMutableLocationWithContextualType(next, sourcePropType)
 	}
-	if c.exactOptionalPropertyTypes && c.isExactOptionalPropertyMismatch(specificSource, targetPropType) {
+	if diagnosticFactory != nil {
+		// Use the custom diagnostic factory if provided (e.g., for JSX text children with dynamic error messages)
+		diags = append(diags, diagnosticFactory(prop))
+	} else if c.exactOptionalPropertyTypes && c.isExactOptionalPropertyMismatch(specificSource, targetPropType) {
 		diags = append(diags, createDiagnosticForNode(prop, diagnostics.Type_0_is_not_assignable_to_type_1_with_exactOptionalPropertyTypes_Colon_true_Consider_adding_undefined_to_the_type_of_the_target, c.TypeToString(specificSource), c.TypeToString(targetPropType)))
 	} else {
 		propName := c.getPropertyNameFromIndex(nameType, nil /*accessNode*/)

internal/checker/types.go

@@ -193,8 +193,10 @@ type TypeAliasLinks struct {
 // Links for declared types (type parameters, class types, interface types, enums)
 
 type DeclaredTypeLinks struct {
-	declaredType          *Type
-	typeParametersChecked bool
+	declaredType           *Type
+	interfaceChecked       bool
+	indexSignaturesChecked bool
+	typeParametersChecked  bool
 }
 
 // Links for switch clauses