Common pattern for reused state objects (#649)

Author: ahejlsberg

internal/checker/checker.go

@@ -721,8 +721,8 @@ type Checker struct {
 	lastGetCombinedNodeFlagsResult             ast.NodeFlags
 	lastGetCombinedModifierFlagsNode           *ast.Node
 	lastGetCombinedModifierFlagsResult         ast.ModifierFlags
-	inferenceStates                            []InferenceState
-	flowStates                                 []FlowState
+	freeinferenceState                         *InferenceState
+	freeFlowState                              *FlowState
 	flowLoopCache                              map[FlowLoopKey]*Type
 	flowLoopStack                              []FlowLoopInfo
 	sharedFlows                                []SharedFlow

internal/checker/flow.go

@@ -36,15 +36,32 @@ type SharedFlow struct {
 }
 
 type FlowState struct {
-	reference          *ast.Node
-	declaredType       *Type
-	initialType        *Type
-	flowContainer      *ast.Node
-	refKey             string
-	depth              int
-	sharedFlowStart    int
-	reduceLabels       []*ast.FlowReduceLabelData
-	reduceLabelsBuffer [4]*ast.FlowReduceLabelData
+	reference       *ast.Node
+	declaredType    *Type
+	initialType     *Type
+	flowContainer   *ast.Node
+	refKey          string
+	depth           int
+	sharedFlowStart int
+	reduceLabels    []*ast.FlowReduceLabelData
+	next            *FlowState
+}
+
+func (c *Checker) getFlowState() *FlowState {
+	f := c.freeFlowState
+	if f == nil {
+		f = &FlowState{}
+	}
+	c.freeFlowState = f.next
+	return f
+}
+
+func (c *Checker) putFlowState(f *FlowState) {
+	*f = FlowState{
+		reduceLabels: f.reduceLabels[:0],
+		next:         c.freeFlowState,
+	}
+	c.freeFlowState = f
 }
 
 func getFlowNodeOfNode(node *ast.Node) *ast.FlowNode {
@@ -69,20 +86,16 @@ func (c *Checker) getFlowTypeOfReferenceEx(reference *ast.Node, declaredType *Ty
 			return declaredType
 		}
 	}
-	flowStateCount := len(c.flowStates)
-	c.flowStates = slices.Grow(c.flowStates, 1)[:flowStateCount+1]
-	f := &c.flowStates[flowStateCount]
+	f := c.getFlowState()
 	f.reference = reference
 	f.declaredType = declaredType
 	f.initialType = core.Coalesce(initialType, declaredType)
 	f.flowContainer = flowContainer
 	f.sharedFlowStart = len(c.sharedFlows)
-	f.reduceLabels = f.reduceLabelsBuffer[:0]
 	c.flowInvocationCount++
 	evolvedType := c.getTypeAtFlowNode(f, flowNode).t
 	c.sharedFlows = c.sharedFlows[:f.sharedFlowStart]
-	c.flowStates[flowStateCount] = FlowState{}
-	c.flowStates = c.flowStates[:flowStateCount]
+	c.putFlowState(f)
 	// When the reference is 'x' in an 'x.length', 'x.push(value)', 'x.unshift(value)' or x[n] = value' operation,
 	// we give type 'any[]' to 'x' instead of using the type determined by control flow analysis such that operations
 	// on empty arrays are possible without implicit any errors and new element types can be inferred without
@@ -2442,15 +2455,15 @@ func (c *Checker) getFlowTypeInStaticBlocks(symbol *ast.Symbol, staticBlocks []*
 }
 
 func (c *Checker) isReachableFlowNode(flow *ast.FlowNode) bool {
-	result := c.isReachableFlowNodeWorker(flow, false /*noCacheCheck*/)
+	f := c.getFlowState()
+	result := c.isReachableFlowNodeWorker(f, flow, false /*noCacheCheck*/)
+	c.putFlowState(f)
 	c.lastFlowNode = flow
 	c.lastFlowNodeReachable = result
 	return result
 }
 
-func (c *Checker) isReachableFlowNodeWorker(flow *ast.FlowNode, noCacheCheck bool) bool {
-	var reduceLabelsBuffer [4]*ast.FlowReduceLabelData
-	reduceLabels := reduceLabelsBuffer[:0]
+func (c *Checker) isReachableFlowNodeWorker(f *FlowState, flow *ast.FlowNode, noCacheCheck bool) bool {
 	for {
 		if flow == c.lastFlowNode {
 			return c.lastFlowNodeReachable
@@ -2461,7 +2474,7 @@ func (c *Checker) isReachableFlowNodeWorker(flow *ast.FlowNode, noCacheCheck boo
 				if reachable, ok := c.flowNodeReachable[flow]; ok {
 					return reachable
 				}
-				reachable := c.isReachableFlowNodeWorker(flow, true /*noCacheCheck*/)
+				reachable := c.isReachableFlowNodeWorker(f, flow, true /*noCacheCheck*/)
 				c.flowNodeReachable[flow] = reachable
 				return reachable
 			}
@@ -2487,8 +2500,8 @@ func (c *Checker) isReachableFlowNodeWorker(flow *ast.FlowNode, noCacheCheck boo
 			flow = flow.Antecedent
 		case flags&ast.FlowFlagsBranchLabel != 0:
 			// A branching point is reachable if any branch is reachable.
-			for list := getBranchLabelAntecedents(flow, reduceLabels); list != nil; list = list.Next {
-				if c.isReachableFlowNodeWorker(list.Flow, false /*noCacheCheck*/) {
+			for list := getBranchLabelAntecedents(flow, f.reduceLabels); list != nil; list = list.Next {
+				if c.isReachableFlowNodeWorker(f, list.Flow, false /*noCacheCheck*/) {
 					return true
 				}
 			}
@@ -2510,9 +2523,9 @@ func (c *Checker) isReachableFlowNodeWorker(flow *ast.FlowNode, noCacheCheck boo
 		case flags&ast.FlowFlagsReduceLabel != 0:
 			// Cache is unreliable once we start adjusting labels
 			c.lastFlowNode = nil
-			reduceLabels = append(reduceLabels, flow.Node.AsFlowReduceLabelData())
-			result := c.isReachableFlowNodeWorker(flow.Antecedent, false /*noCacheCheck*/)
-			reduceLabels = reduceLabels[:len(reduceLabels)-1]
+			f.reduceLabels = append(f.reduceLabels, flow.Node.AsFlowReduceLabelData())
+			result := c.isReachableFlowNodeWorker(f, flow.Antecedent, false /*noCacheCheck*/)
+			f.reduceLabels = f.reduceLabels[:len(f.reduceLabels)-1]
 			return result
 		default:
 			return flags&ast.FlowFlagsUnreachable == 0
@@ -2536,16 +2549,21 @@ func (c *Checker) isFalseExpression(expr *ast.Node) bool {
 // Return true if the given flow node is preceded by a 'super(...)' call in every possible code path
 // leading to the node.
 func (c *Checker) isPostSuperFlowNode(flow *ast.FlowNode, noCacheCheck bool) bool {
-	var reduceLabelsBuffer [4]*ast.FlowReduceLabelData
-	reduceLabels := reduceLabelsBuffer[:0]
+	f := c.getFlowState()
+	result := c.isPostSuperFlowNodeWorker(f, flow, noCacheCheck)
+	c.putFlowState(f)
+	return result
+}
+
+func (c *Checker) isPostSuperFlowNodeWorker(f *FlowState, flow *ast.FlowNode, noCacheCheck bool) bool {
 	for {
 		flags := flow.Flags
 		if flags&ast.FlowFlagsShared != 0 {
 			if !noCacheCheck {
 				if postSuper, ok := c.flowNodePostSuper[flow]; ok {
 					return postSuper
 				}
-				postSuper := c.isPostSuperFlowNode(flow, true /*noCacheCheck*/)
+				postSuper := c.isPostSuperFlowNodeWorker(f, flow, true /*noCacheCheck*/)
 				c.flowNodePostSuper[flow] = postSuper
 			}
 			noCacheCheck = false
@@ -2559,8 +2577,8 @@ func (c *Checker) isPostSuperFlowNode(flow *ast.FlowNode, noCacheCheck bool) boo
 			}
 			flow = flow.Antecedent
 		case flags&ast.FlowFlagsBranchLabel != 0:
-			for list := getBranchLabelAntecedents(flow, reduceLabels); list != nil; list = list.Next {
-				if !c.isPostSuperFlowNode(list.Flow, false /*noCacheCheck*/) {
+			for list := getBranchLabelAntecedents(flow, f.reduceLabels); list != nil; list = list.Next {
+				if !c.isPostSuperFlowNodeWorker(f, list.Flow, false /*noCacheCheck*/) {
 					return false
 				}
 			}
@@ -2569,9 +2587,9 @@ func (c *Checker) isPostSuperFlowNode(flow *ast.FlowNode, noCacheCheck bool) boo
 			// A loop is post-super if the control flow path that leads to the top is post-super.
 			flow = flow.Antecedents.Flow
 		case flags&ast.FlowFlagsReduceLabel != 0:
-			reduceLabels = append(reduceLabels, flow.Node.AsFlowReduceLabelData())
-			result := c.isPostSuperFlowNode(flow.Antecedent, false /*noCacheCheck*/)
-			reduceLabels = reduceLabels[:len(reduceLabels)-1]
+			f.reduceLabels = append(f.reduceLabels, flow.Node.AsFlowReduceLabelData())
+			result := c.isPostSuperFlowNodeWorker(f, flow.Antecedent, false /*noCacheCheck*/)
+			f.reduceLabels = f.reduceLabels[:len(f.reduceLabels)-1]
 			return result
 		default:
 			// Unreachable nodes are considered post-super to silence errors

internal/checker/inference.go

@@ -26,21 +26,40 @@ type InferenceState struct {
 	visited           map[InferenceKey]InferencePriority
 	sourceStack       []*Type
 	targetStack       []*Type
+	next              *InferenceState
+}
+
+func (c *Checker) getInferenceState() *InferenceState {
+	n := c.freeinferenceState
+	if n == nil {
+		n = &InferenceState{}
+	}
+	c.freeinferenceState = n.next
+	return n
+}
+
+func (c *Checker) putInferenceState(n *InferenceState) {
+	clear(n.visited)
+	*n = InferenceState{
+		inferences:  n.inferences[:0],
+		visited:     n.visited,
+		sourceStack: n.sourceStack[:0],
+		targetStack: n.targetStack[:0],
+		next:        c.freeinferenceState,
+	}
+	c.freeinferenceState = n
 }
 
 func (c *Checker) inferTypes(inferences []*InferenceInfo, originalSource *Type, originalTarget *Type, priority InferencePriority, contravariant bool) {
-	inferenceStateCount := len(c.inferenceStates)
-	c.inferenceStates = slices.Grow(c.inferenceStates, 1)[:inferenceStateCount+1]
-	n := &c.inferenceStates[inferenceStateCount]
+	n := c.getInferenceState()
 	n.inferences = inferences
 	n.originalSource = originalSource
 	n.originalTarget = originalTarget
 	n.priority = priority
 	n.inferencePriority = InferencePriorityMaxValue
 	n.contravariant = contravariant
 	c.inferFromTypes(n, originalSource, originalTarget)
-	c.inferenceStates[inferenceStateCount] = InferenceState{}
-	c.inferenceStates = c.inferenceStates[:inferenceStateCount]
+	c.putInferenceState(n)
 }
 
 func (c *Checker) inferFromTypes(n *InferenceState, source *Type, target *Type) {

internal/checker/relater.go

@@ -365,12 +365,7 @@ func (c *Checker) checkTypeRelatedToEx(
 	headMessage *diagnostics.Message,
 	diagnosticOutput *[]*ast.Diagnostic,
 ) bool {
-	r := c.freeRelater
-	if r == nil {
-		r = &Relater{c: c}
-	} else {
-		c.freeRelater = r.next
-	}
+	r := c.getRelater()
 	r.relation = relation
 	r.errorNode = errorNode
 	r.relationCount = (16_000_000 - relation.size()) / 8
@@ -398,16 +393,7 @@ func (c *Checker) checkTypeRelatedToEx(
 		}
 		c.reportDiagnostic(createDiagnosticChainFromErrorChain(r.errorChain, r.errorNode, r.relatedInfo), diagnosticOutput)
 	}
-	r.maybeKeysSet.Clear()
-	*r = Relater{
-		c:            c,
-		maybeKeys:    r.maybeKeys[:0],
-		maybeKeysSet: r.maybeKeysSet,
-		sourceStack:  r.sourceStack[:0],
-		targetStack:  r.targetStack[:0],
-		next:         c.freeRelater,
-	}
-	c.freeRelater = r
+	c.putRelater(r)
 	return result != TernaryFalse
 }
 
@@ -2528,6 +2514,28 @@ type Relater struct {
 	next           *Relater
 }
 
+func (c *Checker) getRelater() *Relater {
+	r := c.freeRelater
+	if r == nil {
+		r = &Relater{c: c}
+	}
+	c.freeRelater = r.next
+	return r
+}
+
+func (c *Checker) putRelater(r *Relater) {
+	r.maybeKeysSet.Clear()
+	*r = Relater{
+		c:            c,
+		maybeKeys:    r.maybeKeys[:0],
+		maybeKeysSet: r.maybeKeysSet,
+		sourceStack:  r.sourceStack[:0],
+		targetStack:  r.targetStack[:0],
+		next:         c.freeRelater,
+	}
+	c.freeRelater = r
+}
+
 func (r *Relater) isRelatedToSimple(source *Type, target *Type) Ternary {
 	return r.isRelatedToEx(source, target, RecursionFlagsBoth, false /*reportErrors*/, nil /*headMessage*/, IntersectionStateNone)
 }

testdata/baselines/reference/submodule/conformance/neverReturningFunctions1.errors.txt

@@ -20,9 +20,10 @@ neverReturningFunctions1.ts(129,5): error TS7027: Unreachable code detected.
 neverReturningFunctions1.ts(139,9): error TS7027: Unreachable code detected.
 neverReturningFunctions1.ts(141,5): error TS7027: Unreachable code detected.
 neverReturningFunctions1.ts(148,9): error TS7027: Unreachable code detected.
+neverReturningFunctions1.ts(153,5): error TS7027: Unreachable code detected.
 
 
-==== neverReturningFunctions1.ts (22 errors) ====
+==== neverReturningFunctions1.ts (23 errors) ====
     function fail(message?: string): never {
         throw new Error(message);
     }
@@ -220,6 +221,8 @@ neverReturningFunctions1.ts(148,9): error TS7027: Unreachable code detected.
             x;
         }
         x;  // Unreachable
+        ~~
+!!! error TS7027: Unreachable code detected.
     }
 
     function f43() {