Files
tsgo/_scripts/generate-go-ast.ts

1106 lines
42 KiB
TypeScript

/**
* Go AST code generator: reads _scripts/ast.json and produces internal/ast/ast_generated.go
*
* Usage: node --experimental-strip-types _scripts/generate-go-ast.ts
*
* Generates:
* - Struct definitions for each node kind
* - As*() cast methods on *Node
* - New*()/Update*() factory methods on *NodeFactory
* - ForEachChild() implementations
* - VisitEachChild() implementations
* - Clone() implementations
* - Polymorphic accessor switch statements (Expression(), Type(), etc.)
* - Is*() type guard functions
*/
import { execaSync } from "execa";
import * as fs from "node:fs";
import * as path from "node:path";
import { fileURLToPath } from "node:url";
import type {
MemberInfo,
NodeType,
Type,
} from "./schema.ts";
import {
api,
kindGuardName,
} from "./schema.ts";
// ────────────────────────────────────────────────────────────────────────────
// Load schema
// ────────────────────────────────────────────────────────────────────────────
const ROOT = path.resolve(import.meta.dirname!, "..");
// Members that participate in factory/visitor/clone (excludes noFactory)
function schemaMembers(node: NodeType): MemberInfo[] {
return node.members.filter(m => !m.noFactory);
}
function isTextContentType(type: Type): boolean {
if (type.kind === "primitive") {
return type.name === "string";
}
if (type.kind === "list" && type.listKind === "raw") {
return type.elementType.kind === "primitive" && type.elementType.name === "string";
}
return false;
}
// Does this node have any string-typed member (triggering textCount++)?
function hasTextContent(node: NodeType): boolean {
if (node.members.length === 0) return false;
return schemaMembers(node).some(m => isTextContentType(m.type));
}
// ────────────────────────────────────────────────────────────────────────────
// Code generation
// ────────────────────────────────────────────────────────────────────────────
class CodeWriter {
private lines: string[] = [];
private indent = 0;
write(line: string = "") {
if (line === "") {
this.lines.push("");
}
else {
this.lines.push("\t".repeat(this.indent) + line);
}
}
writeRaw(line: string) {
this.lines.push(line);
}
push() {
this.indent++;
}
pop() {
this.indent--;
}
toString(): string {
return this.lines.join("\n");
}
}
function generateNodeFactoryStruct(w: CodeWriter) {
const arenaFields: { fieldName: string; typeName: string; }[] = [];
for (const node of api.nodes()) {
if (!node.arena) continue;
arenaFields.push({
fieldName: `${api.uncapitalize(node.name)}Arena`,
typeName: node.name,
});
}
arenaFields.push({ fieldName: "modifierListArena", typeName: "ModifierList" });
arenaFields.push({ fieldName: "nodeListArena", typeName: "NodeList" });
arenaFields.sort((a, b) => a.fieldName.localeCompare(b.fieldName));
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("// NodeFactory");
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("");
w.write("type NodeFactory struct {");
w.push();
w.write("hooks NodeFactoryHooks");
for (const { fieldName, typeName } of arenaFields) {
w.write(`${fieldName} core.Arena[${typeName}]`);
}
w.write("");
w.write("nodeCount int");
w.write("textCount int");
w.pop();
w.write("}");
w.write("");
}
function generateHeader(w: CodeWriter) {
w.write("// Code generated by _scripts/generate-go-ast.ts. DO NOT EDIT.");
w.write("");
w.write("package ast");
w.write("");
w.write("import (");
w.push();
w.write('"sync/atomic"');
w.write("");
w.write('"github.com/microsoft/typescript-go/internal/core"');
w.pop();
w.write(")");
w.write("");
w.write("var _ = core.Same[string] // prevent unused import");
w.write("var _ atomic.Uint32 // prevent unused import");
w.write("");
}
// ── Generate struct definitions ────────────────────────────────────────────
/**
* Verifies that nothing inherits a base along more than one path.
*/
function verifyNoDuplicateBases(): void {
const problems: string[] = [];
const check = (name: string, extendsKeys: string[]) => {
const copies = new Map<string, number>();
const walk = (keys: string[]) => {
for (const key of keys) {
copies.set(key, (copies.get(key) ?? 0) + 1);
walk(api.getBase(key)?.extendsKeys ?? []);
}
};
walk(extendsKeys);
for (const [base, count] of copies) {
if (count > 1) problems.push(`${name} inherits ${base} ${count} times`);
}
};
for (const base of api.bases()) check(base.key, base.extendsKeys);
for (const node of api.nodes()) check(node.name, node.extendsKeys);
if (problems.length > 0) {
throw new Error(`ast.json declares duplicate embedded bases:\n ${problems.sort().join("\n ")}`);
}
}
/**
* Verifies that the inheritance path containing NodeBase is embedded first.
*/
function verifyNodeBaseAtOffsetZero(): void {
const containsNodeBase = (key: string): boolean => {
if (key === "NodeBase") return true;
return api.getBase(key)?.extendsKeys.some(containsNodeBase) ?? false;
};
const problems: string[] = [];
const check = (name: string, extendsKeys: string[], requireNodeBase: boolean) => {
const nodeBaseIndex = extendsKeys.findIndex(containsNodeBase);
if (nodeBaseIndex < 0 && requireNodeBase) {
problems.push(`${name} does not embed NodeBase`);
}
else if (nodeBaseIndex > 0) {
problems.push(`${name} embeds ${extendsKeys[nodeBaseIndex]} after ${extendsKeys.slice(0, nodeBaseIndex).join(", ")}`);
}
};
for (const base of api.bases()) check(base.key, base.extendsKeys, false);
for (const node of api.nodes()) check(node.name, node.extendsKeys, true);
if (problems.length > 0) {
throw new Error(`ast.json does not embed NodeBase at offset zero:\n ${problems.sort().join("\n ")}`);
}
}
verifyNoDuplicateBases();
verifyNodeBaseAtOffsetZero();
// A base with no fields and no extends is a struct{} marker. Go pads a struct whose last field is
// zero-size (so the field's address stays in bounds), so markers are embedded first, never last; being
// zero-size, they don't move NodeBase off offset zero.
function isZeroSizeBase(key: string): boolean {
const base = api.getBase(key);
return !!base && base.extendsKeys.length === 0 && base.fields.length === 0;
}
function goEmbeds(extendsKeys: string[]): string[] {
const zeroSized: string[] = [];
const nonZeroSized: string[] = [];
for (const key of extendsKeys) {
if (isZeroSizeBase(key)) {
zeroSized.push(key);
}
else {
nonZeroSized.push(key);
}
}
return [...zeroSized, ...nonZeroSized];
}
function generateStructDef(w: CodeWriter, node: NodeType) {
const structName = node.name;
w.write(`type ${structName} struct {`);
w.push();
// Embeddings from extends (each maps to a Go struct via convention)
for (const ext of goEmbeds(node.extendsKeys)) {
w.write(ext);
}
// Fields from members (skip inherited, Kind params, and noGo)
if (node.members.length > 0) {
for (const m of node.members) {
if (m.inherited || m.isKindParam() || m.noGo) continue;
const fieldName = m.name;
const goType = m.goOnly ? m.rawType as string : m.type.formatGoReference();
const comment = buildFieldComment(m);
if (comment) {
w.write(`${fieldName} ${goType} ${comment}`);
}
else {
w.write(`${fieldName} ${goType}`);
}
}
}
w.pop();
w.write("}");
w.write("");
}
function buildFieldComment(m: MemberInfo): string {
const parts: string[] = [];
if (m.optional) parts.push("Optional");
if (parts.length > 0) return `// ${parts.join(". ")}`;
return "";
}
function goSubtreeFactsTerm(m: MemberInfo): string {
const access = `node.${m.name}`;
if (m.listKind === "ModifierList") {
return `propagateModifierListSubtreeFacts(${access})`;
}
if (m.type.kind === "list") {
return `propagateNodeListSubtreeFacts(${access}, propagateSubtreeFacts)`;
}
return `propagateSubtreeFacts(${access})`;
}
function generateSubtreeFacts(w: CodeWriter, node: NodeType) {
if (!node.generateSubtreeFacts) return;
const childMembers = schemaMembers(node).filter(m => m.isChild());
const structName = node.name;
w.write(`func (node *${structName}) computeSubtreeFacts() SubtreeFacts {`);
w.push();
if (childMembers.length === 0) {
w.write("return SubtreeFactsNone");
}
else {
for (let index = 0; index < childMembers.length; index++) {
const term = goSubtreeFactsTerm(childMembers[index]);
if (index === 0) {
const suffix = childMembers.length > 1 ? " |" : "";
w.write(`return ${term}${suffix}`);
}
else {
const suffix = index < childMembers.length - 1 ? " |" : "";
w.write(`${term}${suffix}`);
}
}
}
w.pop();
w.write("}");
w.write("");
}
// ── Generate base struct definitions ──────────────────────────────────────
// Bases that are hand-written and should not be generated
const HAND_WRITTEN_BASES = new Set(["NodeBase"]);
function generateBaseStructDefs(w: CodeWriter) {
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("// Base struct definitions");
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("");
for (const base of api.bases()) {
if (HAND_WRITTEN_BASES.has(base.key)) continue;
const structName = base.key;
const goExts = goEmbeds(base.extendsKeys);
w.write(`type ${structName} struct {`);
w.push();
// Embeddings from extends
for (const ext of goExts) {
w.write(ext);
}
// Schema fields
if (base.fields.length > 0) {
for (const field of base.fields) {
if (field.noGo) continue;
const goType = field.goOnly ? field.rawType as string : field.type.formatGoReference();
const comment = field.optional ? " // Optional" : "";
w.write(`${field.name} ${goType}${comment}`);
}
}
w.pop();
w.write("}");
w.write("");
}
}
// ── Generate As*() cast methods ────────────────────────────────────────────
function generateAsCast(w: CodeWriter, name: string) {
const structName = name;
w.write(`func (n *Node) As${name}() *${structName} {`);
w.push();
w.write(`return n.data.(*${structName})`);
w.pop();
w.write("}");
w.write("");
}
// ── Generate New*() factory methods ────────────────────────────────────────
function isNodeFlagsMember(m: MemberInfo): boolean {
const type = m.type;
return type.kind === "primitive" && type.name === "NodeFlags";
}
function emitNewFactory(
w: CodeWriter,
funcName: string,
kindName: string,
structName: string,
node: NodeType,
members: MemberInfo[],
kindMember: MemberInfo | undefined,
nodeFlagsMembers: MemberInfo[],
) {
const params = members.map(m => `${m.goParamName()} ${m.type.formatGoReference()}`).join(", ");
w.write(`func (f *NodeFactory) ${funcName}(${params}) *Node {`);
w.push();
if (node.arena) {
w.write(`data := f.${api.uncapitalize(structName)}Arena.New()`);
}
else {
w.write(`data := &${structName}{}`);
}
for (const m of members) {
if (m.isKindParam()) continue;
if (isNodeFlagsMember(m)) continue;
const value = m.bitmask ? `${m.goParamName()} & ${m.bitmask}` : m.goParamName();
w.write(`data.${m.name} = ${value}`);
}
if (hasTextContent(node)) {
w.write("f.textCount++");
}
const kindArg = kindMember ? kindMember.goParamName() : `Kind${kindName}`;
if (nodeFlagsMembers.length > 0) {
w.write(`node := f.newNode(${kindArg}, data)`);
for (const m of nodeFlagsMembers) {
const param = m.goParamName();
if (m.bitmask) {
w.write(`node.Flags |= ${param} & ${m.bitmask}`);
}
else {
w.write(`node.Flags = ${param}`);
}
}
w.write("return node");
}
else {
w.write(`return f.newNode(${kindArg}, data)`);
}
w.pop();
w.write("}");
w.write("");
}
function generateNewFactory(w: CodeWriter, node: NodeType) {
const structName = node.name;
const members = schemaMembers(node);
const kindMember = members.find(m => m.isKindParam());
const nodeFlagsMembers = members.filter(m => isNodeFlagsMember(m));
emitNewFactory(w, `New${node.name}`, node.syntaxKindName, structName, node, members, kindMember, nodeFlagsMembers);
for (const alias of node.kindAliases) {
emitNewFactory(w, `New${alias}`, alias, structName, node, members, kindMember, nodeFlagsMembers);
}
}
// ── Generate Update*() factory methods ─────────────────────────────────────
function generateUpdateFactory(w: CodeWriter, node: NodeType) {
const structName = node.name;
const members = schemaMembers(node);
// All non-Kind members participate in Update (both child and data)
const updateMembers = members.filter(m => !m.isKindParam());
if (updateMembers.length === 0) return;
// Leaf nodes (no child AST node members) don't get Update methods.
if (!updateMembers.some(m => m.isChild())) return;
// Build parameter list
const params = [
`node *${structName}`,
...updateMembers.map(m => `${m.goParamName()} ${m.type.formatGoReference()}`),
].join(", ");
w.write(`func (f *NodeFactory) Update${node.name}(${params}) *Node {`);
w.push();
// Build comparison (all update members)
const comparisons = updateMembers.map(m => {
const type = m.type;
// Slices can't be compared with != in Go
if (type.kind === "list" && type.listKind === "raw") {
return `!core.Same(${m.goParamName()}, node.${m.name})`;
}
return `${m.goParamName()} != node.${m.name}`;
});
w.write(`if ${comparisons.join(" || ")} {`);
w.push();
// Call New with all members (Kind from original, everything else from params)
const newArgs = members.map(m => {
if (m.isKindParam()) {
return "node.Kind";
}
return m.goParamName();
}).join(", ");
if (node.kindAliases.length > 0) {
w.write("switch node.Kind {");
w.push();
w.write(`case ${api.kindType(`SyntaxKind.${node.syntaxKindName}`).formatGoConstant()}:`);
w.push();
w.write(`return updateNode(f.New${node.name}(${newArgs}), node.AsNode(), f.hooks)`);
w.pop();
for (const alias of node.kindAliases) {
w.write(`case Kind${alias}:`);
w.push();
w.write(`return updateNode(f.New${alias}(${newArgs}), node.AsNode(), f.hooks)`);
w.pop();
}
w.write("default:");
w.push();
w.write(`panic("unexpected kind in Update${node.name}: " + node.Kind.String())`);
w.pop();
w.pop();
w.write("}");
}
else {
w.write(`return updateNode(f.New${node.name}(${newArgs}), node.AsNode(), f.hooks)`);
}
w.pop();
w.write("}");
w.write("return node.AsNode()");
w.pop();
w.write("}");
w.write("");
}
// ── Generate ForEachChild() ────────────────────────────────────────────────
function generateForEachChild(w: CodeWriter, node: NodeType) {
const members = schemaMembers(node);
const childMembers = members.filter(m => m.isChild());
if (childMembers.length === 0) {
// No children - empty implementation (already provided by NodeDefault)
return;
}
const structName = node.name;
w.write(`func (node *${structName}) ForEachChild(v Visitor) bool {`);
w.push();
// Nodes with runtime-dependent child ordering delegate to a hand-written function.
if (node.handWrittenVisitor) {
w.write(`return forEachChild_${structName}(node, v)`);
w.pop();
w.write("}");
w.write("");
return;
}
// Build visit chain: visit(v, node.Field) || visitNodeList(v, node.Field) || ...
const parts = childMembers.map(m => {
const access = `node.${m.name}`;
const type = m.type;
const listKind = m.listKind;
if (listKind === "raw") {
return `visitNodes(v, ${access})`;
}
if (listKind === "ModifierList") {
return `visitModifiers(v, ${access})`;
}
if (listKind === "NodeList") {
return `visitNodeList(v, ${access})`;
}
return `visit(v, ${access})`;
});
// Join with || across multiple lines if needed
if (parts.length <= 3) {
w.write(`return ${parts.join(" || ")}`);
}
else {
w.write(`return ${parts[0]} ||`);
for (let i = 1; i < parts.length - 1; i++) {
w.write(`\t${parts[i]} ||`);
}
w.write(`\t${parts[parts.length - 1]}`);
}
w.pop();
w.write("}");
w.write("");
}
// ── Generate ForEachChild dispatch ─────────────────────────────────────────
// Determines whether a node has a meaningful ForEachChild implementation (i.e.
// one that is not the no-op inherited from NodeDefault). This is true for any
// generated node with child members, or for hand-written nodes (e.g. SourceFile)
// which define ForEachChild manually in ast.go.
function hasForEachChild(node: NodeType): boolean {
if (node.handWritten) return true;
return schemaMembers(node).some(m => m.isChild());
}
// Generates a (*Node).ForEachChild method that dispatches on node.Kind to the
// concrete node type's ForEachChild method.
//
// This deliberately avoids calling node.data.ForEachChild(v) through the
// nodeData interface. An interface (or other indirect) call is opaque to escape
// analysis, which must then assume the visitor `v` escapes; that forces caller
// closures — and any locals they capture — onto the heap. Dispatching through a
// Kind switch to a statically-resolved concrete method lets escape analysis
// prove the visitor does not escape, keeping caller closures on the stack. The
// integer switch over Kind also compiles to a jump table, making dispatch
// cheaper than the interface call it replaces.
//
// Kinds whose node has no children fall through to `default` and return false,
// matching NodeDefault.ForEachChild.
function generateForEachChildDispatch(w: CodeWriter) {
w.write("func (n *Node) ForEachChild(v Visitor) bool {");
w.push();
w.write("switch n.Kind {");
for (const node of api.nodes()) {
if (!hasForEachChild(node)) continue;
const kinds = node.allKinds().map(k => k.formatGoConstant());
if (kinds.length === 0) continue;
w.write(`case ${kinds.join(", ")}:`);
w.push();
w.write(`return n.data.(*${node.name}).ForEachChild(v)`);
w.pop();
}
w.write("default:");
w.push();
w.write("return false");
w.pop();
w.write("}");
w.pop();
w.write("}");
w.write("");
}
// ── Generate VisitEachChild() ──────────────────────────────────────────────
function generateVisitEachChild(w: CodeWriter, node: NodeType) {
const members = schemaMembers(node);
const childMembers = members.filter(m => m.isChild());
if (childMembers.length === 0) return;
const structName = node.name;
w.write(`func (node *${structName}) VisitEachChild(v *NodeVisitor) *Node {`);
w.push();
// Nodes with runtime-dependent child ordering delegate to a hand-written function.
if (node.handWrittenVisitor) {
w.write(`return visitEachChild_${structName}(node, v)`);
w.pop();
w.write("}");
w.write("");
return;
}
// For raw slice lists, emit local variables with core.SameMap
const updateMembers = members.filter(m => !m.isKindParam());
const rawListLocals: Map<string, string> = new Map();
for (const m of updateMembers) {
const type = m.type;
if (m.isChild() && type.kind === "list" && type.listKind === "raw") {
const localName = m.goParamName();
rawListLocals.set(m.name, localName);
w.write(`${localName} := core.SameMap(node.${m.name}, func(n *Node) *Node { return v.visitNode(n) })`);
}
}
const args = updateMembers.map(m => {
if (!m.isChild()) {
return `node.${m.name}`;
}
// Raw list: use the local variable
if (rawListLocals.has(m.name)) {
return rawListLocals.get(m.name)!;
}
const access = `node.${m.name}`;
const type = m.type;
const listKind = m.listKind;
if (m.visit) {
return `v.visit${api.capitalize(m.visit)}(${access})`;
}
if (listKind === "ModifierList") {
return `v.visitModifiers(${access})`;
}
if (listKind === "NodeList") {
return `v.visitNodes(${access})`;
}
if (type.kind === "primitive" && type.name === "Token") return `v.visitToken(${access})`;
return `v.visitNode(${access})`;
}).join(", ");
w.write(`return v.Factory.Update${node.name}(node, ${args})`);
w.pop();
w.write("}");
w.write("");
}
// ── Generate Clone() ───────────────────────────────────────────────────────
function generateClone(w: CodeWriter, node: NodeType) {
const structName = node.name;
const members = schemaMembers(node);
w.write(`func (node *${structName}) Clone(f NodeFactoryCoercible) *Node {`);
w.push();
// Build args for New* call
// Clone is a struct method, so it can access private fields directly
const args = members.map(m => {
if (m.isKindParam()) {
return "node.Kind";
}
const type = m.declaredType;
if (m.inherited && type?.kind === "alias" && type.name === "ModifierLike") {
return "node.Modifiers()";
}
// Use direct field access (Clone is a struct method, can access private fields)
return `node.${m.name}`;
}).join(", ");
if (node.kindAliases.length > 0) {
w.write("switch node.Kind {");
w.push();
w.write(`case ${api.kindType(`SyntaxKind.${node.syntaxKindName}`).formatGoConstant()}:`);
w.push();
w.write(`return cloneNode(f.AsNodeFactory().New${node.name}(${args}), node.AsNode(), f.AsNodeFactory().hooks)`);
w.pop();
for (const alias of node.kindAliases) {
w.write(`case Kind${alias}:`);
w.push();
w.write(`return cloneNode(f.AsNodeFactory().New${alias}(${args}), node.AsNode(), f.AsNodeFactory().hooks)`);
w.pop();
}
w.write("default:");
w.push();
w.write(`panic("unexpected kind in ${structName}.Clone: " + node.Kind.String())`);
w.pop();
w.pop();
w.write("}");
}
else {
w.write(`return cloneNode(f.AsNodeFactory().New${node.name}(${args}), node.AsNode(), f.AsNodeFactory().hooks)`);
}
w.pop();
w.write("}");
w.write("");
}
// ── Generate Is*() functions ───────────────────────────────────────────────
function generateIsFunction(w: CodeWriter, node: NodeType) {
const kindTypes = node.kindTypes();
if (node.kindType.kind === "typeParameter") {
w.write(`func Is${node.name}(node *Node) bool {`);
w.push();
w.write("switch node.Kind {");
w.write(`case ${kindTypes.map(kind => kind.formatGoConstant()).join(", ")}:`);
w.push();
w.write("return true");
w.pop();
w.write("}");
w.write("return false");
w.pop();
w.write("}");
w.write("");
return;
}
if (node.isMultiKind()) {
for (const kind of kindTypes) {
const kindName = kind.name;
w.write(`func Is${kindName}(node *Node) bool {`);
w.push();
w.write(`return node.Kind == ${kind.formatGoConstant()}`);
w.pop();
w.write("}");
w.write("");
}
return;
}
w.write(`func Is${node.name}(node *Node) bool {`);
w.push();
w.write(`return node.Kind == ${api.kindType(`SyntaxKind.${node.syntaxKindName}`).formatGoConstant()}`);
w.pop();
w.write("}");
w.write("");
for (const alias of node.kindAliases) {
w.write(`func Is${alias}(node *Node) bool {`);
w.push();
w.write(`return node.Kind == Kind${alias}`);
w.pop();
w.write("}");
w.write("");
}
}
// ── Generate kind alias guards ─────────────────────────────────────────────
/** Go guard name: "IsTokenKind", "IsKeywordKind", etc. Capital I, no "Syntax". */
function goKindGuardName(aliasName: string): string {
const tsName = kindGuardName(aliasName); // e.g. "isTokenKind"
return tsName.charAt(0).toUpperCase() + tsName.slice(1); // e.g. "IsTokenKind"
}
function generateKindAliasGuards(w: CodeWriter) {
// JSDocSyntaxKind → "IsJSDocKind" conflicts with the hand-written IsJSDocKind in utilities.go
// which checks JSDoc NODE kinds (FirstJSDocNode..LastJSDocNode), a completely different semantic.
const skipGuards = new Set(["IsJSDocKind"]);
for (const guard of api.kindGuards()) {
const funcName = goKindGuardName(guard.aliasName);
if (skipGuards.has(funcName)) continue;
if (guard.type === "range") {
w.write(`func ${funcName}(kind Kind) bool {`);
w.push();
w.write(`return kind >= Kind${guard.first} && kind <= Kind${guard.last}`);
w.pop();
w.write("}");
w.write("");
}
else {
// Enumerated: generate a switch statement.
// Expand sub-aliases to their concrete members.
const expanded = api.expandKindAliasMembers(guard.aliasName);
w.write(`func ${funcName}(kind Kind) bool {`);
w.push();
w.write("switch kind {");
w.push();
w.write(`case ${expanded.map(m => m.formatGoConstant()).join(", ")}:`);
w.push();
w.write("return true");
w.pop();
w.pop();
w.write("}");
w.write("return false");
w.pop();
w.write("}");
w.write("");
}
}
}
// ── Generate Name() accessor ───────────────────────────────────────────────
function generateNameAccessor(w: CodeWriter, node: NodeType) {
const members = schemaMembers(node);
const nameMember = members.find(m => m.name === "name");
if (!nameMember) return;
// Check if private (either directly or via trait)
const isPrivate = nameMember.inherited
? (nameMember.inheritedField?.private || false)
: (nameMember.private || false);
if (!isPrivate) return;
const structName = node.name;
w.write(`func (node *${structName}) Name() *DeclarationName {`);
w.push();
w.write("return node.name");
w.pop();
w.write("}");
w.write("");
}
// ────────────────────────────────────────────────────────────────────────────
// Main generation
// ────────────────────────────────────────────────────────────────────────────
function generate(): string {
const w = new CodeWriter();
generateHeader(w);
generateNodeFactoryStruct(w);
// Generate base struct definitions
generateBaseStructDefs(w);
// Generate node type aliases (FooNode = Node for every concrete node type)
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("// Node type aliases");
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("");
w.write("type (");
w.push();
for (const node of api.nodes()) {
w.write(`${node.name}Node = Node`);
}
// Instantiation aliases (e.g. EndOfFile = Node, AbstractKeyword = Node)
for (const node of api.nodes()) {
if (node.instantiationAliases.length === 0) continue;
for (const alias of node.instantiationAliases) {
w.write(`${alias.name} = Node`);
}
}
w.pop();
w.write(")");
w.write("");
// NodeList type aliases
const listAliases = api.listAliases();
if (listAliases.length > 0) {
w.write("type (");
w.push();
const maxLen = Math.max(...listAliases.map(alias => alias.name.length));
for (const listAlias of listAliases) {
const padding = " ".repeat(maxLen - listAlias.name.length);
w.write(`${listAlias.name}${padding} = NodeList // NodeList[*${listAlias.elementTypeName}]`);
}
w.pop();
w.write(")");
w.write("");
}
// Node union aliases (e.g. Statement = Node, BlockOrExpression = Node)
const nodeAliases = api.nodeAliases();
if (nodeAliases.length > 0) {
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("// Node union aliases");
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("");
w.write("type (");
w.push();
const maxAliasLen = Math.max(...nodeAliases.map(alias => alias.name.length));
for (const alias of nodeAliases) {
const padding = " ".repeat(maxAliasLen - alias.name.length);
let comment: string;
if (alias.isBaseAlias && alias.baseKey) {
comment = `Node with ${alias.baseKey}`;
}
else if (alias.isUnion) {
comment = alias.unionMemberNames.join(" | ");
}
else {
comment = "";
}
w.write(`${alias.name}${padding} = Node${comment ? ` // ${comment}` : ""}`);
}
w.pop();
w.write(")");
w.write("");
}
// Generate for each node
for (const node of api.nodes()) {
// Section comment
w.write(`// ──────────────────────────────────────────────────────────────────────`);
w.write(`// ${node.name}`);
w.write(`// ──────────────────────────────────────────────────────────────────────`);
w.write("");
if (!node.handWritten) {
generateStructDef(w, node);
generateNewFactory(w, node);
generateUpdateFactory(w, node);
generateForEachChild(w, node);
generateVisitEachChild(w, node);
generateClone(w, node);
generateSubtreeFacts(w, node);
generateNameAccessor(w, node);
}
generateIsFunction(w, node);
if (node.handWritten) {
w.write("");
w.write("// Struct and factory methods hand-written in ./ast.go");
}
}
// ForEachChild dispatch
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("// ForEachChild dispatch");
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("");
generateForEachChildDispatch(w);
// As*() casts
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("// As*() cast methods");
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("");
for (const node of api.nodes()) {
generateAsCast(w, node.name);
}
// Kind alias guards
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("// Kind alias guards");
w.write("// ──────────────────────────────────────────────────────────────────────");
w.write("");
generateKindAliasGuards(w);
return w.toString();
}
// ────────────────────────────────────────────────────────────────────────────
// Write output
// ────────────────────────────────────────────────────────────────────────────
// ────────────────────────────────────────────────────────────────────────────
// Kind generation
// ────────────────────────────────────────────────────────────────────────────
function generateKind(): string {
const w = new CodeWriter();
w.write("// Code generated by _scripts/generate-go-ast.ts. DO NOT EDIT.");
w.write("");
w.write("package ast");
w.write("");
w.write("//go:generate go tool golang.org/x/tools/cmd/stringer -type=Kind -output=kind_stringer_generated.go");
w.write("//go:generate npx dprint fmt kind_stringer_generated.go");
w.write("");
w.write("type Kind int16");
w.write("");
w.write("const (");
w.push();
const elements = api.kindElements();
const markers = api.kindMarkers();
const kindUnions = api.kindAliases();
// Build set of all defined kind names for validation
const definedKinds = new Set<string>();
for (const element of elements) {
if (element.name) {
definedKinds.add(element.name);
}
}
// Validate marker references (markers can reference kind names or other marker names)
const markerNames = new Set(markers.map(m => m.name));
for (const marker of markers) {
if (!definedKinds.has(marker.value) && !markerNames.has(marker.value)) {
throw new Error(`Kind marker ${marker.name} references undefined kind or marker "${marker.value}"`);
}
}
// Validate union references
for (const kindUnion of kindUnions) {
for (const m of kindUnion.members) {
if (!definedKinds.has(m) && !api.hasKindAlias(m)) {
throw new Error(`Kind union ${kindUnion.name} references undefined kind or union "${m}"`);
}
}
}
// Emit elements
let first = true;
for (const el of elements) {
if (!el.name) {
w.write(`// ${el.comment}`);
continue;
}
const trailing = el.comment ? ` // ${el.comment}` : "";
if (first) {
w.write(`Kind${el.name} Kind = iota${trailing}`);
first = false;
}
else {
w.write(`Kind${el.name}${trailing}`);
}
}
// KindCount
w.write("KindCount");
// Markers
const maxLen = Math.max(...markers.map(m => m.name.length));
for (const marker of markers) {
const padding = " ".repeat(maxLen - marker.name.length);
w.write(`Kind${marker.name}${padding} = Kind${marker.value}`);
}
w.pop();
w.write(")");
w.write("");
// Kind union type aliases
if (kindUnions.length > 0) {
w.write("type (");
w.push();
for (const { name, members } of kindUnions) {
function expandMembers(ms: string[]): string[] {
const result: string[] = [];
for (const m of ms) {
const alias = api.getKindAlias(m);
if (alias) {
result.push(...expandMembers(alias.members));
}
else {
result.push(m);
}
}
return result;
}
const expanded = expandMembers(members);
const comment = expanded.map(m => `Kind${m}`).join(" | ");
w.write(`${name} = Kind // ${comment}`);
}
w.pop();
w.write(")");
w.write("");
}
return w.toString();
}
function writeAndFormat(filePath: string, content: string) {
fs.writeFileSync(filePath, content);
execaSync("dprint", ["fmt", filePath], { stdio: "inherit", cwd: ROOT });
console.log(`Wrote ${filePath}`);
}
export default function main() {
console.log("Generating Go AST code...");
const code = generate();
const outPath = path.join(ROOT, "internal/ast/ast_generated.go");
writeAndFormat(outPath, code + "\n");
const kindCode = generateKind();
const kindOutPath = path.join(ROOT, "internal/ast/kind_generated.go");
writeAndFormat(kindOutPath, kindCode + "\n");
}
if (process.argv[1] === fileURLToPath(import.meta.url)) {
main();
}