Keep hot node accessors within the inlining budget

On main, Node.Symbol, Locals, Body, Expression and similar accessors
are small enough to inline, so the checker reads a member with a few
loads. Here they were all out of line: reading a member took a kind
table lookup, a ref decode and a store lookup, and several also built
a panic message inline, which the inliner charges as a call.

Symbol, Locals and Body now use the same offset tables as Name and
Expression; the JSDoc tags whose Type is their type expression, and the
kinds that never had a Body, are expressed as overrides of the tables.
Side tables keep their zero value in their first slot so that reading
one needs no test, deref finds the store without the chunk helpers,
and panics carry the kind and build their message only when printed.

Wall-clock runs were too noisy to separate the change; single-threaded
runs with the collector off measure it:

       │   old.txt    │              new.txt               │
       │    insns     │    insns      vs base              │
VSCode   114.9G ± ∞ ¹   113.7G ± ∞ ¹  -1.11% (p=0.008 n=5)
¹ need >= 6 samples for confidence interval at level 0.95

       │   old.txt   │              new.txt              │
       │  task-sec   │  task-sec    vs base              │
VSCode   24.79 ± ∞ ¹   24.53 ± ∞ ¹  -1.03% (p=0.008 n=5)
¹ need >= 6 samples for confidence interval at level 0.95

Author: jakebailey

tools/scripts/tsc/generate-go-ast.ts

@@ -1260,16 +1260,20 @@ function hasMember(node: NodeType, name: string): boolean {
     return schemaMembers(node).some(member => member.name === name);
 }
 
