Do less allocation in JSDoc parsing (#1280)

jakebailey · web-flow · commit 0f8773f7d561 · 2025-06-24T16:38:47.000Z
diff --git a/internal/api/encoder/encoder.go b/internal/api/encoder/encoder.go
@@ -774,7 +774,7 @@ func recordNodeStrings(node *ast.Node, strs *stringTable) uint32 {
 	case ast.KindNoSubstitutionTemplateLiteral:
 		return strs.add(node.AsNoSubstitutionTemplateLiteral().Text, node.Kind, node.Pos(), node.End())
 	case ast.KindJSDocText:
-		return strs.add(node.AsJSDocText().Text, node.Kind, node.Pos(), node.End())
+		return strs.add(node.AsJSDocText().Text(), node.Kind, node.Pos(), node.End())
 	default:
 		panic(fmt.Sprintf("Unexpected node kind %v", node.Kind))
 	}
diff --git a/internal/ast/ast.go b/internal/ast/ast.go
@@ -296,7 +296,7 @@ func (n *Node) Text() string {
 	case KindRegularExpressionLiteral:
 		return n.AsRegularExpressionLiteral().Text
 	case KindJSDocText:
-		return n.AsJSDocText().Text
+		return strings.Join(n.AsJSDocText().text, "")
 	}
 	panic(fmt.Sprintf("Unhandled case in Node.Text: %T", n.data))
 }
