Move optional structured type shape into cold storage

Every object, union, and intersection paid for signature and index-info
slice headers, a call-signature count, and a node-builder cache, even
when none were needed. Those fields made StructuredType 144 bytes on
amd64. Keep them in an optional checker-arena sidecar and reduce the
hot record to 88 bytes.

Preserve signature publication during recursive anonymous resolution,
clipped public signature slices, index-info nil/empty distinctions,
and independent node-builder cache identity. Empty unresolved shape
does not allocate a sidecar.

Compared with the parent commit, including all previous checker, AST,
and symbol reductions. Six fresh-process
interleaved samples parse, bind, and check the actual VS Code project
using one checker and normal GC settings.

Live heap falls another 1.81%, GC scan bytes fall 2.01%, and allocated
bytes fall 1.28%. Allocation counts do not differ significantly.
Neither hardware instructions nor elapsed time establishes a change;
this does not claim a CPU improvement.

Exact CLI diagnostic text and compiler counts match the baseline.

Exact benchstat output:

goos: linux
goarch: amd64
pkg: github.com/microsoft/TypeScript/tsc/internal/checker
cpu: Intel(R) Core(TM) i9-10900K CPU @ 3.70GHz
                   │ vscode-shape-before.txt │       vscode-shape.txt       │
                   │         sec/op          │   sec/op     vs base         │
ExternalProgram-20                41.55 ± 6%   41.84 ± 13%  ~ (p=0.937 n=6)

                   │ vscode-shape-before.txt │        vscode-shape.txt        │
                   │       diagnostics       │ diagnostics  vs base           │
ExternalProgram-20                321.0 ± 0%    321.0 ± 0%  ~ (p=1.000 n=6) ¹
¹ all samples are equal

                   │ vscode-shape-before.txt │        vscode-shape.txt        │
                   │          files          │    files     vs base           │
ExternalProgram-20               10.28k ± 0%   10.28k ± 0%  ~ (p=1.000 n=6) ¹
¹ all samples are equal

                   │ vscode-shape-before.txt │          vscode-shape.txt          │
                   │       retained-B        │  retained-B   vs base              │
ExternalProgram-20              3.959Gi ± 0%   3.887Gi ± 0%  -1.81% (p=0.002 n=6)

                   │ vscode-shape-before.txt │          vscode-shape.txt          │
                   │         scan-B          │    scan-B     vs base              │
ExternalProgram-20              3.553Gi ± 0%   3.482Gi ± 0%  -2.01% (p=0.002 n=6)

                   │ vscode-shape-before.txt │        vscode-shape.txt        │
                   │         symbols         │   symbols    vs base           │
ExternalProgram-20               4.154M ± 0%   4.154M ± 0%  ~ (p=1.000 n=6) ¹
¹ all samples are equal

                   │ vscode-shape-before.txt │          vscode-shape.txt          │
                   │          B/op           │     B/op      vs base              │
ExternalProgram-20              5.577Gi ± 0%   5.506Gi ± 0%  -1.28% (p=0.002 n=6)

                   │ vscode-shape-before.txt │       vscode-shape.txt       │
                   │        allocs/op        │  allocs/op   vs base         │
ExternalProgram-20               27.36M ± 0%   27.35M ± 0%  ~ (p=0.818 n=6)

                        │ shape-before-instructions.txt │      shape-instructions.txt      │
                        │        instructions/op        │ instructions/op  vs base         │
ExternalInstructions-20                     292.5G ± 4%       301.6G ± 4%  ~ (p=0.093 n=6)

Author: jakebailey

tsc/internal/checker/checker.go

