类

class Annotation

public class Annotation <: SyntaxTreeNode {
    public init(arguments: Array<Argument>, identifier: String, opKind: AtOpKind, comments!: Array<Comment> = [])
}

功能：表示编译器内置的注解节点。

一个 Annotation 节点：@CallingConv[xxx], @Attribute[xxx], @When[condition]等。

父类型：

• SyntaxTreeNode

prop arguments

public prop arguments: Array<Argument>

功能：获取 Annotation 中的参数序列，如 @CallingConv[xxx] 中的 xxx。

类型：Array<Argument>

prop identifier

public prop identifier: String

功能：获取 Annotation 节点的标识符，如 @CallingConv[xxx] 中的 CallingConv。

类型：String

prop opKind

public prop opKind: AtOpKind

功能：获取 Annotation 节点的操作符，如 @CallingConv[xxx] 中的 @。

类型：AtOpKind

init(Array<Argument>, String, AtOpKind, Array<Comment>)

public init(arguments: Array<Argument>, identifier: String, opKind: AtOpKind, comments!: Array<Comment> = [])

功能：构造一个 Annotation 对象，表示语法树中的注解节点。

参数：

• arguments: Array<Argument> - 注解的参数列表。
• identifier: String - 注解的标识符名称，例如 MyAnnotation。
• opKind: AtOpKind - 注解操作符类型，如 @ 或 @!。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 identifier 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 arguments
    let arguments = [Argument(
        "a1", 
        false, 
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    )]

    // 创建 identifier
    let identifier = "MyAnnotation"

    // 创建 opKind
    let opKind = AtOpKind.At

    // 创建 Annotation 实例
    let annotation = Annotation(
        arguments, 
        identifier, 
        opKind
    )

    println("annotation: ${annotation}")
}

运行结果：

annotation: @MyAnnotation[a1: 123]

func getAtOpPos()

public func getAtOpPos(): CodePositionRange

功能：获取 Annotation 节点中操作符 @ 或 @! 的位置。

返回值：

• CodePositionRange - 返回操作符 @ 或 @! 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 arguments
    let arguments = [Argument(
        "a1", 
        false, 
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    )]

    // 创建 identifier
    let identifier = "MyAnnotation"

    // 创建 opKind
    let opKind = AtOpKind.At

    // 创建 Annotation 实例
    let annotation = Annotation(
        arguments, 
        identifier, 
        opKind
    )
    let pos = annotation.getAtOpPos()

    // 输出 @ 或 @! 操作符位置
    println("annotation.getAtOpPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

annotation.getAtOpPos(): 1:1-1:2

func getCommasPos()

public func getCommasPos(): Array<CodePositionRange>

功能：获取 Annotation 节点中 , 的位置。

返回值：

• Array<CodePositionRange> - 返回 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 arguments
    let arguments = [
        Argument("a1", false, LitConstExpr(LitConstKind.IntergerLiteral, "1")),
        Argument("a2", false, LitConstExpr(LitConstKind.IntergerLiteral, "2")),
        Argument("a3", false, LitConstExpr(LitConstKind.IntergerLiteral, "3"))
    ]

    // 创建 identifier
    let identifier = "MyAnnotation"

    // 创建 opKind
    let opKind = AtOpKind.At

    // 创建 Annotation 实例
    let annotation = Annotation(
        arguments, 
        identifier, 
        opKind
    )
    let posArr = annotation.getCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("annotation.getCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

annotation.getCommasPos()[0]: 1:20-1:21
annotation.getCommasPos()[1]: 1:27-1:28

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 Annotation 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 arguments
    let arguments = [Argument(
        "a1", 
        false, 
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    )]

    // 创建 identifier
    let identifier = "MyAnnotation"

    // 创建 opKind
    let opKind = AtOpKind.At

    // 创建 Annotation 实例
    let annotation = Annotation(
        arguments, 
        identifier, 
        opKind
    )
    let pos = annotation.getIdentifierPos()

    // 输出注解名位置
    println("annotation.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

annotation.getIdentifierPos(): 1:2-1:14

func getLSquarePos()

public func getLSquarePos(): Option<CodePositionRange>

功能：获取 Annotation 节点中 [ 的位置。

返回值：

• Option<CodePositionRange> - 返回 [ 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 arguments
    let arguments = [Argument(
        "a1", 
        false, 
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    )]

    // 创建 identifier
    let identifier = "MyAnnotation"

    // 创建 opKind
    let opKind = AtOpKind.At

    // 创建 Annotation 实例
    let annotation = Annotation(
        arguments, 
        identifier, 
        opKind
    )

    if (let Some(pos) <- annotation.getLSquarePos()) {
        // 输出 [ 位置
        println("annotation.getLSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

annotation.getLSquarePos(): 1:14-1:15

func getRSquarePos()

public func getRSquarePos(): Option<CodePositionRange>

功能：获取 Annotation 节点中 ] 的位置。

返回值：

• Option<CodePositionRange> - 返回 ] 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 arguments
    let arguments = [Argument(
        "a1", 
        false, 
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    )]

    // 创建 identifier
    let identifier = "MyAnnotation"

    // 创建 opKind
    let opKind = AtOpKind.At

    // 创建 Annotation 实例
    let annotation = Annotation(
        arguments, 
        identifier, 
        opKind
    )

    if (let Some(pos) <- annotation.getRSquarePos()) {
        // 输出 ] 位置
        println("annotation.getRSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

annotation.getRSquarePos(): 1:22-1:23

class Argument

public class Argument <: SyntaxTreeNode {
    public init(identifier: Option<String>, isInOut: Bool, value: Expr, comments!: Array<Comment> = [])
}

功能：表示函数调用的实参节点。

例如 foo(arg:value) 中的 arg:value。

父类型：

• SyntaxTreeNode

prop identifier

public prop identifier: Option<String>

功能：获取 Argument 节点中的标识符，如 arg:value 中的 arg（若不存在返回 None）。

类型：Option<String>

prop isInOut

public prop isInOut: Bool

功能：获取 Argument 节点是否有关键字 inout。

类型：Bool

prop isNamed

public prop isNamed: Bool

功能：获取 Argument 节点是否为命名参数。

类型：Bool

prop value

public prop value: Expr

功能：获取 Argument 节点中的表达式，如 arg:value 中的 value。

类型：Expr

init(Option<String>, Bool, Expr, Array<Comment>)

public init(identifier: Option<String>, isInOut: Bool, value: Expr, comments!: Array<Comment> = [])

功能：构造一个 Argument 对象，表示语法树中的参数节点。

参数：

• identifier: Option<String> - 参数的可选标识符名称。
• isInOut: Bool - 是否为 inout 参数。
• value: Expr - 参数的值表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 identifier 不为 None 且不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建参数标识符（可选）
    let identifier = "paramName"

    // 设置是否为 inout 参数
    let isInOut = false

    // 创建参数值
    let value = LitConstExpr(LitConstKind.IntergerLiteral, "123")

    // 创建 Argument 实例
    let argument = Argument(
        identifier, 
        isInOut, 
        value
    )

    println("argument: ${argument}")
}

运行结果：

argument: paramName: 123

func getColonPos()

public func getColonPos(): Option<CodePositionRange>

功能：获取当前 Argument 中 : 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 : 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建参数标识符
    let identifier = "paramName"

    // 设置是否为 inout 参数
    let isInOut = false

    // 创建参数值
    let value = LitConstExpr(LitConstKind.IntergerLiteral, "123")

    // 创建 Argument 实例
    let argument = Argument(
        identifier, 
        isInOut, 
        value
    )

    if (let Some(pos) <- argument.getColonPos()) {
        // 输出冒号位置
        println("argument.getColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

argument.getColonPos(): 1:10-1:11

func getIdentifierPos()

public func getIdentifierPos(): Option<CodePositionRange>

功能：获取当前 Argument 中标识符的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回标识符的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建参数标识符
    let identifier = "paramName"

    // 设置是否为 inout 参数
    let isInOut = false

    // 创建参数值
    let value = LitConstExpr(LitConstKind.IntergerLiteral, "123")

    // 创建 Argument 实例
    let argument = Argument(
        identifier, 
        isInOut, 
        value
    )

    if (let Some(pos) <- argument.getIdentifierPos()) {
        // 输出标识符位置
        println("argument.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

argument.getIdentifierPos(): 1:1-1:10

func getInoutKeyWordPos()

public func getInoutKeyWordPos(): Option<CodePositionRange>

功能：获取当前 Argument 中 inout 关键字的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 inout 关键字的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建参数标识符
    let identifier = "paramName"

    // 设置为 inout 参数
    let isInOut = true

    // 创建参数值
    let value = LitConstExpr(LitConstKind.IntergerLiteral, "123")

    // 创建 Argument 实例
    let argument = Argument(
        identifier, 
        isInOut, 
        value
    )

    if (let Some(pos) <- argument.getInoutKeyWordPos()) {
        // 输出 inout 关键字位置
        println("argument.getInoutKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

argument.getInoutKeyWordPos(): 1:12-1:17

class ArrayLiteral

public class ArrayLiteral <: Expr {
    public init(elements: Array<Expr>, comments!: Array<Comment> = [])
}

功能：表示 Array 字面量节点。

ArrayLiteral 节点：使用格式 [element1, element2, ... , elementN] 表示， 每个 element 是一个表达式。

父类型：

• Expr

prop elements

public prop elements: Array<Expr>

功能：获取 ArrayLiteral 中的表达式列表。

类型：Array<Expr>

init(Array<Expr>, Array<Comment>)

public init(elements: Array<Expr>, comments!: Array<Comment> = [])

功能：构造一个 ArrayLiteral 对象，表示数组字面量表达式，如 [1, 2, 3]。

参数：

• elements: Array<Expr> - 数组元素表达式列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 elements
    let elements: Array<Expr> = [
        LitConstExpr(LitConstKind.IntergerLiteral, "123"),
        LitConstExpr(LitConstKind.BoolLiteral, "true")
    ]

    // 创建 ArrayLiteral 实例
    let arrayLiteral = ArrayLiteral(
        elements
    )

    println("arrayLiteral: ${arrayLiteral}")
}

运行结果：

arrayLiteral: [123, true]

func getCommasPos()

public func getCommasPos(): Array<CodePositionRange>

功能：获取当前 ArrayLiteral 中所有 , 的位置。

返回值：

• Array<CodePositionRange> - 返回所有 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 elements
    let elements: Array<Expr> = [
        LitConstExpr(LitConstKind.IntergerLiteral, "1"),
        LitConstExpr(LitConstKind.IntergerLiteral, "2"),
        LitConstExpr(LitConstKind.IntergerLiteral, "3")
    ]

    // 创建 ArrayLiteral 实例
    let arrayLiteral = ArrayLiteral(elements)
    let posArr = arrayLiteral.getCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("arrayLiteral.getCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

arrayLiteral.getCommasPos()[0]: 1:3-1:4
arrayLiteral.getCommasPos()[1]: 1:6-1:7

func getLSquarePos()

public func getLSquarePos(): CodePositionRange

功能：获取当前 ArrayLiteral 中 [ 的位置。

返回值：

• CodePositionRange - 返回 [ 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 elements
    let elements: Array<Expr> = [
        LitConstExpr(LitConstKind.IntergerLiteral, "1"),
        LitConstExpr(LitConstKind.IntergerLiteral, "2")
    ]

    // 创建 ArrayLiteral 实例
    let arrayLiteral = ArrayLiteral(elements)
    let pos = arrayLiteral.getLSquarePos()

    // 输出左方括号位置
    println("arrayLiteral.getLSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

arrayLiteral.getLSquarePos(): 1:1-1:2

func getRSquarePos()

public func getRSquarePos(): CodePositionRange

功能：获取当前 ArrayLiteral 中 ] 的位置。

返回值：

• CodePositionRange - 返回 ] 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 elements
    let elements: Array<Expr> = [
        LitConstExpr(LitConstKind.IntergerLiteral, "1"),
        LitConstExpr(LitConstKind.IntergerLiteral, "2")
    ]

    // 创建 ArrayLiteral 实例
    let arrayLiteral = ArrayLiteral(elements)
    let pos = arrayLiteral.getRSquarePos()

    // 输出右方括号位置
    println("arrayLiteral.getRSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

arrayLiteral.getRSquarePos(): 1:6-1:7

class AsExpr

public class AsExpr <: Expr {
    public init(srcVal: Expr, targetTypeAnnotation: TypeAnnotation, comments!: Array<Comment> = [])
}

功能：表示一个类型转换表达式。

一个 AsExpr 表达式：e as T，类型为 Option<T>。其中 e 可以是任何类型的表达式，T 可以是任何类型。

父类型：

• Expr

prop srcVal

public prop srcVal: Expr

功能：获取 AsExpr 节点中的源表达式节点。

类型：Expr

prop targetTypeAnnotation

public prop targetTypeAnnotation: TypeAnnotation

功能：获取 AsExpr 节点中的目标类型。

类型：TypeAnnotation

init(Expr, TypeAnnotation, Array<Comment>)

public init(srcVal: Expr, targetTypeAnnotation: TypeAnnotation, comments!: Array<Comment> = [])

功能：构造一个 AsExpr 对象，表示类型转换表达式，如 x as Int32。

参数：

• srcVal: Expr - 被转换的源表达式。
• targetTypeAnnotation: TypeAnnotation - 目标类型。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 srcVal
    let srcVal = SymbolRef("x", [])

    // 创建 targetTypeAnnotation
    let targetTypeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 AsExpr 实例
    let asExpr = AsExpr(
        srcVal, 
        targetTypeAnnotation
    )

    println("asExpr: ${asExpr}")
}

运行结果：

asExpr: x as Int64

func getAsKeyWordPos()

public func getAsKeyWordPos(): CodePositionRange

功能：获取 as 的位置。

返回值：

• CodePositionRange - 返回 as 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 srcVal
    let srcVal = SymbolRef("x", [])

    // 创建 targetTypeAnnotation
    let targetTypeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 AsExpr 实例
    let asExpr = AsExpr(srcVal, targetTypeAnnotation)
    let pos = asExpr.getAsKeyWordPos()

    // 输出 as 关键字位置
    println("asExpr.getAsKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

asExpr.getAsKeyWordPos(): 1:3-1:5

class AssignExpr

public class AssignExpr <: Expr {
    public init(assignOpKind: AssignOpKind, lhs: SyntaxTreeNode, rhs: Expr, comments!: Array<Comment> = [])
}

功能：表示赋值表达式节点。

用于将左操作数的值修改为右操作数的值。一个 AssignExpr 节点：a = b。

父类型：

• Expr

prop assignOpKind

public prop assignOpKind: AssignOpKind

功能：获取 AssignExpr 节点中的赋值操作符类型（如 = 等）。

类型：AssignOpKind

prop lhs

public prop lhs: SyntaxTreeNode

功能：获取 AssignExpr 节点中的左操作数。

类型：SyntaxTreeNode

prop rhs

public prop rhs: Expr

功能：获取 AssignExpr 节点中的右操作数。

类型：Expr

init(AssignOpKind, SyntaxTreeNode, Expr, Array<Comment>)

public init(assignOpKind: AssignOpKind, lhs: SyntaxTreeNode, rhs: Expr, comments!: Array<Comment> = [])

功能：构造一个 AssignExpr 对象，表示赋值表达式。

参数：

• assignOpKind: AssignOpKind - 赋值操作符类型。
• lhs: SyntaxTreeNode - 左操作数节点。
• rhs: Expr - 右操作数表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 assignOpKind
    let assignOpKind = AssignOpKind.Assign

    // 创建 lhs
    let lhs = SymbolRef("a", [])

    // 创建 rhs
    let rhs = LitConstExpr(LitConstKind.IntergerLiteral, "3")

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    println("assignExpr: ${assignExpr}")
}

运行结果：

assignExpr: a = 3

func getAssignOpPos()

public func getAssignOpPos(): CodePositionRange

功能：获取赋值操作符的位置。

返回值：

• CodePositionRange - 返回赋值操作符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 assignOpKind
    let assignOpKind = AssignOpKind.Assign

    // 创建 lhs
    let lhs = SymbolRef("a", [])

    // 创建 rhs
    let rhs = LitConstExpr(LitConstKind.IntergerLiteral, "3")

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(assignOpKind, lhs, rhs)
    let pos = assignExpr.getAssignOpPos()

    // 输出赋值操作符位置
    println("assignExpr.getAssignOpPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

assignExpr.getAssignOpPos(): 1:3-1:4

class ASTRewriter

public open class ASTRewriter {}

功能：语法树的重写器基类，提供对语法树节点的遍历时重写节点内容的能力。

说明：

• 通过 walk 方法自顶向下遍历语法树，并在遍历过程中调用 rewrite 方法对节点进行重写；
• 支持对任意语法树节点进行遍历及重写；
• 重写过程中会保持节点类型一致性，若重写后节点类型发生变化将抛出异常。

func rewrite(SyntaxTreeNode)

public open func rewrite(node: SyntaxTreeNode): SyntaxTreeNode

功能：重写单个语法树节点，默认实现为直接返回原节点，子类可重写此方法以实现自定义的节点替换逻辑。

参数：

• node: SyntaxTreeNode - 待重写的语法树节点。

返回值：

• SyntaxTreeNode - 重写后的语法树节点。

示例：

import stdx.syntax.*
import std.collection.ArrayList

// 继承 ASTRewriter
class DocStubGenerator <: ASTRewriter {
    public override func rewrite(node: SyntaxTreeNode): SyntaxTreeNode {
        match (node) {
            case fn: FuncDecl =>
                let comment = Comment(
                    "// @brief describe ${fn.name}"
                )
                let newComments = ArrayList<Comment>(fn.comments)
                newComments.add(comment)
                // 2. 修改 FuncDecl 中的 comments 属性
                let f = FuncDecl(
                    fn.body,
                    fn.genericConstraints,
                    fn.genericParams,
                    fn.kind,
                    fn.name,
                    fn.params,
                    fn.retTyAnnotation,
                    annotations: fn.annotations,
                    modifiers: fn.modifiers,
                    comments: newComments.toArray()
                )
                return f
            case _ => return node
        }
    }
}

main() {
    let root = parseFile("path/to/source/main.cj")

    // 利用实现的 DocStubGenerator 重写节点
    let generator = DocStubGenerator()
    let newNode = generator.walk(root.node.getOrThrow(), detach: true)

    println(newNode)
}

func walk(SyntaxTreeNode, Bool)

public func walk(startPoint: SyntaxTreeNode, detach!: Bool = false): SyntaxTreeNode

功能：对指定的语法树节点进行遍历与重写。

说明：

• 若 detach 为 true，遍历后产生一颗独立的新树，新树的父节点为空；若 detach 为 false，会向上刷新父节点中的内容。

参数：

• startPoint: SyntaxTreeNode - 起始节点，可以是任意语法树节点或整包节点。
• detach!: Bool - 是否断开与父节点的关联，默认为 false。

返回值：

• SyntaxTreeNode - 重写后的新语法树节点。

异常：

• Exception - 当重写后的节点类型与原始节点类型不一致时，抛出异常。

示例：

import stdx.syntax.*
import std.collection.ArrayList

// 继承 ASTRewriter
class DocStubGenerator <: ASTRewriter {
    public override func rewrite(node: SyntaxTreeNode): SyntaxTreeNode {
        match (node) {
            case fn: FuncDecl =>
                let comment = Comment(
                    "// @brief describe ${fn.name}"
                )
                let newComments = ArrayList<Comment>(fn.comments)
                newComments.add(comment)
                // 2. 修改 FuncDecl 中的 comments 属性
                let f = FuncDecl(
                    fn.body,
                    fn.genericConstraints,
                    fn.genericParams,
                    fn.kind,
                    fn.name,
                    fn.params,
                    fn.retTyAnnotation,
                    annotations: fn.annotations,
                    modifiers: fn.modifiers,
                    comments: newComments.toArray()
                )
                return f
            case _ => return node
        }
    }
}

main() {
    let root = parseFile("path/to/source/main.cj")

    // 利用实现的 DocStubGenerator 重写节点
    let generator = DocStubGenerator()
    let newNode = generator.walk(root.node.getOrThrow(), detach: true)

    println(newNode)
}

class ASTVisitor

public open class ASTVisitor {}

功能：语法树的通用访问器基类。开发者可以通过遍历 SyntaxTreeNode 及其子类，实现对 Cangjie 源代码结构的统一访问与处理。

func postAction(SyntaxTreeNode)

public open func postAction(node: SyntaxTreeNode): PostActionMode

功能：在离开节点后执行的钩子函数，用于决定是否继续或停止遍历，当 preAction 停止时， postAction 也会立即停止。

参数：

• node: SyntaxTreeNode - 当前已访问完成的节点。

返回值：

• PostActionMode - 访问节点完成后的行为策略。

示例：

import stdx.syntax.*

// 继承 ASTVisitor
public class BinaryCounter <: ASTVisitor {
    public var count = 0

    // 重写 postAction，在进入节点后做判断
    public override func postAction(node: SyntaxTreeNode): PostActionMode {
        match (node) {
            // 遇到 BinaryExpr 时计数 +1 并继续
            case _: BinaryExpr =>
                count += 1
                return PostActionMode.Continue

            // 遇到 CallExpr 停止整个遍历
            case _: CallExpr =>
                println("Found CallExpr, stop traversal")
                return PostActionMode.Stop

            // 其它节点保持默认行为
            case _ => PostActionMode.Continue
        }
    }
}

main() {
    let root = parseFile("path/to/source/main.cj")

    let counter = BinaryCounter()
    if (let Some(node) <- root.node) {
        // 进行遍历
        counter.walk(node)
    }

    println("Total BinaryExpr count: ${counter.count}")
}

func preAction(SyntaxTreeNode)

public open func preAction(node: SyntaxTreeNode): PreActionMode

功能：在进入节点前执行的钩子函数，用于决定是否继续、跳过或停止遍历。

参数：

• node: SyntaxTreeNode - 当前即将访问的节点。

返回值：

• PreActionMode - 访问节点前的行为策略。

示例：

import stdx.syntax.*

//继承 ASTVisitor
public class BinaryCounter <: ASTVisitor {
    public var count = 0

    // 重写 preAction，只在进入节点前做判断
    public override func preAction(node: SyntaxTreeNode): PreActionMode {
        match (node) {
            // 遇到 BinaryExpr 时计数 +1 并继续
            case _: BinaryExpr =>
                count += 1
                return PreActionMode.Continue

            // 遇到 CallExpr 立即停止整个遍历
            case _: CallExpr =>
                println("Found CallExpr, stop traversal")
                return PreActionMode.Stop

            // 其它节点保持默认行为
            case _ => PreActionMode.Continue
        }
    }
}

main() {
    let root = parseFile("path/to/source/main.cj")

    let counter = BinaryCounter()
    if (let Some(node) <- root.node) {
        // 进行遍历
        counter.walk(node)
    }

    println("Total BinaryExpr count: ${counter.count}")
}

func walk(SyntaxTreeNode)

public func walk(root: SyntaxTreeNode): Unit

功能：从指定节点开始深度优先遍历 AST。

参数：

• root: SyntaxTreeNode - 遍历的起始节点。

示例：

import stdx.syntax.*

//继承 ASTVisitor
public class BinaryCounter <: ASTVisitor {
    public var count = 0

    // 重写 preAction，只在进入节点前做判断
    public override func preAction(node: SyntaxTreeNode): PreActionMode {
        match (node) {
            // 遇到 BinaryExpr 时计数 +1 并继续
            case _: BinaryExpr =>
                count += 1
                return PreActionMode.Continue

            // 遇到 CallExpr 立即停止整个遍历
            case _: CallExpr =>
                println("Found CallExpr, stop traversal")
                return PreActionMode.Stop

            // 其它节点保持默认行为
            case _ => PreActionMode.Continue
        }
    }
}

main() {
    let root = parseFile("path/to/source/main.cj")

    let counter = BinaryCounter()
    if (let Some(node) <- root.node) {
        // 进行遍历
        counter.walk(node)
    }

    println("Total BinaryExpr count: ${counter.count}")
}

class AtomicType

public class AtomicType <: TypeAnnotation {
    public init(kind: AtomicTypeKind, comments!: Array<Comment> = [])
}

功能：表示一个基本类型节点。

例如数值类型，字符类型，布尔类型等。

父类型：

• TypeAnnotation

prop kind

public prop kind: AtomicTypeKind

功能：获取 AtomicType 的具体类型。

类型：AtomicTypeKind

init(AtomicTypeKind, Array<Comment>)

public init(kind: AtomicTypeKind, comments!: Array<Comment> = [])

功能：构造一个 AtomicType 对象，表示原子类型，如 Int64、Bool 等。

参数：

• kind: AtomicTypeKind - 原子类型种类。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 kind
    let kind = AtomicTypeKind.UInt32Type

    // 创建 AtomicType 实例
    let atomicType = AtomicType(
        kind
    )

    println("atomicType: ${atomicType}")
}

运行结果：

atomicType: UInt32

class BinaryExpr

public class BinaryExpr <: Expr {
    public init(lhs: Expr, opKind: BinaryOpKind, rhs: Expr, comments!: Array<Comment> = [])
}

功能：表示一个二元操作表达式节点。

一个 BinaryExpr 节点：1 + 2

父类型：

• Expr

prop lhs

public prop lhs: Expr

功能：获取 BinaryExpr 节点中操作符左侧的表达式节点。

类型：Expr

prop opKind

public prop opKind: BinaryOpKind

功能：获取 BinaryExpr 节点中的二元操作符类型。

类型：BinaryOpKind

prop rhs

public prop rhs: Expr

功能：获取 BinaryExpr 节点中操作符右侧的表达式节点。

类型：Expr

init(Expr, BinaryOpKind, Expr, Array<Comment>)

public init(lhs: Expr, opKind: BinaryOpKind, rhs: Expr, comments!: Array<Comment> = [])

功能：构造一个 BinaryExpr 对象，表示二元运算表达式，如 x + y。

参数：

• lhs: Expr - 左操作数表达式。
• opKind: BinaryOpKind - 二元操作符类型。
• rhs: Expr - 右操作数表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 lhs
    let lhs = SymbolRef("x", [])

    // 创建 opKind
    let opKind = BinaryOpKind.Add

    // 创建 rhs
    let rhs = SymbolRef("y", [])

    // 创建 BinaryExpr 实例
    let binaryExpr = BinaryExpr(
        lhs, 
        opKind, 
        rhs
    )

    println("binaryExpr: ${binaryExpr}")
}

运行结果：

binaryExpr: x + y

func getOperatorPos()

public func getOperatorPos(): CodePositionRange

功能：获取二元操作符的位置。

返回值：

• CodePositionRange - 返回二元操作符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 lhs
    let lhs = SymbolRef("x", [])

    // 创建 opKind
    let opKind = BinaryOpKind.Add

    // 创建 rhs
    let rhs = SymbolRef("y", [])

    // 创建 BinaryExpr 实例
    let binaryExpr = BinaryExpr(lhs, opKind, rhs)
    let pos = binaryExpr.getOperatorPos()

    // 输出操作符位置
    println("binaryExpr.getOperatorPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

binaryExpr.getOperatorPos(): 1:3-1:4

class Block

public class Block <: SyntaxTreeNode {
    public init(nodes: Array<SyntaxTreeNode>, comments!: Array<Comment> = [])
}

功能：表示一个块节点。

父类型：

• SyntaxTreeNode

prop nodes

public prop nodes: Array<SyntaxTreeNode>

功能：获取 Block 中的表达式或声明序列。

类型：Array<SyntaxTreeNode>

init(Array<SyntaxTreeNode>, Array<Comment>)

public init(nodes: Array<SyntaxTreeNode>, comments!: Array<Comment> = [])

功能：构造一个 Block 对象，表示语法树中的代码块节点。

参数：

• nodes: Array<SyntaxTreeNode> - 块内的子节点列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 nodes 中的节点不是表达式类型、函数声明或变量声明时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 nodes
    let nodes: Array<SyntaxTreeNode> = [
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    ]

    // 创建 Block 实例
    let block = Block(
        nodes
    )

    println("block: ${block}")
}

运行结果：

block: {
    123
}

func getLCurlPos()

public func getLCurlPos(): CodePositionRange

功能：获取 Block 节点中 { 的位置。

返回值：

• CodePositionRange - 返回 { 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 nodes
    let nodes: Array<SyntaxTreeNode> = [
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    ]

    // 创建 Block 实例
    let block = Block(nodes)
    let pos = block.getLCurlPos()

    // 输出左花括号位置
    println("block.getLCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

block.getLCurlPos(): 1:1-1:2

func getRCurlPos()

public func getRCurlPos(): CodePositionRange

功能：获取 Block 节点中 } 的位置。

返回值：

• CodePositionRange - 返回 } 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 nodes
    let nodes: Array<SyntaxTreeNode> = [
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    ]

    // 创建 Block 实例
    let block = Block(nodes)
    let pos = block.getRCurlPos()

    // 输出右花括号位置
    println("block.getRCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

block.getRCurlPos(): 3:1-3:2

class Body

public class Body <: SyntaxTreeNode {
    public init(memberDecls: Array<Decl>, comments!: Array<Comment> = [])
}

功能：表示 Class 类型、 Struct 类型、 Interface 类型以及扩展中由 {} 和内部的一组声明节点组成的结构。

父类型：

• SyntaxTreeNode

prop memberDecls

public prop memberDecls: Array<Decl>

功能：获取 Body 内的声明节点集合。

类型：Array<Decl>

init(Array<Decl>, Array<Comment>)

public init(memberDecls: Array<Decl>, comments!: Array<Comment> = [])

功能：构造一个 Body 对象，表示语法树中的声明体节点。

参数：

• memberDecls: Array<Decl> - 成员声明列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建一个变量声明
    let initializer = LitConstExpr(LitConstKind.IntergerLiteral, "1")
    let varDecl = VarDecl(initializer, VarKind.Let, "x", VarPattern("x"), AtomicType(AtomicTypeKind.Int64Type))
    
    // 创建成员声明列表
    let memberDecls: Array<Decl> = [varDecl]
    
    // 创建 Body 实例
    let body = Body(memberDecls)
    
    println("body: ${body}")
}

运行结果：

body: {
    let x: Int64 = 1
}

func getLCurlPos()

public func getLCurlPos(): CodePositionRange

功能：获取 Body 节点中 { 的位置。

返回值：

• CodePositionRange - 返回 { 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建一个变量声明
    let initializer = LitConstExpr(LitConstKind.IntergerLiteral, "1")
    let varDecl = VarDecl(initializer, VarKind.Let, "x", VarPattern("x"), AtomicType(AtomicTypeKind.Int64Type))
    
    // 创建成员声明列表
    let memberDecls: Array<Decl> = [varDecl]
    
    // 创建 Body 实例
    let body = Body(memberDecls)
    
    // 获取左花括号位置
    let pos = body.getLCurlPos()
    
    // 输出左花括号位置
    println("body.getLCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

body.getLCurlPos(): 1:1-1:2

func getRCurlPos()

 public func getRCurlPos(): CodePositionRange

功能：获取 Body 节点中 } 的位置。

返回值：

• CodePositionRange - 返回 } 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建一个变量声明
    let initializer = LitConstExpr(LitConstKind.IntergerLiteral, "1")
    let varDecl = VarDecl(initializer, VarKind.Let, "x", VarPattern("x"), AtomicType(AtomicTypeKind.Int64Type))
    
    // 创建成员声明列表
    let memberDecls: Array<Decl> = [varDecl]
    
    // 创建 Body 实例
    let body = Body(memberDecls)
    
    // 获取右花括号位置
    let pos = body.getRCurlPos()
    
    // 输出右花括号位置
    println("body.getRCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

body.getRCurlPos(): 3:1-3:2

class BreakExpr

public class BreakExpr <: Expr {
    public init(comments!: Array<Comment> = [])
}

功能：表示中断表达式。

用于终止当前循环语句，并将控制权转移到外层代码。BreakExpr 节点以 break 关键字表示，通常用于循环体内部，以提前退出循环。

父类型：

• Expr

init(Array<Comment>)

public init(comments!: Array<Comment> = [])

功能：构造一个 BreakExpr 对象，表示 break 表达式。

参数：

• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 BreakExpr 实例
    let breakexpr = BreakExpr()

    println("breakexpr: ${breakexpr}")
}

运行结果：

breakexpr: break

class CallExpr

public class CallExpr <: Expr {
    public init(callee: Expr, arguments: Array<Argument>, comments!: Array<Comment> = [])
}

功能：表示函数调用节点。

一个 CallExpr 节点包括一个表达式，后面紧跟参数列表，例如 foo(100)。

父类型：

• Expr

prop arguments

public prop arguments: Array<Argument>

功能：获取 CallExpr 节点中的函数参数。

类型：Array<Argument>

prop callee

public prop callee: Expr

功能：获取 CallExpr 节点中的函数调用节点。

类型：Expr

init(Expr, Array<Argument>, Array<Comment>)

public init(callee: Expr, arguments: Array<Argument>, comments!: Array<Comment> = [])

功能：构造一个 CallExpr 对象，表示函数调用表达式，如 f(x, y)。

参数：

• callee: Expr - 被调用的函数表达式。
• arguments: Array<Argument> - 实参列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当调用表达式不是成员访问或引用表达式时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 callee
    let callee = SymbolRef("foo", [])

    // 创建 arguments
    let arguments = [Argument(
        "a1", 
        false, 
        LitConstExpr(LitConstKind.IntergerLiteral, "123")
    )]

    // 创建 CallExpr 实例
    let callExpr = CallExpr(
        callee, 
        arguments
    )

    println("callExpr: ${callExpr}")
}

运行结果：

callExpr: foo(a1: 123)

func getCommasPos()

public func getCommasPos(): Array<CodePositionRange>

功能：获取 CallExpr 节点中 , 的位置。

返回值：

• Array<CodePositionRange> - 返回 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 callee
    let callee = SymbolRef("foo", [])

    // 创建 arguments
    let arguments = [
        Argument("a1", false, LitConstExpr(LitConstKind.IntergerLiteral, "1")),
        Argument("a2", false, LitConstExpr(LitConstKind.IntergerLiteral, "2")),
        Argument("a3", false, LitConstExpr(LitConstKind.IntergerLiteral, "3"))
    ]

    // 创建 CallExpr 实例
    let callExpr = CallExpr(callee, arguments)
    let posArr = callExpr.getCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("callExpr.getCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

callExpr.getCommasPos()[0]: 1:10-1:11
callExpr.getCommasPos()[1]: 1:17-1:18

func getLParenPos()

public func getLParenPos(): CodePositionRange

功能：获取当前 CallExpr 中 ( 的位置。

返回值：

• CodePositionRange - 返回 ( 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 callee
    let callee = SymbolRef("foo", [])

    // 创建 arguments
    let arguments = [Argument("a1", false, LitConstExpr(LitConstKind.IntergerLiteral, "123"))]

    // 创建 CallExpr 实例
    let callExpr = CallExpr(callee, arguments)
    let pos = callExpr.getLParenPos()

    // 输出左括号位置
    println("callExpr.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

callExpr.getLParenPos(): 1:4-1:5

func getRParenPos()

public func getRParenPos(): CodePositionRange

功能：获取当前 CallExpr 中 ) 的位置。

返回值：

• CodePositionRange - 返回 ) 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 callee
    let callee = SymbolRef("foo", [])

    // 创建 arguments
    let arguments = [Argument("a1", false, LitConstExpr(LitConstKind.IntergerLiteral, "123"))]

    // 创建 CallExpr 实例
    let callExpr = CallExpr(callee, arguments)
    let pos = callExpr.getRParenPos()

    // 输出右括号位置
    println("callExpr.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

callExpr.getRParenPos(): 1:12-1:13

class CatchPattern

public class CatchPattern <: SyntaxTreeNode {
    public init(pattern: Pattern, exceptionType: Array<TypeAnnotation>, comments!: Array<Comment> = [])
}

功能：表示一个捕获模式。

用于获取 TryCatch 中通过模式匹配的方式匹配待捕获的异常序列。

父类型：

• SyntaxTreeNode

prop exceptionType

public prop exceptionType: Array<TypeAnnotation>

功能：获取当前捕获模式的异常类型列表。

类型：Array<TypeAnnotation>

prop pattern

public prop pattern: Pattern

功能：获取当前捕获模式的模式。

类型：Pattern

init(Pattern, Array<TypeAnnotation>, Array<Comment>)

public init(pattern: Pattern, exceptionType: Array<TypeAnnotation>, comments!: Array<Comment> = [])

功能：构造一个 CatchPattern 对象，表示 catch 子句中的异常捕获模式。

参数：

• pattern: Pattern - 用于绑定异常的模式。
• exceptionType: Array<TypeAnnotation> - 可捕获的异常类型列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 pattern 不为 WildcardPattern 或 VarPattern，或当 pattern 为 VarPattern 但 exceptionType 为空时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 pattern
    let pattern = VarPattern("x")

    // 创建 exceptionType
    let exceptionType: Array<TypeAnnotation> = [CompositeType("I1", [], []), CompositeType("I2", [], [])]

    // 创建 CatchPattern 实例
    let catchPattern = CatchPattern(
        pattern, 
        exceptionType
    )

    println("catchPattern: ${catchPattern}")
}

运行结果：

catchPattern: x: I1 | I2

func getBitOrsPos()

public func getBitOrsPos(): Array<CodePositionRange>

功能：获取 CatchPattern 节点中 | 的位置。

返回值：

• Array<CodePositionRange> - 返回 | 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 pattern
    let pattern = VarPattern("x")

    // 创建 exceptionType
    let exceptionType: Array<TypeAnnotation> = [
        CompositeType("I1", [], []),
        CompositeType("I2", [], []),
        CompositeType("I3", [], [])
    ]

    // 创建 CatchPattern 实例
    let catchPattern = CatchPattern(pattern, exceptionType)
    let posArr = catchPattern.getBitOrsPos()

    // 遍历输出竖线位置
    for (i in 0..posArr.size) {
        println("catchPattern.getBitOrsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

catchPattern.getBitOrsPos()[0]: 1:7-1:8
catchPattern.getBitOrsPos()[1]: 1:12-1:13

func getColonPos()

public func getColonPos(): Option<CodePositionRange>

功能：获取 CatchPattern 节点中 : 的位置。

返回值：

• Option<CodePositionRange> - 返回 : 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 pattern
    let pattern = VarPattern("x")

    // 创建 exceptionType
    let exceptionType: Array<TypeAnnotation> = [CompositeType("I1", [], []), CompositeType("I2", [], [])]

    // 创建 CatchPattern 实例
    let catchPattern = CatchPattern(pattern, exceptionType)

    if (let Some(pos) <- catchPattern.getColonPos()) {
        // 输出冒号位置
        println("catchPattern.getColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

catchPattern.getColonPos(): 1:2-1:3

class ClassDecl

public class ClassDecl <: Decl {
    public init(body: Body, genericConstraints: Option<GenericConstraints>, genericParams: Array<GenericParam>,
        name: String, superTyAnnotations: Array<TypeAnnotation>, annotations!: Array<Annotation> = [],
        modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])
}

功能：表示一个类声明节点。

类的声明使用 class 关键字，声明依次为：可缺省的修饰符、class 关键字、class 名、可选的类型参数、是否指定父类或父接口、可选的泛型约束、类体的声明。

父类型：

• Decl

prop body

public prop body: Body

功能：获取当前类声明的主体部分。

类型：Body

prop genericConstraints

public prop genericConstraints: Option<GenericConstraints>

功能：获取当前类声明的泛型约束（若不存在返回 None）。

类型：Option<GenericConstraints>

prop genericParams

public prop genericParams: Array<GenericParam>

功能：获取当前类声明的泛型参数列表。

类型：Array<GenericParam>

prop name

public prop name: String

功能：获取当前类声明的名称。

类型：String

prop superTyAnnotations

public prop superTyAnnotations: Array<TypeAnnotation>

功能：获取当前类声明的父类类型标注列表。

类型：Array<TypeAnnotation>

init(Body, Option<GenericConstraints>, Array<GenericParam>, String, Array<TypeAnnotation>, Array<Annotation>, Array<Modifier>, Array<Comment>)

public init(body: Body, genericConstraints: Option<GenericConstraints>, genericParams: Array<GenericParam>,
    name: String, superTyAnnotations: Array<TypeAnnotation>, annotations!: Array<Annotation> = [],
    modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])

功能：构造一个 ClassDecl 对象，表示类声明节点。

参数：

• body: Body - 类体，包含成员声明。
• genericConstraints: Option<GenericConstraints> - 可选的泛型约束。
• genericParams: Array<GenericParam> - 泛型参数列表。
• name: String - 类名。
• superTyAnnotations: Array<TypeAnnotation> - 父类类型标注列表。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• modifiers!: Array<Modifier> - 修饰符列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 body 中有除静态初始化器、函数声明、变量声明、宏展开声明和属性声明外的声明或当泛型约束与泛型参数不对应，或输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 body
    let body = Body([])
    
    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])
    
    // 创建 genericParams
    let genericParams = [GenericParam("T")]
    
    // 创建 name
    let name = "A"
    
    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 annotations
    let annotations = [Annotation([Argument(None, false, LitConstExpr(LitConstKind.IntergerLiteral, "123"))], "MyAnno", AtOpKind.At)]
    
    // 创建 modifiers
    let modifiers = [Modifier(ModifierKind.Public)]
    
    // 创建 ClassDecl 实例
    let classDecl = ClassDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations, 
        annotations: annotations, 
        modifiers: modifiers
    )
    
    println("classDecl: ${classDecl}")
}

运行结果：

classDecl: @MyAnno[123]
public class A<T> <: I1 where T<:I1 {
}

func getClassKeyWordPos()

public func getClassKeyWordPos(): CodePositionRange

功能：获取 ClassDecl 节点中 class 关键字的位置。

返回值：

• CodePositionRange - 返回 class 关键字 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 body
    let body = Body([])
    
    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])
    
    // 创建 genericParams
    let genericParams = [GenericParam("T")]
    
    // 创建 name
    let name = "A"
    
    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ClassDecl 实例
    let classDecl = ClassDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations
    )
    
    // 获取 class 关键字位置
    let pos = classDecl.getClassKeyWordPos()
    
    // 输出 class 关键字位置
    println("classDecl.getClassKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

classDecl.getClassKeyWordPos(): 1:1-1:6

func getGenericParamsCommasPos()

public func getGenericParamsCommasPos(): Array<CodePositionRange>

功能：获取 ClassDecl 节点中泛型参数中 , 的位置。

返回值：

• Array<CodePositionRange> - 返回泛型参数中 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 body
    let body = Body([])
    
    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])
    
    // 创建 genericParams
    let genericParams = [GenericParam("T"), GenericParam("U"), GenericParam("V")]
    
    // 创建 name
    let name = "A"
    
    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ClassDecl 实例
    let classDecl = ClassDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations
    )
    
    // 获取泛型参数中逗号的位置
    let posArr = classDecl.getGenericParamsCommasPos()
    
    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("classDecl.getGenericParamsCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

classDecl.getGenericParamsCommasPos()[0]: 1:10-1:11
classDecl.getGenericParamsCommasPos()[1]: 1:13-1:14

func getGenericParamsLAnglePos()

public func getGenericParamsLAnglePos(): Option<CodePositionRange>

功能：获取 ClassDecl 节点中泛型参数的 < 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回泛型参数的 < 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 body
    let body = Body([])
    
    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])
    
    // 创建 genericParams
    let genericParams = [GenericParam("T")]
    
    // 创建 name
    let name = "A"
    
    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ClassDecl 实例
    let classDecl = ClassDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations
    )
    
    // 获取泛型参数左尖括号的位置
    if (let Some(pos) <- classDecl.getGenericParamsLAnglePos()) {
        // 输出左尖括号位置
        println("classDecl.getGenericParamsLAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    } else {
        println("No left angle bracket found")
    }
}

运行结果：

classDecl.getGenericParamsLAnglePos(): 1:8-1:9

func getGenericParamsRAnglePos()

public func getGenericParamsRAnglePos(): Option<CodePositionRange>

功能：获取 ClassDecl 节点中泛型参数的 > 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回泛型参数的 > 的位置（若不存在返回 None）

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 body
    let body = Body([])
    
    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])
    
    // 创建 genericParams
    let genericParams = [GenericParam("T")]
    
    // 创建 name
    let name = "A"
    
    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ClassDecl 实例
    let classDecl = ClassDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations
    )
    
    // 获取泛型参数右尖括号的位置
    if (let Some(pos) <- classDecl.getGenericParamsRAnglePos()) {
        // 输出右尖括号位置
        println("classDecl.getGenericParamsRAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    } else {
        println("No right angle bracket found")
    }
}

运行结果：

classDecl.getGenericParamsRAnglePos(): 1:10-1:11

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 ClassDecl 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 body
    let body = Body([])
    
    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])
    
    // 创建 genericParams
    let genericParams = [GenericParam("T")]
    
    // 创建 name
    let name = "A"
    
    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ClassDecl 实例
    let classDecl = ClassDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations
    )
    
    // 获取标识符的位置
    let pos = classDecl.getIdentifierPos()
    
    // 输出标识符位置
    println("classDecl.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

classDecl.getIdentifierPos(): 1:7-1:8

func getSuperTyAnnotationsBitAndsPos()

public func getSuperTyAnnotationsBitAndsPos(): Array<CodePositionRange>

功能：获取 ClassDecl 节点中父类型中 & 的位置。

返回值：

• Array<CodePositionRange> - 返回父类型中 & 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 body
    let body = Body([])
    
    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])
    
    // 创建 genericParams
    let genericParams = [GenericParam("T")]
    
    // 创建 name
    let name = "A"
    
    // 创建多个父类型（使用 & 连接）
    let superTyAnnotations: Array<TypeAnnotation> = [
        CompositeType("I1", [], []),
        CompositeType("I2", [], []),
        CompositeType("I3", [], [])
    ]
    
    // 创建 ClassDecl 实例
    let classDecl = ClassDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations
    )
    
    // 获取父类型中 & 的位置
    let posArr = classDecl.getSuperTyAnnotationsBitAndsPos()
    
    // 遍历输出 & 位置
    for (i in 0..posArr.size) {
        println("classDecl.getSuperTyAnnotationsBitAndsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

classDecl.getSuperTyAnnotationsBitAndsPos()[0]: 1:18-1:19
classDecl.getSuperTyAnnotationsBitAndsPos()[1]: 1:23-1:24

func getUpperBoundPos()

public func getUpperBoundPos(): Option<CodePositionRange>

功能：获取 ClassDecl 节点中 <: 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 <: 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 body
    let body = Body([])
    
    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])
    
    // 创建 genericParams
    let genericParams = [GenericParam("T")]
    
    // 创建 name
    let name = "A"
    
    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ClassDecl 实例
    let classDecl = ClassDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations
    )
    
    // 获取 <: 位置
    if (let Some(pos) <- classDecl.getUpperBoundPos()) {
        // 输出 <: 位置
        println("classDecl.getUpperBoundPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    } else {
        println("No upper bound found")
    }
}

