Various node builder related performance optimizations (#1001)

jakebailey · web-flow · commit 1b095c1ac2c9 · 2025-06-04T18:55:44.000Z
diff --git a/internal/checker/checker.go b/internal/checker/checker.go
@@ -15172,7 +15172,7 @@ type ExportCollisionTable = map[string]*ExportCollision
 
 func (c *Checker) getExportsOfModuleWorker(moduleSymbol *ast.Symbol) (exports ast.SymbolTable, typeOnlyExportStarMap map[string]*ast.Node) {
 	var visitedSymbols []*ast.Symbol
-	var nonTypeOnlyNames core.Set[string]
+	nonTypeOnlyNames := core.NewSetWithSizeHint[string](len(moduleSymbol.Exports))
 	// The ES6 spec permits export * declarations in a module to circularly reference the module itself. For example,
 	// module 'a' can 'export * from "b"' and 'b' can 'export * from "a"' without error.
 	var visit func(*ast.Symbol, *ast.Node, bool) ast.SymbolTable
diff --git a/internal/checker/nodebuilder.go b/internal/checker/nodebuilder.go
@@ -36,7 +36,6 @@ func (b *NodeBuilder) enterContext(enclosingDeclaration *ast.Node, flags nodebui
 		tracker = NewSymbolTrackerImpl(b.impl.ctx, nil, b.host)
 		b.impl.ctx.tracker = tracker
 	}
-	b.impl.initializeClosures() // recapture ctx
 	b.ctxStack = append(b.ctxStack, b.impl.ctx)
 }
 
@@ -159,7 +158,7 @@ func (b *NodeBuilder) TypePredicateToTypePredicateNode(predicate *TypePredicate,
 // TypeToTypeNode implements NodeBuilderInterface.
 func (b *NodeBuilder) TypeToTypeNode(typ *Type, enclosingDeclaration *ast.Node, flags nodebuilder.Flags, internalFlags nodebuilder.InternalFlags, tracker nodebuilder.SymbolTracker) *ast.Node {
 	b.enterContext(enclosingDeclaration, flags, internalFlags, tracker)
-	return b.exitContext(b.impl.typeToTypeNodeWorker(typ))
+	return b.exitContext(b.impl.typeToTypeNode(typ))
 }
 
 // var _ NodeBuilderInterface = NewNodeBuilderAPI(nil, nil)
diff --git a/internal/checker/nodebuilderimpl.go b/internal/checker/nodebuilderimpl.go
@@ -91,14 +91,6 @@ type nodeBuilderImpl struct {
 	links       core.LinkStore[*ast.Node, NodeBuilderLinks]
 	symbolLinks core.LinkStore[*ast.Symbol, NodeBuilderSymbolLinks]
 
-	// closures
-	typeToTypeNode               func(t *Type) *ast.TypeNode
-	typeReferenceToTypeNode      func(t *Type) *ast.TypeNode
-	conditionalTypeToTypeNode    func(t *Type) *ast.TypeNode
-	createTypeNodeFromObjectType func(t *Type) *ast.TypeNode
-	isStringNamed                func(d *ast.Declaration) bool
-	isSingleQuotedStringNamed    func(d *ast.Declaration) bool
-
 	// state
 	ctx *NodeBuilderContext
 }
@@ -111,20 +103,10 @@ const (
 // Node builder utility functions
 
 func newNodeBuilderImpl(ch *Checker, e *printer.EmitContext) nodeBuilderImpl {
-	result := nodeBuilderImpl{f: e.Factory.AsNodeFactory(), ch: ch, e: e, typeToTypeNode: nil, typeReferenceToTypeNode: nil, conditionalTypeToTypeNode: nil, ctx: nil}
-	result.initializeClosures()
+	result := nodeBuilderImpl{f: e.Factory.AsNodeFactory(), ch: ch, e: e}
 	return result
 }
 
-func (b *nodeBuilderImpl) initializeClosures() {
-	b.typeToTypeNode = b.typeToTypeNodeWorker
-	b.typeReferenceToTypeNode = b.typeReferenceToTypeNodeWorker
-	b.conditionalTypeToTypeNode = b.conditionalTypeToTypeNodeWorker
-	b.createTypeNodeFromObjectType = b.createTypeNodeFromObjectTypeWorker
-	b.isStringNamed = b.isStringNamedWorker
-	b.isSingleQuotedStringNamed = b.isSingleQuotedStringNamedWorker
-}
-
 func (b *nodeBuilderImpl) saveRestoreFlags() func() {
 	flags := b.ctx.flags
 	internalFlags := b.ctx.internalFlags
@@ -1976,7 +1958,7 @@ func (b *nodeBuilderImpl) createPropertyNameNodeForIdentifierOrLiteral(name stri
 	return result
 }
 
-func (b *nodeBuilderImpl) isStringNamedWorker(d *ast.Declaration) bool {
+func (b *nodeBuilderImpl) isStringNamed(d *ast.Declaration) bool {
 	name := ast.GetNameOfDeclaration(d)
 	if name == nil {
 		return false
@@ -1992,7 +1974,7 @@ func (b *nodeBuilderImpl) isStringNamedWorker(d *ast.Declaration) bool {
 	return ast.IsStringLiteral(name)
 }
 
-func (b *nodeBuilderImpl) isSingleQuotedStringNamedWorker(d *ast.Declaration) bool {
+func (b *nodeBuilderImpl) isSingleQuotedStringNamed(d *ast.Declaration) bool {
 	return false // !!!
 	// TODO: actually support single-quote-style-maintenance
 	// name := ast.GetNameOfDeclaration(d)
@@ -2216,7 +2198,7 @@ func (b *nodeBuilderImpl) createTypeNodesFromResolvedType(resolvedType *Structur
 	}
 }
 
-func (b *nodeBuilderImpl) createTypeNodeFromObjectTypeWorker(t *Type) *ast.TypeNode {
+func (b *nodeBuilderImpl) createTypeNodeFromObjectType(t *Type) *ast.TypeNode {
 	if b.ch.isGenericMappedType(t) || (t.objectFlags&ObjectFlagsMapped != 0 && t.AsMappedType().containsError) {
 		return b.createMappedTypeNodeFromType(t)
 	}
@@ -2329,7 +2311,7 @@ func (b *nodeBuilderImpl) createAnonymousTypeNode(t *Type) *ast.TypeNode {
 			if _, ok := b.ctx.visitedTypes[typeId]; ok {
 				return b.createElidedInformationPlaceholder()
 			}
-			return b.visitAndTransformType(t, b.createTypeNodeFromObjectType)
+			return b.visitAndTransformType(t, (*nodeBuilderImpl).createTypeNodeFromObjectType)
 		}
 		var isInstanceType ast.SymbolFlags
 		if isClassInstanceSide(b.ch, t) {
@@ -2355,7 +2337,7 @@ func (b *nodeBuilderImpl) createAnonymousTypeNode(t *Type) *ast.TypeNode {
 				return b.createElidedInformationPlaceholder()
 			}
 		} else {
-			return b.visitAndTransformType(t, b.createTypeNodeFromObjectType)
+			return b.visitAndTransformType(t, (*nodeBuilderImpl).createTypeNodeFromObjectType)
 		}
 	} else {
 		// Anonymous types without a symbol are never circular.
@@ -2386,12 +2368,12 @@ func (b *nodeBuilderImpl) typeToTypeNodeOrCircularityElision(t *Type) *ast.TypeN
 			}
 			return b.createElidedInformationPlaceholder()
 		}
-		return b.visitAndTransformType(t, b.typeToTypeNode)
+		return b.visitAndTransformType(t, (*nodeBuilderImpl).typeToTypeNode)
 	}
 	return b.typeToTypeNode(t)
 }
 
-func (b *nodeBuilderImpl) conditionalTypeToTypeNodeWorker(_t *Type) *ast.TypeNode {
+func (b *nodeBuilderImpl) conditionalTypeToTypeNode(_t *Type) *ast.TypeNode {
 	t := _t.AsConditionalType()
 	checkTypeNode := b.typeToTypeNode(t.checkType)
 	b.ctx.approximateLength += 15
@@ -2449,7 +2431,7 @@ func (b *nodeBuilderImpl) getParentSymbolOfTypeParameter(typeParameter *TypePara
 	return b.ch.getSymbolOfNode(host)
 }
 
-func (b *nodeBuilderImpl) typeReferenceToTypeNodeWorker(t *Type) *ast.TypeNode {
+func (b *nodeBuilderImpl) typeReferenceToTypeNode(t *Type) *ast.TypeNode {
 	var typeArguments []*Type = b.ch.getTypeArguments(t)
 	if t.Target() == b.ch.globalArrayType || t.Target() == b.ch.globalReadonlyArrayType {
 		if b.ctx.flags&nodebuilder.FlagsWriteArrayAsGenericType != 0 {
@@ -2583,7 +2565,7 @@ func (b *nodeBuilderImpl) typeReferenceToTypeNodeWorker(t *Type) *ast.TypeNode {
 	}
 }
 
-func (b *nodeBuilderImpl) visitAndTransformType(t *Type, transform func(t *Type) *ast.TypeNode) *ast.TypeNode {
+func (b *nodeBuilderImpl) visitAndTransformType(t *Type, transform func(b *nodeBuilderImpl, t *Type) *ast.TypeNode) *ast.TypeNode {
 	typeId := t.id
 	isConstructorObject := t.objectFlags&ObjectFlagsAnonymous != 0 && t.symbol != nil && t.symbol.Flags&ast.SymbolFlagsClass != 0
 	var id *CompositeSymbolIdentity
@@ -2629,7 +2611,7 @@ func (b *nodeBuilderImpl) visitAndTransformType(t *Type, transform func(t *Type)
 	prevTrackedSymbols := b.ctx.trackedSymbols
 	b.ctx.trackedSymbols = nil
 	startLength := b.ctx.approximateLength
-	result := transform(t)
+	result := transform(b, t)
 	addedLength := b.ctx.approximateLength - startLength
 	if !b.ctx.reportedDiagnostic && !b.ctx.encounteredError {
 		links := b.links.Get(b.ctx.enclosingDeclaration)
@@ -2668,7 +2650,7 @@ func (b *nodeBuilderImpl) visitAndTransformType(t *Type, transform func(t *Type)
 	// }
 }
 
-func (b *nodeBuilderImpl) typeToTypeNodeWorker(t *Type) *ast.TypeNode {
+func (b *nodeBuilderImpl) typeToTypeNode(t *Type) *ast.TypeNode {
 	inTypeAlias := b.ctx.flags & nodebuilder.FlagsInTypeAlias
 	b.ctx.flags &^= nodebuilder.FlagsInTypeAlias
 
@@ -2830,7 +2812,7 @@ func (b *nodeBuilderImpl) typeToTypeNodeWorker(t *Type) *ast.TypeNode {
 	if objectFlags&ObjectFlagsReference != 0 {
 		// Debug.assert(t.flags&TypeFlagsObject != 0) // !!!
 		if t.AsTypeReference().node != nil {
-			return b.visitAndTransformType(t, b.typeReferenceToTypeNode)
+			return b.visitAndTransformType(t, (*nodeBuilderImpl).typeReferenceToTypeNode)
 		} else {
 			return b.typeReferenceToTypeNode(t)
 		}
@@ -2936,7 +2918,7 @@ func (b *nodeBuilderImpl) typeToTypeNodeWorker(t *Type) *ast.TypeNode {
 		return b.f.NewIndexedAccessTypeNode(objectTypeNode, indexTypeNode)
 	}
 	if t.flags&TypeFlagsConditional != 0 {
-		return b.visitAndTransformType(t, b.conditionalTypeToTypeNode)
+		return b.visitAndTransformType(t, (*nodeBuilderImpl).conditionalTypeToTypeNode)
 	}
 	if t.flags&TypeFlagsSubstitution != 0 {
 		typeNode := b.typeToTypeNode(t.AsSubstitutionType().baseType)
diff --git a/internal/printer/emitcontext.go b/internal/printer/emitcontext.go
@@ -24,10 +24,6 @@ type EmitContext struct {
 	varScopeStack core.Stack[*varScope]
 	letScopeStack core.Stack[*varScope]
 	emitHelpers   collections.OrderedSet[*EmitHelper]
-
-	isCustomPrologue           func(node *ast.Statement) bool
-	isHoistedFunction          func(node *ast.Statement) bool
-	isHoistedVariableStatement func(node *ast.Statement) bool
 }
 
 type varScope struct {
@@ -38,12 +34,15 @@ type varScope struct {
 func NewEmitContext() *EmitContext {
 	c := &EmitContext{}
 	c.Factory = NewNodeFactory(c)
-	c.isCustomPrologue = c.isCustomPrologueWorker
-	c.isHoistedFunction = c.isHoistedFunctionWorker
-	c.isHoistedVariableStatement = c.isHoistedVariableStatementWorker
 	return c
 }
 
+func (c *EmitContext) Reset() {
+	*c = EmitContext{
+		Factory: c.Factory,
+	}
+}
+
 func (c *EmitContext) onCreate(node *ast.Node) {
 	node.Flags |= ast.NodeFlagsSynthesized
 }
@@ -260,14 +259,14 @@ func (c *EmitContext) mergeEnvironment(statements []*ast.Statement, declarations
 
 	// find standard prologues on left in the following order: standard directives, hoisted functions, hoisted variables, other custom
 	leftStandardPrologueEnd := findSpanEnd(statements, ast.IsPrologueDirective, 0)
-	leftHoistedFunctionsEnd := findSpanEnd(statements, c.isHoistedFunction, leftStandardPrologueEnd)
-	leftHoistedVariablesEnd := findSpanEnd(statements, c.isHoistedVariableStatement, leftHoistedFunctionsEnd)
+	leftHoistedFunctionsEnd := findSpanEndWithEmitContext(c, statements, (*EmitContext).isHoistedFunction, leftStandardPrologueEnd)
+	leftHoistedVariablesEnd := findSpanEndWithEmitContext(c, statements, (*EmitContext).isHoistedVariableStatement, leftHoistedFunctionsEnd)
 
 	// find standard prologues on right in the following order: standard directives, hoisted functions, hoisted variables, other custom
 	rightStandardPrologueEnd := findSpanEnd(declarations, ast.IsPrologueDirective, 0)
-	rightHoistedFunctionsEnd := findSpanEnd(declarations, c.isHoistedFunction, rightStandardPrologueEnd)
-	rightHoistedVariablesEnd := findSpanEnd(declarations, c.isHoistedVariableStatement, rightHoistedFunctionsEnd)
-	rightCustomPrologueEnd := findSpanEnd(declarations, c.isCustomPrologue, rightHoistedVariablesEnd)
+	rightHoistedFunctionsEnd := findSpanEndWithEmitContext(c, declarations, (*EmitContext).isHoistedFunction, rightStandardPrologueEnd)
+	rightHoistedVariablesEnd := findSpanEndWithEmitContext(c, declarations, (*EmitContext).isHoistedVariableStatement, rightHoistedFunctionsEnd)
+	rightCustomPrologueEnd := findSpanEndWithEmitContext(c, declarations, (*EmitContext).isCustomPrologue, rightHoistedVariablesEnd)
 	if rightCustomPrologueEnd != len(declarations) {
 		panic("Expected declarations to be valid standard or custom prologues")
 	}
@@ -316,20 +315,20 @@ func (c *EmitContext) mergeEnvironment(statements []*ast.Statement, declarations
 	return left, changed
 }
 
-func (c *EmitContext) isCustomPrologueWorker(node *ast.Statement) bool {
+func (c *EmitContext) isCustomPrologue(node *ast.Statement) bool {
 	return c.EmitFlags(node)&EFCustomPrologue != 0
 }
 
-func (c *EmitContext) isHoistedFunctionWorker(node *ast.Statement) bool {
-	return c.isCustomPrologueWorker(node) && ast.IsFunctionDeclaration(node)
+func (c *EmitContext) isHoistedFunction(node *ast.Statement) bool {
+	return c.isCustomPrologue(node) && ast.IsFunctionDeclaration(node)
 }
 
 func isHoistedVariable(node *ast.VariableDeclarationNode) bool {
 	return ast.IsIdentifier(node.Name()) && node.Initializer() == nil
 }
 
-func (c *EmitContext) isHoistedVariableStatementWorker(node *ast.Statement) bool {
-	return c.isCustomPrologueWorker(node) &&
+func (c *EmitContext) isHoistedVariableStatement(node *ast.Statement) bool {
+	return c.isCustomPrologue(node) &&
 		ast.IsVariableStatement(node) &&
 		core.Every(node.AsVariableStatement().DeclarationList.AsVariableDeclarationList().Declarations.Nodes, isHoistedVariable)
 }
diff --git a/internal/printer/utilities.go b/internal/printer/utilities.go
@@ -728,6 +728,14 @@ func makeIdentifierFromModuleName(moduleName string) string {
 	return builder.String()
 }
 
+func findSpanEndWithEmitContext[T any](c *EmitContext, array []T, test func(c *EmitContext, value T) bool, start int) int {
+	i := start
+	for i < len(array) && test(c, array[i]) {
+		i++
+	}
+	return i
+}
+
 func findSpanEnd[T any](array []T, test func(value T) bool, start int) int {
 	i := start
 	for i < len(array) && test(array[i]) {
diff --git a/internal/testutil/tsbaseline/type_symbol_baseline.go b/internal/testutil/tsbaseline/type_symbol_baseline.go
@@ -346,6 +346,8 @@ func (walker *typeWriterWalker) writeTypeOrSymbol(node *ast.Node, isSymbolWalk b
 	fileChecker, done := walker.getTypeCheckerForCurrentFile()
 	defer done()
 
+	ctx := printer.NewEmitContext()
+
 	if !isSymbolWalk {
 		// Don't try to get the type of something that's already a type.
 		// Exception for `T` in `type T = something` because that may evaluate to some interesting type.
@@ -382,7 +384,7 @@ func (walker *typeWriterWalker) writeTypeOrSymbol(node *ast.Node, isSymbolWalk b
 			!isIntrinsicJsxTag(node, walker.currentSourceFile) {
 			typeString = t.AsIntrinsicType().IntrinsicName()
 		} else {
-			ctx := printer.NewEmitContext()
+			ctx.Reset()
 			builder := checker.NewNodeBuilder(fileChecker, ctx)
 			typeFormatFlags := checker.TypeFormatFlagsNoTruncation | checker.TypeFormatFlagsAllowUniqueESSymbolType | checker.TypeFormatFlagsGenerateNamesForShadowedTypeParams
 			typeNode := builder.TypeToTypeNode(t, node.Parent, nodebuilder.Flags(typeFormatFlags&checker.TypeFormatFlagsNodeBuilderFlagsMask)|nodebuilder.FlagsIgnoreErrors, nodebuilder.InternalFlagsAllowUnresolvedNames, nil)

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,6 @@ func (b NodeBuilder) enterContext(enclosingDeclaration ast.Node, flags nodebui`
`36`	`36`	`tracker = NewSymbolTrackerImpl(b.impl.ctx, nil, b.host)`
`37`	`37`	`b.impl.ctx.tracker = tracker`
`38`	`38`	`}`
`39`		`- b.impl.initializeClosures() // recapture ctx`
`40`	`39`	`b.ctxStack = append(b.ctxStack, b.impl.ctx)`
`41`	`40`	`}`
`42`	`41`
`@@ -159,7 +158,7 @@ func (b NodeBuilder) TypePredicateToTypePredicateNode(predicate TypePredicate,`
`159`	`158`	`// TypeToTypeNode implements NodeBuilderInterface.`
`160`	`159`	`func (b NodeBuilder) TypeToTypeNode(typ Type, enclosingDeclaration ast.Node, flags nodebuilder.Flags, internalFlags nodebuilder.InternalFlags, tracker nodebuilder.SymbolTracker) ast.Node {`
`161`	`160`	`b.enterContext(enclosingDeclaration, flags, internalFlags, tracker)`
`162`		`- return b.exitContext(b.impl.typeToTypeNodeWorker(typ))`
	`161`	`+ return b.exitContext(b.impl.typeToTypeNode(typ))`
`163`	`162`	`}`
`164`	`163`
`165`	`164`	`// var _ NodeBuilderInterface = NewNodeBuilderAPI(nil, nil)`