// Generated by scripts/generate_ast.py from Endor.asdl. Do not edit.

// 与 Rust wire 共同核对的 ASDL 原文协议身份；生成源码注释不改变此值。
export const AST_SCHEMA_ID = "urn:endor:ast:sha256:21b0349ac295d9bc8cedcad8f07d8e2d45cf220e19e7c2fad10269555fcfd71a" as const;
// 原 UTF-8 半开字节范围；number 类型本身不验证安全整数、顺序或原文边界。
export interface Span { start: number; end: number; }
// 宿主/编辑器传输的版本化语法文档，wire 校验后供 compiler 使用。
// schema: 协议身份，wire 按 AST_SCHEMA_ID 核对；不是源码内容哈希。
// root: 拥有的语法根，文档校验及编译从这里递归。
export type AstDocument = { schema: typeof AST_SCHEMA_ID; root: AstRoot; };
// parse_ast 按模式构造的模块、表达式或交互根，compiler 据此选择生成入口。
// Module: 模块根，包含函数/类声明。
// Module.body: body 保存 Program 类型的值。
// Expression: 表达式根，编译后直接返回求值结果。
// Expression.body: body 保存 Expr 类型的值。
// Interactive: 交互根，包含一次完整提交。
// Interactive.body: body 保存 InteractiveInput 类型的值。
export type AstRoot = { kind: "Module"; data: Program; } | { kind: "Expression"; data: Expr; } | { kind: "Interactive"; data: InteractiveInput; };
// parser 复制的名称文本与位置，用于声明、类型注解或属性名。
// text: 拥有名称文本，不依赖输入缓冲存活。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Name = { text: string; span: Span; };
// 模块声明序列，compiler 先注册全部顶层名称再分析各函数体。
// declarations: 按源码顺序的声明；源码模块解析要求非空，文档结构本身不限制数量。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Program = { declarations: Array<Decl>; span: Span; };
// 顶层/交互声明的种类及完整范围，compiler 按函数或类分派。
// kind: 函数/类声明载荷，JSON 和类型采用 kind/data 标签。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Decl = { kind: DeclKind; span: Span; };
// 函数与类声明的判别载荷，外层 Decl 另外保存完整跨度。
// Function: 显式参数/返回注解与函数体，compiler 生成独立模板及源码签名；解析本身不调用函数。
// Function.definition: definition 保存 Function 类型的值。
// Class: 类名、可选基类、字段和方法，compiler 检查成员后生成构类指令。
// Class.definition: definition 保存 Class 类型的值。
export type DeclKind = { kind: "Function"; data: Function; } | { kind: "Class"; data: Class; };
// 类名、可选基类、字段和方法，compiler 检查成员后生成构类指令。
// name: 类声明名与精确位置。
// base: 显式基类名，可省略；当前 compiler 对省略项使用 Object。
// fields: 按出现顺序的字段名称/类型注解，不含方法。
// methods: 按出现顺序的方法；显式 self 约束由 compiler 检查。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Class = { name: Name; base?: Name | null; fields: Array<Parameter>; methods: Array<Function>; span: Span; };
// 显式参数/返回注解与函数体，compiler 生成独立模板及源码签名；解析本身不调用函数。
// name: 函数/方法名，代码模板沿用为诊断名称。
// parameters: 位置参数列表，compiler 依次分配前部局部槽。
// return_type: 返回类型名，生成源码签名后由运行时解析。
// body: 独立函数作用域的语句体，当前源码不支持嵌套声明闭包。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Function = { name: Name; parameters: Array<Parameter>; return_type: Name; body: Block; span: Span; };
// 函数参数或类字段共用的名称/类型注解，实际类型身份由运行时环境解析。
// name: 参数/字段名，用于布局和重复检查。
// type_name: 声明类型名，前端只保留文本与位置。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Parameter = { name: Name; type_name: Name; span: Span; };
// 顺序语句块，compiler 检查确定初始化并按语句生成指令。
// statements: 有序语句列表，不引入独立块级局部作用域。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Block = { statements: Array<Stmt>; span: Span; };
// 语句种类及原文范围，compiler 处理副作用、控制流或返回。
// kind: 具体语句载荷，外层另存整句范围。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Stmt = { kind: StmtKind; span: Span; };
// 语句判别载荷，parser 选择分支，compiler 按绑定、赋值、控制流等规则处理。
// Binding: let 新绑定，compiler 检查重名并分析右值后才标记目标已初始化。
// Binding.binding: binding 保存 Binding 类型的值。
// Assignment: 普通名称赋值，compiler 按作用域写局部槽或全局环境。
// Assignment.assignment: assignment 保存 Assignment 类型的值。
// MemberAssignment: 成员写入的对象、属性名与右值，compiler 生成 StoreAttr。
// MemberAssignment.assignment: assignment 保存 MemberAssignment 类型的值。
// If: 条件、then 和可选 else，compiler 合并继续路径的初始化集合并生成跳转。
// If.statement: statement 保存 IfStatement 类型的值。
// While: 循环条件与体，compiler 生成回边并处理循环可能零次执行。
// While.statement: statement 保存 WhileStatement 类型的值。
// Return: 函数返回，compiler 对缺省值补 Nil；当前源码语法要求 return 后有表达式。
// Return.statement: statement 保存 ReturnStatement 类型的值。
// Expression: 表达式载荷及完整范围，compiler 生成留下一个结果的求值序列。
// Expression.expression: expression 保存 Expr 类型的值。
// Declaration: 顶层/交互声明的种类及完整范围，compiler 按函数或类分派。
// Declaration.declaration: declaration 保存 Decl 类型的值。
export type StmtKind = { kind: "Binding"; data: Binding; } | { kind: "Assignment"; data: Assignment; } | { kind: "MemberAssignment"; data: MemberAssignment; } | { kind: "If"; data: IfStatement; } | { kind: "While"; data: WhileStatement; } | { kind: "Return"; data: ReturnStatement; } | { kind: "Expression"; data: Expr; } | { kind: "Declaration"; data: Decl; };
// let 新绑定，compiler 检查重名并分析右值后才标记目标已初始化。
// name: let 目标名，重复声明由语义分析拒绝。
// value: 绑定右值，本局部不能在初始化前读取自身。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Binding = { name: Name; value: Expr; span: Span; };
// 普通名称赋值，compiler 按作用域写局部槽或全局环境。
// name: 普通赋值目标，函数内首次赋值可预分配局部槽。
// value: 先求右值再更新目标。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Assignment = { name: Name; value: Expr; span: Span; };
// 成员写入的对象、属性名与右值，compiler 生成 StoreAttr。
// object: 属性写入接收对象表达式，前端不求值。
// name: 待写属性名，compiler 加入名字表。
// value: 待写右值，当前 compiler 先于接收对象生成求值以匹配 VM 栈布局。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type MemberAssignment = { object: Expr; name: Name; value: Expr; span: Span; };
// 条件、then 和可选 else，compiler 合并继续路径的初始化集合并生成跳转。
// condition: 条件表达式，运行时按真值协议选择分支。
// body: 条件为真的 then 块。
// otherwise: 可选 else 块，缺省时存在直接继续路径。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type IfStatement = { condition: Expr; body: Block; otherwise?: Block | null; span: Span; };
// 循环条件与体，compiler 生成回边并处理循环可能零次执行。
// condition: 每轮重新求值的条件，假值退出。
// body: 循环体，可能一次也不执行。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type WhileStatement = { condition: Expr; body: Block; span: Span; };
// 函数返回，compiler 对缺省值补 Nil；当前源码语法要求 return 后有表达式。
// value: 可选返回表达式，手工 AST 缺省时由 compiler 补 Nil。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type ReturnStatement = { value?: Expr | null; span: Span; };
// 单次交互提交容器，parser 产生一条语句，compiler 也检查数量，不保存宿主会话环境。
// statements: 当前 parse/compile 约定恰好一个完整提交的语句。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type InteractiveInput = { statements: Array<Stmt>; span: Span; };
// 表达式载荷及完整范围，compiler 生成留下一个结果的求值序列。
// kind: 求值形状，不缓存名称解析或运行时类型。
// span: 原始 UTF-8 文本的半开字节范围，定位与父子范围校验共用；不是字符列。
export type Expr = { kind: ExprKind; span: Span; };
// 名称、字面量、等待、运算和调用等表达式载荷，范围由外层 Expr 提供。
// Name: 变量引用文本，compiler 决定局部槽或全局索引。
// Name.text: text 保存 string 类型的值。
// Number: 原始十进制拼写，保留全部位数、前导零及尾零，不转浮点。
// Number.spelling: spelling 保存 string 类型的值。
// String: 已解码受支持转义的拥有文本，原引号范围在外层 Expr。
// String.value: value 保存 string 类型的值。
// Symbol: 点开头的符号名，前端可表示，当前 compiler 拒绝生成运行时值。
// Symbol.name: 成员或符号名，不是已解析的运行时属性句柄。
// Await: 等待子表达式，VM 执行上下文决定是否允许停放。
// Await.operand: 一元子表达式，Rust 的递归回边间接存储。
// Unary: 一元取负，可在纯数值链上合并符号。
// Unary.operation: 运算种类，决定算术、比较或取负指令。
// Unary.operand: 一元子表达式，Rust 的递归回边间接存储。
// Binary: 左右操作数及算术/比较种类，保留解析优先级树。
// Binary.operation: 运算种类，决定算术、比较或取负指令。
// Binary.left: 二元左操作数，当前 compiler 先于右侧求值。
// Binary.right: 二元右操作数，与左侧一起被运行时运算消费。
// Member: 接收对象及属性名的读取。
// Member.object: 成员读取接收对象。
// Member.name: 成员或符号名，不是已解析的运行时属性句柄。
// Call: 被调用表达式与位置实参，由 VM 实际求值。
// Call.callee: 调用目标，先于实参求值。
// Call.arguments: 有序位置实参，AST 不隐式添加接收者。
export type ExprKind = { kind: "Name"; data: string; } | { kind: "Number"; data: string; } | { kind: "String"; data: string; } | { kind: "Symbol"; data: Name; } | { kind: "Await"; data: Expr; } | { kind: "Unary"; data: { operation: UnaryOp; operand: Expr; }; } | { kind: "Binary"; data: { operation: BinaryOp; left: Expr; right: Expr; }; } | { kind: "Member"; data: { object: Expr; name: Name; }; } | { kind: "Call"; data: { callee: Expr; arguments: Array<Expr>; }; };
// 一元运算种类，compiler 合并纯数值负号或生成运行时取负。
// Negate: 一元取负。
export type UnaryOp = "Negate";
// 二元算术/比较种类，parser 保留优先级树，compiler 映射为对应 VM 操作。
// Add: 加法。
// Subtract: 减法。
// Multiply: 乘法。
// Divide: 除法。
// Equal: 相等比较。
// NotEqual: 不等比较。
// Less: 小于比较。
// LessEqual: 小于等于比较。
// Greater: 大于比较。
// GreaterEqual: 大于等于比较。
export type BinaryOp = "Add" | "Subtract" | "Multiply" | "Divide" | "Equal" | "NotEqual" | "Less" | "LessEqual" | "Greater" | "GreaterEqual";
// 编辑器可选节点回调；walk<Type> 先回调，返回 false 只剪掉当前子树，其他值继续递归。
export interface Visitor {
// 跨度叶子回调没有子结构，其返回值不参与后续剪枝。
visitSpan?(node: Span): boolean | void;
// walkAstDocument 到达 AstDocument 时调用，false 跳过该节点的后续子字段。
visitAstDocument?(node: AstDocument): boolean | void;
// walkAstRoot 到达 AstRoot 时调用，false 跳过该节点的后续子字段。
visitAstRoot?(node: AstRoot): boolean | void;
// walkName 到达 Name 时调用，false 跳过该节点的后续子字段。
visitName?(node: Name): boolean | void;
// walkProgram 到达 Program 时调用，false 跳过该节点的后续子字段。
visitProgram?(node: Program): boolean | void;
// walkDecl 到达 Decl 时调用，false 跳过该节点的后续子字段。
visitDecl?(node: Decl): boolean | void;
// walkDeclKind 到达 DeclKind 时调用，false 跳过该节点的后续子字段。
visitDeclKind?(node: DeclKind): boolean | void;
// walkClass 到达 Class 时调用，false 跳过该节点的后续子字段。
visitClass?(node: Class): boolean | void;
// walkFunction 到达 Function 时调用，false 跳过该节点的后续子字段。
visitFunction?(node: Function): boolean | void;
// walkParameter 到达 Parameter 时调用，false 跳过该节点的后续子字段。
visitParameter?(node: Parameter): boolean | void;
// walkBlock 到达 Block 时调用，false 跳过该节点的后续子字段。
visitBlock?(node: Block): boolean | void;
// walkStmt 到达 Stmt 时调用，false 跳过该节点的后续子字段。
visitStmt?(node: Stmt): boolean | void;
// walkStmtKind 到达 StmtKind 时调用，false 跳过该节点的后续子字段。
visitStmtKind?(node: StmtKind): boolean | void;
// walkBinding 到达 Binding 时调用，false 跳过该节点的后续子字段。
visitBinding?(node: Binding): boolean | void;
// walkAssignment 到达 Assignment 时调用，false 跳过该节点的后续子字段。
visitAssignment?(node: Assignment): boolean | void;
// walkMemberAssignment 到达 MemberAssignment 时调用，false 跳过该节点的后续子字段。
visitMemberAssignment?(node: MemberAssignment): boolean | void;
// walkIfStatement 到达 IfStatement 时调用，false 跳过该节点的后续子字段。
visitIfStatement?(node: IfStatement): boolean | void;
// walkWhileStatement 到达 WhileStatement 时调用，false 跳过该节点的后续子字段。
visitWhileStatement?(node: WhileStatement): boolean | void;
// walkReturnStatement 到达 ReturnStatement 时调用，false 跳过该节点的后续子字段。
visitReturnStatement?(node: ReturnStatement): boolean | void;
// walkInteractiveInput 到达 InteractiveInput 时调用，false 跳过该节点的后续子字段。
visitInteractiveInput?(node: InteractiveInput): boolean | void;
// walkExpr 到达 Expr 时调用，false 跳过该节点的后续子字段。
visitExpr?(node: Expr): boolean | void;
// walkExprKind 到达 ExprKind 时调用，false 跳过该节点的后续子字段。
visitExprKind?(node: ExprKind): boolean | void;
// walkUnaryOp 到达 UnaryOp 时调用，false 跳过该节点的后续子字段。
visitUnaryOp?(node: UnaryOp): boolean | void;
// walkBinaryOp 到达 BinaryOp 时调用，false 跳过该节点的后续子字段。
visitBinaryOp?(node: BinaryOp): boolean | void;
}
// 上层 walker/宿主调用的跨度叶子入口，仅通知 visitSpan，不验证输入或修改节点。
export function walkSpan(node: Span, visitor: Visitor): void { visitor.visitSpan?.(node); }
// 上层 walker 或宿主调用，先通知 AstDocument 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkAstDocument(node: AstDocument, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitAstDocument?.(node) === false) return;
// 递归访问 node.root 的 AstRoot 子结构或跨度。
walkAstRoot(node.root, visitor);
}
// 上层 walker 或宿主调用，先通知 AstRoot 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkAstRoot(node: AstRoot, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitAstRoot?.(node) === false) return;
// 判别 kind 只选择当前载荷，普通文本/数字拼写没有进一步语法子结构。
switch (node.kind) {
// 模块根，包含函数/类声明。
case "Module":
// 递归访问 node.data 的 Program 子结构或跨度。
walkProgram(node.data, visitor);
break;
// 表达式根，编译后直接返回求值结果。
case "Expression":
// 递归访问 node.data 的 Expr 子结构或跨度。
walkExpr(node.data, visitor);
break;
// 交互根，包含一次完整提交。
case "Interactive":
// 递归访问 node.data 的 InteractiveInput 子结构或跨度。
walkInteractiveInput(node.data, visitor);
break;
}
}
// 上层 walker 或宿主调用，先通知 Name 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkName(node: Name, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitName?.(node) === false) return;
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 Program 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkProgram(node: Program, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitProgram?.(node) === false) return;
// 按声明顺序访问 node.declarations 列表中的每个 Decl 子节点。
for (const value of node.declarations) walkDecl(value, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 Decl 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkDecl(node: Decl, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitDecl?.(node) === false) return;
// 递归访问 node.kind 的 DeclKind 子结构或跨度。
walkDeclKind(node.kind, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 DeclKind 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkDeclKind(node: DeclKind, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitDeclKind?.(node) === false) return;
// 判别 kind 只选择当前载荷，普通文本/数字拼写没有进一步语法子结构。
switch (node.kind) {
// 显式参数/返回注解与函数体，compiler 生成独立模板及源码签名；解析本身不调用函数。
case "Function":
// 递归访问 node.data 的 Function 子结构或跨度。
walkFunction(node.data, visitor);
break;
// 类名、可选基类、字段和方法，compiler 检查成员后生成构类指令。
case "Class":
// 递归访问 node.data 的 Class 子结构或跨度。
walkClass(node.data, visitor);
break;
}
}
// 上层 walker 或宿主调用，先通知 Class 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkClass(node: Class, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitClass?.(node) === false) return;
// 递归访问 node.name 的 Name 子结构或跨度。
walkName(node.name, visitor);
// node.base 可缺省或为 null，只有存在时才访问该子节点。
if (node.base != null) walkName(node.base, visitor);
// 按声明顺序访问 node.fields 列表中的每个 Parameter 子节点。
for (const value of node.fields) walkParameter(value, visitor);
// 按声明顺序访问 node.methods 列表中的每个 Function 子节点。
for (const value of node.methods) walkFunction(value, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 Function 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkFunction(node: Function, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitFunction?.(node) === false) return;
// 递归访问 node.name 的 Name 子结构或跨度。
walkName(node.name, visitor);
// 按声明顺序访问 node.parameters 列表中的每个 Parameter 子节点。
for (const value of node.parameters) walkParameter(value, visitor);
// 递归访问 node.return_type 的 Name 子结构或跨度。
walkName(node.return_type, visitor);
// 递归访问 node.body 的 Block 子结构或跨度。
walkBlock(node.body, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 Parameter 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkParameter(node: Parameter, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitParameter?.(node) === false) return;
// 递归访问 node.name 的 Name 子结构或跨度。
walkName(node.name, visitor);
// 递归访问 node.type_name 的 Name 子结构或跨度。
walkName(node.type_name, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 Block 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkBlock(node: Block, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitBlock?.(node) === false) return;
// 按声明顺序访问 node.statements 列表中的每个 Stmt 子节点。
for (const value of node.statements) walkStmt(value, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 Stmt 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkStmt(node: Stmt, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitStmt?.(node) === false) return;
// 递归访问 node.kind 的 StmtKind 子结构或跨度。
walkStmtKind(node.kind, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 StmtKind 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkStmtKind(node: StmtKind, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitStmtKind?.(node) === false) return;
// 判别 kind 只选择当前载荷，普通文本/数字拼写没有进一步语法子结构。
switch (node.kind) {
// let 新绑定，compiler 检查重名并分析右值后才标记目标已初始化。
case "Binding":
// 递归访问 node.data 的 Binding 子结构或跨度。
walkBinding(node.data, visitor);
break;
// 普通名称赋值，compiler 按作用域写局部槽或全局环境。
case "Assignment":
// 递归访问 node.data 的 Assignment 子结构或跨度。
walkAssignment(node.data, visitor);
break;
// 成员写入的对象、属性名与右值，compiler 生成 StoreAttr。
case "MemberAssignment":
// 递归访问 node.data 的 MemberAssignment 子结构或跨度。
walkMemberAssignment(node.data, visitor);
break;
// 条件、then 和可选 else，compiler 合并继续路径的初始化集合并生成跳转。
case "If":
// 递归访问 node.data 的 IfStatement 子结构或跨度。
walkIfStatement(node.data, visitor);
break;
// 循环条件与体，compiler 生成回边并处理循环可能零次执行。
case "While":
// 递归访问 node.data 的 WhileStatement 子结构或跨度。
walkWhileStatement(node.data, visitor);
break;
// 函数返回，compiler 对缺省值补 Nil；当前源码语法要求 return 后有表达式。
case "Return":
// 递归访问 node.data 的 ReturnStatement 子结构或跨度。
walkReturnStatement(node.data, visitor);
break;
// 表达式载荷及完整范围，compiler 生成留下一个结果的求值序列。
case "Expression":
// 递归访问 node.data 的 Expr 子结构或跨度。
walkExpr(node.data, visitor);
break;
// 顶层/交互声明的种类及完整范围，compiler 按函数或类分派。
case "Declaration":
// 递归访问 node.data 的 Decl 子结构或跨度。
walkDecl(node.data, visitor);
break;
}
}
// 上层 walker 或宿主调用，先通知 Binding 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkBinding(node: Binding, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitBinding?.(node) === false) return;
// 递归访问 node.name 的 Name 子结构或跨度。
walkName(node.name, visitor);
// 递归访问 node.value 的 Expr 子结构或跨度。
walkExpr(node.value, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 Assignment 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkAssignment(node: Assignment, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitAssignment?.(node) === false) return;
// 递归访问 node.name 的 Name 子结构或跨度。
walkName(node.name, visitor);
// 递归访问 node.value 的 Expr 子结构或跨度。
walkExpr(node.value, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 MemberAssignment 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkMemberAssignment(node: MemberAssignment, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitMemberAssignment?.(node) === false) return;
// 递归访问 node.object 的 Expr 子结构或跨度。
walkExpr(node.object, visitor);
// 递归访问 node.name 的 Name 子结构或跨度。
walkName(node.name, visitor);
// 递归访问 node.value 的 Expr 子结构或跨度。
walkExpr(node.value, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 IfStatement 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkIfStatement(node: IfStatement, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitIfStatement?.(node) === false) return;
// 递归访问 node.condition 的 Expr 子结构或跨度。
walkExpr(node.condition, visitor);
// 递归访问 node.body 的 Block 子结构或跨度。
walkBlock(node.body, visitor);
// node.otherwise 可缺省或为 null，只有存在时才访问该子节点。
if (node.otherwise != null) walkBlock(node.otherwise, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 WhileStatement 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkWhileStatement(node: WhileStatement, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitWhileStatement?.(node) === false) return;
// 递归访问 node.condition 的 Expr 子结构或跨度。
walkExpr(node.condition, visitor);
// 递归访问 node.body 的 Block 子结构或跨度。
walkBlock(node.body, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 ReturnStatement 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkReturnStatement(node: ReturnStatement, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitReturnStatement?.(node) === false) return;
// node.value 可缺省或为 null，只有存在时才访问该子节点。
if (node.value != null) walkExpr(node.value, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 InteractiveInput 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkInteractiveInput(node: InteractiveInput, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitInteractiveInput?.(node) === false) return;
// 按声明顺序访问 node.statements 列表中的每个 Stmt 子节点。
for (const value of node.statements) walkStmt(value, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 Expr 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkExpr(node: Expr, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitExpr?.(node) === false) return;
// 递归访问 node.kind 的 ExprKind 子结构或跨度。
walkExprKind(node.kind, visitor);
// 递归访问 node.span 的 span 子结构或跨度。
walkSpan(node.span, visitor);
}
// 上层 walker 或宿主调用，先通知 ExprKind 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkExprKind(node: ExprKind, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitExprKind?.(node) === false) return;
// 判别 kind 只选择当前载荷，普通文本/数字拼写没有进一步语法子结构。
switch (node.kind) {
// 变量引用文本，compiler 决定局部槽或全局索引。
case "Name":
break;
// 原始十进制拼写，保留全部位数、前导零及尾零，不转浮点。
case "Number":
break;
// 已解码受支持转义的拥有文本，原引号范围在外层 Expr。
case "String":
break;
// 点开头的符号名，前端可表示，当前 compiler 拒绝生成运行时值。
case "Symbol":
// 递归访问 node.data 的 Name 子结构或跨度。
walkName(node.data, visitor);
break;
// 等待子表达式，VM 执行上下文决定是否允许停放。
case "Await":
// 递归访问 node.data 的 Expr 子结构或跨度。
walkExpr(node.data, visitor);
break;
// 一元取负，可在纯数值链上合并符号。
case "Unary":
// 递归访问 node.data.operation 的 UnaryOp 子结构或跨度。
walkUnaryOp(node.data.operation, visitor);
// 递归访问 node.data.operand 的 Expr 子结构或跨度。
walkExpr(node.data.operand, visitor);
break;
// 左右操作数及算术/比较种类，保留解析优先级树。
case "Binary":
// 递归访问 node.data.operation 的 BinaryOp 子结构或跨度。
walkBinaryOp(node.data.operation, visitor);
// 递归访问 node.data.left 的 Expr 子结构或跨度。
walkExpr(node.data.left, visitor);
// 递归访问 node.data.right 的 Expr 子结构或跨度。
walkExpr(node.data.right, visitor);
break;
// 接收对象及属性名的读取。
case "Member":
// 递归访问 node.data.object 的 Expr 子结构或跨度。
walkExpr(node.data.object, visitor);
// 递归访问 node.data.name 的 Name 子结构或跨度。
walkName(node.data.name, visitor);
break;
// 被调用表达式与位置实参，由 VM 实际求值。
case "Call":
// 递归访问 node.data.callee 的 Expr 子结构或跨度。
walkExpr(node.data.callee, visitor);
// 按声明顺序访问 node.data.arguments 列表中的每个 Expr 子节点。
for (const value of node.data.arguments) walkExpr(value, visitor);
break;
}
}
// 上层 walker 或宿主调用，先通知 UnaryOp 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkUnaryOp(node: UnaryOp, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitUnaryOp?.(node) === false) return;
}
// 上层 walker 或宿主调用，先通知 BinaryOp 回调，再按 ASDL 顺序访问子结构；不修改树。
export function walkBinaryOp(node: BinaryOp, visitor: Visitor): void {
// 仅显式 false 剪枝，未提供回调或返回 void 则继续访问。
if (visitor.visitBinaryOp?.(node) === false) return;
}