Keep SourceFile synchronization state out of accessor copies

SourceFile owns mutable metadata and synchronization primitives even
though ordinary AST nodes are value handles. Copying the file for a
field access races with concurrent binding and cache initialization,
including when the requested arena field itself is stable.

The focused regression reproduces the race before the fix. Both exact
race-enabled smoke commands and npx hereby validate --all now pass.

Author: jakebailey

notes/arena-ast.md

@@ -107,10 +107,14 @@ metadata operations even when the requested arena field was stable.
 The race was reported by the parallel race-enabled smoke job for
 [microsoft/TypeScript#64698](https://github.com/microsoft/TypeScript/pull/64698),
 [run 37849859691](https://github.com/microsoft/TypeScript/actions/runs/37849859691/job/113559811242).
-The required correction is pointer receivers for source-file field accessors,
-base conversions, and subtree-fact forwarding. Other concrete/base views should
-remain values. Record the implementation and regression evidence here with the
-fix.
+The fix generates pointer receivers for source-file field accessors, base
+conversions, and subtree-fact forwarding. Other concrete/base views remain
+values.
+
+Regression coverage checks the public generated method sets and concurrently
+reads source-file accessors while its metadata mutex is used. The regression
+reproduced the race before the fix. Both exact CI smoke commands pass with a
+race-enabled compiler after the fix.
 
 ## Performance observations
 
@@ -165,8 +169,10 @@ therefore also a generator input. Forced regeneration must be deterministic.
 
 The initial migration passed full validation with unchanged compiler baselines,
 focused race/checkptr tests, 32-bit tests, and a WASI AST test compilation.
-The CI receiver race needs its own regression and race-enabled smoke validation;
-the initial focused arena tests did not exercise concurrent metadata copies.
+The source-file receiver fix passes its focused race regression, both
+race-enabled smoke commands, and `npx hereby validate --all`, with unchanged
+compiler baselines. The initial focused arena tests did not exercise concurrent
+metadata copies.
 
 Relevant commands:
 

tools/scripts/tsc/go-arena.ts

@@ -165,13 +165,14 @@ function baseFieldOffset(w: Writer, base: NodeType, field: MemberInfo): string {
 }
 
 export function generateArenaView(w: Writer, node: NodeType): void {
+    const receiver = node.name === "SourceFile" ? "*SourceFile" : node.name;
     if (!node.handWritten && node.name !== "NodeBase") {
         w.write(`type ${node.name} struct { NodeDefault }`);
     }
     const fields = arenaFields(node);
     for (const [i, field] of fields.entries()) {
         const offset = node.isBase ? baseFieldOffset(w, node, field) : String(arenaHeaderWords + i);
-        emitField(w, node.name, { name: field.name, type: arenaFieldType(field), storage: storageType(field) }, offset);
+        emitField(w, receiver, { name: field.name, type: arenaFieldType(field), storage: storageType(field) }, offset);
     }
     const bases = new Set<string>();
     const visit = (type: NodeType) => {
@@ -183,14 +184,14 @@ export function generateArenaView(w: Writer, node: NodeType): void {
     visit(node);
     for (const base of bases) {
         if (base === "NodeBase") continue;
-        w.write(`func (node ${node.name}) ${base}() ${base} { return ${base}{NodeDefault{node.Node}} }`);
+        w.write(`func (node ${receiver}) ${base}() ${base} { return ${base}{NodeDefault{node.Node}} }`);
     }
     for (const method of ["computeSubtreeFacts", "propagateSubtreeFacts", "subtreeFactsWorker"]) {
         const owner = methodOwner(node, method);
         if (owner === node.name || owner === "NodeDefault" || (method === "subtreeFactsWorker" && owner !== "CompositeBase")) continue;
         const params = method === "subtreeFactsWorker" ? "self Node" : "";
         const args = method === "subtreeFactsWorker" ? "self" : "";
-        w.write(`func (node ${node.name}) ${method}(${params}) SubtreeFacts { return (${owner}{NodeDefault{node.Node}}).${method}(${args}) }`);
+        w.write(`func (node ${receiver}) ${method}(${params}) SubtreeFacts { return (${owner}{NodeDefault{node.Node}}).${method}(${args}) }`);
     }
     w.write("");
 }

tsc/internal/ast/ast_generated.go

@@ -1,7 +1,9 @@
 package ast_test
 
 import (
+	"reflect"
 	"runtime"
+	"sync"
 	"testing"
 
 	"github.com/microsoft/TypeScript/tsc/internal/ast"
@@ -11,6 +13,53 @@ import (
 	"gotest.tools/v3/assert"
 )
 
+func TestSourceFileAccessorsUsePointerReceivers(t *testing.T) {
+	t.Parallel()
+	value := reflect.TypeFor[ast.SourceFile]()
+	pointer := reflect.TypeFor[*ast.SourceFile]()
+	for _, name := range []string{
+		"Symbol", "SetSymbol", "Locals", "SetLocals", "NextContainer", "SetNextContainer",
+		"DeclarationBase", "LocalsContainerBase", "CompositeBase",
+	} {
+		if _, ok := value.MethodByName(name); ok {
+			t.Errorf("%s must not copy SourceFile metadata through a value receiver", name)
+		}
+		if _, ok := pointer.MethodByName(name); !ok {
+			t.Errorf("*SourceFile is missing %s", name)
+		}
+	}
+}
+
+func TestSourceFileAccessorsConcurrentMetadata(t *testing.T) {
+	t.Parallel()
+	factory := ast.NewNodeFactory(ast.NodeFactoryHooks{})
+	file := factory.NewSourceFile(ast.SourceFileParseOptions{}, "", nil, ast.Node{}).AsSourceFile()
+	key := ast.NewSourceFileDataKey[int]()
+	compute := func(*ast.SourceFile) int { return 1 }
+	file.GetOrComputeData(key, compute)
+	start := make(chan struct{})
+	var wait sync.WaitGroup
+	wait.Go(func() {
+		<-start
+		for range 1024 {
+			assert.Equal(t, file.GetOrComputeData(key, compute), 1)
+		}
+	})
+	wait.Go(func() {
+		<-start
+		for range 1024 {
+			assert.Equal(t, file.Symbol(), (*ast.Symbol)(nil))
+			assert.Assert(t, file.Locals() == nil)
+			assert.Assert(t, file.NextContainer().IsNil())
+			assert.Equal(t, file.DeclarationBase().AsNode(), file.AsNode())
+			assert.Equal(t, file.LocalsContainerBase().AsNode(), file.AsNode())
+			assert.Equal(t, file.CompositeBase().AsNode(), file.AsNode())
+		}
+	})
+	close(start)
+	wait.Wait()
+}
+
 func TestNodeAccessorsCastLayout(t *testing.T) {
 	t.Parallel()
 	factory := ast.NewNodeFactory(ast.NodeFactoryHooks{})