Keep optional outer type parameters out of hot node links

Most resolved type nodes never need an anonymous object's outer type
parameter list. Reserving a slice header for every node makes the common
case needlessly expensive to retain and scan.

TypeNodeLinks now occupies 16 rather than 32 bytes on amd64. An optional
checker-owned arena entry preserves computed-empty lists and the
original slice aliasing without introducing a separate allocation per
cached list.

VS Code src/tsconfig.json versus the parent commit, six fresh-process
interleaved pairs with the normal GC policy. Retained bytes fall 0.43%,
scan bytes 0.47%, and allocated bytes 0.33%. Allocation events and
instruction counts are not statistically different; no CPU improvement
is claimed.

Exact production diagnostics and semantic counts match.

goos: linux
goarch: amd64
pkg: github.com/microsoft/TypeScript/tsc/internal/checker
cpu: Intel(R) Core(TM) i9-10900K CPU @ 3.70GHz
                   │ vscode-typeparams-before.txt │       vscode-typeparams.txt        │
                   │          retained-B          │  retained-B   vs base              │
ExternalProgram-20                   3.864Gi ± 0%   3.847Gi ± 0%  -0.43% (p=0.002 n=6)

                   │ vscode-typeparams-before.txt │       vscode-typeparams.txt        │
                   │            scan-B            │    scan-B     vs base              │
ExternalProgram-20                   3.459Gi ± 0%   3.443Gi ± 0%  -0.47% (p=0.002 n=6)

                   │ vscode-typeparams-before.txt │       vscode-typeparams.txt        │
                   │             B/op             │     B/op      vs base              │
ExternalProgram-20                   5.484Gi ± 0%   5.466Gi ± 0%  -0.33% (p=0.002 n=6)

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

                        │ typeparams-before-instructions.txt │   typeparams-instructions.txt    │
                        │          instructions/op           │ instructions/op  vs base         │
ExternalInstructions-20                          297.2G ± 2%       290.9G ± 4%  ~ (p=0.310 n=6)

Author: jakebailey

tsc/internal/checker/checker.go

@@ -686,6 +686,7 @@ type Checker struct {
 	indexedAccessTypeArena                      core.Arena[IndexedAccessType]
 	conditionalTypeArena                        core.Arena[ConditionalType]
 	typeListArena                               core.Arena[*Type]
+	outerTypeParameterListArena                 core.Arena[[]*Type]
 	valueSymbolExtraArena                       core.Arena[valueSymbolExtra]
 	structuredTypeExtraArena                    core.Arena[structuredTypeExtra]
 	freeTypeSets                                *temporaryTypeSet
@@ -22870,7 +22871,7 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type
 	default:
 		target = t
 	}
-	typeParameters = links.outerTypeParameters
+	typeParameters = links.getOuterTypeParameters()
 	if typeParameters == nil {
 		// The first time an anonymous type is instantiated we compute and store a list of the type
 		// parameters that are in scope (and therefore potentially referenced). For type literals that
@@ -22893,7 +22894,7 @@ func (c *Checker) getObjectTypeInstantiation(t *Type, m *TypeMapper, alias *Type
 		if typeParameters == nil {
 			typeParameters = []*Type{}
 		}
-		links.outerTypeParameters = typeParameters
+		links.setOuterTypeParameters(c, typeParameters)
 	}
 	if len(typeParameters) == 0 {
 		return t

tsc/internal/checker/types.go

@@ -438,8 +438,26 @@ type SymbolNodeLinks struct {
 }
 
 type TypeNodeLinks struct {
-	resolvedType        *Type   // Resolved type associated with node
-	outerTypeParameters []*Type // Outer type parameters of anonymous object type
+	resolvedType        *Type    // Resolved type associated with node
+	outerTypeParameters *[]*Type // Outer type parameters of anonymous object type
+}
+
+func (links *TypeNodeLinks) getOuterTypeParameters() []*Type {
+	if links.outerTypeParameters == nil {
+		return nil
+	}
+	return *links.outerTypeParameters
+}
+
+func (links *TypeNodeLinks) setOuterTypeParameters(c *Checker, types []*Type) {
+	if types == nil {
+		links.outerTypeParameters = nil
+		return
+	}
+	if links.outerTypeParameters == nil {
+		links.outerTypeParameters = c.outerTypeParameterListArena.New()
+	}
+	*links.outerTypeParameters = types
 }
 
 type ComputedNameNodeLinks struct {

tsc/internal/checker/types_test.go

@@ -441,3 +441,35 @@ func TestStructuredTypeExtra(t *testing.T) {
 	assert.Assert(t, data.getIndexInfos() != nil)
 	runtime.KeepAlive(c)
 }
+
+func TestCompactTypeNodeLinksLayout(t *testing.T) {
+	t.Parallel()
+	assert.Equal(t, unsafe.Sizeof(TypeNodeLinks{}), 2*unsafe.Sizeof(uintptr(0)))
+	c, types := newCompositeTestChecker()
+	var links TypeNodeLinks
+	links.resolvedType = types[0]
+	assert.Assert(t, links.getOuterTypeParameters() == nil)
+	links.setOuterTypeParameters(c, nil)
+	assert.Assert(t, links.outerTypeParameters == nil)
+	links.setOuterTypeParameters(c, []*Type{})
+	assert.Assert(t, links.getOuterTypeParameters() != nil)
+	assert.Equal(t, len(links.getOuterTypeParameters()), 0)
+	entry := links.outerTypeParameters
+	list := slices.Clone(types)
+	links.setOuterTypeParameters(c, list)
+	assert.Equal(t, links.outerTypeParameters, entry)
+	assert.Equal(t, links.getOuterTypeParameters()[0], types[0])
+	list[0] = types[1]
+	assert.Equal(t, links.getOuterTypeParameters()[0], types[1])
+	for range 1024 {
+		var other TypeNodeLinks
+		other.setOuterTypeParameters(c, types)
+	}
+	runtime.GC()
+	assert.Equal(t, links.getOuterTypeParameters()[0], types[1])
+	assert.Equal(t, links.resolvedType, types[0])
+	links.setOuterTypeParameters(c, nil)
+	assert.Assert(t, links.getOuterTypeParameters() == nil)
+	assert.Equal(t, links.resolvedType, types[0])
+	runtime.KeepAlive(c)
+}