运行结果：

classDecl.getUpperBoundPos(): 1:12-1:14

class Comment

public class Comment <: SyntaxTreeNode {
    public init(content: String)
}

功能：表示一个注释信息节点。例如 // comment。

父类型：

• SyntaxTreeNode

prop content

public prop content: String

功能：表示注释信息的内容。

类型：String

prop kind

public prop kind: CommentKind

功能：表示注释的类型。

类型：CommentKind

init(String)

public init(content: String)

功能：构造一个 Comment 对象，表示语法树中的注释节点。

参数：

• content: String - 注释内容。

示例：

import stdx.syntax.*

main() {
    // 创建注释内容
    let content = "// This is a comment"

    // 创建 Comment 实例
    let comment = Comment(
        content
    )

    println("comment: ${comment}")
}

运行结果：

comment: // This is a comment

class CompositeType

public class CompositeType <: TypeAnnotation {
    public init(name: String, prefixes: Array<String>, typeArguments: Array<TypeAnnotation>, comments!: Array<Comment> = [])
}

功能：表示一个复合类型节点。例如 p1.p0.A<Int64>。

父类型：

• TypeAnnotation

prop name

public prop name: String

功能：表示复合类型的名称。

类型：String

prop prefixes

public prop prefixes: Array<String>

功能：表示复合类型的所有前缀类型。

类型：Array<String>

prop typeArguments

public prop typeArguments: Array<TypeAnnotation>

功能：表示复合类型的所有类型参数。

类型：Array<TypeAnnotation>

init(String, Array<String>, Array<TypeAnnotation>, Array<Comment>)

public init(name: String, prefixes: Array<String>, typeArguments: Array<TypeAnnotation>, comments!: Array<Comment> = [])

功能：构造一个 CompositeType 对象，表示如 p1.p0.A<Int64> 这样的复合类型。

参数：

• name: String - 复合类型的主名称，例如 A。
• prefixes: Array<String> - 复合类型的前缀路径，例如 ["p1", "p0"]。
• typeArguments: Array<TypeAnnotation> - 类型参数列表，例如 [Int64]。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 name
    let name = "A"

    // 创建 prefixes
    let prefixes = ["p0"]

    // 创建 typeArguments
    let typeArguments : Array<TypeAnnotation> = [CompositeType("I1", [], [])]

    // 创建 CompositeType 实例
    let compositeType = CompositeType(
        name, 
        prefixes, 
        typeArguments
    )

    println("compositeType: ${compositeType}")
}

运行结果：

compositeType: p0.A<I1>

func getCommasPos()

public func getCommasPos(): Array<CodePositionRange>

功能：获取 , 的位置序列。

返回值：