-function generateMemberOffsetTable(w: CodeWriter, table: string, member: string, refType: string) {
-    const storage = goStorageName(member);
+// Overrides map a kind's Go constant to the storage of the field read for
+// the member instead, or to null if the kind has none.
+function generateMemberOffsetTable(w: CodeWriter, table: string, member: string, refType: string, overrides: Record<string, string | null> = {}) {
     w.write(`var ${table} = [kindFlowReduceLabelData + 1]uint8{`);
     w.push();
     for (const node of api.nodes()) {
-        const field = nodeRecordFields(node).find(f => f.storage === storage);
-        // Only refs can be read the same way for every kind.
-        if (field?.goType !== refType) continue;
         for (const kind of node.allKinds()) {
-            w.write(`${kind.formatGoConstant()}: uint8(unsafe.Offsetof(${dataName(node)}{}.${storage})),`);
+            const constant = kind.formatGoConstant();
+            const storage = constant in overrides ? overrides[constant] : goStorageName(member);
+            if (storage === null) continue;
+            const field = nodeRecordFields(node).find(f => f.storage === storage);
+            // Only refs can be read the same way for every kind.
+            if (field?.goType !== refType) continue;
+            w.write(`${constant}: uint8(unsafe.Offsetof(${dataName(node)}{}.${storage})),`);
         }
     }
     w.pop();
@@ -1297,20 +1301,28 @@ function generateMemberOffsetAccessor(w: CodeWriter, method: string, ret: string
 
 // Members read through Node by hand-written accessors, which find them by
 // these tables.
-const MEMBER_OFFSET_TABLES: { member: string; refType: string; }[] = [
+const MEMBER_OFFSET_TABLES: { member: string; refType: string; overrides?: Record<string, string | null>; }[] = [
     { member: "Expression", refType: "nodeRef" },
     { member: "Initializer", refType: "nodeRef" },
-    { member: "Type", refType: "nodeRef" },
+    {
+        member: "Type",
+        refType: "nodeRef",
+        overrides: { KindJSDocParameterTag: "typeExpression", KindJSDocPropertyTag: "typeExpression", KindJSDocVariadicType: null },
+    },
     { member: "PostfixToken", refType: "nodeRef" },
     { member: "QuestionToken", refType: "nodeRef" },
     { member: "QuestionDotToken", refType: "nodeRef" },
     { member: "TypeArguments", refType: "listRef" },
     { member: "Arguments", refType: "listRef" },
+    // Node.Body has never read the body of a class static block.
+    { member: "Body", refType: "nodeRef", overrides: { KindClassStaticBlockDeclaration: null } },
+    { member: "Symbol", refType: "sideRef" },
+    { member: "Locals", refType: "sideRef" },
 ];
 
 function generateMemberOffsetTables(w: CodeWriter) {
-    for (const { member, refType } of MEMBER_OFFSET_TABLES) {
-        generateMemberOffsetTable(w, `node${member}Offsets`, member, refType);
+    for (const { member, refType, overrides } of MEMBER_OFFSET_TABLES) {
+        generateMemberOffsetTable(w, `node${member}Offsets`, member, refType, overrides);
     }
 }
 

tsc/internal/ast/ast.go

@@ -220,9 +220,8 @@ type MutableNode struct{ Node }
 func (n Node) AsMutable() MutableNode { return MutableNode{n} }
 
 func (n Node) Symbol() *Symbol {
-	data := n.DeclarationData()
-	if !data.IsNil() {
-		return data.Symbol()
+	if off := nodeSymbolOffsets[n.Kind()]; off != 0 {
+		return n.store().symbols.items[*(*sideRef)(unsafe.Add(n.p, off))]
 	}
 	return nil
 }
@@ -236,17 +235,15 @@ func (n Node) LocalSymbol() *Symbol {
 }
 
 func (n Node) Locals() SymbolTable {
-	data := n.LocalsContainerData()
-	if !data.IsNil() {
-		return data.Locals()
+	if off := nodeLocalsOffsets[n.Kind()]; off != 0 {
+		return n.store().symbolTables.items[*(*sideRef)(unsafe.Add(n.p, off))]
 	}
 	return nil
 }
 
 func (n Node) Body() Node {
-	data := n.BodyData()
-	if !data.IsNil() {
-		return data.Body()
+	if off := nodeBodyOffsets[n.Kind()]; off != 0 {
+		return n.refAt(off)
 	}
 	return Node{}
 }
@@ -289,11 +286,24 @@ func (n Node) Text() string {
 	panic(fmt.Sprintf("Unhandled case in Node.Text: %s", n.Kind()))
 }
 
+// unhandledKind is the panic value of accessors given a kind without the
+// member. Its message is built only when printed, which keeps the accessors
+// small enough to inline.
+type unhandledKind struct {
+	method string
+	kind   Kind
+}
+
+func (e unhandledKind) Error() string {
+	return "Unhandled case in " + e.method + ": " + e.kind.String()
+}
+
 func (n Node) Expression() Node {
-	if off := nodeExpressionOffsets[n.Kind()]; off != 0 {
+	k := n.Kind()
+	if off := nodeExpressionOffsets[k]; off != 0 {
 		return n.refAt(off)
 	}
-	panic("Unhandled case in Node.Expression: " + n.Kind().String())
+	panic(unhandledKind{"Node.Expression", k})
 }
 
 func (n Node) RawText() string {
@@ -387,10 +397,11 @@ func (m MutableNode) SetExpression(expr Node) {
 }
 
 func (n Node) ArgumentList() NodeList {
-	if off := nodeArgumentsOffsets[n.Kind()]; off != 0 {
+	k := n.Kind()
+	if off := nodeArgumentsOffsets[k]; off != 0 {
 		return n.listAt(off)
 	}
-	panic("Unhandled case in Node.Arguments: " + n.Kind().String())
+	panic(unhandledKind{"Node.Arguments", k})
 }
 
 func (n Node) Arguments() []Node {
@@ -518,16 +529,11 @@ func (n Node) ModifierNodes() []Node {
 	return nil
 }
 
+// Type reads the type expression of JSDoc parameter and property tags, and
+// nothing for JSDocVariadicType, whose type is its operand.
 func (n Node) Type() Node {
-	switch k := n.Kind(); k {
-	case KindJSDocParameterTag, KindJSDocPropertyTag:
-		return n.AsJSDocParameterOrPropertyTag().TypeExpression()
-	case KindJSDocVariadicType:
-		return Node{}
-	default:
-		if off := nodeTypeOffsets[k]; off != 0 {
-			return n.refAt(off)
-		}
+	if off := nodeTypeOffsets[n.Kind()]; off != 0 {
+		return n.refAt(off)
 	}
 	return Node{}
 }
@@ -913,10 +919,11 @@ func (n Node) QuestionToken() TokenNode {
 }
 
 func (n Node) QuestionDotToken() Node {
-	if off := nodeQuestionDotTokenOffsets[n.Kind()]; off != 0 {
+	k := n.Kind()
+	if off := nodeQuestionDotTokenOffsets[k]; off != 0 {
 		return n.refAt(off)
 	}
-	panic("Unhandled case in Node.QuestionDotToken: " + n.Kind().String())
+	panic(unhandledKind{"Node.QuestionDotToken", k})
 }
 
 func (n Node) TypeExpression() Node {

tsc/internal/ast/ast_generated.go

@@ -222,7 +222,7 @@ func (n Node) derefList(f *listRef) NodeList {
 	if r&refNear != 0 {
 		return NodeList{unsafe.Add(unsafe.Pointer(f), int(int32(r))-refNear)}
 	}
-	return n.store().farLists[r>>1]
+	return (*chunkHeader)(unsafe.Add(n.p, -int((*nodeBaseData)(n.p).chunk))).store.farLists[r>>1]
 }
 
 func (n Node) derefModifiers(f *listRef) ModifierList {
@@ -263,5 +263,5 @@ func setListRef(c *chunkHeader, f *listRef, v NodeList) {
 // listAt returns the list that the field at offset off of n's record
 // refers to.
 func (n Node) listAt(off uint8) NodeList {
-	return n.derefList((*listRef)(unsafe.Add(n.rec(), off)))
+	return n.derefList((*listRef)(unsafe.Add(n.p, off)))
 }

tsc/internal/ast/list.go

@@ -80,7 +80,16 @@ const (
 func newNodeStore() *nodeStore {
 	// The first far slots are the absent node and list, which zero refs
 	// refer to.
-	return &nodeStore{far: make([]Node, 1), farLists: make([]NodeList, 1)}
+	return &nodeStore{
+		far:          make([]Node, 1),
+		farLists:     make([]NodeList, 1),
+		symbols:      newSideTable[*Symbol](),
+		symbolTables: newSideTable[SymbolTable](),
+		stringLists:  newSideTable[[]string](),
+		nodeSlices:   newSideTable[[]Node](),
+		values:       newSideTable[any](),
+		sourceFiles:  newSideTable[*SourceFile](),
+	}
 }
 
 // nodeBaseData is the header at the start of every node record.
@@ -133,13 +142,15 @@ func (n Node) deref(f *nodeRef) Node {
 	if r&refNear != 0 {
 		return Node{unsafe.Add(unsafe.Pointer(f), int(int32(r))-refNear)}
 	}
-	return n.store().far[r>>1]
+	// The store is found by hand rather than by n.store() to keep callers
+	// within the inlining budget.
+	return (*chunkHeader)(unsafe.Add(n.p, -int((*nodeBaseData)(n.p).chunk))).store.far[r>>1]
 }
 
 // refAt returns the node that the field at offset off of n's record refers
 // to.
 func (n Node) refAt(off uint8) Node {
-	return n.deref((*nodeRef)(unsafe.Add(n.rec(), off)))
+	return n.deref((*nodeRef)(unsafe.Add(n.p, off)))
 }
 
 // setRef makes the field f of n's record refer to v.
@@ -355,8 +366,9 @@ func (s *nodeStore) compactSide() {
 	s.farLists = slices.Clip(slices.Clone(s.farLists))
 }
 
-// A sideRef is a record field's slot in a side table, biased by one so that
-// zero means the zero value without a slot.
+// A sideRef is a record field's slot in a side table. The first slot holds
+// the zero value and is never written, so a zero ref reads as the zero value
+// without a slot of its own.
 type sideRef uint32
 
 // A sideTable is appended to only by its store's owner, before the store
@@ -365,23 +377,23 @@ type sideTable[T any] struct {
 	items []T
 }
 
+func newSideTable[T any]() sideTable[T] {
+	return sideTable[T]{items: make([]T, 1)}
+}
+
 func (t *sideTable[T]) get(r sideRef) T {
-	if r == 0 {
-		var zero T
-		return zero
-	}
-	return t.items[r-1]
+	return t.items[r]
 }
 
 // set stores v in r's slot, allocating one unless v is the zero value.
 func (t *sideTable[T]) set(r *sideRef, v T, isZero bool) {
 	if *r != 0 {
-		t.items[*r-1] = v
+		t.items[*r] = v
 		return
 	}
 	if !isZero {
-		t.items = append(t.items, v)
 		*r = sideRef(len(t.items))
+		t.items = append(t.items, v)
 	}
 }
 

tsc/internal/ast/store.go

@@ -106,7 +106,7 @@ func TestNodeSideTableZeroValues(t *testing.T) {
 	assert.Assert(t, node.AsBlock().Locals() != nil)
 	node.AsBlock().SetLocals(nil)
 	assert.Assert(t, node.AsBlock().Locals() == nil)
-	assert.Equal(t, len(factory.store.symbolTables.items), 1)
+	assert.Equal(t, len(factory.store.symbolTables.items), 2)
 }
 
 func TestNodeTextRefs(t *testing.T) {