类
class Annotation
public class Annotation <: Node {
public init(inputs: Tokens)
public init()
}
功能：表示编译器内置的注解节点。
一个 Annotation 节点：@CallingConv[xxx], @Attribute[xxx], @When[condition]等。
父类型：
prop arguments
public mut prop arguments: ArrayList<Argument>
功能：获取或设置 Annotation 中的参数序列，如 @CallingConv[xxx] 中的 xxx。
prop at
public mut prop at: Token
功能：获取或设置 Annotation 节点中的 @ 操作符或 @! 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
@操作符或@!操作符时，抛出异常。
prop attributes
public mut prop attributes: Tokens
功能：获取或设置 Attribute 中设置的属性值，仅用于 @Attribute，如 @Attribute[xxx] 中的 xxx。
类型：Tokens
prop condition
public mut prop condition: Expr
功能：获取或设置条件编译中的条件表达式，用于 @When，如 @When[xxx] 中的 xxx。
类型：Expr
异常：
- ASTException - 当 Annotation 节点中没有条件表达式时，抛出异常。
prop identifier
public mut prop identifier: Token
功能：获取或设置 Annotation 节点的标识符，如 @CallingConv[xxx] 中的 CallingConv。
类型：Token
init()
public init()
功能：构造一个默认的 Annotation 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 Annotation 对象
let annotation = Annotation()
// 设置 Annotation 的属性
annotation.identifier = Token(TokenKind.IDENTIFIER, "Anno")
// 输出 Annotation 节点转化成的 Tokens
println("annotation.toTokens(): ${annotation.toTokens()}")
}
运行结果：
annotation.toTokens(): @Anno
init(Tokens)
public init(inputs: Tokens)
功能：根据输入的词法单元，构造一个 Annotation 对象。
参数：
- inputs: Tokens - 将要构造 Annotation 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 Annotation 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 Annotation 对象
let annotation = Annotation(quote(@!Anno))
// 输出 Annotation 节点转化成的 Tokens
println("annotation.toTokens(): ${annotation.toTokens()}")
}
运行结果：
annotation.toTokens(): @!Anno
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 Annotation 对象
let annotation = Annotation(quote(@!Anno))
// 输出 Annotation 节点转化成的 Tokens
println("annotation.toTokens(): ${annotation.toTokens()}")
}
运行结果：
annotation.toTokens(): @!Anno
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Annotation) {
println("Visiting Annotation")
}
}
main(): Unit {
let annotation = Annotation(quote(@!Anno))
// 对 Annotation 节点进行遍历
annotation.traverse(MyVisitor())
}
运行结果：
Visiting Annotation
class Argument
public class Argument <: Node {
public init()
}
功能：表示函数调用的实参节点。
例如 foo(arg:value) 中的 arg:value。
父类型：
prop colon
public mut prop colon: Token
功能：获取或设置 Argument 节点中的操作符 ":"，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ":" 操作符时，抛出异常。
prop expr
public mut prop expr: Expr
功能：获取或设置 Argument 节点中的表达式，如 arg:value 中的 value。
类型：Expr
prop identifier
public mut prop identifier: Token
功能：获取或设置 Argument 节点中的标识符，如 arg:value 中的 arg，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当获取和设置的 Token 类型不是 IDENTIFIER 标识符或 Token 的字面量值是空时，抛出异常。
prop keyword
public mut prop keyword: Token
功能：获取或设置 Argument 节点中的关键字 inout，可能为 ILLEGAL 的词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 Argument 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 Argument 对象
let argument = Argument()
argument.expr = RefExpr(quote(value))
// 将 Argument 转化为 Tokens 并输出
println("argument.toTokens(): ${argument.toTokens()}")
}
运行结果：
argument.toTokens(): value
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let argument = Argument()
let identifierToken = Token(TokenKind.IDENTIFIER, "arg")
let colonToken = Token(TokenKind.COLON, ":")
// 设置 Argument 的属性
argument.identifier = identifierToken
argument.colon = colonToken
argument.expr = RefExpr(quote(value))
// 将 Argument 转化为 Tokens 并输出
println("argument.toTokens(): ${argument.toTokens()}")
}
运行结果：
argument.toTokens(): arg: value
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Argument) {
println("Visiting Argument")
}
}
main(): Unit {
let argument = Argument()
argument.expr = RefExpr(quote(value))
// 使用自定义访问器遍历 Argument 节点
argument.traverse(MyVisitor())
}
运行结果：
Visiting Argument
class ArrayLiteral
public class ArrayLiteral <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 Array 字面量节点。
ArrayLiteral 节点：使用格式 [element1, element2, ... , elementN] 表示， 每个 element 是一个表达式。
父类型：
prop elements
public mut prop elements: ArrayList<Expr>
功能：获取或设置 ArrayLiteral 中的表达式列表。
prop lSquare
public mut prop lSquare: Token
功能：获取或设置 ArrayLiteral 中的 "["。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "[" 时，抛出异常。
prop rSquare
public mut prop rSquare: Token
功能：获取或设置 ArrayLiteral 中的 "]"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "]" 时，抛出异常。
init()
public init()
功能：构造一个默认的 ArrayLiteral 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ArrayLiteral 对象
let arrayLiteral = ArrayLiteral()
// 设置 ArrayLiteral 的属性
arrayLiteral.lSquare = Token(TokenKind.LSQUARE, "[")
arrayLiteral.rSquare = Token(TokenKind.RSQUARE, "]")
println("arrayLiteral.toTokens(): ${arrayLiteral.toTokens()}")
}
运行结果：
arrayLiteral.toTokens(): []
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ArrayLiteral 对象。
参数：
- inputs: Tokens - 将要构造 ArrayLiteral 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ArrayLiteral 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ArrayLiteral 对象
let arrayLiteral = ArrayLiteral(quote([1, 2, 3]))
println("arrayLiteral.toTokens(): ${arrayLiteral.toTokens()}")
}
运行结果：
arrayLiteral.toTokens(): [1, 2, 3]
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let arrayLiteral = ArrayLiteral()
// 设置数组字面量的属性
arrayLiteral.lSquare = Token(TokenKind.LSQUARE, "[")
arrayLiteral.rSquare = Token(TokenKind.RSQUARE, "]")
arrayLiteral.elements.add(RefExpr(quote(item)))
// 转化为 Tokens 并输出
println("arrayLiteral.toTokens(): ${arrayLiteral.toTokens()}")
}
运行结果：
arrayLiteral.toTokens(): [item]
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ArrayLiteral) {
println("Visiting ArrayLiteral")
}
}
main(): Unit {
let arrayLiteral = ArrayLiteral(quote([1, 2]))
// 使用自定义访问器遍历 ArrayLiteral 节点
arrayLiteral.traverse(MyVisitor())
}
运行结果：
Visiting ArrayLiteral
class AsExpr
public class AsExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示一个类型检查表达式。
一个 AsExpr 表达式：e as T，类型为 Option<T>。其中 e 可以是任何类型的表达式，T 可以是任何类型。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 AsExpr 节点中的表达式节点。
类型：Expr
prop keyword
public mut prop keyword: Token
功能：获取或设置 AsExpr 节点中的 as 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
as操作符时，抛出异常。
prop shiftType
public mut prop shiftType: TypeNode
功能：获取或设置 AsExpr 节点中的目标类型。
类型：TypeNode
init()
public init()
功能：构造一个默认的 AsExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 AsExpr 对象
let asExpr = AsExpr()
// 设置 AsExpr 的属性
asExpr.expr = RefExpr(quote(x))
asExpr.keyword = Token(TokenKind.AS, "as")
asExpr.shiftType = RefType(quote(A))
println("asExpr.toTokens(): ${asExpr.toTokens()}")
}
运行结果：
asExpr.toTokens(): x as A
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 AsExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 AsExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 AsExpr 对象
let asExpr = AsExpr(quote(value as Int64))
println("asExpr.toTokens(): ${asExpr.toTokens()}")
}
运行结果：
asExpr.toTokens(): value as Int64
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 AsExpr 对象
let asExpr = AsExpr(quote(value as Int64))
// 转化为 Tokens 并输出
println("asExpr.toTokens(): ${asExpr.toTokens()}")
}
运行结果：
asExpr.toTokens(): value as Int64
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: AsExpr) {
println("Visiting AsExpr")
}
}
main(): Unit {
let asExpr = AsExpr(quote(a as Int32))
// 使用自定义访问器遍历 AsExpr 节点
asExpr.traverse(MyVisitor())
}
运行结果：
Visiting AsExpr
class AssignExpr
public class AssignExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示赋值表达式节点。
用于将左操作数的值修改为右操作数的值。一个 AssignExpr 节点：a = b。
父类型：
prop assign
public mut prop assign: Token
功能：获取或设置 AssignExpr 节点中的赋值操作符（如 = 等）。
类型：Token
异常：
- ASTException - 当设置的 Token 不是赋值操作符时，抛出异常。
prop leftExpr
public mut prop leftExpr: Expr
功能：获取或设置 AssignExpr 节点中的左操作数。
类型：Expr
prop rightExpr
public mut prop rightExpr: Expr
功能：获取或设置 AssignExpr 节点中的右操作数。
类型：Expr
init()
public init()
功能：构造一个默认的 AssignExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 AssignExpr 对象
let assignExpr = AssignExpr()
// 设置 AssignExpr 的属性
assignExpr.leftExpr = RefExpr(quote(a))
assignExpr.assign = Token(TokenKind.ASSIGN, "=")
assignExpr.rightExpr = RefExpr(quote(b))
println("assignExpr.toTokens(): ${assignExpr.toTokens()}")
}
运行结果：
assignExpr.toTokens(): a = b
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 AssignExpr 对象。
参数：
- inputs: Tokens - 将要构造 AssignExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 AssignExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 AssignExpr 对象
let assignExpr = AssignExpr(quote(x = 10))
println("assignExpr.toTokens(): ${assignExpr.toTokens()}")
}
运行结果：
assignExpr.toTokens(): x = 10
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let assignExpr = AssignExpr()
// 设置 AssignExpr 的属性
assignExpr.leftExpr = RefExpr(quote(x))
assignExpr.assign = Token(TokenKind.ASSIGN, "=")
assignExpr.rightExpr = LitConstExpr(quote(42))
// 转化为 Tokens 并输出
println("assignExpr.toTokens(): ${assignExpr.toTokens()}")
}
运行结果：
assignExpr.toTokens(): x = 42
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: AssignExpr) {
println("Visiting AssignExpr")
}
}
main(): Unit {
let assignExpr = AssignExpr(quote(x = 10))
// 使用自定义访问器遍历 AssignExpr 节点
assignExpr.traverse(MyVisitor())
}
运行结果：
Visiting AssignExpr
class BinaryExpr
public class BinaryExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示一个二元操作表达式节点。
一个 BinaryExpr 节点：a + b, a - b 等。
父类型：
prop leftExpr
public mut prop leftExpr: Expr
功能：获取或设置 BinaryExpr 节点中操作符左侧的表达式节点。
类型：Expr
prop op
public mut prop op: Token
功能：获取或设置 BinaryExpr 节点中的二元操作符。
类型：Token
prop rightExpr
public mut prop rightExpr: Expr
功能：获取或设置 BinaryExpr 节点中操作符右侧的表达式节点。
类型：Expr
init()
public init()
功能：构造一个默认的 BinaryExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 BinaryExpr 对象
let binaryExpr = BinaryExpr()
// 设置 BinaryExpr 的属性
binaryExpr.leftExpr = RefExpr(quote(x))
binaryExpr.op = Token(TokenKind.ADD, "+")
binaryExpr.rightExpr = RefExpr(quote(y))
println("binaryExpr.toTokens(): ${binaryExpr.toTokens()}")
}
运行结果：
binaryExpr.toTokens(): x + y
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 BinaryExpr 对象。
参数：
- inputs: Tokens - 将要构造 BinaryExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 BinaryExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 BinaryExpr 对象
let binaryExpr = BinaryExpr(quote(5 + 3))
println("binaryExpr.toTokens(): ${binaryExpr.toTokens()}")
}
运行结果：
binaryExpr.toTokens(): 5 + 3
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 BinaryExpr 对象
let binaryExpr = BinaryExpr()
// 设置 BinaryExpr 的属性
binaryExpr.leftExpr = RefExpr(quote(a))
binaryExpr.op = Token(TokenKind.MUL, "*")
binaryExpr.rightExpr = RefExpr(quote(b))
// 转化为 Tokens 并输出
println("binaryExpr.toTokens(): ${binaryExpr.toTokens()}")
}
运行结果：
binaryExpr.toTokens(): a * b
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: BinaryExpr) {
println("Visiting BinaryExpr")
}
}
main(): Unit {
let binaryExpr = BinaryExpr(quote(1 + 1))
// 使用自定义访问器遍历 BinaryExpr 节点
binaryExpr.traverse(MyVisitor())
}
运行结果：
Visiting BinaryExpr
class Block
public class Block <: Expr {
public init()
}
功能：表示块节点。
Block 由一对匹配的大括号及其中可选的表达式声明序列组成的结构，简称 “块”。
父类型：
prop lBrace
public mut prop lBrace: Token
功能：获取或设置 Block 的 "{"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "{" 时，抛出异常。
prop nodes
public mut prop nodes: ArrayList<Node>
功能：获取或设置 Block 中的表达式或声明序列。
prop rBrace
public mut prop rBrace: Token
功能：获取或设置 Block 的 "}"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "}" 时，抛出异常。
init()
public init()
功能：构造一个默认的 Block 对象。
说明：
Block 节点无法脱离表达式或声明节点单独存在，因此不提供其他的构造函数。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 Block 对象
let block = Block()
// 设置 Block 的属性
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
// 转化为 Tokens 并输出
println("block.toTokens(): ${block.toTokens()}")
}
运行结果：
block.toTokens(): {
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let block = Block()
// 设置 Block 的属性
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
let expr = CallExpr(quote(foo()))
block.nodes.add(expr)
// 转化为 Tokens 并输出
println("block.toTokens(): ${block.toTokens()}")
}
运行结果：
block.toTokens(): {
foo()
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Block) {
println("Visiting Block")
}
}
main(): Unit {
let block = Block()
// 设置 Block 的属性
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
// 使用自定义访问器遍历 Block 节点
block.traverse(MyVisitor())
}
运行结果：
Visiting Block
class Body
public class Body <: Node {
public init(decls: ArrayList<Decl>)
public init()
}
功能：表示 Class 类型、 Struct 类型、 Interface 类型以及扩展中由 {} 和内部的一组声明节点组成的结构。
父类型：
prop decls
public mut prop decls: ArrayList<Decl>
功能：获取或设置 Body 内的声明节点集合。
prop lBrace
public mut prop lBrace: Token
功能：获取或设置 { 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
{词法单元时，抛出异常。
prop rBrace
public mut prop rBrace: Token
功能：获取或设置 } 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
}词法单元时，抛出异常。
init()
public init()
功能：构造一个默认的 Body 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 Body 对象
let body = Body()
// 设置 Body 的属性
body.lBrace = Token(TokenKind.LCURL, "{")
body.rBrace = Token(TokenKind.RCURL, "}")
println("body.toTokens(): ${body.toTokens()}")
}
运行结果：
body.toTokens(): {
}
init(ArrayList<Decl>)
public init(decls: ArrayList<Decl>)
功能：构造一个 Body 对象。
参数：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 创建声明列表
let decls = ArrayList<Decl>()
// 将变量声明添加到列表中
decls.add(VarDecl(quote(let x: Int64 = 10)))
// 使用声明列表创建 Body 对象
let body = Body(decls)
// 输出转换后的 Tokens
println("body.toTokens(): ${body.toTokens()}")
}
运行结果：
body.toTokens(): {
let x: Int64 = 10
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 Body 对象
let body = Body()
// 将变量声明添加到 Body 中
body.decls.add(VarDecl(quote(let x: Int64 = 10)))
// 将函数声明添加到 Body 中
body.decls.add(FuncDecl(quote(func foo() {})))
// 设置左右花括号
body.lBrace = Token(TokenKind.LCURL, "{")
body.rBrace = Token(TokenKind.RCURL, "}")
// 转换为 Tokens 并输出
println("body.toTokens(): ${body.toTokens()}")
}
运行结果：
body.toTokens(): {
let x: Int64 = 10
func foo() {
}
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
import std.collection.*
class MyVisitor <: Visitor {
public override func visit(_: Body) {
println("Visiting Body")
}
}
main(): Unit {
// 构造一个默认的 Body 对象
let body = Body()
// 设置 Body 的属性
body.lBrace = Token(TokenKind.LCURL, "{")
body.rBrace = Token(TokenKind.RCURL, "}")
// 使用自定义访问器遍历 Body 节点
body.traverse(MyVisitor())
}
运行结果：
Visiting Body
class CallExpr
public class CallExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示函数调用节点节点。
一个 CallExpr 节点包括一个表达式后面紧跟参数列表，例如 foo(100)。
父类型：
prop arguments
public mut prop arguments: ArrayList<Argument>
功能：获取或设置 CallExpr 节点中函数参数。
prop callFunc
public mut prop callFunc: Expr
功能：获取或设置 CallExpr 节点中的函数调用节点。
类型：Expr
prop lParen
public mut prop lParen: Token
功能：获取或设置 CallExpr 节点中的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 CallExpr 节点中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 CallExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 CallExpr 对象
let callExpr = CallExpr()
// 设置 CallExpr 的属性
callExpr.callFunc = RefExpr(quote(bar))
callExpr.lParen = Token(TokenKind.LPAREN, "(")
callExpr.rParen = Token(TokenKind.RPAREN, ")")
println("callExpr.toTokens(): ${callExpr.toTokens()}")
}
运行结果：
callExpr.toTokens(): bar()
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 CallExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 CallExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 CallExpr 对象
let callExpr = CallExpr(quote(foo(10, "hello")))
// 转化为 Tokens 并输出
println("callExpr.toTokens(): ${callExpr.toTokens()}")
}
运行结果：
callExpr.toTokens(): foo(10, "hello")
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 CallExpr 对象
let callExpr = CallExpr()
// 设置 CallExpr 的属性
callExpr.callFunc = RefExpr(quote(bar))
callExpr.lParen = Token(TokenKind.LPAREN, "(")
callExpr.rParen = Token(TokenKind.RPAREN, ")")
// 创建第一个参数并添加到调用表达式中
let arg1 = Argument()
arg1.expr = LitConstExpr(quote(true))
callExpr.arguments.add(arg1)
// 创建第二个参数并添加到调用表达式中
let arg2 = Argument()
arg2.expr = LitConstExpr(quote(3.14))
callExpr.arguments.add(arg2)
// 转化为 Tokens 并输出
println("callExpr.toTokens(): ${callExpr.toTokens()}")
}
运行结果：
callExpr.toTokens(): bar(true, 3.14)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: CallExpr) {
println("Visiting CallExpr")
}
}
main(): Unit {
let callExpr = CallExpr(quote(foo(42)))
// 使用自定义访问器遍历 CallExpr 节点
callExpr.traverse(MyVisitor())
}
运行结果：
Visiting CallExpr
class ClassDecl
public class ClassDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：类定义节点。
类的定义使用 class 关键字，定义依次为：可缺省的修饰符、class 关键字、class 名、可选的类型参数、是否指定父类或父接口、可选的泛型约束、类体的定义。
父类型：
prop body
public mut prop body: Body
功能：获取或设置 ClassDecl 节点的类体。
类型：Body
prop superTypeBitAnds
public mut prop superTypeBitAnds: Tokens
功能：获取或设置 ClassDecl 节点的父类或父接口声明中的 & 操作符的词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是
&词法单元序列时，抛出异常。
prop superTypes
public mut prop superTypes: ArrayList<TypeNode>
功能：获取或设置 ClassDecl 节点的父类或者父接口。
prop upperBound
public mut prop upperBound: Token
功能：获取或设置 <: 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
<:操作符时，抛出异常。
init()
public init()
功能：构造一个默认的 ClassDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ClassDecl 对象
let classDecl = ClassDecl()
// 设置 ClassDecl 的属性
classDecl.keyword = Token(TokenKind.CLASS, "class")
classDecl.identifier = Token(TokenKind.IDENTIFIER, "A")
classDecl.body = Body()
println("classDecl.toTokens(): ${classDecl.toTokens()}")
}
运行结果：
classDecl.toTokens(): class A {
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ClassDecl 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ClassDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ClassDecl 对象
let classDecl = ClassDecl(quote(class MyClass {}))
// 转化为 Tokens 并输出
println("classDecl.toTokens(): ${classDecl.toTokens()}")
}
运行结果：
classDecl.toTokens(): class MyClass {
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 ClassDecl 对象
let classDecl = ClassDecl()
// 设置 ClassDecl 的属性
classDecl.keyword = Token(TokenKind.CLASS, "class")
classDecl.identifier = Token(TokenKind.IDENTIFIER, "A")
let varDecl = VarDecl(quote(let x: Int64 = 10))
classDecl.body = Body(ArrayList<Decl>([varDecl]))
// 转化为 Tokens 并输出
println("classDecl.toTokens(): ${classDecl.toTokens()}")
}
运行结果：
classDecl.toTokens(): class A {
let x: Int64 = 10
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ClassDecl) {
println("Visiting ClassDecl")
}
}
main(): Unit {
// 从 Tokens 创建 ClassDecl 对象
let classDecl = ClassDecl(quote(class Test {}))
// 使用自定义访问器遍历 ClassDecl 节点
classDecl.traverse(MyVisitor())
}
运行结果：
Visiting ClassDecl
class CommandTypePattern
public class CommandTypePattern <: Pattern {
public init()
public init(inputs: Tokens)
}
功能：表示一个带有类型注解的命令模式，例如：pattern: Type1 | Type2 | ...。
一个 CommandTypePattern 节点的示例：
someCommand: Effect
父类型：
prop pattern
public mut prop pattern: Pattern
功能：获取或设置冒号（:）之前的命令模式。
类型：Pattern
prop colon
public mut prop colon: Token
功能：获取或设置用于分隔模式与类型的冒号（:）标记。
类型：Token
异常：
- ASTException — 如果提供的标记不是冒号，则抛出异常。
prop types
public mut prop types: ArrayList<TypeNode>
功能：获取或设置冒号后面的类型节点列表，例如：String | Int | Float。
init()
public init()
功能：构建一个默认的 CommandTypePattern 对象。
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 CommandTypePattern 对象
let commandTypePattern = CommandTypePattern()
// 设置 CommandTypePattern 的属性
commandTypePattern.colon = Token(TokenKind.COLON, ":")
commandTypePattern.pattern = WildcardPattern()
commandTypePattern.types = ArrayList<TypeNode>([RefType(quote(Eff))])
// 转化为 Tokens 并输出
println("commandTypePattern.toTokens(): ${commandTypePattern.toTokens()}")
}
运行结果：
commandTypePattern.toTokens(): _: Eff
init(Tokens)
public init(inputs: Tokens)
功能：从标记流中构建一个 CommandTypePattern 对象。
参数：
- inputs: Tokens — 要解析为
CommandTypePattern节点的标记集合。
异常：
- ASTException — 如果输入的标记无法解析为有效的
CommandTypePattern节点，则抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 CommandTypePattern 对象
let commandTypePattern = CommandTypePattern(quote(e: MyEffect))
// 转化为 Tokens 并输出
println("commandTypePattern.toTokens(): ${commandTypePattern.toTokens()}")
}
运行结果：
commandTypePattern.toTokens(): e: MyEffect
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 CommandTypePattern 对象
let commandTypePattern = CommandTypePattern()
// 设置 CommandTypePattern 的属性
commandTypePattern.colon = Token(TokenKind.COLON, ":")
commandTypePattern.pattern = WildcardPattern()
commandTypePattern.types = ArrayList<TypeNode>([RefType(quote(Eff))])
// 转化为 Tokens 并输出
println("commandTypePattern.toTokens(): ${commandTypePattern.toTokens()}")
}
运行结果：
commandTypePattern.toTokens(): _: Eff
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: CommandTypePattern) {
println("Visiting CommandTypePattern")
}
}
main(): Unit {
// 从 Tokens 创建 CommandTypePattern 对象
let commandTypePattern = CommandTypePattern(quote(e: MyEffect))
// 使用自定义访问器遍历 CommandTypePattern 节点
commandTypePattern.traverse(MyVisitor())
}
运行结果：
Visiting CommandTypePattern
class ConstPattern
public class ConstPattern <: Pattern {
public init(inputs: Tokens)
public init()
}
功能：表示常量模式节点。
常量模式可以是整数字面量、字符字节字面量、浮点数字面量、字符字面量、布尔字面量、字符串字面量等字面量，如 case 1 => 0 中的 1。
父类型：
prop litConstExpr
public mut prop litConstExpr: LitConstExpr
功能：获取或设置 ConstPattern 节点中的字面量表达式。
类型：LitConstExpr
init()
public init()
功能：构造一个默认的 ConstPattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ConstPattern 对象
let constPattern = ConstPattern()
// 设置 ConstPattern 的属性
constPattern.litConstExpr = LitConstExpr(quote(1))
println("constPattern.toTokens(): ${constPattern.toTokens()}")
}
运行结果：
constPattern.toTokens(): 1
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ConstPattern 对象。
参数：
- inputs: Tokens - 将要构造 ConstPattern 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ConstPattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ConstPattern 对象
let constPattern = ConstPattern(quote(42))
// 输出转换后的 Tokens
println("constPattern.toTokens(): ${constPattern.toTokens()}")
}
运行结果：
constPattern.toTokens(): 42
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ConstPattern 对象
let constPattern = ConstPattern()
// 设置 ConstPattern 的属性
constPattern.litConstExpr = LitConstExpr(quote(3.14))
// 转化为 Tokens 并输出
println("constPattern.toTokens(): ${constPattern.toTokens()}")
}
运行结果：
constPattern.toTokens(): 3.14
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ConstPattern) {
println("Visiting ConstPattern")
}
}
main(): Unit {
// 从 Tokens 创建 ConstPattern 对象
let constPattern = ConstPattern(quote(100))
// 使用自定义访问器遍历ConstPattern节点
constPattern.traverse(MyVisitor())
}
运行结果：
Visiting ConstPattern
class Constructor
public class Constructor <: Node {
public init()
}
功能：表示 enum 类型中的 Constructor 节点。
一个 Constructor 节点：enum TimeUnit { Year | Month(Float32, Float32)} 中的 Year 和 Month(Float32, Float32)。
说明：
Constructor 可以没有参数，也可以有一组不同类型的参数。
父类型：
prop annotations
public mut prop annotations: ArrayList<Annotation>
功能：获取或设置作用于 Constructor 节点的注解列表。
类型：ArrayList<Annotation>
prop identifier
public mut prop identifier: Token
功能：获取或设置 Constructor 的标识符词法单元。
类型：Token
prop lParen
public mut prop lParen: Token
功能：获取或设置 Constructor 节点中的 "(" 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 Constructor 节点中的 ")" 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop typeArguments
public mut prop typeArguments: ArrayList<TypeNode>
功能：获取或设置 Constructor 节点可选的参数类型节点的集合。
init()
public init()
功能：构造一个默认的 Constructor 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 Constructor 对象
let constructor = Constructor()
// 设置 Constructor 的属性
constructor.identifier = Token(TokenKind.IDENTIFIER, "Con")
// 转化为 Tokens 并输出
println("constructor.toTokens(): ${constructor.toTokens()}")
}
运行结果：
constructor.toTokens(): Con
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 Constructor 对象
let constructor = Constructor()
// 设置 Constructor 的属性
constructor.identifier = Token(TokenKind.IDENTIFIER, "Year")
// 转化为 Tokens 并输出
println("constructor.toTokens(): ${constructor.toTokens()}")
}
运行结果：
constructor.toTokens(): Year
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Constructor) {
println("Visiting Constructor")
}
}
main(): Unit {
// 构造一个默认的 Constructor 对象
let constructor = Constructor()
// 设置 Constructor 的属性
constructor.identifier = Token(TokenKind.IDENTIFIER, "Month")
// 使用自定义访问器遍历 Constructor 节点
constructor.traverse(MyVisitor())
}
运行结果：
Visiting Constructor
class Decl
public open class Decl <: Node {
protected var annotations_: ArrayList<Annotation> = ArrayList<Annotation>()
protected var modifiers_: ArrayList<Modifier> = ArrayList<Modifier>()
protected var keyword_: Token = Token()
protected var identifier_: Token = Token()
protected var node: Node = Expr()
}
功能：所有声明节点的父类，继承自 Node 节点，提供了所有声明节点的通用接口。
说明：
类定义、接口定义、函数定义、变量定义、枚举定义、结构体定义、扩展定义、类型别名定义、宏定义等都属于 Decl 节点。
父类型：
var annotations_
protected var annotations_: ArrayList<Annotation> = ArrayList<Annotation>()
功能：获取或设置作用于 Decl 节点的注解列表。
类型：ArrayList<Annotation>
var identifier_
protected var identifier_: Token = Token()
功能：获取或设置声明节点的标识符，如 class foo {} 中的 foo。
类型：Token
var keyword_
protected var keyword_: Token = Token()
功能：获取或设置声明节点的关键字。
类型：Token
var modifiers_
protected var modifiers_: ArrayList<Modifier> = ArrayList<Modifier>()
功能：获取或设置节点的修饰符列表。
var node
protected var node: Node = Expr()
功能：获取或设置Decl 节点的形参节点。
类型：Node
prop annotations
public mut prop annotations: ArrayList<Annotation>
功能：获取或设置作用于 Decl 节点的注解列表。
类型：ArrayList<Annotation>
prop constraintCommas
public mut prop constraintCommas: Tokens
功能：获取或设置 Decl 节点中的 "," 词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop genericConstraint
public mut prop genericConstraint: ArrayList<GenericConstraint>
功能：获取或设置声明节点的泛型约束，可能为空，如 func foo<T>() where T <: Comparable<T> {} 中的 where T <: Comparable<T>。
类型：ArrayList<GenericConstraint>
prop genericParam
public mut prop genericParam: GenericParam
功能：获取或设置形参列表，类型形参列表由 <> 括起，多个类型形参之间用逗号分隔。
类型：GenericParam
异常：
- ASTException - 当节点未定义类型形参列表时，抛出异常。
prop identifier
public mut open prop identifier: Token
功能：获取或设置声明节点的标识符，如 class foo {} 中的 foo。
类型：Token
prop isGenericDecl
public mut prop isGenericDecl: Bool
功能：判断是否是一个泛型节点。
类型：Bool - 是一个泛型节点为 true；反之为 false。
prop keyword
public mut prop keyword: Token
功能：获取或设置声明节点的关键字。
类型：Token
prop modifiers
public mut prop modifiers: ArrayList<Modifier>
功能：获取或设置节点的修饰符列表。
func dump(UInt16)
protected open func dump(indent: UInt16): String
功能：将当前语法树节点转化为树形结构的形态并进行打印。语法树节点的树形结构将按照以下形式进行输出：
-字符串：表示当前节点的公共属性， 如-keyword,-identifier。- 节点属性后紧跟该节点的具体类型， 如
-declType: PrimitiveType表示节点类型是一个 PrimitiveType 节点。 - 每个类型使用大括号表示类型的作用区间。
语法树输出的详细格式请参见语法树节点打印。
参数：
- indent: UInt16 - 格式化输出的缩进空格数量。
返回值：
- String - 格式化输出内容。
示例：
import std.ast.*
// 在子类中调用
extend FuncDecl {
public func myDump() {
dump(1)
}
}
main(): Unit {
// 创建 Decl 的子类
let decl = FuncDecl(quote(func foo() {}))
println("decl.myDump(): ${decl.myDump()}")
}
运行结果：
decl.myDump(): FuncDecl {
-keyword: Token {
value: "func"
kind: FUNC
pos: 12: 31
}
-identifier: Token {
value: "foo"
kind: IDENTIFIER
pos: 12: 36
}
-block: Block {
}
}
func getAttrs()
public func getAttrs(): Tokens
功能：获取当前节点的属性（一般通过内置的 Attribute 来设置某个声明设置属性值）。
返回值：
- Tokens - 当前节点的属性。
示例：
import std.ast.*
main(): Unit {
// 创建 Decl 节点
let decl = ClassDecl(quote(@Attribute[attr1, attr2] class A {}))
// 获取 Decl 节点属性值
println("decl.getAttrs(): ${decl.getAttrs()}")
}
运行结果：
decl.getAttrs(): attr1 attr2
func hasAttr(String)
public func hasAttr(attr: String): Bool
功能：判断当前节点是否具有某个属性（一般通过内置的 Attribute 来设置某个声明的属性值）。
参数：
- attr: String - 将要判断是否存在于该节点的属性。
返回值：
- Bool - 当前节点具有该属性时，返回 true；反之，返回 false。
示例：
import std.ast.*
main(): Unit {
// 创建 Decl 节点
let decl = ClassDecl(quote(@Attribute[attr1, attr2] class A {}))
// 判断 Decl 节点是否有对应属性值
println("decl.hasAttr(\"attr1\"): ${decl.hasAttr("attr1")}")
println("decl.hasAttr(\"attr2\"): ${decl.hasAttr("attr2")}")
println("decl.hasAttr(\"attr3\"): ${decl.hasAttr("attr3")}")
}
运行结果：
decl.hasAttr("attr1"): true
decl.hasAttr("attr2"): true
decl.hasAttr("attr3"): false
func toTokens()
public open func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 创建 Decl 节点
let decl = ClassDecl(quote(class A {}))
// 转化为 Tokens 并输出
println("decl.toTokens(): ${decl.toTokens()}")
}
运行结果：
decl.toTokens(): class A {
}
func traverse(Visitor)
public open func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Decl) {
breakTraverse()
println("Visiting Decl")
}
}
main(): Unit {
// 创建 Decl 节点（以 ClassDecl 为例）
let decl = ClassDecl(quote(class A {}))
// 使用自定义访问器遍历 Decl 节点
decl.traverse(MyVisitor())
}
运行结果：
Visiting Decl
class DoWhileExpr
public class DoWhileExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 do-while 表达式。
父类型：
prop block
public mut prop block: Block
功能：获取或设置 DoWhileExpr 中的块表达式。
类型：Block
prop condition
public mut prop condition: Expr
功能：获取或设置关键字 DoWhileExpr 中的条件表达式。
类型：Expr
prop keywordD
public mut prop keywordD: Token
功能：获取或设置 DoWhileExpr 节点中 do 关键字，其中 keywordD 中的 D 为关键字 do 的首字母大写，代表关键字 do 。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
do关键字时，抛出异常。
prop keywordW
public mut prop keywordW: Token
功能：获取或设置 DoWhileExpr 节点中 while 关键字，其中 keywordW 中的 W 为关键字 while 的首字母大写，代表关键字 while 。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
while关键字时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 DoWhileExpr 中 while 关键字之后的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 DoWhileExpr 中 while 关键字之后的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 DoWhileExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 DoWhileExpr 对象
let doWhileExpr = DoWhileExpr()
// 设置 DoWhileExpr 的属性
doWhileExpr.keywordD = Token(TokenKind.DO, "do")
doWhileExpr.keywordW = Token(TokenKind.WHILE, "while")
doWhileExpr.lParen = Token(TokenKind.LPAREN, "(")
doWhileExpr.rParen = Token(TokenKind.RPAREN, ")")
doWhileExpr.condition = RefExpr(quote(flag))
let block = Block()
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
doWhileExpr.block = block
// 转化为 Tokens 并输出
println("doWhileExpr.toTokens(): ${doWhileExpr.toTokens()}")
}
运行结果：
doWhileExpr.toTokens(): do {
}
while(flag)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 DoWhileExpr 对象。
参数：
- inputs: Tokens - 将要构造 DoWhileExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 DoWhileExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 DoWhileExpr 对象
let doWhileExpr = DoWhileExpr(quote(do {} while (true)))
// 转化为 Tokens 并输出
println("doWhileExpr.toTokens(): ${doWhileExpr.toTokens()}")
}
运行结果：
doWhileExpr.toTokens(): do {
}
while(true)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 DoWhileExpr 对象
let doWhileExpr = DoWhileExpr()
// 设置 DoWhileExpr 的属性
doWhileExpr.keywordD = Token(TokenKind.DO, "do")
doWhileExpr.keywordW = Token(TokenKind.WHILE, "while")
doWhileExpr.lParen = Token(TokenKind.LPAREN, "(")
doWhileExpr.rParen = Token(TokenKind.RPAREN, ")")
doWhileExpr.condition = RefExpr(quote(flag))
let block = Block()
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
doWhileExpr.block = block
// 转化为 Tokens 并输出
println("doWhileExpr.toTokens(): ${doWhileExpr.toTokens()}")
}
运行结果：
doWhileExpr.toTokens(): do {
}
while(flag)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: DoWhileExpr) {
println("Visiting DoWhileExpr")
}
}
main(): Unit {
let doWhileExpr = DoWhileExpr(quote(do {} while (false)))
// 使用自定义访问器遍历 DoWhileExpr 节点
doWhileExpr.traverse(MyVisitor())
}
运行结果：
Visiting DoWhileExpr
class EnumDecl
public class EnumDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示一个 Enum 定义节点。
Enum 的定义使用 enum 关键字，定义依次为：可缺省的修饰符、enum 关键字、enum 名、可选的类型参数、是否指定父接口、可选的泛型约束、enum 体的定义。
父类型：
prop constructors
public mut prop constructors: ArrayList<Constructor>
功能：获取或设置 EnumDecl 节点内 constructor 的成员。
类型：ArrayList<Constructor>
prop decls
public mut prop decls: ArrayList<Decl>
功能：获取或设置 EnumDecl 节点内除 constructor 的其他成员。
prop ellipsis
public mut prop ellipsis: Token
功能：获取或设置 EnumDecl 节点中可选的 ... 词法单元，可能为 ILLEGAL 的词法单元类型。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
...词法单元时，抛出异常。
prop lBrace
public mut prop lBrace: Token
功能：获取或设置 EnumDecl 节点的 { 词法单元类型。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
{词法单元类型时，抛出异常。
prop rBrace
public mut prop rBrace: Token
功能：获取或设置 EnumDecl 节点的 } 词法单元类型。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
}词法单元类型时，抛出异常。
prop superTypeBitAnds
public mut prop superTypeBitAnds: Tokens
功能：获取或设置 EnumDecl 节点的父接口声明中的 & 操作符的词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是
&词法单元序列时，抛出异常。
prop superTypes
public mut prop superTypes: ArrayList<TypeNode>
功能：获取或设置 EnumDecl 节点的父接口。
prop upperBound
public mut prop upperBound: Token
功能：获取或设置 <: 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
<:操作符时，抛出异常。
init()
public init()
功能：构造一个默认的 EnumDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 EnumDecl 对象
let enumDecl = EnumDecl()
// 设置 EnumDecl 的属性
enumDecl.keyword = Token(TokenKind.ENUM, "enum")
enumDecl.identifier = Token(TokenKind.IDENTIFIER, "status")
let constructor = Constructor()
constructor.identifier = Token(TokenKind.IDENTIFIER, "Active")
enumDecl.constructors.add(constructor)
enumDecl.lBrace = Token(TokenKind.LCURL, "{")
enumDecl.rBrace = Token(TokenKind.RCURL, "}")
// 转化为 Tokens 并输出
println("enumDecl.toTokens(): ${enumDecl.toTokens()}")
}
运行结果：
enumDecl.toTokens(): enum status {
Active
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 EnumDecl 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 EnumDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 EnumDecl 对象
let enumDecl = EnumDecl(quote(enum Color { Red | Green | Blue }))
// 转化为 Tokens 并输出
println("enumDecl.toTokens(): ${enumDecl.toTokens()}")
}
运行结果：
enumDecl.toTokens(): enum Color {
Red
| Green
| Blue
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 EnumDecl 对象
let enumDecl = EnumDecl()
// 设置 EnumDecl 的属性
enumDecl.keyword = Token(TokenKind.ENUM, "enum")
enumDecl.identifier = Token(TokenKind.IDENTIFIER, "status")
let constructor = Constructor()
constructor.identifier = Token(TokenKind.IDENTIFIER, "Active")
enumDecl.constructors.add(constructor)
// 创建函数声明
let funcDecl = FuncDecl(quote(func getValue(): Int64 { 0 }))
// 将函数声明添加到EnumDecl中
enumDecl.decls.add(funcDecl)
// 设置左右花括号
enumDecl.lBrace = Token(TokenKind.LCURL, "{")
enumDecl.rBrace = Token(TokenKind.RCURL, "}")
// 转化为 Tokens 并输出
println("enumDecl.toTokens(): ${enumDecl.toTokens()}")
}
运行结果：
enumDecl.toTokens(): enum status {
Active
func getValue(): Int64 {
0
}
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: EnumDecl) {
println("Visiting EnumDecl")
}
}
main(): Unit {
let enumDecl = EnumDecl(quote(enum Status { Pending | Completed }))
// 使用自定义访问器遍历 EnumDecl 节点
enumDecl.traverse(MyVisitor())
}
运行结果：
Visiting EnumDecl
class EnumPattern
public class EnumPattern <: Pattern {
public init()
public init(inputs: Tokens)
}
功能：表示 enum 模式节点。
用于匹配 enum 的 constructor， 如 case Year(n) => 1 中的 Year(n)。
父类型：
prop commas
public mut prop commas: Tokens
功能：获取或设置 EnumPattern 节点中的 "," 词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop constructor
public mut prop constructor: Expr
功能：获取或设置 EnumPattern 节点中的构造器表达式节点。
类型：Expr
prop lParen
public mut prop lParen: Token
功能：获取或设置 EnumPattern 节点中的 "(" 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop patterns
public mut prop patterns: ArrayList<Pattern>
功能：获取或设置 EnumPattern 节点中有参构造器内的模式节点列表。
prop rParen
public mut prop rParen: Token
功能：获取或设置 EnumPattern 节点中的 ")" 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 EnumPattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 EnumPattern 对象
let enumPattern = EnumPattern()
// 设置 EnumPattern 的属性
enumPattern.constructor = RefExpr(quote(Status))
enumPattern.lParen = Token(TokenKind.LPAREN, "(")
enumPattern.rParen = Token(TokenKind.RPAREN, ")")
let pattern = WildcardPattern()
enumPattern.patterns.add(pattern)
// 转化为 Tokens 并输出
println("enumPattern.toTokens(): ${enumPattern.toTokens()}")
}
运行结果：
enumPattern.toTokens(): Status(_)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 EnumPattern 对象。
参数：
- inputs: Tokens - 将要构造 EnumPattern 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 EnumPattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 EnumPattern 对象
let enumPattern = EnumPattern(quote(Point(x, y)))
// 转化为 Tokens 并输出
println("enumPattern.toTokens(): ${enumPattern.toTokens()}")
}
运行结果：
enumPattern.toTokens(): Point(x, y)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 EnumPattern 对象
let enumPattern = EnumPattern()
// 设置 EnumPattern 的属性
enumPattern.constructor = RefExpr(quote(Status))
enumPattern.lParen = Token(TokenKind.LPAREN, "(")
enumPattern.rParen = Token(TokenKind.RPAREN, ")")
// 创建模式
let pattern = WildcardPattern()
// 将模式添加到 EnumPattern 中
enumPattern.patterns.add(pattern)
// 转化为 Tokens 并输出
println("enumPattern.toTokens(): ${enumPattern.toTokens()}")
}
运行结果：
enumPattern.toTokens(): Status(_)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: EnumPattern) {
println("Visiting EnumPattern")
}
}
main(): Unit {
// 从 Tokens 创建 EnumPattern 对象
let enumPattern = EnumPattern(quote(Error(code)))
// 使用自定义访问器遍历 EnumPattern 节点
enumPattern.traverse(MyVisitor())
}
运行结果：
Visiting EnumPattern
class ExceptTypePattern
public class ExceptTypePattern <: Pattern {
public init()
public init(inputs: Tokens)
}
功能：表示一个用于异常模式状态下的节点。
例如 e: Exception1 | Exception2。
父类型：
prop colon
public mut prop colon: Token
功能：获取或设置 ExceptTypePattern 节点中的 ":" 操作符的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ":" 操作符时，抛出异常。
prop pattern
public mut prop pattern: Pattern
功能：获取或设置 ExceptTypePattern 节点中的模式节点。
类型：Pattern
prop types
public mut prop types: ArrayList<TypeNode>
功能：获取或设置 ExceptTypePattern 节点中有类型列表。
init()
public init()
功能：构造一个默认的 ExceptTypePattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ExceptTypePattern 对象
let exceptTypePattern = ExceptTypePattern()
// 设置 ExceptTypePattern 的属性
exceptTypePattern.colon = Token(TokenKind.COLON, ":")
exceptTypePattern.pattern = WildcardPattern()
let ioExceptionType = RefType(quote(IOException))
exceptTypePattern.types.add(ioExceptionType)
// 转化为 Tokens 并输出
println("exceptTypePattern.toTokens(): ${exceptTypePattern.toTokens()}")
}
运行结果：
exceptTypePattern.toTokens(): _: IOException
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ExceptTypePattern 对象。
参数：
- inputs: Tokens - 将要构造 ExceptTypePattern 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ExceptTypePattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ExceptTypePattern 对象
let exceptTypePattern = ExceptTypePattern(quote(e: IOException))
// 转化为 Tokens 并输出
println("exceptTypePattern.toTokens(): ${exceptTypePattern.toTokens()}")
}
运行结果：
exceptTypePattern.toTokens(): e: IOException
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 ExceptTypePattern 对象
let exceptTypePattern = ExceptTypePattern()
// 设置 ExceptTypePattern 的属性
exceptTypePattern.colon = Token(TokenKind.COLON, ":")
exceptTypePattern.pattern = WildcardPattern()
// 创建第一个类型
let ioExceptionType = RefType(quote(IOException))
// 创建第二个类型
let fileExceptionType = RefType(quote(FileException))
// 将类型添加到 ExceptTypePattern 中
exceptTypePattern.types.add(ioExceptionType)
exceptTypePattern.types.add(fileExceptionType)
// 转化为 Tokens 并输出
println("exceptTypePattern.toTokens(): ${exceptTypePattern.toTokens()}")
}
运行结果：
exceptTypePattern.toTokens(): _: IOException | FileException
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ExceptTypePattern) {
println("Visiting ExceptTypePattern")
}
}
main(): Unit {
// 从 Tokens 创建 ExceptTypePattern 对象
let exceptTypePattern = ExceptTypePattern(quote(err: RuntimeException))
// 使用自定义访问器遍历 ExceptTypePattern 节点
exceptTypePattern.traverse(MyVisitor())
}
运行结果：
Visiting ExceptTypePattern
class Expr
public open class Expr <: Node {}
功能：所有表达式节点的父类，继承自 Node 节点。
表达式节点的 toTokens 方法会根据操作符优先级添加括号，例如已有一个 BinaryExpr 节点 a * b, 用户将左表达式内容 a 修改为 a + 1，修改后 toTokens 方法会为左表达式添加括号，toTokens 输出为 (a + 1) * b。
父类型：
func dump(UInt16)
protected open func dump(_: UInt16): String
功能：将当前语法树节点转化为树形结构的形态并进行打印，需要被子类重写。
参数：
- _: UInt16 - 格式化输出的缩进空格数量。
返回值：
- String - 格式化输出内容。
示例：
import std.ast.*
// 在子类中调用
extend BinaryExpr {
public func myDump() {
dump(1)
}
}
main(): Unit {
// 创建 Expr 的子类
let expr = BinaryExpr(quote(1 + 1))
println("expr.myDump(): ${expr.myDump()}")
}
运行结果：
expr.myDump(): BinaryExpr {
-leftExpr: LitConstExpr {
-literal: Token {
value: "1"
kind: INTEGER_LITERAL
pos: 12: 33
}
}
-op: Token {
value: "+"
kind: ADD
pos: 12: 35
}
-rightExpr: LitConstExpr {
-literal: Token {
value: "1"
kind: INTEGER_LITERAL
pos: 12: 37
}
}
}
func precedence()
protected open func precedence(): Int64
功能：返回当前表达式节点的优先级。
返回值：
- Int64 - 当前表达式节点的优先级。
示例：
import std.ast.*
// 在子类中调用
extend BinaryExpr {
public func myPrecedence(): Int64 {
precedence()
}
}
main(): Unit {
// 创建 Expr 的子类
let binaryExpr1 = BinaryExpr(quote(1 + 1))
let binaryExpr2 = BinaryExpr()
binaryExpr2.leftExpr = binaryExpr1
binaryExpr2.op = Token(TokenKind.MUL, "*")
binaryExpr2.rightExpr = LitConstExpr(quote(5))
// 输出内外 Expr 的优先级
println("binaryExpr1.myPrecedence(): ${binaryExpr1.myPrecedence()}")
println("binaryExpr2.myPrecedence(): ${binaryExpr2.myPrecedence()}")
// 由于内层 Expr 低于外层，自动添加了括号
println("binaryExpr2.toTokens(): ${binaryExpr2.toTokens()}")
}
运行结果：
binaryExpr1.myPrecedence(): 12
binaryExpr2.myPrecedence(): 13
binaryExpr2.toTokens(): (1 + 1) * 5
func toTokens()
public open func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建 Expr 节点
let expr = BinaryExpr(quote(1 + 1))
// 转化为 Tokens 并输出
println("expr.toTokens(): ${expr.toTokens()}")
}
运行结果：
expr.toTokens(): 1 + 1
func traverse(Visitor)
public open func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Expr) {
breakTraverse()
println("Visiting Expr")
}
}
main(): Unit {
// 创建 Expr 节点（以 BinaryExpr 为例）
let expr = BinaryExpr(quote(1 + 1))
// 使用自定义访问器遍历 Expr 节点
expr.traverse(MyVisitor())
}
运行结果：
Visiting Expr
class ExtendDecl
public class ExtendDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示一个扩展定义节点。
扩展的定义使用 extend 关键字，扩展定义依次为：extend 关键字、扩展类型、是否指定父接口、可选的泛型约束、扩展体的定义。
父类型：
prop body
public mut prop body: Body
功能：获取或设置 ExtendDecl 节点的类体。
类型：Body
prop extendType
public mut prop extendType: TypeNode
功能：获取或设置被扩展的类型。
类型：TypeNode
prop identifier
public mut override prop identifier: Token
功能：ExtendDecl 节点继承 Decl 节点，但是不支持 identifier 属性，使用时会抛出异常。
类型：Token
异常：
- ASTException - 当使用
identifier属性时，抛出异常。
prop superTypeBitAnds
public mut prop superTypeBitAnds: Tokens
功能：获取或设置 ExtendDecl 节点的父接口声明中的 & 操作符的词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是
&词法单元序列时，抛出异常。
prop superTypes
public mut prop superTypes: ArrayList<TypeNode>
功能：获取或设置 ExtendDecl 节点的父接口。
prop upperBound
public mut prop upperBound: Token
功能：获取或设置 <: 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
<:操作符时，抛出异常。
init()
public init()
功能：构造一个默认的 ExtendDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ExtendDecl 对象
let extendDecl = ExtendDecl()
// 设置 ExtendDecl 的属性
extendDecl.extendType = RefType(quote(B))
let body = Body()
let funcDecl = FuncDecl(quote(func bar() { println("Hello from bar") }))
body.decls.add(funcDecl)
extendDecl.body = body
// 转化为 Tokens 并输出
println("extendDecl.toTokens(): ${extendDecl.toTokens()}")
}
运行结果：
extendDecl.toTokens(): B {
func bar() {
println("Hello from bar")
}
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ExtendDecl 对象。
参数：
- inputs: Tokens - 将要构造 ExtendDecl 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ExtendDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ExtendDecl 对象
let extendDecl = ExtendDecl(quote(extend A { func foo() {} }))
// 转化为 Tokens 并输出
println("extendDecl.toTokens(): ${extendDecl.toTokens()}")
}
运行结果：
extendDecl.toTokens(): extend A {
func foo() {
}
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ExtendDecl 对象
let extendDecl = ExtendDecl()
// 设置 ExtendDecl 的属性
extendDecl.extendType = RefType(quote(B))
let body = Body()
let funcDecl = FuncDecl(quote(func bar() { println("Hello from bar") }))
body.decls.add(funcDecl)
extendDecl.body = body
// 转化为 Tokens 并输出
println("extendDecl.toTokens(): ${extendDecl.toTokens()}")
}
运行结果：
extendDecl.toTokens(): B {
func bar() {
println("Hello from bar")
}
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ExtendDecl) {
println("Visiting ExtendDecl")
}
}
main(): Unit {
// 从 Tokens 创建 ExtendDecl 对象
let extendDecl = ExtendDecl(quote(extend A { func foo() {} }))
// 使用自定义访问器遍历 ExtendDecl 节点
extendDecl.traverse(MyVisitor())
}
运行结果：
Visiting ExtendDecl
class FeatureId
public class FeatureId <: Node {
public init()
}
功能：表示一个 feature id。
注意:
必须以关键字开头
features，其次是 feature id 列表，必须出现在源文件的包名声明之前。 feature id 由标识符组成，标识符之间用点号分隔。feature id 不能用反引号转义。
父类型:
prop identifiers
public mut prop identifiers: Tokens
功能：获取或设置 FeatureId 节点的标识符。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是一组标识符。
prop dots
public mut prop dots: Tokens
功能：获取或设置 feature 的点号。例如：features { user.define.sample }。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是一组
.。
init()
public init()
功能：构造一个 FeatureId 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 FeatureId 对象
let featureId = FeatureId()
// 设置 FeatureId 的属性
featureId.identifiers = quote(ftr)
// 转化为 Tokens 并输出
println("featureId.toTokens(): ${featureId.toTokens()}")
}
运行结果：
featureId.toTokens(): ftr
func toTokens()
public func toTokens(): Tokens
功能：转换当前的抽象语法树节点为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 FeatureId 对象
let featureId = FeatureId()
// 设置 FeatureId 的属性
featureId.identifiers = quote(a b c)
featureId.dots = quote(. .)
// 转化为 Tokens 并输出
println("featureId.toTokens(): ${featureId.toTokens()}")
}
运行结果：
featureId.toTokens(): a.b.c
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。要提前终止子节点遍历，请重写 visit 函数并调用 breakTraverse 函数来终止遍历行为。参见 自定义访问函数遍历 AST 对象。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FeatureId) {
println("Visiting FeatureId")
}
}
main(): Unit {
// 构造一个默认的 FeatureId 对象
let featureId = FeatureId()
// 设置 FeatureId 的属性
featureId.identifiers = quote(a b c)
featureId.dots = quote(. .)
// 使用自定义访问器遍历 FeatureId 节点
featureId.traverse(MyVisitor())
}
运行结果：
Visiting FeatureId
class FeaturesDirective
public class FeaturesDirective <: Node {
public init()
public init(input: Tokens)
}
功能：feature directive 节点对象。
注意：
Features 声明必须以关键字
features开头，后跟 FeaturesSet，并且必须出现在源文件的包头之前。
父类型：
prop annotations
public mut prop annotations: ArrayList<Annotation>
功能：获取或设置在 FeaturesDirective 上的注解。
类型：ArrayList<Annotation>
prop keyword
public mut prop keyword: Token
功能：获取或设置 FeaturesDirective 节点里的 features 关键字。
类型：Token
异常：
- ASTException - 在配置的不是关键字时抛出异常。
prop featuresSet
public mut prop featuresSet: FeaturesSet
功能：获取或设置 FeaturesDirective 节点里的 features 名称。
类型：FeaturesSet
init()
public init()
功能：构造一个默认的 FeaturesDirective 对象。
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 FeaturesDirective 对象
let featuresDirective = FeaturesDirective()
// 设置 FeaturesDirective 的属性
featuresDirective.keyword = Token(TokenKind.FEATURES, "features")
let featuresSet = FeaturesSet()
let featureId = FeatureId()
featureId.identifiers = quote(ftr)
featuresSet.content = ArrayList<FeatureId>([featureId])
featuresSet.lCurl = Token(TokenKind.LCURL, "{")
featuresSet.rCurl = Token(TokenKind.RCURL, "}")
featuresDirective.featuresSet = featuresSet
// 转化为 Tokens 并输出
println("featuresDirective.toTokens(): ${featuresDirective.toTokens()}")
}
运行结果：
featuresDirective.toTokens(): features { ftr }
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 FeaturesDirective 对象。
参数：
- inputs: Tokens - 用于构造 FeaturesDirective 节点的词法单元集合。
异常：
- ASTException - 当输入的 Tokens 无法构造 FeaturesDirective 的时候抛出异常。
示例：
import std.ast.*
main(): Unit {
// 用 Tokens 创建一个 FeaturesDirective 对象
let featuresDirective = FeaturesDirective(quote(features {a, b.c}))
// 转化为 Tokens 并输出
println("featuresDirective.toTokens(): ${featuresDirective.toTokens()}")
}
运行结果：
featuresDirective.toTokens(): features { a, b.c }
func toTokens()
public func toTokens(): Tokens
功能：转换一个语法树节点为 Tokens。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 FeaturesDirective 对象
let featuresDirective = FeaturesDirective()
// 设置 FeaturesDirective 的属性
featuresDirective.keyword = Token(TokenKind.FEATURES, "features")
let featuresSet = FeaturesSet()
let featureId = FeatureId()
featureId.identifiers = quote(ftr)
featuresSet.content = ArrayList<FeatureId>([featureId])
featuresSet.lCurl = Token(TokenKind.LCURL, "{")
featuresSet.rCurl = Token(TokenKind.RCURL, "}")
featuresDirective.featuresSet = featuresSet
// 转化为 Tokens 并输出
println("featuresDirective.toTokens(): ${featuresDirective.toTokens()}")
}
运行结果：
featuresDirective.toTokens(): features { ftr }
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。要提前终止子节点遍历，请重写 visit 函数并调用 breakTraverse 函数来终止遍历行为。参见 自定义访问函数遍历 AST 对象。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FeaturesDirective) {
println("Visiting FeaturesDirective")
}
}
main(): Unit {
// 用 Tokens 创建一个 FeaturesDirective 对象
let featuresDirective = FeaturesDirective(quote(features {a, b.c}))
// 使用自定义访问器遍历 FeaturesDirective 节点
featuresDirective.traverse(MyVisitor())
}
运行结果：
Visiting FeaturesDirective
class FeaturesSet
public class FeaturesSet <: Node {
public init()
public init(input: Tokens)
}
功能：一组 features 名称。
注意：
featuresSet 必须开被
{}包裹。featuresSet 包含一组 FeatureId。
父类型：
prop lCurl
public mut prop lCurl: Token
功能：获取或设置在 FeaturesSet 节点里的 { 。
类型：Token
异常：
- ASTException - 当配置的不是
{时抛出异常。
prop content
public mut prop content: ArrayList<FeatureId>
功能：获取或设置在 FeaturesSet 节点里的一组 feature id。
异常：
- ASTException - 当配置的不是一组 feature id 时抛出异常。
prop commas
public mut prop commas: Tokens
功能：获取或设置在 FeaturesSet 节点里的一组 ,。
类型：Tokens
异常：
- ASTException - 当配置的不是一组
,时抛出异常。
prop rCurl
public mut prop rCurl: Token
功能：获取或设置在 FeaturesSet 节点里的 } 。
类型：Token
异常：
- ASTException - 当配置的不是
}时抛出异常。
init()
public init()
功能：构造一个默认的 FeaturesSet 对象。
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 FeaturesSet 对象
let featuresSet = FeaturesSet()
// 设置 FeaturesSet 的属性
let featureId = FeatureId()
featureId.identifiers = quote(ftr)
featuresSet.content = ArrayList<FeatureId>([featureId])
featuresSet.lCurl = Token(TokenKind.LCURL, "{")
featuresSet.rCurl = Token(TokenKind.RCURL, "}")
// 转化为 Tokens 并输出
println("featuresSet.toTokens(): ${featuresSet.toTokens()}")
}
运行结果：
featuresSet.toTokens(): { ftr }
func toTokens()
public func toTokens(): Tokens
功能：转换一个语法树节点为 Tokens。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 FeaturesSet 对象
let featuresSet = FeaturesSet()
// 设置 FeaturesSet 的属性
let featureId = FeatureId()
featureId.identifiers = quote(a b c)
featureId.dots = quote(. .)
featuresSet.content = ArrayList<FeatureId>([featureId])
featuresSet.lCurl = Token(TokenKind.LCURL, "{")
featuresSet.rCurl = Token(TokenKind.RCURL, "}")
// 转化为 Tokens 并输出
println("featuresSet.toTokens(): ${featuresSet.toTokens()}")
}
运行结果：
featuresSet.toTokens(): { a.b.c }
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。要提前终止子节点遍历，请重写 visit 函数并调用 breakTraverse 函数来终止遍历行为。参见 自定义访问函数遍历 AST 对象。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FeaturesSet) {
println("Visiting FeaturesSet")
}
}
main(): Unit {
// 构造一个默认的 FeaturesSet 对象
let featuresSet = FeaturesSet()
// 设置 FeaturesSet 的属性
let featureId = FeatureId()
featureId.identifiers = quote(a b c)
featureId.dots = quote(. .)
featuresSet.content = ArrayList<FeatureId>([featureId])
featuresSet.lCurl = Token(TokenKind.LCURL, "{")
featuresSet.rCurl = Token(TokenKind.RCURL, "}")
// 使用自定义访问器遍历 FeaturesSet 节点
featuresSet.traverse(MyVisitor())
}
运行结果：
Visiting FeaturesSet
class ForInExpr
public class ForInExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 for-in 表达式。
ForInExpr 类型中，关键字 for 之后是 Pattern, 此后是一个 in 关键字和表达式节点，最后是一个执行循环体 Block。
父类型：
prop block
public mut prop block: Block
功能：获取或设置 ForInExpr 中的循环体。
类型：Block
prop expr
public mut prop expr: Expr
功能：获取或设置 ForInExpr 中的表达式。
类型：Expr
prop keywordF
public mut prop keywordF: Token
功能：获取或设置 ForInExpr 中的关键字 for。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
for关键字时，抛出异常。
prop keywordI
public mut prop keywordI: Token
功能：获取或设置 ForInExpr 中的关键字 in。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
in关键字时，抛出异常。
prop keywordW
public mut prop keywordW: Token
功能：获取或设置 ForInExpr 中的关键字 where。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
where关键字时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 ForInExpr 中关键字 for 后的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop pattern
public mut prop pattern: Pattern
功能：获取或设置 ForInExpr 中的 Pattern 节点。
类型：Pattern
prop patternGuard
public mut prop patternGuard: Expr
功能：获取或设置 ForInExpr 中的 patternGuard 条件表达式。
类型：Expr
异常：
- ASTException - 当 ForInExpr 节点中不存在
patternGuard表达式时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 ForInExpr 中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 ForInExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ForInExpr 对象
let forInExpr = ForInExpr()
// 设置 ForInExpr 的属性
forInExpr.keywordF = Token(TokenKind.FOR, "for")
forInExpr.pattern = VarPattern(Token(TokenKind.IDENTIFIER, "x"))
forInExpr.keywordI = Token(TokenKind.IN, "in")
forInExpr.expr = RefExpr(quote(arr))
// 创建块
let block = Block()
// 设置 Block 的属性
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
// 添加一个表达式节点
let expr = CallExpr(quote(foo()))
block.nodes.add(expr)
forInExpr.block = block
// 转化为 Tokens 并输出
println("forInExpr.toTokens(): ${forInExpr.toTokens()}")
}
运行结果：
forInExpr.toTokens(): for(x in arr) {
foo()
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ForInExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ForInExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ForInExpr 对象
let forInExpr = ForInExpr(quote(for (i in 1..10) { println(i) }))
// 转化为 Tokens 并输出
println("forInExpr.toTokens(): ${forInExpr.toTokens()}")
}
运行结果：
forInExpr.toTokens(): for(i in 1 .. 10) {
println(i)
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ForInExpr 对象
let forInExpr = ForInExpr()
// 设置 ForInExpr 的属性
forInExpr.keywordF = Token(TokenKind.FOR, "for")
forInExpr.pattern = VarPattern(Token(TokenKind.IDENTIFIER, "x"))
forInExpr.keywordI = Token(TokenKind.IN, "in")
forInExpr.expr = RefExpr(quote(arr))
// 创建块
let block = Block()
// 设置 Block 的属性
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
// 添加一个表达式节点
let expr = CallExpr(quote(foo()))
block.nodes.add(expr)
forInExpr.block = block
// 转化为 Tokens 并输出
println("forInExpr.toTokens(): ${forInExpr.toTokens()}")
}
运行结果：
forInExpr.toTokens(): for(x in arr) {
foo()
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ForInExpr) {
println("Visiting ForInExpr")
}
}
main(): Unit {
// 从 Tokens 创建 ForInExpr 对象
let forInExpr = ForInExpr(quote(for (i in 1..10) { println(i) }))
// 使用自定义访问器遍历 ForInExpr 节点
forInExpr.traverse(MyVisitor())
}
运行结果：
Visiting ForInExpr
class FuncDecl
public class FuncDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示一个函数定义节点。
由可选的函数修饰符，关键字 func ，函数名，可选的类型形参列表，函数参数，可缺省的函数返回类型来定义一个函数，函数定义时必须有函数体，函数体是一个块。
父类型：
prop block
public mut prop block: Block
功能：获取或设置 FuncDecl 节点的函数体。
类型：Block
prop colon
public mut prop colon: Token
功能：获取或设置 FuncDecl 节点的冒号。
类型：Token
异常：
- ASTException - 当设置的 Token 不是冒号时，抛出异常。
prop declType
public mut prop declType: TypeNode
功能：获取或设置 FuncDecl 节点的函数返回类型。
类型：TypeNode
异常：
- ASTException - 当 FuncDecl 节点的函数返回类型是一个缺省值时，抛出异常。
prop funcParams
public mut prop funcParams: ArrayList<FuncParam>
功能：获取或设置 FuncDecl 节点的函数参数。
prop lParen
public mut prop lParen: Token
功能：获取或设置 FuncDecl 节点的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop overloadOp
public mut prop overloadOp: Tokens
功能：获取或设置 FuncDecl 节点的重载操作符。
类型：Tokens
prop rParen
public mut prop rParen: Token
功能：获取或设置 FuncDecl 节点的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 FuncDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 FuncDecl 对象
let funcDecl = FuncDecl()
// 设置 FuncDecl 的属性
funcDecl.keyword = Token(TokenKind.FUNC, "func")
funcDecl.identifier = Token(TokenKind.IDENTIFIER, "foo")
funcDecl.lParen = Token(TokenKind.LPAREN, "(")
funcDecl.rParen = Token(TokenKind.RPAREN, ")")
// 创建函数体
let block = Block()
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
funcDecl.block = block
// 转化为 Tokens 并输出
println("funcDecl.toTokens(): ${funcDecl.toTokens()}")
}
运行结果：
funcDecl.toTokens(): func foo() {
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 FuncDecl 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 FuncDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 FuncDecl 对象
let funcDecl = FuncDecl(quote(func add(a: Int64, b: Int64): Int64 { return a + b }))
// 转化为 Tokens 并输出
println("funcDecl.toTokens(): ${funcDecl.toTokens()}")
}
运行结果：
funcDecl.toTokens(): func add(a: Int64, b: Int64): Int64 {
return a + b
}
func isConst()
public func isConst(): Bool
功能：判断是否是一个 Const 类型的节点。
返回值：
- Bool - 是一个
Const类型的节点返回 true；反之，返回 false。
示例：
import std.ast.*
main(): Unit {
let funcDecl1 = FuncDecl(quote(func foo() { println("Hello") }))
let funcDecl2 = FuncDecl(quote(const func bar() { println("World") }))
println("funcDecl1.isConst(): ${funcDecl1.isConst()}")
println("funcDecl2.isConst(): ${funcDecl2.isConst()}")
}
运行结果：
funcDecl1.isConst(): false
funcDecl2.isConst(): true
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 FuncDecl 对象
let funcDecl = FuncDecl()
// 设置 FuncDecl 的属性
funcDecl.keyword = Token(TokenKind.FUNC, "func")
funcDecl.identifier = Token(TokenKind.IDENTIFIER, "foo")
funcDecl.lParen = Token(TokenKind.LPAREN, "(")
funcDecl.rParen = Token(TokenKind.RPAREN, ")")
funcDecl.colon = Token(TokenKind.COLON, ":")
funcDecl.declType = PrimitiveType(quote(Int64))
// 创建函数参数
let param = FuncParam(quote(x: Int64))
funcDecl.funcParams = ArrayList<FuncParam>([param])
// 创建函数体
let block = Block()
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
let expr = BinaryExpr(quote(x + 1))
block.nodes.add(expr)
funcDecl.block = block
// 转化为 Tokens 并输出
println("funcDecl.toTokens(): ${funcDecl.toTokens()}")
}
运行结果：
funcDecl.toTokens(): func foo(x: Int64): Int64 {
x + 1
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FuncDecl) {
println("Visiting FuncDecl")
}
}
main(): Unit {
// 从 Tokens 创建 FuncDecl 对象
let funcDecl = FuncDecl(quote(func foo() { println("Hello") }))
// 使用自定义访问器遍历 FuncDecl 节点
funcDecl.traverse(MyVisitor())
}
运行结果：
Visiting FuncDecl
class FuncParam
public open class FuncParam <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示函数参数节点，包括非命名参数和命名参数。
一个 FuncParam 节点： func foo(a: Int64, b: Float64) {...} 中的 a: Int64 和 b: Float64。
父类型：
prop assign
public mut prop assign: Token
功能：获取或设置具有默认值的函数参数中的 =。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
=时，抛出异常。
prop colon
public mut prop colon: Token
功能：获取或设置置形参中的 ":"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ":" 时，抛出异常。
prop expr
public mut prop expr: Expr
功能：获取或设置具有默认值的函数参数的变量初始化节点。
类型：Expr
异常：
- ASTException - 当函数参数没有进行初始化时，抛出异常。
prop not
public mut prop not: Token
功能：获取或设置命名形参中的 !。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
!时，抛出异常。
prop paramType
public mut prop paramType: TypeNode
功能：获取或设置函数参数的类型。
类型：TypeNode
init()
public init()
功能：构造一个默认的 FuncParam 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 FuncParam 对象
let funcParam = FuncParam()
// 设置 FuncParam 的属性
funcParam.identifier = Token(TokenKind.IDENTIFIER, "b")
funcParam.colon = Token(TokenKind.COLON, ":")
funcParam.paramType = PrimitiveType(quote(Float32))
funcParam.assign = Token(TokenKind.ASSIGN, "=")
funcParam.expr = RefExpr(quote(defaultValue))
// 转化为 Tokens 并输出
println("funcParam.toTokens(): ${funcParam.toTokens()}")
}
运行结果：
funcParam.toTokens(): b: Float32 = defaultValue
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 FuncParam 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 FuncParam 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 FuncParam 对象
let funcParam = FuncParam(quote(a: Int64))
println("funcParam.toTokens(): ${funcParam.toTokens()}")
}
运行结果：
funcParam.toTokens(): a: Int64
func dump(UInt16)
protected open func dump(indent: UInt16): String
功能：将当前语法树节点转化为树形结构的形态并进行打印。
参数：
- indent: UInt16 - 格式化输出的缩进空格数量。
返回值：
- String - 格式化输出内容。
示例：
import std.ast.*
// 在子类中调用
class MyParam <: FuncParam {
public init(input: Tokens) { super(input) }
public func myDump(): String {
dump(1)
}
}
main(): Unit {
// 创建 FuncParam 的子类
let param = MyParam(quote(a: Int64))
println("param.myDump(): ${param.myDump()}")
}
运行结果：
param.myDump(): FuncParam {
-identifier: Token {
value: "a"
kind: IDENTIFIER
pos: 13: 31
}
-colon: Token {
value: ":"
kind: COLON
pos: 13: 32
}
-paramType: PrimitiveType {
-keyword: Token {
value: "Int64"
kind: INT64
pos: 13: 34
}
}
}
func isMemberParam()
public func isMemberParam(): Bool
功能：当前的函数参数是否是主构造函数中的参数。
返回值：
- Bool - 布尔类型，如果是主构造函数中的参数，返回
true。
示例：
import std.ast.*
main(): Unit {
// 使用 Tokens 构造主构造函数节点
let decl = PrimaryCtorDecl(quote(MyParam(a: Int64, let v: Int64) {}))
println("decl.funcParams[0].isMemberParam(): ${decl.funcParams[0].isMemberParam()}")
println("decl.funcParams[1].isMemberParam(): ${decl.funcParams[1].isMemberParam()}")
}
运行结果：
decl.funcParams[0].isMemberParam(): false
decl.funcParams[1].isMemberParam(): true
func toTokens()
public open func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 FuncParam 对象
let funcParam = FuncParam()
// 设置 FuncParam 的属性
funcParam.identifier = Token(TokenKind.IDENTIFIER, "b")
funcParam.colon = Token(TokenKind.COLON, ":")
funcParam.paramType = PrimitiveType(quote(Float32))
funcParam.assign = Token(TokenKind.ASSIGN, "=")
funcParam.expr = RefExpr(quote(defaultValue))
// 转化为 Tokens 并输出
println("funcParam.toTokens(): ${funcParam.toTokens()}")
}
运行结果：
funcParam.toTokens(): b: Float32 = defaultValue
func traverse(Visitor)
public open func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FuncParam) {
println("Visiting FuncParam")
}
}
main(): Unit {
// 从 Tokens 创建 FuncParam 对象
let funcParam = FuncParam(quote(b!: Float64))
// 使用自定义访问器遍历 FuncParam 节点
funcParam.traverse(MyVisitor())
}
运行结果：
Visiting FuncParam
class FuncType
public class FuncType <: TypeNode {
public init(inputs: Tokens)
public init()
}
功能：表示函数类型节点。
由函数的参数类型和返回类型组成，参数类型与返回类型之间用 -> 分隔，如：(Int32) -> Unit。
父类型：
prop arrow
public mut prop arrow: Token
功能：获取或设置 FuncType 节点参数类型与返回类型之间的 ->的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
->的词法单元时，抛出异常。
prop commas
public mut prop commas: Tokens
功能：获取或设置 FuncType 节点中的 "," 词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop keyword
public mut prop keyword: Token
功能：获取或设置 FuncType 节点的中的关键字 CFunc 的词法单元，若不是一个 CFunc 类型，则获取一个 ILLEGAL 的词法单元。
类型：Token
prop lParen
public mut prop lParen: Token
功能：获取或设置 FuncType 节点的 "(" 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 FuncType 节点的 ")" 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop returnType
public mut prop returnType: TypeNode
功能：获取或设置 FuncType 返回类型节点。
类型：TypeNode
prop types
public mut prop types: ArrayList<TypeNode>
功能：获取或设置 FuncType 节点中函数的参数类型列表。
init()
public init()
功能：构造一个默认的 FuncType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 FuncType 对象
let funcType = FuncType()
// 设置 FuncType 的属性
funcType.lParen = Token(TokenKind.LPAREN, "(")
funcType.rParen = Token(TokenKind.RPAREN, ")")
funcType.arrow = Token(TokenKind.ARROW, "->")
// 设置参数类型
let paramTypes = ArrayList<TypeNode>()
funcType.types = paramTypes
// 设置返回类型
funcType.returnType = RefType(quote(String))
// 转化为 Tokens 并输出
println("funcType.toTokens(): ${funcType.toTokens()}")
}
运行结果：
funcType.toTokens(): () -> String
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 FuncType 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 FuncType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 FuncType 对象
let funcType = FuncType(quote((Int32, Float64) -> String))
// 转化为 Tokens 并输出
println("funcType.toTokens(): ${funcType.toTokens()}")
}
运行结果：
funcType.toTokens(): (Int32, Float64) -> String
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 FuncType 对象
let funcType = FuncType()
// 设置 FuncType 的属性
funcType.lParen = Token(TokenKind.LPAREN, "(")
funcType.rParen = Token(TokenKind.RPAREN, ")")
funcType.arrow = Token(TokenKind.ARROW, "->")
// 设置参数类型
let paramTypes = ArrayList<TypeNode>()
paramTypes.add(PrimitiveType(quote(Int64)))
paramTypes.add(PrimitiveType(quote(Bool)))
funcType.types = paramTypes
// 设置返回类型
funcType.returnType = RefType(quote(String))
// 转化为 Tokens 并输出
println("funcType.toTokens(): ${funcType.toTokens()}")
}
运行结果：
funcType.toTokens(): (Int64, Bool) -> String
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FuncType) {
println("Visiting FuncType")
}
}
main(): Unit {
// 从 Tokens 创建 FuncType 对象
let funcType = FuncType(quote((Int32) -> Unit))
// 使用自定义访问器遍历 FuncType 节点
funcType.traverse(MyVisitor())
}
运行结果：
Visiting FuncType
class GenericConstraint
public class GenericConstraint <: Node {
public init()
}
功能：表示一个泛型约束节点。
一个 GenericConstraint 节点：interface Enumerable<U> where U <: Bounded {} 中的 where U <: Bounded。
说明：
通过
where之后的<:运算符来声明，由一个下界与一个上界来组成。其中<:左边称为约束的下界，下界只能为类型变元。<:右边称为约束上界，约束上界可以为类型。
父类型：
prop bitAnds
public mut prop bitAnds: Tokens
功能：获取或设置 GenericConstraint 节点中的 & 操作符的词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是
&词法单元序列时，抛出异常。
prop keyword
public mut prop keyword: Token
功能：获取或设置 GenericConstraint 节点中关键字 where 词法单元，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
where关键字时，抛出异常。
prop typeArgument
public mut prop typeArgument: TypeNode
功能：获取或设置 GenericConstraint 节点中的约束下界。
类型：TypeNode
prop upperBound
public mut prop upperBound: Token
功能：获取或设置 GenericConstraint 节点中的 <: 运算符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
<:运算符时，抛出异常。
prop upperBounds
public mut prop upperBounds: ArrayList<TypeNode>
功能：获取或设置 GenericConstraint 节点约束上界的 TypeNode 类型节点的集合。
init()
public init()
功能：构造一个默认的 GenericConstraint 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 GenericConstraint 对象
let genericConstraint = GenericConstraint()
// 设置 GenericConstraint 的属性
genericConstraint.keyword = Token(TokenKind.WHERE, "where")
genericConstraint.typeArgument = RefType(quote(U))
genericConstraint.upperBound = Token(TokenKind.UPPERBOUND, "<:")
let upperBounds = ArrayList<TypeNode>()
upperBounds.add(RefType(quote(Bound)))
genericConstraint.upperBounds = upperBounds
// 转化为 Tokens 并输出
println("genericConstraint.toTokens(): ${genericConstraint.toTokens()}")
}
运行结果：
genericConstraint.toTokens(): where U <: Bound
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 构造一个默认的 GenericConstraint 对象
let genericConstraint = GenericConstraint()
// 设置 GenericConstraint 的属性
genericConstraint.keyword = Token(TokenKind.WHERE, "where")
genericConstraint.typeArgument = RefType(quote(U))
genericConstraint.upperBound = Token(TokenKind.UPPERBOUND, "<:")
let upperBounds = ArrayList<TypeNode>()
upperBounds.add(RefType(quote(Bound)))
genericConstraint.upperBounds = upperBounds
// 转化为 Tokens 并输出
println("genericConstraint.toTokens(): ${genericConstraint.toTokens()}")
}
运行结果：
genericConstraint.toTokens(): where U <: Bound
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: GenericConstraint) {
println("Visiting GenericConstraint")
}
}
main(): Unit {
// 构造一个默认的 GenericConstraint 对象
let genericConstraint = GenericConstraint()
// 设置 GenericConstraint 的属性
genericConstraint.keyword = Token(TokenKind.WHERE, "where")
genericConstraint.typeArgument = RefType(quote(U))
genericConstraint.upperBound = Token(TokenKind.UPPERBOUND, "<:")
let upperBounds = ArrayList<TypeNode>()
upperBounds.add(RefType(quote(Bound)))
genericConstraint.upperBounds = upperBounds
// 使用自定义访问器遍历 GenericConstraint 节点
genericConstraint.traverse(MyVisitor())
}
运行结果：
Visiting GenericConstraint
class GenericParam
public class GenericParam <: Node {
public init(parameters: Tokens)
public init()
}
功能：表示一个类型形参节点。
一个 GenericParam 节点：<T1, T2, T3>。
说明：
类型形参用
<>括起并用 "," 分隔多个类型形参名称。
父类型：
prop lAngle
public mut prop lAngle: Token
功能：获取或设置 GenericParam 节点中的左尖括号词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是左尖括号时，抛出异常。
prop parameters
public mut prop parameters: Tokens
功能：获取或设置 GenericParam 节点中的类型形参的 Tokens 类型，可能为空，如 <T1, T2, T3> 中的 T1 T2 和 T3。
类型：Tokens
prop rAngle
public mut prop rAngle: Token
功能：获取或设置 GenericParam 节点中的右尖括号词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是右尖括号时，抛出异常。
init()
public init()
功能：构造一个默认的 GenericParam 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 GenericParam 对象
let genericParam = GenericParam()
// 设置 GenericParam 的属性
genericParam.lAngle = Token(TokenKind.LT, "<")
genericParam.rAngle = Token(TokenKind.GT, ">")
genericParam.parameters = quote(A B)
// 转化为 Tokens 并输出
println("genericParam.toTokens(): ${genericParam.toTokens()}")
}
运行结果：
genericParam.toTokens(): < A, B >
init(Tokens)
public init(parameters: Tokens)
功能：构造一个 GenericParam 对象。
参数：
- parameters: Tokens - 将要构造 GenericParam 的类型形参的词法单元集合 (Tokens)。
示例：
import std.ast.*
main(): Unit {
// 使用 Tokens 构造 GenericParam
let genericParam = GenericParam(quote(T U V))
// 转化为 Tokens 并输出
println("genericParam.toTokens(): ${genericParam.toTokens()}")
}
运行结果：
genericParam.toTokens(): < T, U, V >
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 GenericParam 对象
let genericParam = GenericParam()
// 设置 GenericParam 的属性
genericParam.lAngle = Token(TokenKind.LT, "<")
genericParam.rAngle = Token(TokenKind.GT, ">")
genericParam.parameters = quote(A B)
// 转化为 Tokens 并输出
println("genericParam.toTokens(): ${genericParam.toTokens()}")
}
运行结果：
genericParam.toTokens(): < A, B >
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: GenericParam) {
println("Visiting GenericParam")
}
}
main(): Unit {
// 使用 Tokens 构造 GenericParam
let genericParam = GenericParam(quote(T, U))
// 使用自定义访问器遍历 GenericParam 节点
genericParam.traverse(MyVisitor())
}
运行结果：
Visiting GenericParam
class Handler
public class Handler {
}
功能：表示一个 handle 子句，其中包含一个命令模式和要执行的代码块。
一个 Handler 节点的示例：
handle (e: Command<Unit>) { ... }
class IfExpr
public class IfExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示条件表达式。
可以根据判定条件是否成立来决定执行哪条代码分支。一个 IfExpr 节点中 if 是关键字，if 之后是一个小括号，小括号内可以是一个表达式或者一个 let 声明的解构匹配，接着是一个 Block，Block 之后是可选的 else 分支。 else 分支以 else 关键字开始，后接新的 if 表达式或一个 Block。
父类型：
prop condition
public mut prop condition: Expr
功能：获取或设置 IfExpr 节点中的 if 后的条件表达式。
类型：Expr
prop elseExpr
public mut prop elseExpr: Expr
功能：获取或设置 IfExpr 节点中 else 分支节点。
类型：Expr
异常：
- ASTException - 当前 IfExpr 节点没有 else 分支节点。
prop ifBlock
public mut prop ifBlock: Block
功能：获取或设置 IfExpr 节点中的 if 后的 block 节点。
类型：Block
prop keywordE
public mut prop keywordE: Token
功能：获取或设置 IfExpr 节点中 else 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
else关键字时，抛出异常。
prop keywordI
public mut prop keywordI: Token
功能：获取或设置 IfExpr 节点中的 if 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
if关键字时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 IfExpr 节点中的 if 后的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 IfExpr 节点中的 if 后的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 IfExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 IfExpr 对象
let ifExpr = IfExpr()
// 设置 IfExpr 的属性
ifExpr.keywordI = Token(TokenKind.IF, "if")
ifExpr.lParen = Token(TokenKind.LPAREN, "(")
ifExpr.rParen = Token(TokenKind.RPAREN, ")")
ifExpr.condition = RefExpr(quote(cond))
// 创建 if 块
let ifBlock = Block()
ifBlock.lBrace = Token(TokenKind.LCURL, "{")
ifBlock.rBrace = Token(TokenKind.RCURL, "}")
let expr1 = LitConstExpr(quote(1))
ifBlock.nodes.add(expr1)
ifExpr.ifBlock = ifBlock
// 转化为 Tokens 并输出
println("ifExpr.toTokens(): ${ifExpr.toTokens()}")
}
运行结果：
ifExpr.toTokens(): if(cond) {
1
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 IfExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 IfExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 使用 Tokens 构造 IfExpr
let ifExpr = IfExpr(quote(if (x > 0) { println("Positive") } else { println("Negative") }))
// 转化为 Tokens 并输出
println("ifExpr.toTokens(): ${ifExpr.toTokens()}")
}
运行结果：
ifExpr.toTokens(): if(x > 0) {
println("Positive")
}
else {
println("Negative")
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 IfExpr 对象
let ifExpr = IfExpr()
// 设置 IfExpr 的属性
ifExpr.keywordI = Token(TokenKind.IF, "if")
ifExpr.lParen = Token(TokenKind.LPAREN, "(")
ifExpr.rParen = Token(TokenKind.RPAREN, ")")
ifExpr.condition = RefExpr(quote(condition))
// 创建 if 块
let ifBlock = Block()
ifBlock.lBrace = Token(TokenKind.LCURL, "{")
ifBlock.rBrace = Token(TokenKind.RCURL, "}")
let expr1 = CallExpr(quote(println("Condition is true")))
ifBlock.nodes.add(expr1)
ifExpr.ifBlock = ifBlock
// 转化为 Tokens 并输出
println("ifExpr.toTokens(): ${ifExpr.toTokens()}")
}
运行结果：
ifExpr.toTokens(): if(condition) {
println("Condition is true")
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: IfExpr) {
println("Visiting IfExpr")
}
}
main(): Unit {
// 使用 Tokens 构造 IfExpr
let ifExpr = IfExpr(quote(if (a < b) { println(a) } else { println(b) }))
// 使用自定义访问器遍历 IfExpr 节点
ifExpr.traverse(MyVisitor())
}
运行结果：
Visiting IfExpr
class ImportContent
public class ImportContent <: Node {
public init()
}
功能：表示一个包导入声明节点的具体声明内容，如 import pkg.a.b 中的 pkg.a.b。
父类型：
prop commas
public mut prop commas: Tokens
功能：获取或设置 ImportContent 节点中的 "," 词法单元序列，只有 importKind 为 ImportKind.Multi 时非空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop identifier
public mut prop identifier: Token
功能：获取或设置 ImportContent 节点中被导入的项，它可能是包中的顶层定义或声明，也可能是子包的名字。
类型：Token
prop importAlias
public mut prop importAlias: Tokens
功能：获取或设置 ImportContent 节点中导入的定义或声明的别名词法单元序列，只有 importKind 为 ImportKind.Alias 时非空。如：import packageName.xxx as yyy 中的 as yyy。
类型：Tokens
prop importKind
public mut prop importKind: ImportKind
功能：获取或设置 ImportContent 节点中导入类型。
类型：ImportKind
prop items
public mut prop items: ArrayList<ImportContent>
功能：获取或设置 ImportContent 节点中被导入的所有项，只有 importKind 为 ImportKind.Multi 时非空。
prop lBrace
public mut prop lBrace: Token
功能：获取或设置 ImportContent 节点中的 { 操作符词法单元，只有 importKind 为 ImportKind.Multi 时非空。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
{操作符时，抛出异常。
prop orgName
public mut prop orgName: Token
功能：获取或设置 ImportContent 节点中代表组织名的词法单元，setter会检查orgSeparator是否为 "::" 词法单元，若为空则同时设置其为 "::" 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 内容为空字符串时抛出异常。
prop orgSeparator
public mut prop orgSeparator: Token
功能：获取或设置 ImportContent 节点中的 "::" 词法单元，setter会检查orgName内容是否为空字符串，若有则抛异常。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "::" 时，或orgName内容为空字符串时抛出异常。
prop prefixPaths
public mut prop prefixPaths: Tokens
功能：获取或设置 ImportContent 节点中完整包名的前缀部分的词法单元序列，可能为空。如 import a.b.c 中的 a 和 b。
类型：Tokens
prop prefixDots
public mut prop prefixDots: Tokens
功能：获取或设置 ImportContent 节点中完整包名中用于分隔每层子包的词法单元序列，可能为空。如 import a.b.c 中的两个 "."。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "." 词法单元序列时，抛出异常。
prop rBrace
public mut prop rBrace: Token
功能：获取或设置 ImportContent 节点中的 } 操作符词法单元，只有 importKind 为 ImportKind.Multi 时非空。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
}操作符时，抛出异常。
init()
public init()
功能：构造一个默认的 ImportContent 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ImportContent 对象
let importContent = ImportContent()
// 设置 ImportContent 的属性
importContent.importKind = ImportKind.Single
importContent.prefixPaths = quote(std collection)
importContent.prefixDots = quote(. .)
importContent.identifier = Token(TokenKind.IDENTIFIER, "ArrayList")
// 转化为 Tokens 并输出
println("importContent.toTokens(): ${importContent.toTokens()}")
}
运行结果：
importContent.toTokens(): std.collection.ArrayList
func isImportAlias()
public func isImportAlias(): Bool
功能：判断 ImportContent 节点是否对导入项取了别名。
返回值：
- Bool - ImportContent 节点是否对导入项取了别名。
示例：
import std.ast.*
main(): Unit {
// 创建一个别名导入的 ImportContent
let importContent = ImportContent()
importContent.importKind = ImportKind.Alias
importContent.importAlias = quote(as myAlias)
println("importContent.isImportAlias(): ${importContent.isImportAlias()}")
}
运行结果：
importContent.isImportAlias(): true
func isImportAll()
public func isImportAll(): Bool
功能：判断 ImportContent 节点是否为全导入。
返回值：
- Bool - ImportContent 节点是否为全导入。
示例：
import std.ast.*
main(): Unit {
// 创建一个全导入的 ImportContent
let importContent = ImportContent()
importContent.importKind = ImportKind.All
println("importContent.isImportAll(): ${importContent.isImportAll()}")
}
运行结果：
importContent.isImportAll(): true
func isImportMulti()
public func isImportMulti(): Bool
功能：判断 ImportContent 节点是否导入了多个顶级定义或声明。
返回值：
- Bool - ImportContent 节点是否导入了多个顶级定义或声明。
示例：
import std.ast.*
main(): Unit {
// 创建一个多导入的 ImportContent
let importContent = ImportContent()
importContent.importKind = ImportKind.Multi
println("importContent.isImportMulti(): ${importContent.isImportMulti()}")
}
运行结果：
importContent.isImportMulti(): true
func isImportSingle()
public func isImportSingle(): Bool
功能：判断 ImportContent 节点是否为单导入。
返回值：
- Bool - ImportContent 节点是否为单导入。
示例：
import std.ast.*
main(): Unit {
// 创建一个单导入的 ImportContent
let importContent = ImportContent()
importContent.importKind = ImportKind.Single
println("importContent.isImportSingle(): ${importContent.isImportSingle()}")
}
运行结果：
importContent.isImportSingle(): true
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ImportContent 对象
let importContent = ImportContent()
// 设置 ImportContent 的属性
importContent.importKind = ImportKind.Single
importContent.orgName = Token(TokenKind.IDENTIFIER, "ORG")
importContent.orgSeparator = Token(TokenKind.DOUBLE_COLON, "::")
importContent.prefixPaths = quote(std collection)
importContent.prefixDots = quote(.)
importContent.identifier = Token(TokenKind.IDENTIFIER, "ArrayList")
// 转化为 Tokens 并输出
println("importContent.toTokens(): ${importContent.toTokens()}")
}
运行结果：
importContent.toTokens(): ORG :: std.collection.ArrayList
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ImportContent) {
println("Visiting ImportContent")
}
}
main(): Unit {
// 构造一个默认的 ImportContent 对象
let importContent = ImportContent()
// 设置 ImportContent 的属性
importContent.importKind = ImportKind.Single
importContent.orgName = Token(TokenKind.IDENTIFIER, "ORG")
importContent.orgSeparator = Token(TokenKind.DOUBLE_COLON, "::")
importContent.prefixPaths = quote(std collection)
importContent.prefixDots = quote(.)
importContent.identifier = Token(TokenKind.IDENTIFIER, "ArrayList")
// 使用自定义访问器遍历 ImportContent 节点
importContent.traverse(MyVisitor())
}
运行结果：
Visiting ImportContent
class ImportList
public class ImportList <: Node {
public init(inputs: Tokens)
public init()
}
功能：表示包导入节点。
一个 ImportList 节点: import moduleName.packageName.foo as bar。
说明：
导入节点以可选的访问性修饰符（
public/protected/internal/private）加关键字import开头。以import pkga.pkgb.item为例，pkga.pkgb为导入的顶级定义或声明所在的包的名字，item为导入的顶级定义或声明。
父类型：
prop content
public mut prop content: ImportContent
功能：获取或设置 ImportList 节点中的被导入的具体项。如 import a.b.c 中的 a.b.c 部分。
prop keywordI
public mut prop keywordI: Token
功能：获取或设置 ImportList 节点中的 import 关键字的词法单元，I 为关键字首字母。
类型：Token
prop modifier
public mut prop modifier: Token
功能：获取或设置 ImportList 节点中的修饰符，可能为 ILLEGAL 的词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 ImportList 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ImportList 对象
let importList = ImportList()
// 设置 ImportList 的属性
importList.keywordI = Token(TokenKind.IMPORT, "import")
// 创建并设置 ImportContent
let importContent = ImportContent()
importContent.importKind = ImportKind.Single
importContent.prefixPaths = quote(std collection)
importContent.prefixDots = quote(.)
importContent.identifier = Token(TokenKind.IDENTIFIER, "ArrayList")
importList.content = importContent
// 转化为 Tokens 并输出
println("importList.toTokens(): ${importList.toTokens()}")
}
运行结果：
importList.toTokens(): import std.collection.ArrayList
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ImportList 对象。
参数：
- inputs: Tokens - 将要构造 ImportList 类型的词法单元集合 (Tokens) 序列。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ImportList 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 使用 Tokens 构造 ImportList
let importList = ImportList(quote(import std.collection.*))
// 转化为 Tokens 并输出
println("importList.toTokens(): ${importList.toTokens()}")
}
运行结果：
importList.toTokens(): import std.collection.*
func isImportMulti()
public func isImportMulti(): Bool
功能：判断 ImportList 节点是否导入了多个顶级定义或声明。
返回值：
- Bool - 如果 ImportList 节点导入了多个顶级定义或声明，返回 true；反之，返回 false。
示例：
import std.ast.*
main(): Unit {
let singleImport = ImportList(quote(import std.ast.RefType))
let multiImport = ImportList(quote(import std.ast.{RefType, CallExpr}))
println("singleImport.isImportMulti(): ${singleImport.isImportMulti()}")
println("multiImport.isImportMulti(): ${multiImport.isImportMulti()}")
}
运行结果：
singleImport.isImportMulti(): false
multiImport.isImportMulti(): true
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ImportList 对象
let importList = ImportList()
// 设置 ImportList 的属性
importList.keywordI = Token(TokenKind.IMPORT, "import")
// 创建并设置 ImportContent
let importContent = ImportContent()
importContent.importKind = ImportKind.Single
importContent.prefixPaths = quote(std collection)
importContent.prefixDots = quote(.)
importContent.identifier = Token(TokenKind.IDENTIFIER, "ArrayList")
importList.content = importContent
// 转化为 Tokens 并输出
println("importList.toTokens(): ${importList.toTokens()}")
}
运行结果：
importList.toTokens(): import std.collection.ArrayList
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ImportList) {
println("Visiting ImportList")
}
}
main(): Unit {
// 用 Tokens 创建 ImportList
let importList = ImportList(quote(import std.ast.RefType as RT))
// 使用自定义访问器遍历 ImportList 节点
importList.traverse(MyVisitor())
}
运行结果：
Visiting ImportList
class IncOrDecExpr
public class IncOrDecExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示包含自增操作符（++）或自减操作符（--）的表达式。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 IncOrDecExpr 中的表达式。
类型：Expr
prop op
public mut prop op: Token
功能：获取或设置 IncOrDecExpr 中的操作符。
类型：Token
init()
public init()
功能：构造一个默认的 IncOrDecExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 IncOrDecExpr 对象
let incOrDecExpr = IncOrDecExpr()
// 设置 IncOrDecExpr 的属性
incOrDecExpr.expr = RefExpr(quote(counter))
incOrDecExpr.op = Token(TokenKind.DECR, "--")
// 转化为 Tokens 并输出
println("incOrDecExpr.toTokens(): ${incOrDecExpr.toTokens()}")
}
运行结果：
incOrDecExpr.toTokens(): counter --
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 IncOrDecExpr 对象。
参数：
- inputs: Tokens - 将要构造 IncOrDecExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 IncOrDecExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 使用 Tokens 构造 IncOrDecExpr
let incExpr = IncOrDecExpr(quote(x++))
// 转化为 Tokens 并输出
println("incExpr.toTokens(): ${incExpr.toTokens()}")
}
运行结果：
incExpr.toTokens(): x ++
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 IncOrDecExpr 对象
let incOrDecExpr = IncOrDecExpr()
// 设置 IncOrDecExpr 的属性
incOrDecExpr.expr = RefExpr(quote(counter))
incOrDecExpr.op = Token(TokenKind.INCR, "++")
// 转化为 Tokens 并输出
println("incOrDecExpr.toTokens(): ${incOrDecExpr.toTokens()}")
}
运行结果：
incOrDecExpr.toTokens(): counter ++
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: IncOrDecExpr) {
println("Visiting IncOrDecExpr")
}
}
main(): Unit {
// 使用 Tokens 构造 IncOrDecExpr
let incOrDecExpr = IncOrDecExpr(quote(x--))
// 使用自定义访问器遍历 IncOrDecExpr 节点
incOrDecExpr.traverse(MyVisitor())
}
运行结果：
Visiting IncOrDecExpr
class InterfaceDecl
public class InterfaceDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示接口定义节点。
接口的定义使用 interface 关键字，接口定义依次为：可缺省的修饰符、interface 关键字、接口名、可选的类型参数、是否指定父接口、可选的泛型约束、接口体的定义。
父类型：
prop body
public mut prop body: Body
功能：获取或设置 InterfaceDecl 节点的类体。
类型：Body
prop superTypeBitAnds
public mut prop superTypeBitAnds: Tokens
功能：获取或设置 InterfaceDecl 节点的父接口声明中的 & 操作符的词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是
&词法单元序列时，抛出异常。
prop superTypes
public mut prop superTypes: ArrayList<TypeNode>
功能：获取或设置 InterfaceDecl 节点的父接口。
prop upperBound
public mut prop upperBound: Token
功能：获取或设置 <: 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
<:操作符时，抛出异常。
init()
public init()
功能：构造一个默认的 InterfaceDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 InterfaceDecl 对象
let interfaceDecl = InterfaceDecl()
// 设置 InterfaceDecl 的属性
interfaceDecl.identifier = Token(TokenKind.IDENTIFIER, "Shape")
interfaceDecl.keyword = Token(TokenKind.INTERFACE, "interface")
// 创建并设置 body
let body = Body()
let funcDecl = FuncDecl(quote(func area(): Float64))
body.decls.add(funcDecl)
interfaceDecl.body = body
// 转化为 Tokens 并输出
println("interfaceDecl.toTokens(): ${interfaceDecl.toTokens()}")
}
运行结果：
interfaceDecl.toTokens(): interface Shape {
func area(): Float64
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 InterfaceDecl 对象。
参数：
- inputs: Tokens - 将要构造 InterfaceDecl 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 InterfaceDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 使用 Tokens 构造 InterfaceDecl
let interfaceDecl = InterfaceDecl(quote(interface MyInterface { func foo(): Int64 }))
// 转化为 Tokens 并输出
println("interfaceDecl.toTokens(): ${interfaceDecl.toTokens()}")
}
运行结果：
interfaceDecl.toTokens(): interface MyInterface {
func foo(): Int64
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 InterfaceDecl 对象
let interfaceDecl = InterfaceDecl()
// 设置 InterfaceDecl 的属性
interfaceDecl.identifier = Token(TokenKind.IDENTIFIER, "Shape")
interfaceDecl.keyword = Token(TokenKind.INTERFACE, "interface")
// 创建并设置 body
let body = Body()
let funcDecl = FuncDecl(quote(func area(): Float64))
body.decls.add(funcDecl)
interfaceDecl.body = body
// 转化为 Tokens 并输出
println("interfaceDecl.toTokens(): ${interfaceDecl.toTokens()}")
}
运行结果：
interfaceDecl.toTokens(): interface Shape {
func area(): Float64
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: InterfaceDecl) {
println("Visiting InterfaceDecl")
}
}
main(): Unit {
// 使用 Tokens 构造 InterfaceDecl
let interfaceDecl = InterfaceDecl(quote(interface MyInterface { func foo(): Int64 }))
// 使用自定义访问器遍历 InterfaceDecl 节点
interfaceDecl.traverse(MyVisitor())
}
运行结果：
Visiting InterfaceDecl
class IsExpr
public class IsExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示一个类型检查表达式。
一个 IsExpr 表达式：e is T，类型为 Bool。其中 e 可以是任何类型的表达式，T 可以是任何类型。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 IsExpr 节点中的表达式节点。
类型：Expr
prop keyword
public mut prop keyword: Token
功能：获取或设置 IsExpr 节点中的 is 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
is操作符时，抛出异常。
prop shiftType
public mut prop shiftType: TypeNode
功能：获取或设置 IsExpr 节点中的目标类型。
类型：TypeNode
init()
public init()
功能：构造一个默认的 IsExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 IsExpr 对象
let isExpr = IsExpr()
// 设置 IsExpr 的属性
isExpr.expr = RefExpr(quote(x))
isExpr.keyword = Token(TokenKind.IS)
isExpr.shiftType = PrimitiveType(quote(Int8))
// 转化为 Tokens 并输出
println("isExpr.toTokens(): ${isExpr.toTokens()}")
}
运行结果：
isExpr.toTokens(): x is Int8
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 IsExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 IsExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 IsExpr 对象
let isExpr = IsExpr(quote(x is String))
// 转化为 Tokens 并输出
println("isExpr.toTokens(): ${isExpr.toTokens()}")
}
运行结果：
isExpr.toTokens(): x is String
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 IsExpr 对象
let isExpr = IsExpr(quote(x is String))
// 转化为 Tokens 并输出
println("isExpr.toTokens(): ${isExpr.toTokens()}")
}
运行结果：
isExpr.toTokens(): x is String
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: IsExpr) {
println("Visiting IsExpr")
}
}
main(): Unit {
// 从 Tokens 创建 IsExpr 对象
let isExpr = IsExpr(quote(x is String))
// 使用自定义访问器遍历 IsExpr 节点
isExpr.traverse(MyVisitor())
}
运行结果：
Visiting IsExpr
class JumpExpr
public class JumpExpr <: Expr {
public init(kind: Tokens)
public init()
}
功能：表示循环表达式的循环体中的 break 和 continue。
父类型：
prop keyword
public mut prop keyword: Token
功能：获取或设置关键字。
类型：Token
init()
public init()
功能：构造一个默认的 JumpExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 JumpExpr 对象
let jumpExpr = JumpExpr()
// 设置 JumpExpr 的属性
jumpExpr.keyword = Token(TokenKind.BREAK)
// 转化为 Tokens 并输出
println("jumpExpr.toTokens(): ${jumpExpr.toTokens()}")
}
运行结果：
jumpExpr.toTokens(): break
init(Tokens)
public init(kind: Tokens)
功能：构造一个 JumpExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 JumpExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 JumpExpr 对象
let jumpExpr = JumpExpr(quote(break))
// 转化为 Tokens 并输出
println("jumpExpr.toTokens(): ${jumpExpr.toTokens()}")
}
运行结果：
jumpExpr.toTokens(): break
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 JumpExpr 对象
let jumpExpr = JumpExpr(quote(break))
// 转化为 Tokens 并输出
println("jumpExpr.toTokens(): ${jumpExpr.toTokens()}")
}
运行结果：
jumpExpr.toTokens(): break
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: JumpExpr) {
println("Visiting JumpExpr")
}
}
main(): Unit {
// 从 Tokens 创建 JumpExpr 对象
let jumpExpr = JumpExpr(quote(break))
// 使用自定义访问器遍历 JumpExpr 节点
jumpExpr.traverse(MyVisitor())
}
运行结果：
Visiting JumpExpr
class LambdaExpr
public class LambdaExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 Lambda 表达式，是一个匿名的函数。
一个 LambdaExpr 节点有两种形式，一种是有形参的，例如 {a: Int64 => e1; e2 }，另一种是无形参的，例如 { => e1; e2 }。
父类型：
prop doubleArrow
public mut prop doubleArrow: Token
功能：获取或设置 LambdaExpr 中的 =>。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
=>操作符时，抛出异常。
prop funcParams
public mut prop funcParams: ArrayList<FuncParam>
功能：获取或设置 LambdaExpr 中的参数列表。
prop lBrace
public mut prop lBrace: Token
功能：获取或设置 LambdaExpr 中的 "{"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "{" 时，抛出异常。
prop nodes
public mut prop nodes: ArrayList<Node>
功能：获取或设置 LambdaExpr 中的表达式或声明节点。
prop rBrace
public mut prop rBrace: Token
功能：获取或设置 LambdaExpr 中的 "}"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "}" 时，抛出异常。
init()
public init()
功能：构造一个默认的 LambdaExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 LambdaExpr 对象
let lambdaExpr = LambdaExpr()
// 设置 LambdaExpr 的属性
lambdaExpr.lBrace = Token(TokenKind.LCURL)
lambdaExpr.rBrace = Token(TokenKind.RCURL)
lambdaExpr.doubleArrow = Token(TokenKind.DOUBLE_ARROW)
let funcParams = ArrayList<FuncParam>()
funcParams.add(FuncParam(quote(x: Int64)))
lambdaExpr.funcParams = funcParams
let nodes = ArrayList<Node>()
nodes.add(BinaryExpr(quote(x + 1)))
lambdaExpr.nodes = nodes
// 转化为 Tokens 并输出
println("lambdaExpr.toTokens(): ${lambdaExpr.toTokens()}")
}
运行结果：
lambdaExpr.toTokens(): { x: Int64 =>
x + 1
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 LambdaExpr 对象。
参数：
- inputs: Tokens - 将要构造 LambdaExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 LambdaExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 LambdaExpr 对象
let lambdaExpr = LambdaExpr(quote({x: Int64 => x + 1}))
// 转化为 Tokens 并输出
println("lambdaExpr.toTokens(): ${lambdaExpr.toTokens()}")
}
运行结果：
lambdaExpr.toTokens(): { x: Int64 =>
x + 1
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 LambdaExpr 对象
let lambdaExpr = LambdaExpr(quote({x: Int64 => x + 1}))
// 转化为 Tokens 并输出
println("lambdaExpr.toTokens(): ${lambdaExpr.toTokens()}")
}
运行结果：
lambdaExpr.toTokens(): { x: Int64 =>
x + 1
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: LambdaExpr) {
println("Visiting LambdaExpr")
}
}
main(): Unit {
// 从 Tokens 创建 LambdaExpr 对象
let lambdaExpr = LambdaExpr(quote({x: Int64 => x + 1}))
// 使用自定义访问器遍历 LambdaExpr 节点
lambdaExpr.traverse(MyVisitor())
}
运行结果：
Visiting LambdaExpr
class LetPatternExpr
public class LetPatternExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 let 声明的解构匹配节点。
一个 LetPatternExpr 节点：if (let Some(v) <- x) 中的 let Some(v) <- x。
父类型：
prop backArrow
public mut prop backArrow: Token
功能：获取或设置 LetPatternExpr 节点中 <- 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
<-操作符时，抛出异常。
prop expr
public mut prop expr: Expr
功能：获取或设置 LetPatternExpr 节点中 <- 操作符之后的表达式。
类型：Expr
prop keyword
public mut prop keyword: Token
功能：获取或设置 LetPatternExpr 节点中 let 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
let关键字时，抛出异常。
prop pattern
public mut prop pattern: Pattern
功能：获取或设置 LetPatternExpr 节点中 let 之后的 pattern。
类型：Pattern
init()
public init()
功能：构造一个默认的 LetPatternExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 LetPatternExpr 对象
let letPatternExpr = LetPatternExpr()
// 设置 LetPatternExpr 的属性
letPatternExpr.keyword = Token(TokenKind.LET)
letPatternExpr.pattern = EnumPattern(quote(Some(v)))
letPatternExpr.backArrow = Token(TokenKind.BACKARROW)
letPatternExpr.expr = RefExpr(quote(x))
// 转化为 Tokens 并输出
println("letPatternExpr.toTokens(): ${letPatternExpr.toTokens()}")
}
运行结果：
letPatternExpr.toTokens(): let Some(v) <- x
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 LetPatternExpr 对象。
参数：
- inputs: Tokens - 将要构造 LetPatternExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 LetPatternExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 LetPatternExpr 对象
let letPatternExpr = LetPatternExpr(quote(let Some(v) <- x))
// 转化为 Tokens 并输出
println("letPatternExpr.toTokens(): ${letPatternExpr.toTokens()}")
}
运行结果：
letPatternExpr.toTokens(): let Some(v) <- x
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 LetPatternExpr 对象
let letPatternExpr = LetPatternExpr(quote(let Some(v) <- x))
// 转化为 Tokens 并输出
println("letPatternExpr.toTokens(): ${letPatternExpr.toTokens()}")
}
运行结果：
letPatternExpr.toTokens(): let Some(v) <- x
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: LetPatternExpr) {
println("Visiting LetPatternExpr")
}
}
main(): Unit {
// 从 Tokens 创建 LetPatternExpr 对象
let letPatternExpr = LetPatternExpr(quote(let Some(v) <- x))
// 使用自定义访问器遍历 LetPatternExpr 节点
letPatternExpr.traverse(MyVisitor())
}
运行结果：
Visiting LetPatternExpr
class LitConstExpr
public class LitConstExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示一个常量表达式节点。
一个 LitConstExpr 表达式："abc"，123 等。
父类型：
prop literal
public mut prop literal: Token
功能：获取或设置 LitConstExpr 节点中的字面量。
类型：Token
init()
public init()
功能：构造一个默认的 LitConstExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 LitConstExpr 对象
let litConstExpr = LitConstExpr()
// 设置 LitConstExpr 的属性
litConstExpr.literal = Token(TokenKind.INTEGER_LITERAL, "123")
// 转化为 Tokens 并输出
println("litConstExpr.toTokens(): ${litConstExpr.toTokens()}")
}
运行结果：
litConstExpr.toTokens(): 123
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 LitConstExpr 对象。
参数：
- inputs: Tokens - 将要构造 LitConstExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ParenExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 LitConstExpr 对象
let litConstExpr = LitConstExpr(quote(123))
// 转化为 Tokens 并输出
println("litConstExpr.toTokens(): ${litConstExpr.toTokens()}")
}
运行结果：
litConstExpr.toTokens(): 123
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 LitConstExpr 对象
let litConstExpr = LitConstExpr(quote(123))
// 转化为 Tokens 并输出
println("litConstExpr.toTokens(): ${litConstExpr.toTokens()}")
}
运行结果：
litConstExpr.toTokens(): 123
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: LitConstExpr) {
println("Visiting LitConstExpr")
}
}
main(): Unit {
// 从 Tokens 创建 LitConstExpr 对象
let litConstExpr = LitConstExpr(quote(123))
// 使用自定义访问器遍历 LitConstExpr 节点
litConstExpr.traverse(MyVisitor())
}
运行结果：
Visiting LitConstExpr
class MacroDecl
public class MacroDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示一个宏定义节点。
一个 MacroDecl 节点：public macro M(input: Tokens): Tokens {...}。
父类型：
prop block
public mut prop block: Block
功能：获取或设置 MacroDecl 节点的函数体。
类型：Block
prop colon
public mut prop colon: Token
功能：获取或设置 MacroDecl 节点的冒号。
类型：Token
异常：
- ASTException - 当设置的 Token 不是冒号时，抛出异常。
prop declType
public mut prop declType: TypeNode
功能：获取或设置 MacroDecl 节点的函数返回类型。
类型：TypeNode
异常：
- ASTException - 当 MacroDecl 节点的函数返回类型是一个缺省值时，抛出异常。
prop funcParams
public mut prop funcParams: ArrayList<FuncParam>
功能：获取或设置 MacroDecl 节点的参数。
prop lParen
public mut prop lParen: Token
功能：获取或设置 MacroDecl 节点的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 MacroDecl 节点的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 MacroDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MacroDecl 对象
let macroDecl = MacroDecl()
// 设置 MacroDecl 的属性
macroDecl.keyword = quote(macro)[0]
macroDecl.identifier = quote(testMacro)[0]
macroDecl.lParen = Token(TokenKind.LPAREN)
let param1 = FuncParam(quote(a: Tokens))
let param2 = FuncParam(quote(b: Tokens))
macroDecl.funcParams = ArrayList<FuncParam>([param1, param2])
macroDecl.rParen = Token(TokenKind.RPAREN)
macroDecl.colon = Token(TokenKind.COLON)
macroDecl.declType = RefType(quote(Tokens))
macroDecl.block = Block()
// 转化为 Tokens 并输出
println("macroDecl.toTokens(): ${macroDecl.toTokens()}")
}
运行结果：
macroDecl.toTokens(): macro testMacro(a: Tokens, b: Tokens): Tokens
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 MacroDecl 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 MacroDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 MacroDecl 对象
let macroDecl = MacroDecl(quote(public macro M(input: Tokens): Tokens {}))
// 转化为 Tokens 并输出
println("macroDecl.toTokens(): ${macroDecl.toTokens()}")
}
运行结果：
macroDecl.toTokens(): public macro M(input: Tokens): Tokens {
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 MacroDecl 对象
let macroDecl = MacroDecl(quote(public macro M(input: Tokens): Tokens {}))
// 转化为 Tokens 并输出
println("macroDecl.toTokens(): ${macroDecl.toTokens()}")
}
运行结果：
macroDecl.toTokens(): public macro M(input: Tokens): Tokens {
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MacroDecl) {
println("Visiting MacroDecl")
}
}
main(): Unit {
// 从 Tokens 创建 MacroDecl 对象
let macroDecl = MacroDecl(quote(public macro M(input: Tokens): Tokens {}))
// 使用自定义访问器遍历 MacroDecl 节点
macroDecl.traverse(MyVisitor())
}
运行结果：
Visiting MacroDecl
class MacroExpandDecl
public class MacroExpandDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示宏调用节点。
一个 MacroExpandDecl 节点： @M class A {}。
父类型：
prop fullIdentifier
public mut prop fullIdentifier: Token
功能：获取或设置宏调用节点的完整标识符，如 @pkg.m class a{} 中的 pkg.m。
类型：Token
prop identifier
public override mut prop identifier: Token
功能：该属性继承自 Decl 节点，表示宏调用节点的标识符，如 @pkg.m class a{} 中的 m。
类型：Token
prop lParen
public mut prop lParen: Token
功能：获取或设置 MacroExpandDecl 宏调用的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop lSquare
public mut prop lSquare: Token
功能：获取或设置 MacroExpandDecl 属性宏调用的 "["。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "[" 时，抛出异常。
prop macroAttrs
public mut prop macroAttrs: Tokens
功能：获取或设置 MacroExpandDecl 属性宏调用的输入。
类型：Tokens
prop macroInputDecl
public mut prop macroInputDecl: Decl
功能：获取或设置 MacroExpandDecl 中的声明节点。
类型：Decl
异常：
- ASTException - 当 MacroExpandDecl 节点中没有声明节点时，抛出异常。
prop macroInputs
public mut prop macroInputs: Tokens
功能：获取或设置 MacroExpandDecl 宏调用的输入。
类型：Tokens
prop rParen
public mut prop rParen: Token
功能：获取或设置 MacroExpandDecl 宏调用的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop rSquare
public mut prop rSquare: Token
功能：获取或设置 MacroExpandDecl 属性宏调用的 "]"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "]" 时，抛出异常。
init()
public init()
功能：构造一个默认的 MacroExpandDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MacroExpandDecl 对象
let macroExpandDecl = MacroExpandDecl()
// 设置 MacroExpandDecl 的属性
macroExpandDecl.keyword = quote(@)[0]
macroExpandDecl.fullIdentifier = quote(testMacro)[0]
macroExpandDecl.macroAttrs = quote(123)
macroExpandDecl.lSquare = Token(LSQUARE)
macroExpandDecl.rSquare = Token(RSQUARE)
macroExpandDecl.lParen = Token(LPAREN)
macroExpandDecl.rParen = Token(RPAREN)
macroExpandDecl.macroInputs = Tokens()
macroExpandDecl.macroInputDecl = FuncDecl(quote(func test() {}))
// 转化为 Tokens 并输出
println("macroExpandDecl.toTokens(): ${macroExpandDecl.toTokens()}")
}
运行结果：
macroExpandDecl.toTokens(): @testMacro[123](func test() {
}
)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 MacroExpandDecl 对象。
参数：
- inputs: Tokens - 将要构造 MacroExpandDecl 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 MacroExpandDecl 节点时，抛出异常。
示例：
import std.ast.*
main() {
// 从 Tokens 创建 MacroExpandDecl 对象
let macroExpandDecl = MacroExpandDecl(quote(@M class A {}))
// 转化为 Tokens 并输出
println("macroExpandDecl.toTokens(): ${macroExpandDecl.toTokens()}")
}
运行结果：
macroExpandDecl.toTokens(): @M
class A {
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 MacroExpandDecl 对象
let macroExpandDecl = MacroExpandDecl(quote(@M class A {}))
// 转化为 Tokens 并输出
println("macroExpandDecl.toTokens(): ${macroExpandDecl.toTokens()}")
}
运行结果：
macroExpandDecl.toTokens(): @M
class A {
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MacroExpandDecl) {
println("Visiting MacroExpandDecl")
}
}
main() {
// 从 Tokens 创建 MacroExpandDecl 对象
let macroExpandDecl = MacroExpandDecl(quote(@M class A {}))
// 使用自定义访问器遍历 MacroExpandDecl 节点
macroExpandDecl.traverse(MyVisitor())
}
运行结果：
Visiting MacroExpandDecl
class MacroExpandExpr
public class MacroExpandExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示宏调用节点。
一个 MacroExpandExpr 节点： @M (a is Int64)。
父类型：
prop at
public mut prop at: Token
功能：获取或设置 MacroExpandExpr 节点中的 @ 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
@操作符时，抛出异常。
prop identifier
public mut prop identifier: Token
功能：获取或设置宏调用节点的标识符。
类型：Token
prop lParen
public mut prop lParen: Token
功能：获取或设置 MacroExpandExpr 宏调用的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop lSquare
public mut prop lSquare: Token
功能：获取或设置 MacroExpandExpr 属性宏调用的 "["。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "[" 时，抛出异常。
prop macroAttrs
public mut prop macroAttrs: Tokens
功能：获取或设置 MacroExpandExpr 属性宏调用的输入。
类型：Tokens
prop macroInputs
public mut prop macroInputs: Tokens
功能：获取或设置 MacroExpandExpr 宏调用的输入。
类型：Tokens
prop rParen
public mut prop rParen: Token
功能：获取或设置 MacroExpandExpr 宏调用的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop rSquare
public mut prop rSquare: Token
功能：获取或设置 MacroExpandExpr 属性宏调用的 "]"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "]" 时，抛出异常。
init()
public init()
功能：构造一个默认的 MacroExpandExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MacroExpandExpr 对象
let macroExpandExpr = MacroExpandExpr()
// 设置 MacroExpandExpr 的属性
macroExpandExpr.at = Token(TokenKind.AT)
macroExpandExpr.identifier = Token(TokenKind.IDENTIFIER, "M")
macroExpandExpr.lParen = Token(TokenKind.LPAREN)
macroExpandExpr.rParen = Token(TokenKind.RPAREN)
macroExpandExpr.lSquare = Token(TokenKind.LSQUARE)
macroExpandExpr.rSquare = Token(TokenKind.RSQUARE)
macroExpandExpr.macroAttrs = quote(123)
macroExpandExpr.macroInputs = quote(a is Int64)
// 转化为 Tokens 并输出
println("macroExpandExpr.toTokens(): ${macroExpandExpr.toTokens()}")
}
运行结果：
macroExpandExpr.toTokens(): @M[123](a is Int64)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 MacroExpandExpr 对象。
参数：
- inputs: Tokens - 将要构造 MacroExpandExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 MacroExpandExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 MacroExpandExpr 对象
let macroExpandExpr = MacroExpandExpr(quote(@M (a is Int64)))
// 转化为 Tokens 并输出
println("macroExpandExpr.toTokens(): ${macroExpandExpr.toTokens()}")
}
运行结果：
macroExpandExpr.toTokens(): @M(a is Int64)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 MacroExpandExpr 对象
let macroExpandExpr = MacroExpandExpr(quote(@M (a is Int64)))
// 转化为 Tokens 并输出
println("macroExpandExpr.toTokens(): ${macroExpandExpr.toTokens()}")
}
运行结果：
macroExpandExpr.toTokens(): @M(a is Int64)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MacroExpandExpr) {
println("Visiting MacroExpandExpr")
}
}
main(): Unit {
// 从 Tokens 创建 MacroExpandExpr 对象
let macroExpandExpr = MacroExpandExpr(quote(@M (a is Int64)))
// 使用自定义访问器遍历 MacroExpandExpr 节点
macroExpandExpr.traverse(MyVisitor())
}
运行结果：
Visiting MacroExpandExpr
class MacroExpandParam
public class MacroExpandParam <: FuncParam {
public init()
}
功能：表示宏调用节点。
一个 MacroExpandParam 节点： func foo (@M a: Int64) 中的 @M a: Int64。
父类型：
prop fullIdentifier
public mut prop fullIdentifier: Token
功能：获取或设置宏调用节点的完整标识符，如 func bar (@pkg.m a: Int64) 中的 pkg.m。
类型：Token
prop identifier
public override mut prop identifier: Token
功能：该属性继承自 Decl 节点，表示宏调用节点的标识符，如 func bar (@pkg.m a: Int64) 中的 m。
类型：Token
prop lParen
public mut prop lParen: Token
功能：获取或设置 MacroExpandParam 宏调用的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop lSquare
public mut prop lSquare: Token
功能：获取或设置 MacroExpandParam 属性宏调用的 "["。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "[" 时，抛出异常。
prop macroAttrs
public mut prop macroAttrs: Tokens
功能：获取或设置 MacroExpandParam 属性宏调用的输入。
类型：Tokens
prop macroInputDecl
public mut prop macroInputDecl: Decl
功能：获取或设置 MacroExpandParam 中的声明节点。
类型：Decl
异常：
- ASTException - 当 MacroExpandParam 节点中没有声明节点时，抛出异常。
prop macroInputs
public mut prop macroInputs: Tokens
功能：获取或设置 MacroExpandParam 宏调用的输入。
类型：Tokens
prop rParen
public mut prop rParen: Token
功能：获取或设置 MacroExpandParam 宏调用的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop rSquare
public mut prop rSquare: Token
功能：获取或设置 MacroExpandParam 属性宏调用的 "]"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "]" 时，抛出异常。
init()
public init()
功能：构造一个默认的 MacroExpandParam 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MacroExpandParam 对象
let macroExpandParam = MacroExpandParam()
// 设置 MacroExpandParam 的属性
macroExpandParam.keyword = Token(TokenKind.AT, "@")
macroExpandParam.fullIdentifier = Token(TokenKind.IDENTIFIER, "M")
macroExpandParam.identifier = Token(TokenKind.IDENTIFIER, "M")
macroExpandParam.lSquare = Token(TokenKind.LSQUARE)
macroExpandParam.rSquare = Token(TokenKind.RSQUARE)
macroExpandParam.macroAttrs = quote(123)
macroExpandParam.macroInputs = quote(a: Int64)
// 转化为 Tokens 并输出
println("macroExpandParam.toTokens(): ${macroExpandParam.toTokens()}")
}
运行结果：
macroExpandParam.toTokens(): @M[123]
a: Int64
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MacroExpandParam 对象
let macroExpandParam = MacroExpandParam()
// 设置 MacroExpandParam 的属性
macroExpandParam.keyword = Token(TokenKind.AT, "@")
macroExpandParam.fullIdentifier = Token(TokenKind.IDENTIFIER, "M")
macroExpandParam.identifier = Token(TokenKind.IDENTIFIER, "M")
macroExpandParam.lSquare = Token(TokenKind.LSQUARE)
macroExpandParam.rSquare = Token(TokenKind.RSQUARE)
macroExpandParam.macroAttrs = quote(123)
macroExpandParam.macroInputs = quote(a: Int64)
// 转化为 Tokens 并输出
println("macroExpandParam.toTokens(): ${macroExpandParam.toTokens()}")
}
运行结果：
macroExpandParam.toTokens(): @M[123]
a: Int64
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MacroExpandParam) {
println("Visiting MacroExpandParam")
}
}
main(): Unit {
// 构造一个默认的 MacroExpandParam 对象
let macroExpandParam = MacroExpandParam()
// 设置 MacroExpandParam 的属性
macroExpandParam.keyword = Token(TokenKind.AT, "@")
macroExpandParam.identifier = Token(TokenKind.IDENTIFIER, "M")
macroExpandParam.macroInputs = quote(any)
// 使用自定义访问器遍历 MacroExpandParam 节点
macroExpandParam.traverse(MyVisitor())
}
运行结果：
Visiting MacroExpandParam
class MacroMessage
public class MacroMessage {}
功能：记录内层宏发送的信息。
func getBool(String)
public func getBool(key: String): Bool
功能：获取对应 key 值的 Bool 类型信息。
参数：
- key: String - 用于检索的关键字的名字。
返回值：
异常：
示例：
// 宏定义
macro package M
import std.ast.*
import std.collection.ArrayList
public macro inner(input: Tokens) {
// 向外层宏发送 Bool 类型消息
setItem("TrueFromInner", true)
setItem("FalseFromInner", false)
return input
}
public macro outer(input: Tokens) {
// 获取名为 inner 的内层宏所发送的全部消息
let messages = getChildMessages("inner")
// 获取内层宏发送的 Bool 消息
let msg0 = messages[0].getBool("TrueFromInner")
let msg1 = messages[0].getBool("FalseFromInner")
// 输出两个 Bool 类型消息
println("Message 0 from inner-macro: ${msg0}")
println("Message 1 from inner-macro: ${msg1}")
return input
}
// 宏调用
import M.*
@outer(@inner(var a = 1))
main() {
}
运行结果：
Message 0 from inner-macro: true
Message 1 from inner-macro: false
func getInt64(String)
public func getInt64(key: String): Int64
功能：获取对应 key 值的 Int64 类型信息。
参数：
- key: String - 用于检索的关键字的名字。
返回值：
异常：
示例：
// 宏定义
macro package M
import std.ast.*
import std.collection.ArrayList
public macro inner(input: Tokens) {
// 向外层宏发送 Int64 类型消息
setItem("Int64FromInner", 100)
return input
}
public macro outer(input: Tokens) {
// 获取名为 inner 的内层宏所发送的全部消息
let messages = getChildMessages("inner")
// 获取内层宏发送的 Int64 消息
let msg = messages[0].getInt64("Int64FromInner")
// 输出 Int64 类型消息
println("Message from inner-macro: ${msg}")
return input
}
// 宏调用
import M.*
@outer(@inner(var a = 1))
main() {
}
运行结果：
Message from inner-macro: 100
func getString(String)
public func getString(key: String): String
功能：获取对应 key 值的 String 类型信息。
参数：
- key: String - 用于检索的关键字的名字。
返回值：
异常：
示例：
// 宏定义
macro package M
import std.ast.*
import std.collection.ArrayList
public macro inner(input: Tokens) {
// 向外层宏发送 String 类型消息
setItem("StringFromInner", "message")
return input
}
public macro outer(input: Tokens) {
// 获取名为 inner 的内层宏所发送的全部消息
let messages = getChildMessages("inner")
// 获取内层宏发送的 String 消息
let msg = messages[0].getString("StringFromInner")
// 输出 String 类型消息
println("Message from inner-macro: ${msg}")
return input
}
// 宏调用
import M.*
@outer(@inner(var a = 1))
main() {
}
运行结果：
Message from inner-macro: message
func getTokens(String)
public func getTokens(key: String): Tokens
功能：获取对应 key 值的 Tokens 类型信息。
参数：
- key: String - 用于检索的关键字的名字。
返回值：
异常：
示例：
// 宏定义
macro package M
import std.ast.*
import std.collection.ArrayList
public macro inner(input: Tokens) {
// 向外层宏发送 Tokens 类型消息
setItem("TokensFromInner", quote(1 + 1))
return input
}
public macro outer(input: Tokens) {
// 获取名为 inner 的内层宏所发送的全部消息
let messages = getChildMessages("inner")
// 获取内层宏发送的 Tokens 消息
let msg = messages[0].getTokens("TokensFromInner")
// 输出 Tokens 类型消息
println("Message from inner-macro: ${msg}")
return input
}
// 宏调用
import M.*
@outer(@inner(var a = 1))
main() {
}
运行结果：
Message from inner-macro: 1 + 1
func hasItem(String)
public func hasItem(key: String): Bool
功能：检查是否有 key 值对应的相关信息。
参数：
- key: String - 用于检索的关键字名字。
返回值：
- Bool - 若存在 key 值对应的相关信息，返回 true；反之，返回 false。
示例：
// 宏定义
macro package M
import std.ast.*
import std.collection.ArrayList
public macro inner(input: Tokens) {
// 向外层宏发送 Int64 类型消息
setItem("Int64FromInner", 100)
return input
}
public macro outer(input: Tokens) {
// 获取名为 inner 的内层宏所发送的全部消息
let messages = getChildMessages("inner")
// 判断内层宏是否发送了对应的消息
let result = messages[0].hasItem("Int64FromInner")
println("messages[0].hasItem(\"Int64FromInner\"): ${result}")
return input
}
// 宏调用
import M.*
@outer(@inner(var a = 1))
main() {
}
运行结果：
messages[0].hasItem("Int64FromInner"): true
class MainDecl
public class MainDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示一个 main 函数定义节点。
一个 MainDecl 节点：main() {}。
父类型：
prop block
public mut prop block: Block
功能：获取或设置 MainDecl 节点的函数体。
类型：Block
prop colon
public mut prop colon: Token
功能：获取或设置 MainDecl 节点的冒号。
类型：Token
异常：
- ASTException - 当设置的 Token 不是冒号时，抛出异常。
prop declType
public mut prop declType: TypeNode
功能：获取或设置 MainDecl 节点的函数返回类型。
类型：TypeNode
异常：
- ASTException - 当 MainDecl 节点的函数返回类型是一个缺省值时，抛出异常。
prop funcParams
public mut prop funcParams: ArrayList<FuncParam>
功能：获取或设置 MainDecl 节点的函数参数。
prop lParen
public mut prop lParen: Token
功能：获取或设置 MainDecl 节点的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 MainDecl 节点的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 MainDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MainDecl 对象
let mainDecl = MainDecl()
// 设置 MainDecl 的属性
mainDecl.keyword = quote(main)[0]
mainDecl.colon = Token(TokenKind.COLON)
mainDecl.declType = PrimitiveType(quote(Unit))
mainDecl.funcParams = ArrayList<FuncParam>()
mainDecl.lParen = Token(TokenKind.LPAREN)
mainDecl.rParen = Token(TokenKind.RPAREN)
// 设置代码块
let block = Block()
block.lBrace = Token(TokenKind.LCURL)
block.rBrace = Token(TokenKind.RCURL)
mainDecl.block = block
// 转化为 Tokens 并输出
println("mainDecl.toTokens(): ${mainDecl.toTokens()}")
}
运行结果：
mainDecl.toTokens(): main(): Unit {
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 MainDecl 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 MainDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 MainDecl 对象
let mainDecl = MainDecl(quote(main() { println("Hello World") }))
// 转化为 Tokens 并输出
println("mainDecl.toTokens(): ${mainDecl.toTokens()}")
}
运行结果：
mainDecl.toTokens(): main() {
println("Hello World")
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 MainDecl 对象
let mainDecl = MainDecl(quote(main() { println("Hello World") }))
// 通过toTokens()将实例输出
println("mainDecl.toTokens(): ${mainDecl.toTokens()}")
}
运行结果：
mainDecl.toTokens(): main() {
println("Hello World")
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MainDecl) {
println("Visiting MainDecl")
}
}
main(): Unit {
// 从 Tokens 创建 MainDecl 对象
let mainDecl = MainDecl(quote(main() { println("Hello World") }))
// 使用自定义访问器遍历 MainDecl 节点
mainDecl.traverse(MyVisitor())
}
运行结果：
Visiting MainDecl
class MatchCase
public class MatchCase <: Node {
public init()
}
功能：表示 match 表达式中的一个 case 节点。
一个 MatchCase 节点：case failScore where score > 0 => 0。
说明：
父类型：
prop arrow
public mut prop arrow: Token
功能：获取或设置 MatchCase 中的 => 操作符的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
=>操作符时，抛出异常。
prop bitOrs
public mut prop bitOrs: Tokens
功能：获取或设置 MatchCase 中的 | 操作符的词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是
|词法单元序列时，抛出异常。
prop block
public mut prop block: Block
功能：获取或设置 MatchCase 中的一系列声明或表达式节点。
类型：Block
prop expr
public mut prop expr: Expr
功能：获取或设置 MatchCase 中位于 case 后的表达式节点。
类型：Expr
异常：
- ASTException - 当 MatchCase 节点中不存在表达式节点时，抛出异常。
prop keywordC
public mut prop keywordC: Token
功能：获取或设置 MatchCase 内的 case 关键字的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
case关键字时，抛出异常。
prop keywordW
public mut prop keywordW: Token
功能：获取或设置 MatchCase 中可选的关键字 where 的词法单元，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
where关键字时，抛出异常。
prop patternGuard
public mut prop patternGuard: Expr
功能：获取或设置 MatchCase 中可选的 pattern guard 表达式节点。
类型：Expr
异常：
- ASTException - 当 MatchCase 节点中不存在 pattern guard 表达式时，抛出异常。
prop patterns
public mut prop patterns: ArrayList<Pattern>
功能：获取或设置 MatchCase 中位于 case 后的 pattern 列表。
init()
public init()
功能：构造一个默认的 MatchCase 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MatchCase 对象
let matchCase = MatchCase()
// 设置 MatchCase 的属性
matchCase.keywordC = Token(CASE)
matchCase.expr = BinaryExpr(quote(a > 1))
// 设置代码块
let block = Block()
block.nodes.add(LitConstExpr(quote(true)))
matchCase.block = block
// 转化为 Tokens 并输出
println("matchCase.toTokens(): ${matchCase.toTokens()}")
}
运行结果：
matchCase.toTokens(): case a > 1 => true
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MatchCase 对象
let matchCase = MatchCase()
// 设置 MatchCase 的属性
matchCase.keywordC = Token(CASE)
matchCase.expr = BinaryExpr(quote(a > 1))
// 设置代码块
let block = Block()
block.nodes.add(LitConstExpr(quote(true)))
matchCase.block = block
// 转化为 Tokens 并输出
println("matchCase.toTokens(): ${matchCase.toTokens()}")
}
运行结果：
matchCase.toTokens(): case a > 1 => true
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MatchCase) {
println("Visiting MatchCase")
}
}
main(): Unit {
// 构造一个默认的 MatchCase 对象
let matchCase = MatchCase()
// 设置 MatchCase 的属性
matchCase.keywordC = Token(CASE)
matchCase.expr = BinaryExpr(quote(a > 1))
// 设置代码块
let block = Block()
block.nodes.add(LitConstExpr(quote(true)))
matchCase.block = block
// 使用自定义访问器遍历 MatchCase 节点
matchCase.traverse(MyVisitor())
}
运行结果：
Visiting MatchCase
class MatchExpr
public class MatchExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示模式匹配表达式实现模式匹配。
模式匹配表达式分为带 selector 的 match 表达式和不带 selector 的 match 表达式。
父类型：
prop keyword
public mut prop keyword: Token
功能：获取或设置 MatchExpr 节点中 match 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
matcch关键字时，抛出异常。
prop lBrace
public mut prop lBrace: Token
功能：获取或设置 MatchExpr 之后的 "{"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "{" 时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 MatchExpr 之后的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop matchCases
public mut prop matchCases: ArrayList<MatchCase>
功能：获取或设置 MatchExpr 内的 matchCase, matchCase 以关键字 case 开头，后跟一个或者多个由 Pattern 或 Expr节点，具体见 MatchCase。
prop rBrace
public mut prop rBrace: Token
功能：获取或设置 MatchExpr 之后的 "}"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "}" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 MatchExpr 之后的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop selector
public mut prop selector: Expr
功能：获取或设置关键字 match 之后的 Expr。
类型：Expr
异常：
- ASTException - 当该表达式是一个不带 selector 的
match表达式时，抛出异常。
init()
public init()
功能：构造一个默认的 MatchExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MatchExpr 对象
let matchExpr = MatchExpr()
// 设置 MatchExpr 的属性
matchExpr.keyword = Token(TokenKind.MATCH)
matchExpr.lBrace = Token(TokenKind.LCURL)
matchExpr.rBrace = Token(TokenKind.RCURL)
matchExpr.lParen = Token(TokenKind.LPAREN)
matchExpr.rParen = Token(TokenKind.RPAREN)
matchExpr.matchCases = ArrayList<MatchCase>()
matchExpr.selector = RefExpr(quote(x))
let matchCase = MatchCase()
matchCase.keywordC = Token(CASE)
matchCase.expr = WildcardExpr()
let block = Block()
block.nodes.add(LitConstExpr(quote(true)))
matchCase.block = block
matchExpr.matchCases.add(matchCase)
// 转化为 Tokens 并输出
println("matchExpr.toTokens(): ${matchExpr.toTokens()}")
}
运行结果：
matchExpr.toTokens(): match(x) {
case _ => true
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 MatchExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 MatchExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 MatchExpr 对象
let matchExpr = MatchExpr(quote(match (x) { case _ => 2 }))
// 转化为 Tokens 并输出
println("matchExpr.toTokens(): ${matchExpr.toTokens()}")
}
运行结果：
matchExpr.toTokens(): match(x) {
case _ => 2
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个带实际值的 MatchExpr 对象
let matchExpr = MatchExpr(quote(match (x) { case _ => 2 }))
// 调用 toTokens 方法将 MatchExpr 转化为 Tokens
let tokens = matchExpr.toTokens()
// 转化为 Tokens 并输出
println("matchExpr.toTokens(): ${matchExpr.toTokens()}")
}
运行结果：
matchExpr.toTokens(): match(x) {
case _ => 2
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MatchExpr) {
println("Visiting MatchExpr")
}
}
main(): Unit {
// 创建一个 MatchExpr 对象
let matchExpr = MatchExpr(quote(match (x) { case _ => 2 }))
// 使用自定义访问器遍历 MatchExpr 节点
matchExpr.traverse(MyVisitor())
}
运行结果：
Visiting MatchExpr
class MemberAccess
public class MemberAccess <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示成员访问表达式。
可以用于访问 class、interface、struct 等类型的成员。一个 MemberAccess 节点的形式为 T.a，T 为成员访问表达式的主体，a 表示成员的名字。
父类型：
prop baseExpr
public mut prop baseExpr: Expr
功能：获取或设置 MemberAccess 节点的成员访问表达式主体。
类型：Expr
prop commas
public mut prop commas: Tokens
功能：获取或设置 MemberAccess 节点中的 "," 词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop dot
public mut prop dot: Token
功能：获取或设置 MemberAccess 节点中的 "."。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "." 词法单元类型时，抛出异常。
prop field
public mut prop field: Token
功能：获取或设置 MemberAccess 节点成员的名字。
类型：Token
prop lAngle
public mut prop lAngle: Token
功能：获取或设置 MemberAccess 节点中的左尖括号。
类型：Token
异常：
- ASTException - 当设置的 Token 不是左尖括号时，抛出异常。
prop rAngle
public mut prop rAngle: Token
功能：获取或设置 MemberAccess 节点中的右尖括号。
类型：Token
异常：
- ASTException - 当设置的 Token 不是右尖括号时，抛出异常。
prop typeArguments
public mut prop typeArguments: ArrayList<TypeNode>
功能：获取或设置 MemberAccess 节点中的实例化类型。
init()
public init()
功能：构造一个默认的 MemberAccess 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 MemberAccess 对象
let memberAccess = MemberAccess()
// 设置 MemberAccess 的属性
memberAccess.baseExpr = RefExpr(quote(obj))
memberAccess.dot = Token(TokenKind.DOT)
memberAccess.field = Token(TokenKind.IDENTIFIER, "field")
memberAccess.commas = quote(,)
memberAccess.lAngle = Token(TokenKind.LT)
memberAccess.rAngle = Token(TokenKind.GT)
memberAccess.typeArguments = ArrayList<TypeNode>()
// 转化为 Tokens 并输出
println("memberAccess.toTokens(): ${memberAccess.toTokens()}")
}
运行结果：
memberAccess.toTokens(): obj.field
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 MemberAccess 对象。
参数：
- inputs: Tokens - 将要构造 MemberAccess 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 MemberAccess 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 MemberAccess 对象
let memberAccess = MemberAccess(quote(obj.field))
// 转化为 Tokens 并输出
println("memberAccess.toTokens(): ${memberAccess.toTokens()}")
}
运行结果：
memberAccess.toTokens(): obj.field
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个带实际值的 MemberAccess 对象
let memberAccess = MemberAccess(quote(obj.field))
// 转化为 Tokens 并输出
println("memberAccess.toTokens(): ${memberAccess.toTokens()}")
}
运行结果：
memberAccess.toTokens(): obj.field
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MemberAccess) {
println("Visiting MemberAccess")
}
}
main(): Unit {
// 创建一个 MemberAccess 对象
let memberAccess = MemberAccess(quote(obj.field))
// 使用自定义访问器遍历 MemberAccess 节点
memberAccess.traverse(MyVisitor())
}
运行结果：
Visiting MemberAccess
class Modifier
public class Modifier <: Node {
public init(keyword: Token)
public init()
}
功能：表示该定义具备某些特性，通常放在定义处的最前端。
一个 Modifier 节点：public func foo() 中的 public。
父类型：
prop keyword
public mut prop keyword: Token
功能：获取或设置 Modifier 节点中的修饰符词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 Modifier 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 Modifier 对象
let modifier = Modifier()
// 设置 Modifier 的属性
modifier.keyword = Token(TokenKind.PUBLIC, "public")
// 转化为 Tokens 并输出
println("modifier.toTokens(): ${modifier.toTokens()}")
}
运行结果：
modifier.toTokens(): public
init(Token)
public init(keyword: Token)
功能：构造一个 Modifier 对象。
参数：
示例：
import std.ast.*
main(): Unit {
// 使用 Token 构造 Modifier 对象
let modifier = Modifier(Token(TokenKind.PUBLIC, "public"))
// 转化为 Tokens 并输出
println("modifier.toTokens(): ${modifier.toTokens()}")
}
运行结果：
modifier.toTokens(): public
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个带实际值的 Modifier 对象
let token = Token(TokenKind.PUBLIC, "public")
let modifier = Modifier(token)
// 转化为 Tokens 并输出
println("modifier.toTokens(): ${modifier.toTokens()}")
}
运行结果：
modifier.toTokens(): public
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Modifier) {
println("Visiting Modifier")
}
}
main(): Unit {
// 创建一个 Modifier 对象
let modifier = Modifier(Token(TokenKind.PUBLIC, "public"))
// 使用自定义访问器遍历 Modifier 节点
modifier.traverse(MyVisitor())
}
运行结果：
Visiting Modifier
class Node
abstract sealed class Node <: ToTokens {}
功能：所有仓颉语法树节点的父类。
该类提供了所有数据类型通用的操作接口。
父类型：
prop beginPos
public mut prop beginPos: Position
功能：获取或设置当前节点的起始的位置信息。
类型：Position
prop endPos
public mut prop endPos: Position
功能：获取或设置当前节点的终止的位置信息。
类型：Position
func dump()
public func dump(): Unit
功能：将当前语法树节点转化为树形结构的形态并进行打印。
语法树节点的树形结构将按照以下形式进行输出：
-字符串：表示当前节点的公共属性， 如-keyword,-identifier。- 节点属性后紧跟该节点的具体类型， 如
-declType: PrimitiveType表示节点类型是一个 PrimitiveType 节点。 - 每个类型使用大括号表示类型的作用区间。
语法树输出的详细格式请参见语法树节点打印。
示例：
import std.ast.*
main(): Unit {
// 创建一个 Node 子类对象 (使用 IfExpr 作为示例)
let ifExpr = IfExpr()
// 设置 IfExpr 的条件
ifExpr.condition = LitConstExpr(quote(true))
ifExpr.keywordI = Token(TokenKind.IF)
// 设置代码块
let block = Block()
block.lBrace = Token(TokenKind.LCURL)
block.rBrace = Token(TokenKind.RCURL)
ifExpr.ifBlock = block
// 调用 dump 方法输出节点信息
ifExpr.dump()
}
运行结果：
IfExpr {
-keywordI: Token {
value: "if"
kind: IF
pos: 9: 23
}
-condition: LitConstExpr {
-literal: Token {
value: "true"
kind: BOOL_LITERAL
pos: 8: 43
}
}
-ifBlock: Block {
}
}
func toTokens()
public func toTokens(): Tokens
功能：将语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 Node 子类对象 (使用 IfExpr 作为示例)
let node = IfExpr(quote(if (x > 0) { x = x + 1 } else { x = x - 1 }))
// 输出 Tokens 信息
println("node.toTokens(): ${node.toTokens()}")
}
运行结果：
node.toTokens(): if(x > 0) {
x = x + 1
}
else {
x = x - 1
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Node) {
breakTraverse()
println("Visiting Node")
}
}
main(): Unit {
// 创建 Node 节点（以 ClassDecl 为例）
let node = ClassDecl(quote(class A {}))
// 使用自定义访问器遍历 Node 节点
node.traverse(MyVisitor())
}
运行结果：
Visiting Node
class OptionalExpr
public class OptionalExpr <: Expr {
public init()
public init(inputs: Tokens)
}
功能：表示一个带有问号操作符的表达式节点。
一个 OptionalExpr 节点：a?.b, a?(b), a?[b] 中的 a?。
父类型：
prop baseExpr
public mut prop baseExpr: Expr
功能：获取或设置 OptionalExpr 的表达式节点。
类型：Expr
prop quest
public mut prop quest: Token
功能：获取或设置 OptionalExpr 中的问号操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是问号操作符时，抛出异常。
init()
public init()
功能：构造一个默认的 OptionalExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 OptionalExpr 对象
let optionalExpr = OptionalExpr()
// 设置 OptionalExpr 的属性
optionalExpr.baseExpr = RefExpr(quote(a))
optionalExpr.quest = Token(TokenKind.QUEST)
// 转化为 Tokens 并输出
println("optionalExpr.toTokens(): ${optionalExpr.toTokens()}")
}
运行结果：
optionalExpr.toTokens(): a?
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 OptionalExpr 对象。
参数：
- inputs: Tokens - 将要构造 OptionalExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 OptionalExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 OptionalExpr 对象
let optionalExpr = OptionalExpr(quote(a?))
// 转化为 Tokens 并输出
println("optionalExpr.toTokens(): ${optionalExpr.toTokens()}")
}
运行结果：
optionalExpr.toTokens(): a?
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 OptionalExpr 对象
let optionalExpr = OptionalExpr(quote(a?))
// 转化为 Tokens 并输出
println("optionalExpr.toTokens(): ${optionalExpr.toTokens()}")
}
运行结果：
optionalExpr.toTokens(): a?
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: OptionalExpr) {
println("Visiting OptionalExpr")
}
}
main(): Unit {
// 创建一个 OptionalExpr 对象
let optionalExpr = OptionalExpr(quote(a?))
// 使用自定义访问器遍历 OptionalExpr 节点
optionalExpr.traverse(MyVisitor())
}
运行结果：
Visiting OptionalExpr
class PackageHeader
public class PackageHeader <: Node {
public init(inputs: Tokens)
public init()
}
功能：表示包声明节点。
一个 PackageHeader 节点: package define 或者 macro package define。
说明：
包声明以关键字
package或macro package开头，后面紧跟包名，且包声明必须在源文件的首行。
父类型：
prop accessible
public mut prop accessible: Token
功能：获取或设置 PackageHeader 节点中的访问性修饰符的词法单元，可能为 ILLEGAL 的词法单元。
类型：Token
prop keywordM
public mut prop keywordM: Token
功能：获取或设置 PackageHeader 节点中的 macro 关键字的词法单元（M 为关键字首字母，下同），可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
macro关键字时，抛出异常。
prop keywordP
public mut prop keywordP: Token
功能：获取或设置 PackageHeader 节点中的 package 关键字的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
package关键字时，抛出异常。
prop orgName
public mut prop orgName: Token
功能：获取或设置 PackageHeader 节点中代表组织名的词法单元，setter会检查orgSeparator是否为 "::" 词法单元，若为空则同时设置其为 "::" 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 内容为空字符串时抛出异常。
prop orgSeparator
public mut prop orgSeparator: Token
功能：获取或设置 PackageHeader 节点中的 "::" 词法单元，setter会检查orgName内容是否为空字符串，若有则抛异常。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "::" 时，或orgName内容为空字符串时抛出异常。
prop prefixPaths
public mut prop prefixPaths: Tokens
功能：获取或设置 PackageHeader 节点中完整包名的前缀部分的词法单元序列，可能为空。如 package a.b.c 中的 a 和 b。
类型：Tokens
prop prefixDots
public mut prop prefixDots: Tokens
功能：获取或设置 PackageHeader 节点中完整包名中用于分隔每层子包的词法单元序列，可能为空。如 package a.b.c 中的两个 "."。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "." 词法单元序列时，抛出异常。
prop packageIdentifier
public mut prop packageIdentifier: Token
功能：获取或设置 PackageHeader 节点中当前包的名字，如果当前包为 root 包，即为完整包名，若当前包为子包，则为最后一个 "." 后的名字。
类型：Token
init()
public init()
功能：构造一个默认的 PackageHeader 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 PackageHeader 对象
let packageHeader = PackageHeader()
// 设置 PackageHeader 的属性
packageHeader.keywordP = Token(TokenKind.PACKAGE)
packageHeader.packageIdentifier = Token(TokenKind.IDENTIFIER, "myPackage")
packageHeader.accessible = Token(TokenKind.PUBLIC)
// 转化为 Tokens 并输出
println("packageHeader.toTokens(): ${packageHeader.toTokens()}")
}
运行结果：
packageHeader.toTokens(): package myPackage
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 PackageHeader 对象。
参数：
- inputs: Tokens - 将要构造 PackageHeader 类型的词法单元集合 (Tokens) 序列。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 PackageHeader 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 PackageHeader 对象
let packageHeader = PackageHeader(quote(package myPackage))
// 转化为 Tokens 并输出
println("packageHeader.toTokens(): ${packageHeader.toTokens()}")
}
运行结果：
packageHeader.toTokens(): package myPackage
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个带实际值的 PackageHeader 对象
let packageHeader = PackageHeader(quote(package myPackage))
// 转化为 Tokens 并输出
println("packageHeader.toTokens(): ${packageHeader.toTokens()}")
}
运行结果：
packageHeader.toTokens(): package myPackage
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PackageHeader) {
println("Visiting PackageHeader")
}
}
main(): Unit {
// 创建一个 PackageHeader 对象
let packageHeader = PackageHeader(quote(package myPackage))
// 使用自定义访问器遍历 PackageHeader 节点
packageHeader.traverse(MyVisitor())
}
运行结果：
Visiting PackageHeader
class ParenExpr
public class ParenExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示一个括号表达式节点，是指使用圆括号括起来的表达式。
一个 ParenExpr 节点：(1 + 2)。
父类型：
prop lParen
public mut prop lParen: Token
功能：获取或设置 ParenExpr 节点中的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop parenthesizedExpr
public mut prop parenthesizedExpr: Expr
功能：获取或设置 ParenExpr 节点中由圆括号括起来的子表达式。
类型：Expr
prop rParen
public mut prop rParen: Token
功能：获取或设置 ParenExpr 节点中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 ParenExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ParenExpr 对象
let parenExpr = ParenExpr()
// 设置 ParenExpr 的属性
parenExpr.lParen = Token(TokenKind.LPAREN)
parenExpr.parenthesizedExpr = LitConstExpr(quote(1))
parenExpr.rParen = Token(TokenKind.RPAREN)
// 转化为 Tokens 并输出
println("parenExpr.toTokens(): ${parenExpr.toTokens()}")
}
运行结果：
parenExpr.toTokens(): (1)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ParenExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ParenExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ParenExpr 对象
let parenExpr = ParenExpr(quote((1 + 2)))
// 转化为 Tokens 并输出
println("parenExpr.toTokens(): ${parenExpr.toTokens()}")
}
运行结果：
parenExpr.toTokens(): (1 + 2)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个带实际值的 ParenExpr 对象
let parenExpr = ParenExpr(quote((1 + 2)))
// 转化为 Tokens 并输出
println("parenExpr.toTokens(): ${parenExpr.toTokens()}")
}
运行结果：
parenExpr.toTokens(): (1 + 2)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ParenExpr) {
println("Visiting ParenExpr")
}
}
main(): Unit {
// 创建一个 ParenExpr 对象
let parenExpr = ParenExpr(quote((1 + 2)))
// 使用自定义访问器遍历 ParenExpr 节点
parenExpr.traverse(MyVisitor())
}
运行结果：
Visiting ParenExpr
class ParenType
public class ParenType <: TypeNode {
public init()
public init(inputs: Tokens)
}
功能：表示括号类型节点。
例如 var a: (Int64) 中的 (Int64)。
父类型：
prop lParen
public mut prop lParen: Token
功能：获取或设置 ParenType 节点中的 "(" 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop parenthesizedType
public mut prop parenthesizedType: TypeNode
功能：获取或设置 ParenType 节点中括起来的类型，如 (Int64) 中的 Int64。
类型：TypeNode
prop rParen
public mut prop rParen: Token
功能：获取或设置 ParenType 节点中的 ")" 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 ParenType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ParenType 对象
let parenType = ParenType()
// 设置 ParenType 的属性
parenType.lParen = Token(TokenKind.LPAREN)
parenType.parenthesizedType = PrimitiveType(quote(Int8))
parenType.rParen = Token(TokenKind.RPAREN)
// 转化为 Tokens 并输出
println("parenType.toTokens(): ${parenType.toTokens()}")
}
运行结果：
parenType.toTokens(): (Int8)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ParenType 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ParenType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ParenType 对象
let parenType = ParenType(quote((Int32)))
// 转化为 Tokens 并输出
println("parenType.toTokens(): ${parenType.toTokens()}")
}
运行结果：
parenType.toTokens(): (Int32)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 ParenType 对象
let parenType = ParenType(quote((Int32)))
// 转化为 Tokens 并输出
println("parenType.toTokens(): ${parenType.toTokens()}")
}
运行结果：
parenType.toTokens(): (Int32)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ParenType) {
println("Visiting ParenType")
}
}
main(): Unit {
// 创建一个 ParenType 对象
let parenType = ParenType(quote((Int32)))
// 使用自定义访问器遍历 ParenType 节点
parenType.traverse(MyVisitor())
}
运行结果：
Visiting ParenType
class Pattern
public open class Pattern <: Node {}
功能：所有模式匹配节点的父类，继承自 Node 节点。
父类型：
func dump(UInt16)
protected open func dump(_: UInt16): String
功能：将当前语法树节点转化为树形结构的形态并进行打印，需要被子类重写。
参数：
- _: UInt16 - 格式化输出的缩进空格数量。
返回值：
- String - 格式化输出内容。
示例：
import std.ast.*
extend VarPattern {
public func myDump() {
dump(4)
}
}
main(): Unit {
// 创建一个 Pattern 子类对象 (使用 VarPattern 作为示例)
let pattern = VarPattern(quote(e)[0])
// 调用 dump 方法输出节点信息
let result = pattern.myDump()
println("Pattern dump result: ${result}")
}
运行结果：
Pattern dump result: VarPattern {
-identifier: Token {
value: "e"
kind: IDENTIFIER
pos: 11: 36
}
}
func toTokens()
public open func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 Pattern 子类对象 (使用 VarPattern 作为示例)
let pattern = VarPattern(quote(e)[0])
// 输出 Pattern 节点转化成的 Tokens
println("pattern.toTokens(): ${pattern.toTokens()}")
}
运行结果：
pattern.toTokens(): e
func traverse(Visitor)
public open func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Pattern) {
breakTraverse()
println("Visiting Pattern")
}
}
main(): Unit {
// 创建 Pattern 节点（以 VarPattern 为例）
let pattern = VarPattern(quote(e)[0])
// 使用自定义访问器遍历 Pattern 节点
pattern.traverse(MyVisitor())
}
运行结果：
Visiting Pattern
class PerformExpr
public class PerformExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示一个 perform 表达式节点。
一个 PerformExpr 节点示例：perform Eff()。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 PerformExpr 节点中的表达式部分。
类型：Expr
prop keyword
public mut prop keyword: Token
功能：获取或设置 PerformExpr 节点中的 perform 关键字。
类型：Token
异常：
- ASTException — 当给定的 Token 不是
perform关键字时抛出。
init()
public init()
功能：构造一个默认的 PerformExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 PerformExpr 对象
let performExpr = PerformExpr()
// 设置 PerformExpr 的属性
performExpr.keyword = Token(TokenKind.PERFORM)
performExpr.expr = CallExpr(quote(Effect()))
// 转化为 Tokens 并输出
println("performExpr.toTokens(): ${performExpr.toTokens()}")
}
运行结果：
performExpr.toTokens(): perform Effect()
init(Tokens)
public init(inputs: Tokens)
功能：从提供的词法单元构造一个 PerformExpr 对象。
注意:
编译时需要添加
--experimental和--enable-eh编译选项以支持Effect Handlers特性。
参数：
- inputs: Tokens — 要解析为 PerformExpr 节点的词法单元集合。
异常：
- ASTException — 当输入的 Tokens 无法解析为 PerformExpr 节点，或编译未开启
Effect Handlers实验特性时抛出。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 PerformExpr 对象
let performExpr = PerformExpr(quote(perform Effect()))
// 转化为 Tokens 并输出
println("performExpr.toTokens(): ${performExpr.toTokens()}")
}
运行结果：
performExpr.toTokens(): perform Effect()
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 PerformExpr 对象
let performExpr = PerformExpr()
// 设置 PerformExpr 的属性
performExpr.keyword = Token(TokenKind.PERFORM)
performExpr.expr = CallExpr(quote(Eff()))
// 转化为 Tokens 并输出
println("performExpr.toTokens(): ${performExpr.toTokens()}")
}
运行结果：
performExpr.toTokens(): perform Eff()
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PerformExpr) {
println("Visiting PerformExpr")
}
}
main(): Unit {
// 构造一个默认的 PerformExpr 对象
let performExpr = PerformExpr()
// 设置 PerformExpr 的属性
performExpr.keyword = Token(TokenKind.PERFORM)
performExpr.expr = CallExpr(quote(Effect()))
// 使用自定义访问器遍历 PerformExpr 节点
performExpr.traverse(MyVisitor())
}
运行结果：
Visiting PerformExpr
class PrefixType
public class PrefixType <: TypeNode {
public init(inputs: Tokens)
public init()
}
功能：表示带问号的前缀类型节点。
例如 var a : ?A 中的 ?A。
父类型：
prop baseType
public mut prop baseType: TypeNode
功能：获取或设置 PrefixType 节点中的类型节点，如 var a: ?A 中的 A。
类型：TypeNode
prop prefixOps
public mut prop prefixOps: Tokens
功能：获取或设置 PrefixType 节点中前缀操作符集合。
类型：Tokens
init()
public init()
功能：构造一个默认的 PrefixType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 PrefixType 对象
let prefixType = PrefixType()
// 设置 PrefixType 的属性
prefixType.prefixOps = quote(?)
prefixType.baseType = PrimitiveType(quote(Int8))
// 转化为 Tokens 并输出
println("prefixType.toTokens(): ${prefixType.toTokens()}")
}
运行结果：
prefixType.toTokens(): ?Int8
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 PrefixType 对象。
参数：
- inputs: Tokens - 将要构造 PrefixType 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 PrefixType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 PrefixType 对象
let prefixType = PrefixType(quote(?Int32))
// 转化为 Tokens 并输出
println("prefixType.toTokens(): ${prefixType.toTokens()}")
}
运行结果：
prefixType.toTokens(): ?Int32
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 PrefixType 对象
let prefixType = PrefixType(quote(?Int32))
// 转化为 Tokens 并输出
println("prefixType.toTokens(): ${prefixType.toTokens()}")
}
运行结果：
prefixType.toTokens(): ?Int32
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PrefixType) {
println("Visiting PrefixType")
}
}
main(): Unit {
// 创建一个 PrefixType 对象
let prefixType = PrefixType(quote(?Int32))
// 使用自定义访问器遍历 PrefixType 节点
prefixType.traverse(MyVisitor())
}
运行结果：
Visiting PrefixType
class PrimaryCtorDecl
public class PrimaryCtorDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示一个主构造函数节点。
主构造函数节点由修饰符，主构造函数名，形参列表和主构造函数体构成。
父类型：
prop block
public mut prop block: Block
功能：获取或设置 PrimaryCtorDecl 节点的主构造函数体。
类型：Block
prop funcParams
public mut prop funcParams: ArrayList<FuncParam>
功能：获取或设置 PrimaryCtorDecl 节点的参数。
prop lParen
public mut prop lParen: Token
功能：获取或设置 PrimaryCtorDecl 节点的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 PrimaryCtorDecl 节点的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 PrimaryCtorDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 PrimaryCtorDecl 对象
let primaryCtorDecl = PrimaryCtorDecl()
// 设置 PrimaryCtorDecl 的属性
primaryCtorDecl.identifier = quote(Ctor)[0]
primaryCtorDecl.lParen = Token(TokenKind.LPAREN)
primaryCtorDecl.rParen = Token(TokenKind.RPAREN)
// 设置参数
let param1 = FuncParam(quote(x: Int8))
primaryCtorDecl.funcParams = ArrayList<FuncParam>([param1])
// 设置代码块
let block = Block()
block.lBrace = Token(TokenKind.LCURL)
block.rBrace = Token(TokenKind.RCURL)
primaryCtorDecl.block = block
// 转化为 Tokens 并输出
println("primaryCtorDecl.toTokens(): ${primaryCtorDecl.toTokens()}")
}
运行结果：
primaryCtorDecl.toTokens(): Ctor(x: Int8) {
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 PrimaryCtorDecl 对象。
参数：
- inputs: Tokens - 将要构造 PrimaryCtorDecl 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 PrimaryCtorDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 PrimaryCtorDecl 对象
let primaryCtorDecl = PrimaryCtorDecl(quote(Ctor(x: Int8) { super(x) }))
// 转化为 Tokens 并输出
println("primaryCtorDecl.toTokens(): ${primaryCtorDecl.toTokens()}")
}
运行结果：
primaryCtorDecl.toTokens(): Ctor(x: Int8) {
super(x)
}
func isConst()
public func isConst(): Bool
功能：判断是否是一个 Const 类型的节点。
返回值：
- Bool - 当前节点为
Const类型的节点时，返回 true；反之，返回 false。
示例：
import std.ast.*
main(): Unit {
// 创建一个 PrimaryCtorDecl 对象
let primaryCtorDecl = PrimaryCtorDecl()
println("primaryCtorDecl.isConst(): ${primaryCtorDecl.isConst()}")
}
运行结果：
primaryCtorDecl.isConst(): false
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 PrimaryCtorDecl 对象
let primaryCtorDecl = PrimaryCtorDecl(quote(Ctor(x: Int8) { super(x) }))
// 转化为 Tokens 并输出
println("primaryCtorDecl.toTokens(): ${primaryCtorDecl.toTokens()}")
}
运行结果：
primaryCtorDecl.toTokens(): Ctor(x: Int8) {
super(x)
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PrimaryCtorDecl) {
println("Visiting PrimaryCtorDecl")
}
}
main(): Unit {
// 创建一个 PrimaryCtorDecl 对象
let primaryCtorDecl = PrimaryCtorDecl(quote(Ctor(x: Int8) { super(x) }))
// 使用自定义访问器遍历 PrimaryCtorDecl 节点
primaryCtorDecl.traverse(MyVisitor())
}
运行结果：
Visiting PrimaryCtorDecl
class PrimitiveType
public class PrimitiveType <: TypeNode {
public init(inputs: Tokens)
public init()
}
功能：表示一个基本类型节点。
例如数值类型，Rune 类型，布尔类型等。
父类型：
prop keyword
public mut prop keyword: Token
功能：获取或设置构造 PrimitiveType 类型的关键字，如 Int8。
类型：Token
init()
public init()
功能：构造一个默认的 PrimitiveType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 PrimitiveType 对象
let primitiveType = PrimitiveType()
// 设置 PrimitiveType 的属性
primitiveType.keyword = Token(TokenKind.INT8, "Int8")
// 输出 PrimitiveType 节点转化成的 Tokens
println("primitiveType.toTokens(): ${primitiveType.toTokens()}")
}
运行结果：
primitiveType.toTokens(): Int8
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 PrimitiveType 对象。
参数：
- inputs: Tokens - 将要构造 PrimitiveType 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 PrimitiveType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 使用 quote 宏创建 Tokens
let tokens = quote(Int8)
// 使用 Tokens 构造 PrimitiveType 对象
let primitiveType = PrimitiveType(tokens)
// 输出 PrimitiveType 节点转化成的 Tokens
println("primitiveType.toTokens(): ${primitiveType.toTokens()}")
}
运行结果：
primitiveType.toTokens(): Int8
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 PrimitiveType 对象
let primitiveType = PrimitiveType(quote(Int8))
// 输出 PrimitiveType 节点转化成的 Tokens
println("primitiveType.toTokens(): ${primitiveType.toTokens()}")
}
运行结果：
primitiveType.toTokens(): Int8
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PrimitiveType) {
println("Visiting PrimitiveType")
}
}
main(): Unit {
// 创建一个 PrimitiveType 对象
let primitiveType = PrimitiveType(quote(Int8))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 PrimitiveType 节点
primitiveType.traverse(visitor)
}
运行结果：
Visiting PrimitiveType
class PrimitiveTypeExpr
public class PrimitiveTypeExpr <: Expr {
public init(kind: Tokens)
public init()
}
功能：表示基本类型表达式节点。
PrimitiveTypeExpr 节点：编译器内置的基本类型作为表达式出现在节点中。如 Int64.toSting() 中的 Int64。
父类型：
prop keyword
public mut prop keyword: Token
功能：获取或设置 PrimitiveTypeExpr 中的基本类型关键字。
类型：Token
init()
public init()
功能：构造一个默认的 PrimitiveTypeExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 PrimitiveTypeExpr 对象
let primitiveTypeExpr = PrimitiveTypeExpr()
// 设置 PrimitiveTypeExpr 的属性
primitiveTypeExpr.keyword = Token(TokenKind.INT8, "Int8")
// 输出 PrimitiveTypeExpr 节点转化成的 Tokens
println("primitiveTypeExpr.toTokens(): ${primitiveTypeExpr.toTokens()}")
}
运行结果：
primitiveTypeExpr.toTokens(): Int8
init(Tokens)
public init(kind: Tokens)
功能：构造一个 PrimitiveTypeExpr 对象。
参数：
- kind: Tokens - 将要构造 PrimitiveTypeExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 PrimitiveTypeExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 使用 quote 宏创建 Tokens
let tokens = quote(Int8)
// 使用 Tokens 构造 PrimitiveTypeExpr 对象
let primitiveTypeExpr = PrimitiveTypeExpr(tokens)
// 输出 PrimitiveTypeExpr 节点转化成的 Tokens
println("primitiveTypeExpr.toTokens(): ${primitiveTypeExpr.toTokens()}")
}
运行结果：
primitiveTypeExpr.toTokens(): Int8
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 PrimitiveTypeExpr 对象
let primitiveTypeExpr = PrimitiveTypeExpr(quote(Int8))
// 输出 PrimitiveTypeExpr 节点转化成的 Tokens
println("primitiveTypeExpr.toTokens(): ${primitiveTypeExpr.toTokens()}")
}
运行结果：
primitiveTypeExpr.toTokens(): Int8
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PrimitiveTypeExpr) {
println("Visiting PrimitiveTypeExpr")
}
}
main(): Unit {
// 创建一个 PrimitiveTypeExpr 对象
let primitiveTypeExpr = PrimitiveTypeExpr(quote(Int8))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 PrimitiveTypeExpr 节点
primitiveTypeExpr.traverse(visitor)
}
运行结果：
Visiting PrimitiveTypeExpr
class Program
public class Program <: Node {
public init(inputs: Tokens)
public init()
}
功能：表示一个仓颉源码文件节点。
一个仓颉源码文件节点主要包括包定义节点，包导入节点和 TopLevel 作用域内的所有声明节点。
说明：
任何一个仓颉源码文件都可以被解析为一个 Program 类型。
父类型：
prop decls
public mut prop decls: ArrayList<Decl>
功能：获取或设置仓颉源码文件中 TopLevel 作用域内定义的声明节点列表。
prop featuresDirective
public mut prop featuresDirective: Option<FeaturesDirective>
功能：获取或设置仓颉源码文件中 TopLevel 作用域内定义的 features 声明节点。
prop importLists
public mut prop importLists: ArrayList<ImportList>
功能：获取或设置仓颉源码文件中包导入节点 ImportList 的列表。
类型：ArrayList<ImportList>
prop packageHeader
public mut prop packageHeader: PackageHeader
功能：获取或设置仓颉源码文件中包的声明节点 PackageHeader。
init()
public init()
功能：构造一个默认的 Program 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 Program 对象
let program = Program()
// 设置 Program 的属性
program.packageHeader = PackageHeader(quote(package test))
program.importLists = ArrayList<ImportList>()
program.decls = ArrayList<Decl>()
// 转化为 Tokens 并输出
println("program.toTokens(): ${program.toTokens()}")
}
运行结果：
program.toTokens(): package test
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 Program 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为一个文件节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 Program 对象
let program = Program(quote(let a = 1))
// 转化为 Tokens 并输出
println("program.toTokens(): ${program.toTokens()}")
}
运行结果：
program.toTokens(): let a = 1
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 Program 对象
let program = Program(quote(let a = 1))
// 转化为 Tokens 并输出
println("program.toTokens(): ${program.toTokens()}")
}
运行结果：
program.toTokens(): let a = 1
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Program) {
println("Visiting Program")
}
}
main(): Unit {
// 创建一个 Program 对象
let program = Program(quote(let a = 1))
// 使用自定义访问器遍历 Program 节点
program.traverse(MyVisitor())
}
运行结果：
Visiting Program
class PropDecl
public class PropDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示一个属性定义节点。
一个 PropDecl 节点：prop X: Int64 { get() { 0 } }。
父类型：
prop colon
public mut prop colon: Token
功能：获取或设置 PropDecl 节点的冒号。
类型：Token
异常：
- ASTException - 当设置的 Token 不是冒号时，抛出异常。
prop declType
public mut prop declType : TypeNode
功能：获取或设置 PropDecl 节点的返回类型。
类型：TypeNode
prop getter
public mut prop getter: FuncDecl
功能：获取或设置 PropDecl 节点的 getter 函数。
类型：FuncDecl
异常：
- ASTException - 当 PropDecl 节点不存在 getter 函数时，抛出异常。
prop lBrace
public mut prop lBrace: Token
功能：获取或设置 PropDecl 节点的 "{"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "{" 时，抛出异常。
prop rBrace
public mut prop rBrace: Token
功能：获取或设置 PropDecl 节点的 "}"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "}" 时，抛出异常。
prop setter
public mut prop setter: FuncDecl
功能：获取或设置 PropDecl 节点的 setter 函数。
类型：FuncDecl
异常：
- ASTException - 当 PropDecl 节点不存在 setter 函数时，抛出异常。
init()
public init()
功能：构造一个默认的 PropDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 PropDecl 对象
let propDecl = PropDecl()
// 设置 PropDecl 的属性
propDecl.keyword = quote(prop)[0]
propDecl.identifier = quote(testProp)[0]
propDecl.colon = Token(TokenKind.COLON)
propDecl.declType = PrimitiveType(quote(Int8))
propDecl.lBrace = Token(TokenKind.LCURL)
propDecl.rBrace = Token(TokenKind.RCURL)
// 转化为 Tokens 并输出
println("propDecl.toTokens(): ${propDecl.toTokens()}")
}
运行结果：
propDecl.toTokens(): prop testProp: Int8 {
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 PropDecl 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 PropDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 PropDecl 对象
let propDecl = PropDecl(quote(prop x: Int32 { get() { 0 } }))
// 转化为 Tokens 并输出
println("propDecl.toTokens(): ${propDecl.toTokens()}")
}
运行结果：
propDecl.toTokens(): prop x: Int32 {
get() {
0
}
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个带实际值的 PropDecl 对象
let propDecl = PropDecl(quote(prop x: Int32 { get() { 0 } }))
// 转化为 Tokens 并输出
println("propDecl.toTokens(): ${propDecl.toTokens()}")
}
运行结果：
propDecl.toTokens(): prop x: Int32 {
get() {
0
}
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PropDecl) {
println("Visiting PropDecl")
}
}
main(): Unit {
// 创建一个 PropDecl 对象
let propDecl = PropDecl(quote(prop x: Int32 { get() { 0 } }))
// 使用自定义访问器遍历 PropDecl 节点
propDecl.traverse(MyVisitor())
}
运行结果：
Visiting PropDecl
class QualifiedType
public class QualifiedType <: TypeNode {
public init(inputs: Tokens)
public init()
}
功能：表示一个用户自定义成员类型。
例如 var a : T.a 中的 T.a, 其中 T 是包名，a 是从 T 包中导入的类型。
父类型：
prop baseType
public mut prop baseType: TypeNode
功能：获取或设置 QualifiedType 节点的成员访问类型主体，如 var a : T.a 中的 T。
类型：TypeNode
prop commas
public mut prop commas: Tokens
功能：获取或设置 QualifiedType 节点中的 "," 词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop dot
public mut prop dot: Token
功能：获取或设置 QualifiedType 节点中的 "." 。
类型：Token
异常：
- ASTException - 当设置的 Tokens 不是 "." 词法单元时，抛出异常。
prop identifier
public mut prop identifier: Token
功能：获取或设置 QualifiedType 节点成员的标识符，如 var a : T.a 中的 a。
类型：Token
prop lAngle
public mut prop lAngle: Token
功能：获取或设置 QualifiedType 节点中的左尖括号词法单元，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是左尖括号时，抛出异常。
prop rAngle
public mut prop rAngle: Token
功能：获取或设置 QualifiedType 节点中的右尖括号词法单元，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是右尖括号时，抛出异常。
prop typeArguments
public mut prop typeArguments: ArrayList<TypeNode>
功能：获取或设置 QualifiedType 节点中的实例化类型的列表，如 T.a<Int32> 中的 Int32，列表可能为空。
init()
public init()
功能：构造一个默认的 QualifiedType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 QualifiedType 对象
let qualifiedType = QualifiedType()
// 设置 QualifiedType 的属性
qualifiedType.baseType = RefType(quote(Package))
qualifiedType.identifier = Token(TokenKind.IDENTIFIER, "Type")
qualifiedType.dot = Token(TokenKind.DOT)
qualifiedType.commas = quote(,)
qualifiedType.lAngle = Token(TokenKind.LT)
qualifiedType.rAngle = Token(TokenKind.GT)
qualifiedType.typeArguments = ArrayList<TypeNode>()
// 转化为 Tokens 并输出
println("qualifiedType.toTokens(): ${qualifiedType.toTokens()}")
}
运行结果：
qualifiedType.toTokens(): Package.Type
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 QualifiedType 对象。
参数：
- inputs: Tokens - 将要构造 QualifiedType 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 QualifiedType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 QualifiedType 对象
let qualifiedType = QualifiedType(quote(Package.Type))
// 转化为 Tokens 并输出
println("qualifiedType.toTokens(): ${qualifiedType.toTokens()}")
}
运行结果：
qualifiedType.toTokens(): Package.Type
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 QualifiedType 对象
let qualifiedType = QualifiedType(quote(Package.Type))
// 转化为 Tokens 并输出
println("qualifiedType.toTokens(): ${qualifiedType.toTokens()}")
}
运行结果：
qualifiedType.toTokens(): Package.Type
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: QualifiedType) {
println("Visiting QualifiedType")
}
}
main(): Unit {
// 创建一个 QualifiedType 对象
let qualifiedType = QualifiedType(quote(Package.Type))
// 使用自定义访问器遍历 QualifiedType 节点
qualifiedType.traverse(MyVisitor())
}
运行结果：
Visiting QualifiedType
class QuoteExpr
public class QuoteExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 quote 表达式节点。
一个 QuoteExpr 节点： quote(var ident = 0)。
父类型：
prop exprs
public mut prop exprs: ArrayList<Expr>
功能：获取或设置 QuoteExpr 中由 () 括起的内部引用表达式节点。
prop keyword
public mut prop keyword: Token
功能：获取或设置 QuoteExpr 的 quote 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
quote关键字时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 QuoteExpr 中的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 QuoteExpr 中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 QuoteExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 QuoteExpr 对象
let quoteExpr = QuoteExpr()
// 设置 QuoteExpr 的属性
quoteExpr.keyword = Token(TokenKind.QUOTE)
quoteExpr.lParen = Token(TokenKind.LPAREN)
quoteExpr.rParen = Token(TokenKind.RPAREN)
quoteExpr.exprs = ArrayList<Expr>()
// 转化为 Tokens 并输出
println("quoteExpr.toTokens(): ${quoteExpr.toTokens()}")
}
运行结果：
quoteExpr.toTokens(): quote()
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 QuoteExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 QuoteExpr 节点。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 QuoteExpr 对象
let quoteExpr = QuoteExpr(quote(quote(x + 1)))
// 转化为 Tokens 并输出
println("quoteExpr.toTokens(): ${quoteExpr.toTokens()}")
}
运行结果：
quoteExpr.toTokens(): quote(x + 1)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个带实际值的 QuoteExpr 对象
let quoteExpr = QuoteExpr(quote(quote(x + 1)))
// 转化为 Tokens 并输出
println("quoteExpr.toTokens(): ${quoteExpr.toTokens()}")
}
运行结果：
quoteExpr.toTokens(): quote(x + 1)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: QuoteExpr) {
println("Visiting QuoteExpr")
}
}
main(): Unit {
// 创建一个 QuoteExpr 对象
let quoteExpr = QuoteExpr(quote(quote(x + 1)))
// 使用自定义访问器遍历 QuoteExpr 节点
quoteExpr.traverse(MyVisitor())
}
运行结果：
Visiting QuoteExpr
class QuoteToken
public class QuoteToken <: Expr {}
功能：表示 quote 表达式节点内任意合法的 token。
父类型：
prop tokens
public mut prop tokens: Tokens
功能：获取 QuoteToken 内的 Tokens。
类型：Tokens
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 使用 quote 宏创建 Tokens
let tokens = quote(quote(x + 1))
// 使用 Tokens 构造 QuoteExpr 对象
let quoteExpr = QuoteExpr(tokens)
// 获取一个 QuoteToken 对象
let quoteToken = quoteExpr.exprs[0]
// 转化为 Tokens 并输出
println("quoteToken.toTokens(): ${quoteToken.toTokens()}")
}
运行结果：
quoteToken.toTokens(): x + 1
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: QuoteToken) {
println("Visiting QuoteToken")
}
}
main(): Unit {
// 创建一个 QuoteToken 对象
let tokens = quote(quote(x + 1))
let quoteExpr = QuoteExpr(tokens)
let quoteToken = quoteExpr.exprs[0]
// 使用自定义访问器遍历 QuoteToken 节点
quoteToken.traverse(MyVisitor())
}
运行结果：
Visiting QuoteToken
class RangeExpr
public class RangeExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示包含区间操作符的表达式。
RangeExpr 节点：存在两种 Range 操作符：.. 和 ..=，分别用于创建左闭右开和左闭右闭的 Range 实例。它们的使用方式分别为 start..end:step 和 start..=end:step。
父类型：
prop colon
public mut prop colon: Token
功能：获取或设置 RangeExpr 中的 ":" 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ":" 操作符时，抛出异常。
prop end
public mut prop end: Expr
功能：获取或设置 RangeExpr 中的终止值。
类型：Expr
异常：
- ASTException - 终止表达式省略。只有在 Range<Int64> 类型的实例用在下标操作符
[]为空的场景。
prop op
public mut prop op: Token
功能：获取或设置 RangeExpr 中的 Range 的操作符。
类型：Token
prop start
public mut prop start: Expr
功能：获取或设置 RangeExpr 中的起始值。
类型：Expr
异常：
- ASTException - 起始表达式省略。只有在 Range<Int64> 类型的实例用在下标操作符
[]为空的场景。
prop step
public mut prop step: Expr
功能：获取或设置 RangeExpr 中序列中前后两个元素之间的差值。
类型：Expr
异常：
- ASTException - 当 RangeExpr 中未设置序列前后两个元素之间的差值时，抛出异常。
init()
public init()
功能：构造一个默认的 RangeExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 RangeExpr 对象
let rangeExpr = RangeExpr()
// 设置 RangeExpr 的属性
rangeExpr.start = LitConstExpr(quote(1))
rangeExpr.end = LitConstExpr(quote(5))
rangeExpr.op = Token(TokenKind.RANGEOP)
// 转化为 Tokens 并输出
println("rangeExpr.toTokens(): ${rangeExpr.toTokens()}")
}
运行结果：
rangeExpr.toTokens(): 1 .. 5
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 RangeExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 RangeExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 RangeExpr 对象
let rangeExpr = RangeExpr(quote(1..5))
// 转化为 Tokens 并输出
println("rangeExpr.toTokens(): ${rangeExpr.toTokens()}")
}
运行结果：
rangeExpr.toTokens(): 1 .. 5
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let rangeExpr = RangeExpr(quote(2..=10:2))
// 转化为 Tokens 并输出
println("rangeExpr.toTokens(): ${rangeExpr.toTokens()}")
}
运行结果：
rangeExpr.toTokens(): 2 ..= 10: 2
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: RangeExpr) {
println("Visiting RangeExpr")
}
}
main(): Unit {
let rangeExpr = RangeExpr(quote(1..10))
// 使用自定义访问器遍历 RangeExpr 节点
rangeExpr.traverse(MyVisitor())
}
运行结果：
Visiting RangeExpr
class RefExpr
public class RefExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示引用一个声明的表达式节点。
一个 RefExpr 节点：var b = a + 1 中的 a 是一个 RefExpr。
父类型：
prop commas
public mut prop commas: Tokens
功能：获取或设置 RefExpr 节点中的 "," 词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop identifier
public mut prop identifier: Token
功能：获取或设置 RefExpr 节点中的自定义类型的标识符。
类型：Token
prop lAngle
public mut prop lAngle: Token
功能：获取或设置 RefExpr 节点中的左尖括号。
类型：Token
异常：
- ASTException - 当设置的 Token 不是左尖括号时，抛出异常。
prop rAngle
public mut prop rAngle: Token
功能：获取或设置 RefExpr 节点中的右尖括号。
类型：Token
异常：
- ASTException - 当设置的 Token 不是右尖括号时，抛出异常。
prop typeArguments
public mut prop typeArguments: ArrayList<TypeNode>
功能：获取或设置 RefExpr 节点中的实例化类型。
init()
public init()
功能：构造一个默认的 RefExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 RefExpr 对象
let refExpr = RefExpr()
// 设置 RefExpr 的属性
refExpr.identifier = Token(TokenKind.IDENTIFIER, "myRef")
// 转化为 Tokens 并输出
println("refExpr.toTokens(): ${refExpr.toTokens()}")
}
运行结果：
refExpr.toTokens(): myRef
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 RefExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 RefExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 RefExpr 对象
let refExpr = RefExpr(quote(myRef))
// 转化为 Tokens 并输出
println("refExpr.toTokens(): ${refExpr.toTokens()}")
}
运行结果：
refExpr.toTokens(): myRef
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let refExpr = RefExpr(quote(testRef))
// 转化为 Tokens 并输出
println("refExpr.toTokens(): ${refExpr.toTokens()}")
}
运行结果：
refExpr.toTokens(): testRef
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: RefExpr) {
println("Visiting RefExpr")
}
}
main(): Unit {
let refExpr = RefExpr(quote(myRef))
// 使用自定义访问器遍历 RefExpr 节点
refExpr.traverse(MyVisitor())
}
运行结果：
Visiting RefExpr
class RefType
public class RefType <: TypeNode {
public init(inputs: Tokens)
public init()
}
功能：表示一个非基础类型节点。
例如用户通过 class、struct、enum 等定义的自定义类型，以及 Array、String 等内置类型都可以使用 RefType 表示。例如 var a : A 中的 A。
父类型：
prop commas
public mut prop commas: Tokens
功能：获取或设置 RefType 节点中的 "," 词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop identifier
public mut prop identifier: Token
功能：获取或设置构造 RefType 类型的关键字，如 var a : A = A() 中的 A。
类型：Token
prop lAngle
public mut prop lAngle: Token
功能：获取或设置 RefType 节点中的左尖括号词法单元，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是左尖括号时，抛出异常。
prop rAngle
public mut prop rAngle: Token
功能：获取或设置 RefType 节点中的右尖括号词法单元，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是右尖括号时，抛出异常。
prop typeArguments
public mut prop typeArguments: ArrayList<TypeNode>
功能：获取或设置 RefType 节点中的实例化类型的列表，可能为空，如 var a : Array<Int32> 中的 Int32。
init()
public init()
功能：构造一个默认的 RefType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 RefType 对象
let refType = RefType()
// 设置 RefType 的属性
refType.identifier = Token(TokenKind.IDENTIFIER, "MyType")
// 转化为 Tokens 并输出
println("refType.toTokens(): ${refType.toTokens()}")
}
运行结果：
refType.toTokens(): MyType
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 RefType 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 RefType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 RefType 对象
let refType = RefType(quote(MyType))
// 转化为 Tokens 并输出
println("refType.toTokens(): ${refType.toTokens()}")
}
运行结果：
refType.toTokens(): MyType
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let refType = RefType(quote(TestType))
// 转化为 Tokens 并输出
println("refType.toTokens(): ${refType.toTokens()}")
}
运行结果：
refType.toTokens(): TestType
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: RefType) {
println("Visiting RefType")
}
}
main(): Unit {
let refType = RefType(quote(MyType))
// 使用自定义访问器遍历 RefType 节点
refType.traverse(MyVisitor())
}
运行结果：
Visiting RefType
class ResumeExpr
public class ResumeExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示一个 resume 表达式节点，可选包含 with 和 throwing 子句。
一个 ResumeExpr 节点示例：
resume r with 42。
父类型：
prop keywordR
public mut prop keywordR: Token
功能：获取或设置 resume 关键字的词法单元。
类型：Token
异常：
- ASTException — 当提供的 Token 不是
resume关键字时抛出。
prop keywordW
public mut prop keywordW: Option<Token>
功能：获取或设置 with 关键字的词法单元（如果存在）。
异常：
- ASTException — 当提供的 Token 不是
with关键字时抛出。
prop withExpr
public mut prop withExpr: Option<Expr>
功能：获取或设置 with 关键字之后的表达式。
prop keywordT
public mut prop keywordT: Option<Token>
功能：获取或设置 throwing 关键字的词法单元（如果存在）。
异常：
- ASTException — 当提供的 Token 不是
throwing关键字时抛出。
prop throwingExpr
public mut prop throwingExpr: Option<Expr>
功能：获取或设置 throwing 关键字之后的表达式。
init()
public init()
功能：构造一个默认的 ResumeExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ResumeExpr 对象
let resumeExpr = ResumeExpr()
// 设置 ResumeExpr 的属性
resumeExpr.throwingExpr = Some(CallExpr(quote(Exception("Error from effect"))))
resumeExpr.keywordT = Token(TokenKind.THROWING, "throwing")
// 转化为 Tokens 并输出
println("resumeExpr.toTokens(): ${resumeExpr.toTokens()}")
}
运行结果：
resumeExpr.toTokens(): resume throwing Exception("Error from effect")
init(Tokens)
public init(inputs: Tokens)
功能：从词法单元流构造一个 ResumeExpr 对象。
注意:
编译时需要添加
--experimental和--enable-eh编译选项以支持Effect Handlers特性。
参数：
- inputs: Tokens — 要解析为 ResumeExpr 节点的词法单元集合。
异常：
- ASTException — 当输入的 Tokens 无法解析为 ResumeExpr 节点，或编译未开启
Effect Handlers实验特性时抛出。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ResumeExpr 对象
let resumeExpr = ResumeExpr(quote(resume throwing Exception("Error from effect")))
// 转化为 Tokens 并输出
println("resumeExpr.toTokens(): ${resumeExpr.toTokens()}")
}
运行结果：
resumeExpr.toTokens(): resume throwing Exception("Error from effect")
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ResumeExpr 对象
let resumeExpr = ResumeExpr()
// 设置 ResumeExpr 的属性
resumeExpr.throwingExpr = Some(CallExpr(quote(Exception())))
resumeExpr.keywordT = Token(TokenKind.THROWING, "throwing")
// 转化为 Tokens 并输出
println("resumeExpr.toTokens(): ${resumeExpr.toTokens()}")
}
运行结果：
resumeExpr.toTokens(): resume throwing Exception()
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ResumeExpr) {
println("Visiting ResumeExpr")
}
}
main(): Unit {
// 构造一个默认的 ResumeExpr 对象
let resumeExpr = ResumeExpr()
// 设置 ResumeExpr 的属性
resumeExpr.throwingExpr = Some(CallExpr(quote(Exception())))
resumeExpr.keywordT = Token(TokenKind.THROWING, "throwing")
// 使用自定义访问器遍历 ResumeExpr 节点
resumeExpr.traverse(MyVisitor())
}
运行结果：
Visiting ResumeExpr
class ReturnExpr
public class ReturnExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 return 表达式节点。
一个 ReturnExpr 节点：return 1。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 ReturnExpr 节点中的表达式节点。
类型：Expr
异常：
- ASTException - 当 ReturnExpr 节点没有表达式时，抛出异常。
prop keyword
public mut prop keyword: Token
功能：获取或设置 ReturnExpr 节点中的关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
return关键字时，抛出异常。
init()
public init()
功能：构造一个默认的 ReturnExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ReturnExpr 对象
let returnExpr = ReturnExpr()
// 设置 ReturnExpr 的属性
returnExpr.expr = LitConstExpr(quote(42))
// 转化为 Tokens 并输出
println("returnExpr.toTokens(): ${returnExpr.toTokens()}")
}
运行结果：
returnExpr.toTokens(): return 42
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ReturnExpr 对象。
参数：
- inputs: Tokens - 将要构造 ReturnExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ReturnExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ReturnExpr 对象
let returnExpr = ReturnExpr(quote(return 100))
// 转化为 Tokens 并输出
println("returnExpr.toTokens(): ${returnExpr.toTokens()}")
}
运行结果：
returnExpr.toTokens(): return 100
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let returnExpr = ReturnExpr(quote(return "hello"))
// 转化为 Tokens 并输出
println("returnExpr.toTokens(): ${returnExpr.toTokens()}")
}
运行结果：
returnExpr.toTokens(): return "hello"
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ReturnExpr) {
println("Visiting ReturnExpr")
}
}
main(): Unit {
let returnExpr = ReturnExpr(quote(return))
// 使用自定义访问器遍历 ReturnExpr 节点
returnExpr.traverse(MyVisitor())
}
运行结果：
Visiting ReturnExpr
class SpawnExpr
public class SpawnExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 Spawn 表达式。
一个 SpawnExpr 节点由 spawn 关键字和一个不包含形参的闭包组成，例如：spawn { add(1, 2) }。
父类型：
prop keyword
public mut prop keyword: Token
功能：获取或设置 SpawnExpr 中的 spawn 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
spawn关键字时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 SpawnExpr 中的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop lambdaExpr
public mut prop lambdaExpr: LambdaExpr
功能：获取或设置 SpawnExpr 中的不含形参的闭包。
类型：LambdaExpr
prop rParen
public mut prop rParen: Token
功能：获取或设置 SpawnExpr 中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop threadContext
public mut prop threadContext: Expr
功能：获取或设置 SpawnExpr 中的线程上下文环境表达式。
类型：Expr
异常：
- ASTException - 当 SpawnExpr 中不含有上下文表达式时，抛出异常。
init()
public init()
功能：构造一个默认的 SpawnExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 SpawnExpr 对象
let spawnExpr = SpawnExpr()
// 设置 SpawnExpr 的属性
spawnExpr.lambdaExpr = LambdaExpr(quote({ => println("New thread") }))
// 转化为 Tokens 并输出
println("spawnExpr.toTokens(): ${spawnExpr.toTokens()}")
}
运行结果：
spawnExpr.toTokens(): spawn { =>
println("New thread")
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 SpawnExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 SpawnExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 SpawnExpr 对象
let spawnExpr = SpawnExpr(quote(spawn { add(1, 2) }))
// 转化为 Tokens 并输出
println("spawnExpr.toTokens(): ${spawnExpr.toTokens()}")
}
运行结果：
spawnExpr.toTokens(): spawn { add(1, 2)
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let spawnExpr = SpawnExpr(quote(spawn { add(1, 2) }))
// 转化为 Tokens 并输出
println("spawnExpr.toTokens(): ${spawnExpr.toTokens()}")
}
运行结果：
spawnExpr.toTokens(): spawn { add(1, 2)
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: SpawnExpr) {
println("Visiting SpawnExpr")
}
}
main(): Unit {
let spawnExpr = SpawnExpr(quote(spawn { add(1, 2) }))
// 使用自定义访问器遍历 SpawnExpr 节点
spawnExpr.traverse(MyVisitor())
}
运行结果：
Visiting SpawnExpr
class StructDecl
public class StructDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示一个 Struct 节点。
Struct 的定义使用 struct 关键字，定义依次为：可缺省的修饰符、struct 关键字、struct 名、可选的类型参数、是否指定父接口、可选的泛型约束、struct 体的定义。
父类型：
prop body
public mut prop body: Body
功能：获取或设置 StructDecl 节点的类体。
类型：Body
prop superTypeBitAnds
public mut prop superTypeBitAnds: Tokens
功能：获取或设置 StructDecl 节点的父接口声明中的 & 操作符的词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是
&词法单元序列时，抛出异常。
prop superTypes
public mut prop superTypes: ArrayList<TypeNode>
功能：获取或设置 StructDecl 节点的父接口。
prop upperBound
public mut prop upperBound: Token
功能：获取或设置 <: 操作符。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
<:操作符时，抛出异常。
init()
public init()
功能：构造一个默认的 StructDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 StructDecl 对象
let structDecl = StructDecl()
// 设置 StructDecl 的属性
structDecl.identifier = Token(TokenKind.IDENTIFIER, "Point")
structDecl.keyword = Token(TokenKind.STRUCT)
structDecl.body = Body()
// 转化为 Tokens 并输出
println("structDecl.toTokens(): ${structDecl.toTokens()}")
}
运行结果：
structDecl.toTokens(): struct Point {
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 StructDecl 对象。
参数：
- inputs: Tokens - 将要构造 StructDecl 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 StructDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 StructDecl 对象
let structDecl = StructDecl(quote(struct Person { let name: String }))
// 转化为 Tokens 并输出
println("structDecl.toTokens(): ${structDecl.toTokens()}")
}
运行结果：
structDecl.toTokens(): struct Person {
let name: String
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let structDecl = StructDecl(quote(struct Data { let value: Int64 }))
// 转化为 Tokens 并输出
println("structDecl.toTokens(): ${structDecl.toTokens()}")
}
运行结果：
structDecl.toTokens(): struct Data {
let value: Int64
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: StructDecl) {
println("Visiting StructDecl")
}
}
main(): Unit {
let structDecl = StructDecl(quote(struct Test {}))
// 使用自定义访问器遍历 StructDecl 节点
structDecl.traverse(MyVisitor())
}
运行结果：
Visiting StructDecl
class SubscriptExpr
public class SubscriptExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示索引访问表达式。
SubscriptExpr 节点：用于那些支持索引访问的类型（包括 Array 类型和 Tuple 类型）通过下标来访问其具体位置的元素，如 arr[0]。
父类型：
prop baseExpr
public mut prop baseExpr: Expr
功能：获取或设置 SubscriptExpr 中的表达式。
类型：Expr
prop indexList
public mut prop indexList: ArrayList<Expr>
功能：获取或设置 SubscriptExpr 中的索引表达式序列。
prop lSquare
public mut prop lSquare: Token
功能：获取或设置 SubscriptExpr 中的 "["。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "[" 时，抛出异常。
prop rSquare
public mut prop rSquare: Token
功能：获取或设置 SubscriptExpr 中的 "]"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "]" 时，抛出异常。
init()
public init()
功能：构造一个默认的 SubscriptExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 SubscriptExpr 对象
let subscriptExpr = SubscriptExpr()
// 设置 SubscriptExpr 的属性
subscriptExpr.baseExpr = RefExpr(quote(arr))
subscriptExpr.indexList = ArrayList<Expr>([LitConstExpr(quote(0))])
// 转化为 Tokens 并输出
println("subscriptExpr.toTokens(): ${subscriptExpr.toTokens()}")
}
运行结果：
subscriptExpr.toTokens(): arr[0]
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 SubscriptExpr 对象。
参数：
- inputs: Tokens - 将要构造 SubscriptExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 SubscriptExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 SubscriptExpr 对象
let subscriptExpr = SubscriptExpr(quote(arr[1]))
// 转化为 Tokens 并输出
println("subscriptExpr.toTokens(): ${subscriptExpr.toTokens()}")
}
运行结果：
subscriptExpr.toTokens(): arr[1]
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let subscriptExpr = SubscriptExpr(quote(data[2]))
// 转化为 Tokens 并输出
println("subscriptExpr.toTokens(): ${subscriptExpr.toTokens()}")
}
运行结果：
subscriptExpr.toTokens(): data[2]
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: SubscriptExpr) {
println("Visiting SubscriptExpr")
}
}
main(): Unit {
let subscriptExpr = SubscriptExpr(quote(arr[0]))
// 使用自定义访问器遍历 SubscriptExpr 节点
subscriptExpr.traverse(MyVisitor())
}
运行结果：
Visiting SubscriptExpr
class SynchronizedExpr
public class SynchronizedExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 synchronized 表达式。
一个 SynchronizedExpr 节点由 synchronized 关键字和 StructuredMutex 对以及后面的代码块组成, 例如 synchronized(m) { foo() }。
父类型：
prop block
public mut prop block: Block
功能：获取或设置 SynchronizedExpr 修饰的代码块。
类型：Block
prop keyword
public mut prop keyword: Token
功能：获取或设置 SynchronizedExpr 中的 synchronized 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
synchronized关键字时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 SynchronizedExpr 中的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 SynchronizedExpr 中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop structuredMutex
public mut prop structuredMutex: Expr
功能：获取或设置 SynchronizedExpr 中的 StructuredMutex 的对象。
类型：Expr
init()
public init()
功能：构造一个默认的 SynchronizedExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 SynchronizedExpr 对象
let synchronizedExpr = SynchronizedExpr()
// 设置 SynchronizedExpr 的属性
synchronizedExpr.structuredMutex = RefExpr(quote(lock))
let block = Block()
block.lBrace = Token(TokenKind.LCURL)
block.rBrace = Token(TokenKind.RCURL)
synchronizedExpr.block = block
// 转化为 Tokens 并输出
println("synchronizedExpr.toTokens(): ${synchronizedExpr.toTokens()}")
}
运行结果：
synchronizedExpr.toTokens(): synchronized(lock) {
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 SynchronizedExpr 对象。
参数：
- inputs: Tokens - 将要构造 SynchronizedExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 SynchronizedExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 SynchronizedExpr 对象
let synchronizedExpr = SynchronizedExpr(quote(synchronized(mutex) { }))
// 转化为 Tokens 并输出
println("synchronizedExpr.toTokens(): ${synchronizedExpr.toTokens()}")
}
运行结果：
synchronizedExpr.toTokens(): synchronized(mutex) {
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let synchronizedExpr = SynchronizedExpr(quote(synchronized(obj) { }))
// 转化为 Tokens 并输出
println("synchronizedExpr.toTokens(): ${synchronizedExpr.toTokens()}")
}
运行结果：
synchronizedExpr.toTokens(): synchronized(obj) {
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: SynchronizedExpr) {
println("Visiting SynchronizedExpr")
}
}
main(): Unit {
let synchronizedExpr = SynchronizedExpr(quote(synchronized(lock) { }))
// 使用自定义访问器遍历 SynchronizedExpr 节点
synchronizedExpr.traverse(MyVisitor())
}
运行结果：
Visiting SynchronizedExpr
class ThisType
public class ThisType <: TypeNode {
public init(inputs: Tokens)
public init()
}
功能：表示 This 类型节点。
父类型：
prop keyword
public mut prop keyword: Token
功能：获取或设置 ThisType 节点关键字 This 的词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 ThisType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ThisType 对象
let thisType = ThisType()
// 转化为 Tokens 并输出
println("thisType.toTokens(): ${thisType.toTokens()}")
}
运行结果：
thisType.toTokens(): This
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ThisType 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ThisType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ThisType 对象
let thisType = ThisType(quote(This))
// 转化为 Tokens 并输出
println("thisType.toTokens(): ${thisType.toTokens()}")
}
运行结果：
thisType.toTokens(): This
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let thisType = ThisType(quote(This))
// 转化为 Tokens 并输出
println("thisType.toTokens(): ${thisType.toTokens()}")
}
运行结果：
thisType.toTokens(): This
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ThisType) {
println("Visiting ThisType")
}
}
main(): Unit {
let thisType = ThisType(quote(This))
// 使用自定义访问器遍历 ThisType 节点
thisType.traverse(MyVisitor())
}
运行结果：
Visiting ThisType
class ThrowExpr
public class ThrowExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 throw 表达式节点。
一个 ThrowExpr 节点：throw Exception()。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 ThrowExpr 节点中的表达式节点。
类型：Expr
prop keyword
public mut prop keyword: Token
功能：获取或设置 ThrowExpr 节点中的关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
throw关键字时，抛出异常。
init()
public init()
功能：构造一个默认的 ThrowExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 ThrowExpr 对象
let throwExpr = ThrowExpr()
// 设置 ThrowExpr 的属性
throwExpr.expr = CallExpr(quote(Exception("Error message")))
// 转化为 Tokens 并输出
println("throwExpr.toTokens(): ${throwExpr.toTokens()}")
}
运行结果：
throwExpr.toTokens(): throw Exception("Error message")
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 ThrowExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 ThrowExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 ThrowExpr 对象
let throwExpr = ThrowExpr(quote(throw Exception("Error message")))
// 转化为 Tokens 并输出
println("throwExpr.toTokens(): ${throwExpr.toTokens()}")
}
运行结果：
throwExpr.toTokens(): throw Exception("Error message")
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let throwExpr = ThrowExpr(quote(throw Exception("Error message")))
// 转化为 Tokens 并输出
println("throwExpr.toTokens(): ${throwExpr.toTokens()}")
}
运行结果：
throwExpr.toTokens(): throw Exception("Error message")
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ThrowExpr) {
println("Visiting ThrowExpr")
}
}
main(): Unit {
let throwExpr = ThrowExpr(quote(throw Exception("Error message")))
// 使用自定义访问器遍历 ThrowExpr 节点
throwExpr.traverse(MyVisitor())
}
运行结果：
Visiting ThrowExpr
class Tokens
public open class Tokens <: ToString & Iterable<Token> & ToBytes {
protected var tokens: ArrayList<Token> = ArrayList<Token>(0)
public init()
public init(tokArray: Array<Token>)
public init(tokArrayList: ArrayList<Token>)
}
功能：对 Token 序列进行封装的类型。
父类型：
var tokens
protected var tokens: ArrayList<Token> = ArrayList<Token>(0)
功能：获取或设置内部以ArrayList<Token>格式存储的全部Token。
prop size
public open prop size: Int64
类型：Int64
init()
public init()
功能：构造一个默认的 Tokens 对象。
示例：
import std.ast.*
main(): Unit {
let tokens = Tokens()
// 添加 token
tokens.append(Token(TokenKind.IDENTIFIER, "hello"))
tokens.append(Token(TokenKind.IDENTIFIER, "world"))
// 输出 tokens
println("tokens.toString(): ${tokens.toString()}")
}
运行结果：
tokens.toString(): hello world
init(Array<Token>)
public init(tokArray: Array<Token>)
功能：构造一个 Tokens 对象。
参数：
示例：
import std.ast.*
main(): Unit {
// 创建 Array<Token>
let arr = [Token(TokenKind.AT, "@"), Token(TokenKind.IDENTIFIER, "test")]
// 使用 Array<Token> 构造 Tokens
let tokens = Tokens(arr)
// 输出 tokens
println("tokens.toString(): ${tokens.toString()}")
}
运行结果：
tokens.toString(): @test
init(ArrayList<Token>)
public init(tokArrayList: ArrayList<Token>)
功能：构造一个 Tokens 对象。
参数：
示例：
import std.ast.*
import std.collection.*
main(): Unit {
// 创建 ArrayList<Token>
let arr = ArrayList<Token>([Token(TokenKind.AT, "@"), Token(TokenKind.IDENTIFIER, "test")])
// 使用 ArrayList<Token> 构造 Tokens
let tokens = Tokens(arr)
// 输出 tokens
println("tokens.toString(): ${tokens.toString()}")
}
运行结果：
tokens.toString(): @test
func append(Node)
public func append(node: Node): Tokens
功能：将当前的 Tokens 与传入节点所转换得到的 Tokens 进行拼接。
参数：
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(@M)
tokens.append(ClassDecl(quote(class A {})))
// 输出 tokens
println("tokens.toString(): ${tokens.toString()}")
}
运行结果：
tokens.toString(): @M class A {
}
func append(Token)
public open func append(token: Token): Tokens
功能：将当前的 Tokens 与传入的 Token 进行拼接。
参数：
返回值：
示例：
import std.ast.*
main(): Unit {
let tokens = Tokens()
let token = Token(TokenKind.IDENTIFIER, "test")
// 追加 token
let result = tokens.append(token)
println("result.toString(): ${result.toString()}")
}
运行结果：
result.toString(): test
func append(Tokens)
public open func append(tokens: Tokens): Tokens
功能：在当前的 Tokens 后追加传入的 Tokens 进行拼接（该接口性能较其他拼接函数表现更好）。
参数：
返回值：
示例：
import std.ast.*
main(): Unit {
let tokens = Tokens()
// 追加 tokens
let toks = quote(123)
let result = tokens.append(toks)
println("result.toString(): ${result.toString()}")
}
运行结果：
result.toString(): 123
func concat(Tokens)
public func concat(tokens: Tokens): Tokens
功能：将当前的 Tokens 与传入的 Tokens 进行拼接，返回新的 Tokens 实例。
参数：
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens1 = quote(@M)
let tokens2 = quote(class A {})
let tokens = tokens1.concat(tokens2)
// 输出 tokens
println("tokens.toString(): ${tokens.toString()}")
}
运行结果：
tokens.toString(): @M class A { }
func dump()
public func dump(): Unit
功能：将 Tokens 内所有 Token 的信息打印出来。
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(@M)
// 输出 tokens
println("tokens.dump():")
tokens.dump()
}
运行结果：
tokens.dump():
description: at, token_id: 51, token_literal_value: @, fileID: 1, line: 5, column: 24
description: identifier, token_id: 137, token_literal_value: M, fileID: 1, line: 5, column: 25
func get(Int64)
public open func get(index: Int64): Token
功能：通过索引值获取 Token 元素。
参数：
- index: Int64 - 待索引的数值。
返回值：
异常：
- IndexOutOfBoundsException - 当
index无效时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(@M)
println("tokens.get(1).dump():")
tokens.get(1).dump()
}
运行结果：
tokens.get(1).dump():
description: identifier, token_id: 137, token_literal_value: M, fileID: 1, line: 5, column: 25
func iterator()
public func iterator(): TokensIterator
功能：获取 Tokens 对象中的一个迭代器对象。
返回值：
- TokensIterator - Tokens 对象的迭代器对象。
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(hello world)
// 获取迭代器
let iter = tokens.iterator()
// 获取下一个 token
let nextToken = iter.next()
match (nextToken) {
case Some(token) => println("Next token: ${token.value}")
case None => println("No more tokens")
}
}
运行结果：
Next token: hello
func remove(Int64)
public func remove(index: Int64): Tokens
功能：删除指定位置的 Token 对象。
参数：
返回值：
示例：
import std.ast.*
main(): Unit {
let tokens = Tokens()
tokens.append(Token(TokenKind.IDENTIFIER, "hello"))
tokens.append(Token(TokenKind.IDENTIFIER, "world"))
println("tokens.toString() before remove: ${tokens.toString()}")
// 删除位置为 1 的 tokens
tokens.remove(1)
println("tokens.toString() after remove: ${tokens.toString()}")
}
运行结果：
tokens.toString() before remove: hello world
tokens.toString() after remove: hello
func toBytes()
public func toBytes(): Array<UInt8>
功能：Tokens 类型的序列化。
返回值：
示例：
import std.ast.*
main(): Unit {
let tokens = quote(&)
// 序列化为 Array<UInt8> 后输出
println("tokens.toBytes(): ${tokens.toBytes()}")
}
运行结果：
tokens.toBytes(): [1, 0, 0, 0, 22, 0, 1, 0, 0, 0, 38, 1, 0, 0, 0, 4, 0, 0, 0, 24, 0, 0, 0, 0, 0]
func toString()
public func toString(): String
返回值：
- String - 转化后的字符串。
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(@M)
println("tokens.toString(): ${tokens.toString()}")
}
运行结果：
tokens.toString(): @M
operator func +(Token)
public operator func +(r: Token): Tokens
功能：使用当前 Tokens 与另一个 Token 相加以获取新的 Tokens 实例。
参数：
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens1 = quote(@)
let token = Token(TokenKind.IDENTIFIER, "M")
let tokens = tokens1 + token
// 输出 tokens
println("tokens.toString(): ${tokens.toString()}")
}
运行结果：
tokens.toString(): @M
operator func +(Tokens)
public operator func +(r: Tokens): Tokens
功能：使用当前 Tokens 与 Tokens 相加以获取新的 Tokens 实例。
参数：
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens1 = quote(@M)
let tokens2 = quote(class A {})
let tokens = tokens1 + tokens2
// 输出 tokens
println("tokens.toString(): ${tokens.toString()}")
}
运行结果：
tokens.toString(): @M class A { }
operator func [](Int64)
public operator func [](index: Int64): Token
功能：操作符重载，通过索引值获取对应 Token。
参数：
- index: Int64 - 待索引的数值。
返回值：
异常：
- IndexOutOfBoundsException - 当
index无效时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(@M)
println("tokens[1].dump():")
tokens[1].dump()
}
运行结果：
tokens[1].dump():
description: identifier, token_id: 137, token_literal_value: M, fileID: 1, line: 5, column: 25
operator func [](Range<Int64>)
public open operator func [](range: Range<Int64>): Tokens
功能：操作符重载，通过 range 获取对应 Tokens 切片。
参数：
返回值：
异常：
- IllegalArgumentException - 当
range.step不等于 1 时，抛出异常。 - IndexOutOfBoundsException - 当 range 无效时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = Tokens()
tokens.append(Token(TokenKind.CLASS, "class"))
tokens.append(Token(TokenKind.IDENTIFIER, "A"))
tokens.append(Token(TokenKind.LCURL, "{"))
tokens.append(Token(TokenKind.RCURL, "}"))
// 输出 Tokens 切片
println("tokens[2..].toString(): ${tokens[2..].toString()}")
}
运行结果：
tokens[2..].toString(): { }
class TokensIterator
public class TokensIterator <: Iterator<Token> {
public init(tokens: Tokens)
}
功能：实现 Tokens 的迭代器功能。
父类型：
init(Tokens)
public init(tokens: Tokens)
功能：构造一个 TokensIterator 对象。
参数：
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(hello world)
// 获取迭代器
let iter = TokensIterator(tokens)
// 获取下一个 token
let nextToken = iter.next()
match (nextToken) {
case Some(token) => println("Next token: ${token.value}")
case None => println("No more tokens")
}
}
运行结果：
Next token: hello
func next()
public func next(): Option<Token>
功能：获取迭代器中的下一个值。
返回值：
示例：
import std.ast.*
main(): Unit {
let tokens = quote(hello world)
let iter = TokensIterator(tokens)
// 获取下一个 token
let nextToken = iter.next()
match (nextToken) {
case Some(token) => println("Next token: ${token.value}")
case None => println("No more tokens")
}
}
运行结果：
Next token: hello
func peek()
public func peek(): Option<Token>
功能：获取迭代器中的当前值。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(hello world)
// 获取迭代器
let iter = TokensIterator(tokens)
iter.next()
let curToken = iter.peek()
match (curToken) {
case Some(token) => println("Current token: ${token.value}")
case None => println("No more tokens")
}
}
运行结果：
Current token: hello
func seeing(TokenKind)
public func seeing(kind: TokenKind): Bool
功能：判断当前节点的 Token 类型是否是传入的类型。
参数：
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建 Tokens
let tokens = quote(hello world)
// 获取迭代器
let iter = TokensIterator(tokens)
iter.next()
println("iter.seeing(TokenKind.IDENTIFIER): ${iter.seeing(TokenKind.IDENTIFIER)}")
}
运行结果：
iter.seeing(TokenKind.IDENTIFIER): true
class TrailingClosureExpr
public class TrailingClosureExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示尾随 Lambda 节点。
一个 TrailingClosureExpr 节点将 lambda 表达式放在函数调用的尾部，括号外面，如 f(a){ i => i * i }。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 TrailingClosureExpr 中的表达式。
类型：Expr
prop lambdaExpr
public mut prop lambdaExpr: LambdaExpr
功能：获取或设置 TrailingClosureExpr 中的尾随 lambda。
类型：LambdaExpr
init()
public init()
功能：构造一个默认的 TrailingClosureExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 TrailingClosureExpr 对象
let trailingClosureExpr = TrailingClosureExpr()
// 设置 TrailingClosureExpr 的属性
trailingClosureExpr.expr = CallExpr(quote(f(a)))
trailingClosureExpr.lambdaExpr = LambdaExpr(quote({x => x + 1}))
// 转化为 Tokens 并输出
println("trailingClosureExpr.toTokens(): ${trailingClosureExpr.toTokens()}")
}
运行结果：
trailingClosureExpr.toTokens(): f(a) { x =>
x + 1
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 TrailingClosureExpr 对象。
参数：
- inputs: Tokens - 将要构造 TrailingClosureExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 TrailingClosureExpr 节点。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 TrailingClosureExpr 对象
let trailingClosureExpr = TrailingClosureExpr(quote(f(a){ i => i * i }))
// 转化为 Tokens 并输出
println("trailingClosureExpr.toTokens(): ${trailingClosureExpr.toTokens()}")
}
运行结果：
trailingClosureExpr.toTokens(): f(a) { i =>
i * i
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let trailingClosureExpr = TrailingClosureExpr(quote(f(a){ i }))
// 转化为 Tokens 并输出
println("trailingClosureExpr.toTokens(): ${trailingClosureExpr.toTokens()}")
}
运行结果：
trailingClosureExpr.toTokens(): f(a) { i
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TrailingClosureExpr) {
println("Visiting TrailingClosureExpr")
}
}
main(): Unit {
let trailingClosureExpr = TrailingClosureExpr(quote(f(a){ i => i * i }))
// 使用自定义访问器遍历 TrailingClosureExpr 节点
trailingClosureExpr.traverse(MyVisitor())
}
运行结果：
Visiting TrailingClosureExpr
class TryExpr
public class TryExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 try 表达式节点。
try 表达式包括三个部分：try 块，catch 块和 finally 块。
父类型：
prop catchBlocks
public mut prop catchBlocks: ArrayList<Block>
功能：获取或设置 TryExpr 中的 Catch 块。
prop catchPatterns
public mut prop catchPatterns: ArrayList<Pattern>
功能：获取或设置 TryExpr 中通过模式匹配的方式匹配待捕获的异常序列。
prop finallyBlock
public mut prop finallyBlock: Block
功能：获取或设置 TryExpr 中的关键字 Finally 块。
类型：Block
异常：
- ASTException - 当 TryExpr 节点无
Finally块节点时，抛出异常。
prop handlers
public mut prop handlers: ArrayList<Handler>
功能：获取或设置 Handler 节点列表。
prop keywordF
public mut prop keywordF: Token
功能：获取或设置 TryExpr 中的 finally 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
finally关键字时，抛出异常。
prop keywordT
public mut prop keywordT: Token
功能：获取或设置 TryExpr 中的 try 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
try关键字时，抛出异常。
prop keywordsC
public mut prop keywordsC: Tokens
功能：获取或设置 TryExpr 中的关键字 catch。
类型：Tokens
异常：
- ASTException - 当设置的 Token 不是
catch关键字时，抛出异常。
prop resourceSpec
public mut prop resourceSpec: ArrayList<VarDecl>
功能：获取或设置 TryExpr 中 Try-with-resources 类型表达式的实例化对象序列。
prop tryBlock
public mut prop tryBlock: Block
功能：获取或设置 TryExpr 中由表达式与声明组成的块。
类型：Block
init()
public init()
功能：构造一个默认的 TryExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 TryExpr 对象
let tryExpr = TryExpr()
// 设置 TryExpr 的属性
tryExpr.keywordT = Token(TokenKind.TRY, "try")
// 设置 try Block
let blockT = Block()
blockT.lBrace = Token(TokenKind.LCURL)
blockT.rBrace = Token(TokenKind.RCURL)
blockT.nodes = ArrayList<Node>([parseExpr(quote(throw Exception("I am an Exception!")))])
tryExpr.tryBlock = blockT
// 设置关键字
tryExpr.keywordF = Token(TokenKind.FINALLY, "finally")
// 设置 finally Block
let blockF = Block()
blockF.lBrace = Token(TokenKind.LCURL)
blockF.rBrace = Token(TokenKind.RCURL)
blockF.nodes = ArrayList<Node>([parseExpr(quote(println("I am an Exception!")))])
tryExpr.finallyBlock = blockF
// 转化为 Tokens 并输出
println("tryExpr.toTokens(): ${tryExpr.toTokens()}")
}
运行结果：
tryExpr.toTokens(): try {
throw Exception("I am an Exception!")
} finally {
println("I am an Exception!")
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 TryExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 TryExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 TryExpr 对象
let inputs = quote(try {
throw Exception("I am an Exception!")
} catch (e: Exception) {
println(e)
})
let tryExpr = TryExpr(inputs)
// 转化为 Tokens 并输出
println("tryExpr.toTokens(): ${tryExpr.toTokens()}")
}
运行结果：
tryExpr.toTokens(): try {
throw Exception("I am an Exception!")
} catch(e: Exception) {
println(e)
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let tryExpr = TryExpr(quote(try {
throw Exception("I am an Exception!")
} catch (e: Exception) {
println(e)
}))
// 转化为 Tokens 并输出
println("tryExpr.toTokens(): ${tryExpr.toTokens()}")
}
运行结果：
tryExpr.toTokens(): try {
throw Exception("I am an Exception!")
} catch(e: Exception) {
println(e)
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TryExpr) {
println("Visiting TryExpr")
}
}
main(): Unit {
let tryExpr = TryExpr(quote(try {
throw Exception("I am an Exception!")
} catch (e: Exception) {
println(e)
}))
// 使用自定义访问器遍历 TryExpr 节点
tryExpr.traverse(MyVisitor())
}
运行结果：
Visiting TryExpr
class TupleLiteral
public class TupleLiteral <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示元组字面量节点。
TupleLiteral 节点：使用格式 (expr1, expr2, ... , exprN) 表示，每个 expr 是一个表达式。
父类型：
prop elements
public mut prop elements: ArrayList<Expr>
功能：获取或设置 TupleLiteral 中的表达式列表。
prop lParen
public mut prop lParen: Token
功能：获取或设置 TupleLiteral 中的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 TupleLiteral 中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 TupleLiteral 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 TupleLiteral 对象
let tupleLiteral = TupleLiteral()
// 设置 TupleLiteral 的属性
tupleLiteral.elements = ArrayList<Expr>([LitConstExpr(quote(1))])
// 转化为 Tokens 并输出
println("tupleLiteral.toTokens(): ${tupleLiteral.toTokens()}")
}
运行结果：
tupleLiteral.toTokens(): (1)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 TupleLiteral 对象。
参数：
- inputs: Tokens - 将要构造 TupleLiteral 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 TupleLiteral 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 TupleLiteral 对象
let tupleLiteral = TupleLiteral(quote((1, 2)))
// 转化为 Tokens 并输出
println("tupleLiteral.toTokens(): ${tupleLiteral.toTokens()}")
}
运行结果：
tupleLiteral.toTokens(): (1, 2)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let tupleLiteral = TupleLiteral(quote(("a", "b")))
// 转化为 Tokens 并输出
println("tupleLiteral.toTokens(): ${tupleLiteral.toTokens()}")
}
运行结果：
tupleLiteral.toTokens(): ("a", "b")
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TupleLiteral) {
println("Visiting TupleLiteral")
}
}
main(): Unit {
let tupleLiteral = TupleLiteral(quote((1, 2)))
// 使用自定义访问器遍历 TupleLiteral 节点
tupleLiteral.traverse(MyVisitor())
}
运行结果：
Visiting TupleLiteral
class TuplePattern
public class TuplePattern <: Pattern {
public init()
public init(inputs: Tokens)
}
功能：表示 Tuple 模式节点。
用于 tuple 值的匹配，如 case ("Bob", age) => 1 中的 ("Bob", age)。
父类型：
prop commas
public mut prop commas: Tokens
功能：获取或设置 TuplePattern 节点中的 "," 词法单元序列，可能为空。
类型：Tokens
异常：
- ASTException - 当设置的 Tokens 不是 "," 词法单元序列时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 TuplePattern 节点中的 "(" 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop patterns
public mut prop patterns: ArrayList<Pattern>
功能：获取或设置 TuplePattern 节点中的一组 Pattern 节点。
prop rParen
public mut prop rParen: Token
功能：获取或设置 TuplePattern 节点中的 ")" 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 TuplePattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 TuplePattern 对象
let tuplePattern = TuplePattern()
// 设置 TuplePattern 的属性
tuplePattern.patterns = ArrayList<Pattern>([VarPattern(Token(TokenKind.IDENTIFIER, "a"))])
// 转化为 Tokens 并输出
println("tuplePattern.toTokens(): ${tuplePattern.toTokens()}")
}
运行结果：
tuplePattern.toTokens(): (a)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 TuplePattern 对象。
参数：
- inputs: Tokens - 将要构造 TuplePattern 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 TuplePattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 TuplePattern 对象
let tuplePattern = TuplePattern(quote((a, b)))
// 转化为 Tokens 并输出
println("tuplePattern.toTokens(): ${tuplePattern.toTokens()}")
}
运行结果：
tuplePattern.toTokens(): (a, b)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let tuplePattern = TuplePattern(quote((x, y)))
// 转化为 Tokens 并输出
println("tuplePattern.toTokens(): ${tuplePattern.toTokens()}")
}
运行结果：
tuplePattern.toTokens(): (x, y)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TuplePattern) {
println("Visiting TuplePattern")
}
}
main(): Unit {
let tuplePattern = TuplePattern(quote((a, b)))
// 使用自定义访问器遍历 TuplePattern 节点
tuplePattern.traverse(MyVisitor())
}
运行结果：
Visiting TuplePattern
class TupleType
public class TupleType <: TypeNode {
public init(inputs: Tokens)
public init()
}
功能：表示元组类型节点。
例如 var a : (Int64, Int32) 中的 (Int64, Int32)。
父类型：
prop lParen
public mut prop lParen: Token
功能：获取或设置 TupleType 节点中的 "(" 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 TupleType 节点中的 ")" 词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop types
public mut prop types: ArrayList<TypeNode>
功能：获取或设置 TupleType 节点中的类型节点列表。
init()
public init()
功能：构造一个默认的 TupleType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 TupleType 对象
let tupleType = TupleType()
// 设置 TupleType 的属性
tupleType.types = ArrayList<TypeNode>([PrimitiveType(quote(Int64))])
// 转化为 Tokens 并输出
println("tupleType.toTokens(): ${tupleType.toTokens()}")
}
运行结果：
tupleType.toTokens(): (Int64)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 TupleType 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 TupleType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 TupleType 对象
let tupleType = TupleType(quote((Int64, String)))
// 转化为 Tokens 并输出
println("tupleType.toTokens(): ${tupleType.toTokens()}")
}
运行结果：
tupleType.toTokens(): (Int64, String)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let tupleType = TupleType(quote((Bool, Float64)))
// 转化为 Tokens 并输出
println("tupleType.toTokens(): ${tupleType.toTokens()}")
}
运行结果：
tupleType.toTokens(): (Bool, Float64)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TupleType) {
println("Visiting TupleType")
}
}
main(): Unit {
let tupleType = TupleType(quote((Int64, String)))
// 使用自定义访问器遍历 TupleType 节点
tupleType.traverse(MyVisitor())
}
运行结果：
Visiting TupleType
class TypeAliasDecl
public class TypeAliasDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示类型别名节点。
一个 TypeAliasDecl 节点： type Point2D = Float64。
说明：
该节点中
type作为关键字，紧跟任意的合法标识符，其后的type是任意的 top-level 可见的类型，标识符和type之间使用=进行连接。
父类型：
prop aliasType
public mut prop aliasType: TypeNode
功能：获取或设置将要别名的类型。
类型：TypeNode
prop assign
public mut prop assign: Token
功能：获取或设置标识符和 type 之间的 =。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
=时，抛出异常。
init()
public init()
功能：构造一个默认的 TypeAliasDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 TypeAliasDecl 对象
let typeAliasDecl = TypeAliasDecl()
// 设置 TypeAliasDecl 的属性
typeAliasDecl.keyword = Token(TokenKind.TYPE, "type")
typeAliasDecl.identifier = Token(TokenKind.IDENTIFIER, "MyType")
typeAliasDecl.assign = Token(TokenKind.ASSIGN, "=")
typeAliasDecl.aliasType = PrimitiveType(quote(Float64))
// 转化为 Tokens 并输出
println("typeAliasDecl.toTokens(): ${typeAliasDecl.toTokens()}")
}
运行结果：
typeAliasDecl.toTokens(): type MyType = Float64
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 TypeAliasDecl 对象。
参数：
- inputs: Tokens - 将要构造 TypeAliasDecl 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 TypeAliasDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 TypeAliasDecl 对象
let typeAliasDecl = TypeAliasDecl(quote(type Alias = Int64))
// 转化为 Tokens 并输出
println("typeAliasDecl.toTokens(): ${typeAliasDecl.toTokens()}")
}
运行结果：
typeAliasDecl.toTokens(): type Alias = Int64
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let typeAliasDecl = TypeAliasDecl(quote(type MyString = String))
// 转化为 Tokens 并输出
println("typeAliasDecl.toTokens(): ${typeAliasDecl.toTokens()}")
}
运行结果：
typeAliasDecl.toTokens(): type MyString = String
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TypeAliasDecl) {
println("Visiting TypeAliasDecl")
}
}
main(): Unit {
let typeAliasDecl = TypeAliasDecl(quote(type Test = Int64))
// 使用自定义访问器遍历 TypeAliasDecl 节点
typeAliasDecl.traverse(MyVisitor())
}
运行结果：
Visiting TypeAliasDecl
class TypeConvExpr
public class TypeConvExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示类型转换表达式。
用于实现若干数值类型间的转换。一个 TypeConvExpr 节点：Int8(32)。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 TypeConvExpr 中进行类型转化的原始表达式。
类型：Expr
prop lParen
public mut prop lParen: Token
功能：获取或设置 TypeConvExpr 中的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 TypeConvExpr 中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop targetType
public mut prop targetType: PrimitiveType
功能：获取或设置 TypeConvExpr 中将要转换到的目标类型。
init()
public init()
功能：构造一个默认的 TypeConvExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 TypeConvExpr 对象
let typeConvExpr = TypeConvExpr()
// 设置 TypeConvExpr 的属性
typeConvExpr.targetType = PrimitiveType(quote(Int8))
typeConvExpr.expr = LitConstExpr(quote(42))
// 转化为 Tokens 并输出
println("typeConvExpr.toTokens(): ${typeConvExpr.toTokens()}")
}
运行结果：
typeConvExpr.toTokens(): Int8(42)
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 TypeConvExpr 对象。
参数：
- inputs: Tokens - 将要构造 TypeConvExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 TypeConvExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 TypeConvExpr 对象
let typeConvExpr = TypeConvExpr(quote(Int8(42)))
// 转化为 Tokens 并输出
println("typeConvExpr.toTokens(): ${typeConvExpr.toTokens()}")
}
运行结果：
typeConvExpr.toTokens(): Int8(42)
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let typeConvExpr = TypeConvExpr(quote(Int8(42)))
// 转化为 Tokens 并输出
println("typeConvExpr.toTokens(): ${typeConvExpr.toTokens()}")
}
运行结果：
typeConvExpr.toTokens(): Int8(42)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TypeConvExpr) {
println("Visiting TypeConvExpr")
}
}
main(): Unit {
let typeConvExpr = TypeConvExpr(quote(Int8(42)))
// 使用自定义访问器遍历 TypeConvExpr 节点
typeConvExpr.traverse(MyVisitor())
}
运行结果：
Visiting TypeConvExpr
class TypeNode
public open class TypeNode <: Node {}
功能：所有类型节点的父类，继承自 Node。
父类型：
prop colon
public mut prop colon: Token
功能：获取或设置 TypeNode 节点中的操作符 ":"，可能为 ILLEGAL 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ":" 操作符时，抛出异常。
prop typeParameterName
public mut prop typeParameterName: Token
功能：获取或设置类型节点的参数，如：(p1:Int64, p2:Int64) 中的 p1 和 p2，可能为 ILLEGAL 的词法单元。
类型：Token
func dump(UInt16)
protected open func dump(indent: UInt16): String
功能：将当前语法树节点转化为树形结构的形态并进行打印。
参数：
- indent: UInt16 - 格式化输出的缩进空格数量。
返回值：
- String - 格式化输出内容。
示例：
import std.ast.*
// 在子类中调用
extend FuncType {
public func myDump() {
dump(1)
}
}
main(): Unit {
// 创建 TypeNode 的子类
let typeNode = FuncType(quote(() -> Unit))
println("typeNode.myDump(): ${typeNode.myDump()}")
}
运行结果：
typeNode.myDump(): FuncType {
-ARROW: Token {
value: "->"
kind: ARROW
pos: 12: 38
}
-returnType: PrimitiveType {
-keyword: Token {
value: "Unit"
kind: UNIT
pos: 12: 41
}
}
}
func toTokens()
public open func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
// 创建一个 TypeNode 子类对象 (使用 FuncType 作为示例)
let typeNode = FuncType(quote((Int64) -> Float64))
// 输出 Tokens 信息
println("typeNode.toTokens(): ${typeNode.toTokens()}")
}
运行结果：
typeNode.toTokens(): (Int64) -> Float64
func traverse(Visitor)
public open func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TypeNode) {
breakTraverse()
println("Visiting TypeNode")
}
}
main(): Unit {
// 创建 TypeNode 节点（以 FuncType 为例）
let typeNode = FuncType(quote((Int64) -> Float64))
// 使用自定义访问器遍历 TypeNode 节点
typeNode.traverse(MyVisitor())
}
运行结果：
Visiting TypeNode
class TypePattern
public class TypePattern <: Pattern {
public init()
public init(inputs: Tokens)
}
功能：表示类型模式节点。
用于判断一个值的运行时类型是否是某个类型的子类型，如 case b: Base => 0 中的 b: Base。
父类型：
prop colon
public mut prop colon: Token
功能：获取或设置 TypePattern 节点中的 ":" 操作符的词法单元节点。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ":" 操作符时，抛出异常。
prop pattern
public mut prop pattern: Pattern
功能：获取或设置 TypePattern 节点中的模式节点。
类型：Pattern
prop patternType
public mut prop patternType: TypeNode
功能：获取或设置 TypePattern 节点中的待匹配的模式类型节点。
类型：TypeNode
init()
public init()
功能：构造一个默认的 TypePattern 对象。
示例：
import std.ast.*
main(): Unit {
let typePattern = TypePattern()
// 设置待匹配的模式类型节点
typePattern.patternType = PrimitiveType(quote(Int64))
// 设置类型节点的参数
typePattern.pattern = VarPattern(Token(TokenKind.IDENTIFIER, "a"))
// 输出 TypePattern 节点转化成的 Tokens
println("typePattern.toTokens(): ${typePattern.toTokens()}")
}
运行结果：
typePattern.toTokens(): a: Int64
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 TypePattern 对象。
参数：
- inputs: Tokens - 将要构造 TypePattern 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 TypePattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
let inputs = quote(b: Base)
let typePattern = TypePattern(inputs)
// 输出 TypePattern 节点转化成的 Tokens
println("typePattern.toTokens(): ${typePattern.toTokens()}")
}
运行结果：
typePattern.toTokens(): b: Base
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let typePattern = TypePattern(quote(i: Int64))
// 输出 TypePattern 节点转化成的 Tokens
println("typePattern.toTokens(): ${typePattern.toTokens()}")
}
运行结果：
typePattern.toTokens(): i: Int64
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TypePattern) {
println("Visiting TypePattern")
}
}
main(): Unit {
let typePattern = TypePattern(quote(i: Int64))
// 对 TypePattern 节点进行遍历
typePattern.traverse(MyVisitor())
}
运行结果：
Visiting TypePattern
class UnaryExpr
public class UnaryExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示一个一元操作表达式节点。
父类型：
prop expr
public mut prop expr: Expr
功能：获取或设置 UnaryExpr 节点中的操作数。
类型：Expr
prop op
public mut prop op: Token
功能：获取或设置 UnaryExpr 节点中的一元操作符。
类型：Token
init()
public init()
功能：构造一个默认的 UnaryExpr 对象。
示例：
import std.ast.*
main(): Unit {
let unaryExpr = UnaryExpr()
// 设置一元表达式操作符
unaryExpr.op = Token(TokenKind.NOT, "!")
// 设置操作数
unaryExpr.expr = parseExpr(quote(true))
// 输出 UnaryExpr 节点转化成的 Tokens
println("unaryExpr.toTokens(): ${unaryExpr.toTokens()}")
}
运行结果：
unaryExpr.toTokens(): ! true
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 UnaryExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 UnaryExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
let inputs = quote(!false)
let unaryExpr = UnaryExpr(inputs)
// 输出 UnaryExpr 节点转化成的 Tokens
println("unaryExpr.toTokens(): ${unaryExpr.toTokens()}")
}
运行结果：
unaryExpr.toTokens(): ! false
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let inputs = quote(!false)
let unaryExpr = UnaryExpr(inputs)
// 输出 UnaryExpr 节点转化成的 Tokens
println("unaryExpr.toTokens(): ${unaryExpr.toTokens()}")
}
运行结果：
unaryExpr.toTokens(): ! false
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: UnaryExpr) {
println("Visiting UnaryExpr")
}
}
main(): Unit {
let unaryExpr = UnaryExpr(quote(!true))
// 对 UnaryExpr 节点进行遍历
unaryExpr.traverse(MyVisitor())
}
运行结果：
Visiting UnaryExpr
class VarDecl
public class VarDecl <: Decl {
public init(inputs: Tokens)
public init()
}
功能：表示变量定义节点。
一个 VarDecl 节点: var a: String，var b: Int64 = 1。
说明：
变量的定义主要包括如下几个部分：修饰符、关键字、patternsMaybeIrrefutable、变量类型和变量初始值。
父类型：
prop assign
public mut prop assign: Token
功能：获取或设置 VarDecl 节点中的赋值操作符的位置信息。
类型：Token
异常：
- ASTException - 当设置的 Token 不是赋值操作符时，抛出异常。
prop colon
public mut prop colon: Token
功能：获取或设置 VarDecl 节点中的冒号位置信息。
类型：Token
异常：
- ASTException - 当设置的 Token 不是冒号时，抛出异常。
prop declType
public mut prop declType: TypeNode
功能：获取或设置 VarDecl 节点的变量类型。
类型：TypeNode
异常：
- ASTException - 当 VarDecl 节点没有声明变量类型时，抛出异常。
prop expr
public mut prop expr: Expr
功能：获取或设置 VarDecl 节点的变量初始化节点。
类型：Expr
异常：
- ASTException - 当 VarDecl 节点没有对变量进行初始化时，抛出异常。
prop pattern
public mut prop pattern: Pattern
功能：获取或设置 VarDecl 节点的 pattern 节点。
类型：Pattern
异常：
- ASTException - 当 VarDecl 节点没有声明 pattern 节点时，抛出异常。
init()
public init()
功能：构造一个默认的 VarDecl 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 VarDecl 对象
let varDecl = VarDecl()
// 设置 VarDecl 的属性
varDecl.keyword = Token(TokenKind.VAR, "var")
varDecl.identifier = Token(TokenKind.IDENTIFIER, "counter")
varDecl.assign = Token(TokenKind.ASSIGN, "=")
varDecl.expr = parseExpr(quote(0))
// 转化为 Tokens 并输出
println("varDecl.toTokens(): ${varDecl.toTokens()}")
}
运行结果：
varDecl.toTokens(): var counter = 0
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 VarDecl 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 VarDecl 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 VarDecl 对象
let varDecl = VarDecl(quote(var name = "test"))
// 转化为 Tokens 并输出
println("varDecl.toTokens(): ${varDecl.toTokens()}")
}
运行结果：
varDecl.toTokens(): var name = "test"
func isConst()
public func isConst(): Bool
功能：判断是否是一个 Const 类型的节点。
返回值：
- Bool - 是一个
Const类型的节点返回 true；反之，返回 false。
示例：
import std.ast.*
main(): Unit {
let varDecl = VarDecl(quote(const pi = 3.14))
println("varDecl.isConst(): ${varDecl.isConst()}")
}
运行结果：
varDecl.isConst(): true
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let varDecl = VarDecl(quote(var age = 25))
// 转化为 Tokens 并输出
println("varDecl.toTokens(): ${varDecl.toTokens()}")
}
运行结果：
varDecl.toTokens(): var age = 25
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VarDecl) {
println("Visiting VarDecl")
}
}
main(): Unit {
let varDecl = VarDecl(quote(var a = 0))
// 使用自定义访问器遍历 VarDecl 节点
varDecl.traverse(MyVisitor())
}
运行结果：
Visiting VarDecl
class VarOrEnumPattern
public class VarOrEnumPattern <: Pattern {
public init(identifier: Token)
public init()
}
功能：表示当模式的标识符为 Enum 构造器时的节点。
例如 case RED 中的 RED 为 Enum 构造器。
父类型：
prop identifier
public mut prop identifier: Token
功能：获取或设置 VarOrEnumPattern 节点中的标识符的词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 VarOrEnumPattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 VarOrEnumPattern 对象
let varOrEnumPattern = VarOrEnumPattern()
// 设置 VarOrEnumPattern 的属性
varOrEnumPattern.identifier = Token(TokenKind.IDENTIFIER, "GREEN")
// 转化为 Tokens 并输出
println("varOrEnumPattern.toTokens(): ${varOrEnumPattern.toTokens()}")
}
运行结果：
varOrEnumPattern.toTokens(): GREEN
init(Token)
public init(identifier: Token)
功能：构造一个 VarOrEnumPattern 对象。
参数：
- identifier: Token - 将要构造 VarOrEnumPattern 类型的词法单元。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 VarOrEnumPattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Token 创建 VarOrEnumPattern 对象
let varOrEnumPattern = VarOrEnumPattern(Token(TokenKind.IDENTIFIER, "BLUE"))
// 转化为 Tokens 并输出
println("varOrEnumPattern.toTokens(): ${varOrEnumPattern.toTokens()}")
}
运行结果：
varOrEnumPattern.toTokens(): BLUE
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let varOrEnumPattern = VarOrEnumPattern(Token(TokenKind.IDENTIFIER, "YELLOW"))
// 转化为 Tokens 并输出
println("varOrEnumPattern.toTokens(): ${varOrEnumPattern.toTokens()}")
}
运行结果：
varOrEnumPattern.toTokens(): YELLOW
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VarOrEnumPattern) {
println("Visiting VarOrEnumPattern")
}
}
main(): Unit {
let varOrEnumPattern = VarOrEnumPattern(Token(TokenKind.IDENTIFIER, "PURPLE"))
// 使用自定义访问器遍历 VarOrEnumPattern 节点
varOrEnumPattern.traverse(MyVisitor())
}
运行结果：
Visiting VarOrEnumPattern
class VarPattern
public class VarPattern <: Pattern {
public init(identifier: Token)
public init()
}
功能：表示绑定模式节点。
使用一个合法的标识符表示，如 for (i in 1..10) 中的 i。
父类型：
prop identifier
public mut prop identifier: Token
功能：获取或设置 VarPattern 节点中的标识符符的词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 VarPattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 VarPattern 对象
let varPattern = VarPattern()
// 设置 VarPattern 的属性
varPattern.identifier = Token(TokenKind.IDENTIFIER, "index")
// 转化为 Tokens 并输出
println("varPattern.toTokens(): ${varPattern.toTokens()}")
}
运行结果：
varPattern.toTokens(): index
init(Token)
public init(identifier: Token)
功能：构造一个 VarPattern 对象。
参数：
- identifier: Token - 将要构造 VarPattern 类型的词法单元。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 VarPattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Token 创建 VarPattern 对象
let varPattern = VarPattern(Token(TokenKind.IDENTIFIER, "item"))
// 转化为 Tokens 并输出
println("varPattern.toTokens(): ${varPattern.toTokens()}")
}
运行结果：
varPattern.toTokens(): item
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let varPattern = VarPattern(Token(TokenKind.IDENTIFIER, "value"))
// 转化为 Tokens 并输出
println("varPattern.toTokens(): ${varPattern.toTokens()}")
}
运行结果：
varPattern.toTokens(): value
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若提前终止遍历子节点的行为，可重写 visit 函数并调用 breakTraverse 函数提前终止遍历行为，请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VarPattern) {
println("Visiting VarPattern")
}
}
main(): Unit {
let varPattern = VarPattern(Token(TokenKind.IDENTIFIER, "name"))
// 使用自定义访问器遍历 VarPattern 节点
varPattern.traverse(MyVisitor())
}
运行结果：
Visiting VarPattern
class VArrayExpr
public class VArrayExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 VArray 的实例节点。
一个 VArrayExpr 节点：let arr: VArray<Int64, $5> = VArray<Int64, $5>({ i => i }) 中的 VArray<Int64, $5>({ i => i })。
父类型：
prop arguments
public mut prop arguments: ArrayList<Argument>
功能：获取或设置 VArrayExpr 中的中的初始化参数序列。
prop lParen
public mut prop lParen: Token
功能：获取或设置 VArrayExpr 中的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 VArrayExpr 中的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
prop vArrayType
public mut prop vArrayType: VArrayType
功能：获取或设置 VArrayExpr 的 VArray 类型节点。
类型：VArrayType
init()
public init()
功能：构造一个默认的 VArrayExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 VArrayExpr 对象
let varrayExpr = VArrayExpr()
// 设置 VArrayExpr 的属性
varrayExpr.lParen = Token(TokenKind.LPAREN, "(")
varrayExpr.rParen = Token(TokenKind.RPAREN, ")")
let argument = Argument()
argument.expr = parseExpr(quote({ i => i }))
varrayExpr.arguments.add(argument)
varrayExpr.vArrayType = VArrayType(quote(VArray<Int32, \$5>))
// 转化为 Tokens 并输出
println("varrayExpr.toTokens(): ${varrayExpr.toTokens()}")
}
运行结果：
varrayExpr.toTokens(): VArray < Int32, $5 >({ i =>
i
})
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 VArrayExpr 对象。
参数：
- inputs: Tokens - 将要构造 VArrayExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 VArrayExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 VArrayExpr 对象
let varrayExpr = VArrayExpr(quote(VArray<Int64, \$5>({ i => i })))
// 转化为 Tokens 并输出
println("varrayExpr.toTokens(): ${varrayExpr.toTokens()}")
}
运行结果：
varrayExpr.toTokens(): VArray < Int64, $5 >({ i =>
i
})
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let varrayExpr = VArrayExpr(quote(VArray<Int64, \$5>(repeat: 0)))
// 转化为 Tokens 并输出
println("varrayExpr.toTokens(): ${varrayExpr.toTokens()}")
}
运行结果：
varrayExpr.toTokens(): VArray < Int64, $5 >(repeat: 0)
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若提前终止遍历子节点的行为，可重写 visit 函数并调用 breakTraverse 函数提前终止遍历行为，请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VArrayExpr) {
println("Visiting VArrayExpr")
}
}
main(): Unit {
let varrayExpr = VArrayExpr(quote(VArray<Int64, \$5>({ i => i })))
// 使用自定义访问器遍历 VArrayExpr 节点
varrayExpr.traverse(MyVisitor())
}
运行结果：
Visiting VArrayExpr
class VArrayType
public class VArrayType <: TypeNode {
public init(inputs: Tokens)
public init()
}
功能：表示 VArray 类型节点。
使用泛型 VArray<T, size: Int64> 表示 VArray 类型。
父类型：
prop dollar
public mut prop dollar: Token
功能：获取或设置 VArrayType 节点中的操作符 $ 的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
$词法单元时，抛出异常。
prop elementTy
public mut prop elementTy: TypeNode
功能：获取或设置 VArrayType 节点中的类型变元节点，如 VArray<Int16, $0> 中的 Int16。
类型：TypeNode
prop keyword
public mut prop keyword: Token
功能：获取或设置 VArrayType 节点的关键字 VArray 的词法单元。
类型：Token
prop lAngle
public mut prop lAngle: Token
功能：获取或设置 VArrayType 节点左尖括号的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是左尖括号时，抛出异常。
prop rAngle
public mut prop rAngle: Token
功能：获取或设置 VArrayType 节点右尖括号的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是右尖括号时，抛出异常。
prop size
public mut prop size: Token
功能：获取或设置 VArrayType 节点中类型长度的词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 VArrayType 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 VArrayType 对象
let varrayType = VArrayType()
// 设置 VArrayType 的属性
varrayType.dollar = Token(TokenKind.DOLLAR, "$")
varrayType.keyword = Token(TokenKind.VARRAY, "VArray")
varrayType.elementTy = PrimitiveType(quote(Int32))
varrayType.size = Token(TokenKind.INTEGER_LITERAL, "10")
// 转化为 Tokens 并输出
println("varrayType.toTokens(): ${varrayType.toTokens()}")
}
运行结果：
varrayType.toTokens(): VArray < Int32, $10 >
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 VArrayType 对象。
参数：
- inputs: Tokens - 将要构造 VArrayType 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 VArrayType 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 VArrayType 对象
let varrayType = VArrayType(quote(VArray<Int64, \$5>))
// 转化为 Tokens 并输出
println("varrayType.toTokens(): ${varrayType.toTokens()}")
}
运行结果：
varrayType.toTokens(): VArray < Int64, $5 >
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let varrayType = VArrayType(quote(VArray<Int64, \$5>))
// 转化为 Tokens 并输出
println("varrayType.toTokens(): ${varrayType.toTokens()}")
}
运行结果：
varrayType.toTokens(): VArray < Int64, $5 >
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若提前终止遍历子节点的行为，可重写 visit 函数并调用 breakTraverse 函数提前终止遍历行为，请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VArrayType) {
println("Visiting VArrayType")
}
}
main(): Unit {
let varrayType = VArrayType(quote(VArray<Int64, \$5>))
// 使用自定义访问器遍历 VArrayType 节点
varrayType.traverse(MyVisitor())
}
运行结果：
Visiting VArrayType
class VarOrEnumPattern
public class VarOrEnumPattern <: Pattern {
public init(identifier: Token)
public init()
}
功能：表示当模式的标识符为 Enum 构造器时的节点。
例如 case RED 中的 RED 为 Enum 构造器。
父类型：
prop identifier
public mut prop identifier: Token
功能：获取或设置 VarOrEnumPattern 节点中的标识符的词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 VarOrEnumPattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 VarOrEnumPattern 对象
let varOrEnumPattern = VarOrEnumPattern()
// 设置 VarOrEnumPattern 的属性
varOrEnumPattern.identifier = Token(TokenKind.IDENTIFIER, "GREEN")
// 转化为 Tokens 并输出
println("varOrEnumPattern.toTokens(): ${varOrEnumPattern.toTokens()}")
}
运行结果：
varOrEnumPattern.toTokens(): GREEN
init(Token)
public init(identifier: Token)
功能：构造一个 VarOrEnumPattern 对象。
参数：
- identifier: Token - 将要构造 VarOrEnumPattern 类型的词法单元。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 VarOrEnumPattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Token 创建 VarOrEnumPattern 对象
let varOrEnumPattern = VarOrEnumPattern(Token(TokenKind.IDENTIFIER, "BLUE"))
// 转化为 Tokens 并输出
println("varOrEnumPattern.toTokens(): ${varOrEnumPattern.toTokens()}")
}
运行结果：
varOrEnumPattern.toTokens(): BLUE
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let varOrEnumPattern = VarOrEnumPattern(Token(TokenKind.IDENTIFIER, "YELLOW"))
// 转化为 Tokens 并输出
println("varOrEnumPattern.toTokens(): ${varOrEnumPattern.toTokens()}")
}
运行结果：
varOrEnumPattern.toTokens(): YELLOW
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若提前终止遍历子节点的行为，可重写 visit 函数并调用 breakTraverse 函数提前终止遍历行为，请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VarOrEnumPattern) {
println("Visiting VarOrEnumPattern")
}
}
main(): Unit {
let varOrEnumPattern = VarOrEnumPattern(Token(TokenKind.IDENTIFIER, "PURPLE"))
// 使用自定义访问器遍历 VarOrEnumPattern 节点
varOrEnumPattern.traverse(MyVisitor())
}
运行结果：
Visiting VarOrEnumPattern
class VarPattern
public class VarPattern <: Pattern {
public init(identifier: Token)
public init()
}
功能：表示绑定模式节点。
使用一个合法的标识符表示，如 for (i in 1..10) 中的 i。
父类型：
prop identifier
public mut prop identifier: Token
功能：获取或设置 VarPattern 节点中的标识符符的词法单元。
类型：Token
init()
public init()
功能：构造一个默认的 VarPattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 VarPattern 对象
let varPattern = VarPattern()
// 设置 VarPattern 的属性
varPattern.identifier = Token(TokenKind.IDENTIFIER, "index")
// 转化为 Tokens 并输出
println("varPattern.toTokens(): ${varPattern.toTokens()}")
}
运行结果：
varPattern.toTokens(): index
init(Token)
public init(identifier: Token)
功能：构造一个 VarPattern 对象。
参数：
- identifier: Token - 将要构造 VarPattern 类型的词法单元。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 VarPattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Token 创建 VarPattern 对象
let varPattern = VarPattern(Token(TokenKind.IDENTIFIER, "item"))
// 转化为 Tokens 并输出
println("varPattern.toTokens(): ${varPattern.toTokens()}")
}
运行结果：
varPattern.toTokens(): item
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let varPattern = VarPattern(Token(TokenKind.IDENTIFIER, "value"))
// 转化为 Tokens 并输出
println("varPattern.toTokens(): ${varPattern.toTokens()}")
}
运行结果：
varPattern.toTokens(): value
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若提前终止遍历子节点的行为，可重写 visit 函数并调用 breakTraverse 函数提前终止遍历行为，请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VarPattern) {
println("Visiting VarPattern")
}
}
main(): Unit {
let varPattern = VarPattern(Token(TokenKind.IDENTIFIER, "name"))
// 使用自定义访问器遍历 VarPattern 节点
varPattern.traverse(MyVisitor())
}
运行结果：
Visiting VarPattern
class Visitor
public abstract class Visitor {}
功能：一个抽象类，其内部默认定义了访问不同类型 AST 节点访问（visit）函数。
说明：
visit函数搭配traverse一起使用，可实现对节点的访问和修改, 所有visit函数都有默认为空的实现，可以按需实现需要的visit方法。- 该类需要被继承使用，并允许子类重新定义访问函数。
- 对于有父类的节点类型，
traverse函数的遍历顺序为先遍历当前节点，再遍历父类节点，最后遍历子节点。对于无父类的节点类型，traverse函数先遍历当前节点，再遍历子节点。
func breakTraverse()
public func breakTraverse(): Unit
功能：用于重写 visit 函数中，通过调用该函数来终止继续遍历子节点的行为。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ClassDecl) {
println("Visiting ClassDecl")
}
public override func visit(_: FuncDecl) {
println("Visiting FuncDecl")
// 在 FuncDecl 层级停止遍历
breakTraverse()
}
public override func visit(_: FuncParam) {
// 不会遍历到
println("Visiting FuncParam")
}
}
main(): Unit {
// 创建一个内含 FuncDecl 和 FuncParam 的 ClassDecl 实例
let classDecl = ClassDecl(quote(
class A {
func foo(a: Int64) {}
}
))
// 使用自定义访问器遍历 ClassDecl 节点
classDecl.traverse(MyVisitor())
}
运行结果：
Visiting ClassDecl
Visiting FuncDecl
func needBreakTraverse()
protected func needBreakTraverse(): Bool
功能：用于判断是否需要停止遍历。
注意:
该函数会在判断需要停止遍历后将用于判断的标记位重置，因此若在先调用
breakTraverse()的情况下调用该函数，可能导致上一次breakTraverse()失效，影响遍历的停止。
返回值：
- Bool - 需要停止遍历返回
true；反之，返回false。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ClassDecl) {
println("Visiting ClassDecl")
// 由于 needBreakTraverse() 函数有副作用
// 这里仅作演示，不建议这样使用
breakTraverse()
if (needBreakTraverse()) {
println("Need to break")
breakTraverse()
}
}
}
main(): Unit {
// 创建一个内含 FuncDecl 和 FuncParam 的 ClassDecl 实例
let classDecl = ClassDecl(quote(
class A {
func foo(a: Int64) {}
}
))
// 使用自定义访问器遍历 ClassDecl 节点
classDecl.traverse(MyVisitor())
}
运行结果：
Visiting ClassDecl
Need to break
func visit(Annotation)
protected open func visit(_: Annotation): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: Annotation - Annotation 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Annotation) {
println("Visiting Annotation")
}
}
main(): Unit {
let annotation = Annotation(quote(@!Anno))
// 对 Annotation 节点进行遍历
annotation.traverse(MyVisitor())
}
运行结果：
Visiting Annotation
func visit(Argument)
protected open func visit(_: Argument): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Argument) {
println("Visiting Argument")
}
}
main(): Unit {
let argument = Argument()
argument.expr = RefExpr(quote(value))
// 使用自定义访问器遍历 Argument 节点
argument.traverse(MyVisitor())
}
运行结果：
Visiting Argument
func visit(ArrayLiteral)
protected open func visit(_: ArrayLiteral): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: ArrayLiteral - ArrayLiteral 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ArrayLiteral) {
println("Visiting ArrayLiteral")
}
}
main(): Unit {
let arrayLiteral = ArrayLiteral(quote([1, 2]))
// 使用自定义访问器遍历 ArrayLiteral 节点
arrayLiteral.traverse(MyVisitor())
}
运行结果：
Visiting ArrayLiteral
func visit(AsExpr)
protected open func visit(_: AsExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: AsExpr) {
println("Visiting AsExpr")
}
}
main(): Unit {
let asExpr = AsExpr(quote(a as Int32))
// 使用自定义访问器遍历 AsExpr 节点
asExpr.traverse(MyVisitor())
}
运行结果：
Visiting AsExpr
func visit(AssignExpr)
protected open func visit(_: AssignExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: AssignExpr - AssignExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: AssignExpr) {
println("Visiting AssignExpr")
}
}
main(): Unit {
let assignExpr = AssignExpr(quote(x = 10))
// 使用自定义访问器遍历 AssignExpr 节点
assignExpr.traverse(MyVisitor())
}
运行结果：
Visiting AssignExpr
func visit(BinaryExpr)
protected open func visit(_: BinaryExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: BinaryExpr - BinaryExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: BinaryExpr) {
println("Visiting BinaryExpr")
}
}
main(): Unit {
let binaryExpr = BinaryExpr(quote(1 + 1))
// 使用自定义访问器遍历 BinaryExpr 节点
binaryExpr.traverse(MyVisitor())
}
运行结果：
Visiting BinaryExpr
func visit(Block)
protected open func visit(_: Block): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Block) {
println("Visiting Block")
}
}
main(): Unit {
let block = Block()
// 设置 Block 的属性
block.lBrace = Token(TokenKind.LCURL, "{")
block.rBrace = Token(TokenKind.RCURL, "}")
// 使用自定义访问器遍历 Block 节点
block.traverse(MyVisitor())
}
运行结果：
Visiting Block
func visit(Body)
protected open func visit(_: Body): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
import std.collection.*
class MyVisitor <: Visitor {
public override func visit(_: Body) {
println("Visiting Body")
}
}
main(): Unit {
// 创建 Body 对象
let body = Body()
// 设置 Body 的属性
body.lBrace = Token(TokenKind.LCURL, "{")
body.rBrace = Token(TokenKind.RCURL, "}")
// 使用自定义访问器遍历 Body 节点
body.traverse(MyVisitor())
}
运行结果：
Visiting Body
func visit(CallExpr)
protected open func visit(_: CallExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: CallExpr) {
println("Visiting CallExpr")
}
}
main(): Unit {
let callExpr = CallExpr(quote(foo(42)))
// 使用自定义访问器遍历CallExpr节点
callExpr.traverse(MyVisitor())
}
运行结果：
Visiting CallExpr
func visit(ClassDecl)
protected open func visit(_: ClassDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ClassDecl) {
println("Visiting ClassDecl")
}
}
main(): Unit {
let classDecl = ClassDecl(quote(class Test {}))
// 使用自定义访问器遍历 ClassDecl 节点
classDecl.traverse(MyVisitor())
}
运行结果：
Visiting ClassDecl
func visit(CommandTypePattern)
protected open func visit(_: CommandTypePattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: CommandTypePattern - CommandTypePattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: CommandTypePattern) {
println("Visiting CommandTypePattern")
}
}
main(): Unit {
let commandTypePattern = CommandTypePattern(quote(e: MyEffect))
// 使用自定义访问器遍历 CommandTypePattern 节点
commandTypePattern.traverse(MyVisitor())
}
运行结果：
Visiting CommandTypePattern
func visit(ConstPattern)
protected open func visit(_: ConstPattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: ConstPattern - ConstPattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ConstPattern) {
println("Visiting ConstPattern")
}
}
main(): Unit {
let constPattern = ConstPattern(quote(100))
// 使用自定义访问器遍历ConstPattern节点
constPattern.traverse(MyVisitor())
}
运行结果：
Visiting ConstPattern
func visit(Constructor)
protected open func visit(_: Constructor): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: Constructor - Constructor 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Constructor) {
println("Visiting Constructor")
}
}
main(): Unit {
// 创建 Constructor 对象
let constructor = Constructor()
// 设置标识符为 Month
constructor.identifier = Token(TokenKind.IDENTIFIER, "Month")
// 使用自定义访问器遍历 Constructor 节点
constructor.traverse(MyVisitor())
}
运行结果：
Visiting Constructor
func visit(Decl)
protected open func visit(_: Decl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Decl) {
breakTraverse()
println("Visiting Decl")
}
}
main(): Unit {
// 创建 Decl 节点（以 ClassDecl 为例）
let decl = ClassDecl(quote(class A {}))
// 使用自定义访问器遍历 Decl 节点
decl.traverse(MyVisitor())
}
运行结果：
Visiting Decl
func visit(DoWhileExpr)
protected open func visit(_: DoWhileExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: DoWhileExpr - DoWhileExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: DoWhileExpr) {
println("Visiting DoWhileExpr")
}
}
main(): Unit {
let doWhileExpr = DoWhileExpr(quote(do {} while (false)))
// 使用自定义访问器遍历 DoWhileExpr 节点
doWhileExpr.traverse(MyVisitor())
}
运行结果：
Visiting DoWhileExpr
func visit(EnumDecl)
protected open func visit(_: EnumDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: EnumDecl) {
println("Visiting EnumDecl")
}
}
main(): Unit {
let enumDecl = EnumDecl(quote(enum Status { Pending | Completed }))
// 使用自定义访问器遍历 EnumDecl 节点
enumDecl.traverse(MyVisitor())
}
运行结果：
Visiting EnumDecl
func visit(EnumPattern)
protected open func visit(_: EnumPattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: EnumPattern - EnumPattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: EnumPattern) {
println("Visiting EnumPattern")
}
}
main(): Unit {
let enumPattern = EnumPattern(quote(Error(code)))
// 使用自定义访问器遍历 EnumPattern 节点
enumPattern.traverse(MyVisitor())
}
运行结果：
Visiting EnumPattern
func visit(ExceptTypePattern)
protected open func visit(_: ExceptTypePattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: ExceptTypePattern - ExceptTypePattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ExceptTypePattern) {
println("Visiting ExceptTypePattern")
}
}
main(): Unit {
let exceptTypePattern = ExceptTypePattern(quote(err: RuntimeException))
// 使用自定义访问器遍历 ExceptTypePattern 节点
exceptTypePattern.traverse(MyVisitor())
}
运行结果：
Visiting ExceptTypePattern
func visit(Expr)
protected open func visit(_: Expr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Expr) {
breakTraverse()
println("Visiting Expr")
}
}
main(): Unit {
// 创建 Expr 节点（以 BinaryExpr 为例）
let expr = BinaryExpr(quote(1 + 1))
// 使用自定义访问器遍历 Expr 节点
expr.traverse(MyVisitor())
}
运行结果：
Visiting Expr
func visit(ExtendDecl)
protected open func visit(_: ExtendDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: ExtendDecl - ExtendDecl 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ExtendDecl) {
println("Visiting ExtendDecl")
}
}
main(): Unit {
let extendDecl = ExtendDecl(quote(extend A { func foo() {} }))
// 对 ExtendDecl 节点进行遍历
extendDecl.traverse(MyVisitor())
}
运行结果：
Visiting ExtendDecl
func visit(FeatureId)
protected open func visit(_: FeatureId): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FeatureId) {
println("Visiting FeatureId")
}
}
main(): Unit {
// 构造一个默认的 FeatureId 对象
let featureId = FeatureId()
// 设置 FeatureId 的属性
featureId.identifiers = quote(a b c)
featureId.dots = quote(. .)
// 使用自定义访问器遍历 FeatureId 节点
featureId.traverse(MyVisitor())
}
运行结果：
Visiting FeatureId
func visit(FeaturesDirective)
protected open func visit(_: FeaturesDirective): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: FeaturesDirective - FeaturesDirective 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FeaturesDirective) {
println("Visiting FeaturesDirective")
}
}
main(): Unit {
// 用 Tokens 创建一个 FeaturesDirective 对象
let featuresDirective = FeaturesDirective(quote(features {a, b.c}))
// 使用自定义访问器遍历 FeaturesDirective 节点
featuresDirective.traverse(MyVisitor())
}
运行结果：
Visiting FeaturesDirective
func visit(FeaturesSet)
protected open func visit(_: FeaturesSet): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: FeaturesSet - FeaturesSet 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FeaturesSet) {
println("Visiting FeaturesSet")
}
}
main(): Unit {
// 构造一个默认的 FeaturesSet 对象
let featuresSet = FeaturesSet()
// 设置 FeaturesSet 的属性
let featureId = FeatureId()
featureId.identifiers = quote(a b c)
featureId.dots = quote(. .)
featuresSet.content = ArrayList<FeatureId>([featureId])
featuresSet.lCurl = Token(TokenKind.LCURL, "{")
featuresSet.rCurl = Token(TokenKind.RCURL, "}")
// 使用自定义访问器遍历 FeaturesSet 节点
featuresSet.traverse(MyVisitor())
}
运行结果：
Visiting FeaturesSet
func visit(ForInExpr)
protected open func visit(_: ForInExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ForInExpr) {
println("Visiting ForInExpr")
}
}
main(): Unit {
let forInExpr = ForInExpr(quote(for (i in 1..10) { println(i) }))
// 使用自定义访问器遍历 ForInExpr 节点
forInExpr.traverse(MyVisitor())
}
运行结果：
Visiting ForInExpr
func visit(FuncDecl)
protected open func visit(_: FuncDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FuncDecl) {
println("Visiting FuncDecl")
}
}
main(): Unit {
let funcDecl = FuncDecl(quote(func foo() { println("Hello") }))
// 使用自定义访问器遍历 FuncDecl 节点
funcDecl.traverse(MyVisitor())
}
运行结果：
Visiting FuncDecl
func visit(FuncParam)
protected open func visit(_: FuncParam): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FuncParam) {
println("Visiting FuncParam")
}
}
main(): Unit {
let funcParam = FuncParam(quote(b!: Float64))
// 使用自定义访问器遍历 FuncParam 节点
funcParam.traverse(MyVisitor())
}
运行结果：
Visiting FuncParam
func visit(FuncType)
protected open func visit(_: FuncType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: FuncType) {
println("Visiting FuncType")
}
}
main(): Unit {
let funcType = FuncType(quote((Int32) -> Unit))
// 使用自定义访问器遍历 FuncType 节点
funcType.traverse(MyVisitor())
}
运行结果：
Visiting FuncType
func visit(GenericConstraint)
protected open func visit(_: GenericConstraint): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: GenericConstraint - GenericConstraint 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: GenericConstraint) {
println("Visiting GenericConstraint")
}
}
main(): Unit {
let genericConstraint = GenericConstraint()
// 使用自定义访问器遍历 GenericConstraint 节点
genericConstraint.traverse(MyVisitor())
}
运行结果：
Visiting GenericConstraint
func visit(GenericParam)
protected open func visit(_: GenericParam): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: GenericParam - GenericParam 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: GenericParam) {
println("Visiting GenericParam")
}
}
main(): Unit {
let genericParam = GenericParam(quote(T, U))
// 使用自定义访问器遍历 GenericParam 节点
genericParam.traverse(MyVisitor())
}
运行结果：
Visiting GenericParam
func visit(IfExpr)
protected open func visit(_: IfExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: IfExpr) {
println("Visiting IfExpr")
}
}
main(): Unit {
let ifExpr = IfExpr(quote(if (a < b) { println(a) } else { println(b) }))
// 使用自定义访问器遍历 IfExpr 节点
ifExpr.traverse(MyVisitor())
}
运行结果：
Visiting IfExpr
func visit(ImportContent)
protected open func visit(_: ImportContent): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: ImportContent - ImportContent 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ImportContent) {
println("Visiting ImportContent")
}
}
main(): Unit {
let importContent = ImportContent()
// 使用自定义访问器遍历 ImportContent 节点
importContent.traverse(MyVisitor())
}
运行结果：
Visiting ImportContent
func visit(ImportList)
protected open func visit(_: ImportList): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: ImportList - ImportList 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ImportList) {
println("Visiting ImportList")
}
}
main(): Unit {
let importList = ImportList(quote(import std.ast.RefType as RT))
// 使用自定义访问器遍历 ImportList 节点
importList.traverse(MyVisitor())
}
运行结果：
Visiting ImportList
func visit(IncOrDecExpr)
protected open func visit(_: IncOrDecExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: IncOrDecExpr - IncOrDecExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: IncOrDecExpr) {
println("Visiting IncOrDecExpr")
}
}
main(): Unit {
let incOrDecExpr = IncOrDecExpr(quote(x--))
// 使用自定义访问器遍历 IncOrDecExpr 节点
incOrDecExpr.traverse(MyVisitor())
}
运行结果：
Visiting IncOrDecExpr
func visit(InterfaceDecl)
protected open func visit(_: InterfaceDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: InterfaceDecl - InterfaceDecl 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: InterfaceDecl) {
println("Visiting InterfaceDecl")
}
}
main(): Unit {
let interfaceDecl = InterfaceDecl(quote(interface MyInterface { func foo(): Int64 }))
// 使用自定义访问器遍历 InterfaceDecl 节点
interfaceDecl.traverse(MyVisitor())
}
运行结果：
Visiting InterfaceDecl
func visit(IsExpr)
protected open func visit(_: IsExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: IsExpr) {
println("Visiting IsExpr")
}
}
main(): Unit {
// 创建一个 IsExpr 对象
let isExpr = IsExpr(quote(x is String))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 IsExpr 节点
isExpr.traverse(visitor)
}
运行结果：
Visiting IsExpr
func visit(JumpExpr)
protected open func visit(_: JumpExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: JumpExpr) {
println("Visiting JumpExpr")
}
}
main(): Unit {
// 创建一个 JumpExpr 对象
let jumpExpr = JumpExpr(quote(break))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 JumpExpr 节点
jumpExpr.traverse(visitor)
}
运行结果：
Visiting JumpExpr
func visit(LambdaExpr)
protected open func visit(_: LambdaExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: LambdaExpr - LambdaExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: LambdaExpr) {
println("Visiting LambdaExpr")
}
}
main(): Unit {
// 创建一个 LambdaExpr 对象
let lambdaExpr = LambdaExpr(quote({x: Int => x + 1}))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 LambdaExpr 节点
lambdaExpr.traverse(visitor)
}
运行结果：
Visiting LambdaExpr
func visit(LetPatternExpr)
protected open func visit(_: LetPatternExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: LetPatternExpr - LetPatternExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: LetPatternExpr) {
println("Visiting LetPatternExpr")
}
}
main(): Unit {
// 创建一个 LetPatternExpr 对象
let letPatternExpr = LetPatternExpr(quote(let Some(v) <- x))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 LetPatternExpr 节点
letPatternExpr.traverse(visitor)
}
运行结果：
Visiting LetPatternExpr
func visit(LitConstExpr)
protected open func visit(_: LitConstExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: LitConstExpr - LitConstExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: LitConstExpr) {
println("Visiting LitConstExpr")
}
}
main(): Unit {
// 创建一个 LitConstExpr 对象
let litConstExpr = LitConstExpr(quote(123))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 LitConstExpr 节点
litConstExpr.traverse(visitor)
}
运行结果：
Visiting LitConstExpr
func visit(MacroDecl)
protected open func visit(_: MacroDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MacroDecl) {
println("Visiting MacroDecl")
}
}
main(): Unit {
// 创建一个 MacroDecl 对象
let macroDecl = MacroDecl(quote(public macro M(input: Tokens): Tokens {}))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 MacroDecl 节点
macroDecl.traverse(visitor)
}
运行结果：
Visiting MacroDecl
func visit(MacroExpandDecl)
protected open func visit(_: MacroExpandDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: MacroExpandDecl - MacroExpandDecl 类型的被遍历节点。
示例：
import std.ast.*
// 自定义访问者实现
class MyVisitor <: Visitor {
public override func visit(_: MacroExpandDecl) {
println("Visiting MacroExpandDecl")
}
}
main() {
// 创建一个宏展开声明节点
let macroExpandDecl = MacroExpandDecl(quote(@M class A {}))
// 创建自定义访问者
let visitor = MyVisitor()
// 遍历节点
macroExpandDecl.traverse(visitor)
}
运行结果：
Visiting MacroExpandDecl
func visit(MacroExpandExpr)
protected open func visit(_: MacroExpandExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: MacroExpandExpr - MacroExpandExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MacroExpandExpr) {
println("Visiting MacroExpandExpr")
}
}
main(): Unit {
// 创建一个 MacroExpandExpr 对象
let macroExpandExpr = MacroExpandExpr(quote(@M (a is Int64)))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 MacroExpandExpr 节点
macroExpandExpr.traverse(visitor)
}
运行结果：
Visiting MacroExpandExpr
func visit(MacroExpandParam)
protected open func visit(_: MacroExpandParam): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: MacroExpandParam - MacroExpandParam 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MacroExpandParam) {
println("Visiting MacroExpandParam")
}
}
main(): Unit {
// 构造一个默认的 MacroExpandParam 对象
let macroExpandParam = MacroExpandParam()
// 设置 MacroExpandParam 的属性
macroExpandParam.keyword = Token(TokenKind.AT, "@")
macroExpandParam.identifier = Token(TokenKind.IDENTIFIER, "M")
macroExpandParam.macroInputs = quote(any)
// 使用自定义访问器遍历 MacroExpandParam 节点
macroExpandParam.traverse(MyVisitor())
}
运行结果：
Visiting MacroExpandParam
func visit(MainDecl)
protected open func visit(_: MainDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MainDecl) {
println("Visiting MainDecl")
}
}
main(): Unit {
// 创建一个 MainDecl 对象
let mainDecl = MainDecl(quote(main() { println("Hello World") }))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 MainDecl 节点
mainDecl.traverse(visitor)
}
运行结果：
Visiting MainDecl
func visit(MatchCase)
protected open func visit(_: MatchCase): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MatchCase) {
println("Visiting MatchCase")
}
}
main(): Unit {
// 通过init()创建一个空的 MatchCase 实例
let matchCase = MatchCase()
// 为实例的各个属性赋值
matchCase.keywordC = Token(CASE)
matchCase.expr = BinaryExpr(quote(a > 1))
// 设置代码块
let block = Block()
block.nodes.add(LitConstExpr(quote(true)))
matchCase.block = block
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 MatchCase 节点
matchCase.traverse(visitor)
}
运行结果：
Visiting MatchCase
func visit(MatchExpr)
protected open func visit(_: MatchExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MatchExpr) {
println("Visiting MatchExpr")
}
}
main(): Unit {
// 创建一个 MatchExpr 对象
let matchExpr = MatchExpr(quote(match (x) { case _ => 2 }))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 MatchExpr 节点
matchExpr.traverse(visitor)
}
运行结果：
Visiting MatchExpr
func visit(MemberAccess)
protected open func visit(_: MemberAccess): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: MemberAccess - MemberAccess 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: MemberAccess) {
println("Visiting MemberAccess")
}
}
main(): Unit {
// 创建一个 MemberAccess 对象
let memberAccess = MemberAccess(quote(obj.field))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 MemberAccess 节点
memberAccess.traverse(visitor)
}
运行结果：
Visiting MemberAccess
func visit(Modifier)
protected open func visit(_: Modifier): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Modifier) {
println("Visiting Modifier")
}
}
main(): Unit {
// 创建一个 Modifier 对象
let modifier = Modifier(Token(TokenKind.PUBLIC, "public"))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 Modifier 节点
modifier.traverse(visitor)
}
运行结果：
Visiting Modifier
func visit(Node)
protected open func visit(_: Node): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Node) {
breakTraverse()
println("Visiting Node")
}
}
main(): Unit {
// 创建 Node 节点（以 ClassDecl 为例）
let node = ClassDecl(quote(class A {}))
// 使用自定义访问器遍历 Node 节点
node.traverse(MyVisitor())
}
运行结果：
Visiting Node
func visit(OptionalExpr)
protected open func visit(_: OptionalExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: OptionalExpr - OptionalExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: OptionalExpr) {
println("Visiting OptionalExpr")
}
}
main(): Unit {
// 创建一个 OptionalExpr 对象
let optionalExpr = OptionalExpr(quote(a?))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 OptionalExpr 节点
optionalExpr.traverse(visitor)
}
运行结果：
Visiting OptionalExpr
func visit(PackageHeader)
protected open func visit(_: PackageHeader): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: PackageHeader - PackageHeader 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PackageHeader) {
println("Visiting PackageHeader")
}
}
main(): Unit {
// 创建一个 PackageHeader 对象
let packageHeader = PackageHeader(quote(package myPackage))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 PackageHeader 节点
packageHeader.traverse(visitor)
}
运行结果：
Visiting PackageHeader
func visit(ParenExpr)
protected open func visit(_: ParenExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ParenExpr) {
println("Visiting ParenExpr")
}
}
main(): Unit {
// 创建一个 ParenExpr 对象
let parenExpr = ParenExpr(quote((1 + 2)))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 ParenExpr 节点
parenExpr.traverse(visitor)
}
运行结果：
Visiting ParenExpr
func visit(ParenType)
protected open func visit(_: ParenType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ParenType) {
println("Visiting ParenType")
}
}
main(): Unit {
// 创建一个 ParenType 对象
let parenType = ParenType(quote((Int32)))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 ParenType 节点
parenType.traverse(visitor)
}
运行结果：
Visiting ParenType
func visit(Pattern)
protected open func visit(_: Pattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Pattern) {
breakTraverse()
println("Visiting Pattern")
}
}
main(): Unit {
// 创建 Pattern 节点（以 VarPattern 为例）
let pattern = VarPattern(quote(e)[0])
// 使用自定义访问器遍历 Pattern 节点
pattern.traverse(MyVisitor())
}
运行结果：
Visiting Pattern
func visit(PerformExpr)
protected open func visit(_: PerformExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: PerformExpr - PerformExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PerformExpr) {
println("Visiting PerformExpr")
}
}
main(): Unit {
// 构造一个默认的 PerformExpr 对象
let performExpr = PerformExpr()
// 设置 PerformExpr 的属性
performExpr.keyword = Token(TokenKind.PERFORM)
performExpr.expr = CallExpr(quote(Effect()))
// 使用自定义访问器遍历 PerformExpr 节点
performExpr.traverse(MyVisitor())
}
运行结果：
Visiting PerformExpr
func visit(PrefixType)
protected open func visit(_: PrefixType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: PrefixType - PrefixType 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PrefixType) {
println("Visiting PrefixType")
}
}
main(): Unit {
// 创建一个 PrefixType 对象
let prefixType = PrefixType(quote(?Int32))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 PrefixType 节点
prefixType.traverse(visitor)
}
运行结果：
Visiting PrefixType
func visit(PrimaryCtorDecl)
protected open func visit(_: PrimaryCtorDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: PrimaryCtorDecl - PrimaryCtorDecl 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PrimaryCtorDecl) {
println("Visiting PrimaryCtorDecl")
}
}
main(): Unit {
// 创建一个 PrimaryCtorDecl 对象
let primaryCtorDecl = PrimaryCtorDecl(quote(Ctor(x: Int8) { super(x) }))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 PrimaryCtorDecl 节点
primaryCtorDecl.traverse(visitor)
}
运行结果：
Visiting PrimaryCtorDecl
func visit(PrimitiveType)
protected open func visit(_: PrimitiveType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: PrimitiveType - PrimitiveType 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PrimitiveType) {
println("Visiting PrimitiveType")
}
}
main(): Unit {
// 创建一个 PrimitiveType 对象
let primitiveType = PrimitiveType(quote(Int8))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 PrimitiveType 节点
primitiveType.traverse(visitor)
}
运行结果：
Visiting PrimitiveType
func visit(PrimitiveTypeExpr)
protected open func visit(_: PrimitiveTypeExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: PrimitiveTypeExpr - PrimitiveTypeExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PrimitiveTypeExpr) {
println("Visiting PrimitiveTypeExpr")
}
}
main(): Unit {
// 创建一个 PrimitiveTypeExpr 对象
let primitiveTypeExpr = PrimitiveTypeExpr(quote(Int8))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 PrimitiveTypeExpr 节点
primitiveTypeExpr.traverse(visitor)
}
运行结果：
Visiting PrimitiveTypeExpr
func visit(Program)
protected open func visit(_: Program): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: Program) {
println("Visiting Program")
}
}
main(): Unit {
// 创建一个 Program 对象
let program = Program(quote(let a = 1))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 Program 节点
program.traverse(visitor)
}
运行结果：
Visiting Program
func visit(PropDecl)
protected open func visit(_: PropDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: PropDecl) {
println("Visiting PropDecl")
}
}
main(): Unit {
// 创建一个 PropDecl 对象
let propDecl = PropDecl(quote(prop x: Int32 { get() { 0 } }))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 PropDecl 节点
propDecl.traverse(visitor)
}
运行结果：
Visiting PropDecl
func visit(QualifiedType)
protected open func visit(_: QualifiedType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: QualifiedType - QualifiedType 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: QualifiedType) {
println("Visiting QualifiedType")
}
}
main(): Unit {
// 创建一个 QualifiedType 对象
let qualifiedType = QualifiedType(quote(Package.Type))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 QualifiedType 节点
qualifiedType.traverse(visitor)
}
运行结果：
Visiting QualifiedType
func visit(QuoteExpr)
protected open func visit(_: QuoteExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: QuoteExpr) {
println("Visiting QuoteExpr")
}
}
main(): Unit {
// 创建一个 QuoteExpr 对象
let quoteExpr = QuoteExpr(quote(quote(x + 1)))
// 创建自定义访问器
let visitor = MyVisitor()
// 遍历 QuoteExpr 节点
quoteExpr.traverse(visitor)
}
运行结果：
Visiting QuoteExpr
func visit(QuoteToken)
protected open func visit(_: QuoteToken): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: QuoteToken - QuoteToken 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: QuoteToken) {
println("Visiting QuoteToken")
}
}
main(): Unit {
// 创建一个 QuoteToken 对象
let tokens = quote(quote(x + 1))
let quoteExpr = QuoteExpr(tokens)
let quoteToken = quoteExpr.exprs[0]
// 使用自定义访问器遍历 QuoteToken 节点
quoteToken.traverse(MyVisitor())
}
运行结果：
Visiting QuoteToken
func visit(RangeExpr)
protected open func visit(_: RangeExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: RangeExpr) {
println("Visiting RangeExpr")
}
}
main(): Unit {
let rangeExpr = RangeExpr(quote(1..10))
// 对 RangeExpr 节点进行遍历
rangeExpr.traverse(MyVisitor())
}
运行结果：
Visiting RangeExpr
func visit(RefExpr)
protected open func visit(_: RefExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: RefExpr) {
println("Visiting RefExpr")
}
}
main(): Unit {
let refExpr = RefExpr(quote(myRef))
// 对 RefExpr 节点进行遍历
refExpr.traverse(MyVisitor())
}
运行结果：
Visiting RefExpr
func visit(RefType)
protected open func visit(_: RefType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: RefType) {
println("Visiting RefType")
}
}
main(): Unit {
let refType = RefType(quote(MyType))
// 对 RefType 节点进行遍历
refType.traverse(MyVisitor())
}
运行结果：
Visiting RefType
func visit(ResumeExpr)
protected open func visit(_: ResumeExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: ResumeExpr - ResumeExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ResumeExpr) {
println("Visiting ResumeExpr")
}
}
main(): Unit {
// 构造一个默认的 ResumeExpr 对象
let resumeExpr = ResumeExpr()
// 设置 ResumeExpr 的属性
resumeExpr.throwingExpr = Some(CallExpr(quote(Exception())))
resumeExpr.keywordT = Token(TokenKind.THROWING, "throwing")
// 使用自定义访问器遍历 ResumeExpr 节点
resumeExpr.traverse(MyVisitor())
}
运行结果：
Visiting ResumeExpr
func visit(ReturnExpr)
protected open func visit(_: ReturnExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: ReturnExpr - ReturnExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ReturnExpr) {
println("Visiting ReturnExpr")
}
}
main(): Unit {
let returnExpr = ReturnExpr(quote(return))
// 对 ReturnExpr 节点进行遍历
returnExpr.traverse(MyVisitor())
}
运行结果：
Visiting ReturnExpr
func visit(SpawnExpr)
protected open func visit(_: SpawnExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: SpawnExpr) {
println("Visiting SpawnExpr")
}
}
main(): Unit {
let spawnExpr = SpawnExpr(quote(spawn { add(1, 2) }))
// 对 SpawnExpr 节点进行遍历
spawnExpr.traverse(MyVisitor())
}
运行结果：
Visiting SpawnExpr
func visit(StructDecl)
protected open func visit(_: StructDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: StructDecl - StructDecl 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: StructDecl) {
println("Visiting StructDecl")
}
}
main(): Unit {
let structDecl = StructDecl(quote(struct Test {}))
// 对 StructDecl 节点进行遍历
structDecl.traverse(MyVisitor())
}
运行结果：
Visiting StructDecl
func visit(SubscriptExpr)
protected open func visit(_: SubscriptExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: SubscriptExpr - SubscriptExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: SubscriptExpr) {
println("Visiting SubscriptExpr")
}
}
main(): Unit {
let subscriptExpr = SubscriptExpr(quote(arr[0]))
// 对 SubscriptExpr 节点进行遍历
subscriptExpr.traverse(MyVisitor())
}
运行结果：
Visiting SubscriptExpr
func visit(SynchronizedExpr)
protected open func visit(_: SynchronizedExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: SynchronizedExpr - SynchronizedExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: SynchronizedExpr) {
println("Visiting SynchronizedExpr")
}
}
main(): Unit {
let synchronizedExpr = SynchronizedExpr(quote(synchronized(lock) { }))
// 对 SynchronizedExpr 节点进行遍历
synchronizedExpr.traverse(MyVisitor())
}
运行结果：
Visiting SynchronizedExpr
func visit(ThisType)
protected open func visit(_: ThisType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ThisType) {
println("Visiting ThisType")
}
}
main(): Unit {
let thisType = ThisType(quote(This))
// 对 ThisType 节点进行遍历
thisType.traverse(MyVisitor())
}
运行结果：
Visiting ThisType
func visit(ThrowExpr)
protected open func visit(_: ThrowExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: ThrowExpr) {
println("Visiting ThrowExpr")
}
}
main(): Unit {
let throwExpr = ThrowExpr(quote(throw Exception("Error message")))
// 对 ThrowExpr 节点进行遍历
throwExpr.traverse(MyVisitor())
}
运行结果：
Visiting ThrowExpr
func visit(TrailingClosureExpr)
protected open func visit(_: TrailingClosureExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: TrailingClosureExpr - TrailingClosureExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TrailingClosureExpr) {
println("Visiting TrailingClosureExpr")
}
}
main(): Unit {
let trailingClosureExpr = TrailingClosureExpr(quote(f(a){ i => i * i }))
// 对 TrailingClosureExpr 节点进行遍历
trailingClosureExpr.traverse(MyVisitor())
}
运行结果：
Visiting TrailingClosureExpr
func visit(TryExpr)
protected open func visit(_: TryExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TryExpr) {
println("Visiting TryExpr")
}
}
main(): Unit {
let tryExpr = TryExpr(quote(try {
throw Exception("I am an Exception!")
} catch (e: Exception) {
println(e)
}))
// 对 TryExpr 节点进行遍历
tryExpr.traverse(MyVisitor())
}
运行结果：
Visiting TryExpr
func visit(TupleLiteral)
protected open func visit(_: TupleLiteral): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: TupleLiteral - TupleLiteral 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TupleLiteral) {
println("Visiting TupleLiteral")
}
}
main(): Unit {
let tupleLiteral = TupleLiteral(quote((1, 2)))
// 对 TupleLiteral 节点进行遍历
tupleLiteral.traverse(MyVisitor())
}
运行结果：
Visiting TupleLiteral
func visit(TuplePattern)
protected open func visit(_: TuplePattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: TuplePattern - TuplePattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TuplePattern) {
println("Visiting TuplePattern")
}
}
main(): Unit {
let tuplePattern = TuplePattern(quote((a, b)))
// 对 TuplePattern 节点进行遍历
tuplePattern.traverse(MyVisitor())
}
运行结果：
Visiting TuplePattern
func visit(TupleType)
protected open func visit(_: TupleType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TupleType) {
println("Visiting TupleType")
}
}
main(): Unit {
let tupleType = TupleType(quote((Int64, String)))
// 对 TupleType 节点进行遍历
tupleType.traverse(MyVisitor())
}
运行结果：
Visiting TupleType
func visit(TypeAliasDecl)
protected open func visit(_: TypeAliasDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: TypeAliasDecl - TypeAliasDecl 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TypeAliasDecl) {
println("Visiting TypeAliasDecl")
}
}
main(): Unit {
let typeAliasDecl = TypeAliasDecl(quote(type Test = Int64))
// 对 TypeAliasDecl 节点进行遍历
typeAliasDecl.traverse(MyVisitor())
}
运行结果：
Visiting TypeAliasDecl
func visit(TypeConvExpr)
protected open func visit(_: TypeConvExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: TypeConvExpr - TypeConvExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TypeConvExpr) {
println("Visiting TypeConvExpr")
}
}
main(): Unit {
let typeConvExpr = TypeConvExpr(quote(Int8(42)))
// 对 TypeConvExpr 节点进行遍历
typeConvExpr.traverse(MyVisitor())
}
运行结果：
Visiting TypeConvExpr
func visit(TypeNode)
protected open func visit(_: TypeNode): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TypeNode) {
breakTraverse()
println("Visiting TypeNode")
}
}
main(): Unit {
// 创建 TypeNode 节点（以 FuncType 为例）
let typeNode = FuncType(quote((Int64) -> Float64))
// 使用自定义访问器遍历 TypeNode 节点
typeNode.traverse(MyVisitor())
}
运行结果：
Visiting TypeNode
func visit(TypePattern)
protected open func visit(_: TypePattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: TypePattern - TypePattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: TypePattern) {
println("Visiting TypePattern")
}
}
main(): Unit {
let typePattern = TypePattern(quote(i: Int64))
// 对 TypePattern 节点进行遍历
typePattern.traverse(MyVisitor())
}
运行结果：
Visiting TypePattern
func visit(UnaryExpr)
protected open func visit(_: UnaryExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: UnaryExpr) {
println("Visiting UnaryExpr")
}
}
main(): Unit {
let unaryExpr = UnaryExpr(quote(!true))
// 对 UnaryExpr 节点进行遍历
unaryExpr.traverse(MyVisitor())
}
运行结果：
Visiting UnaryExpr
func visit(VarDecl)
protected open func visit(_: VarDecl): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VarDecl) {
println("Visiting VarDecl")
}
}
main(): Unit {
let varDecl = VarDecl(quote(var a = 0))
// 对 VarDecl 节点进行遍历
varDecl.traverse(MyVisitor())
}
运行结果：
Visiting VarDecl
func visit(VarOrEnumPattern)
protected open func visit(_: VarOrEnumPattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: VarOrEnumPattern - VarOrEnumPattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VarOrEnumPattern) {
println("Visiting VarOrEnumPattern")
}
}
main(): Unit {
let varOrEnumPattern = VarOrEnumPattern(Token(TokenKind.IDENTIFIER, "PURPLE"))
// 对 VarOrEnumPattern 节点进行遍历
varOrEnumPattern.traverse(MyVisitor())
}
运行结果：
Visiting VarOrEnumPattern
func visit(VarPattern)
protected open func visit(_: VarPattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: VarPattern - VarPattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VarPattern) {
println("Visiting VarPattern")
}
}
main(): Unit {
let varPattern = VarPattern(Token(TokenKind.IDENTIFIER, "name"))
// 对 VarPattern 节点进行遍历
varPattern.traverse(MyVisitor())
}
运行结果：
Visiting VarPattern
func visit(VArrayExpr)
protected open func visit(_: VArrayExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: VArrayExpr - VArrayExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VArrayExpr) {
println("Visiting VArrayExpr")
}
}
main(): Unit {
let varrayExpr = VArrayExpr(quote(VArray<Int64, \$5>({ i => i })))
// 对 VArrayExpr 节点进行遍历
varrayExpr.traverse(MyVisitor())
}
运行结果：
Visiting VArrayExpr
func visit(VArrayType)
protected open func visit(_: VArrayType): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: VArrayType - VArrayType 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: VArrayType) {
println("Visiting VArrayType")
}
}
main(): Unit {
let varrayType = VArrayType(quote(VArray<Int64, \$5>))
// 对 VArrayType 节点进行遍历
varrayType.traverse(MyVisitor())
}
运行结果：
Visiting VArrayType
func visit(WhileExpr)
protected open func visit(_: WhileExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: WhileExpr) {
println("Visiting WhileExpr")
}
}
main(): Unit {
let whileExpr = WhileExpr(quote(while(true) {}))
// 对 WhileExpr 节点进行遍历
whileExpr.traverse(MyVisitor())
}
运行结果：
Visiting WhileExpr
func visit(WildcardExpr)
protected open func visit(_: WildcardExpr): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: WildcardExpr - WildcardExpr 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: WildcardExpr) {
println("Visiting WildcardExpr")
}
}
main(): Unit {
let wildcardExpr = WildcardExpr(quote(_))
// 对 WildcardExpr 节点进行遍历
wildcardExpr.traverse(MyVisitor())
}
运行结果：
Visiting WildcardExpr
func visit(WildcardPattern)
protected open func visit(_: WildcardPattern): Unit
功能：定义访问节点时的操作，需要重写。
参数：
- _: WildcardPattern - WildcardPattern 类型的被遍历节点。
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: WildcardPattern) {
println("Visiting WildcardPattern")
}
}
main(): Unit {
let wildcardPattern = WildcardPattern(quote(_))
// 对 WildcardPattern 节点进行遍历
wildcardPattern.traverse(MyVisitor())
}
运行结果：
Visiting WildcardPattern
class WhileExpr
public class WhileExpr <: Expr {
public init(inputs: Tokens)
public init()
}
功能：表示 while 表达式。
while 是关键字，while 之后是一个小括号，小括号内可以是一个表达式或者一个 let 声明的解构匹配，接着是一个 Block 节点。
父类型：
prop block
public mut prop block: Block
功能：获取或设置 WhileExpr 中的块节点。
类型：Block
prop condition
public mut prop condition: Expr
功能：获取或设置关键字 WhileExpr 中的条件表达式。
类型：Expr
prop keyword
public mut prop keyword: Token
功能：获取或设置 WhileExpr 节点中 while 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是
while关键字时，抛出异常。
prop lParen
public mut prop lParen: Token
功能：获取或设置 WhileExpr 中 while 关键字之后的 "("。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "(" 时，抛出异常。
prop rParen
public mut prop rParen: Token
功能：获取或设置 WhileExpr 中 while 关键字之后的 ")"。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 ")" 时，抛出异常。
init()
public init()
功能：构造一个默认的 WhileExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 WhileExpr 对象
let whileExpr = WhileExpr()
// 设置 WhileExpr 的属性
whileExpr.keyword = Token(TokenKind.WHILE, "while")
whileExpr.condition = parseExpr(quote(true))
whileExpr.lParen = Token(TokenKind.LPAREN, "(")
whileExpr.rParen = Token(TokenKind.RPAREN, ")")
let block = Block()
block.lBrace = Token(TokenKind.LCURL)
block.rBrace = Token(TokenKind.RCURL)
whileExpr.block = block
// 转化为 Tokens 并输出
println("whileExpr.toTokens(): ${whileExpr.toTokens()}")
}
运行结果：
whileExpr.toTokens(): while(true) {
}
init(Tokens)
public init(inputs: Tokens)
功能：构造一个 WhileExpr 对象。
参数：
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 WhileExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 WhileExpr 对象
let whileExpr = WhileExpr(quote(while(true) {}))
// 转化为 Tokens 并输出
println("whileExpr.toTokens(): ${whileExpr.toTokens()}")
}
运行结果：
whileExpr.toTokens(): while(true) {
}
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let whileExpr = WhileExpr(quote(while(x < 10) { x++ }))
// 转化为 Tokens 并输出
println("whileExpr.toTokens(): ${whileExpr.toTokens()}")
}
运行结果：
whileExpr.toTokens(): while(x < 10) {
x ++
}
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: WhileExpr) {
println("Visiting WhileExpr")
}
}
main(): Unit {
let whileExpr = WhileExpr(quote(while(true) {}))
// 使用自定义访问器遍历 WhileExpr 节点
whileExpr.traverse(MyVisitor())
}
运行结果：
Visiting WhileExpr
class WildcardExpr
public class WildcardExpr <: Expr {
public init(keyword: Tokens)
public init()
}
功能：表示通配符表达式节点。
父类型：
prop keyword
public mut prop keyword: Token
功能：获取 WildcardExpr 的 "_" 关键字。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "_" 关键字时，抛出异常。
init()
public init()
功能：构造一个默认的 WildcardExpr 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 WildcardExpr 对象
let wildcardExpr = WildcardExpr()
// 设置 WildcardExpr 的属性
wildcardExpr.keyword = Token(TokenKind.WILDCARD, "_")
// 转化为 Tokens 并输出
println("wildcardExpr.toTokens(): ${wildcardExpr.toTokens()}")
}
运行结果：
wildcardExpr.toTokens(): _
init(Tokens)
public init(keyword: Tokens)
功能：构造一个 WildcardExpr 对象。
参数：
- keyword: Tokens - 将要构造 WildcardExpr 类型的词法单元集合 (Tokens)。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 WildcardExpr 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 WildcardExpr 对象
let wildcardExpr = WildcardExpr(quote(_))
// 转化为 Tokens 并输出
println("wildcardExpr.toTokens(): ${wildcardExpr.toTokens()}")
}
运行结果：
wildcardExpr.toTokens(): _
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let wildcardExpr = WildcardExpr(quote(_))
// 转化为 Tokens 并输出
println("wildcardExpr.toTokens(): ${wildcardExpr.toTokens()}")
}
运行结果：
wildcardExpr.toTokens(): _
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: WildcardExpr) {
println("Visiting WildcardExpr")
}
}
main(): Unit {
let wildcardExpr = WildcardExpr(quote(_))
// 使用自定义访问器遍历 WildcardExpr 节点
wildcardExpr.traverse(MyVisitor())
}
运行结果：
Visiting WildcardExpr
class WildcardPattern
public class WildcardPattern <: Pattern {
public init(keyword: Tokens)
public init()
}
功能：表示通配符模式节点。
使用下划线 "_" 表示，可以匹配任意值。
父类型：
prop wildcard
public mut prop wildcard: Token
功能：获取或设置 WildcardPattern 节点中的 "_" 操作符的词法单元。
类型：Token
异常：
- ASTException - 当设置的 Token 不是 "_" 操作符时，抛出异常。
init()
public init()
功能：构造一个默认的 WildcardPattern 对象。
示例：
import std.ast.*
main(): Unit {
// 构造一个默认的 WildcardPattern 对象
let wildcardPattern = WildcardPattern()
// 设置 WildcardPattern 的属性
wildcardPattern.wildcard = Token(TokenKind.WILDCARD, "_")
// 转化为 Tokens 并输出
println("wildcardPattern.toTokens(): ${wildcardPattern.toTokens()}")
}
运行结果：
wildcardPattern.toTokens(): _
init(Tokens)
public init(keyword: Tokens)
功能：构造一个 WildcardPattern 对象。
参数：
- keyword: Tokens - 将要构造 WildcardPattern 类型的词法单元集合（Tokens）。
异常：
- ASTException - 当输入的 Tokens 类型无法构造为 WildcardPattern 节点时，抛出异常。
示例：
import std.ast.*
main(): Unit {
// 从 Tokens 创建 WildcardPattern 对象
let wildcardPattern = WildcardPattern(quote(_))
// 转化为 Tokens 并输出
println("wildcardPattern.toTokens(): ${wildcardPattern.toTokens()}")
}
运行结果：
wildcardPattern.toTokens(): _
func toTokens()
public func toTokens(): Tokens
功能：将当前语法树节点转化为 Tokens 类型。
返回值：
示例：
import std.ast.*
main(): Unit {
let wildcardPattern = WildcardPattern(quote(_))
// 转化为 Tokens 并输出
println("wildcardPattern.toTokens(): ${wildcardPattern.toTokens()}")
}
运行结果：
wildcardPattern.toTokens(): _
func traverse(Visitor)
public func traverse(v: Visitor): Unit
功能：遍历当前语法树节点及其子节点。若要提前终止子节点遍历，可重写 visit 函数并调用 breakTraverse 函数。请参见自定义访问函数遍历 AST 对象示例。
参数：
示例：
import std.ast.*
class MyVisitor <: Visitor {
public override func visit(_: WildcardPattern) {
println("Visiting WildcardPattern")
}
}
main(): Unit {
let wildcardPattern = WildcardPattern(quote(_))
// 使用自定义访问器遍历 WildcardPattern 节点
wildcardPattern.traverse(MyVisitor())
}
运行结果：
Visiting WildcardPattern