deps(deps): bump microsoft/typescript-go from 5ac8497 to dcebe53

pkg/ast/ast.go

@@ -6141,15 +6141,16 @@ type StringLiteral struct {
 	LiteralLikeBase
 }
 
-func (f *NodeFactory) NewStringLiteral(text string) *Node {
+func (f *NodeFactory) NewStringLiteral(text string, flags TokenFlags) *Node {
 	data := f.stringLiteralPool.New()
 	data.Text = text
+	data.TokenFlags = flags & TokenFlagsStringLiteralFlags
 	f.textCount++
 	return f.newNode(KindStringLiteral, data)
 }
 
 func (node *StringLiteral) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewStringLiteral(node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewStringLiteral(node.Text, node.TokenFlags), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 func IsStringLiteral(node *Node) bool {
@@ -6163,15 +6164,16 @@ type NumericLiteral struct {
 	LiteralLikeBase
 }
 
-func (f *NodeFactory) NewNumericLiteral(text string) *Node {
+func (f *NodeFactory) NewNumericLiteral(text string, flags TokenFlags) *Node {
 	data := f.numericLiteralPool.New()
 	data.Text = text
+	data.TokenFlags = flags & TokenFlagsNumericLiteralFlags
 	f.textCount++
 	return f.newNode(KindNumericLiteral, data)
 }
 
 func (node *NumericLiteral) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewNumericLiteral(node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewNumericLiteral(node.Text, node.TokenFlags), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 func IsNumericLiteral(node *Node) bool {
@@ -6185,15 +6187,16 @@ type BigIntLiteral struct {
 	LiteralLikeBase
 }
 
-func (f *NodeFactory) NewBigIntLiteral(text string) *Node {
+func (f *NodeFactory) NewBigIntLiteral(text string, flags TokenFlags) *Node {
 	data := &BigIntLiteral{}
 	data.Text = text
+	data.TokenFlags = flags & TokenFlagsNumericLiteralFlags
 	f.textCount++
 	return f.newNode(KindBigIntLiteral, data)
 }
 
 func (node *BigIntLiteral) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewBigIntLiteral(node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewBigIntLiteral(node.Text, node.TokenFlags), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 func (node *BigIntLiteral) computeSubtreeFacts() SubtreeFacts {
@@ -6211,15 +6214,16 @@ type RegularExpressionLiteral struct {
 	LiteralLikeBase
 }
 
-func (f *NodeFactory) NewRegularExpressionLiteral(text string) *Node {
+func (f *NodeFactory) NewRegularExpressionLiteral(text string, flags TokenFlags) *Node {
 	data := &RegularExpressionLiteral{}
 	data.Text = text
+	data.TokenFlags = flags & TokenFlagsRegularExpressionLiteralFlags
 	f.textCount++
 	return f.newNode(KindRegularExpressionLiteral, data)
 }
 
 func (node *RegularExpressionLiteral) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewRegularExpressionLiteral(node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewRegularExpressionLiteral(node.Text, node.TokenFlags), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 func IsRegularExpressionLiteral(node *Node) bool {
@@ -6233,15 +6237,16 @@ type NoSubstitutionTemplateLiteral struct {
 	TemplateLiteralLikeBase
 }
 
-func (f *NodeFactory) NewNoSubstitutionTemplateLiteral(text string) *Node {
+func (f *NodeFactory) NewNoSubstitutionTemplateLiteral(text string, templateFlags TokenFlags) *Node {
 	data := &NoSubstitutionTemplateLiteral{}
 	data.Text = text
+	data.TemplateFlags = templateFlags & TokenFlagsTemplateLiteralLikeFlags
 	f.textCount++
 	return f.newNode(KindNoSubstitutionTemplateLiteral, data)
 }
 
 func (node *NoSubstitutionTemplateLiteral) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewNoSubstitutionTemplateLiteral(node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewNoSubstitutionTemplateLiteral(node.Text, node.TemplateFlags), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 // BinaryExpression
@@ -8722,7 +8727,7 @@ func (f *NodeFactory) NewTemplateHead(text string, rawText string, templateFlags
 	data := &TemplateHead{}
 	data.Text = text
 	data.RawText = rawText
-	data.TemplateFlags = templateFlags
+	data.TemplateFlags = templateFlags & TokenFlagsTemplateLiteralLikeFlags
 	f.textCount++
 	return f.newNode(KindTemplateHead, data)
 }
@@ -8746,7 +8751,7 @@ func (f *NodeFactory) NewTemplateMiddle(text string, rawText string, templateFla
 	data := &TemplateMiddle{}
 	data.Text = text
 	data.RawText = rawText
-	data.TemplateFlags = templateFlags
+	data.TemplateFlags = templateFlags & TokenFlagsTemplateLiteralLikeFlags
 	f.textCount++
 	return f.newNode(KindTemplateMiddle, data)
 }
@@ -8770,7 +8775,7 @@ func (f *NodeFactory) NewTemplateTail(text string, rawText string, templateFlags
 	data := &TemplateTail{}
 	data.Text = text
 	data.RawText = rawText
-	data.TemplateFlags = templateFlags
+	data.TemplateFlags = templateFlags & TokenFlagsTemplateLiteralLikeFlags
 	f.textCount++
 	return f.newNode(KindTemplateTail, data)
 }
@@ -10980,33 +10985,23 @@ func createToken(kind Kind, file *SourceFile, pos, end int, flags TokenFlags) *N
 	text := file.text[pos:end]
 	switch kind {
 	case KindNumericLiteral:
-		literal := file.tokenFactory.NewNumericLiteral(text)
-		literal.AsNumericLiteral().TokenFlags = flags & TokenFlagsNumericLiteralFlags
-		return literal
+		return file.tokenFactory.NewNumericLiteral(text, flags)
 	case KindBigIntLiteral:
-		literal := file.tokenFactory.NewBigIntLiteral(text)
-		literal.AsBigIntLiteral().TokenFlags = flags & TokenFlagsNumericLiteralFlags
-		return literal
+		return file.tokenFactory.NewBigIntLiteral(text, flags)
 	case KindStringLiteral:
-		literal := file.tokenFactory.NewStringLiteral(text)
-		literal.AsStringLiteral().TokenFlags = flags & TokenFlagsStringLiteralFlags
-		return literal
+		return file.tokenFactory.NewStringLiteral(text, flags)
 	case KindJsxText, KindJsxTextAllWhiteSpaces:
 		return file.tokenFactory.NewJsxText(text, kind == KindJsxTextAllWhiteSpaces)
 	case KindRegularExpressionLiteral:
-		literal := file.tokenFactory.NewRegularExpressionLiteral(text)
-		literal.AsRegularExpressionLiteral().TokenFlags = flags & TokenFlagsRegularExpressionLiteralFlags
-		return literal
+		return file.tokenFactory.NewRegularExpressionLiteral(text, flags)
 	case KindNoSubstitutionTemplateLiteral:
-		literal := file.tokenFactory.NewNoSubstitutionTemplateLiteral(text)
-		literal.AsNoSubstitutionTemplateLiteral().TokenFlags = flags & TokenFlagsTemplateLiteralLikeFlags
-		return literal
+		return file.tokenFactory.NewNoSubstitutionTemplateLiteral(text, flags)
 	case KindTemplateHead:
-		return file.tokenFactory.NewTemplateHead(text, "" /*rawText*/, flags&TokenFlagsTemplateLiteralLikeFlags)
+		return file.tokenFactory.NewTemplateHead(text, "" /*rawText*/, flags)
 	case KindTemplateMiddle:
-		return file.tokenFactory.NewTemplateMiddle(text, "" /*rawText*/, flags&TokenFlagsTemplateLiteralLikeFlags)
+		return file.tokenFactory.NewTemplateMiddle(text, "" /*rawText*/, flags)
 	case KindTemplateTail:
-		return file.tokenFactory.NewTemplateTail(text, "" /*rawText*/, flags&TokenFlagsTemplateLiteralLikeFlags)
+		return file.tokenFactory.NewTemplateTail(text, "" /*rawText*/, flags)
 	case KindIdentifier:
 		return file.tokenFactory.NewIdentifier(text)
 	case KindPrivateIdentifier:

pkg/checker/checker.go

@@ -9638,6 +9638,17 @@ func (c *Checker) getArgumentArityError(node *ast.Node, signatures []*Signature,
 		}
 		return diagnostic
 	default:
+		// Guard against out-of-bounds access when maxCount >= len(args).
+		// This can happen when we reach this fallback error path but the argument
+		// count actually matches the parameter count (e.g., due to trailing commas
+		// causing signature resolution to fail for other reasons).
+		if maxCount >= len(args) {
+			diagnostic := NewDiagnosticForNode(errorNode, message, parameterRange, len(args))
+			if headMessage != nil {
+				diagnostic = ast.NewDiagnosticChain(diagnostic, headMessage)
+			}
+			return diagnostic
+		}
 		sourceFile := ast.GetSourceFileOfNode(node)
 		pos := scanner.SkipTrivia(sourceFile.Text(), args[maxCount].Pos())
 		end := args[len(args)-1].End()
@@ -17352,7 +17363,7 @@ func (c *Checker) getSyntheticElementAccess(node *ast.Node) *ast.Node {
 	parentAccess := c.getParentElementAccess(node)
 	if parentAccess != nil && getFlowNodeOfNode(parentAccess) != nil {
 		if propName, ok := c.getDestructuringPropertyName(node); ok {
-			literal := c.factory.NewStringLiteral(propName)
+			literal := c.factory.NewStringLiteral(propName, ast.TokenFlagsNone)
 			literal.Loc = node.Loc
 			lhsExpr := parentAccess
 			if !ast.IsLeftHandSideExpression(parentAccess) {

pkg/checker/emitresolver.go

@@ -972,18 +972,18 @@ func (r *EmitResolver) CreateLiteralConstValue(emitContext *printer.EmitContext,
 	}
 	switch value := t.AsLiteralType().value.(type) {
 	case string:
-		return emitContext.Factory.NewStringLiteral(value)
+		return emitContext.Factory.NewStringLiteral(value, ast.TokenFlagsNone)
 	case jsnum.Number:
 		if value.Abs() != value {
 			// negative
 			return emitContext.Factory.NewPrefixUnaryExpression(
 				ast.KindMinusToken,
-				emitContext.Factory.NewNumericLiteral(value.String()[1:]),
+				emitContext.Factory.NewNumericLiteral(value.String()[1:], ast.TokenFlagsNone),
 			)
 		}
-		return emitContext.Factory.NewNumericLiteral(value.String())
+		return emitContext.Factory.NewNumericLiteral(value.String(), ast.TokenFlagsNone)
 	case jsnum.PseudoBigInt:
-		return emitContext.Factory.NewBigIntLiteral(pseudoBigIntToString(value) + "n")
+		return emitContext.Factory.NewBigIntLiteral(pseudoBigIntToString(value)+"n", ast.TokenFlagsNone)
 	case bool:
 		kind := ast.KindFalseKeyword
 		if value {

pkg/checker/nodebuilderimpl.go

@@ -757,11 +757,11 @@ func (b *NodeBuilderImpl) createExpressionFromSymbolChain(chain []*ast.Symbol, i
 
 	var expression *ast.Expression
 	if startsWithSingleOrDoubleQuote(symbolName) && symbol.Flags&ast.SymbolFlagsEnumMember == 0 {
-		expression = b.newStringLiteral(stringutil.UnquoteString(symbolName))
+		expression = b.newStringLiteralEx(stringutil.UnquoteString(symbolName), symbolName[0] == '\'')
 	} else if jsnum.FromString(symbolName).String() == symbolName {
 		// TODO: the follwing in strada would assert if the number is negative, but no such assertion exists here
 		// Moreover, what's even guaranteeing the name *isn't* -1 here anyway? Needs double-checking.
-		expression = b.f.NewNumericLiteral(symbolName)
+		expression = b.f.NewNumericLiteral(symbolName, ast.TokenFlagsNone)
 	}
 	if expression == nil {
 		expression = b.f.NewIdentifier(symbolName)
@@ -2088,12 +2088,9 @@ func (b *NodeBuilderImpl) createPropertyNameNodeForIdentifierOrLiteral(name stri
 		return b.f.NewIdentifier(name)
 	}
 	if !stringNamed && !isMethodNamedNew && isNumericLiteralName(name) && jsnum.FromString(name) >= 0 {
-		return b.f.NewNumericLiteral(name)
-	}
-	result := b.f.NewStringLiteral(name)
-	if singleQuote {
-		result.AsStringLiteral().TokenFlags |= ast.TokenFlagsSingleQuote
+		return b.f.NewNumericLiteral(name, ast.TokenFlagsNone)
 	}
+	result := b.f.NewStringLiteral(name, core.IfElse(singleQuote, ast.TokenFlagsSingleQuote, ast.TokenFlagsNone))
 	return result
 }
 
@@ -2157,14 +2154,11 @@ func (b *NodeBuilderImpl) getPropertyNameNodeForSymbolFromNameType(symbol *ast.S
 			name = nameType.AsLiteralType().value.(string)
 		}
 		if !scanner.IsIdentifierText(name, core.LanguageVariantStandard) && (stringNamed || !isNumericLiteralName(name)) {
-			node := b.f.NewStringLiteral(name)
-			if singleQuote {
-				node.AsStringLiteral().TokenFlags |= ast.TokenFlagsSingleQuote
-			}
+			node := b.f.NewStringLiteral(name, core.IfElse(singleQuote, ast.TokenFlagsSingleQuote, ast.TokenFlagsNone))
 			return node
 		}
 		if isNumericLiteralName(name) && name[0] == '-' {
-			return b.f.NewComputedPropertyName(b.f.NewPrefixUnaryExpression(ast.KindMinusToken, b.f.NewNumericLiteral(name[1:])))
+			return b.f.NewComputedPropertyName(b.f.NewPrefixUnaryExpression(ast.KindMinusToken, b.f.NewNumericLiteral(name[1:], ast.TokenFlagsNone)))
 		}
 		return b.createPropertyNameNodeForIdentifierOrLiteral(name, singleQuote, stringNamed, isMethod)
 	}
@@ -2896,14 +2890,14 @@ func (b *NodeBuilderImpl) typeToTypeNode(t *Type) *ast.TypeNode {
 		value := t.AsLiteralType().value.(jsnum.Number)
 		b.ctx.approximateLength += len(value.String())
 		if value < 0 {
-			return b.f.NewLiteralTypeNode(b.f.NewPrefixUnaryExpression(ast.KindMinusToken, b.f.NewNumericLiteral(value.String()[1:])))
+			return b.f.NewLiteralTypeNode(b.f.NewPrefixUnaryExpression(ast.KindMinusToken, b.f.NewNumericLiteral(value.String()[1:], ast.TokenFlagsNone)))
 		} else {
-			return b.f.NewLiteralTypeNode(b.f.NewNumericLiteral(value.String()))
+			return b.f.NewLiteralTypeNode(b.f.NewNumericLiteral(value.String(), ast.TokenFlagsNone))
 		}
 	}
 	if t.flags&TypeFlagsBigIntLiteral != 0 {
 		b.ctx.approximateLength += len(pseudoBigIntToString(getBigIntLiteralValue(t))) + 1
-		return b.f.NewLiteralTypeNode(b.f.NewBigIntLiteral(pseudoBigIntToString(getBigIntLiteralValue(t)) + "n"))
+		return b.f.NewLiteralTypeNode(b.f.NewBigIntLiteral(pseudoBigIntToString(getBigIntLiteralValue(t))+"n", ast.TokenFlagsNone))
 	}
 	if t.flags&TypeFlagsBooleanLiteral != 0 {
 		if t.AsLiteralType().value.(bool) {
@@ -3102,10 +3096,15 @@ func (b *NodeBuilderImpl) typeToTypeNode(t *Type) *ast.TypeNode {
 }
 
 func (b *NodeBuilderImpl) newStringLiteral(text string) *ast.Node {
-	node := b.f.NewStringLiteral(text)
-	if b.ctx.flags&nodebuilder.FlagsUseSingleQuotesForStringLiteralType != 0 {
-		node.AsStringLiteral().TokenFlags |= ast.TokenFlagsSingleQuote
+	return b.newStringLiteralEx(text, false /*isSingleQuote*/)
+}
+
+func (b *NodeBuilderImpl) newStringLiteralEx(text string, isSingleQuote bool) *ast.Node {
+	flags := ast.TokenFlagsNone
+	if isSingleQuote || b.ctx.flags&nodebuilder.FlagsUseSingleQuotesForStringLiteralType != 0 {
+		flags |= ast.TokenFlagsSingleQuote
 	}
+	node := b.f.NewStringLiteral(text, flags)
 	return node
 }
 

pkg/compiler/fileloader.go

@@ -477,7 +477,7 @@ func (p *fileLoader) resolveImportsAndModuleAugmentations(t *parseTask) {
 func (p *fileLoader) createSyntheticImport(text string, file *ast.SourceFile) *ast.Node {
 	p.factoryMu.Lock()
 	defer p.factoryMu.Unlock()
-	externalHelpersModuleReference := p.factory.NewStringLiteral(text)
+	externalHelpersModuleReference := p.factory.NewStringLiteral(text, ast.TokenFlagsNone)
 	importDecl := p.factory.NewImportDeclaration(nil, nil, externalHelpersModuleReference, nil)
 	// !!! addInternalEmitFlags(importDecl, InternalEmitFlags.NeverApplyImportHelper);
 	externalHelpersModuleReference.Parent = importDecl