@@ -685,6 +685,7 @@ type Checker struct {
 	conditionalTypeArena                        core.Arena[ConditionalType]
 	typeListArena                               core.Arena[*Type]
 	valueSymbolExtraArena                       core.Arena[valueSymbolExtra]
+	structuredTypeExtraArena                    core.Arena[structuredTypeExtra]
 	freeTypeSets                                *temporaryTypeSet
 	mergedSymbols                               map[*ast.Symbol]*ast.Symbol
 	mergedExportsChecked                        collections.Set[*ast.Symbol]
@@ -4604,7 +4605,7 @@ func (c *Checker) getTypeWithoutSignatures(t *Type) *Type {
 	switch {
 	case t.flags&TypeFlagsObject != 0:
 		resolved := c.resolveStructuredTypeMembers(t)
-		if len(resolved.signatures) != 0 {
+		if len(resolved.getSignatures()) != 0 {
 			result := c.newObjectType(ObjectFlagsAnonymous, t.symbol)
 			result.objectFlags |= ObjectFlagsMembersResolved
 			result.AsObjectType().members = resolved.members
@@ -10944,7 +10945,7 @@ func (c *Checker) getInstantiationExpressionType(exprType *Type, node *ast.Node)
 					debug.Assert(t.symbol != nil, "Instantiation expression source type must have a symbol")
 					symbol.SetDeclarations(t.symbol.Declarations())
 					result := c.newObjectType(ObjectFlagsAnonymous|ObjectFlagsInstantiationExpressionType, symbol)
-					c.setStructuredTypeMembers(result, resolved.members, callSignatures, constructSignatures, resolved.indexInfos)
+					c.setStructuredTypeMembers(result, resolved.members, callSignatures, constructSignatures, resolved.getIndexInfos())
 					result.AsInstantiationExpressionType().node = node
 					return result
 				}
@@ -16139,7 +16140,7 @@ func (c *Checker) cloneTypeAsModuleType(symbol *ast.Symbol, moduleType *Type, re
 	links.target = symbol
 	links.originatingImport = referenceParent
 	resolvedModuleType := c.resolveStructuredTypeMembers(moduleType)
-	c.valueSymbolLinks.Get(result).resolvedType = c.newAnonymousType(result, resolvedModuleType.members, nil, nil, resolvedModuleType.indexInfos)
+	c.valueSymbolLinks.Get(result).resolvedType = c.newAnonymousType(result, resolvedModuleType.members, nil, nil, resolvedModuleType.getIndexInfos())
 	return result
 }
 
@@ -19403,10 +19404,13 @@ func (c *Checker) getSignaturesOfStructuredType(t *Type, kind SignatureKind) []*
 		return nil
 	}
 	resolved := c.resolveStructuredTypeMembers(t)
+	if resolved.extra == nil {
+		return nil
+	}
 	if kind == SignatureKindCall {
-		return resolved.signatures[:resolved.callSignatureCount]
+		return resolved.extra.signatures[:resolved.extra.callSignatureCount]
 	}
-	return resolved.signatures[resolved.callSignatureCount:]
+	return resolved.extra.signatures[resolved.extra.callSignatureCount:]
 }
 
 func (c *Checker) getIndexInfosOfType(t *Type) []*IndexInfo {
@@ -19415,7 +19419,7 @@ func (c *Checker) getIndexInfosOfType(t *Type) []*IndexInfo {
 
 func (c *Checker) getIndexInfosOfStructuredType(t *Type) []*IndexInfo {
 	if t.flags&TypeFlagsStructuredType != 0 {
-		return c.resolveStructuredTypeMembers(t).indexInfos
+		return c.resolveStructuredTypeMembers(t).getIndexInfos()
 	}
 	return nil
 }
@@ -19788,7 +19792,7 @@ func (c *Checker) getSingleCallOrConstructSignature(t *Type) *Signature {
 func (c *Checker) getSingleSignature(t *Type, kind SignatureKind, allowMembers bool) *Signature {
 	if t.flags&TypeFlagsObject != 0 {
 		resolved := c.resolveStructuredTypeMembers(t)
-		if allowMembers || len(resolved.properties) == 0 && len(resolved.indexInfos) == 0 {
+		if allowMembers || len(resolved.properties) == 0 && len(resolved.getIndexInfos()) == 0 {
 			if kind == SignatureKindCall && len(resolved.CallSignatures()) == 1 && len(resolved.ConstructSignatures()) == 0 {
 				return resolved.CallSignatures()[0]
 			}
@@ -21141,14 +21145,20 @@ func (c *Checker) resolveAnonymousTypeMembers(t *Type) {
 			indexInfos = append(indexInfos, c.enumNumberIndexInfo)
 		}
 	}
-	d.indexInfos = indexInfos
+	if indexInfos != nil || d.extra != nil {
+		d.ensureExtra(c).indexInfos = indexInfos
+	}
 	// We resolve the members before computing the signatures because a signature may use
 	// typeof with a qualified name expression that circularly references the type we are
 	// in the process of resolving (see issue #6072). The temporarily empty signature list
 	// will never be observed because a qualified name can't reference signatures.
 	if symbol.Flags()&(ast.SymbolFlagsFunction|ast.SymbolFlagsMethod) != 0 {
-		d.signatures = c.getSignaturesOfSymbol(symbol)
-		d.callSignatureCount = len(d.signatures)
+		signatures := c.getSignaturesOfSymbol(symbol)
+		if signatures != nil || d.extra != nil {
+			extra := d.ensureExtra(c)
+			extra.signatures = signatures
+			extra.callSignatureCount = len(signatures)
+		}
 	}
 	// And likewise for construct signatures for classes
 	if symbol.Flags()&ast.SymbolFlagsClass != 0 {
@@ -21157,7 +21167,10 @@ func (c *Checker) resolveAnonymousTypeMembers(t *Type) {
 		if len(constructSignatures) == 0 {
 			constructSignatures = c.getDefaultConstructSignatures(classType)
 		}
-		d.signatures = append(d.signatures, constructSignatures...)
+		if len(constructSignatures) != 0 {
+			extra := d.ensureExtra(c)
+			extra.signatures = append(extra.signatures, constructSignatures...)
+		}
 	}
 }
 
@@ -25716,22 +25729,30 @@ func (c *Checker) setStructuredTypeMembers(t *Type, members ast.SymbolTable, cal
 	data := t.AsStructuredType()
 	data.members = members
 	data.properties = c.getNamedMembers(members, t.symbol)
+	c.setStructuredTypeSignatures(data, callSignatures, constructSignatures, indexInfos)
+}
+
+func (c *Checker) setStructuredTypeSignatures(data *StructuredType, callSignatures []*Signature, constructSignatures []*Signature, indexInfos []*IndexInfo) {
+	if data.extra == nil && callSignatures == nil && constructSignatures == nil && indexInfos == nil {
+		return
+	}
+	extra := data.ensureExtra(c)
 	if len(callSignatures) != 0 {
 		if len(constructSignatures) != 0 {
-			data.signatures = core.Concatenate(callSignatures, constructSignatures)
+			extra.signatures = core.Concatenate(callSignatures, constructSignatures)
 		} else {
-			data.signatures = slices.Clip(callSignatures)
+			extra.signatures = slices.Clip(callSignatures)
 		}
-		data.callSignatureCount = len(callSignatures)
+		extra.callSignatureCount = len(callSignatures)
 	} else {
 		if len(constructSignatures) != 0 {
-			data.signatures = slices.Clip(constructSignatures)
+			extra.signatures = slices.Clip(constructSignatures)
 		} else {
-			data.signatures = nil
+			extra.signatures = nil
 		}
-		data.callSignatureCount = 0
+		extra.callSignatureCount = 0
 	}
-	data.indexInfos = slices.Clip(indexInfos)
+	extra.indexInfos = slices.Clip(indexInfos)
 }
 
 func (c *Checker) newTypeParameter(symbol *ast.Symbol) *Type {
@@ -27061,7 +27082,7 @@ func (c *Checker) IsEmptyAnonymousObjectType(t *Type) bool {
 }
 
 func (c *Checker) isEmptyResolvedType(t *StructuredType) bool {
-	return t.AsType() != c.anyFunctionType && len(t.properties) == 0 && len(t.signatures) == 0 && len(t.indexInfos) == 0
+	return t.AsType() != c.anyFunctionType && len(t.properties) == 0 && len(t.getSignatures()) == 0 && len(t.getIndexInfos()) == 0
 }
 
 func (c *Checker) isEmptyObjectType(t *Type) bool {
@@ -28445,7 +28466,7 @@ func (c *Checker) containsUndefinedType(t *Type) bool {
 }
 
 func (c *Checker) typeHasCallOrConstructSignatures(t *Type) bool {
-	return t.flags&TypeFlagsStructuredType != 0 && len(c.resolveStructuredTypeMembers(t).signatures) != 0
+	return t.flags&TypeFlagsStructuredType != 0 && len(c.resolveStructuredTypeMembers(t).getSignatures()) != 0
 }
 
 func (c *Checker) getNormalizedType(t *Type, writing bool) *Type {
@@ -28752,7 +28773,7 @@ func (c *Checker) getRegularTypeOfObjectLiteral(t *Type) *Type {
 	}
 	resolved := c.resolveStructuredTypeMembers(t)
 	members := c.transformTypeOfMembers(t, c.getRegularTypeOfObjectLiteral)
-	regular := c.newAnonymousType(t.symbol, members, resolved.CallSignatures(), resolved.ConstructSignatures(), resolved.indexInfos)
+	regular := c.newAnonymousType(t.symbol, members, resolved.CallSignatures(), resolved.ConstructSignatures(), resolved.getIndexInfos())
 	regular.flags = resolved.flags
 	regular.objectFlags |= resolved.objectFlags & ^ObjectFlagsFreshLiteral
 	c.cachedTypes[key] = regular
@@ -31745,7 +31766,7 @@ func (c *Checker) isFunctionObjectType(t *Type) bool {
 	// We do a quick check for a "bind" property before performing the more expensive subtype
 	// check. This gives us a quicker out in the common case where an object type is not a function.
 	resolved := c.resolveStructuredTypeMembers(t)
-	return len(resolved.signatures) != 0 || resolved.members["bind"] != nil && c.isTypeSubtypeOf(t, c.globalFunctionType)
+	return len(resolved.getSignatures()) != 0 || resolved.members["bind"] != nil && c.isTypeSubtypeOf(t, c.globalFunctionType)
 }
 
 func (c *Checker) getTypeWithFacts(t *Type, include TypeFacts) *Type {

tsc/internal/checker/nodebuilderimpl.go

@@ -566,19 +566,19 @@ func (b *NodeBuilderImpl) getResolvedTypeWithoutAbstractConstructSignatures(t *S
 	if len(t.ConstructSignatures()) == 0 {
 		return t.AsType()
 	}
-	if t.objectTypeWithoutAbstractConstructSignatures != nil {
-		return t.objectTypeWithoutAbstractConstructSignatures
+	if t.extra.objectTypeWithoutAbstractConstructSignatures != nil {
+		return t.extra.objectTypeWithoutAbstractConstructSignatures
 	}
 	constructSignatures := core.Filter(t.ConstructSignatures(), func(signature *Signature) bool {
 		return signature.flags&SignatureFlagsAbstract == 0
 	})
 	if len(constructSignatures) == len(t.ConstructSignatures()) {
-		t.objectTypeWithoutAbstractConstructSignatures = t.AsType()
+		t.extra.objectTypeWithoutAbstractConstructSignatures = t.AsType()
 		return t.AsType()
 	}
-	typeCopy := b.ch.newAnonymousType(t.symbol, t.members, t.CallSignatures(), core.IfElse(len(constructSignatures) > 0, constructSignatures, []*Signature{}), t.indexInfos)
-	t.objectTypeWithoutAbstractConstructSignatures = typeCopy
-	typeCopy.AsStructuredType().objectTypeWithoutAbstractConstructSignatures = typeCopy
+	typeCopy := b.ch.newAnonymousType(t.symbol, t.members, t.CallSignatures(), core.IfElse(len(constructSignatures) > 0, constructSignatures, []*Signature{}), t.getIndexInfos())
+	t.extra.objectTypeWithoutAbstractConstructSignatures = typeCopy
+	typeCopy.AsStructuredType().ensureExtra(b.ch).objectTypeWithoutAbstractConstructSignatures = typeCopy
 	return typeCopy
 }
 
@@ -2737,7 +2737,7 @@ func (b *NodeBuilderImpl) createTypeNodesFromResolvedType(resolvedType *Structur
 		}
 		typeElements = append(typeElements, b.signatureToSignatureDeclarationHelper(signature, ast.KindConstructSignature, nil))
 	}
-	for _, info := range resolvedType.indexInfos {
+	for _, info := range resolvedType.getIndexInfos() {
 		var typeNode *ast.TypeNode
 		if resolvedType.objectFlags&ObjectFlagsReverseMapped != 0 && b.ctx.flags&nodebuilder.FlagsAllowAnonymousIdentifier != 0 {
 			typeNode = b.createElidedInformationPlaceholder()
@@ -2794,7 +2794,7 @@ func (b *NodeBuilderImpl) createTypeNodeFromObjectType(t *Type) *ast.TypeNode {
 	resolved := b.ch.resolveStructuredTypeMembers(t)
 	callSigs := resolved.CallSignatures()
 	ctorSigs := resolved.ConstructSignatures()
-	if len(resolved.properties) == 0 && len(resolved.indexInfos) == 0 {
+	if len(resolved.properties) == 0 && len(resolved.getIndexInfos()) == 0 {
 		if len(callSigs) == 0 && len(ctorSigs) == 0 {
 			b.ctx.approximateLength += 2
 			result := b.f.NewTypeLiteralNode(b.f.NewNodeList([]*ast.Node{}))
@@ -2823,7 +2823,7 @@ func (b *NodeBuilderImpl) createTypeNodeFromObjectType(t *Type) *ast.TypeNode {
 			return b.ch.getOrCreateTypeFromSignature(s)
 		})
 		// count the number of type elements excluding abstract constructors
-		typeElementCount := len(callSigs) + (len(ctorSigs) - len(abstractSignatures)) + len(resolved.indexInfos) + core.IfElse(b.ctx.flags&nodebuilder.FlagsWriteClassExpressionAsTypeLiteral != 0, core.CountWhere(resolved.properties, func(p *ast.Symbol) bool {
+		typeElementCount := len(callSigs) + (len(ctorSigs) - len(abstractSignatures)) + len(resolved.getIndexInfos()) + core.IfElse(b.ctx.flags&nodebuilder.FlagsWriteClassExpressionAsTypeLiteral != 0, core.CountWhere(resolved.properties, func(p *ast.Symbol) bool {
 			return p.Flags()&ast.SymbolFlagsPrototype == 0
 		}), len(resolved.properties))
 		// don't include an empty object literal if there were no other static-side

tsc/internal/checker/relater.go

@@ -679,7 +679,7 @@ func (c *Checker) elaborateArrowFunction(node *ast.Node, source *Type, target *T
 func (c *Checker) isWeakType(t *Type) bool {
 	if t.flags&TypeFlagsObject != 0 {
 		resolved := c.resolveStructuredTypeMembers(t)
-		return len(resolved.signatures) == 0 && len(resolved.indexInfos) == 0 && len(resolved.properties) > 0 && core.Every(resolved.properties, func(p *ast.Symbol) bool {
+		return len(resolved.getSignatures()) == 0 && len(resolved.getIndexInfos()) == 0 && len(resolved.properties) > 0 && core.Every(resolved.properties, func(p *ast.Symbol) bool {
 			return p.Flags()&ast.SymbolFlagsOptional != 0
 		})
 	}

tsc/internal/checker/types.go

@@ -1096,8 +1096,12 @@ func (t *ConstrainedType) AsConstrainedType() *ConstrainedType { return t }
 
 type StructuredType struct {
 	ConstrainedType
-	members            ast.SymbolTable
-	properties         []*ast.Symbol
+	members    ast.SymbolTable
+	properties []*ast.Symbol
+	extra      *structuredTypeExtra
+}
+
+type structuredTypeExtra struct {
 	signatures         []*Signature // Signatures (call + construct)
 	callSignatureCount int          // Count of call signatures
 	indexInfos         []*IndexInfo
@@ -1108,11 +1112,38 @@ type StructuredType struct {
 func (t *StructuredType) AsStructuredType() *StructuredType { return t }
 
 func (t *StructuredType) CallSignatures() []*Signature {
-	return slices.Clip(t.signatures[:t.callSignatureCount])
+	if t.extra == nil {
+		return nil
+	}
+	return slices.Clip(t.extra.signatures[:t.extra.callSignatureCount])
 }
 
 func (t *StructuredType) ConstructSignatures() []*Signature {
-	return slices.Clip(t.signatures[t.callSignatureCount:])
+	if t.extra == nil {
+		return nil
+	}
+	return slices.Clip(t.extra.signatures[t.extra.callSignatureCount:])
+}
+
+func (t *StructuredType) getSignatures() []*Signature {
+	if t.extra == nil {
+		return nil
+	}
+	return t.extra.signatures
+}
+
+func (t *StructuredType) getIndexInfos() []*IndexInfo {
+	if t.extra == nil {
+		return nil
+	}
+	return t.extra.indexInfos
+}
+
+func (t *StructuredType) ensureExtra(c *Checker) *structuredTypeExtra {
+	if t.extra == nil {
+		t.extra = c.structuredTypeExtraArena.New()
+	}
+	return t.extra
 }
 
 func (t *StructuredType) Properties() []*ast.Symbol {

tsc/internal/checker/types_test.go

@@ -391,3 +391,53 @@ func TestCompactValueSymbolLinksLayout(t *testing.T) {
 	assert.Equal(t, links.getWriteType(), types[0])
 	assert.Equal(t, links.getContainingType(), types[2])
 }
+
+func TestCompactStructuredTypeLayout(t *testing.T) {
+	t.Parallel()
+	assert.Equal(t, unsafe.Sizeof(StructuredType{}), unsafe.Sizeof(ConstrainedType{})+5*unsafe.Sizeof(uintptr(0)))
+}
+
+func TestStructuredTypeExtra(t *testing.T) {
+	t.Parallel()
+	c, types := newCompositeTestChecker()
+	data := c.newAnonymousType(nil, nil, nil, nil, nil).AsStructuredType()
+	assert.Assert(t, data.extra == nil)
+	assert.Assert(t, data.CallSignatures() == nil)
+	assert.Assert(t, data.ConstructSignatures() == nil)
+	assert.Assert(t, data.getIndexInfos() == nil)
+	c.setStructuredTypeSignatures(data, nil, nil, nil)
+	assert.Assert(t, data.extra == nil)
+
+	call := &Signature{}
+	construct := &Signature{}
+	info := &IndexInfo{keyType: types[0]}
+	c.setStructuredTypeSignatures(data, []*Signature{call}, []*Signature{construct}, []*IndexInfo{info})
+	assert.Equal(t, data.CallSignatures()[0], call)
+	assert.Equal(t, data.ConstructSignatures()[0], construct)
+	assert.Equal(t, cap(data.CallSignatures()), 1)
+	assert.Equal(t, cap(data.ConstructSignatures()), 1)
+	assert.Equal(t, data.getIndexInfos()[0], info)
+	extra := data.extra
+	extra.objectTypeWithoutAbstractConstructSignatures = types[2]
+	for range 1024 {
+		other := c.newAnonymousType(nil, nil, []*Signature{call}, nil, nil)
+		assert.Assert(t, other.AsStructuredType().extra != extra)
+	}
+	runtime.GC()
+	assert.Equal(t, data.CallSignatures()[0], call)
+	assert.Equal(t, data.ConstructSignatures()[0], construct)
+	assert.Equal(t, data.getIndexInfos()[0], info)
+	assert.Equal(t, data.extra.objectTypeWithoutAbstractConstructSignatures, types[2])
+	c.setStructuredTypeSignatures(data, nil, []*Signature{construct}, nil)
+	assert.Equal(t, len(data.CallSignatures()), 0)
+	assert.Equal(t, data.ConstructSignatures()[0], construct)
+	assert.Assert(t, data.getIndexInfos() == nil)
+	c.setStructuredTypeSignatures(data, nil, nil, nil)
+	assert.Assert(t, data.CallSignatures() == nil)
+	assert.Assert(t, data.ConstructSignatures() == nil)
+	assert.Equal(t, data.extra, extra)
+	assert.Equal(t, extra.objectTypeWithoutAbstractConstructSignatures, types[2])
+	c.setStructuredTypeSignatures(data, nil, nil, []*IndexInfo{})
+	assert.Assert(t, data.getIndexInfos() != nil)
+	runtime.KeepAlive(c)
+}