@@ -8814,40 +8814,40 @@ type JSDocTagBase struct {
 
 type JSDocCommentBase struct {
 	NodeBase
-	Text string
+	text []string
 }
 
 // JSDoc comments
 type JSDocText struct {
 	JSDocCommentBase
 }
 
-func (f *NodeFactory) NewJSDocText(text string) *Node {
+func (f *NodeFactory) NewJSDocText(text []string) *Node {
 	data := f.jsdocTextPool.New()
-	data.Text = text
+	data.text = text
 	f.textCount++
 	return f.newNode(KindJSDocText, data)
 }
 
 func (node *JSDocText) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewJSDocText(node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewJSDocText(node.text), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 type JSDocLink struct {
 	JSDocCommentBase
 	name *Node // optional (should only be EntityName)
 }
 
-func (f *NodeFactory) NewJSDocLink(name *Node, text string) *Node {
+func (f *NodeFactory) NewJSDocLink(name *Node, text []string) *Node {
 	data := &JSDocLink{}
 	data.name = name
-	data.Text = text
+	data.text = text
 	f.textCount++
 	return f.newNode(KindJSDocLink, data)
 }
 
-func (f *NodeFactory) UpdateJSDocLink(node *JSDocLink, name *Node, text string) *Node {
-	if name != node.name || text != node.Text {
+func (f *NodeFactory) UpdateJSDocLink(node *JSDocLink, name *Node, text []string) *Node {
+	if name != node.name || !core.Same(text, node.text) {
 		return updateNode(f.NewJSDocLink(name, text), node.AsNode(), f.hooks)
 	}
 	return node.AsNode()
@@ -8858,11 +8858,11 @@ func (node *JSDocLink) ForEachChild(v Visitor) bool {
 }
 
 func (node *JSDocLink) VisitEachChild(v *NodeVisitor) *Node {
-	return v.Factory.UpdateJSDocLink(node, v.visitNode(node.name), node.Text)
+	return v.Factory.UpdateJSDocLink(node, v.visitNode(node.name), node.text)
 }
 
 func (node *JSDocLink) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewJSDocLink(node.Name(), node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewJSDocLink(node.Name(), node.text), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 func (node *JSDocLink) Name() *DeclarationName {
@@ -8874,16 +8874,16 @@ type JSDocLinkPlain struct {
 	name *Node // optional (should only be EntityName)
 }
 
-func (f *NodeFactory) NewJSDocLinkPlain(name *Node, text string) *Node {
+func (f *NodeFactory) NewJSDocLinkPlain(name *Node, text []string) *Node {
 	data := &JSDocLinkPlain{}
 	data.name = name
-	data.Text = text
+	data.text = text
 	f.textCount++
 	return f.newNode(KindJSDocLinkPlain, data)
 }
 
-func (f *NodeFactory) UpdateJSDocLinkPlain(node *JSDocLinkPlain, name *Node, text string) *Node {
-	if name != node.name || text != node.Text {
+func (f *NodeFactory) UpdateJSDocLinkPlain(node *JSDocLinkPlain, name *Node, text []string) *Node {
+	if name != node.name || !core.Same(text, node.text) {
 		return updateNode(f.NewJSDocLinkPlain(name, text), node.AsNode(), f.hooks)
 	}
 	return node.AsNode()
@@ -8894,11 +8894,11 @@ func (node *JSDocLinkPlain) ForEachChild(v Visitor) bool {
 }
 
 func (node *JSDocLinkPlain) VisitEachChild(v *NodeVisitor) *Node {
-	return v.Factory.UpdateJSDocLinkPlain(node, v.visitNode(node.name), node.Text)
+	return v.Factory.UpdateJSDocLinkPlain(node, v.visitNode(node.name), node.text)
 }
 
 func (node *JSDocLinkPlain) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewJSDocLinkPlain(node.Name(), node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewJSDocLinkPlain(node.Name(), node.text), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 func (node *JSDocLinkPlain) Name() *DeclarationName {
@@ -8910,16 +8910,16 @@ type JSDocLinkCode struct {
 	name *Node // optional (should only be EntityName)
 }
 
-func (f *NodeFactory) NewJSDocLinkCode(name *Node, text string) *Node {
+func (f *NodeFactory) NewJSDocLinkCode(name *Node, text []string) *Node {
 	data := &JSDocLinkCode{}
 	data.name = name
-	data.Text = text
+	data.text = text
 	f.textCount++
 	return f.newNode(KindJSDocLinkCode, data)
 }
 
-func (f *NodeFactory) UpdateJSDocLinkCode(node *JSDocLinkCode, name *Node, text string) *Node {
-	if name != node.name || text != node.Text {
+func (f *NodeFactory) UpdateJSDocLinkCode(node *JSDocLinkCode, name *Node, text []string) *Node {
+	if name != node.name || !core.Same(text, node.text) {
 		return updateNode(f.NewJSDocLinkCode(name, text), node.AsNode(), f.hooks)
 	}
 	return node.AsNode()
@@ -8930,11 +8930,11 @@ func (node *JSDocLinkCode) ForEachChild(v Visitor) bool {
 }
 
 func (node *JSDocLinkCode) VisitEachChild(v *NodeVisitor) *Node {
-	return v.Factory.UpdateJSDocLinkCode(node, v.visitNode(node.name), node.Text)
+	return v.Factory.UpdateJSDocLinkCode(node, v.visitNode(node.name), node.text)
 }
 
 func (node *JSDocLinkCode) Clone(f NodeFactoryCoercible) *Node {
-	return cloneNode(f.AsNodeFactory().NewJSDocLinkCode(node.Name(), node.Text), node.AsNode(), f.AsNodeFactory().hooks)
+	return cloneNode(f.AsNodeFactory().NewJSDocLinkCode(node.Name(), node.text), node.AsNode(), f.AsNodeFactory().hooks)
 }
 
 func (node *JSDocLinkCode) Name() *DeclarationName {
diff --git a/internal/core/pool.go b/internal/core/pool.go
@@ -49,6 +49,15 @@ func (p *Pool[T]) NewSlice1(t T) []T {
 	return slice
 }
 
+func (p *Pool[T]) Clone(t []T) []T {
+	if len(t) == 0 {
+		return nil
+	}
+	slice := p.NewSlice(len(t))
+	copy(slice, t)
+	return slice
+}
+
 func nextPoolSize(size int) int {
 	// This compiles down branch-free.
 	size = max(size, 1)
diff --git a/internal/ls/hover.go b/internal/ls/hover.go
@@ -395,10 +395,10 @@ func writeComments(b *strings.Builder, comments []*ast.Node) {
 	for _, comment := range comments {
 		switch comment.Kind {
 		case ast.KindJSDocText:
-			b.WriteString(comment.AsJSDocText().Text)
+			b.WriteString(comment.Text())
 		case ast.KindJSDocLink:
 			name := comment.Name()
-			text := comment.AsJSDocLink().Text
+			text := comment.AsJSDocLink().Text()
 			if name != nil {
 				if text == "" {
 					writeEntityName(b, name)
diff --git a/internal/parser/jsdoc.go b/internal/parser/jsdoc.go
@@ -256,7 +256,7 @@ loop:
 				if linkEnd == start {
 					comments = removeLeadingNewlines(comments)
 				}
-				jsdocText := p.factory.NewJSDocText(strings.Join(comments, ""))
+				jsdocText := p.factory.NewJSDocText(p.stringSlicePool.Clone(comments))
 				p.finishNodeWithEnd(jsdocText, linkEnd, commentEnd)
 				commentParts = append(commentParts, jsdocText, link)
 				comments = comments[:0]
@@ -283,9 +283,8 @@ loop:
 		commentsPos = p.scanner.TokenFullStart()
 	}
 
-	trimmedComments := trimEnd(strings.Join(comments, ""))
-	if len(trimmedComments) > 0 {
-		jsdocText := p.factory.NewJSDocText(trimmedComments)
+	if len(comments) > 0 {
+		jsdocText := p.factory.NewJSDocText(p.stringSlicePool.Clone(comments))
 		p.finishNodeWithEnd(jsdocText, linkEnd, commentsPos)
 		commentParts = append(commentParts, jsdocText)
 	}
@@ -529,7 +528,7 @@ loop:
 			linkStart := p.scanner.TokenEnd() - 1
 			link := p.parseJSDocLink(linkStart)
 			if link != nil {
-				text := p.factory.NewJSDocText(strings.Join(comments, ""))
+				text := p.factory.NewJSDocText(p.stringSlicePool.Clone(comments))
 				var commentStart int
 				if linkEnd > -1 {
 					commentStart = linkEnd
@@ -583,15 +582,14 @@ loop:
 	p.jsdocTagCommentsSpace = comments[:0]
 
 	comments = removeLeadingNewlines(comments)
-	trimmedComments := trimEnd(strings.Join(comments, ""))
-	if len(trimmedComments) > 0 {
+	if len(comments) > 0 {
 		var commentStart int
 		if linkEnd > -1 {
 			commentStart = linkEnd
 		} else {
 			commentStart = commentsPos
 		}
-		text := p.factory.NewJSDocText(trimmedComments)
+		text := p.factory.NewJSDocText(p.stringSlicePool.Clone(comments))
 		p.finishNode(text, commentStart)
 		parts = append(parts, text)
 	}
@@ -620,11 +618,11 @@ func (p *Parser) parseJSDocLink(start int) *ast.Node {
 	var create *ast.Node
 	switch linkType {
 	case "link":
-		create = p.factory.NewJSDocLink(name, strings.Join(text, ""))
+		create = p.factory.NewJSDocLink(name, text)
 	case "linkcode":
-		create = p.factory.NewJSDocLinkCode(name, strings.Join(text, ""))
+		create = p.factory.NewJSDocLinkCode(name, text)
 	default:
-		create = p.factory.NewJSDocLinkPlain(name, strings.Join(text, ""))
+		create = p.factory.NewJSDocLinkPlain(name, text)
 	}
 	p.finishNodeWithEnd(create, start, p.scanner.TokenEnd())
 	return create
diff --git a/internal/parser/parser.go b/internal/parser/parser.go
@@ -70,6 +70,7 @@ type Parser struct {
 	identifierCount         int
 	notParenthesizedArrow   collections.Set[int]
 	nodeSlicePool           core.Pool[*ast.Node]
+	stringSlicePool         core.Pool[string]
 	jsdocCache              map[*ast.Node][]*ast.Node
 	possibleAwaitSpans      []int
 	jsdocCommentsSpace      []string

Original file line number	Diff line number	Diff line change
`@@ -774,7 +774,7 @@ func recordNodeStrings(node ast.Node, strs stringTable) uint32 {`
`774`	`774`	`case ast.KindNoSubstitutionTemplateLiteral:`
`775`	`775`	`return strs.add(node.AsNoSubstitutionTemplateLiteral().Text, node.Kind, node.Pos(), node.End())`
`776`	`776`	`case ast.KindJSDocText:`
`777`		`- return strs.add(node.AsJSDocText().Text, node.Kind, node.Pos(), node.End())`
	`777`	`+ return strs.add(node.AsJSDocText().Text(), node.Kind, node.Pos(), node.End())`
`778`	`778`	`default:`
`779`	`779`	`panic(fmt.Sprintf("Unexpected node kind %v", node.Kind))`
`780`	`780`	`}`
Original file line number	Diff line number	Diff line change
`@@ -296,7 +296,7 @@ func (n *Node) Text() string {`
`296`	`296`	`case KindRegularExpressionLiteral:`
`297`	`297`	`return n.AsRegularExpressionLiteral().Text`
`298`	`298`	`case KindJSDocText:`
`299`		`- return n.AsJSDocText().Text`
	`299`	`+ return strings.Join(n.AsJSDocText().text, "")`
`300`	`300`	`}`
`301`	`301`	`panic(fmt.Sprintf("Unhandled case in Node.Text: %T", n.data))`
`302`	`302`	`}`
`@@ -8814,40 +8814,40 @@ type JSDocTagBase struct {`
`8814`	`8814`
`8815`	`8815`	`type JSDocCommentBase struct {`
`8816`	`8816`	`NodeBase`
`8817`		`- Text string`
	`8817`	`+ text []string`
`8818`	`8818`	`}`
`8819`	`8819`
`8820`	`8820`	`// JSDoc comments`
`8821`	`8821`	`type JSDocText struct {`
`8822`	`8822`	`JSDocCommentBase`
`8823`	`8823`	`}`
`8824`	`8824`
`8825`		`-func (f NodeFactory) NewJSDocText(text string) Node {`
	`8825`	`+func (f NodeFactory) NewJSDocText(text []string) Node {`
`8826`	`8826`	`data := f.jsdocTextPool.New()`
`8827`		`- data.Text = text`
	`8827`	`+ data.text = text`
`8828`	`8828`	`f.textCount++`
`8829`	`8829`	`return f.newNode(KindJSDocText, data)`
`8830`	`8830`	`}`
`8831`	`8831`
`8832`	`8832`	`func (node JSDocText) Clone(f NodeFactoryCoercible) Node {`
`8833`		`- return cloneNode(f.AsNodeFactory().NewJSDocText(node.Text), node.AsNode(), f.AsNodeFactory().hooks)`
	`8833`	`+ return cloneNode(f.AsNodeFactory().NewJSDocText(node.text), node.AsNode(), f.AsNodeFactory().hooks)`
`8834`	`8834`	`}`
`8835`	`8835`
`8836`	`8836`	`type JSDocLink struct {`
`8837`	`8837`	`JSDocCommentBase`
`8838`	`8838`	`name *Node // optional (should only be EntityName)`
`8839`	`8839`	`}`
`8840`	`8840`
`8841`		`-func (f NodeFactory) NewJSDocLink(name Node, text string) *Node {`
	`8841`	`+func (f NodeFactory) NewJSDocLink(name Node, text []string) *Node {`
`8842`	`8842`	`data := &JSDocLink{}`
`8843`	`8843`	`data.name = name`
`8844`		`- data.Text = text`
	`8844`	`+ data.text = text`
`8845`	`8845`	`f.textCount++`
`8846`	`8846`	`return f.newNode(KindJSDocLink, data)`
`8847`	`8847`	`}`
`8848`	`8848`
`8849`		`-func (f NodeFactory) UpdateJSDocLink(node JSDocLink, name Node, text string) Node {`
`8850`		`- if name != node.name \|\| text != node.Text {`
	`8849`	`+func (f NodeFactory) UpdateJSDocLink(node JSDocLink, name Node, text []string) Node {`
	`8850`	`+ if name != node.name \|\| !core.Same(text, node.text) {`
`8851`	`8851`	`return updateNode(f.NewJSDocLink(name, text), node.AsNode(), f.hooks)`
`8852`	`8852`	`}`
`8853`	`8853`	`return node.AsNode()`
`@@ -8858,11 +8858,11 @@ func (node *JSDocLink) ForEachChild(v Visitor) bool {`
`8858`	`8858`	`}`
`8859`	`8859`
`8860`	`8860`	`func (node JSDocLink) VisitEachChild(v NodeVisitor) *Node {`
`8861`		`- return v.Factory.UpdateJSDocLink(node, v.visitNode(node.name), node.Text)`
	`8861`	`+ return v.Factory.UpdateJSDocLink(node, v.visitNode(node.name), node.text)`
`8862`	`8862`	`}`
`8863`	`8863`
`8864`	`8864`	`func (node JSDocLink) Clone(f NodeFactoryCoercible) Node {`
`8865`		`- return cloneNode(f.AsNodeFactory().NewJSDocLink(node.Name(), node.Text), node.AsNode(), f.AsNodeFactory().hooks)`
	`8865`	`+ return cloneNode(f.AsNodeFactory().NewJSDocLink(node.Name(), node.text), node.AsNode(), f.AsNodeFactory().hooks)`
`8866`	`8866`	`}`
`8867`	`8867`
`8868`	`8868`	`func (node JSDocLink) Name() DeclarationName {`
`@@ -8874,16 +8874,16 @@ type JSDocLinkPlain struct {`
`8874`	`8874`	`name *Node // optional (should only be EntityName)`
`8875`	`8875`	`}`
`8876`	`8876`
`8877`		`-func (f NodeFactory) NewJSDocLinkPlain(name Node, text string) *Node {`
	`8877`	`+func (f NodeFactory) NewJSDocLinkPlain(name Node, text []string) *Node {`
`8878`	`8878`	`data := &JSDocLinkPlain{}`
`8879`	`8879`	`data.name = name`
`8880`		`- data.Text = text`
	`8880`	`+ data.text = text`
`8881`	`8881`	`f.textCount++`
`8882`	`8882`	`return f.newNode(KindJSDocLinkPlain, data)`
`8883`	`8883`	`}`
`8884`	`8884`
`8885`		`-func (f NodeFactory) UpdateJSDocLinkPlain(node JSDocLinkPlain, name Node, text string) Node {`
`8886`		`- if name != node.name \|\| text != node.Text {`
	`8885`	`+func (f NodeFactory) UpdateJSDocLinkPlain(node JSDocLinkPlain, name Node, text []string) Node {`
	`8886`	`+ if name != node.name \|\| !core.Same(text, node.text) {`
`8887`	`8887`	`return updateNode(f.NewJSDocLinkPlain(name, text), node.AsNode(), f.hooks)`
`8888`	`8888`	`}`
`8889`	`8889`	`return node.AsNode()`
`@@ -8894,11 +8894,11 @@ func (node *JSDocLinkPlain) ForEachChild(v Visitor) bool {`
`8894`	`8894`	`}`
`8895`	`8895`
`8896`	`8896`	`func (node JSDocLinkPlain) VisitEachChild(v NodeVisitor) *Node {`
`8897`		`- return v.Factory.UpdateJSDocLinkPlain(node, v.visitNode(node.name), node.Text)`
	`8897`	`+ return v.Factory.UpdateJSDocLinkPlain(node, v.visitNode(node.name), node.text)`
`8898`	`8898`	`}`
`8899`	`8899`
`8900`	`8900`	`func (node JSDocLinkPlain) Clone(f NodeFactoryCoercible) Node {`
`8901`		`- return cloneNode(f.AsNodeFactory().NewJSDocLinkPlain(node.Name(), node.Text), node.AsNode(), f.AsNodeFactory().hooks)`
	`8901`	`+ return cloneNode(f.AsNodeFactory().NewJSDocLinkPlain(node.Name(), node.text), node.AsNode(), f.AsNodeFactory().hooks)`
`8902`	`8902`	`}`
`8903`	`8903`
`8904`	`8904`	`func (node JSDocLinkPlain) Name() DeclarationName {`
`@@ -8910,16 +8910,16 @@ type JSDocLinkCode struct {`
`8910`	`8910`	`name *Node // optional (should only be EntityName)`
`8911`	`8911`	`}`
`8912`	`8912`
`8913`		`-func (f NodeFactory) NewJSDocLinkCode(name Node, text string) *Node {`
	`8913`	`+func (f NodeFactory) NewJSDocLinkCode(name Node, text []string) *Node {`
`8914`	`8914`	`data := &JSDocLinkCode{}`
`8915`	`8915`	`data.name = name`
`8916`		`- data.Text = text`
	`8916`	`+ data.text = text`
`8917`	`8917`	`f.textCount++`
`8918`	`8918`	`return f.newNode(KindJSDocLinkCode, data)`
`8919`	`8919`	`}`
`8920`	`8920`
`8921`		`-func (f NodeFactory) UpdateJSDocLinkCode(node JSDocLinkCode, name Node, text string) Node {`
`8922`		`- if name != node.name \|\| text != node.Text {`
	`8921`	`+func (f NodeFactory) UpdateJSDocLinkCode(node JSDocLinkCode, name Node, text []string) Node {`
	`8922`	`+ if name != node.name \|\| !core.Same(text, node.text) {`
`8923`	`8923`	`return updateNode(f.NewJSDocLinkCode(name, text), node.AsNode(), f.hooks)`
`8924`	`8924`	`}`
`8925`	`8925`	`return node.AsNode()`
`@@ -8930,11 +8930,11 @@ func (node *JSDocLinkCode) ForEachChild(v Visitor) bool {`
`8930`	`8930`	`}`
`8931`	`8931`
`8932`	`8932`	`func (node JSDocLinkCode) VisitEachChild(v NodeVisitor) *Node {`
`8933`		`- return v.Factory.UpdateJSDocLinkCode(node, v.visitNode(node.name), node.Text)`
	`8933`	`+ return v.Factory.UpdateJSDocLinkCode(node, v.visitNode(node.name), node.text)`
`8934`	`8934`	`}`
`8935`	`8935`
`8936`	`8936`	`func (node JSDocLinkCode) Clone(f NodeFactoryCoercible) Node {`
`8937`		`- return cloneNode(f.AsNodeFactory().NewJSDocLinkCode(node.Name(), node.Text), node.AsNode(), f.AsNodeFactory().hooks)`
	`8937`	`+ return cloneNode(f.AsNodeFactory().NewJSDocLinkCode(node.Name(), node.text), node.AsNode(), f.AsNodeFactory().hooks)`
`8938`	`8938`	`}`
`8939`	`8939`
`8940`	`8940`	`func (node JSDocLinkCode) Name() DeclarationName {`