547 lines
34 KiB
TypeScript
547 lines
34 KiB
TypeScript
// 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: 当前模式选中的模块、表达式或交互根载荷，compiler 按对应构造器生成入口代码。
|
||
// Expression: 表达式根，编译后直接返回求值结果。
|
||
// Expression.body: 当前模式选中的模块、表达式或交互根载荷，compiler 按对应构造器生成入口代码。
|
||
// Interactive: 交互根，包含一次完整提交。
|
||
// Interactive.body: 当前模式选中的模块、表达式或交互根载荷，compiler 按对应构造器生成入口代码。
|
||
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: 函数或类的完整声明，包含其名称、成员/参数及原文范围。
|
||
// Class: 类名、可选基类、字段和方法，compiler 检查成员后生成构类指令。
|
||
// Class.definition: 函数或类的完整声明，包含其名称、成员/参数及原文范围。
|
||
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: let 新绑定，compiler 先分析/求右值，再登记目标初始化。
|
||
// Assignment: 普通名称赋值，compiler 按作用域写局部槽或全局环境。
|
||
// Assignment.assignment: 普通名称或成员赋值的完整节点，compiler 据构造器选择槽写入或属性写入。
|
||
// MemberAssignment: 成员写入的对象、属性名与右值，compiler 生成 StoreAttr。
|
||
// MemberAssignment.assignment: 普通名称或成员赋值的完整节点，compiler 据构造器选择槽写入或属性写入。
|
||
// If: 条件、then 和可选 else，compiler 合并继续路径的初始化集合并生成跳转。
|
||
// If.statement: 条件、循环或返回节点，compiler 按构造器处理路径、跳转或帧出口。
|
||
// While: 循环条件与体，compiler 生成回边并处理循环可能零次执行。
|
||
// While.statement: 条件、循环或返回节点，compiler 按构造器处理路径、跳转或帧出口。
|
||
// Return: 函数返回，compiler 对缺省值补 Nil；当前源码语法要求 return 后有表达式。
|
||
// Return.statement: 条件、循环或返回节点，compiler 按构造器处理路径、跳转或帧出口。
|
||
// Expression: 表达式载荷及完整范围，compiler 生成留下一个结果的求值序列。
|
||
// Expression.expression: 语句位置的表达式；函数块丢弃结果，交互根可把它作为返回值。
|
||
// Declaration: 顶层/交互声明的种类及完整范围，compiler 按函数或类分派。
|
||
// Declaration.declaration: 交互根中的函数/类声明，compiler 预登记名称；嵌套声明当前被拒绝。
|
||
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: 名称引用原文，由 compiler 名称分析解析到局部槽或全局名字表。
|
||
// Number: 原始十进制拼写，保留全部位数、前导零及尾零，不转浮点。
|
||
// Number.spelling: 原始数字拼写，compiler 构造精确数值；不把文本先转为二进制浮点。
|
||
// String: 已解码受支持转义的拥有文本，原引号范围在外层 Expr。
|
||
// String.value: 字符串解码后的拥有文本，原引号和转义仍可通过外层范围读取。
|
||
// 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;
|
||
}
|