• Array<CodePositionRange> - 返回 , 的位置序列。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 CompositeType 实例
    let typeArguments: Array<TypeAnnotation> = [CompositeType("I1", [], []), CompositeType("I2", [], [])]
    let compositeType = CompositeType("A", ["p0"], typeArguments)
    let posArr = compositeType.getCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("compositeType.getCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

compositeType.getCommasPos()[0]: 1:8-1:9

func getDotsPos()

public func getDotsPos(): Array<CodePositionRange>

功能：获取 . 的位置序列。

返回值：

• Array<CodePositionRange> - 返回 . 的位置序列。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 CompositeType 实例
    let compositeType = CompositeType("A", ["p0", "p1"], [])
    let posArr = compositeType.getDotsPos()

    // 遍历输出点位置
    for (i in 0..posArr.size) {
        println("compositeType.getDotsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

compositeType.getDotsPos()[0]: 1:3-1:4
compositeType.getDotsPos()[1]: 1:6-1:7

func getLAnglePos()

public func getLAnglePos(): Option<CodePositionRange>

功能：获取 < 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 < 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 CompositeType 实例
    let typeArguments: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    let compositeType = CompositeType("A", [], typeArguments)

    if (let Some(pos) <- compositeType.getLAnglePos()) {
        // 输出左尖括号位置
        println("compositeType.getLAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

compositeType.getLAnglePos(): 1:2-1:3

func getRAnglePos()

public func getRAnglePos(): Option<CodePositionRange>

功能：获取 > 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 > 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 CompositeType 实例
    let typeArguments: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    let compositeType = CompositeType("A", [], typeArguments)

    if (let Some(pos) <- compositeType.getRAnglePos()) {
        // 输出右尖括号位置
        println("compositeType.getRAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

compositeType.getRAnglePos(): 1:5-1:6

class ConjunctionCondition

public class ConjunctionCondition <: SyntaxTreeNode {
    public init(cond: Array<AtomicCondition>, comments!: Array<Comment> = [])
}

功能：表示原子条件的逻辑合取。

该节点聚合了多个原子条件，只有当所有原子条件的求值结果都为 true 时，该合取条件才会被满足。它对其包含的原子条件之间的关系建模为逻辑 AND 运算。

父类型：

-SyntaxTreeNode

prop cond

public prop cond: Array<AtomicCondition>

功能：表示该模式节点中的原子条件列表。

类型：Array<AtomicCondition>

init(Array<AtomicCondition>, Array<Comment>)

public init(cond: Array<AtomicCondition>, comments!: Array<Comment> = [])

功能：构造一个 ConjunctionCondition 对象，表示原子条件的逻辑合取。

参数：

• cond: Array<AtomicCondition> - 原子条件列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 cond 为空时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 cond
    let cond = [
            AtomicCondition.Expression(BinaryExpr(SymbolRef("x", []),BinaryOpKind.Equal, SymbolRef("y", []))), 
            AtomicCondition.Expression(BinaryExpr(SymbolRef("a", []),BinaryOpKind.Gt, SymbolRef("b", [])))
        ]

    // 创建 ConjunctionCondition 实例
    let conjunctionCondition = ConjunctionCondition(
        cond
    )

    println("conjunctionCondition: ${conjunctionCondition}")
}

运行结果：

conjunctionCondition: x == y && a > b

func getAndsPos()

public func getAndsPos(): Array<CodePositionRange>

功能：获取 ConjunctionCondition 节点中 && 的位置序列。

返回值：

• Array<CodePositionRange> - 返回 && 的位置序列。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 cond
    let cond = [
        AtomicCondition.Expression(BinaryExpr(SymbolRef("x", []), BinaryOpKind.Equal, SymbolRef("y", []))),
        AtomicCondition.Expression(BinaryExpr(SymbolRef("a", []), BinaryOpKind.Gt, SymbolRef("b", []))),
        AtomicCondition.Expression(BinaryExpr(SymbolRef("m", []), BinaryOpKind.Lt, SymbolRef("n", [])))
    ]

    // 创建 ConjunctionCondition 实例
    let conjunctionCondition = ConjunctionCondition(cond)
    let posArr = conjunctionCondition.getAndsPos()

    // 遍历输出 && 位置
    for (i in 0..posArr.size) {
        println("conjunctionCondition.getAndsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

conjunctionCondition.getAndsPos()[0]: 1:8-1:10
conjunctionCondition.getAndsPos()[1]: 1:17-1:19

class ConstPattern

public class ConstPattern <: Pattern {
    public init(litConstExpr: LitConstExpr, comments!: Array<Comment> = [])
}

功能：表示常量模式节点。

常量模式可以是整数字面量、浮点数字面量、字符字面量、布尔字面量、字符串字面量等字面量，如 case 1 => 0 中的 1。

父类型：

• Pattern

prop litConstExpr

public prop litConstExpr: LitConstExpr

功能：表示该模式节点中的常量表达式节点。

类型：LitConstExpr

init(LitConstExpr, Array<Comment>)

public init(litConstExpr: LitConstExpr, comments!: Array<Comment> = [])

功能：构造一个 ConstPattern 对象，表示常量模式，如 42、"hello"。

参数：

• litConstExpr: LitConstExpr - 字面量常量表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 litConstExpr
    let litConstExpr = LitConstExpr(LitConstKind.BoolLiteral, "true")

    // 创建 ConstPattern 实例
    let constPattern = ConstPattern(
        litConstExpr
    )

    println("constPattern: ${constPattern}")
}

运行结果：

constPattern: true

class ContinueExpr

public class ContinueExpr <: Expr {
    public init(comments!: Array<Comment> = [])
}

功能：表示继续表达式。

用于跳过当前循环迭代，直接进入下一次循环迭代。ContinueExpr 节点以 continue 关键字表示，通常用于循环体内部，以跳过当前迭代的剩余部分。

父类型：

• Expr

init(Array<Comment>)

public init(comments!: Array<Comment> = [])

功能：构造一个 ContinueExpr 对象，表示 continue 表达式。

参数：

• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 ContinueExpr 实例
    let continueexpr = ContinueExpr()

    println("continueexpr: ${continueexpr}")
}

运行结果：

continueexpr: continue

class Decl

sealed abstract class Decl <: SyntaxTreeNode {}

功能：所有声明节点的父类，继承自 SyntaxTreeNode 节点，提供了所有声明节点的通用接口。

父类型：

• SyntaxTreeNode

prop annotations

public prop annotations: Array<Annotation>

功能：获取当前声明的注解列表。

类型：Array<Annotation>

prop modifiers

public prop modifiers: Array<Modifier>

功能：获取当前声明的修饰符列表。

类型：Array<Modifier>

class Diagnostic

public class Diagnostic {
    public let codePos: CodePositionRange
    public let diagInfo: DiagnosticInfo
}

功能：表示仓颉语法树的一个诊断信息。

let codePos

public let codePos: CodePositionRange

功能：获取当前代码诊断信息的位置信息。

类型：CodePositionRange

let diagInfo

public let diagInfo: DiagnosticInfo

功能：获取当前代码诊断信息的具体诊断信息，包括 Warning, Error 类型等。

类型：DiagnosticInfo

class DisjunctionCondition

public class DisjunctionCondition <: SyntaxTreeNode {
    public init(cond: Array<ConjunctionCondition>, comments!: Array<Comment> = [])
}

功能：表示合取条件的逻辑析取。

该节点聚合了多个合取条件，只要其中至少一个合取条件的求值结果为 true，该析取条件就会被满足。它对其包含的合取条件之间的关系建模为逻辑 OR 运算，形成一个析取范式的逻辑表达式。

父类型：

-SyntaxTreeNode

prop cond

public prop cond: Array<ConjunctionCondition>

功能：表示该模式节点中的合取条件列表。

类型：Array<ConjunctionCondition>

init(Array<ConjunctionCondition>, Array<Comment>)

public init(cond: Array<ConjunctionCondition>, comments!: Array<Comment> = [])

功能：构造一个 DisjunctionCondition 对象，表示逻辑析取条件。

参数：

• cond: Array<ConjunctionCondition> - 合取条件列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 cond 为空时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 cond
    let cond = [
            ConjunctionCondition(AtomicCondition.Expression(BinaryExpr(SymbolRef("x", []),BinaryOpKind.Equal, SymbolRef("y", [])))), 
            ConjunctionCondition(AtomicCondition.Expression(BinaryExpr(SymbolRef("a", []),BinaryOpKind.Equal, SymbolRef("b", []))))
        ]

    // 创建 DisjunctionCondition 实例
    let disjunctionCondition = DisjunctionCondition(
        cond
    )

    println("disjunctionCondition: ${disjunctionCondition}")
}

运行结果：

disjunctionCondition: x == y || a == b

func getOrsPos()

public func getOrsPos(): Array<CodePositionRange>

功能：获取 DisjunctionCondition 节点中 || 的位置序列。

返回值：

• Array<CodePositionRange> - 返回 || 的位置序列。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 cond
    let cond = [
        ConjunctionCondition(AtomicCondition.Expression(BinaryExpr(SymbolRef("x", []), BinaryOpKind.Equal, SymbolRef("y", [])))),
        ConjunctionCondition(AtomicCondition.Expression(BinaryExpr(SymbolRef("a", []), BinaryOpKind.Equal, SymbolRef("b", [])))),
        ConjunctionCondition(AtomicCondition.Expression(BinaryExpr(SymbolRef("m", []), BinaryOpKind.Equal, SymbolRef("n", []))))
    ]

    // 创建 DisjunctionCondition 实例
    let disjunctionCondition = DisjunctionCondition(cond)
    let posArr = disjunctionCondition.getOrsPos()

    // 遍历输出 || 位置
    for (i in 0..posArr.size) {
        println("disjunctionCondition.getOrsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

disjunctionCondition.getOrsPos()[0]: 1:8-1:10
disjunctionCondition.getOrsPos()[1]: 1:18-1:20

class DoWhileExpr

public class DoWhileExpr <: Expr {
    public init(body: Block, condition: Expr, comments!: Array<Comment> = [])
}

功能：表示 do-while 表达式。

父类型：

• Expr

prop body

public prop body: Block

功能：获取当前 do-while 语句的循环体代码块。

类型：Block

prop condition

public prop condition: Expr

功能：获取当前 do-while 语句的继续条件表达式。

类型：Expr

init(Block, Expr, Array<Comment>)

public init(body: Block, condition: Expr, comments!: Array<Comment> = [])

功能：构造一个 DoWhileExpr 对象，表示 do-while 循环表达式。

参数：

• body: Block - 循环体代码块。
• condition: Expr - 循环继续条件表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建循环体
    let body = Block([])

    // 创建循环条件
    let condition = BinaryExpr(SymbolRef("x", []),BinaryOpKind.Gt, SymbolRef("y", []))

    // 创建 DoWhileExpr 实例
    let doWhileExpr = DoWhileExpr(
        body, 
        condition
    )

    println("doWhileExpr: ${doWhileExpr}")
}

运行结果：

doWhileExpr: do {
} while (x > y)

func getCondLParenPos()

public func getCondLParenPos(): CodePositionRange

功能：获取 DoWhileExpr 节点中条件的 ( 的位置。

返回值：

• CodePositionRange - 返回条件的 ( 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建循环体
    let body = Block([])

    // 创建循环条件
    let condition = BinaryExpr(SymbolRef("x", []), BinaryOpKind.Gt, SymbolRef("y", []))

    // 创建 DoWhileExpr 实例
    let doWhileExpr = DoWhileExpr(body, condition)
    let pos = doWhileExpr.getCondLParenPos()

    // 输出条件左括号位置
    println("doWhileExpr.getCondLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

doWhileExpr.getCondLParenPos(): 2:9-2:10

func getCondRParenPos()

public func getCondRParenPos(): CodePositionRange

功能：获取 DoWhileExpr 节点中条件的 ) 的位置。

返回值：

• CodePositionRange - 返回条件的 ) 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建循环体
    let body = Block([])

    // 创建循环条件
    let condition = BinaryExpr(SymbolRef("x", []), BinaryOpKind.Gt, SymbolRef("y", []))

    // 创建 DoWhileExpr 实例
    let doWhileExpr = DoWhileExpr(body, condition)
    let pos = doWhileExpr.getCondRParenPos()

    // 输出条件右括号位置
    println("doWhileExpr.getCondRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

doWhileExpr.getCondRParenPos(): 2:15-2:16

func getDoKeyWordPos()

public func getDoKeyWordPos(): CodePositionRange

功能：获取 DoWhileExpr 节点中 do 关键字的位置。

返回值：

• CodePositionRange - 返回 do 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建循环体
    let body = Block([])

    // 创建循环条件
    let condition = BinaryExpr(SymbolRef("x", []), BinaryOpKind.Gt, SymbolRef("y", []))

    // 创建 DoWhileExpr 实例
    let doWhileExpr = DoWhileExpr(body, condition)
    let pos = doWhileExpr.getDoKeyWordPos()

    // 输出 do 关键字位置
    println("doWhileExpr.getDoKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

doWhileExpr.getDoKeyWordPos(): 1:1-1:3

func getWhileKeyWordPos()

public func getWhileKeyWordPos(): CodePositionRange

功能：获取 DoWhileExpr 节点中 while 关键字的位置。

返回值：

• CodePositionRange - 返回 while 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建循环体
    let body = Block([])

    // 创建循环条件
    let condition = BinaryExpr(SymbolRef("x", []), BinaryOpKind.Gt, SymbolRef("y", []))

    // 创建 DoWhileExpr 实例
    let doWhileExpr = DoWhileExpr(body, condition)
    let pos = doWhileExpr.getWhileKeyWordPos()

    // 输出 while 关键字位置
    println("doWhileExpr.getWhileKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

doWhileExpr.getWhileKeyWordPos(): 2:3-2:8

class EnumConstructor

public class EnumConstructor <: Decl {
    public init(name: String, paramTyAnnotations: Array<TypeAnnotation>, annotations!: Array<Annotation> = [],
        comments!: Array<Comment> = [])
}

功能：表示一个枚举构造器。

EnumConstructor 类用于在枚举类型中声明一个构造器，name 表示构造器的名称，paramTyAnnotations 表示构造器参数的类型标注列表。

父类型：

• Decl

prop name

public prop name: String

功能：获取当前枚举构造器的名称。

类型：String

prop paramTyAnnotations

public prop paramTyAnnotations: Array<TypeAnnotation>

功能：获取当前枚举构造器参数的类型标注列表。

类型：Array<TypeAnnotation>

init(String, Array<TypeAnnotation>, Array<Annotation>, Array<Comment>)

public init(name: String, paramTyAnnotations: Array<TypeAnnotation>, annotations!: Array<Annotation> = [],
    comments!: Array<Comment> = [])

功能：构造一个 EnumConstructor 对象，表示枚举构造器节点。

参数：

• name: String - 构造器名称。
• paramTyAnnotations: Array<TypeAnnotation> - 参数类型注解列表。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 name
    let name = "EnumA"

    // 创建 paramTyAnnotations
    let paramTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]

    // 创建 annotations
    let annotations = [Annotation([Argument(None, false, LitConstExpr(LitConstKind.IntergerLiteral, "123"))], "MyAnno", AtOpKind.At)]

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        name, 
        paramTyAnnotations, 
        annotations: annotations
    )

    println("enumConstructor: ${enumConstructor}")
}

运行结果：

enumConstructor: @MyAnno[123]
EnumA(I1)

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 EnumConstructor 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor("EnumA", [])
    let pos = enumConstructor.getIdentifierPos()

    // 输出标识符位置
    println("enumConstructor.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

enumConstructor.getIdentifierPos(): 1:1-1:6

func getParamsCommasPos()

public func getParamsCommasPos(): Array<CodePositionRange>

功能：获取 EnumConstructor 节点中参数间的 , 的位置。

返回值：

• Array<CodePositionRange> - 返回参数间的 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumConstructor 实例
    let paramTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], []), CompositeType("I2", [], [])]
    let enumConstructor = EnumConstructor("EnumA", paramTyAnnotations)
    let posArr = enumConstructor.getParamsCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("enumConstructor.getParamsCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

enumConstructor.getParamsCommasPos()[0]: 1:9-1:10

func getParamsLParenPos()

public func getParamsLParenPos(): Option<CodePositionRange>

功能：获取 EnumConstructor 节点中参数的 ( 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回参数的 ( 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumConstructor 实例
    let paramTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    let enumConstructor = EnumConstructor("EnumA", paramTyAnnotations)

    if (let Some(pos) <- enumConstructor.getParamsLParenPos()) {
        // 输出参数左括号位置
        println("enumConstructor.getParamsLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumConstructor.getParamsLParenPos(): 1:6-1:7

func getParamsRParenPos()

public func getParamsRParenPos(): Option<CodePositionRange>

功能：获取 EnumConstructor 节点中参数的 ) 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回参数的 ) 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumConstructor 实例
    let paramTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    let enumConstructor = EnumConstructor("EnumA", paramTyAnnotations)

    if (let Some(pos) <- enumConstructor.getParamsRParenPos()) {
        // 输出参数右括号位置
        println("enumConstructor.getParamsRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumConstructor.getParamsRParenPos(): 1:9-1:10

class EnumDecl

public class EnumDecl <: Decl {
    public init(body: Body, constructors: Array<EnumConstructor>, genericConstraints: Option<GenericConstraints>, genericParams: Array<GenericParam>,
        isNonExhaustive: Bool, name: String, superTyAnnotations: Array<TypeAnnotation>,
        annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])
}

功能：表示一个 Enum 声明节点。

Enum 的声明使用 enum 关键字，声明依次为：可缺省的修饰符、enum 关键字、enum 名、可选的类型参数、是否指定父接口、可选的泛型约束、enum 体的声明。

父类型：

• Decl

prop body

public prop body: Body

功能：获取当前枚举声明的主体部分。

类型：Body

prop genericConstraints

public prop genericConstraints: Option<GenericConstraints>

功能：获取当前枚举声明的泛型约束（若不存在返回 None）。

类型：Option<GenericConstraints>

prop genericParams

public prop genericParams: Array<GenericParam>

功能：获取当前枚举声明的泛型参数列表。

类型：Array<GenericParam>

prop isNonExhaustive

public prop isNonExhaustive: Bool

功能：判断当前枚举声明是否为 non-exhaustive enum。

类型：Bool

prop name

public prop name: String

功能：获取当前枚举声明的名称。

类型：String

prop superTyAnnotations

public prop superTyAnnotations: Array<TypeAnnotation>

功能：获取当前枚举声明的父类类型标注列表。

类型：Array<TypeAnnotation>

init(Body, Array<EnumConstructor>, Option<GenericConstraints>, Array<GenericParam>, Bool, String, Array<TypeAnnotation>, Array<Annotation>, Array<Modifier>, Array<Comment>)

public init(body: Body, constructors: Array<EnumConstructor>, genericConstraints: Option<GenericConstraints>,
    genericParams: Array<GenericParam>, isNonExhaustive: Bool, name: String, superTyAnnotations: Array<TypeAnnotation>,
    annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])

功能：构造一个 EnumDecl 对象，表示枚举声明节点。

参数：

• body: Body - 枚举体，包含除枚举构造器外其他成员声明。
• constructors: Array<EnumConstructor> - 枚举构造器列表。
• genericConstraints: Option<GenericConstraints> - 可选的泛型约束。
• genericParams: Array<GenericParam> - 泛型参数列表。
• isNonExhaustive: Bool - 是否为非穷举枚举。
• name: String - 枚举名。
• superTyAnnotations: Array<TypeAnnotation> - 父类类型标注列表。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• modifiers!: Array<Modifier> - 修饰符列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 constructors 为空，或输入的 body 中的节点不是函数声明、属性声明及宏展开声明，或当泛型约束与泛型参数不对应，或输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 body
    let body = Body([])

    // 创建 constructor
    let constructor = [EnumConstructor("EnumA", [])]

    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建 genericParams
    let genericParams = [GenericParam("T")]

    // 创建 isNonExhaustive
    let isNonExhaustive = true

    // 创建 name
    let name = "A"

    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]

    // 创建 EnumDecl 实例
    let enumDecl = EnumDecl(
        body, 
        constructor, 
        genericConstraints, 
        genericParams, 
        isNonExhaustive, 
        name, 
        superTyAnnotations
    )

    println("enumDecl: ${enumDecl}")
}

运行结果：

enumDecl: enum A<T> <: I1 where T<:I1 {
    | EnumA
    | ...
}

func getCaseSeparatorsPos()

public func getCaseSeparatorsPos(): Array<CodePositionRange>

功能：获取 EnumDecl 节点中 | 的位置。

返回值：

• Array<CodePositionRange> - 返回 | 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let constructors = [EnumConstructor("A", []), EnumConstructor("B", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, [], false, "MyEnum", [])
    let posArr = enumDecl.getCaseSeparatorsPos()

    // 遍历输出竖线位置
    for (i in 0..posArr.size) {
        println("enumDecl.getCaseSeparatorsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

enumDecl.getCaseSeparatorsPos()[0]: 2:5-2:6
enumDecl.getCaseSeparatorsPos()[1]: 3:5-3:6

func getEnumKeyWordPos()

public func getEnumKeyWordPos(): CodePositionRange

功能：获取 EnumDecl 节点中 enum 关键字的位置。

返回值：

• CodePositionRange - 返回 enum 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let constructors = [EnumConstructor("A", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, [], false, "MyEnum", [])
    let pos = enumDecl.getEnumKeyWordPos()

    // 输出 enum 关键字位置
    println("enumDecl.getEnumKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

enumDecl.getEnumKeyWordPos(): 1:1-1:5

func getGenericParamsCommasPos()

public func getGenericParamsCommasPos(): Array<CodePositionRange>

功能：获取 EnumDecl 节点中泛型参数中 , 的位置。

返回值：

• Array<CodePositionRange> - 返回泛型参数中 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let genericParams = [GenericParam("T"), GenericParam("U")]
    let constructors = [EnumConstructor("A", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, genericParams, false, "MyEnum", [])
    let posArr = enumDecl.getGenericParamsCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("enumDecl.getGenericParamsCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

enumDecl.getGenericParamsCommasPos()[0]: 1:14-1:15

func getGenericParamsLAnglePos()

public func getGenericParamsLAnglePos(): Option<CodePositionRange>

功能：获取 EnumDecl 节点中泛型参数的 < 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回泛型参数的 < 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let genericParams = [GenericParam("T")]
    let constructors = [EnumConstructor("A", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, genericParams, false, "MyEnum", [])

    if (let Some(pos) <- enumDecl.getGenericParamsLAnglePos()) {
        // 输出泛型参数左尖括号位置
        println("enumDecl.getGenericParamsLAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumDecl.getGenericParamsLAnglePos(): 1:12-1:13

func getGenericParamsRAnglePos()

public func getGenericParamsRAnglePos(): Option<CodePositionRange>

功能：获取 EnumDecl 节点中泛型参数的 > 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回泛型参数的 > 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let genericParams = [GenericParam("T")]
    let constructors = [EnumConstructor("A", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, genericParams, false, "MyEnum", [])

    if (let Some(pos) <- enumDecl.getGenericParamsRAnglePos()) {
        // 输出泛型参数右尖括号位置
        println("enumDecl.getGenericParamsRAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumDecl.getGenericParamsRAnglePos(): 1:14-1:15

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 EnumDecl 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let constructors = [EnumConstructor("A", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, [], false, "MyEnum", [])
    let pos = enumDecl.getIdentifierPos()

    // 输出标识符位置
    println("enumDecl.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

enumDecl.getIdentifierPos(): 1:6-1:12

func getNonExhaustiveTripleDotPos()

public func getNonExhaustiveTripleDotPos(): Option<CodePositionRange>

功能：获取 EnumDecl 节点中 ... 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ... 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let constructors = [EnumConstructor("A", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, [], true, "MyEnum", [])

    if (let Some(pos) <- enumDecl.getNonExhaustiveTripleDotPos()) {
        // 输出三点位置
        println("enumDecl.getNonExhaustiveTripleDotPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumDecl.getNonExhaustiveTripleDotPos(): 3:7-3:10

func getSuperTyAnnotationsBitAndsPos()

public func getSuperTyAnnotationsBitAndsPos(): Array<CodePositionRange>

功能：获取 EnumDecl 节点的父类型中 & 的位置。

返回值：

• Array<CodePositionRange> - 返回父类型中 & 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], []), CompositeType("I2", [], [])]
    let constructors = [EnumConstructor("A", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, [], false, "MyEnum", superTyAnnotations)
    let posArr = enumDecl.getSuperTyAnnotationsBitAndsPos()

    // 遍历输出&位置
    for (i in 0..posArr.size) {
        println("enumDecl.getSuperTyAnnotationsBitAndsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

enumDecl.getSuperTyAnnotationsBitAndsPos()[0]: 1:19-1:20

func getUpperBoundPos()

public func getUpperBoundPos(): Option<CodePositionRange>

功能：获取 EnumDecl 节点中 <: 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回父类型中 & 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumDecl 实例
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    let constructors = [EnumConstructor("A", [])]
    let enumDecl = EnumDecl(Body([]), constructors, None, [], false, "MyEnum", superTyAnnotations)

    if (let Some(pos) <- enumDecl.getUpperBoundPos()) {
        // 输出 <: 位置
        println("enumDecl.getUpperBoundPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumDecl.getUpperBoundPos(): 1:13-1:15

class EnumPattern

public class EnumPattern <: Pattern {
    public init(enumConstructor: SymbolRef, enumType: Option<CompositeType>, subPatterns: Array<Pattern>, 
        comments!: Array<Comment> = [])
}

功能：表示 enum 模式节点。

用于匹配 enum 的 constructor， 如 case Year(n) => 1 中的 Year(n)。

父类型：

• Pattern

prop enumConstructor

public prop enumConstructor: SymbolRef

功能：表示 enum 构造器。

类型：SymbolRef

prop enumType

public prop enumType: Option<CompositeType>

功能：表示该 enum 模式节点中的前缀类型，例如，p1.p0.E<Int64> 是模式 p1.p0.E<Int64>.C0(x) 的 enumType。

类型：Option<CompositeType>

prop subPatterns

public prop subPatterns: Array<Pattern>

功能：表示该模式节点中有参构造器内的模式节点列表。

类型：Array<Pattern>

init(SymbolRef, Option<CompositeType>, Array<Pattern>, Array<Comment>)

public init(enumConstructor: SymbolRef, enumType: Option<CompositeType>, subPatterns: Array<Pattern>, comments!: Array<Comment> = [])

功能：构造一个 EnumPattern 对象，表示枚举模式。

参数：

• enumConstructor: SymbolRef - 枚举构造器引用。
• enumType: Option<CompositeType> - 可选的枚举类型前缀，如 Result。
• subPatterns: Array<Pattern> - 子模式列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 enumConstructor
    let enumConstructor = SymbolRef("A", [])

    // 创建 enumType
    let enumType = CompositeType("C1", [], [])

    // 创建 subPatterns
    let subPatterns: Array<Pattern> = [VarPattern("x")]

    // 创建 EnumPattern 实例
    let enumPattern = EnumPattern(
        enumConstructor, 
        enumType, 
        subPatterns
    )

    println("enumPattern: ${enumPattern}")
}

运行结果：

enumPattern: C1.A(x)

func getCommasPos()

public func getCommasPos(): Array<CodePositionRange>

功能：获取 EnumPattern 节点中 , 的位置。

返回值：

• Array<CodePositionRange> - 返回 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumPattern 实例
    let enumConstructor = SymbolRef("A", [])
    let subPatterns: Array<Pattern> = [VarPattern("x"), VarPattern("y")]
    let enumPattern = EnumPattern(enumConstructor, None, subPatterns)
    let posArr = enumPattern.getCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("enumPattern.getCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

enumPattern.getCommasPos()[0]: 1:4-1:5

func getDotPos()

public func getDotPos(): Option<CodePositionRange>

功能：获取 EnumPattern 节点中 . 的位置。

返回值：

• Option<CodePositionRange> - 返回 . 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumPattern 实例
    let enumConstructor = SymbolRef("A", [])
    let enumType = CompositeType("C1", [], [])
    let subPatterns: Array<Pattern> = [VarPattern("x")]
    let enumPattern = EnumPattern(enumConstructor, enumType, subPatterns)

    if (let Some(pos) <- enumPattern.getDotPos()) {
        // 输出点位置
        println("enumPattern.getDotPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumPattern.getDotPos(): 1:3-1:4

func getLParenPos()

public func getLParenPos(): Option<CodePositionRange>

功能：获取 EnumPattern 节点中 ( 的位置。

返回值：

• Option<CodePositionRange> - 返回 ( 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumPattern 实例
    let enumConstructor = SymbolRef("A", [])
    let subPatterns: Array<Pattern> = [VarPattern("x")]
    let enumPattern = EnumPattern(enumConstructor, None, subPatterns)

    if (let Some(pos) <- enumPattern.getLParenPos()) {
        // 输出左括号位置
        println("enumPattern.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumPattern.getLParenPos(): 1:2-1:3

func getRParenPos()

public func getRParenPos(): Option<CodePositionRange>

功能：获取 EnumPattern 节点中 ) 的位置。

返回值：

• Option<CodePositionRange> - 返回 ) 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 EnumPattern 实例
    let enumConstructor = SymbolRef("A", [])
    let subPatterns: Array<Pattern> = [VarPattern("x")]
    let enumPattern = EnumPattern(enumConstructor, None, subPatterns)

    if (let Some(pos) <- enumPattern.getRParenPos()) {
        // 输出右括号位置
        println("enumPattern.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

enumPattern.getRParenPos(): 1:4-1:5

class Expr

sealed abstract class Expr <: SyntaxTreeNode {}

功能：表示一个表达式节点。

父类型：

• SyntaxTreeNode

class ExtendDecl

public class ExtendDecl <: Decl {
    public init(body: Body, extendedTyAnnotation: TypeAnnotation, genericConstraints: Option<GenericConstraints>,
        genericParams: Array<GenericParam>, superTyAnnotations: Array<TypeAnnotation>,
        annotations!: Array<Annotation> = [], comments!: Array<Comment> = [])
}

功能：表示一个扩展声明节点。

扩展的声明使用 extend 关键字，扩展声明依次为：extend 关键字、扩展类型、是否指定父接口、可选的泛型约束、扩展体的声明。

父类型：

• Decl

prop body

public prop body: Body

功能：获取当前扩展声明的主体部分。

类型：Body

prop extendedTyAnnotation

public prop extendedTyAnnotation: TypeAnnotation

功能：获取当前扩展声明的被扩展类型标注。

类型：TypeAnnotation

prop genericConstraints

public prop genericConstraints: Option<GenericConstraints>

功能：获取当前扩展声明的泛型约束（若不存在返回 None）。

类型：Option<GenericConstraints>

prop genericParams

public prop genericParams: Array<GenericParam>

功能：获取当前扩展声明的泛型参数列表。

类型：Array<GenericParam>

prop superTyAnnotations

public prop superTyAnnotations: Array<TypeAnnotation>

功能：获取当前扩展声明的父类类型标注列表。

类型：Array<TypeAnnotation>

init(Body, TypeAnnotation, Option<GenericConstraints>, Array<GenericParam>, Array<TypeAnnotation>, Array<Annotation>, Array<Comment>)

public init(body: Body, extendedTyAnnotation: TypeAnnotation, genericConstraints: Option<GenericConstraints>,
    genericParams: Array<GenericParam>, superTyAnnotations: Array<TypeAnnotation>,
    annotations!: Array<Annotation> = [], comments!: Array<Comment> = [])

功能：构造一个 ExtendDecl 对象，表示扩展声明节点。

参数：

• body: Body - 扩展体，包含成员声明。
• extendedTyAnnotation: TypeAnnotation - 被扩展的类型注解。
• genericConstraints: Option<GenericConstraints> - 可选的泛型约束。
• genericParams: Array<GenericParam> - 泛型参数列表。
• superTyAnnotations: Array<TypeAnnotation> - 父类类型标注列表。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 body 中有除函数声明、宏展开声明和属性声明外的声明或当泛型约束与泛型参数不对应时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建扩展体，包含一些成员声明
    let body = Body([])

    // 设置被扩展的类型注解
    let extendedTyAnnotation = CompositeType("C1", [], [])

    // 创建泛型约束（无）
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建泛型参数
    let genericParams = [GenericParam("T")]

    // 设置父类型注解
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]

    // 创建注解
    let annotations = [Annotation([Argument(None, false, LitConstExpr(LitConstKind.IntergerLiteral, "123"))], "MyAnno", AtOpKind.At)]

    // 创建 ExtendDecl 实例
    let extendDecl = ExtendDecl(
        body, 
        extendedTyAnnotation, 
        genericConstraints, 
        genericParams, 
        superTyAnnotations, 
        annotations: annotations
    )

    println("extendDecl: ${extendDecl}")
}

运行结果：

extendDecl: @MyAnno[123]
extend<T> C1 <: I1 where T<:I1 {
}

func getExtendKeyWordPos()

public func getExtendKeyWordPos(): CodePositionRange

功能：获取 ExtendDecl 节点中 extend 关键字的位置。

返回值：

• CodePositionRange - 返回 extend 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建扩展体
    let body = Body([])

    // 设置被扩展的类型注解
    let extendedTyAnnotation = CompositeType("C1", [], [])

    // 创建泛型约束（无）
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建泛型参数
    let genericParams = [GenericParam("T")]

    // 设置父类型注解
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ExtendDecl 实例
    let extendDecl = ExtendDecl(
        body, 
        extendedTyAnnotation, 
        genericConstraints, 
        genericParams, 
        superTyAnnotations
    )
    
    // 获取 extend 关键字位置
    let pos = extendDecl.getExtendKeyWordPos()
    
    // 输出 extend 关键字位置
    println("extendDecl.getExtendKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

extendDecl.getExtendKeyWordPos(): 1:1-1:7

func getGenericParamsCommasPos()

public func getGenericParamsCommasPos(): Array<CodePositionRange>

功能：获取 ExtendDecl 节点中泛型参数中 , 的位置。

返回值：

• Array<CodePositionRange> - 返回泛型参数中 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建扩展体
    let body = Body([])

    // 设置被扩展的类型注解
    let extendedTyAnnotation = CompositeType("C1", [], [])

    // 创建泛型约束（无）
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建泛型参数
    let genericParams = [GenericParam("T"), GenericParam("U"), GenericParam("V")]

    // 设置父类型注解
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ExtendDecl 实例
    let extendDecl = ExtendDecl(
        body, 
        extendedTyAnnotation, 
        genericConstraints, 
        genericParams, 
        superTyAnnotations
    )
    
    // 获取泛型参数中逗号的位置
    let posArr = extendDecl.getGenericParamsCommasPos()
    
    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("extendDecl.getGenericParamsCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

extendDecl.getGenericParamsCommasPos()[0]: 1:9-1:10
extendDecl.getGenericParamsCommasPos()[1]: 1:12-1:13

func getGenericParamsLAnglePos()

public func getGenericParamsLAnglePos(): Option<CodePositionRange>

功能：获取 ExtendDecl 节点中泛型参数的 < 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回泛型参数中 < 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建扩展体
    let body = Body([])

    // 设置被扩展的类型注解
    let extendedTyAnnotation = CompositeType("C1", [], [])

    // 创建泛型约束（无）
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建泛型参数
    let genericParams = [GenericParam("T")]

    // 设置父类型注解
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ExtendDecl 实例
    let extendDecl = ExtendDecl(
        body, 
        extendedTyAnnotation, 
        genericConstraints, 
        genericParams, 
        superTyAnnotations
    )
    
    // 获取泛型参数左尖括号的位置
    if (let Some(pos) <- extendDecl.getGenericParamsLAnglePos()) {
        // 输出左尖括号位置
        println("extendDecl.getGenericParamsLAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    } else {
        println("No left angle bracket found")
    }
}

运行结果：

extendDecl.getGenericParamsLAnglePos(): 1:7-1:8

func getGenericParamsRAnglePos()

public func getGenericParamsRAnglePos(): Option<CodePositionRange>

功能：获取 ExtendDecl 节点中泛型参数的 > 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回泛型参数中 > 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建扩展体
    let body = Body([])

    // 设置被扩展的类型注解
    let extendedTyAnnotation = CompositeType("C1", [], [])

    // 创建泛型约束（无）
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建泛型参数
    let genericParams = [GenericParam("T")]

    // 设置父类型注解
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ExtendDecl 实例
    let extendDecl = ExtendDecl(
        body, 
        extendedTyAnnotation, 
        genericConstraints, 
        genericParams, 
        superTyAnnotations
    )
    
    // 获取泛型参数右尖括号的位置
    if (let Some(pos) <- extendDecl.getGenericParamsRAnglePos()) {
        // 输出右尖括号位置
        println("extendDecl.getGenericParamsRAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    } else {
        println("No right angle bracket found")
    }
}

运行结果：

extendDecl.getGenericParamsRAnglePos(): 1:9-1:10

func getSuperTyAnnotationsBitAndsPos()

public func getSuperTyAnnotationsBitAndsPos(): Array<CodePositionRange>

功能：获取 ExtendDecl 节点中父类型中 & 的位置。

返回值：

• Array<CodePositionRange> - 返回父类型中 & 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建扩展体
    let body = Body([])

    // 设置被扩展的类型注解
    let extendedTyAnnotation = CompositeType("C1", [], [])

    // 创建泛型约束（无）
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建泛型参数
    let genericParams = [GenericParam("T")]
    
    // 创建多个父类型（使用 & 连接）
    let superTyAnnotations: Array<TypeAnnotation> = [
        CompositeType("I1", [], []),
        CompositeType("I2", [], []),
        CompositeType("I3", [], [])
    ]
    
    // 创建 ExtendDecl 实例
    let extendDecl = ExtendDecl(
        body, 
        extendedTyAnnotation, 
        genericConstraints, 
        genericParams, 
        superTyAnnotations
    )
    
    // 获取父类型中 & 的位置
    let posArr = extendDecl.getSuperTyAnnotationsBitAndsPos()
    
    // 遍历输出 & 位置
    for (i in 0..posArr.size) {
        println("extendDecl.getSuperTyAnnotationsBitAndsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

extendDecl.getSuperTyAnnotationsBitAndsPos()[0]: 1:20-1:21
extendDecl.getSuperTyAnnotationsBitAndsPos()[1]: 1:25-1:26

func getUpperBoundPos()

public func getUpperBoundPos(): Option<CodePositionRange>

功能：获取 ExtendDecl 节点中 <: 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 <: 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建扩展体
    let body = Body([])

    // 设置被扩展的类型注解
    let extendedTyAnnotation = CompositeType("C1", [], [])

    // 创建泛型约束（无）
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建泛型参数
    let genericParams = [GenericParam("T")]

    // 设置父类型注解
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    
    // 创建 ExtendDecl 实例
    let extendDecl = ExtendDecl(
        body, 
        extendedTyAnnotation, 
        genericConstraints, 
        genericParams, 
        superTyAnnotations
    )
    
    // 获取 <: 位置
    if (let Some(pos) <- extendDecl.getUpperBoundPos()) {
        // 输出 <: 位置
        println("extendDecl.getUpperBoundPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    } else {
        println("No upper bound found")
    }
}

运行结果：

extendDecl.getUpperBoundPos(): 1:14-1:16

class FeatureId

public class FeatureId <: SyntaxTreeNode {
    public init(identifiers: Array<String>, comments!: Array<Comment> = [])
}

功能：一个 feature 标识节点。

父类型：

• SyntaxTreeNode

prop featureNameIdentifiers

public prop featureNameIdentifiers: Array<String> 

功能：获取 feature 名称中的标识符。

类型：Array<String>

init(Array<String>, Array<Comment>)

public init(identifiers: Array<String>, comments!: Array<Comment> = [])

功能：构造一个对象。

参数：

• features: Array<String> - feature 名称数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当数组为空或包含空字符串时抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 identifiers
    let identifiers = ["std", "core", "feature"]

    // 创建 FeatureId 实例
    let featureId = FeatureId(
        identifiers
    )

    println("featureId: ${featureId}")
}

运行结果：

featureId: std.core.feature

func getDotPoses()

public func getDotPoses(): Array<CodePositionRange>

功能：获取 feature 名称中的 . 的位置。

返回值：

• Array<CodePositionRange>

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 identifiers
    let identifiers = ["std", "core", "feature"]

    // 创建 FeatureId 实例
    let featureId = FeatureId(identifiers)
    
    // 获取点的位置
    let posArr = featureId.getDotPoses()
    
    // 遍历输出点的位置
    for (i in 0..posArr.size) {
        println("featureId.getDotPoses()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

featureId.getDotPoses()[0]: 1:4-1:5
featureId.getDotPoses()[1]: 1:9-1:10

func getIdentifierPos()

public func getIdentifierPos(): Array<CodePositionRange> 

功能：获取 feature 名称中的标识符位置。

返回值：

• Array<CodePositionRange>

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 identifiers
    let identifiers = ["std", "core", "feature"]

    // 创建 FeatureId 实例
    let featureId = FeatureId(identifiers)
    
    // 获取标识符的位置
    let posArr = featureId.getIdentifierPos()
    
    // 遍历输出标识符位置
    for (i in 0..posArr.size) {
        println("featureId.getIdentifierPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

featureId.getIdentifierPos()[0]: 1:1-1:4
featureId.getIdentifierPos()[1]: 1:5-1:9
featureId.getIdentifierPos()[2]: 1:10-1:17

class FeaturesDirective

public class FeaturesDirective <: SyntaxTreeNode {
    public init(annotations: Array<Annotation>, set: FeaturesSet, comments!: Array<Comment> = [])
}

功能：一个 features 声明节点。

父类型：

• SyntaxTreeNode

prop annotations

public prop annotations: Array<Annotation>

功能：获取当前声明的注解列表。

类型：Array<Annotation>

prop featuresSet

public prop featuresSet: FeaturesSet

功能：获取当前声明的 features set。

类型：FeaturesSet

init(Array<Annotation>, FeaturesSet, Array<Comment>)

public init(annotations: Array<Annotation>, set: FeaturesSet, comments!: Array<Comment> = [])

功能：构造一个 FeatureId 对象。

参数：

• annotations: Array<Annotation> - 一组在 feature directive 声明节点上的注解。
• set: FeaturesSet - 一组 features 名称。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 featureId 无法构造时抛出异常。

示例：

import stdx.syntax.*

main() {
    // 创建注解
    let annotations: Array<Annotation> = []

    // 创建 FeatureId
    let featureId1 = FeatureId(["std", "core", "feature1"])
    let featureId2 = FeatureId(["std", "core", "feature2"])

    // 创建 FeaturesSet
    let featuresSet = FeaturesSet([featureId1, featureId2])

    // 创建 FeaturesDirective 实例
    let featuresDirective = FeaturesDirective(
        annotations, 
        featuresSet
    )

    println("featuresDirective: ${featuresDirective}")
}

运行结果：

featuresDirective: features {std.core.feature1, std.core.feature2}

func getFeaturesKeywordPos()

public func getFeaturesKeywordPos(): CodePositionRange    

功能：获取声明中的关键字 features 的位置信息。

返回值：

• CodePositionRange

示例：

import stdx.syntax.*

main(): Unit {
    // 创建注解
    let annotations: Array<Annotation> = []

    // 创建 FeatureId
    let featureId = FeatureId(["std", "core", "feature"])

    // 创建 FeaturesSet
    let featuresSet = FeaturesSet([featureId])

    // 创建 FeaturesDirective 实例
    let featuresDirective = FeaturesDirective(
        annotations, 
        featuresSet
    )

    // 获取 features 关键字的位置
    let pos = featuresDirective.getFeaturesKeywordPos()

    // 输出关键字位置
    println("featuresDirective.getFeaturesKeywordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

featuresDirective.getFeaturesKeywordPos(): 1:1-1:9

class FeaturesSet

public class FeaturesSet <: SyntaxTreeNode {
    public init(features: Array<FeatureId>, comments!: Array<Comment> = [])
}

功能：一个 feature set 节点。

父类型：

• SyntaxTreeNode

prop content

public prop content: Array<FeatureId>

功能：获取 features set 内包含的一组 featureId。

类型：Array<FeatureId>

init(Array<FeatureId>, Array<Comment>)

public init(features: Array<FeatureId>, comments!: Array<Comment> = [])

功能：创建一个 FeaturesSet 对象。

参数：

• features: Array<FeatureId> - 一组定义在 features set 中的 feature id。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 FeatureId
    let featureId1 = FeatureId(["std", "core", "feature1"])
    let featureId2 = FeatureId(["std", "core", "feature2"])

    // 创建 FeaturesSet 实例
    let featuresSet = FeaturesSet([featureId1, featureId2])

    println("featuresSet: ${featuresSet}")
}

运行结果：

featuresSet: {std.core.feature1, std.core.feature2}

func getLCurlPos()

public func getLCurlPos(): CodePositionRange 

功能：获取 '{' 的位置信息。

返回值：

• CodePositionRange

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FeatureId
    let featureId = FeatureId(["std", "core", "feature"])

    // 创建 FeaturesSet 实例
    let featuresSet = FeaturesSet([featureId])

    // 获取左花括号的位置
    let pos = featuresSet.getLCurlPos()

    // 输出左花括号位置
    println("featuresSet.getLCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

featuresSet.getLCurlPos(): 1:1-1:2

func getRCurlPos()

public func getRCurlPos(): CodePositionRange

功能：获取 '}' 的位置信息。

返回值：

• CodePositionRange

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FeatureId
    let featureId = FeatureId(["std", "core", "feature"])

    // 创建 FeaturesSet 实例
    let featuresSet = FeaturesSet([featureId])

    // 获取右花括号的位置
    let pos = featuresSet.getRCurlPos()

    // 输出右花括号位置
    println("featuresSet.getRCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

featuresSet.getRCurlPos(): 1:18-1:19

func getCommaPoses()

public func getCommaPoses(): Array<CodePositionRange>

功能：获取 ',' 的位置信息。

返回值：

• Array<CodePositionRange>

示例：

import stdx.syntax.*

main(): Unit {
    // 创建多个 FeatureId
    let featureId1 = FeatureId(["std", "core", "feature1"])
    let featureId2 = FeatureId(["std", "core", "feature2"])
    let featureId3 = FeatureId(["std", "core", "feature3"])

    // 创建 FeaturesSet 实例
    let featuresSet = FeaturesSet([featureId1, featureId2, featureId3])

    // 获取逗号的位置
    let posArr = featuresSet.getCommaPoses()

    // 输出逗号位置
    for (i in 0..posArr.size) {
        println("featuresSet.getCommaPoses()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

featuresSet.getCommaPoses()[0]: 1:19-1:20
featuresSet.getCommaPoses()[1]: 1:38-1:39

class ForInExpr

public class ForInExpr <: Expr {
    public init(body: Block, expr: Expr, pattern: Pattern, patternGuard: Option<Expr>, comments!: Array<Comment> = [])
}

功能：表示 for-in 表达式。

ForInExpr 类型中，关键字 for 之后是 Pattern, 此后是一个 in 关键字和表达式节点，最后是一个执行循环体 Block。

父类型：

• Expr

prop body

public prop body: Block

功能：获取当前 for-in 语句的循环体代码块。

类型：Block

prop expr

public prop expr: Expr

功能：获取当前 for-in 语句的集合表达式，即要遍历的对象。

类型：Expr

prop pattern

public prop pattern: Pattern

功能：获取当前 for-in 语句的迭代变量模式。

类型：Pattern

prop patternGuard

public prop patternGuard: Option<Expr>

功能：获取当前 for-in 语句中用于迭代的条件表达式（若不存在返回 None）。

类型：Option<Expr>

init(Block, Expr, Pattern, Option<Expr>, Array<Comment>)

public init(body: Block, expr: Expr, pattern: Pattern, patternGuard: Option<Expr>, comments!: Array<Comment> = [])

功能：构造一个 ForInExpr 对象，表示 for-in 循环表达式。

参数：

• body: Block - 循环体代码块。
• expr: Expr - 被迭代的集合表达式。
• pattern: Pattern - 用于解构每次迭代值的绑定模式。
• patternGuard: Option<Expr> - 可选的模式守卫表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 pattern 不是通配符模式、变量绑定模式、元组模式或枚举模式时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 body
    let body = Block([])

    // 创建 expr
    let expr = LitConstExpr(LitConstKind.IntergerLiteral, "10")

    // 创建 pattern
    let pattern = VarPattern("x")

    // 创建 patternGuard
    let patternGuard = BinaryExpr(SymbolRef("x", []),BinaryOpKind.NotEq, LitConstExpr(LitConstKind.IntergerLiteral, "5"))

    // 创建 ForInExpr 实例
    let forInExpr = ForInExpr(
        body, 
        expr, 
        pattern, 
        patternGuard
    )

    println("forInExpr: ${forInExpr}")
}

运行结果：

forInExpr: for (x in 10 where x != 5) {
}

func getForKeyWordPos()

public func getForKeyWordPos(): CodePositionRange

功能：获取 ForInExpr 节点中 for 关键字的位置。

返回值：

• CodePositionRange - 返回 for 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ForInExpr 实例
    let forInExpr = ForInExpr(Block([]), LitConstExpr(LitConstKind.IntergerLiteral, "10"), VarPattern("x"), None)
    let pos = forInExpr.getForKeyWordPos()

    // 输出 for 关键字位置
    println("forInExpr.getForKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

forInExpr.getForKeyWordPos(): 1:1-1:4

func getInKeyWordPos()

public func getInKeyWordPos(): CodePositionRange

功能：获取 ForInExpr 节点中 in 关键字的位置。

返回值：

• CodePositionRange - 返回 in 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ForInExpr 实例
    let forInExpr = ForInExpr(Block([]), LitConstExpr(LitConstKind.IntergerLiteral, "10"), VarPattern("x"), None)
    let pos = forInExpr.getInKeyWordPos()

    // 输出 in 关键字位置
    println("forInExpr.getInKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

forInExpr.getInKeyWordPos(): 1:8-1:10

func getLParenPos()

public func getLParenPos(): CodePositionRange

功能：获取 ForInExpr 节点中的 ( 的位置。

返回值：

• CodePositionRange - 返回 ( 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ForInExpr 实例
    let forInExpr = ForInExpr(Block([]), LitConstExpr(LitConstKind.IntergerLiteral, "10"), VarPattern("x"), None)
    let pos = forInExpr.getLParenPos()

    // 输出左括号位置
    println("forInExpr.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

forInExpr.getLParenPos(): 1:5-1:6

func getRParenPos()

public func getRParenPos(): CodePositionRange

功能：获取 ForInExpr 节点中的 ) 的位置。

返回值：

• CodePositionRange - 返回 ) 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ForInExpr 实例
    let forInExpr = ForInExpr(Block([]), LitConstExpr(LitConstKind.IntergerLiteral, "10"), VarPattern("x"), None)
    let pos = forInExpr.getRParenPos()

    // 输出右括号位置
    println("forInExpr.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

forInExpr.getRParenPos(): 1:13-1:14

func getWhereKeyWordPos()

public func getWhereKeyWordPos(): Option<CodePositionRange>

功能：获取 ForInExpr 节点中 where 关键字的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 where 关键字的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 patternGuard
    let patternGuard = BinaryExpr(SymbolRef("x", []), BinaryOpKind.NotEq, LitConstExpr(LitConstKind.IntergerLiteral, "5"))

    // 创建 ForInExpr 实例
    let forInExpr = ForInExpr(Block([]), LitConstExpr(LitConstKind.IntergerLiteral, "10"), VarPattern("x"), patternGuard)

    if (let Some(pos) <- forInExpr.getWhereKeyWordPos()) {
        // 输出 where 关键字位置
        println("forInExpr.getWhereKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

forInExpr.getWhereKeyWordPos(): 1:14-1:19

class FuncDecl

public class FuncDecl <: Decl {
    public init(body: Option<Block>, genericConstraints: Option<GenericConstraints>, genericParams: Array<GenericParam>,
        kind: FuncKind, name: String, params: ParameterList, retTyAnnotation: Option<TypeAnnotation>,
        annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])
}

功能：表示一个函数声明节点。

由可选的函数修饰符，关键字 func，函数名，可选的泛型约束列表，可选的类型形参列表，函数参数，可选的函数体，可缺省的函数返回类型来声明一个函数。

父类型：

• Decl

prop body

public prop body: Option<Block>

功能：获取当前函数声明的主体部分（若不存在返回 None）。

类型：Option<Block>

prop genericConstraints

public prop genericConstraints: Option<GenericConstraints>

功能：获取当前函数声明的泛型约束（若不存在返回 None）。

类型：Option<GenericConstraints>

prop genericParams

public prop genericParams: Array<GenericParam>

功能：获取当前函数声明的泛型参数列表。

类型：Array<GenericParam>

prop kind

public prop kind: FuncKind

功能：获取当前函数声明的种类。

类型：FuncKind

prop name

public prop name: String

功能：获取当前函数声明的名称。

类型：String

prop params

public prop params: ParameterList

功能：获取当前函数声明的参数列表。

类型：ParameterList

prop retTyAnnotation

public prop retTyAnnotation: Option<TypeAnnotation>

功能：获取当前函数声明的返回类型标注（若不存在返回 None）。

类型：Option<TypeAnnotation>

init(Option<Block>, Option<GenericConstraints>, Array<GenericParam>, FuncKind, String, ParameterList, Option<TypeAnnotation>, Array<Annotation>, Array<Modifier>, Array<Comment>)

public init(body: Option<Block>, genericConstraints: Option<GenericConstraints>, genericParams: Array<GenericParam>,
    kind: FuncKind, name: String, params: ParameterList, retTyAnnotation: Option<TypeAnnotation>,
    annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])

功能：构造一个 FuncDecl 对象，表示函数声明节点。

参数：

• body: Option<Block> - 可选的函数体。
• genericConstraints: Option<GenericConstraints> - 可选的泛型约束。
• genericParams: Array<GenericParam> - 泛型参数列表。
• kind: FuncKind - 函数种类。
• name: String - 函数名。
• params: ParameterList - 参数列表。
• retTyAnnotation: Option<TypeAnnotation> - 可选的返回类型注解。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• modifiers!: Array<Modifier> - 修饰符列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当函数种类和修饰符不对应，或输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 body
    let body = Block([ReturnExpr(None)])

    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建 genericParams
    let genericParams = [GenericParam("T")]

    // 创建 kind
    let kind = FuncKind.Normal

    // 创建 name
    let name = "foo"

    // 创建 params
    let params = ParameterList([])

    // 创建 retTyAnnotation
    let retTyAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 FuncDecl 实例
    let funcDecl = FuncDecl(
        body, 
        genericConstraints, 
        genericParams, 
        kind, 
        name, 
        params, 
        retTyAnnotation
    )

    println("funcDecl: ${funcDecl}")
}

运行结果：

funcDecl: func foo<T>(): Int64 where T<:I1 {
    return
}

func getFuncKeyWordPos()

public func getFuncKeyWordPos(): Option<CodePositionRange>

功能：获取 FuncDecl 节点中 func 关键字的位置。

返回值：

• Option<CodePositionRange> - 返回 func 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncDecl 实例
    let funcDecl = FuncDecl(
        Block([ReturnExpr(None)]),
        None,
        [],
        FuncKind.Normal,
        "foo",
        ParameterList([]),
        AtomicType(AtomicTypeKind.Int64Type)
    )

    if (let Some(pos) <- funcDecl.getFuncKeyWordPos()) {
        // 输出 func 关键字位置
        println("funcDecl.getFuncKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

funcDecl.getFuncKeyWordPos(): 1:1-1:5

func getFuncKindKeyWordPos()

public func getFuncKindKeyWordPos(): Option<CodePositionRange>

功能：获取 FuncDecl 节点中 FuncKind 关键字的位置。

返回值：

• Option<CodePositionRange> - 返回 FuncKind 关键字的位置。

注意：

kind 为 Finalizer 时，返回 ~ 的位置，kind 为 Operator 时，返回 operator 的位置，kind 为 Foreign 时，返回 foriegn 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 Operator 类型的 FuncDecl 实例
    let operatorFuncDecl = FuncDecl(
        Block([ReturnExpr(None)]),
        None,
        [],
        FuncKind.Operator,
        "+",
        ParameterList([]),
        AtomicType(AtomicTypeKind.Int64Type),
        modifiers: [Modifier(ModifierKind.Operator)]
    )

    if (let Some(pos) <- operatorFuncDecl.getFuncKindKeyWordPos()) {
        // 输出 operator 关键字位置
        println("operatorFuncDecl.getFuncKindKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

operatorFuncDecl.getFuncKindKeyWordPos(): 1:1-1:9

func getGenericParamsCommasPos()

public func getGenericParamsCommasPos(): Array<CodePositionRange>

功能：获取 FuncDecl 节点中泛型参数间 , 的位置。

返回值：

• Array<CodePositionRange> - 返回泛型参数间 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建带有多个泛型参数的 FuncDecl 实例
    let funcDecl = FuncDecl(
        Block([ReturnExpr(None)]),
        None,
        [GenericParam("T"), GenericParam("U"), GenericParam("V")],
        FuncKind.Normal,
        "foo",
        ParameterList([]),
        AtomicType(AtomicTypeKind.Int64Type)
    )

    // 获取泛型参数间逗号的位置
    let posArr = funcDecl.getGenericParamsCommasPos()

    // 输出逗号位置
    for (i in 0..posArr.size) {
        println("funcDecl.getGenericParamsCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

funcDecl.getGenericParamsCommasPos()[0]: 1:11-1:12
funcDecl.getGenericParamsCommasPos()[1]: 1:14-1:15

func getGenericParamsLAnglePos()

public func getGenericParamsLAnglePos(): Option<CodePositionRange>

功能：获取 FuncDecl 节点中泛型参数 < 的位置。

返回值：

• Option<CodePositionRange> - 返回泛型参数 < 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建带有泛型参数的 FuncDecl 实例
    let funcDecl = FuncDecl(
        Block([ReturnExpr(None)]),
        None,
        [GenericParam("T")],
        FuncKind.Normal,
        "foo",
        ParameterList([]),
        AtomicType(AtomicTypeKind.Int64Type)
    )

    if (let Some(pos) <- funcDecl.getGenericParamsLAnglePos()) {
        // 输出左尖括号位置
        println("funcDecl.getGenericParamsLAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

funcDecl.getGenericParamsLAnglePos(): 1:9-1:10

func getGenericParamsRAnglePos()

public func getGenericParamsRAnglePos(): Option<CodePositionRange>

功能：获取 FuncDecl 节点中泛型参数 > 的位置。

返回值：

• Option<CodePositionRange> - 返回泛型参数 > 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建带有泛型参数的 FuncDecl 实例
    let funcDecl = FuncDecl(
        Block([ReturnExpr(None)]),
        None,
        [GenericParam("T")],
        FuncKind.Normal,
        "foo",
        ParameterList([]),
        AtomicType(AtomicTypeKind.Int64Type)
    )

    if (let Some(pos) <- funcDecl.getGenericParamsRAnglePos()) {
        // 输出右尖括号位置
        println("funcDecl.getGenericParamsRAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

funcDecl.getGenericParamsRAnglePos(): 1:11-1:12

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 FuncDecl 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

注意：

kind 为 Finalizer 时，返回 init 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncDecl 实例
    let funcDecl = FuncDecl(
        Block([ReturnExpr(None)]),
        None,
        [],
        FuncKind.Normal,
        "foo",
        ParameterList([]),
        AtomicType(AtomicTypeKind.Int64Type)
    )

    // 获取标识符位置
    let pos = funcDecl.getIdentifierPos()

    // 输出标识符位置
    println("funcDecl.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

funcDecl.getIdentifierPos(): 1:6-1:9

func getRetTyAnnotationColonPos()

public func getRetTyAnnotationColonPos(): Option<CodePositionRange>

功能：获取 FuncDecl 节点中类型前 : 的位置。

返回值：

• Option<CodePositionRange> - 返回类型前 : 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建带有返回类型注解的 FuncDecl 实例
    let funcDecl = FuncDecl(
        Block([ReturnExpr(None)]),
        None,
        [],
        FuncKind.Normal,
        "foo",
        ParameterList([]),
        AtomicType(AtomicTypeKind.Int64Type)
    )

    if (let Some(pos) <- funcDecl.getRetTyAnnotationColonPos()) {
        // 输出冒号位置
        println("funcDecl.getRetTyAnnotationColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

funcDecl.getRetTyAnnotationColonPos(): 1:11-1:12

class FuncParam

public open class FuncParam <: Parameter {
    public init(defaultValue: Option<Expr>, kind: Option<VarKind>, name: String, typeAnnotation: TypeAnnotation,
        isNamed!: Bool = false, annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [],
        comments!: Array<Comment> = [])
}

功能：表示一个函数参数。

FuncParam 类用于在程序中声明一个新的函数参数，defaultValue 表示参数的默认值，name 表示参数的名称，typeAnnotation 表示参数的类型标注。

父类型：

• Parameter

prop defaultValue

public prop defaultValue: Option<Expr>

功能：获取当前函数参数的默认值（若不存在返回 None）。

类型：Option<Expr>

prop kind

public prop kind: Option<VarKind>

功能：获取当前函数参数的种类（若不存在返回 None）。

类型：Option<VarKind>

prop name

public prop name: String

功能：获取当前函数参数的名称。

类型：String

prop typeAnnotation

public prop typeAnnotation: TypeAnnotation

功能：获取当前函数参数的类型标注。

类型：TypeAnnotation

init(Option<Expr>, Option<VarKind>, String, TypeAnnotation, Bool, Array<Annotation>, Array<Modifier>, Array<Comment>)

public init(defaultValue: Option<Expr>, kind: Option<VarKind>, name: String, typeAnnotation: TypeAnnotation,
    isNamed!: Bool = false, annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [],
    comments!: Array<Comment> = [])

功能：构造一个 FuncParam 对象，表示函数参数节点。

参数：

• defaultValue: Option<Expr> - 可选的默认值表达式。
• kind: Option<VarKind> - 可选的变量种类。
• name: String - 参数名。
• typeAnnotation: TypeAnnotation - 类型注解。
• isNamed!: Bool - 是否为命名参数，默认为 false。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• modifiers!: Array<Modifier> - 修饰符列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 kind 不代表 var 或 let，或 kind 为空但 modifiers 不为空，或没有传入参数名却为命名参数，或输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 defaultValue
    let defaultValue = LitConstExpr(LitConstKind.IntergerLiteral, "1")

    // 创建 kind
    let kind = VarKind.Let

    // 创建 name
    let name = "x"

    // 创建 typeAnnotation
    let typeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 isNamed
    let isNamed = true

    // 创建 FuncParam 实例
    let funcParam = FuncParam(
        defaultValue, 
        kind, 
        name, 
        typeAnnotation, 
        isNamed: isNamed
    )

    println("funcParam: ${funcParam}")
}

运行结果：

funcParam: let x!: Int64 = 1

func getAssignPos()

public func getAssignPos(): Option<CodePositionRange>

功能：获取 FuncParam 节点中 = 的位置。

返回值：

• Option<CodePositionRange> - 返回 = 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncParam 实例
    let defaultValue = LitConstExpr(LitConstKind.IntergerLiteral, "1")
    let funcParam = FuncParam(defaultValue, VarKind.Let, "x", AtomicType(AtomicTypeKind.Int64Type), isNamed: true)

    if (let Some(pos) <- funcParam.getAssignPos()) {
        // 输出等号位置
        println("funcParam.getAssignPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

funcParam.getAssignPos(): 1:15-1:16

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 FuncParam 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncParam 实例
    let funcParam = FuncParam(None, VarKind.Let, "x", AtomicType(AtomicTypeKind.Int64Type))
    let pos = funcParam.getIdentifierPos()

    // 输出标识符位置
    println("funcParam.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

funcParam.getIdentifierPos(): 1:5-1:6

func getNotPos()

public func getNotPos(): Option<CodePositionRange>

功能：获取 FuncParam 节点中 ! 的位置。

返回值：

• Option<CodePositionRange> - 返回 ! 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncParam 实例
    let funcParam = FuncParam(None, VarKind.Let, "x", AtomicType(AtomicTypeKind.Int64Type), isNamed: true)

    if (let Some(pos) <- funcParam.getNotPos()) {
        // 输出感叹号位置
        println("funcParam.getNotPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

funcParam.getNotPos(): 1:6-1:7

func getTypeAnnotationColonPos()

public func getTypeAnnotationColonPos(): CodePositionRange

功能：获取 FuncParam 节点中 : 的位置。

返回值：

• CodePositionRange - 返回 : 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncParam 实例
    let funcParam = FuncParam(None, VarKind.Let, "x", AtomicType(AtomicTypeKind.Int64Type))
    let pos = funcParam.getTypeAnnotationColonPos()

    // 输出冒号位置
    println("funcParam.getTypeAnnotationColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

funcParam.getTypeAnnotationColonPos(): 1:6-1:7

func getVarKindKeyWordPos()

public func getVarKindKeyWordPos(): Option<CodePositionRange>

功能：获取 FuncParam 节点中关键字 let 或 var 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回关键字 let 或 var 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncParam 实例
    let funcParam = FuncParam(None, VarKind.Let, "x", AtomicType(AtomicTypeKind.Int64Type))

    if (let Some(pos) <- funcParam.getVarKindKeyWordPos()) {
        // 输出 let/var 关键字位置
        println("funcParam.getVarKindKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

funcParam.getVarKindKeyWordPos(): 1:1-1:4

class FuncType

public class FuncType <: TypeAnnotation {
    public init(paramTypes: Array<TypeAnnotation>, labels: Array<String>, retType: TypeAnnotation, comments!: Array<Comment> = [])
}

功能：表示函数类型节点。

由函数的参数类型和返回类型组成，参数类型与返回类型之间用 -> 分隔，如：(Int32) -> Unit。

父类型：

• TypeAnnotation

prop labels

public prop labels: Array<String>

功能：获取 FuncType 节点中的类型参数名，例如 (name: String, age: Int64) -> Unit 中的 name 和 age。

类型：Array<String>

prop paramTypes

public prop paramTypes: Array<TypeAnnotation>

功能：获取 FuncType 节点中函数的参数类型列表。

类型：Array<TypeAnnotation>

prop retType

public prop retType: TypeAnnotation

功能：获取 FuncType 的返回类型节点。

类型：TypeAnnotation

init(Array<TypeAnnotation>, Array<String>, TypeAnnotation, Array<Comment>)

public init(paramTypes: Array<TypeAnnotation>, labels: Array<String>, retType: TypeAnnotation, comments!: Array<Comment> = [])

功能：构造一个 FuncType 对象，表示函数类型，如 (a: Int64, b: String) -> Bool。

参数：

• paramTypes: Array<TypeAnnotation> - 参数类型列表。
• labels: Array<String> - 参数标签列表。
• retType: TypeAnnotation - 返回类型。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当参数类型列表和参数名列表长度不一样时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 paramTypes
    let paramTypes: Array<TypeAnnotation> = [CompositeType("I1", [], [])]

    // 创建 labels
    let labels = ["x"]

    // 创建 retType
    let retType = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 FuncType 实例
    let funcType = FuncType(
        paramTypes, 
        labels, 
        retType
    )

    println("funcType: ${funcType}")
}

运行结果：

funcType: (x: I1) -> Int64

func getArrowPos()

public func getArrowPos(): CodePositionRange

功能：获取 -> 的位置。

返回值：

• CodePositionRange - 返回 -> 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncType 实例
    let funcType = FuncType(
        [AtomicType(AtomicTypeKind.Int64Type), AtomicType(Int32Type)],
        ["a", "b"],
        AtomicType(BoolType)
    )

    // 获取箭头位置
    let pos = funcType.getArrowPos()

    // 输出箭头位置
    println("funcType.getArrowPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

funcType.getArrowPos(): 1:22-1:24

func getColonsPos()

public func getColonsPos(): Array<CodePositionRange>

功能：获取 : 的位置序列。

返回值：

• Array<CodePositionRange> - 返回 : 的位置序列。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncType 实例
    let funcType = FuncType(
        [AtomicType(AtomicTypeKind.Int64Type), AtomicType(Int32Type)],
        ["a", "b"],
        AtomicType(BoolType)
    )

    // 获取冒号位置
    let posArr = funcType.getColonsPos()

    // 输出冒号位置
    for (i in 0..posArr.size) {
        println("funcType.getColonsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

funcType.getColonsPos()[0]: 1:3-1:4
funcType.getColonsPos()[1]: 1:13-1:14

func getCommasPos()

public func getCommasPos(): Array<CodePositionRange>

功能：获取 , 的位置序列。

返回值：

• Array<CodePositionRange> - 返回 , 的位置序列。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncType 实例
    let funcType = FuncType(
        [AtomicType(AtomicTypeKind.Int64Type), AtomicType(Int32Type), AtomicType(BoolType)],
        ["a", "b", "c"],
        AtomicType(UnitType)
    )

    // 获取逗号位置
    let posArr = funcType.getCommasPos()

    // 输出逗号位置
    for (i in 0..posArr.size) {
        println("funcType.getCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

funcType.getCommasPos()[0]: 1:10-1:11
funcType.getCommasPos()[1]: 1:20-1:21

func getLabelsPos()

public func getLabelsPos(): Array<CodePositionRange>

功能：获取标签的位置序列。

返回值：

• Array<CodePositionRange> - 返回标签的位置序列。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncType 实例
    let funcType = FuncType(
        [AtomicType(AtomicTypeKind.Int64Type), AtomicType(Int32Type)],
        ["a", "b"],
        AtomicType(BoolType)
    )

    // 获取标签位置
    let posArr = funcType.getLabelsPos()

    // 输出标签位置
    for (i in 0..posArr.size) {
        println("funcType.getLabelsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

funcType.getLabelsPos()[0]: 1:2-1:3
funcType.getLabelsPos()[1]: 1:12-1:13

func getLParenPos()

public func getLParenPos(): CodePositionRange

功能：获取 ( 的位置。

返回值：

• CodePositionRange - 返回 ( 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncType 实例
    let funcType = FuncType(
        [AtomicType(AtomicTypeKind.Int64Type)],
        ["a"],
        AtomicType(BoolType)
    )

    // 获取左括号位置
    let pos = funcType.getLParenPos()

    // 输出左括号位置
    println("funcType.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

funcType.getLParenPos(): 1:1-1:2

func getRParenPos()

public func getRParenPos(): CodePositionRange

功能：获取 ) 的位置。

返回值：

• CodePositionRange - 返回 ) 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 FuncType 实例
    let funcType = FuncType(
        [AtomicType(AtomicTypeKind.Int64Type)],
        ["a"],
        AtomicType(BoolType)
    )

    // 获取右括号位置
    let pos = funcType.getRParenPos()

    // 输出右括号位置
    println("funcType.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

funcType.getRParenPos(): 1:10-1:11

class GenericConstraint

public class GenericConstraint <: SyntaxTreeNode {
    public init(typeArgument: TypeAnnotation, upperBounds: Array<TypeAnnotation>, comments!: Array<Comment> = [])
}

功能：表示一个泛型约束节点。

一个 GenericConstraint 节点：interface Enumerable<T> where T <: Interface & Class {} 中的 where T <: Interface & Class。

说明：

通过 where 之后的 <: 符号来声明，其中 <: 左边称为类型变元，<: 右边称为约束上界，约束上界可以为类型或接口。

父类型：

• SyntaxTreeNode

prop typeArgument

public prop typeArgument: TypeAnnotation

功能：获取 GenericConstraint 节点中的类型变元。

类型：TypeAnnotation

prop upperBounds

public prop upperBounds: Array<TypeAnnotation>

功能：获取 GenericConstraint 节点约束上界的 TypeAnnotation 类型节点的集合。

类型：Array<TypeAnnotation>

init(TypeAnnotation, Array<TypeAnnotation>, Array<Comment>)

public init(typeArgument: TypeAnnotation, upperBounds: Array<TypeAnnotation>, comments!: Array<Comment> = [])

功能：构造一个 GenericConstraint 对象，表示泛型约束。

参数：

• typeArgument: TypeAnnotation - 被约束的类型参数。
• upperBounds: Array<TypeAnnotation> - 上界类型列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 upperBounds 为空时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 typeArgument
    let typeArgument = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 upperBounds
    let upperBounds: Array<TypeAnnotation> = [CompositeType("I1", [], [])]

    // 创建 GenericConstraint 实例
    let genericConstraint = GenericConstraint(
        typeArgument, 
        upperBounds
    )

    println("genericConstraint: ${genericConstraint}")
}

运行结果：

genericConstraint: Int64<:I1

func getBitAndsPos()

public func getBitAndsPos(): Array<CodePositionRange>

功能：获取 GenericConstraint 节点中 & 的位置。

返回值：

• Array<CodePositionRange> - 返回 & 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 GenericConstraint 实例
    let typeArgument = AtomicType(AtomicTypeKind.Int64Type)
    let upperBounds: Array<TypeAnnotation> = [CompositeType("I1", [], []), CompositeType("I2", [], [])]
    let genericConstraint = GenericConstraint(typeArgument, upperBounds)
    let posArr = genericConstraint.getBitAndsPos()

    // 遍历输出&位置
    for (i in 0..posArr.size) {
        println("genericConstraint.getBitAndsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

genericConstraint.getBitAndsPos()[0]: 1:11-1:12

func getUpperBoundPos()

public func getUpperBoundPos(): CodePositionRange

功能：获取 GenericConstraint 节点中 <: 的位置。

返回值：

• CodePositionRange - 返回 <: 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 GenericConstraint 实例
    let typeArgument = AtomicType(AtomicTypeKind.Int64Type)
    let upperBounds: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    let genericConstraint = GenericConstraint(typeArgument, upperBounds)
    let pos = genericConstraint.getUpperBoundPos()

    // 输出 <: 位置
    println("genericConstraint.getUpperBoundPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

genericConstraint.getUpperBoundPos(): 1:6-1:8

class GenericConstraints

public class GenericConstraints <: SyntaxTreeNode {
    public init(constraints: Array<GenericConstraint>, comments!: Array<Comment> = [])
}

功能：表示一组泛型约束。

一个 GenericConstraints 节点：interface Enumerable<T1, T2> where T1 <: I1 & I2, T2 <: I3 & I4 中的 where T1 <: I1 & I2, T2 <: I3 & I4。

父类型：

• SyntaxTreeNode

prop constraints

public prop constraints: Array<GenericConstraint>

功能：获取 GenericConstraints 节点中的所有约束。

类型：Array<GenericConstraint>

init(Array<GenericConstraint>, Array<Comment>)

public init(constraints: Array<GenericConstraint>, comments!: Array<Comment> = [])

功能：构造一个 GenericConstraints 对象，表示一组泛型约束。

参数：

• constraints: Array<GenericConstraint> - 泛型约束列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 constraints 为空时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 constraints
    let constraints = [
        GenericConstraint(CompositeType("I1", [], []), [CompositeType("T", [], [])]), 
        GenericConstraint(CompositeType("I2", [], []), [CompositeType("T", [], []), CompositeType("U", [], [])])
    ]

    // 创建 GenericConstraints 实例
    let genericConstraints = GenericConstraints(
        constraints
    )

    println("genericConstraints: ${genericConstraints}")
}

运行结果：

genericConstraints: where I1<:T, I2<:T & U

func getCommasPos()

public func getCommasPos(): Array<CodePositionRange>

功能：获取 GenericConstraints 节点中 , 的位置。

返回值：

• Array<CodePositionRange> - 返回 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 GenericConstraints 实例
    let constraints = [
        GenericConstraint(CompositeType("I1", [], []), [CompositeType("T", [], [])]),
        GenericConstraint(CompositeType("I2", [], []), [CompositeType("T", [], []), CompositeType("U", [], [])])
    ]
    let genericConstraints = GenericConstraints(constraints)
    let posArr = genericConstraints.getCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("genericConstraints.getCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

genericConstraints.getCommasPos()[0]: 1:12-1:13

func getWhereKeyWordPos()

public func getWhereKeyWordPos(): CodePositionRange

功能：获取 GenericConstraints 节点中 where 关键字的位置。

返回值：

• CodePositionRange - 返回 where 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 GenericConstraints 实例
    let constraints = [
        GenericConstraint(CompositeType("I1", [], []), [CompositeType("T", [], [])])
    ]
    let genericConstraints = GenericConstraints(constraints)
    let pos = genericConstraints.getWhereKeyWordPos()

    // 输出 where 关键字位置
    println("genericConstraints.getWhereKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

genericConstraints.getWhereKeyWordPos(): 1:1-1:6

class GenericParam

public class GenericParam <: Decl {
    public init(name: String, comments!: Array<Comment> = [])
}

功能：表示一个泛型参数节点。

一个 GenericParam 节点：<T1, T2, T3> 中的 T1。

父类型：

• Decl

prop name

public prop name: String

功能：获取当前型参的名称。

类型：String

init(String, Array<Comment>)

public init(name: String, comments!: Array<Comment> = [])

功能：构造一个 GenericParam 对象，表示泛型参数节点。

参数：

• name: String - 泛型参数名。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 name
    let name = "T"

    // 创建 GenericParam 实例
    let genericParam = GenericParam(
        name
    )

    println("genericParam: ${genericParam}")
}

运行结果：

genericParam: T

class IfExpr

public class IfExpr <: Expr {
    public init(condition: DisjunctionCondition, elseBlock: Option<Block>, elseIf: Option<IfExpr>, ifBlock: Block, comments!: Array<Comment> = [])
}

功能：表示条件表达式。

可以根据判定条件是否成立来决定执行哪条代码分支。一个 IfExpr 节点中 if 是关键字，if 之后是一个小括号，小括号内可以是一个表达式或者一个 let 声明的解构匹配，接着是一个 Block，Block 之后是可选的 else 分支。 else 分支以 else 关键字开始，后接新的 if 表达式或一个 Block。

父类型：

• Expr

prop condition

public prop condition: DisjunctionCondition

功能：获取当前 if 语句的条件表达式。

类型：DisjunctionCondition

prop elseBlock

public prop elseBlock: Option<Block>

功能：获取当前 if 语句的 else 分支代码块（若不存在返回 None）。

类型：Option<Block>

prop elseIf

public prop elseIf: Option<IfExpr>

功能：获取当前 if 语句的 else if 分支（若不存在返回 None）。

类型：Option<IfExpr>

prop ifBlock

public prop ifBlock: Block

功能：获取当前 if 语句的 if 分支代码块。

类型：Block

init(DisjunctionCondition, Option<Block>, Option<IfExpr>, Block, Array<Comment>)

public init(condition: DisjunctionCondition, elseBlock: Option<Block>, elseIf: Option<IfExpr>, ifBlock: Block, comments!: Array<Comment> = [])

功能：构造一个 IfExpr 对象，表示 if 条件表达式。

参数：

• condition: DisjunctionCondition - 条件表达式。
• elseBlock: Option<Block> - 可选的 else 分支代码块。
• elseIf: Option<IfExpr> - 可选的 else if 分支。
• ifBlock: Block - if 分支代码块。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入中存在多个 elseBlock 时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 condition
    let cond = [
        ConjunctionCondition(AtomicCondition.Expression(SymbolRef("x", [])))
    ]

    // 创建 DisjunctionCondition 实例
    let condition = DisjunctionCondition(cond)

    // 创建 elseBlock
    let elseBlock = Block([ReturnExpr(LitConstExpr(LitConstKind.IntergerLiteral, "100"))])

    // 创建 ifBlock
    let ifBlock = Block([ReturnExpr(LitConstExpr(LitConstKind.IntergerLiteral, "10"))])

    // 创建 IfExpr 实例
    let ifExpr = IfExpr(
        condition, 
        elseBlock, 
        None, 
        ifBlock
    )

    println("ifExpr: ${ifExpr}")
}

运行结果：

ifExpr: if (x) {
    return 10
} else {
    return 100
}

func getCondLParenPos()

public func getCondLParenPos(): CodePositionRange

功能：获取 IfExpr 节点中条件的 ( 的位置。

返回值：

• CodePositionRange - 返回条件的 ( 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 condition
    let condition = DisjunctionCondition([ConjunctionCondition(AtomicCondition.Expression(SymbolRef("x", [])))])

    // 创建 ifBlock
    let ifBlock = Block([ReturnExpr(LitConstExpr(LitConstKind.IntergerLiteral, "10"))])

    // 创建 IfExpr 实例
    let ifExpr = IfExpr(condition, None, None, ifBlock)
    let pos = ifExpr.getCondLParenPos()

    // 输出条件左括号位置
    println("ifExpr.getCondLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

ifExpr.getCondLParenPos(): 1:4-1:5

func getCondRParenPos()

public func getCondRParenPos(): CodePositionRange

功能：获取 IfExpr 节点中条件的 ) 的位置。

返回值：

• CodePositionRange - 返回条件的 ) 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 condition
    let condition = DisjunctionCondition([ConjunctionCondition(AtomicCondition.Expression(SymbolRef("x", [])))])

    // 创建 ifBlock
    let ifBlock = Block([ReturnExpr(LitConstExpr(LitConstKind.IntergerLiteral, "10"))])

    // 创建 IfExpr 实例
    let ifExpr = IfExpr(condition, None, None, ifBlock)
    let pos = ifExpr.getCondRParenPos()

    // 输出条件右括号位置
    println("ifExpr.getCondRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

ifExpr.getCondRParenPos(): 1:6-1:7

func getElseKeyWordPos()

public func getElseKeyWordPos(): Option<CodePositionRange>

功能：获取 IfExpr 节点中 else 关键字的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 else 关键字的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 condition
    let condition = DisjunctionCondition([ConjunctionCondition(AtomicCondition.Expression(SymbolRef("x", [])))])

    // 创建 elseBlock
    let elseBlock = Block([ReturnExpr(LitConstExpr(LitConstKind.IntergerLiteral, "100"))])

    // 创建 ifBlock
    let ifBlock = Block([ReturnExpr(LitConstExpr(LitConstKind.IntergerLiteral, "10"))])

    // 创建 IfExpr 实例
    let ifExpr = IfExpr(condition, elseBlock, None, ifBlock)

    if (let Some(pos) <- ifExpr.getElseKeyWordPos()) {
        // 输出 else 关键字位置
        println("ifExpr.getElseKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

ifExpr.getElseKeyWordPos(): 3:3-3:7

func getIfKeyWordPos()

public func getIfKeyWordPos(): CodePositionRange

功能：获取 IfExpr 节点中 if 关键字的位置。

返回值：

• CodePositionRange - 返回 if 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 condition
    let condition = DisjunctionCondition([ConjunctionCondition(AtomicCondition.Expression(SymbolRef("x", [])))])

    // 创建 ifBlock
    let ifBlock = Block([ReturnExpr(LitConstExpr(LitConstKind.IntergerLiteral, "10"))])

    // 创建 IfExpr 实例
    let ifExpr = IfExpr(condition, None, None, ifBlock)
    let pos = ifExpr.getIfKeyWordPos()

    // 输出 if 关键字位置
    println("ifExpr.getIfKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

ifExpr.getIfKeyWordPos(): 1:1-1:3

class ImportAlias

public class ImportAlias <: ImportContent {
    public init(prefixes: Array<String>, identifier: String, alias: String, comments!: Array<Comment> = [])
}

功能：表示一个别名导入的包导入声明节点的具体项目，如 import pkg.a.b as p 中的 pkg.a.b as p。

父类型：

• ImportContent

prop aliasName

public prop aliasName: String

功能：表示该包导入节点中的别名，如 pkg.a.b as p 中的 p。

类型：String

prop identifier

public prop identifier: String

功能：表示该包导入节点中的被导入的项，它可能是包中的顶层声明或声明，也可能是子包的名字，如 pkg.a.b as a 中的 b。

类型：String

init(Array<String>, String, String, Array<Comment>)

public init(prefixes: Array<String>, identifier: String, alias: String, comments!: Array<Comment> = [])

功能：构造一个 ImportAlias 对象，表示带别名的导入项。

参数：

• prefixes: Array<String> - 导入路径的前缀列表，如 ["pkg"]。
• identifier: String - 被导入的标识符名称，如 A。
• alias: String - 别名名称，如 B。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 identifier 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 prefixes
    let prefixes = ["pkg"]

    // 创建 identifier
    let identifier = "a"

    // 创建 alias
    let alias = "p"

    // 创建 ImportAlias 实例
    let importAlias = ImportAlias(
        prefixes, 
        identifier, 
        alias
    )

    println("importAlias: ${importAlias}")
}

运行结果：

importAlias: pkg.a as p

func getAliasNamePos()

public func getAliasNamePos(): CodePositionRange

功能：获取当前 ImportAlias 中包的别名的位置。

返回值：

• CodePositionRange - 返回包别名的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportAlias 实例
    let importAlias = ImportAlias(["pkg"], "a", "p")
    let pos = importAlias.getAliasNamePos()

    // 输出别名位置
    println("importAlias.getAliasNamePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

importAlias.getAliasNamePos(): 1:10-1:11

func getAsPos()

public func getAsPos(): CodePositionRange

功能：获取当前 ImportAlias 中 as 关键字的位置。

返回值：

• CodePositionRange - 返回 as 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportAlias 实例
    let importAlias = ImportAlias(["pkg"], "a", "p")
    let pos = importAlias.getAsPos()

    // 输出 as 关键字位置
    println("importAlias.getAsPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

importAlias.getAsPos(): 1:7-1:9

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取当前 ImportAlias 中原始包名的位置。

返回值：

• CodePositionRange - 返回原始包名的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportAlias 实例
    let importAlias = ImportAlias(["pkg"], "a", "p")
    let pos = importAlias.getIdentifierPos()

    // 输出原始包名位置
    println("importAlias.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

importAlias.getIdentifierPos(): 1:5-1:6

class ImportAll

public class ImportAll <: ImportContent {
    public init(prefixes: Array<String>, comments!: Array<Comment> = [])
}

功能：表示一个全导入的包导入声明节点的具体项目，如 import pkg.* 中的 pkg.*。

父类型：

• ImportContent

init(Array<String>, Array<Comment>)

public init(prefixes: Array<String>, comments!: Array<Comment> = [])

功能：构造一个 ImportAll 对象，表示通配符导入。

参数：

• prefixes: Array<String> - 导入路径的前缀列表，如 ["pkg"]。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 prefixes
    let prefixes = ["pkg"]

    // 创建 ImportAll 实例
    let importAll = ImportAll(
        prefixes
    )

    println("importAll: ${importAll}")
}

运行结果：

importAll: pkg.*

func getMulPos()

public func getMulPos(): CodePositionRange

功能：获取当前 ImportAll 中 * 的位置。

返回值：

• CodePositionRange - 返回 * 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportAll 实例
    let importAll = ImportAll(["pkg"])
    let pos = importAll.getMulPos()

    // 输出星号位置
    println("importAll.getMulPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

importAll.getMulPos(): 1:5-1:6

class ImportContent

public open class ImportContent <: SyntaxTreeNode {}

功能：表示一个包导入声明节点的具体声明内容，如 import pkg.a.b 中的 pkg.a.b。

父类型：

• SyntaxTreeNode

prop prefixes

public prop prefixes: Array<String>

功能：表示该包导入节点中完整包名的前缀列表，如 pkg.a.b 中的 [pkg, a]。

类型：Array<String>

func getDotsPos()

public func getDotsPos(): Array<CodePositionRange>

功能：获取当前 ImportContent 中所有 . 分隔符的位置。

返回值：

• Array<CodePositionRange> - 返回所有 . 分隔符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 使用 ImportSingle 子类来演示
    let importSingle = ImportSingle(["pkg", "a"], "b")
    let posArr = importSingle.getDotsPos()

    // 输出点号位置
    for (i in 0..posArr.size) {
        println("importSingle.getDotsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

importSingle.getDotsPos()[0]: 1:4-1:5
importSingle.getDotsPos()[1]: 1:6-1:7

func getPrefixesPos()

public func getPrefixesPos(): Array<CodePositionRange>

功能：获取当前 ImportMulti 中所有前缀包名的位置。

返回值：

• Array<CodePositionRange> - 返回所有前缀包名的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 使用 ImportSingle 子类来演示
    let importSingle = ImportSingle(["pkg", "a"], "b")
    let posArr = importSingle.getPrefixesPos()

    // 输出前缀包名位置
    for (i in 0..posArr.size) {
        println("importSingle.getPrefixesPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

importSingle.getPrefixesPos()[0]: 1:1-1:4
importSingle.getPrefixesPos()[1]: 1:5-1:6

class ImportList

public class ImportList <: SyntaxTreeNode {
    public init(contents: ImportContent, modifier: Option<Modifier>, comments!: Array<Comment> = [])
}

功能：表示包导入节点。

一个 ImportList 节点：import pkg.a.b，import pkg.a.b as p 等。

父类型：

• SyntaxTreeNode

prop contents

public prop contents: ImportContent

功能：表示该包导入节点中的导入内容。

类型：ImportContent

prop kind

public prop kind: ImportKind

功能：表示该包导入节点的类型。

类型：ImportKind

prop modifier

public prop modifier: Option<Modifier>

功能：表示该包导入节点中的修饰符。

类型：Option<Modifier>

init(ImportContent, Option<Modifier>, Array<Comment>)

public init(contents: ImportContent, modifier: Option<Modifier>, comments!: Array<Comment> = [])

功能：构造一个 ImportList 对象，表示一条导入语句，如 import pkg.A。

参数：

• contents: ImportContent - 导入内容。
• modifier: Option<Modifier> - 修饰符，可选。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 modifier 不为 Public、Protected、Private 或 Internal 时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 contents
    let contents = ImportSingle(["pkg"], "a")

    // 创建 modifier
    let modifier = Modifier(ModifierKind.Public)

    // 创建 ImportList 实例
    let importList = ImportList(
        contents, 
        modifier
    )

    println("importList: ${importList}")
}

运行结果：

importList: public import pkg.a

func getImportKeyWordPos()

public func getImportKeyWordPos(): CodePositionRange

功能：获取当前 ImportList 中 import 关键字的位置。

返回值：

• CodePositionRange - 返回 import 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportList 实例
    let contents = ImportSingle(["pkg"], "a")
    let importList = ImportList(contents, None)
    let pos = importList.getImportKeyWordPos()

    // 输出 import 关键字位置
    println("importList.getImportKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

importList.getImportKeyWordPos(): 1:1-1:7

class ImportMulti

public class ImportMulti <: ImportContent {
    public init(prefixes: Array<String>, contents: Array<ImportContent>, comments!: Array<Comment> = [])
}

功能：表示一个多导入的包导入声明节点的具体项目，如 import pkg.{a.*, b.c, d as p} 中的 pkg.{a.*, b.c, d as p}。

父类型：

• ImportContent

prop contents

public prop contents: Array<ImportContent>

功能：表示该包导入节点中的多个导入项的列表，如 pkg.{a.*, b.c, d as p} 中的 [a.*, b.c, d as p]。

类型：Array<ImportContent>

init(Array<String>, Array<ImportContent>, Array<Comment>)

public init(prefixes: Array<String>, contents: Array<ImportContent>, comments!: Array<Comment> = [])

功能：构造一个 ImportMulti 对象，表示多导入项。

参数：

• prefixes: Array<String> - 导入路径的前缀列表，如 ["pkg"]。
• contents: Array<ImportContent> - 导入内容列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 contents 为空时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 prefixes
    let prefixes = ["pkg"]

    // 创建 contents
    let contents: Array<ImportContent> = [ImportSingle([], "a"), ImportSingle([], "b")]

    // 创建 ImportMulti 实例
    let importMulti = ImportMulti(
        prefixes, 
        contents
    )

    println("importMulti: ${importMulti}")
}

运行结果：

importMulti: pkg.{a, b}

func getCommasPos()

public func getCommasPos(): Array<CodePositionRange>

功能：获取当前 ImportMulti 中所有 , 分隔符的位置。

返回值：

• Array<CodePositionRange> - 返回所有 , 分隔符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportMulti 实例
    let contents: Array<ImportContent> = [ImportSingle([], "a"), ImportSingle([], "b")]
    let importMulti = ImportMulti(["pkg"], contents)
    let posArr = importMulti.getCommasPos()

    // 遍历输出逗号位置
    for (i in 0..posArr.size) {
        println("importMulti.getCommasPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

importMulti.getCommasPos()[0]: 1:7-1:8

func getLCurlPos()

public func getLCurlPos(): CodePositionRange

功能：获取当前 ImportMulti 中 { 的位置。

返回值：

• CodePositionRange - 返回 { 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportMulti 实例
    let contents: Array<ImportContent> = [ImportSingle([], "a")]
    let importMulti = ImportMulti(["pkg"], contents)
    let pos = importMulti.getLCurlPos()

    // 输出左花括号位置
    println("importMulti.getLCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

importMulti.getLCurlPos(): 1:5-1:6

func getRCurlPos()

public func getRCurlPos(): CodePositionRange

功能：获取当前 ImportMulti 中 } 的位置。

返回值：

• CodePositionRange - 返回 } 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportMulti 实例
    let contents: Array<ImportContent> = [ImportSingle([], "a")]
    let importMulti = ImportMulti(["pkg"], contents)
    let pos = importMulti.getRCurlPos()

    // 输出右花括号位置
    println("importMulti.getRCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

importMulti.getRCurlPos(): 1:7-1:8

class ImportSingle

public class ImportSingle <: ImportContent {
    public init(prefixes: Array<String>, identifier: String, comments!: Array<Comment> = [])
}

功能：表示一个单导入的包导入声明节点的具体项目，如 import pkg.a 中的 pkg.a。

父类型：

• ImportContent

prop identifier

public prop identifier: String

功能：表示该包导入节点中的被导入的项，它可能是包中的顶层声明或声明，也可能是子包的名字，如 pkg.a 中的 a。

类型：String

init(Array<String>, String, Array<Comment>)

public init(prefixes: Array<String>, identifier: String, comments!: Array<Comment> = [])

功能：构造一个 ImportSingle 对象，表示单导入项。

参数：

• prefixes: Array<String> - 导入路径的前缀列表，如 ["pkg"]。
• identifier: String - 被导入的标识符名称，如 A。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 identifier 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 prefixes
    let prefixes = ["pkg"]

    // 创建 identifier
    let identifier = "a"

    // 创建 ImportSingle 实例
    let importSingle = ImportSingle(
        prefixes, 
        identifier
    )

    println("importSingle: ${importSingle}")
}

运行结果：

importSingle: pkg.a

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取当前 ImportSingle 中具体包名的位置。

返回值：

• CodePositionRange - 返回具体包名的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 ImportSingle 实例
    let importSingle = ImportSingle(["pkg"], "a")
    let pos = importSingle.getIdentifierPos()

    // 输出标识符位置
    println("importSingle.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

importSingle.getIdentifierPos(): 1:5-1:6

class IncOrDecExpr

public class IncOrDecExpr <: Expr {
    public init(kind: IncOrDecOpKind, operand: Expr, comments!: Array<Comment> = [])
}

功能：表示包含自增操作符（++）或自减操作符（--）的表达式。

父类型：

• Expr

prop kind

public prop kind: IncOrDecOpKind

功能：获取当前自增自减表达式的操作符类型。

类型：IncOrDecOpKind

prop operand

public prop operand: Expr

功能：获取 IncOrDecExpr 中的表达式。

类型：Expr

init(IncOrDecOpKind, Expr, Array<Comment>)

public init(kind: IncOrDecOpKind, operand: Expr, comments!: Array<Comment> = [])

功能：构造一个 IncOrDecExpr 对象，表示自增或自减表达式。

参数：

• kind: IncOrDecOpKind - 自增或自减操作类型。
• operand: Expr - 被操作的表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 kind
    let kind = IncOrDecOpKind.Incr

    // 创建 operand
    let operand = SymbolRef("x", [])

    // 创建 IncOrDecExpr 实例
    let incOrDecExpr = IncOrDecExpr(
        kind, 
        operand
    )

    println("incOrDecExpr: ${incOrDecExpr}")
}

运行结果：

incOrDecExpr: x++

func getOperatorPos()

public func getOperatorPos(): CodePositionRange

功能：获取操作符的位置。

返回值：

• CodePositionRange - 返回操作符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 kind
    let kind = IncOrDecOpKind.Incr

    // 创建 operand
    let operand = SymbolRef("x", [])

    // 创建 IncOrDecExpr 实例
    let incOrDecExpr = IncOrDecExpr(kind, operand)
    let pos = incOrDecExpr.getOperatorPos()

    // 输出操作符位置
    println("incOrDecExpr.getOperatorPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

incOrDecExpr.getOperatorPos(): 1:2-1:4

class InterfaceDecl

public class InterfaceDecl <: Decl {
    public init(body: Body, genericConstraints: Option<GenericConstraints>, genericParams: Array<GenericParam>,
        name: String, superTyAnnotations: Array<TypeAnnotation>, annotations!: Array<Annotation> = [],
        modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])
}

功能：表示接口声明节点。

接口的声明使用 interface 关键字，接口声明依次为：可缺省的修饰符、interface 关键字、接口名、可选的类型参数、是否指定父接口、可选的泛型约束、接口体的声明。

父类型：

• Decl

prop body

public prop body: Body

功能：获取当前接口声明的主体部分。

类型：Body

prop genericConstraints

public prop genericConstraints: Option<GenericConstraints>

功能：获取当前接口声明的泛型约束（若不存在返回 None）。

类型：Option<GenericConstraints>

prop genericParams

public prop genericParams: Array<GenericParam>

功能：获取当前接口声明的泛型参数列表。

类型：Array<GenericParam>

prop name

public prop name: String

功能：获取当前接口声明的名称。

类型：String

prop superTyAnnotations

public prop superTyAnnotations: Array<TypeAnnotation>

功能：获取当前接口声明的父类类型标注列表。

类型：Array<TypeAnnotation>

init(Body, Option<GenericConstraints>, Array<GenericParam>, String, Array<TypeAnnotation>, Array<Annotation>, Array<Modifier>, Array<Comment>)

public init(body: Body, genericConstraints: Option<GenericConstraints>, genericParams: Array<GenericParam>,
    name: String, superTyAnnotations: Array<TypeAnnotation>, annotations!: Array<Annotation> = [],
    modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])

功能：构造一个 InterfaceDecl 对象，表示接口声明节点。

参数：

• body: Body - 接口体，包含成员声明。
• genericConstraints: Option<GenericConstraints> - 可选的泛型约束。
• genericParams: Array<GenericParam> - 泛型参数列表。
• name: String - 接口名。
• superTyAnnotations: Array<TypeAnnotation> - 父类类型标注列表。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• modifiers!: Array<Modifier> - 修饰符列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 body 中有除函数声明和宏展开声明外的声明，或泛型约束与泛型参数不对应，或输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 body
    let body = Body([])

    // 创建 genericConstraints
    let genericConstraints = GenericConstraints([GenericConstraint(CompositeType("T", [], []), [CompositeType("I1", [], [])])])

    // 创建 genericParams
    let genericParams = [GenericParam("T")]

    // 创建 name
    let name = "foo"

    // 创建 superTyAnnotations
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]

    // 创建 InterfaceDecl 实例
    let interfaceDecl = InterfaceDecl(
        body, 
        genericConstraints, 
        genericParams, 
        name, 
        superTyAnnotations
    )

    println("interfaceDecl: ${interfaceDecl}")
}

运行结果：

interfaceDecl: interface foo<T> <: I1 where T<:I1 {
}

func getGenericParamsCommasPos()

public func getGenericParamsCommasPos(): Array<CodePositionRange>

功能：获取 InterfaceDecl 节点中泛型参数中 , 的位置。

返回值：

• Array<CodePositionRange> - 返回泛型参数中 , 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 InterfaceDecl 实例
    let body = Body([])
    let genericParams = [GenericParam("T"), GenericParam("U"), GenericParam("V")]
    let interfaceDecl = InterfaceDecl(body, None, genericParams, "MyInterface", [])

    // 获取泛型参数中逗号的位置
    let commaPoses = interfaceDecl.getGenericParamsCommasPos()

    // 输出逗号位置
    for (i in 0..commaPoses.size) {
        println("interfaceDecl.getGenericParamsCommasPos()[${i}]: ${commaPoses[i].beginLine}:${commaPoses[i].beginColumn}-${commaPoses[i].endLine}:${commaPoses[i].endColumn}")
    }
}

运行结果：

interfaceDecl.getGenericParamsCommasPos()[0]: 1:24-1:25
interfaceDecl.getGenericParamsCommasPos()[1]: 1:27-1:28

func getGenericParamsLAnglePos()

public func getGenericParamsLAnglePos(): Option<CodePositionRange>

功能：获取 InterfaceDecl 节点中泛型参数的 < 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回泛型参数的 < 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 InterfaceDecl 实例
    let body = Body([])
    let genericParams = [GenericParam("T")]
    let interfaceDecl = InterfaceDecl(body, None, genericParams, "MyInterface", [])

    if (let Some(pos) <- interfaceDecl.getGenericParamsLAnglePos()) {
        // 输出左尖括号位置
        println("interfaceDecl.getGenericParamsLAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

interfaceDecl.getGenericParamsLAnglePos(): 1:22-1:23

func getGenericParamsRAnglePos()

public func getGenericParamsRAnglePos(): Option<CodePositionRange>

功能：获取 InterfaceDecl 节点中泛型参数的 > 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回泛型参数的 > 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 InterfaceDecl 实例
    let body = Body([])
    let genericParams = [GenericParam("T")]
    let interfaceDecl = InterfaceDecl(body, None, genericParams, "MyInterface", [])

    if (let Some(pos) <- interfaceDecl.getGenericParamsRAnglePos()) {
        // 输出右尖括号位置
        println("interfaceDecl.getGenericParamsRAnglePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

interfaceDecl.getGenericParamsRAnglePos(): 1:24-1:25

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 InterfaceDecl 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 InterfaceDecl 实例
    let body = Body([])
    let interfaceDecl = InterfaceDecl(body, None, [], "MyInterface", [])

    // 获取标识符位置
    let pos = interfaceDecl.getIdentifierPos()

    // 输出标识符位置
    println("interfaceDecl.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

interfaceDecl.getIdentifierPos(): 1:11-1:22

func getInterfaceKeyWordPos()

public func getInterfaceKeyWordPos(): CodePositionRange

功能：获取 InterfaceDecl 节点中 interface 关键字的位置。

返回值：

• CodePositionRange - 返回 interface 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 InterfaceDecl 实例
    let body = Body([])
    let interfaceDecl = InterfaceDecl(body, None, [], "MyInterface", [])

    // 获取 interface 关键字位置
    let pos = interfaceDecl.getInterfaceKeyWordPos()

    // 输出 interface 关键字位置
    println("interfaceDecl.getInterfaceKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

interfaceDecl.getInterfaceKeyWordPos(): 1:1-1:10

func getSuperTyAnnotationsBitAndsPos()

public func getSuperTyAnnotationsBitAndsPos(): Array<CodePositionRange>

功能：获取 InterfaceDecl 节点中父类型中 & 的位置。

返回值：

• Array<CodePositionRange> - 返回父类型中 & 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 InterfaceDecl 实例
    let body = Body([])
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], []), CompositeType("I2", [], [])]
    let interfaceDecl = InterfaceDecl(body, None, [], "MyInterface", superTyAnnotations)

    // 获取父类型中 & 的位置
    let bitAndsPoses = interfaceDecl.getSuperTyAnnotationsBitAndsPos()

    // 输出 & 位置
    for (i in 0..bitAndsPoses.size) {
        println("interfaceDecl.getSuperTyAnnotationsBitAndsPos()[${i}]: ${bitAndsPoses[i].beginLine}:${bitAndsPoses[i].beginColumn}-${bitAndsPoses[i].endLine}:${bitAndsPoses[i].endColumn}")
    }
}

运行结果：

interfaceDecl.getSuperTyAnnotationsBitAndsPos()[0]: 1:29-1:30

func getUpperBoundPos()

public func getUpperBoundPos(): Option<CodePositionRange>

功能：获取 InterfaceDecl 节点中 <: 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 <: 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 InterfaceDecl 实例
    let body = Body([])
    let superTyAnnotations: Array<TypeAnnotation> = [CompositeType("I1", [], [])]
    let interfaceDecl = InterfaceDecl(body, None, [], "MyInterface", superTyAnnotations)

    if (let Some(pos) <- interfaceDecl.getUpperBoundPos()) {
        // 输出 <: 位置
        println("interfaceDecl.getUpperBoundPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

interfaceDecl.getUpperBoundPos(): 1:23-1:25

class IsExpr

public class IsExpr <: Expr {
    public init(srcVal: Expr, targetTypeAnnotation: TypeAnnotation, comments!: Array<Comment> = [])
}

功能：表示一个类型检查表达式。

一个 IsExpr 表达式：e is T，类型为 Bool 。其中 e 可以是任何类型的表达式，T 可以是任何类型。

父类型：

• Expr

prop srcVal

public prop srcVal: Expr

功能：获取 IsExpr 节点中的源表达式节点。

类型：Expr

prop targetTypeAnnotation

public prop targetTypeAnnotation: TypeAnnotation

功能：获取 IsExpr 节点中的目标类型。

类型：TypeAnnotation

init(Expr, TypeAnnotation, Array<Comment>)

public init(srcVal: Expr, targetTypeAnnotation: TypeAnnotation, comments!: Array<Comment> = [])

功能：构造一个 IsExpr 对象，表示类型判断表达式，如 x is Int64。

参数：

• srcVal: Expr - 被判断的源表达式。
• targetTypeAnnotation: TypeAnnotation - 目标类型。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 srcVal
    let srcVal = SymbolRef("x", [])

    // 创建 targetTypeAnnotation
    let targetTypeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 IsExpr 实例
    let isExpr = IsExpr(
        srcVal, 
        targetTypeAnnotation
    )

    println("isExpr: ${isExpr}")
}

运行结果：

isExpr: x is Int64

func getIsKeyWordPos()

public func getIsKeyWordPos(): CodePositionRange

功能：获取 is 的位置。

返回值：

• CodePositionRange - 返回 is 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 srcVal
    let srcVal = SymbolRef("x", [])

    // 创建 targetTypeAnnotation
    let targetTypeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 IsExpr 实例
    let isExpr = IsExpr(srcVal, targetTypeAnnotation)
    let pos = isExpr.getIsKeyWordPos()

    // 输出 is 关键字位置
    println("isExpr.getIsKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

isExpr.getIsKeyWordPos(): 1:3-1:5

class Lambda

public class Lambda <: Expr {
    public init(body: Array<SyntaxTreeNode>, params: ParameterList, comments!: Array<Comment> = [])
}

功能：表示 Lambda 表达式，是一个匿名的函数。

一个 Lambda 节点有两种形式，一种是有形参的，例如 {a: Int64 => e1; e2 }，另一种是无形参的，例如 { => e1; e2 }。

父类型：

• Expr

prop body

public prop body: Array<SyntaxTreeNode>

功能：获取当前 Lambda 表达式的主体代码块。

类型：Array<SyntaxTreeNode>

prop params

public prop params: ParameterList

功能：获取当前 Lambda 表达式的参数列表。

类型：ParameterList

init(Array<SyntaxTreeNode>, ParameterList, Array<Comment>)

public init(body: Array<SyntaxTreeNode>, params: ParameterList, comments!: Array<Comment> = [])

功能：构造一个 Lambda 对象，表示匿名函数（lambda）表达式，如 { x => x + 1 }。

参数：

• body: Array<SyntaxTreeNode> - lambda 体中的语法节点列表。
• params: ParameterList - 参数列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 body
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []),BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]

    // 创建 params
    let params = ParameterList(LambdaParam("x", None), hasParen:false)

    // 创建 Lambda 实例
    let lambda = Lambda(
        body, 
        params
    )

    println("lambda: ${lambda}")
}

运行结果：

lambda: { x => x + 1 }

func getDoubleArrowPos()

public func getDoubleArrowPos(): Option<CodePositionRange>

功能：获取当前 Lambda 中 => 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 => 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 Lambda 实例
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]
    let params = ParameterList(LambdaParam("x", None), hasParen: false)
    let lambda = Lambda(body, params)

    if (let Some(pos) <- lambda.getDoubleArrowPos()) {
        // 输出双箭头位置
        println("lambda.getDoubleArrowPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

lambda.getDoubleArrowPos(): 1:5-1:7

func getLCurlPos()

public func getLCurlPos(): CodePositionRange

功能：获取当前 Lambda 中 { 的位置。

返回值：

• CodePositionRange - 返回 { 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 Lambda 实例
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]
    let params = ParameterList(LambdaParam("x", None), hasParen: false)
    let lambda = Lambda(body, params)
    let pos = lambda.getLCurlPos()

    // 输出左花括号位置
    println("lambda.getLCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

lambda.getLCurlPos(): 1:1-1:2

func getRCurlPos()

public func getRCurlPos(): CodePositionRange

功能：获取当前 Lambda 中 } 的位置。

返回值：

• CodePositionRange - 返回 } 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 Lambda 实例
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]
    let params = ParameterList(LambdaParam("x", None), hasParen: false)
    let lambda = Lambda(body, params)
    let pos = lambda.getRCurlPos()

    // 输出右花括号位置
    println("lambda.getRCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

lambda.getRCurlPos(): 1:14-1:15

class LambdaParam

public open class LambdaParam <: Parameter {
    public init(name: String, typeAnnotation: Option<TypeAnnotation>, comments!: Array<Comment> = [])
}

功能：表示一个 lambda 参数。

LambdaParam 类用于在程序中声明一个新的 lambda 参数，name 表示参数的名称，typeAnnotation 表示参数的类型标注。

父类型：

• Parameter

prop name

public prop name: String

功能：获取当前 lambda 参数的名称。

类型：String

prop typeAnnotation

public prop typeAnnotation: Option<TypeAnnotation>

功能：获取 LambdaParam 节点中的类型标注（若不存在返回 None）。

类型：Option<TypeAnnotation>

init(String, Option<TypeAnnotation>, Array<Comment>)

public init(name: String, typeAnnotation: Option<TypeAnnotation>, comments!: Array<Comment> = [])

功能：构造一个 LambdaParam 对象，表示 lambda 参数节点。

参数：

• name: String - 参数名。
• typeAnnotation: Option<TypeAnnotation> - 可选的类型注解。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 name
    let name = "x"

    // 创建 typeAnnotation
    let typeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 LambdaParam 实例
    let lambdaParam = LambdaParam(
        name, 
        typeAnnotation
    )

    println("lambdaParam: ${lambdaParam}")
}

运行结果：

lambdaParam: x: Int64

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 LambdaParam 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 LambdaParam 实例
    let lambdaParam = LambdaParam("x", AtomicType(AtomicTypeKind.Int64Type))
    let pos = lambdaParam.getIdentifierPos()

    // 输出标识符位置
    println("lambdaParam.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

lambdaParam.getIdentifierPos(): 1:1-1:2

func getTypeAnnotationColonPos()

public func getTypeAnnotationColonPos(): Option<CodePositionRange>

功能：获取 LambdaParam 节点中 : 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 : 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 LambdaParam 实例
    let lambdaParam = LambdaParam("x", AtomicType(AtomicTypeKind.Int64Type))

    if (let Some(pos) <- lambdaParam.getTypeAnnotationColonPos()) {
        // 输出冒号位置
        println("lambdaParam.getTypeAnnotationColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

lambdaParam.getTypeAnnotationColonPos(): 1:2-1:3

class LetPattern

public class LetPattern <: SyntaxTreeNode {
    public init(expr: Expr, patterns: Array<Pattern>, comments!: Array<Comment> = [])
}

功能：表示一个 let 模式绑定表达式。

它将一个表达式绑定到一个或多个模式以进行解构。

父类型：

• SyntaxTreeNode

prop expr

public prop expr: Expr

功能：需要解构的表达式。

类型：Expr

prop patterns

public prop patterns: Array<Pattern>

功能：绑定表达式的模式列表。

类型：Array<Pattern>

init(Expr, Array<Pattern>, Array<Comment>)

public init(expr: Expr, patterns: Array<Pattern>, comments!: Array<Comment> = [])

功能：构造一个 LetPattern 对象，表示 let 模式绑定表达式。

参数：

• expr: Expr - 被绑定的表达式。
• patterns: Array<Pattern> - 用于解构的模式列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 patterns 为空时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 expr
    let expr = SymbolRef("y", [])

    // 创建 patterns
    let patterns: Array<Pattern> = [VarPattern("x")]

    // 创建 LetPattern 实例
    let letPattern = LetPattern(
        expr, 
        patterns
    )

    println("letPattern: ${letPattern}")
}

运行结果：

letPattern: let x <- y

func getBackArrowPos()

public func getBackArrowPos(): CodePositionRange

功能：获取 LetPattern 节点中 <- 的位置。

返回值：

• CodePositionRange - 返回 <- 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 expr
    let expr = SymbolRef("y", [])

    // 创建 patterns
    let patterns: Array<Pattern> = [VarPattern("x")]

    // 创建 LetPattern 实例
    let letPattern = LetPattern(expr, patterns)
    let pos = letPattern.getBackArrowPos()

    // 输出后箭头位置
    println("letPattern.getBackArrowPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

letPattern.getBackArrowPos(): 1:7-1:9

func getBitOrsPos()

public func getBitOrsPos(): Array<CodePositionRange>

功能：获取 LetPattern 节点中 | 的位置序列。

返回值：

• Array<CodePositionRange> - 返回 | 的位置序列。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 expr
    let expr = SymbolRef("y", [])

    // 创建 patterns
    let patterns: Array<Pattern> = [
        VarPattern("x1"),
        VarPattern("x2"),
        VarPattern("x3")
    ]

    // 创建 LetPattern 实例
    let letPattern = LetPattern(expr, patterns)
    let posArr = letPattern.getBitOrsPos()

    // 遍历输出竖线位置
    for (i in 0..posArr.size) {
        println("letPattern.getBitOrsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

letPattern.getBitOrsPos()[0]: 1:8-1:9
letPattern.getBitOrsPos()[1]: 1:13-1:14

func getLetKeyWordPos()

public func getLetKeyWordPos(): CodePositionRange

功能：获取 LetPattern 节点中 let 关键字的位置。

返回值：

• CodePositionRange - 返回 let 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 expr
    let expr = SymbolRef("y", [])

    // 创建 patterns
    let patterns: Array<Pattern> = [VarPattern("x")]

    // 创建 LetPattern 实例
    let letPattern = LetPattern(expr, patterns)
    let pos = letPattern.getLetKeyWordPos()

    // 输出 let 关键字位置
    println("letPattern.getLetKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

letPattern.getLetKeyWordPos(): 1:1-1:4

class LitConstExpr

public open class LitConstExpr <: Expr {
    public init(kind: LitConstKind, rawValue: String, comments!: Array<Comment> = [])
}

功能：表示一个字面量表达式节点。

一个 LitConstExpr 表达式：1.0，123 等。

父类型：

• Expr

prop kind

public prop kind: LitConstKind

功能：获取当前字面量表达式的类型。

类型：LitConstKind

prop rawValue

public prop rawValue: String

功能：获取当前字面量表达式的原始值。

类型：String

init(LitConstKind, String, Array<Comment>)

public init(kind: LitConstKind, rawValue: String, comments!: Array<Comment> = [])

功能：构造一个 LitConstExpr 对象，表示字面量常量表达式。

参数：

• kind: LitConstKind - 字面量类型。
• rawValue: String - 字面量的原始字符串值。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 kind 为 RuneLiteral 或 StringLiteral 时，或 rawValue 无法用于构建对应类型字面量时，抛出异常，异常中包含报错提示信息。

注意：

不支持构造字符类型和字符串类型的字面量表达式节点，字符类型的字面量表达式节点通过 LitConstRuneExpr 构造，字符串类型的字面量表达式节点通过 LitConstStrExpr 构造。

示例：

import stdx.syntax.*

main() {
    // 设置字面量类型
    let kind = LitConstKind.BoolLiteral

    // 设置原始值
    let rawValue = "true"

    // 创建 LitConstExpr 实例
    let litConstExpr = LitConstExpr(
        kind, 
        rawValue
    )

    println("litConstExpr: ${litConstExpr}")
}

运行结果：

litConstExpr: true

class LitConstRuneExpr

public class LitConstRuneExpr <: LitConstExpr {
    public init(kind: LitConstKind, rawValue: String, isSingleQuote: Bool, comments!: Array<Comment> = [])
}

功能：表示一个字符类型的字面量表达式节点。

一个 LitConstRuneExpr 表达式：r'a'。

父类型：

• LitConstExpr

注意：

syntax 库不支持字符字节字面量，即形如 b'x' 的字面量。

prop isSingleQuote

public prop isSingleQuote: Bool

功能：表示当前字符字面量表达式是否为单引号引用。

类型：Bool

init(LitConstKind, String, Bool, Array<Comment>)

public init(kind: LitConstKind, rawValue: String, isSingleQuote: Bool, comments!: Array<Comment> = [])

功能：构造一个 LitConstRuneExpr 对象，表示字符字面量表达式。

参数：

• kind: LitConstKind - 字面量类型，固定为 RuneLiteral。
• rawValue: String - 字面量的原始字符串值。
• isSingleQuote: Bool - 是否使用单引号包裹。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 kind 不是字符字面量类型时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 设置字面量类型
    let kind = LitConstKind.RuneLiteral

    // 设置原始值
    let rawValue = "a"

    // 设置是否为单引号
    let isSingleQuote = true

    // 创建 LitConstRuneExpr 实例
    let litConstRuneExpr = LitConstRuneExpr(
        kind, 
        rawValue, 
        isSingleQuote
    )

    println("litConstRuneExpr: ${litConstRuneExpr}")
}

运行结果：

litConstRuneExpr: r'a'

class LitConstStrExpr

public class LitConstStrExpr <: LitConstExpr {
    public init(kind: LitConstKind, rawValue: String, delimiterNum: Int64, isSingleQuote: Bool, strKind: LitConstStrKind, strPartExprs: Array<StrLiteralPart>,
        comments!: Array<Comment> = [])
}

功能：表示一个字符串类型的字面量表达式节点。

一个 LitConstStrExpr 表达式："me"，#"hi"# 等。

父类型：

• LitConstExpr

prop delimiterNum

public prop delimiterNum: Int64

功能：表示当前 LitConstStrExpr 前后成对出现的 # 分隔符数。例如 ##'\n'## 中 delimiterNum = 2 。

类型：Int64

prop isSingleQuote

public prop isSingleQuote: Bool

功能：表示当前 LitConstStrExpr 是否为单引号引用。

类型：Bool

prop strKind

public prop strKind: LitConstStrKind

功能：获取当前 LitConstStrExpr 的类型

类型：LitConstStrKind

prop strPartExprs

public prop strPartExprs: Array<StrLiteralPart>

功能：获取当前 LitConstStrExpr 中的各个字符串部分，分为字面量表达式和插值字符串表达式两种。

类型：Array<StrLiteralPart>

init(LitConstKind, String, Int64, Bool, LitConstStrKind, Array<StrLiteralPart>, Array<Comment>)

public init(kind: LitConstKind, rawValue: String, delimiterNum: Int64, isSingleQuote: Bool, strKind: LitConstStrKind, strPartExprs: Array<StrLiteralPart>, comments!: Array<Comment> = [])

功能：构造一个 LitConstStrExpr 对象，表示字符串字面量表达式，支持插值。

参数：

• kind: LitConstKind - 字面量类型。
• rawValue: String - 字面量的原始字符串值。
• delimiterNum: Int64 - 分隔符数量。
• isSingleQuote: Bool - 是否使用单引号包裹。
• strKind: LitConstStrKind - 字符串字面量种类。
• strPartExprs: Array<StrLiteralPart> - 字符串片段列表，可包含插值。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 strKind 为 MultiLineRawString 且 delimiterNum 为 0 时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 kind
    let kind = LitConstKind.StringLiteral

    // 创建 rawValue
    let rawValue = "abc"

    // 创建 delimiterNum
    let delimiterNum = 0

    // 创建 isSingleQuote
    let isSingleQuote = true

    // 创建 strKind
    let strKind = LitConstStrKind.StringLiteral

    // 创建 strPartExprs
    let strPartExprs: Array<StrLiteralPart> = []

    // 创建 LitConstStrExpr 实例
    let litConstStrExpr = LitConstStrExpr(
        kind, 
        rawValue, 
        delimiterNum, 
        isSingleQuote, 
        strKind, 
        strPartExprs
    )

    println("litConstStrExpr: ${litConstStrExpr}")
}

运行结果：

litConstStrExpr: 'abc'

func hasInterpolation()

public func hasInterpolation(): Bool

功能：表示当前 LitConstStrExpr 是否存在插值。

返回值：

• Bool - 返回是否存在插值。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 LitConstStrExpr 实例
    let litConstStrExpr = LitConstStrExpr(LitConstKind.StringLiteral, "abc", 0, true, LitConstStrKind.StringLiteral, [])
    let hasInterp = litConstStrExpr.hasInterpolation()

    // 输出是否存在插值
    println("litConstStrExpr.hasInterpolation(): ${hasInterp}")
}

运行结果：

litConstStrExpr.hasInterpolation(): false

class MacroDecl

public class MacroDecl <: Decl {
    public init(body: Block, name: String, params: ParameterList, retTyAnnotation: Option<TypeAnnotation>,
        annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])
}

功能：表示一个宏定义节点。

一个 MacroDecl 节点：public macro M(input: Tokens): Tokens {...}。

父类型：

• Decl

prop body

public prop body: Block

功能：获取 MacroDecl 节点的函数体。

类型：Block

prop name

public prop name: String

功能：获取 MacroDecl 节点的名称。

类型：String

prop params

public prop params: ParameterList

功能：获取 MacroDecl 节点的的参数列表。

类型：ParameterList

prop retTyAnnotation

public prop retTyAnnotation: Option<TypeAnnotation>

功能：获取 MacroDecl 节点的函数返回类型。

类型：Option<TypeAnnotation>

init(Block, String, ParameterList, Option<TypeAnnotation>, Array<Annotation>, Array<Modifier>, Array<Comment>)

public init(body: Block, name: String, params: ParameterList, retTyAnnotation: Option<TypeAnnotation>,
    annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [], comments!: Array<Comment> = [])

功能：构造一个 MacroDecl 对象，表示宏声明节点，如 macro myMacro(input: Tokens): Tokens {...}。

参数：

• body: Block - 宏体。
• name: String - 宏名。
• params: ParameterList - 参数列表。
• retTyAnnotation: Option<TypeAnnotation> - 可选的返回类型注解。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• modifiers!: Array<Modifier> - 修饰符列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 body
    let body = Block([])

    // 创建 name
    let name = "foo"

    // 创建 params
    let params = ParameterList([])

    // 创建 retTyAnnotation
    let retTyAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 MacroDecl 实例
    let macroDecl = MacroDecl(
        body, 
        name, 
        params, 
        retTyAnnotation
    )

    println("macroDecl: ${macroDecl}")
}

运行结果：

macroDecl: macro foo(): Int64 {
}

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 MacroDecl 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 MacroDecl 实例
    let body = Block([])
    let params = ParameterList([])
    let macroDecl = MacroDecl(body, "foo", params, None)
    let pos = macroDecl.getIdentifierPos()

    // 输出标识符位置
    println("macroDecl.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

macroDecl.getIdentifierPos(): 1:7-1:10

func getMacroKeyWordPos()

public func getMacroKeyWordPos(): CodePositionRange

功能：获取 MacroDecl 节点中 macro 关键字的位置。

返回值：

• CodePositionRange - 返回 macro 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 MacroDecl 实例
    let body = Block([])
    let params = ParameterList([])
    let macroDecl = MacroDecl(body, "foo", params, None)
    let pos = macroDecl.getMacroKeyWordPos()

    // 输出 macro 关键字位置
    println("macroDecl.getMacroKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

macroDecl.getMacroKeyWordPos(): 1:1-1:6

func getRetTyAnnotationColonPos()

public func getRetTyAnnotationColonPos(): Option<CodePositionRange>

功能：获取 MacroDecl 节点中返回类型的冒号的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回返回类型的冒号的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 MacroDecl 实例
    let body = Block([])
    let params = ParameterList([])
    let retTyAnnotation = AtomicType(AtomicTypeKind.Int64Type)
    let macroDecl = MacroDecl(body, "foo", params, retTyAnnotation)

    if (let Some(pos) <- macroDecl.getRetTyAnnotationColonPos()) {
        // 输出冒号位置
        println("macroDecl.getRetTyAnnotationColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroDecl.getRetTyAnnotationColonPos(): 1:12-1:13

class MacroExpandDecl

public class MacroExpandDecl <: Decl {
    public init(calleeMacro: Expr, macroAttrs: Tokens, macroInputs: MacroExpandInput,
        annotations!: Array<Annotation> = [], comments!: Array<Comment> = [])
}

功能：表示宏展开声明。

用于在编译时执行宏并将其展开为具体代码，实现元编程能力。

父类型：

• Decl

prop calleeMacro

public prop calleeMacro: Expr

功能：获取被调用的宏表达式。

类型：Expr

prop macroAttrs

public prop macroAttrs: Tokens

功能：获取宏的属性标记集合，用于传递编译时元数据。

类型：Tokens

prop macroInputs

public prop macroInputs: MacroExpandInput

功能：获取宏展开的输入声明，定义宏执行所需的上下文。

类型：MacroExpandInput

init(Expr, Tokens, MacroExpandInput, Array<Annotation>, Array<Comment>)

public init(calleeMacro: Expr, macroAttrs: Tokens, macroInputs: MacroExpandInput,
    annotations!: Array<Annotation> = [], comments!: Array<Comment> = [])

功能：构造一个 MacroExpandDecl 对象，表示宏展开声明节点。

参数：

• calleeMacro: Expr - 被调用的宏表达式。
• macroAttrs: Tokens - 宏的属性标记序列，会被格式化。
• macroInputs: MacroExpandInput - 宏输入，会被格式化。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当宏调用表达式不是成员访问或引用表达式时，格式化过程中内存分配失败，或 macroInputs 不在 MacroExpandInput 中时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        "EnumA",
        [AtomicType(AtomicTypeKind.Int64Type)]
    )

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithoutParens(enumConstructor)

    // 创建 MacroExpandDecl 实例
    let macroExpandDecl = MacroExpandDecl(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    println("macroExpandDecl: ${macroExpandDecl}")
}

运行结果：

macroExpandDecl: @testMacro[123]
EnumA(Int64)

func getAtPos()

public func getAtPos(): CodePositionRange

功能：获取 MacroExpandDecl 节点中 @ 的位置。

返回值：

• CodePositionRange - 返回 @ 的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        "EnumA",
        [AtomicType(AtomicTypeKind.Int64Type)]
    )

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithoutParens(enumConstructor)

    // 创建 MacroExpandDecl 实例
    let macroExpandDecl = MacroExpandDecl(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    let pos = macroExpandDecl.getAtPos()
    // 输出 @ 位置
    println("macroExpandDecl.getAtPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

macroExpandDecl.getAtPos(): 1:1-1:2

func getLParenPos()

public func getLParenPos(): Option<CodePositionRange>

功能：获取 MacroExpandDecl 节点中 ( 的位置。

返回值：

• Option<CodePositionRange> - 返回 ( 的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        "EnumA",
        [AtomicType(AtomicTypeKind.Int64Type)]
    )

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithoutParens(enumConstructor)

    // 创建 MacroExpandDecl 实例
    let macroExpandDecl = MacroExpandDecl(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    // 实际上所创建的 MacroExpandDecl 节点中不存在 ( 子节点，因此 getLParenPos() 会返回 None
    if (let Some(pos) <- macroExpandDecl.getLParenPos()) {
        // 输出 ( 位置
        println("macroExpandDecl.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    } else {
        println("macroExpandDecl.getLParenPos(): None")
    }
}

运行结果：

macroExpandDecl.getLParenPos(): None

func getLSquarePos()

public func getLSquarePos(): Option<CodePositionRange>

功能：获取 MacroExpandDecl 节点中 [ 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 [ 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        "EnumA",
        [AtomicType(AtomicTypeKind.Int64Type)]
    )

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithoutParens(enumConstructor)

    // 创建 MacroExpandDecl 实例
    let macroExpandDecl = MacroExpandDecl(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    if (let Some(pos) <- macroExpandDecl.getLSquarePos()) {
        // 输出 [ 位置
        println("macroExpandDecl.getLSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandDecl.getLSquarePos(): 1:11-1:12

func getRParenPos()

public func getRParenPos(): Option<CodePositionRange>

功能：获取 MacroExpandDecl 节点中 ) 的位置。

返回值：

• Option<CodePositionRange> - 返回 ) 的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        "EnumA",
        [AtomicType(AtomicTypeKind.Int64Type)]
    )

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithoutParens(enumConstructor)

    // 创建 MacroExpandDecl 实例
    let macroExpandDecl = MacroExpandDecl(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    // 实际上所创建的 MacroExpandDecl 节点中不存在 ( 子节点，因此 getLParenPos() 会返回 None
    if (let Some(pos) <- macroExpandDecl.getRParenPos()) {
        // 输出 ) 位置
        println("macroExpandDecl.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    } else {
        println("macroExpandDecl.getRParenPos(): None")
    }
}

运行结果：

macroExpandDecl.getRParenPos(): None

func getRSquarePos()

public func getRSquarePos(): Option<CodePositionRange>

功能：获取 MacroExpandDecl 节点中 ] 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ] 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        "EnumA",
        [AtomicType(AtomicTypeKind.Int64Type)]
    )

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithoutParens(enumConstructor)

    // 创建 MacroExpandDecl 实例
    let macroExpandDecl = MacroExpandDecl(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    if (let Some(pos) <- macroExpandDecl.getRSquarePos()) {
        // 输出 ] 位置
        println("macroExpandDecl.getRSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandDecl.getRSquarePos(): 1:15-1:16

class MacroExpandExpr

public class MacroExpandExpr <: Expr {
    public init(calleeMacro: Expr, macroAttrs: Tokens, macroInputs: MacroExpandInput, comments!: Array<Comment> = [])
}

功能：表示宏展开表达式。

用于在表达式上下文中执行编译时宏，将宏调用展开为具体的表达式代码。

父类型：

• Expr

prop calleeMacro

public prop calleeMacro: Expr

功能：获取被调用的宏表达式。

类型：Expr

prop macroAttrs

public prop macroAttrs: Tokens

功能：获取宏的属性标记集合，用于传递编译时元数据。

类型：Tokens

prop macroInputs

public prop macroInputs: MacroExpandInput

功能：获取宏展开的输入声明，定义宏执行所需的上下文。

类型：MacroExpandInput

init(Expr, Tokens, MacroExpandInput, Array<Comment>)

public init(calleeMacro: Expr, macroAttrs: Tokens, macroInputs: MacroExpandInput, comments!: Array<Comment> = [])

功能：构造一个 MacroExpandExpr 对象，表示宏展开表达式节点。

参数：

• calleeMacro: Expr - 被调用的宏表达式。
• macroAttrs: Tokens - 宏的属性标记序列。
• macroInputs: MacroExpandInput - 宏输入，可以是带括号的 Tokens 或不带括号的 Decl。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当宏调用表达式不是成员访问或引用表达式时，格式化过程中内存分配失败，或 macroInputs 不在 MacroExpandInput 中时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        "EnumA",
        [AtomicType(AtomicTypeKind.Int64Type)]
    )

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(1 + 1))

    // 创建 MacroExpandExpr 实例
    let macroExpandExpr = MacroExpandExpr(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    println("macroExpandExpr: ${macroExpandExpr}")
}

运行结果：

macroExpandExpr: @testMacro[123](1 + 1)

func getAtPos()

public func getAtPos(): CodePositionRange

功能：获取 MacroExpandExpr 节点中 @ 的位置。

返回值：

• CodePositionRange - 返回 @ 的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(1 + 1))

    // 创建 MacroExpandExpr 实例
    let macroExpandExpr = MacroExpandExpr(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    let pos = macroExpandExpr.getAtPos()
    // 输出 @ 位置
    println("macroExpandExpr.getAtPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

macroExpandExpr.getAtPos(): 1:1-1:2

func getLParenPos()

public func getLParenPos(): Option<CodePositionRange>

功能：获取 MacroExpandExpr 节点中 ( 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ( 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(1 + 1))

    // 创建 MacroExpandExpr 实例
    let macroExpandExpr = MacroExpandExpr(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    if (let Some(pos) <- macroExpandExpr.getLParenPos()) {
        // 输出 ( 位置
        println("macroExpandExpr.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandExpr.getLParenPos(): 1:16-1:17

func getLSquarePos()

public func getLSquarePos(): Option<CodePositionRange>

功能：获取 MacroExpandExpr 节点中 [ 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 [ 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(1 + 1))

    // 创建 MacroExpandExpr 实例
    let macroExpandExpr = MacroExpandExpr(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    if (let Some(pos) <- macroExpandExpr.getLSquarePos()) {
        // 输出 [ 位置
        println("macroExpandExpr.getLSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandExpr.getLSquarePos(): 1:11-1:12

func getRParenPos()

public func getRParenPos(): Option<CodePositionRange>

功能：获取 MacroExpandExpr 节点中 ) 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ) 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(1 + 1))

    // 创建 MacroExpandExpr 实例
    let macroExpandExpr = MacroExpandExpr(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    if (let Some(pos) <- macroExpandExpr.getRParenPos()) {
        // 输出 ) 位置
        println("macroExpandExpr.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandExpr.getRParenPos(): 1:22-1:23

func getRSquarePos()

public func getRSquarePos(): Option<CodePositionRange>

功能：获取 MacroExpandExpr 节点中 ] 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ] 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(1 + 1))

    // 创建 MacroExpandExpr 实例
    let macroExpandExpr = MacroExpandExpr(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    if (let Some(pos) <- macroExpandExpr.getRSquarePos()) {
        // 输出 ] 位置
        println("macroExpandExpr.getRSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandExpr.getRSquarePos(): 1:15-1:16

class MacroExpandParam

public class MacroExpandParam <: Parameter {
    public init(calleeMacro: Expr, macroAttrs: Tokens, macroInputs: MacroExpandInput,
        annotations!: Array<Annotation> = [], comments!: Array<Comment> = [])
}

功能：表示宏展开参数。

用于在函数参数定义中应用编译时宏，将宏逻辑应用于参数处理。

父类型：

• Parameter

prop calleeMacro

public prop calleeMacro: Expr

功能：获取被调用的宏表达式。

类型：Expr

prop macroAttrs

public prop macroAttrs: Tokens

功能：获取宏的属性标记集合，用于传递编译时元数据。

类型：Tokens

prop macroInputs

public prop macroInputs: MacroExpandInput

功能：获取宏展开的输入声明，定义宏执行所需的上下文。

类型：MacroExpandInput

init(Expr, Tokens, MacroExpandInput, Array<Annotation>, Array<Comment>)

public init(calleeMacro: Expr, macroAttrs: Tokens, macroInputs: MacroExpandInput,
    annotations!: Array<Annotation> = [], comments!: Array<Comment> = [])

功能：构造一个 MacroExpandParam 对象，表示宏展开参数节点，用于函数参数中嵌入宏调用。

参数：

• calleeMacro: Expr - 被调用的宏表达式。
• macroAttrs: Tokens - 宏的属性标记序列。
• macroInputs: MacroExpandInput - 宏输入，可以是带括号的 Tokens 或不带括号的 Decl。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当宏调用表达式不是成员访问或引用表达式时，格式化过程中内存分配失败，或 macroInputs 不在 MacroExpandInput 中时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 EnumConstructor 实例
    let enumConstructor = EnumConstructor(
        "EnumA",
        [AtomicType(AtomicTypeKind.Int64Type)]
    )

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(a: Int64))

    // 创建 MacroExpandParam 实例
    let macroExpandParam = MacroExpandParam(
        calleeMacro,
        macroAttrs,
        macroInputs
    )

    println("macroExpandParam: ${macroExpandParam}")
}

运行结果：

macroExpandParam: @testMacro[123](a: Int64)

func getAtPos()

public func getAtPos(): CodePositionRange

功能：获取 MacroExpandParam 节点中 @ 的位置。

返回值：

• CodePositionRange - 返回 @ 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(a: Int64))

    // 创建 MacroExpandParam 实例
    let macroExpandParam = MacroExpandParam(
        calleeMacro,
        macroAttrs,
        macroInputs
    )
    let pos = macroExpandParam.getAtPos()

    // 输出 @ 位置
    println("macroExpandParam.getAtPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

macroExpandParam.getAtPos(): 1:1-1:2

func getLParenPos()

public func getLParenPos(): Option<CodePositionRange>

功能：获取 MacroExpandParam 节点中 ( 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ( 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(a: Int64))

    // 创建 MacroExpandParam 实例
    let macroExpandParam = MacroExpandParam(
        calleeMacro,
        macroAttrs,
        macroInputs
    )
    if (let Some(pos) <- macroExpandParam.getLParenPos()) {
        // 输出 ( 位置
        println("macroExpandParam.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandParam.getLParenPos(): 1:16-1:17

func getLSquarePos()

public func getLSquarePos(): Option<CodePositionRange>

功能：获取 MacroExpandParam 节点中 [ 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 [ 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(a: Int64))

    // 创建 MacroExpandParam 实例
    let macroExpandParam = MacroExpandParam(
        calleeMacro,
        macroAttrs,
        macroInputs
    )
    if (let Some(pos) <- macroExpandParam.getLSquarePos()) {
        // 输出 [ 位置
        println("macroExpandParam.getLSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandParam.getLSquarePos(): 1:11-1:12

func getRParenPos()

public func getRParenPos(): Option<CodePositionRange>

功能：获取 MacroExpandParam 节点中 ) 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ) 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(a: Int64))

    // 创建 MacroExpandParam 实例
    let macroExpandParam = MacroExpandParam(
        calleeMacro,
        macroAttrs,
        macroInputs
    )
    if (let Some(pos) <- macroExpandParam.getRParenPos()) {
        // 输出 ) 位置
        println("macroExpandParam.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandParam.getRParenPos(): 1:25-1:26

func getRSquarePos()

public func getRSquarePos(): Option<CodePositionRange>

功能：获取 MacroExpandParam 节点中 ] 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ] 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 calleeMacro
    let calleeMacro = SymbolRef(
        "testMacro",
        []
    )

    // 创建 macroAttrs
    let macroAttrs = quote(123)

    // 创建 macroInputs
    let macroInputs = MacroExpandInput.WithParens(quote(a: Int64))

    // 创建 MacroExpandParam 实例
    let macroExpandParam = MacroExpandParam(
        calleeMacro,
        macroAttrs,
        macroInputs
    )
    if (let Some(pos) <- macroExpandParam.getRSquarePos()) {
        // 输出 ] 位置
        println("macroExpandParam.getRSquarePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

macroExpandParam.getRSquarePos(): 1:15-1:16

class MainDecl

public class MainDecl <: Decl {
    public init(body: Block, params: ParameterList, retTyAnnotation: Option<TypeAnnotation>, comments!: Array<Comment> = [])
}

功能：表示一个 main 函数声明节点。

一个 MainDecl 节点：main() {}。

父类型：

• Decl

prop body

public prop body: Block

功能：获取当前主函数声明的主体部分。

类型：Block

prop params

public prop params: ParameterList

功能：获取当前主函数声明的参数列表。

类型：ParameterList

prop retTyAnnotation

public prop retTyAnnotation: Option<TypeAnnotation>

功能：获取当前主函数声明的返回类型标注（若不存在返回 None）。

类型：Option<TypeAnnotation>

init(Block, ParameterList, Option<TypeAnnotation>, Array<Comment>)

public init(body: Block, params: ParameterList, retTyAnnotation: Option<TypeAnnotation>, comments!: Array<Comment> = [])

功能：构造一个 MainDecl 对象，表示主函数声明节点。

参数：

• body: Block - 主函数体。
• params: ParameterList - 参数列表。
• retTyAnnotation: Option<TypeAnnotation> - 可选的返回类型注解。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 body
    let body = Block([ReturnExpr(None)])

    // 创建 params
    let params = ParameterList([])

    // 创建 retTyAnnotation
    let retTyAnnotation = AtomicType(UnitType)

    // 创建 MainDecl 实例
    let mainDecl = MainDecl(
        body, 
        params, 
        retTyAnnotation
    )

    println("mainDecl: ${mainDecl}")
}

运行结果：

mainDecl: main(): Unit {
    return
}

func getMainKeyWordPos()

public func getMainKeyWordPos(): CodePositionRange

功能：获取 MainDecl 节点中 main 关键字的位置。

返回值：

• CodePositionRange - 返回 main 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 MainDecl 实例
    let body = Block([ReturnExpr(None)])
    let params = ParameterList([])
    let mainDecl = MainDecl(body, params, None)
    let pos = mainDecl.getMainKeyWordPos()

    // 输出 main 关键字位置
    println("mainDecl.getMainKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

mainDecl.getMainKeyWordPos(): 1:1-1:5

func getRetTyAnnotationColonPos()

public func getRetTyAnnotationColonPos(): Option<CodePositionRange>

功能：获取 MainDecl 节点中类型前 : 的位置。

返回值：

• Option<CodePositionRange> - 返回类型前 : 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 MainDecl 实例
    let body = Block([ReturnExpr(None)])
    let params = ParameterList([])
    let retTyAnnotation = AtomicType(UnitType)
    let mainDecl = MainDecl(body, params, retTyAnnotation)

    if (let Some(pos) <- mainDecl.getRetTyAnnotationColonPos()) {
        // 输出冒号位置
        println("mainDecl.getRetTyAnnotationColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

mainDecl.getRetTyAnnotationColonPos(): 1:7-1:8

class MatchCase

public class MatchCase <: SyntaxTreeNode {
    public init(patterns: Array<Pattern>, patternGuardCond: Option<Expr>, caseCond: Option<Expr>, body: Array<SyntaxTreeNode>, comments!: Array<Comment> = [])
}

功能：表示 match 表达式中的一个 case 节点。

一个 MatchCase 节点：case failScore where score > 0 => 0。

父类型：

• SyntaxTreeNode

prop body

public prop body: Array<SyntaxTreeNode>

功能：获取当前匹配条件满足时执行的代码块。

类型：Array<SyntaxTreeNode>

prop caseCond

public prop caseCond: Option<Expr>

功能：获取当前匹配条件的表达式（若不存在返回 None）。

类型：Option<Expr>

prop patternGuardCond

public prop patternGuardCond: Option<Expr>

功能：获取当前匹配条件的模式守卫表达式（若不存在返回 None）。

类型：Option<Expr>

prop patterns

public prop patterns: Array<Pattern>

功能：获取当前匹配条件的模式列表。

类型：Array<Pattern>

init(Array<Pattern>, Option<Expr>, Option<Expr>, Array<SyntaxTreeNode>, Array<Comment>)

public init(patterns: Array<Pattern>, patternGuardCond: Option<Expr>, caseCond: Option<Expr>, body: Array<SyntaxTreeNode>, comments!: Array<Comment> = [])

功能：构造一个 MatchCase 对象，表示 match 表达式中的分支 case。

参数：

• patterns: Array<Pattern> - 匹配模式列表。
• patternGuardCond: Option<Expr> - 可选的模式守卫条件。
• caseCond: Option<Expr> - 可选的 case 条件表达式。
• body: Array<SyntaxTreeNode> - case 体中的语法节点列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 body 中的节点不是表达式类型、函数声明或变量声明时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 patterns
    let patterns: Array<Pattern> = [VarPattern("x"), VarPattern("y")]

    // 创建 patternGuardCond
    let patternGuardCond = BinaryExpr(SymbolRef("x", []),BinaryOpKind.Lt, LitConstExpr(LitConstKind.IntergerLiteral, "5"))

    // 创建 body
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []),BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]

    // 创建 MatchCase 实例
    let matchCase = MatchCase(
        patterns, 
        patternGuardCond, 
        None, 
        body
    )

    println("matchCase: ${matchCase}")
}

运行结果：

matchCase: case x | y where x < 5 => x + 1

func getBitOrsPos()

public func getBitOrsPos(): Array<CodePositionRange>

功能：获取当前 MatchCase 中所有 | 的位置。

返回值：

• Array<CodePositionRange> - 返回所有 | 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 patterns
    let patterns: Array<Pattern> = [VarPattern("x"), VarPattern("y"), VarPattern("z")]

    // 创建 body
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]

    // 创建 MatchCase 实例
    let matchCase = MatchCase(patterns, None, None, body)
    let posArr = matchCase.getBitOrsPos()

    // 遍历输出竖线位置
    for (i in 0..posArr.size) {
        println("matchCase.getBitOrsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

matchCase.getBitOrsPos()[0]: 1:8-1:9
matchCase.getBitOrsPos()[1]: 1:12-1:13

func getCasePos()

public func getCasePos(): CodePositionRange

功能：获取当前 MatchCase 中 case 关键字的位置。

返回值：

• CodePositionRange - 返回 case 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 patterns
    let patterns: Array<Pattern> = [VarPattern("x")]

    // 创建 body
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]

    // 创建 MatchCase 实例
    let matchCase = MatchCase(patterns, None, None, body)
    let pos = matchCase.getCasePos()

    // 输出 case 关键字位置
    println("matchCase.getCasePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

matchCase.getCasePos(): 1:1-1:5

func getDoubleArrowPos()

public func getDoubleArrowPos(): CodePositionRange

功能：获取当前 MatchCase 中 => 的位置。

返回值：

• CodePositionRange - 返回 => 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 patterns
    let patterns: Array<Pattern> = [VarPattern("x")]

    // 创建 body
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]

    // 创建 MatchCase 实例
    let matchCase = MatchCase(patterns, None, None, body)
    let pos = matchCase.getDoubleArrowPos()

    // 输出双箭头位置
    println("matchCase.getDoubleArrowPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

matchCase.getDoubleArrowPos(): 1:8-1:10

func getWherePos()

public func getWherePos(): Option<CodePositionRange>

功能：获取当前 MatchCase 中 where 关键字的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 where 关键字的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 patterns
    let patterns: Array<Pattern> = [VarPattern("x")]

    // 创建 patternGuardCond
    let patternGuardCond = BinaryExpr(SymbolRef("x", []), BinaryOpKind.Lt, LitConstExpr(LitConstKind.IntergerLiteral, "5"))

    // 创建 body
    let body: Array<SyntaxTreeNode> = [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))]

    // 创建 MatchCase 实例
    let matchCase = MatchCase(patterns, patternGuardCond, None, body)

    if (let Some(pos) <- matchCase.getWherePos()) {
        // 输出 where 关键字位置
        println("matchCase.getWherePos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

matchCase.getWherePos(): 1:8-1:13

class MatchExpr

public class MatchExpr <: Expr {
    public init(matchCases: Array<MatchCase>, selector: Option<Expr>, comments!: Array<Comment> = [])
}

功能：表示模式匹配表达式，用于实现模式匹配。

模式匹配表达式分为带 selector 的 match 表达式和不带 selector 的 match 表达式。

父类型：

• Expr

prop matchCases

public prop matchCases: Array<MatchCase>

功能：获取当前 match 语句的所有匹配条件和对应的代码块。

类型：Array<MatchCase>

prop selector

public prop selector: Option<Expr>

功能：获取当前 match 语句的要匹配的表达式。

类型：Option<Expr>

init(Array<MatchCase>, Option<Expr>, Array<Comment>)

public init(matchCases: Array<MatchCase>, selector: Option<Expr>, comments!: Array<Comment> = [])

功能：构造一个 MatchExpr 对象，表示 match 表达式。

参数：

• matchCases: Array<MatchCase> - 分支 case 列表。
• selector: Option<Expr> - 可选的被匹配表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 matchCases
    let matchCases = [MatchCase([VarPattern("x"), VarPattern("y")], None, None, [BinaryExpr(SymbolRef("x", []),BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))])]

    // 创建 selector
    let selector = SymbolRef("x", [])

    // 创建 MatchExpr 实例
    let matchExpr = MatchExpr(
        matchCases, 
        selector
    )

    println("matchExpr: ${matchExpr}")
}

运行结果：

matchExpr: match (x) {
    case x | y => x + 1
}

func getMatchCasesLCurlPos()

public func getMatchCasesLCurlPos(): CodePositionRange

功能：获取当前 MatchExpr 中 { 的位置。

返回值：

• CodePositionRange - 返回 { 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 matchCases
    let matchCases = [MatchCase([VarPattern("x")], None, None, [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))])]

    // 创建 MatchExpr 实例
    let matchExpr = MatchExpr(matchCases, SymbolRef("x", []))
    let pos = matchExpr.getMatchCasesLCurlPos()

    // 输出左花括号位置
    println("matchExpr.getMatchCasesLCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

matchExpr.getMatchCasesLCurlPos(): 1:11-1:12

func getMatchCasesRCurlPos()

public func getMatchCasesRCurlPos(): CodePositionRange

功能：获取当前 MatchExpr 中 } 的位置。

返回值：

• CodePositionRange - 返回 } 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 matchCases
    let matchCases = [MatchCase([VarPattern("x")], None, None, [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))])]

    // 创建 MatchExpr 实例
    let matchExpr = MatchExpr(matchCases, SymbolRef("x", []))
    let pos = matchExpr.getMatchCasesRCurlPos()

    // 输出右花括号位置
    println("matchExpr.getMatchCasesRCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

matchExpr.getMatchCasesRCurlPos(): 3:1-3:2

func getMatchKeyWordPos()

public func getMatchKeyWordPos(): CodePositionRange

功能：获取当前 MatchExpr 中 match 关键字的位置。

返回值：

• CodePositionRange - 返回 match 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 matchCases
    let matchCases = [MatchCase([VarPattern("x")], None, None, [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))])]

    // 创建 MatchExpr 实例
    let matchExpr = MatchExpr(matchCases, SymbolRef("x", []))
    let pos = matchExpr.getMatchKeyWordPos()

    // 输出 match 关键字位置
    println("matchExpr.getMatchKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

matchExpr.getMatchKeyWordPos(): 1:1-1:6

func getSelectorLParenPos()

public func getSelectorLParenPos(): Option<CodePositionRange>

功能：获取当前 MatchExpr 的选择器中的 ( 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回选择器中的 ( 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 matchCases
    let matchCases = [MatchCase([VarPattern("x")], None, None, [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))])]

    // 创建 MatchExpr 实例
    let matchExpr = MatchExpr(matchCases, SymbolRef("x", []))

    if (let Some(pos) <- matchExpr.getSelectorLParenPos()) {
        // 输出选择器左括号位置
        println("matchExpr.getSelectorLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

matchExpr.getSelectorLParenPos(): 1:7-1:8

func getSelectorRParenPos()

public func getSelectorRParenPos(): Option<CodePositionRange>

功能：获取当前 MatchExpr 的选择器中的 ) 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回选择器中的 ) 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 matchCases
    let matchCases = [MatchCase([VarPattern("x")], None, None, [BinaryExpr(SymbolRef("x", []), BinaryOpKind.Add, LitConstExpr(LitConstKind.IntergerLiteral, "1"))])]

    // 创建 MatchExpr 实例
    let matchExpr = MatchExpr(matchCases, SymbolRef("x", []))

    if (let Some(pos) <- matchExpr.getSelectorRParenPos()) {
        // 输出选择器右括号位置
        println("matchExpr.getSelectorRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

matchExpr.getSelectorRParenPos(): 1:9-1:10

class MemberAccess

public class MemberAccess <: Expr {
    public init(base: SyntaxTreeNode, field: SymbolRef, comments!: Array<Comment> = [])
}

功能：表示成员访问表达式。

可以用于访问 class、interface、struct 等类型的成员。一个 MemberAccess 节点的形式为 p.a，p 为成员访问表达式的主体，a 表示成员的名字。

父类型：

• Expr

prop base

public prop base: SyntaxTreeNode

功能：获取当前成员访问表达式的基节点，即被访问的对象或结构体。

类型：SyntaxTreeNode

prop field

public prop field: SymbolRef

功能：获取当前成员访问表达式中要访问的成员字段。

类型：SymbolRef

init(SyntaxTreeNode, SymbolRef, Array<Comment>)

public init(base: SyntaxTreeNode, field: SymbolRef, comments!: Array<Comment> = [])

功能：构造一个 MemberAccess 对象，表示成员访问表达式。

参数：

• base: SyntaxTreeNode - 被访问的对象表达式或类型标注。
• field: SymbolRef - 成员字段引用。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 base 节点不是表达式或类型标注时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 base
    let base = SymbolRef("p", [])

    // 创建 field
    let field = SymbolRef("A", [])

    // 创建 MemberAccess 实例
    let memberAccess = MemberAccess(
        base, 
        field
    )

    println("memberAccess: ${memberAccess}")
}

运行结果：

memberAccess: p.A

func getDotPos()

public func getDotPos(): CodePositionRange

功能：获取当前 MemberAccess 中 . 的位置。

返回值：

• CodePositionRange - 返回 . 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 base
    let base = SymbolRef("p", [])

    // 创建 field
    let field = SymbolRef("A", [])

    // 创建 MemberAccess 实例
    let memberAccess = MemberAccess(base, field)
    let pos = memberAccess.getDotPos()

    // 输出点号位置
    println("memberAccess.getDotPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

memberAccess.getDotPos(): 1:2-1:3

class Modifier

public class Modifier <: SyntaxTreeNode {
    public init(kind: ModifierKind, comments!: Array<Comment> = [])
}

功能：表示某个声明的修饰符，通常放在声明处的最前端。

一个 Modifier 节点：public func foo() 中的 public。

父类型：

• SyntaxTreeNode

prop kind

public prop kind: ModifierKind

功能：获取 Modifier 节点的修饰符种类。

类型：ModifierKind

init(ModifierKind, Array<Comment>)

public init(kind: ModifierKind, comments!: Array<Comment> = [])

功能：构造一个 Modifier 对象，表示语法树中的修饰符节点，如 public、static 等。

参数：

• kind: ModifierKind - 修饰符类型。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 ModifierKind
    let kind = ModifierKind.Public

    // 创建 Modifier 实例
    let modifier = Modifier(
        kind
    )

    println("modifier: ${modifier}")
}

运行结果：

modifier: public

class OptionalExpr

public class OptionalExpr <: Expr {
    public init(base: Expr, comments!: Array<Comment> = [])
}

功能：表示一个带有问号操作符的表达式节点。

一个 OptionalExpr 节点：a?.b, a?(b), a?[b] 中的 a?。

父类型：

• Expr

prop base

public prop base: Expr

功能：获取 OptionalExpr 的表达式节点。

类型：Expr

init(Expr, Array<Comment>)

public init(base: Expr, comments!: Array<Comment> = [])

功能：构造一个 OptionalExpr 对象，表示带问号操作符的表达式节点。

参数：

• base: Expr - 基础表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 SymbolRef 实例
    let symbolRef = SymbolRef("a", [])

    // 创建 OptionalExpr 实例
    let optionalExpr = OptionalExpr(symbolRef)

    println("optionalExpr: ${optionalExpr}")
}

运行结果：

optionalExpr: a?

func getQuestionPos()

public func getQuestionPos(): CodePositionRange

功能：获取 ? 的位置。

返回值：

• CodePositionRange - 返回 ? 的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 SymbolRef 实例
    let symbolRef = SymbolRef("a", [])

    // 创建 OptionalExpr 实例
    let optionalExpr = OptionalExpr(symbolRef)
    
    let pos = optionalExpr.getQuestionPos()
    
    // 输出 ? 位置
    println("optionalExpr.getQuestionPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

optionalExpr.getQuestionPos(): 1:2-1:3

class Package

public class Package <: SyntaxTreeNode {
    public init(isMacroPkg: Bool, name: String, srcFile: Array<SourceFile>)
}

功能：表示包节点。

父类型：

• SyntaxTreeNode

prop isMacroPkg

public prop isMacroPkg: Bool

功能：表示当前包是否为宏包。

类型：Bool

prop name

public prop name: String

功能：表示当前包的包名。

类型：String

prop srcFile

public prop srcFile: Array<SourceFile>

功能：表示当前包的源码文件列表。

类型：Array<SourceFile>

init(Bool, String, Array<SourceFile>)

public init(isMacroPkg: Bool, name: String, srcFile: Array<SourceFile>)

功能：构造一个 Package 对象，表示整个包节点，包含多个源文件。

参数：

• isMacroPkg: Bool - 是否为宏包。
• name: String - 包名。
• srcFile: Array<SourceFile> - 源文件列表。

异常：

• Exception - 当输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    let contents = ImportSingle(["pkg"], "a")

    // 创建 ImportList 实例
    let importList = ImportList(
        contents, 
        None
    )

    let body = Block([ReturnExpr(None)])
    let params = ParameterList([])
    let retTyAnnotation = AtomicType(UnitType)

    // 创建 MainDecl 实例
    let mainDecl = MainDecl(
        body, 
        params, 
        retTyAnnotation
    )

    let name = "sourceFile.cj"
    let path = "/path/to/sourceFile.cj"

    // 创建 SourceFile 实例
    let sourceFile = SourceFile(
        [importList],
        name,
        path,
        None,
        [mainDecl]
    )

    let isMacroPkg = false
    let pkgName = "default"

    // 创建 Package 实例
    let pkg = Package(
        isMacroPkg,
        pkgName,
        [sourceFile]
    )

    println("pkg: ${pkg}")
}

运行结果：

pkg: // sourceFile.cj
import pkg.a
main(): Unit {
    return
}

func toString()

public func toString(): String

功能：将包节点作为字符串打印出来，包内的文件按文件名字母序排序，对每个文件依次打印文件名和文件内容。

返回值：

• String - 返回包节点作为字符串打印的结果。

示例：

import stdx.syntax.*

main() {
    let contents = ImportSingle(["pkg"], "a")

    // 创建 ImportList 实例
    let importList = ImportList(
        contents, 
        None
    )

    let body = Block([ReturnExpr(None)])
    let params = ParameterList([])
    let retTyAnnotation = AtomicType(UnitType)

    // 创建 MainDecl 实例
    let mainDecl = MainDecl(
        body, 
        params, 
        retTyAnnotation
    )

    let name = "sourceFile.cj"
    let path = "/path/to/sourceFile.cj"

    // 创建 SourceFile 实例
    let sourceFile = SourceFile(
        [importList],
        name,
        path,
        None,
        [mainDecl]
    )

    let isMacroPkg = false
    let pkgName = "default"

    // 创建 Package 实例
    let pkg = Package(
        isMacroPkg,
        pkgName,
        [sourceFile]
    )

    println("pkg.toString(): ${pkg.toString()}")
}

运行结果：

pkg.toString(): // sourceFile.cj
import pkg.a
main(): Unit {
    return
}

func toTokens()

public func toTokens(): Tokens

功能：将包节点转换为一组词法单元，包内的文件按文件名字典序排序，在每个文件对应的词法单元之前加上一个注释类型的 Token, 内容为该文件的文件名。

返回值：

• Tokens - 返回包节点转换为一组词法单元的结果。

示例：

import stdx.syntax.*

main() {
    let contents = ImportSingle(["pkg"], "a")

    // 创建 ImportList 实例
    let importList = ImportList(
        contents, 
        None
    )

    let body = Block([ReturnExpr(None)])
    let params = ParameterList([])
    let retTyAnnotation = AtomicType(UnitType)

    // 创建 MainDecl 实例
    let mainDecl = MainDecl(
        body, 
        params, 
        retTyAnnotation
    )

    let name = "sourceFile.cj"
    let path = "/path/to/sourceFile.cj"

    // 创建 SourceFile 实例
    let sourceFile = SourceFile(
        [importList],
        name,
        path,
        None,
        [mainDecl]
    )

    let isMacroPkg = false
    let pkgName = "default"

    // 创建 Package 实例
    let pkg = Package(
        isMacroPkg,
        pkgName,
        [sourceFile]
    )

    println("pkg.toTokens(): ${pkg.toTokens()}")
}

运行结果：

pkg.toTokens(): 
// sourceFile.cj
 import pkg.a
main(): Unit {
    return
}

class PackageHeader

public class PackageHeader <: SyntaxTreeNode {
    public init(accessModifier: Option<Modifier>, isMacroPkg: Bool, packageNameIdentifiers: Array<String>, comments!: Array<Comment> = [])
}

功能：表示包声明节点。

父类型：

• SyntaxTreeNode

prop accessModifier

public prop accessModifier: Option<Modifier>

功能：表示当前包声明的可见性修饰符。

类型：Option<Modifier>

prop isMacroPkg

public prop isMacroPkg: Bool

功能：表示当前包是否为宏包。

类型：Bool

prop packageNameIdentifiers

public prop packageNameIdentifiers: Array<String>

功能：获取 PackageHeader 节点中当前包的包名列表，包含 root 包到当前子包的各级包名。

类型：Array<String>

init(Option<Modifier>, Bool, Array<String>, Array<Comment>)

public init(accessModifier: Option<Modifier>, isMacroPkg: Bool, packageNameIdentifiers: Array<String>, comments!: Array<Comment> = [])

功能：构造一个 PackageHeader 对象，表示包声明头。

参数：

• accessModifier: Option<Modifier> - 访问修饰符，可选。
• isMacroPkg: Bool - 是否为宏包。
• packageNameIdentifiers: Array<String> - 包名标识符列表，如 ["stdx", "syntax"]。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当修饰符不是 public、internal 或 protected，或 packageNameIdentifiers 为空时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 accessModifier
    let accessModifier = Modifier(ModifierKind.Public)

    // 创建 isMacroPkg
    let isMacroPkg = true

    // 创建 packageNameIdentifiers
    let packageNameIdentifiers = ["A"]

    // 创建 PackageHeader 实例
    let packageHeader = PackageHeader(
        accessModifier, 
        isMacroPkg, 
        packageNameIdentifiers
    )

    println("packageHeader: ${packageHeader}")
}

运行结果：

packageHeader: public macro package A

func getDotsPos()

public func getDotsPos(): Array<CodePositionRange>

功能：获取 PackageHeader 节点中 . 的位置。

返回值：

• Array<CodePositionRange> - 返回 . 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PackageHeader 实例
    let packageNameIdentifiers = ["syntax"]
    let packageHeader = PackageHeader(None, false, packageNameIdentifiers)
    let posArr = packageHeader.getDotsPos()

    // 遍历输出点位置
    for (i in 0..posArr.size) {
        println("packageHeader.getDotsPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

func getMacroKeyWordPos()

public func getMacroKeyWordPos(): Option<CodePositionRange>

功能：获取 PackageHeader 节点中 macro 关键字的位置。

返回值：

• Option<CodePositionRange> - 返回 macro 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PackageHeader 实例
    let packageHeader = PackageHeader(None, true, ["A"])

    if (let Some(pos) <- packageHeader.getMacroKeyWordPos()) {
        // 输出 macro 关键字位置
        println("packageHeader.getMacroKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

packageHeader.getMacroKeyWordPos(): 1:1-1:6

func getPackageIdentifiersPos()

public func getPackageIdentifiersPos(): Array<CodePositionRange>

功能：获取 PackageHeader 节点中包标识符的位置。

返回值：

• Array<CodePositionRange> - 返回包标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PackageHeader 实例
    let packageNameIdentifiers = ["std"]
    let packageHeader = PackageHeader(None, false, packageNameIdentifiers)
    let posArr = packageHeader.getPackageIdentifiersPos()

    // 遍历输出包标识符位置
    for (i in 0..posArr.size) {
        println("packageHeader.getPackageIdentifiersPos()[${i}]: ${posArr[i].beginLine}:${posArr[i].beginColumn}-${posArr[i].endLine}:${posArr[i].endColumn}")
    }
}

运行结果：

packageHeader.getPackageIdentifiersPos()[0]: 1:9-1:12

func getPackageKeyWordPos()

public func getPackageKeyWordPos(): CodePositionRange

功能：获取 PackageHeader 节点中 package 关键字的位置。

返回值：

• CodePositionRange - 返回 package 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PackageHeader 实例
    let packageHeader = PackageHeader(None, false, ["A"])
    let pos = packageHeader.getPackageKeyWordPos()

    // 输出 package 关键字位置
    println("packageHeader.getPackageKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

packageHeader.getPackageKeyWordPos(): 1:1-1:8

func getPackageName()

public func getPackageName(): String

功能：获取 PackageHeader 节点中的包名。

返回值：

• String - 返回包名。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PackageHeader 实例
    let packageNameIdentifiers = ["syntax"]
    let packageHeader = PackageHeader(None, false, packageNameIdentifiers)
    let name = packageHeader.getPackageName()

    // 输出包名
    println("packageHeader.getPackageName(): ${name}")
}

运行结果：

packageHeader.getPackageName(): syntax

func getParentPackageName()

public func getParentPackageName(): String

功能：获取 PackageHeader 节点中所有父包的包名。

返回值：

• String - 返回所有父包的包名。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PackageHeader 实例
    let packageNameIdentifiers = ["std", "syntax"]
    let packageHeader = PackageHeader(None, false, packageNameIdentifiers)
    let parentName = packageHeader.getParentPackageName()

    // 输出父包名
    println("packageHeader.getParentPackageName(): ${parentName}")
}

运行结果：

packageHeader.getParentPackageName(): std

class Parameter

sealed abstract class Parameter <: Decl {}

功能：参数节点的父类，继承自 Decl 节点。

父类型：

• Decl

class ParameterList

public class ParameterList <: SyntaxTreeNode {
    public init(parameters: Array<Parameter>, hasParen!: Bool = true, comments!: Array<Comment> = [])
}

功能：参数列表节点。

父类型：

• SyntaxTreeNode

prop params

public prop params: Array<Parameter>

功能：获取全部参数。

类型：Array<Parameter>

init(Array<Parameter>, Bool, Array<Comment>)

public init(parameters: Array<Parameter>, hasParen!: Bool = true, comments!: Array<Comment> = [])

功能：构造一个 ParameterList 对象，表示参数列表。

参数：

• parameters: Array<Parameter> - 参数列表。
• hasParen!: Bool - 是否带有括号，默认为 true。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    let name0 = "x"
    let typeAnnotation0 = AtomicType(Int64Type)
    let name1 = "y"
    let typeAnnotation1 = AtomicType(Int64Type)

    // 创建 LambdaParam 实例
    let lambdaParam0 = LambdaParam(
        name0, 
        typeAnnotation0
    )
    let lambdaParam1 = LambdaParam(
        name1, 
        typeAnnotation1
    )

    // 创建 ParameterList 实例
    let parameterList = ParameterList(
        [lambdaParam0, lambdaParam1],
        hasParen: false
    )

    println("parameterList: ${parameterList}")
}

运行结果：

parameterList: x: Int64, y: Int64

func getParamsCommasPos()

public func getParamsCommasPos(): Array<CodePositionRange>

功能：获取参数间 , 的位置。

返回值：

• Array<CodePositionRange> - 返回参数间 , 的位置。

示例：

import stdx.syntax.*

main() {
    let name0 = "x"
    let typeAnnotation0 = AtomicType(Int64Type)
    let name1 = "y"
    let typeAnnotation1 = AtomicType(Int64Type)

    // 创建 LambdaParam 实例
    let lambdaParam0 = LambdaParam(
        name0, 
        typeAnnotation0
    )
    let lambdaParam1 = LambdaParam(
        name1, 
        typeAnnotation1
    )

    // 创建 ParameterList 实例
    let parameterList = ParameterList(
        [lambdaParam0, lambdaParam1],
        hasParen: false
    )

    let commasPos = parameterList.getParamsCommasPos()
    
    // 输出参数间逗号位置
    for (i in 0..commasPos.size) {
        println("parameterList.getParamsCommasPos()[${i}]: ${commasPos[i].beginLine}:${commasPos[i].beginColumn}-${commasPos[i].endLine}:${commasPos[i].endColumn}")
    }
}

运行结果：

parameterList.getParamsCommasPos()[0]: 1:9-1:10

func getParamsLParenPos()

public func getParamsLParenPos(): Option<CodePositionRange>

功能：获取参数前 ( 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回参数前 ( 的位置。

示例：

import stdx.syntax.*

main() {
    let name0 = "x"
    let typeAnnotation0 = AtomicType(Int64Type)
    let name1 = "y"
    let typeAnnotation1 = AtomicType(Int64Type)

    // 创建 LambdaParam 实例
    let lambdaParam0 = LambdaParam(
        name0, 
        typeAnnotation0
    )
    let lambdaParam1 = LambdaParam(
        name1, 
        typeAnnotation1
    )

    // 创建 ParameterList 实例
    let parameterList = ParameterList(
        [lambdaParam0, lambdaParam1],
        hasParen: true
    )

    if (let Some(pos) <- parameterList.getParamsLParenPos()) {
        // 输出 ( 位置
        println("parameterList.getParamsLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

parameterList.getParamsLParenPos(): 1:1-1:2

func getParamsRParenPos()

public func getParamsRParenPos(): Option<CodePositionRange>

功能：获取参数后 ) 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回参数后 ) 的位置。

示例：

import stdx.syntax.*

main() {
    let name0 = "x"
    let typeAnnotation0 = AtomicType(Int64Type)
    let name1 = "y"
    let typeAnnotation1 = AtomicType(Int64Type)

    // 创建 LambdaParam 实例
    let lambdaParam0 = LambdaParam(
        name0, 
        typeAnnotation0
    )
    let lambdaParam1 = LambdaParam(
        name1, 
        typeAnnotation1
    )

    // 创建 ParameterList 实例
    let parameterList = ParameterList(
        [lambdaParam0, lambdaParam1],
        hasParen: true
    )

    if (let Some(pos) <- parameterList.getParamsRParenPos()) {
        // 输出 ) 位置
        println("parameterList.getParamsRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

parameterList.getParamsRParenPos(): 1:20-1:21

class ParenCondition

public class ParenCondition <: SyntaxTreeNode {
    public init(cond: DisjunctionCondition, comments!: Array<Comment> = [])
}

功能：表示一个括号条件节点，是指使用圆括号括起来的条件。

父类型：

• SyntaxTreeNode

prop cond

public prop cond: DisjunctionCondition

功能：获取 ParenCondition 节点中由圆括号括起来的条件。

类型：DisjunctionCondition

init(DisjunctionCondition, Array<Comment>)

public init(cond: DisjunctionCondition, comments!: Array<Comment> = [])

功能：构造一个 ParenCondition 对象，表示括号包裹的逻辑条件。

参数：

• cond: DisjunctionCondition - 被括号包裹的析取条件。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    let symbolRef0 = SymbolRef("x", [])
    let symbolRef1 = SymbolRef("y", [])
    let symbolRef2 = SymbolRef("a", [])
    let symbolRef3 = SymbolRef("b", [])

    let binaryExpr0 = BinaryExpr(symbolRef0, BinaryOpKind.Equal, symbolRef1)
    let binaryExpr1 = BinaryExpr(symbolRef2, BinaryOpKind.Equal, symbolRef3)

    // 创建 ConjunctionCondition 实例
    let cond0 = ConjunctionCondition(AtomicCondition.Expression(binaryExpr0))
    let cond1 = ConjunctionCondition(AtomicCondition.Expression(binaryExpr1))

    // 创建 DisjunctionCondition 实例
    let disjunctionCondition = DisjunctionCondition(
        [cond0, cond1]
    )

    // 创建 ParenCondition 实例
    let parenCondition = ParenCondition(disjunctionCondition)

    println("parenCondition: ${parenCondition}")
}

运行结果：

parenCondition: (x == y || a == b)

func getLParenPos()

public func getLParenPos(): CodePositionRange

功能：获取 ParenCondition 节点中的 ( 的位置。

返回值：

• CodePositionRange - 返回 ( 的位置。

示例：

import stdx.syntax.*

main() {
    let symbolRef0 = SymbolRef("x", [])
    let symbolRef1 = SymbolRef("y", [])
    let symbolRef2 = SymbolRef("a", [])
    let symbolRef3 = SymbolRef("b", [])

    let binaryExpr0 = BinaryExpr(symbolRef0, BinaryOpKind.Equal, symbolRef1)
    let binaryExpr1 = BinaryExpr(symbolRef2, BinaryOpKind.Equal, symbolRef3)

    // 创建 ConjunctionCondition 实例
    let cond0 = ConjunctionCondition(AtomicCondition.Expression(binaryExpr0))
    let cond1 = ConjunctionCondition(AtomicCondition.Expression(binaryExpr1))

    // 创建 DisjunctionCondition 实例
    let disjunctionCondition = DisjunctionCondition(
        [cond0, cond1]
    )

    // 创建 ParenCondition 实例
    let parenCondition = ParenCondition(disjunctionCondition)
    
    let pos = parenCondition.getLParenPos()
    // 输出 ( 位置
    println("parenCondition.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

parenCondition.getLParenPos(): 1:1-1:2

func getRParenPos()

public func getRParenPos(): CodePositionRange

功能：获取 ParenCondition 节点中的 ) 的位置。

返回值：

• CodePositionRange - 返回 ) 的位置。

示例：

import stdx.syntax.*

main() {
    let symbolRef0 = SymbolRef("x", [])
    let symbolRef1 = SymbolRef("y", [])
    let symbolRef2 = SymbolRef("a", [])
    let symbolRef3 = SymbolRef("b", [])

    let binaryExpr0 = BinaryExpr(symbolRef0, BinaryOpKind.Equal, symbolRef1)
    let binaryExpr1 = BinaryExpr(symbolRef2, BinaryOpKind.Equal, symbolRef3)

    // 创建 ConjunctionCondition 实例
    let cond0 = ConjunctionCondition(AtomicCondition.Expression(binaryExpr0))
    let cond1 = ConjunctionCondition(AtomicCondition.Expression(binaryExpr1))

    // 创建 DisjunctionCondition 实例
    let disjunctionCondition = DisjunctionCondition(
        [cond0, cond1]
    )

    // 创建 ParenCondition 实例
    let parenCondition = ParenCondition(disjunctionCondition)
    
    let pos = parenCondition.getRParenPos()
    // 输出 ) 位置
    println("parenCondition.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

parenCondition.getRParenPos(): 1:18-1:19

class ParenExpr

public class ParenExpr <: Expr {
    public init(subExpr: Expr, comments!: Array<Comment> = [])
}

功能：表示一个括号表达式节点，是指使用圆括号括起来的表达式。

父类型：

• Expr

prop subExpr

public prop subExpr: Expr

功能：获取 ParenExpr 节点中由圆括号括起来的子表达式。

类型：Expr

init(Expr, Array<Comment>)

public init(subExpr: Expr, comments!: Array<Comment> = [])

功能：构造一个 ParenExpr 对象，表示括号表达式，如 (x + 1)。

参数：

• subExpr: Expr - 被括号包裹的子表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    let srcVal = SymbolRef("a", [])
    let targetTypeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 AsExpr 实例
    let asExpr = AsExpr(
        srcVal, 
        targetTypeAnnotation
    )

    // 创建 ParenExpr 实例
    let parenExpr = ParenExpr(asExpr)

    println("parenExpr: ${parenExpr}")
}

运行结果：

parenExpr: (a as Int64)

func getLParenPos()

public func getLParenPos(): CodePositionRange

功能：获取 ( 的位置。

返回值：

• CodePositionRange - 返回 ( 的位置。

示例：

import stdx.syntax.*

main() {
    let srcVal = SymbolRef("a", [])
    let targetTypeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 AsExpr 实例
    let asExpr = AsExpr(
        srcVal, 
        targetTypeAnnotation
    )

    // 创建 ParenExpr 实例
    let parenExpr = ParenExpr(asExpr)
    
    let pos = parenExpr.getLParenPos()
    // 输出 ( 位置
    println("parenExpr.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

parenExpr.getLParenPos(): 1:1-1:2

func getRParenPos()

public func getRParenPos(): CodePositionRange

功能：获取 ) 的位置。

返回值：

• CodePositionRange - 返回 ) 的位置。

示例：

import stdx.syntax.*

main() {
    let srcVal = SymbolRef("a", [])
    let targetTypeAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 AsExpr 实例
    let asExpr = AsExpr(
        srcVal, 
        targetTypeAnnotation
    )

    // 创建 ParenExpr 实例
    let parenExpr = ParenExpr(asExpr)
    
    let pos = parenExpr.getRParenPos()
    // 输出 ) 位置
    println("parenExpr.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

parenExpr.getRParenPos(): 1:12-1:13

class ParenType

public class ParenType <: TypeAnnotation {
    public init(subType: TypeAnnotation, comments!: Array<Comment> = [])
}

功能：表示括号类型节点。

例如 var a: (Int64) 中的 (Int64)。

父类型：

• TypeAnnotation

prop subType

public prop subType: TypeAnnotation

功能：获取 ParenType 节点中括起来的类型，如 (Int64) 中的 Int64。

类型：TypeAnnotation

init(TypeAnnotation, Array<Comment>)

public init(subType: TypeAnnotation, comments!: Array<Comment> = [])

功能：构造一个 ParenType 对象，表示括号包裹的类型，如 (T)。

参数：

• subType: TypeAnnotation - 被括号包裹的子类型。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    
    let subType = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 ParenType 实例
    let parenType = ParenType(subType)

    println("parenType: ${parenType}")
}

运行结果：

parenType: (Int64)

func getLParenPos()

public func getLParenPos(): CodePositionRange

功能：获取 ( 的位置。

返回值：

• CodePositionRange - 返回 ( 的位置。

示例：

import stdx.syntax.*

main() {
    let subType = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 ParenType 实例
    let parenType = ParenType(subType)
    
    let pos = parenType.getLParenPos()
    // 输出 ( 位置
    println("parenType.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

parenType.getLParenPos(): 1:1-1:2

func getRParenPos()

public func getRParenPos(): CodePositionRange

功能：获取 ) 的位置。

返回值：

• CodePositionRange - 返回 ) 的位置。

示例：

import stdx.syntax.*

main() {
    let subType = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 ParenType 实例
    let parenType = ParenType(subType)
    
    let pos = parenType.getRParenPos()
    // 输出 ) 位置
    println("parenType.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

parenType.getRParenPos(): 1:7-1:8

class ParsingResult<T> where T <: SyntaxTreeNode

public class ParsingResult<T> where T <: SyntaxTreeNode {
    public let diags: Array<Diagnostic>
    public let node: Option<T>
}

功能：表示一个符合仓颉语法的抽象语法树。

let diags

public let diags: Array<Diagnostic>

功能：获取当前抽象语法树的全部诊断信息。

类型：Array<Diagnostic>

let node

public let node: Option<T>

功能：获取当前抽象语法树的节点（若不存在返回 None）。

类型：Option<T>，其中 T 为 SyntaxTreeNode 的子类型 T。

class Pattern

sealed abstract class Pattern <: SyntaxTreeNode {}

功能：表示一个模式匹配节点。

父类型：

• SyntaxTreeNode

class PrefixType

public class PrefixType <: TypeAnnotation {
    public init(base: TypeAnnotation, prefixOp: PrefixTypeOpKind, comments!: Array<Comment> = [])
}

功能：表示带前缀操作符的前缀类型节点。

例如 var a : ?A 中的 ?A。

父类型：

• TypeAnnotation

prop base

public prop base: TypeAnnotation

功能：获取 PrefixType 节点中的类型节点，如 var a: ?A 中的 A。

类型：TypeAnnotation

prop prefixTypeOpKind

public prop prefixTypeOpKind: PrefixTypeOpKind

功能：获取 PrefixType 节点中的前缀操作符类型。

类型：PrefixTypeOpKind

init(TypeAnnotation, PrefixTypeOpKind, Array<Comment>)

public init(base: TypeAnnotation, prefixOp: PrefixTypeOpKind, comments!: Array<Comment> = [])

功能：构造一个 PrefixType 对象，表示带前缀的类型，如 ?T。

参数：

• base: TypeAnnotation - 基础类型。
• prefixOp: PrefixTypeOpKind - 前缀操作符类型。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    let base = AtomicType(AtomicTypeKind.Int64Type)
    let prefixOp = PrefixTypeOpKind.Quest

    // 创建 PrefixType 实例
    let prefixType = PrefixType(
        base,
        prefixOp
    )

    println("prefixType: ${prefixType}")
}

运行结果：

prefixType: ?Int64

func getOperatorPos()

public func getOperatorPos(): CodePositionRange

功能：获取前缀操作符的位置。

返回值：

• CodePositionRange - 返回前缀操作符的位置。

示例：

import stdx.syntax.*

main() {
    let base = AtomicType(AtomicTypeKind.Int64Type)
    let prefixOp = PrefixTypeOpKind.Quest

    // 创建 PrefixType 实例
    let prefixType = PrefixType(
        base,
        prefixOp
    )
    
    let pos = prefixType.getOperatorPos()
    // 输出前缀操作符位置
    println("prefixType.getOperatorPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

prefixType.getOperatorPos(): 1:1-1:2

class PropDecl

public class PropDecl <: Decl {
    public init(getter: Option<PropGetterOrSetter>, name: String, setter: Option<PropGetterOrSetter>,
        tyAnnotation: TypeAnnotation, annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [],
        comments!: Array<Comment> = [])
}

功能：表示一个属性声明节点。

一个 PropDecl 节点：prop X: Int64 { get() { 0 } }。

父类型：

• Decl

prop getter

public prop getter: Option<PropGetterOrSetter>

功能：获取当前属性声明的 getter 方法（若不存在返回 None）。

类型：Option<PropGetterOrSetter>

prop isMut

public prop isMut: Bool

功能：判断当前属性声明是否可变。

类型：Bool

prop name

public prop name: String

功能：获取当前属性声明的名称。

类型：String

prop setter

public prop setter: Option<PropGetterOrSetter>

功能：获取当前属性声明的 setter 方法（若不存在返回 None）。

类型：Option<PropGetterOrSetter>

prop tyAnnotation

public prop tyAnnotation: TypeAnnotation

功能：获取当前属性声明的类型标注。

类型：TypeAnnotation

init(Option<PropGetterOrSetter>, String, Option<PropGetterOrSetter>, TypeAnnotation, Array<Annotation>, Array<Modifier>, Array<Comment>)

public init(getter: Option<PropGetterOrSetter>, name: String, setter: Option<PropGetterOrSetter>,
    tyAnnotation: TypeAnnotation, annotations!: Array<Annotation> = [], modifiers!: Array<Modifier> = [],
    comments!: Array<Comment> = [])

功能：构造一个 PropDecl 对象，表示属性声明节点。

参数：

• getter: Option<PropGetterOrSetter> - 可选的 getter。
• name: String - 属性名。
• setter: Option<PropGetterOrSetter> - 可选的 setter。
• tyAnnotation: TypeAnnotation - 类型注解。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• modifiers!: Array<Modifier> - 修饰符列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 setter 存在但 getter 不存在，或输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    // 创建 getter
    let getter = PropGetterOrSetter(Block([]), None, true)

    // 创建 name
    let name = "x"

    // 创建 setter
    let setter = PropGetterOrSetter(Block([]), "v", false)

    // 创建 tyAnnotation
    let tyAnnotation = AtomicType(AtomicTypeKind.Int64Type)

    // 创建 PropDecl 实例
    let propDecl = PropDecl(
        getter, 
        name, 
        setter, 
        tyAnnotation
    )

    println("propDecl: ${propDecl}")
}

运行结果：

propDecl: prop x: Int64 {
    get() {
}
    set(v) {
}
}

func getIdentifierPos()

public func getIdentifierPos(): CodePositionRange

功能：获取 PropDecl 节点中标识符的位置。

返回值：

• CodePositionRange - 返回标识符的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PropDecl 实例
    let getter = PropGetterOrSetter(Block([]), None, true)
    let propDecl = PropDecl(getter, "x", None, AtomicType(AtomicTypeKind.Int64Type))
    let pos = propDecl.getIdentifierPos()

    // 输出标识符位置
    println("propDecl.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

propDecl.getIdentifierPos(): 1:6-1:7

func getLCurlPos()

public func getLCurlPos(): Option<CodePositionRange>

功能：获取 PropDecl 节点中 { 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 { 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PropDecl 实例
    let getter = PropGetterOrSetter(Block([]), None, true)
    let propDecl = PropDecl(getter, "x", None, AtomicType(AtomicTypeKind.Int64Type))

    if (let Some(pos) <- propDecl.getLCurlPos()) {
        // 输出左花括号位置
        println("propDecl.getLCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

propDecl.getLCurlPos(): 1:15-1:16

func getPropKeyWordPos()

public func getPropKeyWordPos(): CodePositionRange

功能：获取 PropDecl 节点中 prop 关键字的位置。

返回值：

• CodePositionRange - 返回 prop 关键字的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PropDecl 实例
    let getter = PropGetterOrSetter(Block([]), None, true)
    let propDecl = PropDecl(getter, "x", None, AtomicType(AtomicTypeKind.Int64Type))
    let pos = propDecl.getPropKeyWordPos()

    // 输出 prop 关键字位置
    println("propDecl.getPropKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

propDecl.getPropKeyWordPos(): 1:1-1:5

func getRCurlPos()

public func getRCurlPos(): Option<CodePositionRange>

功能：获取 PropDecl 节点中 } 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 } 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PropDecl 实例
    let getter = PropGetterOrSetter(Block([]), None, true)
    let propDecl = PropDecl(getter, "x", None, AtomicType(AtomicTypeKind.Int64Type))

    if (let Some(pos) <- propDecl.getRCurlPos()) {
        // 输出右花括号位置
        println("propDecl.getRCurlPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

propDecl.getRCurlPos(): 5:1-5:2

func getTyAnnotationColonPos()

public func getTyAnnotationColonPos(): CodePositionRange

功能：获取 PropDecl 节点中返回类型前的 : 的位置。

返回值：

• CodePositionRange - 返回返回类型前的 : 的位置。

示例：

import stdx.syntax.*

main(): Unit {
    // 创建 PropDecl 实例
    let getter = PropGetterOrSetter(Block([]), None, true)
    let propDecl = PropDecl(getter, "x", None, AtomicType(AtomicTypeKind.Int64Type))
    let pos = propDecl.getTyAnnotationColonPos()

    // 输出冒号位置
    println("propDecl.getTyAnnotationColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

propDecl.getTyAnnotationColonPos(): 1:7-1:8

class PropGetterOrSetter

public class PropGetterOrSetter <: Decl {
    public init(block: Block, identifier: Option<String>, isGetter: Bool, annotations!: Array<Annotation> = [],
        comments!: Array<Comment> = [])
}

功能：表示一个属性的 getter 或 setter 声明。

父类型：

• Decl

prop block

public prop block: Block

功能：获取当前属性 getter 或 setter 方法的主体部分。

类型：Block

prop identifier

public prop identifier: Option<String>

功能：若为 setter 方法，则获取当前方法的输入参数，否则返回 None。

类型：Option<String>

prop isGetter

public prop isGetter: Bool

功能：判断当前属性方法是否为 getter 方法。

类型：Bool

init(Block, Option<String>, Bool, Array<Annotation>, Array<Comment>)

public init(block: Block, identifier: Option<String>, isGetter: Bool, annotations!: Array<Annotation> = [],
    comments!: Array<Comment> = [])

功能：构造一个 PropGetterOrSetter 对象，表示属性 getter 或 setter 节点。

参数：

• block: Block - 代码块。
• identifier: Option<String> - 可选的标识符。
• isGetter: Bool - 是否为 getter。
• annotations!: Array<Annotation> - 附加的注解列表，默认为空数组。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当 isGetter 为 true 但 annotations 不为空或 identifier 不为空，或 isGetter 为 false 但 identifier 为空或不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = SymbolRef("v", [])

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    let nodes: Array<SyntaxTreeNode> = [assignExpr]

    // 创建 Block 实例
    let block = Block(
        nodes
    )

    // 创建 PropGetterOrSetter 实例
    let propSetter = PropGetterOrSetter(
        block,
        Some("v"),
        false
    )

    println("propSetter: ${propSetter}")
}

运行结果：

propSetter: set(v) {
    variable_ = v
}

func getGetKeyWordPos()

public func getGetKeyWordPos(): Option<CodePositionRange>

功能：获取 PropGetterOrSetter 节点中 get 关键字的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 get 关键字的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = SymbolRef("v", [])

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    let nodes: Array<SyntaxTreeNode> = [assignExpr]

    // 创建 Block 实例
    let block = Block(
        nodes
    )

    // 创建 PropGetterOrSetter 实例
    let propGetter = PropGetterOrSetter(
        block,
        None, 
        true
    )

    if (let Some(pos) <- propGetter.getGetKeyWordPos()) {
        // 输出 get 关键字位置
        println("propGetter.getGetKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

propGetter.getGetKeyWordPos(): 1:1-1:4

func getIdentifierPos()

public func getIdentifierPos(): Option<CodePositionRange>

功能：获取 PropGetterOrSetter 节点中标识符的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回标识符的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = SymbolRef("v", [])

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    let nodes: Array<SyntaxTreeNode> = [assignExpr]

    // 创建 Block 实例
    let block = Block(
        nodes
    )

    // 创建 PropGetterOrSetter 实例
    let propSetter = PropGetterOrSetter(
        block,
        Some("v"),
        false
    )

    if (let Some(pos) <- propSetter.getIdentifierPos()) {
        // 输出 setter 中标识符位置
        println("propSetter.getIdentifierPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

propSetter.getIdentifierPos(): 1:5-1:6

func getLParenPos()

public func getLParenPos(): CodePositionRange

功能：获取 PropGetterOrSetter 节点中 ( 的位置。

返回值：

• CodePositionRange - 返回 ( 的位置。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = SymbolRef("v", [])

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    let nodes: Array<SyntaxTreeNode> = [assignExpr]

    // 创建 Block 实例
    let block = Block(
        nodes
    )

    // 创建 PropGetterOrSetter 实例
    let propSetter = PropGetterOrSetter(
        block,
        Some("v"),
        false
    )

    let pos = propSetter.getLParenPos()
    // 输出 ( 位置
    println("propSetter.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

propSetter.getLParenPos(): 1:4-1:5

func getRParenPos()

public func getRParenPos(): CodePositionRange

功能：获取 PropGetterOrSetter 节点中 ) 的位置。

返回值：

• CodePositionRange - 返回 ) 的位置。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = SymbolRef("v", [])

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    let nodes: Array<SyntaxTreeNode> = [assignExpr]

    // 创建 Block 实例
    let block = Block(
        nodes
    )

    // 创建 PropGetterOrSetter 实例
    let propSetter = PropGetterOrSetter(
        block,
        Some("v"),
        false
    )

    let pos = propSetter.getRParenPos()
    // 输出 ) 位置
    println("propSetter.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

propSetter.getRParenPos(): 1:6-1:7

func getSetKeyWordPos()

public func getSetKeyWordPos(): Option<CodePositionRange>

功能：获取 PropGetterOrSetter 节点中 set 关键字的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 set 关键字的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = SymbolRef("v", [])

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    let nodes: Array<SyntaxTreeNode> = [assignExpr]

    // 创建 Block 实例
    let block = Block(
        nodes
    )

    // 创建 PropGetterOrSetter 实例
    let propSetter = PropGetterOrSetter(
        block,
        Some("v"),
        false
    )

    if (let Some(pos) <- propSetter.getSetKeyWordPos()) {
        // 输出 set 关键字位置
        println("propSetter.getSetKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

propSetter.getSetKeyWordPos(): 1:1-1:4

class QuoteExpr

public class QuoteExpr <: Expr {
    public init(tokensOrRefExpr: Array<QuoteExprContent>, comments!: Array<Comment> = [])
}

功能：表示 quote 表达式节点。

一个 QuoteExpr 节点： quote(var ident = 0)。

父类型：

• Expr

prop tokensOrRefExpr

public prop tokensOrRefExpr: Array<QuoteExprContent>

功能：获取 QuoteExpr 中由 () 括起的内部引用表达式或 QuoteToken 节点。

类型：Array<QuoteExprContent>

init(Array<QuoteExprContent>, Array<Comment>)

public init(tokensOrRefExpr: Array<QuoteExprContent>, comments!: Array<Comment> = [])

功能：构造一个 QuoteExpr 对象，表示引用表达式，如 quote( ... )，内部可混合 Tokens 和插值表达式。

参数：

• tokensOrRefExpr: Array<QuoteExprContent> - 引用内容列表。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 QuoteToken 实例
    let quoteToken = QuoteToken(quote(hello world))

    // 创建 QuoteExpr 实例
    let quoteExpr = QuoteExpr(
        QuoteExprContent.TokenPart(quoteToken)
    )

    println("quoteExpr: ${quoteExpr}")
}

运行结果：

quoteExpr: quote(hello world)

func getLParenPos()

public func getLParenPos(): CodePositionRange

功能：获取当前 QuoteExpr 中 ( 的位置。

返回值：

• CodePositionRange - 返回 ( 的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 QuoteToken 实例
    let quoteToken = QuoteToken(quote(hello world))

    // 创建 QuoteExpr 实例
    let quoteExpr = QuoteExpr(
        QuoteExprContent.TokenPart(quoteToken)
    )
    
    let pos = quoteExpr.getLParenPos()
    // 输出 ( 位置
    println("quoteExpr.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

quoteExpr.getLParenPos(): 1:6-1:7

func getQuoteKeyWordPos()

public func getQuoteKeyWordPos(): CodePositionRange

功能：获取当前 QuoteExpr 中 quote 关键字的位置。

返回值：

• CodePositionRange - 返回 quote 关键字的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 QuoteToken 实例
    let quoteToken = QuoteToken(quote(hello world))

    // 创建 QuoteExpr 实例
    let quoteExpr = QuoteExpr(
        QuoteExprContent.TokenPart(quoteToken)
    )
    
    let pos = quoteExpr.getQuoteKeyWordPos()
    // 输出 quote 关键字位置
    println("quoteExpr.getQuoteKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

quoteExpr.getQuoteKeyWordPos(): 1:1-1:6

func getRParenPos()

public func getRParenPos(): CodePositionRange

功能：获取当前 QuoteExpr 中 ) 的位置。

返回值：

• CodePositionRange - 返回 ) 的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 QuoteToken 实例
    let quoteToken = QuoteToken(quote(hello world))

    // 创建 QuoteExpr 实例
    let quoteExpr = QuoteExpr(
        QuoteExprContent.TokenPart(quoteToken)
    )
    
    let pos = quoteExpr.getRParenPos()
    // 输出 ) 位置
    println("quoteExpr.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

quoteExpr.getRParenPos(): 1:18-1:19

class QuoteInterpolationExpr

public class QuoteInterpolationExpr <: Expr {
    public init(expr: Expr, hasParen!: Bool = false, comments!: Array<Comment> = [])
}

功能：表示 QuoteExpr 中由 () 括起的内部引用表达式， 例如 $(A.a) 或 $a。

父类型：

• Expr

prop expr

public prop expr: Expr

功能：获取 QuoteInterpolationExpr 中被引用的表达式。

类型：Expr

init(Expr, Bool, Array<Comment>)

public init(expr: Expr, hasParen!: Bool = false, comments!: Array<Comment> = [])

功能：构造一个 QuoteInterpolationExpr 对象，表示 quote 中的插值表达式。

参数：

• expr: Expr - 被插值的表达式。
• hasParen!: Bool - 是否带有括号，默认为 false。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    let symbolRef = SymbolRef("a", [])

    // 创建 QuoteInterpolationExpr 实例
    let quoteInterpolationExpr = QuoteInterpolationExpr(
        symbolRef,
        hasParen: false
    )

    println("quoteInterpolationExpr: ${quoteInterpolationExpr}")
}

运行结果：

quoteInterpolationExpr: $a

func getDollarPos()

public func getDollarPos(): CodePositionRange

功能：获取当前 QuoteInterpolationExpr 中 $ 的位置。

返回值：

• CodePositionRange - 返回 $ 的位置。

示例：

import stdx.syntax.*

main() {
    let symbolRef = SymbolRef("a", [])

    // 创建 QuoteInterpolationExpr 实例
    let quoteInterpolationExpr = QuoteInterpolationExpr(
        symbolRef,
        hasParen: false
    )
    
    let pos = quoteInterpolationExpr.getDollarPos()
    // 输出 $ 位置
    println("quoteInterpolationExpr.getDollarPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

quoteInterpolationExpr.getDollarPos(): 1:1-1:2

func getLParenPos()

public func getLParenPos(): Option<CodePositionRange>

功能：获取当前 QuoteInterpolationExpr 中 ( 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ( 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    let symbolRef = SymbolRef("a", [])

    // 创建 QuoteInterpolationExpr 实例
    let quoteInterpolationExpr = QuoteInterpolationExpr(
        symbolRef,
        hasParen: true
    )
    
    if (let Some(pos) <- quoteInterpolationExpr.getLParenPos()) {
        // 输出 ( 位置
        println("quoteInterpolationExpr.getLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

quoteInterpolationExpr.getLParenPos(): 1:2-1:3

func getRParenPos()

public func getRParenPos(): Option<CodePositionRange>

功能：获取当前 QuoteInterpolationExpr 中 ) 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 ) 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    let symbolRef = SymbolRef("a", [])

    // 创建 QuoteInterpolationExpr 实例
    let quoteInterpolationExpr = QuoteInterpolationExpr(
        symbolRef,
        hasParen: true
    )
    
    if (let Some(pos) <- quoteInterpolationExpr.getRParenPos()) {
        // 输出 ) 位置
        println("quoteInterpolationExpr.getRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

quoteInterpolationExpr.getRParenPos(): 1:4-1:5

class QuoteToken

public class QuoteToken <: SyntaxTreeNode {
    public init(content: Tokens, comments!: Array<Comment> = [])
}

功能：表示 quote 表达式节点内任意合法的 token。

父类型：

• SyntaxTreeNode

prop content

public prop content: Tokens

功能：获取 QuoteToken 内的 Tokens。

类型：Tokens

init(Tokens, Array<Comment>)

public init(content: Tokens, comments!: Array<Comment> = [])

功能：构造一个 QuoteToken 对象，表示 quote 表达式节点内任意合法的 token。

参数：

• content: Tokens - 被引用的标记序列，会被格式化。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当格式化过程中内存分配失败时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    let tokens = quote(hello world)
    
    // 创建 QuoteToken 实例
    let quoteToken = QuoteToken(tokens)

    println("quoteToken: ${quoteToken}")
}

运行结果：

quoteToken: hello world

class RangeExpr

public class RangeExpr <: Expr {
    public init(start: Option<Expr>, kind: RangeKind, end: Option<Expr>, step: Option<Expr>, comments!: Array<Comment> = [])
}

功能：表示包含区间操作符的表达式。

RangeExpr 节点：存在两种 Range 操作符：.. 和 ..=，分别用于创建左闭右开和左闭右闭的 Range 实例。它们的使用方式分别为 start..end:step 和 start..=end:step。

父类型：

• Expr

prop end

public prop end: Option<Expr>

功能：获取 RangeExpr 中的终止值。

类型：Option<Expr>

prop kind

public prop kind: RangeKind

功能：获取 RangeExpr 的类型。

类型：RangeKind

prop start

public prop start: Option<Expr>

功能：获取 RangeExpr 中的起始值。

类型：Option<Expr>

prop step

public prop step: Option<Expr>

功能：获取 RangeExpr 中的步长表达式。

类型：Option<Expr>

init(Option<Expr>, RangeKind, Option<Expr>, Option<Expr>, Array<Comment>)

public init(start: Option<Expr>, kind: RangeKind, end: Option<Expr>, step: Option<Expr>, comments!: Array<Comment> = [])

功能：构造一个 RangeExpr 对象，表示区间表达式，如 1..10 或 1..=10。

参数：

• start: Option<Expr> - 区间起始表达式。
• kind: RangeKind - 区间类型（开区间或闭区间）。
• end: Option<Expr> - 区间结束表达式。
• step: Option<Expr> - 可选的步长表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    let kind = LitConstKind.IntergerLiteral
    let rawValue0 = "1"
    let rawValue1 = "100"
    let rawValue2 = "2"

    // 创建 LitConstExpr 实例
    let litConstExpr0 = LitConstExpr(
        kind, 
        rawValue0
    )
    let litConstExpr1 = LitConstExpr(
        kind, 
        rawValue1
    )
    let litConstExpr2 = LitConstExpr(
        kind, 
        rawValue2
    )

    let rangeKind = RangeKind.ClosedRangeOp

    // 创建 RangeExpr 实例
    let rangeExpr = RangeExpr(
        litConstExpr0,
        rangeKind,
        litConstExpr1,
        litConstExpr2
    )

    println("rangeExpr: ${rangeExpr}")
}

运行结果：

rangeExpr: 1..=100 : 2

func getColonPos()

public func getColonPos(): Option<CodePositionRange>

功能：获取 : 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回 : 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    let kind = LitConstKind.IntergerLiteral
    let rawValue0 = "1"
    let rawValue1 = "100"
    let rawValue2 = "2"

    // 创建 LitConstExpr 实例
    let litConstExpr0 = LitConstExpr(
        kind, 
        rawValue0
    )
    let litConstExpr1 = LitConstExpr(
        kind, 
        rawValue1
    )
    let litConstExpr2 = LitConstExpr(
        kind, 
        rawValue2
    )

    let rangeKind = RangeKind.ClosedRangeOp

    // 创建 RangeExpr 实例
    let rangeExpr = RangeExpr(
        litConstExpr0,
        rangeKind,
        litConstExpr1,
        litConstExpr2
    )

    if (let Some(pos) <- rangeExpr.getColonPos()) {
        // 输出 : 位置
        println("rangeExpr.getColonPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

rangeExpr.getColonPos(): 1:9-1:10

func getRangeOpPos()

public func getRangeOpPos(): CodePositionRange

功能：获取 .. 或 ..= 的位置。

返回值：

• CodePositionRange - 返回 .. 或 ..= 的位置。

示例：

import stdx.syntax.*

main() {
    let kind = LitConstKind.IntergerLiteral
    let rawValue0 = "1"
    let rawValue1 = "100"
    let rawValue2 = "2"

    // 创建 LitConstExpr 实例
    let litConstExpr0 = LitConstExpr(
        kind, 
        rawValue0
    )
    let litConstExpr1 = LitConstExpr(
        kind, 
        rawValue1
    )
    let litConstExpr2 = LitConstExpr(
        kind, 
        rawValue2
    )

    let rangeKind = RangeKind.ClosedRangeOp

    // 创建 RangeExpr 实例
    let rangeExpr = RangeExpr(
        litConstExpr0,
        rangeKind,
        litConstExpr1,
        litConstExpr2
    )

    let pos = rangeExpr.getRangeOpPos()
    // 输出 .. 位置
    println("rangeExpr.getRangeOpPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

rangeExpr.getRangeOpPos(): 1:2-1:5

class ReturnExpr

public class ReturnExpr <: Expr {
    public init(retVal: Option<Expr>, comments!: Array<Comment> = [])
}

功能：表示 return 表达式节点。

一个 ReturnExpr 节点：return 1。

父类型：

• Expr

prop retVal

public prop retVal: Option<Expr>

功能：获取当前 return 语句的返回值表达式（若不存在返回 None）。

类型：Option<Expr>

init(Option<Expr>, Array<Comment>)

public init(retVal: Option<Expr>, comments!: Array<Comment> = [])

功能：构造一个 ReturnExpr 对象，表示 return 表达式，可带返回值。

参数：

• retVal: Option<Expr> - 可选的返回值表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    let kind = LitConstKind.FloatLiteral
    let rawValue = "3.14"

    // 创建 LitConstExpr 实例
    let litConstExpr = LitConstExpr(
        kind, 
        rawValue
    )

    // 创建 ReturnExpr 实例
    let returnExpr = ReturnExpr(
        Some(litConstExpr)
    )

    println("returnExpr: ${returnExpr}")
}

运行结果：

returnExpr: return 3.14

func getReturnKeyWordPos()

public func getReturnKeyWordPos(): CodePositionRange

功能：获取 return 关键字的位置。

返回值：

• CodePositionRange - 返回 return 关键字的位置。

示例：

import stdx.syntax.*

main() {
    let kind = LitConstKind.FloatLiteral
    let rawValue = "3.14"

    // 创建 LitConstExpr 实例
    let litConstExpr = LitConstExpr(
        kind, 
        rawValue
    )

    // 创建 ReturnExpr 实例
    let returnExpr = ReturnExpr(
        Some(litConstExpr)
    )
    
    let pos = returnExpr.getReturnKeyWordPos()
    // 输出 return 关键字位置
    println("returnExpr.getReturnKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

returnExpr.getReturnKeyWordPos(): 1:1-1:7

class SourceFile

public class SourceFile <: SyntaxTreeNode {
    public init(importLists: Array<ImportList>, name: String, path: String, pkgHeader: Option<PackageHeader>, topLevelDecls: Array<Decl>,
        ftrDirective!: Option<FeaturesDirective> = None, comments!: Array<Comment> = [])
}

功能：表示单个仓颉源码文件的语法树节点。

一个仓颉源码文件节点主要包括包声明节点，包导入节点和 TopLevel 作用域内的所有声明节点。

父类型：

• SyntaxTreeNode

prop ftrDirective

public prop ftrDirective: Option<FeaturesDirective> 

功能：在源码文件节点中找到 FeaturesDirective 节点。

类型： Option<FeaturesDirective>

prop importLists

public prop importLists: Array<ImportList>

功能：获取仓颉源码文件中包导入节点 ImportList 的列表。

类型：Array<ImportList>

prop name

public prop name: String

功能：获取仓颉源码文件的名称。

类型：String

prop path

public prop path: String

功能：获取仓颉源码文件的绝对路径。

类型：String

prop pkgHeader

public prop pkgHeader: Option<PackageHeader>

功能：获取仓颉源码文件中包的声明节点 PackageHeader。

类型：Option<PackageHeader>

prop topLevelDecls

public prop topLevelDecls: Array<Decl>

功能：获取仓颉源码文件中 TopLevel 作用域内声明的声明节点列表。

类型：Array<Decl>

init(Array<ImportList>, String, String, Option<PackageHeader>, Array<Decl>, Option<FeaturesDirective>, Array<Comment>)

public init(importLists: Array<ImportList>, name: String, path: String, pkgHeader: Option<PackageHeader>, topLevelDecls: Array<Decl>,
    ftrDirective!: Option<FeaturesDirective> = None, comments!: Array<Comment> = [])

功能：构造一个 SourceFile 对象，表示语法树中的源文件节点。

参数：

• importLists: Array<ImportList> - 导入列表。
• name: String - 源文件名。
• path: String - 源文件路径。
• pkgHeader: Option<PackageHeader> - 包声明头，可选。
• topLevelDecls: Array<Decl> - 顶层声明列表。
• ftrDirective!: Option<FeaturesDirective> - 特性指令，默认为 None。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

异常：

• Exception - 当输入的 name 不符合仓颉标识符规范时，抛出异常，异常中包含报错提示信息。

示例：

import stdx.syntax.*

main() {
    let contents = ImportSingle(["pkg"], "a")

    // 创建 ImportList 实例
    let importList = ImportList(
        contents, 
        None
    )

    let isMacroPkg = false
    let packageNameIdentifiers = ["A"]

    // 创建 PackageHeader 实例
    let packageHeader = PackageHeader(
        None, 
        isMacroPkg,
        packageNameIdentifiers
    )

    let body = Block([ReturnExpr(None)])
    let params = ParameterList([])
    let retTyAnnotation = AtomicType(UnitType)

    // 创建 MainDecl 实例
    let mainDecl = MainDecl(
        body, 
        params, 
        retTyAnnotation
    )

    let name = "sourceFile.cj"
    let path = "/path/to/sourceFile.cj"

    // 创建 SourceFile 实例
    let sourceFile = SourceFile(
        [importList],
        name,
        path,
        Some(packageHeader),
        [mainDecl]
    )

    println("sourceFile: ${sourceFile}")
}

运行结果：

sourceFile: package A
import pkg.a
main(): Unit {
    return
}

class SpawnExpr

public class SpawnExpr <: Expr {
    public init(threadContext: Option<Expr>, trailingLambdaExpr: Lambda, comments!: Array<Comment> = [])
}

功能：表示 Spawn 表达式。

一个 SpawnExpr 节点由 spawn 关键字和一个不包含形参的闭包组成，例如：spawn { add(1, 2) }。

父类型：

• Expr

prop threadContext

public prop threadContext: Option<Expr>

功能：获取当前 Spawn 语句的线程执行上下文（若不存在返回 None）。

类型：Option<Expr>

prop trailingLambdaExpr

public prop trailingLambdaExpr: Lambda

功能：获取当前 Spawn 语句的线程执行代码块。

类型：Lambda

init(Option<Expr>, Lambda, Array<Comment>)

public init(threadContext: Option<Expr>, trailingLambdaExpr: Lambda, comments!: Array<Comment> = [])

功能：构造一个 SpawnExpr 对象，表示 spawn 表达式，用于创建线程。

参数：

• threadContext: Option<Expr> - 可选的线程上下文表达式。
• trailingLambdaExpr: Lambda - 线程体 lambda 表达式。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    // 创建 LitConstExpr 实例
    let litConstExpr = LitConstExpr(
        LitConstKind.FloatLiteral, 
        "3.14"
    )

    // 创建 Lambda 实例
    let lambda = Lambda(
        [litConstExpr],
        ParameterList([], hasParen: false)
    )

    let symbolRef = SymbolRef("context", [])

    // 创建 SpawnExpr 实例
    let spawnExpr = SpawnExpr(
        Some(symbolRef),
        lambda
    )

    println("spawnExpr: ${spawnExpr}")
}

运行结果：

spawnExpr: spawn (context) {  => 3.14 }

func getSpawnKeyWordPos()

public func getSpawnKeyWordPos(): CodePositionRange

功能：获取 SpawnExpr 节点中 spawn 关键字的位置。

返回值：

• CodePositionRange - 返回 spawn 关键字的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 LitConstExpr 实例
    let litConstExpr = LitConstExpr(
        LitConstKind.FloatLiteral, 
        "3.14"
    )

    // 创建 Lambda 实例
    let lambda = Lambda(
        [litConstExpr],
        ParameterList([], hasParen: false)
    )

    let symbolRef = SymbolRef("context", [])

    // 创建 SpawnExpr 实例
    let spawnExpr = SpawnExpr(
        Some(symbolRef),
        lambda
    )
    
    let pos = spawnExpr.getSpawnKeyWordPos()
    // 输出 spawn 关键字位置
    println("spawnExpr.getSpawnKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

spawnExpr.getSpawnKeyWordPos(): 1:1-1:6

func getThreadContextLParenPos()

public func getThreadContextLParenPos(): Option<CodePositionRange>

功能：获取 SpawnExpr 节点中线程上下文的 ( 的位置。

返回值：

• Option<CodePositionRange> - 返回 return 关键字的位置。

示例：

import stdx.syntax.*

main() {
    // 创建 LitConstExpr 实例
    let litConstExpr = LitConstExpr(
        LitConstKind.FloatLiteral, 
        "3.14"
    )

    // 创建 Lambda 实例
    let lambda = Lambda(
        [litConstExpr],
        ParameterList([], hasParen: false)
    )

    let symbolRef = SymbolRef("context", [])

    // 创建 SpawnExpr 实例
    let spawnExpr = SpawnExpr(
        Some(symbolRef),
        lambda
    )
    
    if (let Some(pos) <- spawnExpr.getThreadContextLParenPos()) {
        // 输出线程上下文参数 ( 位置
        println("spawnExpr.getThreadContextLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

spawnExpr.getThreadContextLParenPos(): 1:7-1:8

func getThreadContextRParenPos()

public func getThreadContextRParenPos(): Option<CodePositionRange>

功能：获取 SpawnExpr 节点中线程上下文的 ) 的位置（若不存在返回 None）。

返回值：

• Option<CodePositionRange> - 返回线程上下文的 ) 的位置（若不存在返回 None）。

示例：

import stdx.syntax.*

main() {
    // 创建 LitConstExpr 实例
    let litConstExpr = LitConstExpr(
        LitConstKind.FloatLiteral, 
        "3.14"
    )

    // 创建 Lambda 实例
    let lambda = Lambda(
        [litConstExpr],
        ParameterList([], hasParen: false)
    )

    let symbolRef = SymbolRef("context", [])

    // 创建 SpawnExpr 实例
    let spawnExpr = SpawnExpr(
        Some(symbolRef),
        lambda
    )
    
    if (let Some(pos) <- spawnExpr.getThreadContextRParenPos()) {
        // 输出线程上下文参数 ) 位置
        println("spawnExpr.getThreadContextRParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
    }
}

运行结果：

spawnExpr.getThreadContextRParenPos(): 1:15-1:16

class StaticInit

public class StaticInit <: Decl {
    public init(body: Block, comments!: Array<Comment> = [])
}

功能：表示一个静态初始化器。

父类型：

• Decl

prop body

public prop body: Block

功能：获取当前静态初始化器的主体部分。

类型：Block

init(Block, Array<Comment>)

public init(body: Block, comments!: Array<Comment> = [])

功能：构造一个 StaticInit 对象，表示静态初始化器节点。

参数：

• body: Block - 静态初始化代码块。
• comments!: Array<Comment> - 附加的注释列表，默认为空数组。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = LitConstExpr(LitConstKind.FloatLiteral, "3.14")

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    // 创建 Block 实例
    let block = Block([assignExpr])

    // 创建 StaticInit 实例
    let staticInit = StaticInit(block)

    println("staticInit: ${staticInit}")
}

运行结果：

staticInit: static init() {
    variable_ = 3.14
}

func getInitKeyWordPos()

public func getInitKeyWordPos(): CodePositionRange

功能：获取 StaticInit 节点中 init 关键字的位置。

返回值：

• CodePositionRange - 返回 init 关键字的位置。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = LitConstExpr(LitConstKind.FloatLiteral, "3.14")

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    // 创建 Block 实例
    let block = Block([assignExpr])

    // 创建 StaticInit 实例
    let staticInit = StaticInit(block)
    
    let pos = staticInit.getInitKeyWordPos()
    // 输出 init 关键字位置
    println("staticInit.getInitKeyWordPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

staticInit.getInitKeyWordPos(): 1:8-1:12

func getParamsLParenPos()

public func getParamsLParenPos(): CodePositionRange

功能：获取 StaticInit 节点中参数左括号的位置。

返回值：

• CodePositionRange - 返回参数左括号的位置。

示例：

import stdx.syntax.*

main() {
    let assignOpKind = AssignOpKind.Assign
    let lhs = SymbolRef("variable_", [])
    let rhs = LitConstExpr(LitConstKind.FloatLiteral, "3.14")

    // 创建 AssignExpr 实例
    let assignExpr = AssignExpr(
        assignOpKind, 
        lhs, 
        rhs
    )

    // 创建 Block 实例
    let block = Block([assignExpr])

    // 创建 StaticInit 实例
    let staticInit = StaticInit(block)
    
    let pos = staticInit.getParamsLParenPos()
    // 输出 ( 位置
    println("staticInit.getParamsLParenPos(): ${pos.beginLine}:${pos.beginColumn}-${pos.endLine}:${pos.endColumn}")
}

运行结果：

staticInit.getParamsLParenPos(): 1:12-1:13

func getParamsRParenPos()

public func getParamsRParenPos(): CodePositionRange

功能：获取 StaticInit 节点中参数右括号的位置。

返回值：

• CodePositionRange - 返回参数右括号的位置。