@@ -691,6 +691,7 @@ type Checker struct {
 	valueSymbolExtraArena                       core.Arena[valueSymbolExtra]
 	structuredTypeExtraArena                    core.Arena[structuredTypeExtra]
 	freeTypeSets                                *temporaryTypeSet
+	freePropertyCounts                          *temporaryPropertyCounts
 	mergedSymbols                               map[*ast.Symbol]*ast.Symbol
 	mergedExportsChecked                        collections.Set[*ast.Symbol]
 	factory                                     ast.NodeFactory
@@ -22344,7 +22345,8 @@ func (c *Checker) isMappingOfSameObjectType(types []*Type) bool {
 
 func (c *Checker) somePropertyReducesToNever(t *Type) bool {
 	// Collect declaration counts for each property across all constituent types of the intersection.
-	var counts collections.OrderedMap[string, int]
+	counts := c.getTemporaryPropertyCounts()
+	defer c.releaseTemporaryPropertyCounts(counts)
 	for _, t := range t.Types() {
 		for _, prop := range c.getPropertiesOfType(t) {
 			counts.Set(prop.Name(), counts.GetOrZero(prop.Name())+1)
 
@@ -286,6 +286,88 @@ func TestTemporaryTypeSetReuse(t *testing.T) {
 	assert.Equal(t, c.getIntersectionType([]*Type{left, right}), primitives[1])
 }
 
+func TestIntersectionReductionAllocations(t *testing.T) { //nolint:paralleltest
+	if race.Enabled {
+		t.Skip("race instrumentation changes hashing allocations")
+	}
+	c, _ := newCompositeTestChecker()
+	members := make(ast.SymbolTable)
+	for i := range 128 {
+		name := strconv.Itoa(i)
+		members[name] = c.newSymbol(ast.SymbolFlagsProperty, name)
+	}
+	object := c.newAnonymousType(nil, members, nil, nil, nil)
+	intersection := c.newIntersectionType(ObjectFlagsNone, []*Type{object, object})
+	assert.Assert(t, !c.somePropertyReducesToNever(intersection))
+	assert.Equal(t, testing.AllocsPerRun(10, func() {
+		assert.Assert(t, !c.somePropertyReducesToNever(intersection))
+	}), float64(0))
+}
+
+func TestTemporaryPropertyCounts(t *testing.T) {
+	t.Parallel()
+	c := &Checker{}
+	outer := c.getTemporaryPropertyCounts()
+	outer.Set("second", 1)
+	outer.Set("first", 1)
+	outer.Set("second", 2)
+	assert.Assert(t, slices.Equal(slices.Collect(outer.Keys()), []string{"second", "first"}))
+	inner := c.getTemporaryPropertyCounts()
+	assert.Assert(t, inner != outer)
+	inner.Set("first", 4)
+	assert.Equal(t, outer.GetOrZero("first"), 1)
+	assert.Equal(t, outer.GetOrZero("second"), 2)
+	c.releaseTemporaryPropertyCounts(inner)
+	assert.Equal(t, inner.Size(), 0)
+	assert.Assert(t, !inner.Has("first"))
+	reused := c.getTemporaryPropertyCounts()
+	assert.Equal(t, reused, inner)
+	reused.Set("second", 3)
+	reused.Set("first", 5)
+	assert.Assert(t, slices.Equal(slices.Collect(reused.Keys()), []string{"second", "first"}))
+	assert.Equal(t, outer.GetOrZero("first"), 1)
+	c.releaseTemporaryPropertyCounts(reused)
+	c.releaseTemporaryPropertyCounts(outer)
+	runtime.GC()
+	reused = c.getTemporaryPropertyCounts()
+	assert.Equal(t, reused.Size(), 0)
+	assert.Assert(t, !reused.Has("second"))
+	for i := range 4097 {
+		reused.Set(strconv.Itoa(i), i)
+	}
+	c.releaseTemporaryPropertyCounts(reused)
+	for counts := c.freePropertyCounts; counts != nil; counts = counts.next {
+		assert.Assert(t, counts != reused)
+		assert.Equal(t, counts.Size(), 0)
+	}
+	assert.Assert(t, c.getTemporaryPropertyCounts() != reused)
+	other := &Checker{}
+	assert.Assert(t, other.getTemporaryPropertyCounts() != outer)
+}
+
+func TestIntersectionReductionReentrancy(t *testing.T) {
+	t.Parallel()
+	c, _ := newCompositeTestChecker()
+	property := c.newSymbol(ast.SymbolFlagsProperty, "value")
+	object := c.newAnonymousType(nil, ast.SymbolTable{"value": property}, nil, nil, nil)
+	inner := c.newIntersectionType(ObjectFlagsNone, []*Type{object, object})
+	outer := c.newIntersectionType(ObjectFlagsNone, []*Type{inner, object})
+	assert.Equal(t, c.getReducedType(outer), outer)
+	assert.Equal(t, c.getReducedType(inner), inner)
+	assert.Equal(t, c.getPropertyOfUnionOrIntersectionType(outer, "value", true), property)
+	assert.Assert(t, c.freePropertyCounts != nil)
+	assert.Assert(t, c.freePropertyCounts.next != nil)
+	workspace := c.freePropertyCounts
+	conflicting := c.newSymbolEx(ast.SymbolFlagsProperty, "value", ast.CheckFlagsContainsPrivate)
+	outer.AsUnionOrIntersectionType().propertyCacheWithoutFunctionPropertyAugment["value"] = conflicting
+	assert.Assert(t, c.somePropertyReducesToNever(outer))
+	assert.Equal(t, c.freePropertyCounts, workspace)
+	for counts := c.freePropertyCounts; counts != nil; counts = counts.next {
+		assert.Equal(t, counts.Size(), 0)
+		assert.Assert(t, !counts.Has("value"))
+	}
+}
+
 func BenchmarkCompositeTypeCacheHit(b *testing.B) {
 	c, types := newCompositeTestChecker()
 	union := c.getUnionType(types)
 
@@ -8,6 +8,7 @@ import (
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
 	"github.com/microsoft/TypeScript/tsc/internal/binder"
+	"github.com/microsoft/TypeScript/tsc/internal/collections"
 	"github.com/microsoft/TypeScript/tsc/internal/core"
 	"github.com/microsoft/TypeScript/tsc/internal/debug"
 	"github.com/microsoft/TypeScript/tsc/internal/diagnostics"
@@ -919,6 +920,33 @@ func (c *Checker) releaseTemporaryTypeSet(set *temporaryTypeSet) {
 	c.freeTypeSets = set
 }
 
+type temporaryPropertyCounts struct {
+	collections.OrderedMap[string, int]
+	next *temporaryPropertyCounts
+}
+
+func (c *Checker) getTemporaryPropertyCounts() *temporaryPropertyCounts {
+	counts := c.freePropertyCounts
+	if counts == nil {
+		return &temporaryPropertyCounts{}
+	}
+	c.freePropertyCounts = counts.next
+	counts.next = nil
+	return counts
+}
+
+func (c *Checker) releaseTemporaryPropertyCounts(counts *temporaryPropertyCounts) {
+	size := counts.Size()
+	counts.Clear()
+	// Recursive reductions borrow separate maps. Do not retain unusually
+	// large property tables or references to their names in the free list.
+	if size > 4096 {
+		return
+	}
+	counts.next = c.freePropertyCounts
+	c.freePropertyCounts = counts
+}
+
 func (s *orderedSet[T]) contains(value T) bool {
 	if s.valuesByKey == nil {
 		return slices.Contains(s.values, value)