ast 包

基本类型

struct Position

public struct Position {
    public init()
    public init(fileID: UInt32, line: Int32, column: Int32)
    public let fileID: UInt32
    public let line: Int32
    public let column: Int32
    public func isEmpty(): Bool
    public func dump(): Unit
    public operator func ==(pos: Position): Bool
    public operator func !=(pos: Position): Bool
}

Position 类型是一个表示位置信息的数据结构。用于表示某个语法树节点的文件 ID，行列号等位置信息。

init

public init(fileID: UInt32, line: Int32, column: Int32)

功能：构造 Position 实例。

参数：

fileID：文件ID
line：行号
column：列号

operator func ==

public operator func == (pos: Position): Bool

功能：重载等号操作符，用于比较两个实例是否相等。

参数：

pos：与当前位置比较的另一个位置实例。

返回值：布尔类型。

operator func !=

public operator func != (pos: Position): Bool

功能：重载不等号操作符，用于比较两个实例是否相等。

参数：

pos：与当前位置比较的另一个位置实例。

返回值：布尔类型。

class Node

sealed abstract class Node <: ToTokens {
    public mut prop beginPos: Position
    public mut prop endPos: Position
    public func toTokens(): Tokens
    public func traverse(v: Visitor): Unit
    public func dump(): Unit
}

Node 是所有仓颉语法树节点的父类，该类提供了所有数据类型通用的操作接口。

func toTokens

public func toTokens(): Tokens

功能：将节点转化为 Tokens 类型，实现语法树树节点与 Tokens 类型之间的转化。

func traverse

public func traverse(v: Visitor): Unit

功能：遍历当前语法树节点及其子节点。若提前终止遍历子节点的行为，可重写 visit 函数并调用 breakTraverse 函数提前终止遍历行为，详细见[visit] 章节。

参数：

v：Visitor 类型的实例

func dump

public func dump(): Unit

功能：将当前语法树节点转为为树形结构的形态并进行打印。

具体使用方式和运行结果如下所示：

from std import ast.*
main() {
    let input = quote(var demo: Int64 = 1) // 假设当前代码所在行数为：3
    let varDecl = parseDecl(input)
    varDecl.dump()
}

运行结果如下：

VarDecl {
  -keyword: Token {
    value: "var"
    kind: VAR
    pos: 3: 23
  }
  -identifier: Token {
    value: "demo"
    kind: IDENTIFIER
    pos: 3: 27
  }
  -declType: PrimitiveType {
    -keyword: Token {
      value: "Int64"
      kind: INT64
      pos: 3: 33
    }
  }
  -assign: Token {
    value: "="
    kind: ASSIGN
    pos: 3: 39
  }
  -expr: LitConstExpr {
    -literal: Token {
      value: "1"
      kind: INTEGER_LITERAL
      pos: 3: 41
    }
  }
}

说明：

- 字符串：表示当前节点的公共属性，如 -keyword , -identifier；
节点属性后紧跟该节点的具体类型，如 -declType: PrimitiveType 表示节点类型是一个 PrimitiveType 节点；
每个类型使用大括号表示类型的作用区间；

class Program

public class Program <: Node {
    public init()
    public init(input: Tokens)
    public mut prop packageHeader: PackageHeader
    public mut prop importLists: ArrayList<ImportList>
    public mut prop decls: ArrayList<Decl>
}

Program 类型表示一个仓颉源码文件节点。一个仓颉源码文件节点主要包括包定义节点，包导入节点和 TopLevel 作用域内的所有声明节点。

说明：任何一个仓颉源码文件都可以被解析为一个 Program 类型。

init

public init(input: Tokens)

功能：构造 Program 实例。

参数：

input：将要构造 Program 类型的词法单元集合 (Tokens) 序列。

异常：

ASTException：输入的 Tokens 类型无法构造为一个文件节点。

prop packageHeader

public mut prop packageHeader: PackageHeader

功能：获取或设置仓颉源码文件中包的声明节点 PackageHeader。

返回值：一个 PackageHeader 类型的节点。

prop importLists

public mut prop importLists: ArrayList<ImportList>

功能：获取或设置仓颉源码文件中包导入节点 ImportList。

返回值：当前源码文件中包导入节点的列表。

prop decls

public mut prop decls: ArrayList<Decl>

功能：获取或设置仓颉源码文件中 toplevel 作用域内定义的节点。

返回值：当前源码文件中 toplevel 作用域内定义的声明节点列表。

class PackageHeader

public class PackageHeader <: Node {
    public init()
    public init(input: Tokens)
    public mut prop keywordM: Token
    public mut prop keywordP: Token
    public mut prop packageIdentifier: Token
}

PackageHeader 类型用来表示包声明节点。

说明：包声明以关键字 package 或 macro package 开头，后面紧跟包名，且包声明必须在源文件的首行。

一个 PackageHeader 节点: package define 或者 macro package define

init

public init(input: Tokens)

功能：构造 PackageHeader 实例。

参数：

input：将要构造 PackageHeader 类型的词法单元集合 (Tokens) 序列。

异常：

ASTException：输入的 Tokens 类型无法构造为目标节点。

prop keywordM

public mut prop keywordM: Token

功能：获取或设置 PackageHeader 节点中的 macro 关键字的词法单元（M 为关键字首字母，下同）。

返回值：macro 关键字的词法单元类型，可能为空的词法单元。

prop keywordP

public mut prop keywordP: Token

功能：获取或设置 PackageHeader 节点中的 package 关键字的词法单元。

返回值：package 关键字的词法单元类型。

prop packageIdentifier

public mut prop packageIdentifier: Token

功能：获取或设置 PackageHeader 节点中的紧跟在 package 后包的名字。

返回值：包名的词法单元类型。

class ImportList

public class ImportList <: Node {
    public init()
    public init(input: Tokens)
    public mut prop keywordF: Token
    public mut prop moduleIdentifier: Token
    public mut prop keywordI: Token
    public mut prop importAll: Tokens
    public mut prop importSpecified: Tokens
    public mut prop importAlias: Tokens
}

ImportList 类型用来表示包导入节点。

说明：导入节点以关键字 from 或 import 开头。以 import pkga.pkgb.item 为例，pkga.pkgb 为导入的顶级定义或声明所在的包的名字，item 为导入的顶级定义或声明。

一个 ImportList 节点: from module import package.foo as bar

init

public init(input: Tokens)

功能：构造 ImportList 实例。

参数：

input：将要构造 ImportList 类型的词法单元集合 (Tokens) 序列。

异常：

ASTException：输入的 Tokens 类型无法构造为目标节点。

prop keywordF

public mut prop keywordF: Token

功能：获取或设置 ImportList 节点中的 from 关键字的词法单元, F 为关键字首字母。

返回值：from 关键字的词法单元类型，可能为空的词法单元。

prop moduleIdentifier

public mut prop moduleIdentifier: Token

功能：获取或设置 ImportList 节点中的导入模块名的词法单元。

返回值：模块名的词法单元类型，可能为空的词法单元。

prop keywordI

public mut prop keywordI: Token

功能：获取或设置 ImportList 节点中的 import 关键字的词法单元, I 为关键字首字母。

返回值：import 关键字的词法单元类型。

prop packageIdentifier

public mut prop packageIdentifier: Token

功能：获取或设置 ImportList 节点中导入的顶级定义或声明所在的包的名字。

返回值：通配符导入形式词法单元序列。如：import packageName.* 中的 packageName。

prop dot

public mut prop dot: Token

功能：获取或设置 ImportList 节点中的 . 操作符。

返回值：. 操作符词法单元。

prop importedItem

public mut prop importedItem: Token

功能：获取或设置 ImportList 节点中导入的顶级定义或声明的词法单元。

返回值：导入的顶级定义或声明的词法单元。

prop importAlias

public mut prop importAlias: Tokens

功能：获取或设置 ImportList 节点导入的定义或声明的别名。

返回值：导入定义或声明的别名词法单元序列。如：import packageName.xxx as yyy 中的 as yyy。

class Annotation

public class Annotation <: Node {
    public init()
    public init(input: Tokens)
    public mut prop at: Token
    public mut prop identifier: Token
    public mut prop arguments: ArrayList<Argument>
    public mut prop stageValue: UInt16
    public mut prop configKind: Token
    public mut prop configParam: ArrayList<RefExpr>
    public mut prop adjointExpr: RefExpr
    public mut prop attributes: Tokens
    public mut prop condition: Expr
}

说明：Annotation 表示编译器内置的注解节点。

一个 Annotation 节点：@CallingConv[xxx], @Attribute[xxx], @Differentiable[except: [xx]], @When[condition]等

init

public init(input: Token)

功能：构造 Annotation 实例。

参数：

input：将要构造 Annotation 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为目标节点。

prop at

public mut prop at: Token

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

返回值：Annotation 节点中的 @ 的词法单元类型。

prop identifier

public mut prop identifier: Token

功能：获取或设置 Annotation 节点的标识符。

返回值：Annotation 节点中的标识符，如 @CallingConv 中的 CallingConv。

prop arguments

public mut prop arguments: ArrayList<Argument>

功能：获取或设置 Annotation 中的参数。

返回值：Annotation 节点中的参数序列，如 @CallingConv[xxx] 中的 xxx。

prop stageValue

public mut prop stageValue: UInt16

功能：获取或设置 AD Annotation 的阶值，仅用于自动微分注解。

返回值：AD Annotation 的阶值，如 @Differentiable [stage: 2] 中的 2。

prop configKind

public mut prop configKind: Token

功能：获取或设置 AD Annotation 的配置项，仅用于自动微分注解。

返回值：AD Annotation 的配置项的词法单元，如 @Differentiable[except: [xx]] 中的 except。

prop configParam

public mut prop configParam: ArrayList<RefExpr>

功能：获取或设置 AD Annotation 配置项的成员，仅用于自动微分注解。

返回值：AD Annotation 的配置列表，如 @Differentiable[except: [xx]] 中的 xx。

prop adjointExpr

public mut prop adjointExpr: RefExpr

功能：获取或设置 AD Annotation 中的自定义伴随函数，仅用于自动微分的自定义伴随函数注解。

返回值：AD Annotation 的自定义伴随函数，如 @adjoint [primal: f] 中的 f。

prop attributes

public mut prop attributes: Tokens

功能：获取或设置 Attribute 中设置的属性值，仅用于 @Attribute。

返回值：Attribute 设置的属性值的词法单元，如 @Attribute[xxx] 中的 xxx。

prop condition

public mut prop condition: Expr

功能：获取或设置条件编译中的条件表达式，用于 @When。

返回值：@When 的条件表达式，如 @When[xxx] 中的 xxx。

class Modifier

public class Modifier <: Node {
    public init()
    public init(keyword: Token)
    public mut prop keyword: Token
}

说明：Modifier 通常放在定义处的最前端，用来表示该定义具备某些特性。

一个 Modifier 节点：public func foo() 中的 public

init

public init(keyword: Token)

功能：构造 Modifier 实例。

参数：

keyword：将要构造 Modifier 类型的词法单元。

prop keyword

public mut prop keyword: Token

功能：获取或设置 Modifier 节点中的修饰符。

返回值：Modifier 节点中的修饰符词法单元类型。

class GenericParam

public class GenericParam <: Node {
    public init()
    public init(input: Tokens)
    public mut prop lAngle: Token
    public mut prop parameters: Tokens
    public mut prop rAngle: Token
}

说明：GenericParam 表示一个类型形参节点，类型形参用 <> 括起并用 , 分隔多个类型形参名称。

一个 GenericParam 节点：<T1, T2, T3>

init

public init(input: Tokens)

功能：构造 GenericParam 实例。

参数：

input：将要构造 GenericParam 的类型形参的词法单元集合 (Tokens)。

prop lAngle

public mut prop lAngle: Token

功能：获取或设置 GenericParam 节点中的左尖括号。

返回值：左尖括号词法单元。

prop parameters

public mut prop parameters: Tokens

功能：获取或设置 GenericParam 节点中的类型形参。

返回值：类型形参的 Tokens 类型，可能为空，如 <T1, T2, T3> 中的 T1 T2 和 T3。

prop rAngle

public mut prop rAngle: Token

功能：获取或设置 GenericParam 节点中的右尖括号。

返回值：右尖括号词法单元。

class GenericConstraint

public class GenericConstraint <: Node {
    public init()
    public mut prop keyword: Token
    public mut prop typeArgument: TypeNode
    public mut prop upperBound: Token
    public mut prop upperBounds: ArrayList<TypeNode> 
}

说明：GenericConstraint 表示一个泛型约束节点，通过 where 之后的 <: 运算符来声明，由一个下界与一个上界来组成。其中 <: 左边称为约束的下界，下界只能为类型变元。<: 右边称为约束上界，约束上界可以为类型。

一个 GenericConstraint 节点：interface Enumerable<U> where U <: Bounded {} 中的 where where U <: Bounded。

prop keyword

public mut prop keyword: Token

功能：获取或设置 GenericConstraint 节点中关键字 where。

返回值：关键字 where 词法单元, 可能为空。

prop typeArgument

public mut prop typeArgument: Token

功能：获取或设置 GenericConstraint 节点中的约束下界。

返回值：类型变元的 Token。

prop upperBound

public mut prop upperBound: Token

功能：获取或设置 GenericConstraint 节点中的 <: 运算符。

返回值：<: 词法单元。

prop upperBounds

public mut prop upperBounds: ArrayList<RefType>

功能：获取或设置 GenericConstraint 节点中的约束上界。

返回值：一组 RefType 类型节点的集合。

class MatchCase

public class MatchCase <: Node {
    public init()
    public mut prop keywordC: Token
    public mut prop expr: Expr
    public mut prop patterns: ArrayList<Pattern>
    public mut prop keywordW: Token
    public mut prop patternGuard: Expr
    public mut prop arrow: Token
    public mut prop block: Block
}

说明：MatchCase 表示一个 MatchCase 类型。MatchCase 以关键字 case 开头，后跟 Expr 或者一个或多个由 | 分隔的相同种类的 pattern，一个可选的 patternguard，一个 => 和一系列声明或表达式。该节点与 MatchExpr 存在强绑定关系。

一个 MatchCase 节点：case failScore where score > 0 => 0

prop keywordC

public mut prop keywordC: Token

功能：获取或设置 MatchCase 内的 case 关键字。

返回值：case 关键字的词法单元。

prop expr

public mut prop expr: Expr

功能：获取或设置 MatchCase 中位于 case 后的表达式节点。

返回值：一个表达式节点。

异常：

ASTException：当前 MatchCase 节点中不存在表达式节点。

prop patterns

public mut prop patterns: ArrayList<Pattern>

功能：获取或设置 MatchCase 中位于 case 后的 pattern 列表。

返回值：一组 pattern 节点的结合。

prop keywordW

public mut prop keywordW: Token

功能：获取或设置 MatchCase 中可选的关键字 where。

返回值：关键字 where 的词法单元，可能为空。

prop patternGuard

public mut prop patternGuard: Expr

功能：获取或设置 MatchCase 中可选的 pattern guard 表达式。

返回值：一个表达式节点。

异常：

ASTException：当前 MatchCase 节点中不存在 pattern guard 表达式。

prop arrow

public mut prop arrow: Token

功能：获取或设置 MatchCase 中的 => 操作符。

返回值：=> 的词法单元。

prop block

public mut prop block: Block

功能：获取或设置 MatchCase 中的一系列声明或表达式节点。

返回值：一个块节点。

class Constructor

public class Constructor <: Node {
    public init()
    public mut prop identifier: Token
    public mut prop lParen: Token
    public mut prop typeArguments: ArrayList<TypeNode>
    public mut prop rParen: Token
}

说明：Constructor 表示 enum 类型中的 Constructor 节点。每个 Constructor 可以没有参数，也可以有一组不同类型的参数。

一个 Constructor 节点：enum TimeUnit { Year | Month(Float32, Float32)} 中的 Year 和 Month(Float32, Float32)。

prop lParen

public mut prop lParen: Token

功能：获取或设置 Constructor 节点中的左括号。

返回值：左括号词法单元。

prop typeArguments

public mut prop typeArguments: ArrayList<TypeNode>

功能：获取或设置 Constructor 节点可选的参数类型。

返回值：一组类型节点的集合。

prop rParen

public mut prop rParen: Token

功能：获取或设置 Constructor 节点中的右括号。

返回值：右括号词法单元。

class Argument

public class Argument <: Node {
    public init()
    public mut prop keyword: Token
    public mut prop identifier: Token
    public mut prop colon: Token
    public mut prop expr: Expr
}

说明：Argument 表示函数调用的实参节点，例如 foo(arg:value) 中的 arg:value。

prop keyword

public mut prop keyword: Token

功能：获取或设置 Argument 节点中的关键字 inout。

返回值：inout 词法单元，可能为空。

prop identifier

public mut prop identifier: Token

功能：获取或设置 Argument 节点中的标识符。

返回值：标识符词法单元，如 arg:value 中的 arg，可能为空。

prop identifier

public mut prop identifier: Token

功能：获取或设置 Argument 节点中的操作符 :。

返回值：: 词法单元，可能为空。

prop expr

public mut prop expr: Expr

功能：获取或设置 Argument 节点中的表达式。

返回值：表达式节点，如 arg:value 中的 value。

class Decl

public open class Decl <: Node {
    public mut prop annotations: ArrayList<Annotation>
    public mut prop modifiers: ArrayList<Modifier>
    public mut prop keyword: Token
    public open mut prop identifier: Token
    public mut prop genericParam: GenericParam
    public mut prop genericConstraint: ArrayList<GenericConstraint>
    public func hasAttr(attr: String): Bool
    public func getAttrs(): Tokens
}

Decl 是所有声明节点的父类，继承自 Node 节点，提供了所有声明节点的通用接口。

类定义、接口定义、函数定义、变量定义、枚举定义、结构体定义、扩展定义、类型别名定义、宏定义等都属于 Decl 节点。

prop annotations

public mut prop annotations: ArrayList<Annotation>

功能：获取或设置作用于 Decl 节点的注解列表。

返回值：一组 Annotation 节点列表，可能为空。

prop modifiers

public mut prop modifiers: ArrayList<Modifier>

功能：获取或设置修饰节点的修饰符列表。

返回值：一组 Modifier 节点列表，可能为空，如 open public func foo() {} 中的 open 和 public。

prop keyword

public mut prop keyword: Token

功能：获取或设置定义节点的关键字。

返回值：一个关键字词法单元，如 func foo() {} 中的 func。

prop identifier

public open mut prop identifier: Token

功能：获取或设置定义节点的标识符。

返回值：一个标识符词法单元，如 class foo {} 中的 foo。

prop genericParam

public mut prop genericParam: GenericParam

功能：获取或设置形参列表，类型形参列表由 <> 括起，多个类型形参之间用逗号分隔。

返回值：一个类型形参节点，如 func foo<T1, T2, T3>() {} 中的 <T1, T2, T3>。

异常：

ASTException：当前节点未定义类型形参列表。

prop genericConstraint

public mut prop genericConstraint: ArrayList<GenericConstraint>

功能：获取或设置定义节点的泛型约束。

返回值：一个组泛型约束节点，可能为空，如 func foo<T>() where T <: Comparable<T> {} 中的 where T <: Comparable<T>。

func getAttrs

public func getAttrs(): Tokens

功能：获取当前节点的属性（一般通过内置的 Attribute 来设置某个声明设置属性值）。

func hasAttr

public func hasAttr(attr: String): Bool

功能：判断当前节点是否具有某个属性（一般通过内置的 Attribute 来设置某个声明设置属性值）。

class ClassDecl

public class ClassDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop upperBound: Token
    public mut prop superTypes: ArrayList<TypeNode>
    public mut prop body: Body
}

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

init

public init(input: Tokens)

功能：构造 ClassDecl 实例。

参数：

input：将要构造 ClassDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ClassDecl 节点。

prop superTypes

public mut prop superTypes: ArrayList<TypeNode>

功能：获取或设置 ClassDecl 节点的父类或者父接口。

返回值：ClassDecl 节点的父类或者父接口类型的列表，如：class B <: A {} 中的 A。

prop body

public mut prop body: Body

功能：获取或设置 ClassDecl 节点的类体。

返回值：ClassDecl 节点的 Body 节点（大括号及大括号内的节点）。

class StructDecl

public class StructDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop upperBound: Token
    public mut prop superTypes: ArrayList<TypeNode>
    public mut prop body: Body
}

StructDecl 表示一个 Struct 节点。Struct 的定义使用 struct 关键字，定义依次为：可缺省的修饰符、struct 关键字、struct 名、可选的类型参数、是否指定父接口、可选的泛型约束、struct 体的定义。

init

public init(input: Tokens)

功能：构造 StructDecl 实例。

参数：

input：将要构造 StructDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 StructDecl 节点。

prop superTypes

public mut prop superTypes: ArrayList<TypeNode>

功能：获取或设置 StructDecl 节点的父接口。

返回值：StructDecl 节点的父接口类型的列表，如：struct B <: A {} 中的 A。

prop body

public mut prop body: Body

功能：获取或设置 StructDecl 节点的类体。

返回值：StructDecl 节点的 Body 节点（大括号及大括号内的节点）。

class InterfaceDecl

public class InterfaceDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop upperBound: Token
    public mut prop superTypes: ArrayList<TypeNode>
    public mut prop body: Body
}

InterfaceDecl 表示接口定义节点。接口的定义使用 interface 关键字，接口定义依次为：可缺省的修饰符、interface 关键字、接口名、可选的类型参数、是否指定父接口、可选的泛型约束、接口体的定义。

init

public init(input: Tokens)

功能：构造 InterfaceDecl 实例。

参数：

input：将要构造 InterfaceDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 InterfaceDecl 节点。

prop superTypes

public mut prop superTypes: ArrayList<TypeNode>

功能：获取或设置 InterfaceDecl 节点的父接口。

返回值：InterfaceDecl 节点的父接口类型的列表，如：interface B <: A {} 中的 A。

prop body

public mut prop body: Body

功能：获取或设置 InterfaceDecl 节点的类体。

返回值：InterfaceDecl 节点的 Body 节点（大括号及大括号内的节点）。

class ExtendDecl

public class ExtendDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop extendType: TypeNode
    public mut prop upperBound: Token
    public mut prop superTypes: ArrayList<TypeNode>
    public mut prop body: Body
    public override mut prop identifier: Token
}

ExtendDecl 表示一个扩展定义节点。扩展的定义使用 extend 关键字，扩展定义依次为：extend 关键字、扩展类型、是否指定父接口、可选的泛型约束、扩展体的定义。

init

public init(input: Tokens)

功能：构造 ExtendDecl 实例。

参数：

input：将要构造 ExtendDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ExtendDecl 节点。

prop extendType

public mut prop extendType: TypeNode

功能：获取或设置被扩展的类型。

返回值：一个类型节点，如：extend B <: A{} 中的 B。

prop superTypes

public mut prop superTypes: ArrayList<TypeNode>

功能：获取或设置 ExtendDecl 节点的父接口。

返回值：ExtendDecl 节点的父接口类型的列表，如：extend B <: A {} 中的 A。

prop body

public mut prop body: Body

功能：获取或设置 ExtendDecl 节点的类体。

返回值：ExtendDecl 节点的 Body 节点（大括号及大括号内的节点）。

prop identifier

public override mut prop identifier

功能：ExtendDecl 节点继承 Decl 节点，但是不支持 identifier 属性，使用时会抛出异常。

异常：

ASTException：当前节点未定义标识符。

class FuncDecl

public class FuncDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop overloadOp: Tokens
    public mut prop lParen: Token
    public mut prop funcParams: ArrayList<FuncParam>
    public mut prop rParen: Token
    public mut prop colon: Token
    public mut prop declType: TypeNode
    public mut prop block: Block
    public func isConst(): Bool
}

FuncDecl 表示一个函数定义节点。由可选的函数修饰符，关键字 func ，函数名，可选的类型形参列表，函数参数，可缺省的函数返回类型来定义一个函数，函数定义时必须有函数体，函数体是一个块。

init

public init(input: Tokens)

功能：构造 FuncDecl 实例。

参数：

input：将要构造 FuncDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 FuncDecl 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 FuncDecl 节点的左括号。

返回值：FuncDecl 节点的左括号词法单元。

prop funcParams

public mut prop funcParams: ArrayList<FuncParam>

功能：获取或设置 FuncDecl 节点的函数参数。

返回值：FuncDecl 节点内的函数参数节点列表。

prop rParen

public mut prop rParen: Token

功能：获取或设置 FuncDecl 节点的右括号。

返回值：FuncDecl 节点的右括号词法单元。

prop colon

public mut prop colon: Token

功能：获取或设置 FuncDecl 节点的冒号。

返回值：FuncDecl 节点的冒号词法单元，可能为空。

prop declType

public mut prop declType: TypeNode

功能：获取或设置 FuncDecl 节点的函数返回类型。

返回值：FuncDecl 节点的类型节点。

异常：

ASTException：FuncDecl 节点的函数返回类型是一个缺省值。

prop block

public mut prop block: Block

功能：获取或设置 FuncDecl 节点的函数体。

返回值：FuncDecl 节点的函数体节点（块）。

prop overloadOp

public mut prop overloadOp: Tokens

功能：获取或设置 FuncDecl 节点的重载操作符。

返回值：FuncDecl 节点中重载的操作符词法单元。

func isConst

public func isConst(): Bool

功能：判断是否是一个 Const 类型的节点。

返回值：是一个 Const 类型的节点返回 true。

class MainDecl

public class MainDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop lParen: Token
    public mut prop funcParams: ArrayList<FuncParam>
    public mut prop rParen: Token
    public mut prop colon: Token
    public mut prop declType: TypeNode
    public mut prop block: Block
}

MainDecl 表示一个 main 函数定义节点。

一个 MainDecl 节点：main() {}

init

public init(input: Tokens)

功能：构造 MainDecl 实例。

参数：

input：将要构造 MainDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 MainDecl 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 MainDecl 节点的左括号。

返回值：MainDecl 节点的左括号词法单元。

prop funcParams

public mut prop funcParams: ArrayList<FuncParam>

功能：获取或设置 MainDecl 节点的函数参数。

返回值：MainDecl 节点内的函数参数节点列表。

prop rParen

public mut prop rParen: Token

功能：获取或设置 MainDecl 节点的右括号。

返回值：MainDecl 节点的右括号词法单元。

prop colon

public mut prop colon: Token

功能：获取或设置 MainDecl 节点的冒号。

返回值：MainDecl 节点的冒号词法单元，可能为空。

prop declType

public mut prop declType: TypeNode

功能：获取或设置 MainDecl 节点的函数返回类型。

返回值：MainDecl 节点的类型节点。

异常：

ASTException：MainDecl 节点的函数返回类型是一个缺省值。

prop block

public mut prop block: Block

功能：获取或设置 MainDecl 节点的函数体。

返回值：MainDecl 节点的函数体节点（块）。

class MacroDecl

public class MacroDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop lParen: Token
    public mut prop funcParams: ArrayList<FuncParam>
    public mut prop rParen: Token
    public mut prop colon: Token
    public mut prop declType: TypeNode
    public mut prop block: Block
}

MacroDecl 表示一个宏定义节点。

一个 MacroDecl 节点：public macro M(input: Tokens): Tokens {...}

init

public init(input: Tokens)

功能：构造 MacroDecl 实例。

参数：

input：将要构造 MacroDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 MacroDecl 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 MacroDecl 节点的左括号。

返回值：MacroDecl 节点的左括号词法单元。

prop funcParams

public mut prop funcParams: ArrayList<FuncParam>

功能：获取或设置 MacroDecl 节点的参数。

返回值：MacroDecl 节点的参数列表。

prop rParen

public mut prop rParen: Token

功能：获取或设置 MacroDecl 节点的右括号。

返回值：MacroDecl 节点的右括号词法单元。

prop colon

public mut prop colon: Token

功能：获取或设置 MacroDecl 节点的冒号。

返回值：MacroDecl 节点的冒号词法单元，可能为空。

prop declType

public mut prop declType: TypeNode

功能：获取或设置 MacroDecl 节点的函数返回类型。

返回值：MacroDecl 节点的类型节点。

异常：

ASTException：MacroDecl 节点的函数返回类型是一个缺省值。

prop block

public mut prop block: Block

功能：获取或设置 MacroDecl 节点的函数体。

返回值：MacroDecl 节点的函数体节点。

class PrimaryCtorDecl

public class PrimaryCtorDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop lParen: Token
    public mut prop funcParams: ArrayList<FuncParam>
    public mut prop rParen: Token
    public mut prop block: Block
    public func isConst(): Bool
}

PrimaryCtorDecl 表示一个主构造函数节点。主构造函数节点由修饰符，主构造函数名，形参列表和主构造函数体构成。

init

public init(input: Tokens)

功能：构造 PrimaryCtorDecl 实例。

参数：

input：将要构造 PrimaryCtorDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 PrimaryCtorDecl 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 PrimaryCtorDecl 节点的左括号。

返回值：PrimaryCtorDecl 节点的左括号词法单元。

prop funcParams

public mut prop funcParams: ArrayList<FuncParam>

功能：获取或设置 PrimaryCtorDecl 节点的参数。

返回值：PrimaryCtorDecl 节点的参数列表。

prop rParen

public mut prop rParen: Token

功能：获取或设置 PrimaryCtorDecl 节点的右括号。

返回值：PrimaryCtorDecl 节点的右括号词法单元。

prop block

public mut prop block: Block

功能：获取或设置 PrimaryCtorDecl 节点的主构造函数体。

返回值：PrimaryCtorDecl 节点的主构造函数体节点。

func isConst

public func isConst(): Bool

功能：判断是否是一个 Const 类型的节点。

返回值：是一个 Const 类型的节点返回 true。

class PropDecl

public class PropDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop colon: Token
    public mut prop declType : TypeNode
    public mut prop lBrace: Token
    public mut prop getter: FuncDecl
    public mut prop setter: FuncDecl
    public mut prop rBrace: Token
}

PropDecl 表示一个属性定义节点。

一个 PropDecl 节点：prop var X: Int64 { get() { 0 } }

init

public init(input: Tokens)

功能：构造 PropDecl 实例。

参数：

input：将要构造 PropDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 PropDecl 节点。

prop colon

public mut prop colon: Token

功能：获取或设置 PropDecl 节点的冒号。

返回值：PropDecl 节点中冒号词法单元。

prop declType

public mut prop declType : TypeNode

功能：获取或设置 PropDecl 节点的返回类型。

返回值：PropDecl 节点的返回类型。

prop lBrace

public mut prop lBrace: Token

功能：获取或设置 PropDecl 节点的左大括号。

返回值：PropDecl 节点的左大括号词法单元。

prop getter

public mut prop getter: FuncDecl

功能：获取或设置 PropDecl 节点的 getter 函数。

返回值：一个函数节点。

异常：

-ASTException：当前 PropDecl 节点不存在 getter 函数。

prop setter

public mut prop setter: FuncDecl

功能：获取或设置 PropDecl 节点的 setter 函数。

返回值：一个函数节点。

异常：

-ASTException：当前 PropDecl 节点不存在 setter 函数。

prop rBrace

public mut prop rBrace: Token

功能：获取或设置 PropDecl 节点的右大括号。

返回值：PropDecl 节点的右大括号词法单元。

class VarDecl

public class VarDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop pattern: Pattern
    public mut prop colon: Token
    public mut prop declType: TypeNode
    public mut prop assign: Token
    public mut prop expr: Expr
    public func isConst(): Bool
}

VarDecl 表示变量定义节点。变量的定义主要包括四个部分：修饰符、关键字、patternsMaybeIrrefutable、变量类型和变量初始值。

一个 VarDecl 节点: var a: String，var b: Int64 = 1

init

public init(input: Tokens)

功能：构造 VarDecl 实例。

参数：

input：将要构造 VarDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 VarDecl 节点。

prop pattern

public mut prop pattern: Pattern

功能：获取或设置 VarDecl 节点的 pattern 节点。

返回值：pattern 节点，如 var (a, b) = (1, 2) 中的 (a, b)。

prop colon

public mut prop colon: Token

功能：获取或设置 VarDecl 节点中的冒号位置信息。

返回值：冒号的词法单元类型（由于变量类型是可选的，所以该属性的值可能为空的 Token）。

prop declType

public mut prop declType: TypeNode

功能：获取或设置 VarDecl 节点的变量类型。

返回值：当前节点的变量类型节点。

异常：

ASTException：VarDecl 节点没有声明变量类型。

prop assign

public mut prop assign: Token

功能：获取或设置 VarDecl 节点中的赋值操作符的位置信息。

返回值：赋值操作符的词法单元类型（由于变变量初始化是可选的，所以该属性的值可能为空的 Token）。

prop expr

public mut prop expr: Expr

功能：获取或设置 VarDecl 节点的变量初始化节点。

返回值：变量初始化节点。

异常：

ASTException：VarDecl 节点没有对变量进行初始化。

func isConst

public func isConst(): Bool

功能：判断是否是一个 Const 类型的节点。

返回值：是一个 Const 类型的节点返回 true。

class FuncParam

public class FuncParam <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop not: Token
    public mut prop colon: Token
    public mut prop paramType: TypeNode
    public mut prop assign: Token
    public mut prop expr: Expr
    public func isMemberParam(): Bool
}

FuncParam 表示函数参数节点，包括非命名参数和命名参数。

一个 FuncParam 节点： func foo(a: Int64, b: Float64) {...} 中的 a: Int64 和 b: Float64

init

public init(input: Tokens)

功能：构造 FuncParam 实例。

参数：

input：将要构造 FuncParam 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 FuncParam 节点。

prop not

public mut prop not: Token

功能：获取或设置命名形参中的 !。

返回值：! 词法单元类型（该属性的值可能为空的 Token）。

prop assign

public mut prop assign: Token

功能：获取或设置具有默认值的函数参数中的 =。

返回值：赋值操作符的词法单元类型（该属性的值可能为空的 Token）。

prop expr

public mut prop expr: Expr

功能：获取或设置具有默认值的函数参数的变量初始化节点。

返回值：变量初始化节点。

异常：

ASTException：函数参数没有进行初始化。

func isMemberParam

public func isMemberParam(): Bool

功能：当前的函数参数是否是主构造函数中的参数。

返回值：布尔类型，如果是主构造函数中的参数，返回 true。

class MacroExpandParam

public class MacroExpandParam <: FuncParam {
    public init()
    public init(inputs: Tokens)
    public mut prop at: Token
    public mut prop identifier: Token
    public mut prop fullIdentifier: Token
    public mut prop lSquare: Token
    public mut prop macroAttrs: Tokens
    public mut prop rSquare: Token
    public mut prop lParen: Token
    public mut prop macroInputs: Tokens
    public mut prop rParen: Token
    public mut prop macroInputDecl: Decl
}

MacroExpandParam 表示宏调用节点。

一个 MacroExpandDecl 节点： func foo (@M a: Int64) 中的 @M a: Int64。

prop at

public mut prop at: Token

功能：获取或设置宏调用节点的关键字 at。

返回值：关键字 at 的词法单元，例如 @pkg.M 中的 @。

prop identifier

public mut prop identifier: Token

功能：获取或设置宏调用节点的标识符。

返回值：一个包含完整标识符的词法单元类型，例如 @pkg.M 中的 M。

prop fullIdentifier

public mut prop fullIdentifier: Token

功能：获取或设置宏调用节点的完整标识符。

返回值：一个包含完整标识符的词法单元类型，例如 @pkg.M 中的 pkg.M。

prop lSquare

public mut prop lSquare: Token

功能：获取或设置 MacroExpandParam 属性宏调用的左中括号。

返回值：左中括号词法单元。

prop macroAttrs

public mut prop macroAttrs: Tokens

功能：获取或设置 MacroExpandParam 属性宏调用的输入。

返回值：宏调用的输入的词法单元集合。

prop rSquare

public mut prop rSquare: Token

功能：获取或设置 MacroExpandParam 属性宏调用的右中括号。

返回值：右中括号词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 MacroExpandParam 属性宏调用的左小括号。

返回值：左小括号词法单元。

prop macroInputs

public mut prop macroInputs: Tokens

功能：获取或设置 MacroExpandParam 宏调用的输入。

返回值：宏调用的输入的词法单元集合。

prop rParen

public mut prop rParen: Token

功能：获取或设置 MacroExpandParam 宏调用的右小括号。

返回值：右小括号词法单元。

prop macroInputDecl

public mut prop macroInputDecl: Decl

功能：获取或设置 MacroExpandParam 中的声明节点。

返回值：不带括号的宏调用的声明节点。

class TypeAliasDecl

public class TypeAliasDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop assign: Token
    public mut prop aliasType: TypeNode
}

TypeAliasDecl 表示类型别名节点。该节点中 type 作为关键字，紧跟任意的合法标识符，其后的 type 是任意的 top-level 可见的类型，标识符和 type 之间使用 = 进行连接。

一个 TypeAliasDecl 节点： type Point2D = Float64

init

public init(input: Tokens)

功能：构造 TypeAliasDecl 实例。

参数：

input：将要构造 TypeAliasDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 TypeAliasDecl 节点。

prop assign

public mut prop assign: Token

功能：获取或设置标识符和 type 之间的 = 。

返回值：= 的词法单元类型。

prop aliasType

public mut prop aliasType: TypeNode

功能：获取或设置将要别名的类型。

返回值：一个类型节点，如 type Point2D = Float64 中的 Float64。

class MacroExpandDecl

public class MacroExpandDecl <: Decl {
    public init()
    public init(inputs: Tokens)
    public mut prop fullIdentifier: Token
    public mut prop lSquare: Token
    public mut prop macroAttrs: Tokens
    public mut prop rSquare: Token
    public mut prop lParen: Token
    public mut prop macroInputs: Tokens
    public mut prop rParen: Token
    public mut prop macroInputDecl: Decl
}

MacroExpandDecl 表示宏调用节点。

一个 MacroExpandDecl 节点： @M class A {}

init

public init(input: Tokens)

功能：构造 MacroExpandDecl 实例。

参数：

input：将要构造 MacroExpandDecl 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 MacroExpandDecl 节点。

prop fullIdentifier

public mut prop fullIdentifier: Token

功能：获取或设置宏调用节点的完整标识符。

返回值：一个包含完整标识符的词法单元类型，例如 @pkg.M 中的 pkg.M。

prop lSquare

public mut prop lSquare: Token

功能：获取或设置 MacroExpandDecl 属性宏调用的左中括号。

返回值：左中括号词法单元。

prop macroAttrs

public mut prop macroAttrs: Tokens

功能：获取或设置 MacroExpandDecl 属性宏调用的输入。

返回值：宏调用的输入的词法单元集合。

prop rSquare

public mut prop rSquare: Token

功能：获取或设置 MacroExpandDecl 属性宏调用的右中括号。

返回值：右中括号词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 MacroExpandDecl 属性宏调用的左小括号。

返回值：左小括号词法单元。

prop macroInputs

public mut prop macroInputs: Tokens

功能：获取或设置 MacroExpandDecl 宏调用的输入。

返回值：宏调用的输入的词法单元集合。

prop rParen

public mut prop rParen: Token

功能：获取或设置 MacroExpandDecl 宏调用的右小括号。

返回值：右小括号词法单元。

prop macroInputDecl

public mut prop macroInputDecl: Decl

功能：获取或设置 MacroExpandDecl 中的声明节点。

返回值：不带括号的宏调用的声明节点。

class Block

public class Block <: Expr {
    public init()
    public mut prop lBrace: Token
    public mut prop nodes: ArrayList<Node>
    public mut prop rBrace: Token
}

Block 表示块节点，Block 由一对匹配的大括号及其中可选的表达式声明序列组成的结构，简称 “块”。

init

public init()

功能：构造一个默认的 Block 实例。

说明：Block 节点无法脱离表达式或声明节点单独存在，因此不提供其他的构造函数。

prop nodes

public mut prop nodes: ArrayList<Node>

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

返回值： Block 中的表达式或声明序列，可以为空。

prop lBrace

public mut prop lBrace: Token

功能：获取或设置 Block 的左大括号。

返回值：一个左大括号节点词法单元类型。

prop rBrace

public mut prop rBrace: Token

功能：获取或设置 Block 的右大括号。

返回值：一个右大括号节点词法单元类型。

class BinaryExpr

public class BinaryExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop leftExpr: Expr
    public mut prop op: Token
    public mut prop rightExpr: Expr
}

BinaryExpr 表示一个二元操作表达式节点。

一个 BinaryExpr 节点：a + b, a - b 等

init

public init(input: Tokens)

功能：构造 BinaryExpr 实例。

参数：

input：将要构造 BinaryExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 BinaryExpr 节点。

prop leftExpr

public mut prop leftExpr: Expr

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

返回值：BinaryExpr 节点中左表达式节点，如： a + b 中的 a。

prop op

public mut prop op: Token

功能：获取或设置 BinaryExpr 节点中的二元操作符。

返回值：BinaryExpr 节点中二元操作符词法单元，如： a + b 中的 +。

prop rightExpr

public mut prop rightExpr: Expr

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

返回值：BinaryExpr 节点中右表达式节点，如： a + b 中的 b。

class UnaryExpr

public class UnaryExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop op: Token
    public mut prop expr: Expr
}

UnaryExpr 表示一个一元操作表达式节点。

init

public init(input: Tokens)

功能：构造 UnaryExpr 实例。

参数：

input：将要构造 UnaryExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 UnaryExpr 节点。

prop op

public mut prop op: Token

功能：获取或设置 UnaryExpr 节点中的一元操作符。

返回值：UnaryExpr 节点中一元操作符词法单元，如：-b 中的 -。

prop expr

public mut prop expr: Expr

功能：获取或设置 UnaryExpr 节点中的操作数。

返回值：UnaryExpr 节点中表达式，如：-b 中的 b。

class IsExpr

public class IsExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop expr: Expr
    public mut prop keyword: Token
    public mut prop shiftType: TypeNode
}

IsExpr 表示一个类型检查表达式。

一个 IsExpr 表达式：e is T，类型为 Bool。其中 e 可以是任何类型的表达式，T 可以是任何类型。

init

public init(input: Tokens)

功能：构造 IsExpr 实例。

参数：

input：将要构造 IsExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 IsExpr 节点。

prop expr

public mut prop expr: Expr

功能：获取或设置 IsExpr 节点中的表达式节点。

返回值：表达式节点，如：e is T 中的 e。

prop keyword

public mut prop keyword: Token

功能：获取或设置 IsExpr 节点中的 is 操作符。

返回值：is 操作符词法单元。

prop shiftType

public mut prop shiftType: TypeNode

功能：获取或设置 IsExpr 节点中的目标类型。

返回值：目标类型节点，如：e is T 中的 T。

class AsExpr

public class AsExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop expr: Expr
    public mut prop keyword: Token
    public mut prop shiftType: TypeNode
}

AsExpr 表示一个类型检查表达式。

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

init

public init(input: Tokens)

功能：构造 AsExpr 实例。

参数：

input：将要构造 AsExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 AsExpr 节点。

prop expr

public mut prop expr: Expr

功能：获取或设置 AsExpr 节点中的表达式节点。

返回值：表达式节点，如：e as T 中的 e。

prop keyword

public mut prop keyword: Token

功能：获取或设置 AsExpr 节点中的 as 操作符。

返回值：as 操作符词法单元。

prop shiftType

public mut prop shiftType: TypeNode

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

返回值：目标类型节点，如：e as T 中的 T。

class ParenExpr

public class ParenExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop lParen: Token
    public mut prop parenthesizedExpr: Expr
    public mut prop rParen: Token
}

ParenExpr 表示一个括号表达式节点，是指使用圆括号括起来的表达式。

一个 ParenExpr 节点：(1 + 2)

init

public init(input: Tokens)

功能：构造 ParenExpr 实例。

参数：

input：将要构造 ParenExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ParenExpr 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 ParenExpr 节点中的左括号。

返回值：左括号的词法单元。

prop parenthesizedExpr

public mut prop parenthesizedExpr: Expr

功能：获取或设置 ParenExpr 节点中由圆括号括起来的子表达式。

返回值：表达式节点，如：(a) 中的 a。

prop rParen

public mut prop rParen: Token

功能：获取或设置 ParenExpr 节点中的右括号。

返回值：右括号的词法单元。

class LitConstExpr

public class LitConstExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop literal: Token
}

LitConstExpr 表示一个常量表达式节点。

一个 LitConstExpr 表达式："abc"，123 等。

init

public init(input: Tokens)

功能：构造 LitConstExpr 实例。

参数：

input：将要构造 LitConstExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ParenExpr 节点。

prop literal

public mut prop literal: Token

功能：获取或设置 LitConstExpr 节点中的字面量。

返回值：字面量值的词法单元。

class RefExpr

public class RefExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop identifier: Token
    public mut prop lAngle: Token
    public mut prop typeArguments: ArrayList<TypeNode>
    public mut prop rAngle: Token
}

RefExpr 表示一个使用自定义类型节点相关的表达式节点。

一个 RefExpr 节点：var ref = refNode + 1 中的 refNode 是一个 RefExpr。

init

public init(input: Tokens)

功能：构造 RefExpr 实例。

参数：

input：将要构造 RefExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 RefExpr 节点。

prop identifier

public mut prop identifier: Token

功能：获取或设置 RefExpr 节点中的自定义类型的标识符。

返回值：自定义类型标识符的词法单元，如 refNode + 1 中的 refNode。

prop lAngle

public mut prop lAngle: Token

功能：获取或设置 RefExpr 节点中的左尖括号。

返回值：左尖括号词法单元，可能为空的 Token。

prop typeArguments

public mut prop typeArguments: ArrayList<TypeNode>

功能：获取或设置 RefExpr 节点中的实例化类型。

返回值：实例化类型的列表，可能为空，如 refNode<Int32, A> + 1 中的 Int32 和 A。

prop rAngle

public mut prop rAngle: Token

功能：获取或设置 RefExpr 节点中的右尖括号。

返回值：右尖括号词法单元，可能为空的 Token。

class ReturnExpr

public class ReturnExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop expr: Expr
}

ReturnExpr 表示 return 表达式节点。

一个 ReturnExpr 节点：return 1。

init

public init(input: Tokens)

功能：构造 ReturnExpr 实例。

参数：

input：将要构造 ReturnExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ReturnExpr 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 ReturnExpr 节点中的关键字。

返回值：return 关键字词法单元。

prop expr

public mut prop expr: Expr

功能：获取或设置 ReturnExpr 节点中的表达式节点。

返回值：一个表达式节点。

异常：

ASTException：当前的 ReturnExpr 节点没有表达式。

class ThrowExpr

public class ThrowExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop expr: Expr
}

ThrowExpr 表示 throw 表达式节点。

一个 ThrowExpr 节点：throw Exception()。

init

public init(input: Tokens)

功能：构造 ThrowExpr 实例。

参数：

input：将要构造 ThrowExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ThrowExpr 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 ThrowExpr 节点中的关键字。

返回值：throw 关键字词法单元。

prop expr

public mut prop expr: Expr

功能：获取或设置 ThrowExpr 节点中的表达式节点。

返回值：一个表达式节点。

class AssignExpr

public class AssignExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop leftExpr: Expr
    public mut prop assign: Token
    public mut prop rightExpr: Expr
}

AssignExpr 表示赋值表达式节点，用于将左操作数的值修改为右操作数的值。

一个 AssignExpr 节点：a = b。

init

public init(input: Tokens)

功能：构造 AssignExpr 实例。

参数：

input：将要构造 AssignExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 AssignExpr 节点。

prop leftExpr

public mut prop leftExpr: Expr

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

返回值：AssignExpr 节点中的左操作数表达式，如 a = b 中的 a。

prop assign

public mut prop assign: Token

功能：获取或设置 AssignExpr 节点中的 = 操作符。

返回值：= 操作符的词法单元。

prop rightExpr

public mut prop rightExpr: Expr

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

返回值：AssignExpr 节点中的右操作数表达式，如 a = b 中的 b。

class CallExpr

public class CallExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop callFunc: Expr
    public mut prop lParen: Token
    public mut prop arguments: ArrayList<Argument>
    public mut prop rParen: Token
}

CallExpr 表示函数调用节点节点。

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

init

public init(input: Tokens)

功能：构造 CallExpr 实例。

参数：

input：将要构造 CallExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 CallExpr 节点。

prop callFunc

public mut prop callFunc: Expr

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

返回值：函数调用的表达式，如 foo(a, b) 中的 foo。

prop lParen

public mut prop lParen: Token

功能：获取或设置 CallExpr 节点中的左括号。

返回值：左括号的词法单元。

prop arguments

public mut prop arguments: ArrayList<Argument>

功能：获取或设置 CallExpr 节点中函数参数。

返回值：函数调用节点的入参。如 foo(a, b) 中的 a, b。

prop rParen

public mut prop rParen: Token

功能：获取或设置 CallExpr 节点中的右括号。

返回值：右括号的词法单元。

class MemberAccess

public class MemberAccess <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop baseExpr: Expr
    public mut prop dot: Token
    public mut prop field: Token
    public mut prop lAngle: Token
    public mut prop typeArguments: ArrayList<TypeNode>
    public mut prop rAngle: Token
}

MemberAccess 表示成员访问表达式，可以用于访问 class、interface、struct 等类型的成员。

一个 MemberAccess 节点的形式为 T.a，T 为成员访问表达式的主体，a 表示成员的名字。

init

public init(input: Tokens)

功能：构造 MemberAccess 实例。

参数：

input：将要构造 MemberAccess 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 MemberAccess 节点。

prop baseExpr

public mut prop baseExpr: Expr

功能：获取或设置 MemberAccess 节点的成员访问表达式主体。

返回值：一个表达式节点，如 T.a 中的 T。

prop dot

public mut prop dot: Token

功能：获取或设置 MemberAccess 节点中的 . 。

返回值：. 的词法单元。

prop field

public mut prop field: Token

功能：获取或设置 MemberAccess 节点成员的名字。

返回值：成员名字的词法单元，如 T.a 中的 a。

prop lAngle

public mut prop lAngle: Token

功能：获取或设置 MemberAccess 节点中的左尖括号。

返回值：左尖括号词法单元，可能为空的 Token。

prop typeArguments

public mut prop typeArguments: ArrayList<TypeNode>

功能：获取或设置 MemberAccess 节点中的实例化类型。

返回值：实例化类型的列表，可能为空，如 T.a<Int32> 中的 Int32。

prop rAngle

public mut prop rAngle: Token

功能：获取或设置 MemberAccess 节点中的右尖括号。

返回值：右尖括号词法单元，可能为空的 Token。

class OptionalExpr

public class OptionalExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop baseExpr: Expr
    public mut prop quest: Token
}

OptionalExpr 表示一个带有问号操作符的表达式节点。

一个 OptionalExpr 节点：a?.b, a?(b), a?[b] 中的 a?。

init

public init(input: Tokens)

功能：构造 OptionalExpr 实例。

参数：

input：将要构造 OptionalExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 OptionalExpr 节点。

prop baseExpr

public mut prop baseExpr: Expr

功能：获取或设置 OptionalExpr 的表达式节点。

返回值：一个表达式节点。

prop quest

public mut prop quest: Token

功能：获取或设置 OptionalExpr 中的问号操作符。

返回值：问号操作符的词法单元。

class IfExpr

public class IfExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keywordI: Token
    public mut prop lParen: Token
    public mut prop condition: Expr
    public mut prop rParen: Token
    public mut prop ifBlock: Block
    public mut prop keywordE: Token
    public mut prop elseExpr: Expr
}

IfExpr 表示条件表达式，可以根据判定条件是否成立来决定执行哪条代码分支。

一个 IfExpr 节点中 if 是关键字，if 之后是一个小括号，小括号内可以是一个表达式或者一个 let 声明的解构匹配，接着是一个 Block，Block 之后是可选的 else 分支。 else 分支以 else 关键字开始，后接新的 if 表达式或一个 Block。

init

public init(input: Tokens)

功能：构造 IfExpr 实例。

参数：

input：将要构造 IfExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 IfExpr 节点。

prop keywordI

public mut prop keywordI: Token

功能：获取或设置 IfExpr 节点中的 if 关键字。

返回值：if 关键字的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 IfExpr 节点中的 if 后的左括号。

返回值：左括号的词法单元。

prop condition

public mut prop condition: Expr

功能：获取或设置 IfExpr 节点中的 if 后的条件表达式。

返回值：一个表达式节点，如 if (a == 1) 中的 a == 1。

prop rParen

public mut prop rParen: Token

功能：获取或设置 IfExpr 节点中的 if 后的右括号。

返回值：右括号的词法单元。

prop ifBlock

public mut prop ifBlock: Block

功能：获取或设置 IfExpr 节点中的 if 后的 block 节点。

返回值：一个 Block 类型的节点。

prop keywordE

public mut prop keywordE: Token

功能：获取或设置 IfExpr 节点中 else 关键字。

返回值：else 关键字的词法单元。

prop elseExpr

public mut prop elseExpr: Expr

功能：获取或设置 IfExpr 节点中 else 分支节点。

返回值：Expr 类型的节点，该节点可能为空，节点的具体类型为 IfExpr 或 Block。

异常：

ASTException：当前 IfExpr 节点没有 else 分支节点。

class LetPatternExpr

public class LetPatternExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop pattern: Pattern
    public mut prop backArrow: Token
    public mut prop expr: Expr
}

LetPatternExpr 表示 let 声明的解构匹配节点。

一个 LetPatternExpr 节点：if (let Some(v) <- x) 中的 let Some(v) <- x。

init

public init(input: Tokens)

功能：构造 LetPatternExpr 实例。

参数：

input：将要构造 LetPatternExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 LetPatternExpr 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 LetPatternExpr 节点中 let 关键字。

返回值：let 关键字的词法单元。

prop pattern

public mut prop pattern: Pattern

功能：获取或设置 LetPatternExpr 节点中 let 之后的 pattern。

返回值：Pattern 类型的节点。

prop backArrow

public mut prop backArrow: Token

功能：获取或设置 LetPatternExpr 节点中 <- 操作符。

返回值：<- 操作符的词法单元。

prop expr

public mut prop expr: Expr

功能：获取或设置 LetPatternExpr 节点中 <- 操作符之后的表达式。

返回值：Expr 类型的节点。

class MatchExpr

public class MatchExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop lParen: Token
    public mut prop selector: Expr
    public mut prop rParen: Token
    public mut prop lBrace: Token
    public mut prop matchCases: ArrayList<MatchCase>
    public mut prop rBrace: Token
}

MatchExpr 表示模式匹配表达式实现模式匹配。模式匹配表达式分为带 selector 的 match 表达式和不带 selector 的 match 表达式。

init

public init(input: Tokens)

功能：构造 MatchExpr 实例。

参数：

input：将要构造 MatchExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 MatchExpr 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 MatchExpr 节点中 match 关键字。

返回值：match 关键字的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 MatchExpr 之后的左括号。

返回值：左括号的词法单元，可能为空的 Token。

prop selector

public mut prop selector: Expr

功能：获取或设置关键字 match 之后的 Expr。

返回值：一个表达式节点。

异常：

ASTException：该表达式是一个不带 selector 的 match 表达式。

prop rParen

public mut prop rParen: Token

功能：获取或设置 MatchExpr 之后的右括号。

返回值：右括号的词法单元，可能为空的 Token。

prop lBrace

public mut prop lBrace: Token

功能：获取或设置 MatchExpr 之后的左大括号。

返回值：左大括号的词法单元。

prop matchCases

public mut prop matchCases: ArrayList<MatchCase>

功能：获取或设置 MatchExpr 内的 matchCase, matchCase 以关键字 case 开头，后跟一个或者多个由 Pattern 或 Expr节点，具体见 [matchCase]。

返回值：一组 matchCase 节点列表。

prop rBrace

public mut prop rBrace: Token

功能：获取或设置 MatchExpr 之后的右大括号。

返回值：右大括号的词法单元。

class WhileExpr

public class WhileExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop lParen: Token
    public mut prop condition: Expr
    public mut prop rParen: Token
    public mut prop block: Block
}

WhileExpr 表示 while 表达式。 while 是关键字，while 之后是一个小括号，小括号内可以是一个表达式或者一个 let 声明的解构匹配，接着是一个 Block 节点。

init

public init(input: Tokens)

功能：构造 WhileExpr 实例。

参数：

input：将要构造 WhileExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 WhileExpr 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 WhileExpr 节点中 while 关键字。

返回值：while 关键字的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 WhileExpr 中 while 关键字之后的左括号。

返回值：左括号的词法单元。

prop condition

public mut prop condition: Expr

功能：获取或设置关键字 WhileExpr 中的条件表达式。

返回值：一个表达式节点。

prop rParen

public mut prop rParen: Token

功能：获取或设置 WhileExpr 中 while 关键字之后的右括号。

返回值：右括号的词法单元。

prop block

public mut prop block: Block

功能：获取或设置 WhileExpr 中的块节点。

返回值：一个 Block 节点。

class DoWhileExpr

public class DoWhileExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keywordD: Token
    public mut prop block: Block
    public mut prop keywordW: Token
    public mut prop lParen: Token
    public mut prop condition: Expr
    public mut prop rParen: Token
}

DoWhileExpr 表示 do-while 表达式。

init

public init(input: Tokens)

功能：构造 DoWhileExpr 实例。

参数：

input：将要构造 DoWhileExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 DoWhileExpr 节点。

prop keywordD

public mut prop keywordD: Token

功能：获取或设置 DoWhileExpr 节点中 do 关键字，D 为关键字前缀的大写表示。

返回值：do 关键字的词法单元。

prop block

public mut prop block: Block

功能：获取或设置 DoWhileExpr 中的块表达式。

返回值：一个 Block 节点。

prop keywordW

public mut prop keywordW: Token

功能：获取或设置 DoWhileExpr 节点中 while 关键字，W 为关键字前缀的大写表示。

返回值：while 关键字的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 DoWhileExpr 中 while 关键字之后的左括号。

返回值：左括号的词法单元。

prop condition

public mut prop condition: Expr

功能：获取或设置关键字 DoWhileExpr 中的条件表达式。

返回值：一个表达式节点。

prop rParen

public mut prop rParen: Token

功能：获取或设置 DoWhileExpr 中 while 关键字之后的右括号。

返回值：右括号的词法单元。

class LambdaExpr

public class LambdaExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop lBrace: Token
    public mut prop funcParams: ArrayList<FuncParam>
    public mut prop doubleArrow: Token
    public mut prop nodes: ArrayList<Node>
    public mut prop rBrace: Token
}

LambdaExpr 表示 Lambda 表达式，是一个匿名的函数。

一个 LambdaExpr 节点有两种形式，一种是有形参的 {a: Int64 => e1; e2 }，另一种是无形参的 { => e1; e2 }。

init

public init(input: Tokens)

功能：构造 LambdaExpr 实例。

参数：

input：将要构造 LambdaExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 LambdaExpr 节点。

prop lBrace

public mut prop lBrace: Token

功能：获取或设置 LambdaExpr 中的左大括号。

返回值：左大括号的词法单元。

prop doubleArrow

public mut prop doubleArrow: Token

功能：获取或设置 LambdaExpr 中的 =>。

返回值：=> 操作符的词法单元。

prop nodes

public mut prop nodes: ArrayList<Node>

功能：获取或设置 LambdaExpr 中的表达式或声明节点。

返回值：一组表达式或声明列表。

prop rBrace

public mut prop rBrace: Token

功能：获取或设置 LambdaExpr 中的右大括号。

返回值：右大括号的词法单元。

class SpawnExpr

public class SpawnExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop lParen: Token
    public mut prop threadContext: Expr
    public mut prop rParen: Token
    public mut prop lambdaExpr: LambdaExpr
}

SpawnExpr 表示 Spawn 表达式。

一个 SpawnExpr 节点由 spawn 关键字和一个不包含形参的闭包组成，例如：spawn { add(1, 2) }。

init

public init(input: Tokens)

功能：构造 SpawnExpr 实例。

参数：

input：将要构造 SpawnExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 SpawnExpr 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 SpawnExpr 中的左括号。

返回值：左括号的词法单元，可以为空。

prop threadContext

public mut prop threadContext: Expr

功能：获取或设置 SpawnExpr 中的线程上下文环境表达式。

返回值：一个表达式节点，如：spwan (ctx) 中的 (ctx)。

异常：

ASTException：SpawnExpr 中不含有上下文表达式。

prop rParen

public mut prop rParen: Token

功能：获取或设置 SpawnExpr 中的右括号。

返回值：右括号的词法单元，可以为空。

prop keyword

public mut prop keyword: Token

功能：获取或设置 SpawnExpr 中的 spawn 关键字。

返回值：spawn 关键字的词法单元。

prop lambdaExpr

public mut prop lambdaExpr: LambdaExpr

功能：获取或设置 SpawnExpr 中的不含形参的闭包。

返回值：不含形参的 LambdaExpr 表达式。

class SynchronizedExpr

public class SynchronizedExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop lParen: Token
    public mut prop structuredMutex: Expr
    public mut prop rParen: Token
    public mut prop block: Block
}

SynchronizedExpr 表示 synchronized 表达式。

一个 SynchronizedExpr 节点由 synchronized 关键字和 StructuredMutex 对以及后面的代码块组成, 例如 synchronized(m) { foo() }。

init

public init(input: Tokens)

功能：构造 SynchronizedExpr 实例。

参数：

input：将要构造 SynchronizedExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 SynchronizedExpr 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 SynchronizedExpr 中的 synchronized 关键字。

返回值：synchronized 关键字的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 SynchronizedExpr 中的左括号。

返回值：左括号词法单元。

prop structuredMutex

public mut prop structuredMutex: Expr

功能：获取或设置 SynchronizedExpr 中的 StructuredMutex 的对象。

返回值：一个 RefExpr 节点。

prop rParen

public mut prop rParen: Token

功能：获取或设置 SynchronizedExpr 中的右括号。

返回值：右括号词法单元。

prop block

public mut prop block: Block

功能：获取或设置 SynchronizedExpr 修饰的代码块。

返回值：代码块节点。

class TrailingClosureExpr

public class TrailingClosureExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop expr: Expr
    public mut prop lambdaExpr: LambdaExpr
}

TrailingClosureExpr 表示尾随 Lambda 节点。

一个 TrailingClosureExpr 节点将 lambda 表达式放在函数调用的尾部，括号外面，如 f(a){ i => i * i }。

init

public init(input: Tokens)

功能：构造 TrailingClosureExpr 实例。

参数：

input：将要构造 TrailingClosureExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 TrailingClosureExpr 节点。

prop expr

public mut prop expr: Expr

功能：获取或设置 TrailingClosureExpr 中的表达式。

返回值：表达式节点，可能为 RefExpr 或 CallExpr 类型。

prop expr

public mut prop lambdaExpr: LambdaExpr

功能：获取或设置 TrailingClosureExpr 中的尾随 lambda 。

返回值：LambdaExpr 表达式节点。

class TypeConvExpr

public class TypeConvExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop targetType: PrimitiveType
    public mut prop lParen: Token
    public mut prop expr: Expr
    public mut prop rParen: Token
}

TypeConvExpr 表示类型转换表达式，用于实现若干数值类型间的转换。

一个 TypeConvExpr 节点：Int8(32)

init

public init(input: Tokens)

功能：构造 TypeConvExpr 实例。

参数：

input：将要构造 TypeConvExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 TypeConvExpr 节点。

prop targetType

public mut prop targetType: PrimitiveType

功能：获取或设置 TypeConvExpr 中将要转换到的目标类型。

返回值：基本类型节点，如 Int8, Int16。

prop lParen

public mut prop lParen: Token

功能：获取或设置 TypeConvExpr 中的左括号。

返回值：左括号词法单元。

prop expr

public mut prop expr: Expr

功能：获取或设置 TypeConvExpr 中进行类型转化的原始表达式。

返回值：表达式节点，如 Int8(a) 中的 a。

prop rParen

public mut prop rParen: Token

功能：获取或设置 TypeConvExpr 中的右括号。

返回值：右括号词法单元。

class ForInExpr

public class ForInExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keywordF: Token
    public mut prop lParen: Token
    public mut prop pattern: Pattern
    public mut prop keywordI: Token
    public mut prop expr: Expr
    public mut prop keywordW: Token
    public mut prop patternGuard: Expr
    public mut prop rParen: Token
    public mut prop block: Block
}

ForInExpr 表示 for-in 表达式。

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

init

public init(input: Tokens)

功能：构造 ForInExpr 实例。

参数：

input：将要构造 ForInExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ForInExpr 节点。

prop keywordF

public mut prop keywordF: Token

功能：获取或设置 ForInExpr 中的关键字 for。

返回值：for 关键字的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 ForInExpr 中关键字 for 后的左括号。

返回值：左括号的词法单元。

prop pattern

public mut prop pattern: Pattern

功能：获取或设置 ForInExpr 中的 Pattern 节点。

返回值：Pattern 节点。

prop keywordI

public mut prop keywordI: Token

功能：获取或设置 ForInExpr 中的关键字 in。

返回值：in 关键字词法单元。

prop expr

public mut prop expr: Expr

功能：获取或设置 ForInExpr 中的表达式。

返回值：表达式节点，如 for (i in children) 中的 children。

prop keywordW

public mut prop keywordW: Token

功能：获取或设置 ForInExpr 中的关键字 where。

返回值：where 关键字词法单元，可能为空。

prop patternGuard

public mut prop patternGuard: Expr

功能：获取或设置 ForInExpr 中的 patternGuard 条件表达式。

返回值：patternGuard 表达式节点。

异常：

ASTException：ForInExpr 节点中不存在 patternGuard 表达式。

prop block

public mut prop block: Block

功能：获取或设置 ForInExpr 中的循环体。

返回值：代码块 Block 节点。

class PrimitiveTypeExpr

public class PrimitiveTypeExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
}

PrimitiveTypeExpr 表示基本类型表达式节点。

PrimitiveTypeExpr 节点：编译器内置的基本类型作为表达式出现在节点中。如 Int64.toSting() 中的 Int64。

init

public init(input: Tokens)

功能：构造 PrimitiveTypeExpr 实例。

参数：

input：将要构造 PrimitiveTypeExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 PrimitiveTypeExpr 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 PrimitiveTypeExpr 中的基本类型关键字。

返回值：基本类型关键字的词法单元。

class ArrayLiteral

public class ArrayLiteral <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop lSquare: Token
    public mut prop elements: ArrayList<Expr>
    public mut prop rSquare: Token
}

ArrayLiteral 表示 Array 字面量节点。

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

init

public init(input: Tokens)

功能：构造 ArrayLiteral 实例。

参数：

input：将要构造 ArrayLiteral 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ArrayLiteral 节点。

prop lSquare

public mut prop lSquare: Token

功能：获取或设置 ArrayLiteral 中的左中括号。

返回值：左中括号的词法单元。

prop elements

public mut prop elements: ArrayList<Expr>

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

返回值：一组表达式列表。

prop rSquare

public mut prop rSquare: Token

功能：获取或设置 ArrayLiteral 中的右中括号。

返回值：右中括号的词法单元。

class TupleLiteral

public class TupleLiteral <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop lParen: Token
    public mut prop elements: ArrayList<Expr>
    public mut prop rParen: Token
}

TupleLiteral 表示元组字面量节点。

TupleLiteral 节点：使用格式 (expr1, expr2, ... , exprN) 表示，每个 expr 是一个表达式。

init

public init(input: Tokens)

功能：构造 TupleLiteral 实例。

参数：

input：将要构造 TupleLiteral 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 TupleLiteral 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 TupleLiteral 中的左括号。

返回值：左中括号的词法单元。

prop elements

public mut prop elements: ArrayList<Expr>

功能：获取或设置 TupleLiteral 中的表达式列表。

返回值：一组表达式列表。

prop rParen

public mut prop rParen: Token

功能：获取或设置 TupleLiteral 中的右括号。

返回值：右括号的词法单元。

class RangeExpr

public class RangeExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop start: Expr
    public mut prop op: Token
    public mut prop end: Expr
    public mut prop colon: Token
    public mut prop step: Expr
}

RangeExpr 表示包含区间操作符的表达式。

RangeExpr 节点：存在两种 Range 操作符：.. 和 ..=，分别用于创建左闭右开和左闭右闭的 Range 实例。它们的使用方式分别为 start..end:step 和 start..=end:step。

init

public init(input: Tokens)

功能：构造 RangeExpr 实例。

参数：

input：将要构造 RangeExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 RangeExpr 节点。

prop start

public mut prop start: Expr

功能：获取或设置 RangeExpr 中的起始值。

返回值：一个表达式节点，如：0..10:1 中的 0。

异常：

ASTException：起始表达式省略。只有在 Range<Int64> 类型的实例用在下标操作符 [] 为空的场景。

prop op

public mut prop op: Token

功能：获取或设置 RangeExpr 中的 Range 的操作符。

返回值：一个操作符的词法单元，如 .. 或 ..=。

prop end

public mut prop end: Expr

功能：获取或设置 RangeExpr 中的终止值。

返回值：一个表达式节点，如：0..10:1 中的 10。

异常：

ASTException：终止表达式省略。只有在 Range<Int64> 类型的实例用在下标操作符 [] 为空的场景。

prop colon

public mut prop colon: Token

功能：获取或设置 RangeExpr 中的 : 操作符。

返回值：一个 : 操作符的词法单元，可以为空。

prop step

public mut prop step: Expr

功能：获取或设置 RangeExpr 中序列中前后两个元素之间的差值。

返回值：一个表达式节点，如：0..10:1 中的 1。

异常：

ASTException：RangeExpr 中未设置序列前后两个元素之间的差值。

class SubscriptExpr

public class SubscriptExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop baseExpr: Expr
    public mut prop lSquare: Token
    public mut prop indexList: ArrayList<Expr>
    public mut prop rSquare: Token
}

SubscriptExpr 表示索引访问表达式。

SubscriptExpr 节点：用于那些支持索引访问的类型（包括 Array 类型和 Tuple 类型）通过下标来访问其具体位置的元素，如 arr[0]。

init

public init(input: Tokens)

功能：构造 SubscriptExpr 实例。

参数：

input：将要构造 SubscriptExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 SubscriptExpr 节点。

prop baseExpr

public mut prop baseExpr: Expr

功能：获取或设置 SubscriptExpr 中的表达式。

返回值：一个表达式节点，如：e[a] 中的 e。

prop lSquare

public mut prop lSquare: Token

功能：获取或设置 SubscriptExpr 中的左中括号。

返回值：左中括号词法单元。

prop indexList

public mut prop indexList: ArrayList<Expr>

功能：获取或设置 SubscriptExpr 中的索引表达式序列。

返回值：表达式节点的序列，如 arr[1] 中的 1。

prop rSquare

public mut prop rSquare: Token

功能：获取或设置 SubscriptExpr 中的右中括号。

返回值：右中括号词法单元。

class IncOrDecExpr

public class IncOrDecExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop op: Token
    public mut prop expr: Expr
}

IncOrDecExpr 表示包含自增操作符（++）或自减操作符（--）的表达式。

init

public init(input: Tokens)

功能：构造 IncOrDecExpr 实例。

参数：

input：将要构造 IncOrDecExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 IncOrDecExpr 节点。

prop op

public mut prop op: Token

功能：获取或设置 IncOrDecExpr 中的操作符。

返回值：操作符的词法单元。

prop expr

public mut prop expr: Expr

功能：获取或设置 IncOrDecExpr 中的表达式。

返回值：一个表达式节点。

class TryExpr

public class TryExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keywordT: Token
    public mut prop resourceSpec: ArrayList<VarDecl>
    public mut prop tryBlock: Block
    public mut prop keywordsC: Tokens
    public mut prop catchPatterns: ArrayList<Pattern>
    public mut prop catchBlocks: ArrayList<Block>
    public mut prop keywordF: ArrayList<Pattern>
    public mut prop finallyBlock: Block
}

TryExpr 表示 try 表达式节点。try 表达式包括三个部分：try 块，catch 块和 finally 块。

init

public init(input: Tokens)

功能：构造 TryExpr 实例。

参数：

input：将要构造 TryExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 TryExpr 节点。

prop keywordT

public mut prop keywordT: Token

功能：获取或设置 TryExpr 中的 try 关键字。

返回值：try 关键字的词法单元。

prop resourceSpec

public mut prop resourceSpec: ArrayList<VarDecl>

功能：获取或设置 TryExpr 中 Try-with-resources 类型表达式的实例化对象序列。

返回值：一组实例化对象节点。

prop tryBlock

public mut prop tryBlock: Block

功能：获取或设置 TryExpr 中由表达式与声明组成的块。

返回值：一个 Block 类型的节点。

prop keywordsC

public mut prop keywordsC: Tokens

功能：获取或设置 TryExpr 中的关键字 catch。

返回值：一组 catch 关键字词法单元。

prop catchPatterns

public mut prop catchPatterns: ArrayList<Pattern>

功能：获取或设置 TryExpr 中通过模式匹配的方式匹配待捕获的异常序列。

返回值：一组模式匹配序列。

prop catchBlocks

public mut prop catchBlocks: ArrayList<Block>

功能：获取或设置 TryExpr 中的 Catch 块。

返回值：由表达式与声明组成块的序列。

prop keywordF

public mut prop keywordF: Token

功能：获取或设置 TryExpr 中的 finally 关键字。

返回值：finally 关键字词法单元，可以为空。

prop finallyBlock

public mut prop finallyBlock: Block

功能：获取或设置 TryExpr 中的关键字 Finally 块。

返回值：由表达式与声明组成块。

异常：

ASTException：TryExpr 节点无 Finally 块节点。

class QuoteExpr

public class QuoteExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop lParen: Token
    public mut prop exprs: ArrayList<Expr>
    public mut prop rParen: Token
}

QuoteExpr 表示 quote 表达式节点。

一个 QuoteExpr 节点： quote(var ident = 0)

init

public init(input: Tokens)

功能：构造 QuoteExpr 实例。

参数：

input：将要构造 QuoteExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 QuoteExpr 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 QuoteExpr 中的左括号。

返回值：左括号节点的词法单元。

prop exprs

public mut prop exprs: ArrayList<Expr>

功能：获取或设置 QuoteExpr 中由 () 括起的内部引用表达式节点。

返回值：一组表达式序列。

prop rParen

public mut prop rParen: Token

功能：获取或设置 QuoteExpr 中的右括号。

返回值：右括号节点的词法单元。

class QuoteToken

public class QuoteToken <: Expr {
    public mut prop tokens: Tokens
}

QuoteToken 表示 quote 表达式节点内任意合法的 token。

tokens

public mut prop tokens: Tokens

功能：获取 QuoteToken 内的 tokens。

返回值：一组词法单元序列，如 quote(1 + 2) 中的 1 + 2。

class MacroExpandExpr

public class MacroExpandExpr <: Expr {
    public init()
    public init(inputs: Tokens)
    public mut prop at: Token
    public mut prop identifier: Token
    public mut prop lSquare: Token
    public mut prop macroAttrs: Tokens
    public mut prop rSquare: Token
    public mut prop lParen: Token
    public mut prop macroInputs: Tokens
    public mut prop rParen: Token
}

MacroExpandExpr 表示宏调用节点。

一个 MacroExpandExpr 节点： @M (a is Int64)

init

public init(input: Tokens)

功能：构造 MacroExpandExpr 实例。

参数：

input：将要构造 MacroExpandExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 MacroExpandExpr 节点。

public mut prop at: Token

功能：获取或设置宏调用节点的关键字 at。

返回值：关键字 at 的词法单元，例如 @pkg.M 中的 @。

public mut prop identifier: Token

功能：获取或设置宏调用节点的标识符。

返回值：一个包含完整标识符的词法单元类型，例如 @pkg.M 中的 M。

prop lSquare

public mut prop lSquare: Token

功能：获取或设置 MacroExpandExpr 属性宏调用的左中括号。

返回值：左中括号词法单元。

prop macroAttrs

public mut prop macroAttrs: Tokens

功能：获取或设置 MacroExpandExpr 属性宏调用的输入。

返回值：宏调用的输入的词法单元集合。

prop rSquare

public mut prop rSquare: Token

功能：获取或设置 MacroExpandExpr 属性宏调用的右中括号。

返回值：右中括号词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 MacroExpandExpr 属性宏调用的左小括号。

返回值：左小括号词法单元。

prop macroInputs

public mut prop macroInputs: Tokens

功能：获取或设置 MacroExpandExpr 宏调用的输入。

返回值：宏调用的输入的词法单元集合。

prop rParen

public mut prop rParen: Token

功能：获取或设置 MacroExpandExpr 宏调用的右小括号。

返回值：右小括号词法单元。

class WildcardExpr

public class WildcardExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
}

WildcardExpr 表示通配符表达式节点。

init

public init(input: Tokens)

功能：构造 WildcardExpr 实例。

参数：

input：将要构造 WildcardExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 WildcardExpr 节点。

token

public mut prop keyword: Token

功能：获取 WildcardExpr 的通配符关键字。

返回值：一个通配符词法单元。

class VArrayExpr

public class VArrayExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop vArrayType: VArrayType
    public mut prop lParen: Token
    public mut prop arguments: ArrayList<Argument>
    public mut prop rParen: Token
}

VArrayExpr 表示 VArray 的实例节点。

一个 VArrayExpr 节点：let arr: VArray<Int64, $5> = VArray<Int64, $5> { i => i} 中的 VArray<Int64, $5> { i => i}

init

public init(input: Tokens)

功能：构造 VArrayExpr 实例。

参数：

input：将要构造 VArrayExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 VArrayExpr 节点。

prop vArrayType

public mut prop vArrayType: VArrayType

功能：获取或设置 VArrayExpr 的 VArray 类型节点。

返回值：一个 VArrayType 类型的节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 VArrayExpr 中的左括号。

返回值：左括号节点的词法单元。

prop exprs

public mut prop exprs: ArrayList<Expr>

功能：获取或设置 VArrayExpr 中的初始化表达式。

返回值：一组表达式序列。

prop rParen

public mut prop rParen: Token

功能：获取或设置 VArrayExpr 中的右括号。

返回值：右括号节点的词法单元。

class AdjointExpr

public class AdjointExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop at: Token
    public mut prop identifier: Token
    public mut prop lParen: Token
    public mut prop diffFunc: Expr
    public mut prop rParen: Token
}

AdjointExpr 用于表示AdjointExpr 节点，给定一个可微函数，可以使用 @AdjointOf 表达式来获取对该函数微分产生的伴随函数。

一个 AdjointExpr 节点：@AdjointOf(foo) ，其中括号内的标识符必须表示一个函数。

init

public init(input: Tokens)

功能：构造 AdjointExpr 实例。

参数：

input：将要构造 AdjointExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 AdjointExpr 节点。

prop at

public mut prop at: Token

功能：设置或获取 AdjointExpr 的 @ 操作符。

返回值：@ 操作符的词法单元。

prop identifier

public mut prop identifier: Token

功能：获取或设置 AdjointExpr 中的标识符 AdjointOf。

返回值：标识符 AdjointOf 的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 AdjointExpr 中的左括号。

返回值：左括号节点的词法单元。

prop diffFunc

public mut prop diffFunc: Expr

功能：获取或设置 AdjointExpr 中的可微函数表达式。

返回值：一个可微函数的表达式节点。

prop rParen

public mut prop rParen: Token

功能：获取或设置 AdjointExpr 中的右括号。

返回值：右括号节点的词法单元。

class GradExpr

public class GradExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop at: Token
    public mut prop identifier: Token
    public mut prop lParen: Token
    public mut prop diffFunc: Expr
    public mut prop inputValue: ArrayList<Expr>
    public mut prop rParen: Token
}

GradExpr 表示 GradExpr 节点，给定一个可微函数和相应的输入参数，可使用 @Grad 表达式来获取该函数在该输入值处的梯度值。

一个 GradExpr 节点：@Grad(foo, 2.0, 3.0) ，其中括号内的标识符必须表示一个函数。

init

public init(input: Tokens)

功能：构造 GradExpr 实例。

参数：

input：将要构造 GradExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 GradExpr 节点。

prop at

public mut prop at: Token

功能：设置或获取 GradExpr 内的 @ 操作符。

返回值：@ 操作符的词法单元。

prop identifier

public mut prop identifier: Token

功能：获取或设置 GradExpr 中的标识符 Grad。

返回值：标识符 Grad 的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 GradExpr 中的左括号。

返回值：左括号节点的词法单元。

prop diffFunc

public mut prop diffFunc: Expr

功能：获取或设置 GradExpr 中的可微函数表达式。

返回值：一个可微函数的表达式节点。

prop inputValue

public mut prop inputValue: ArrayList<Expr>

功能：获取或设置 GradExpr 中的输入参数。

返回值：输入参数的表达式节点结合，如 @Grad(foo, 2.0, 3.0) 中的 2.0, 3.0。

prop rParen

public mut prop rParen: Token

功能：获取或设置 GradExpr 中的右括号。

返回值：右括号节点的词法单元。

class ValWithGradExpr

public class ValWithGradExpr <: Expr {
    public init()
    public init(input: Tokens)
    public mut prop at: Token
    public mut prop identifier: Token
    public mut prop lParen: Token
    public mut prop diffFunc: Expr
    public mut prop inputValue: ArrayList<Expr>
    public mut prop rParen: Token
}

ValWithGradExpr 表示 ValWithGradExpr 节点，给定一个可微函数和相应的输入参数值，用户可使用 @ValWithGrad 表达式来获取该函数在该输入值处的结果和梯度值。

一个 VJPExpr 节点：@ValWithGrad(foo, 2.0, 3.0)，其中括号内的标识符必须表示一个函数。

init

public init(input: Tokens)

功能：构造 ValWithGradExpr 实例。

参数：

input：将要构造 ValWithGradExpr 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ValWithGradExpr 节点。

prop at

public mut prop at: Token

功能：设置或获取 ValWithGradExpr 内的 @ 操作符。

返回值：@ 操作符的词法单元。

prop identifier

public mut prop identifier: Token

功能：获取或设置 ValWithGradExpr 中的标识符。

返回值：标识符 ValWithGrad 的词法单元。

prop lParen

public mut prop lParen: Token

功能：获取或设置 ValWithGradExpr 中的左括号。

返回值：左括号节点的词法单元。

prop diffFunc

public mut prop diffFunc: Expr

功能：获取或设置 ValWithGradExpr 中的可微函数表达式。

返回值：一个可微函数的表达式节点。

prop inputValue

public mut prop inputValue: ArrayList<Expr>

功能：获取或设置 ValWithGradExpr 中的输入参数。

返回值：输入参数的表达式节点结合，如 @ValWithGrad(foo, 2.0, 3.0) 中的 2.0, 3.0。

prop rParen

public mut prop rParen: Token

功能：获取或设置 ValWithGradExpr 中的右括号。

返回值：右括号节点的词法单元。

class TypeNode

public open class TypeNode <: Node {
    public mut prop typeParameterName: Token
}

TypeNode 是所有类型节点的父类，继承自 Node。

prop typeParameterName

public mut prop typeParameterName: Token

功能：获取或设置类型节点的参数。

返回值：类型参数的词法单元，如：(p1:Int64, p2:Int64) 中的 p1 和 p2，并且可以为空。

class PrimitiveType

public class PrimitiveType <: TypeNode {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
}

PrimitiveType 表示一个基本类型节点，如数值类型，Char 类型，布尔类型等。

init

public init(input: Tokens)

功能：构造 PrimitiveType 实例。

参数：

input：将要构造 PrimitiveType 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 PrimitiveType 节点。

keyword

public mut prop keyword: Token

功能：构造 PrimitiveType 类型的关键字。

返回值：一个基本类型关键字词法单元，如 Int8。

class RefType

public class RefType <: TypeNode {
    public init()
    public init(input: Tokens)
    public mut prop identifier: Token
    public mut prop lAngle: Token
    public mut prop typeArguments: ArrayList<TypeNode>
    public mut prop rAngle: Token
}

RefType 表示一个用户自定义类型节点，如 var a : A = A() 中的 A。

init

public init(input: Tokens)

功能：构造 RefType 实例。

参数：

input：将要构造 RefType 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 RefType 节点。

prop identifier

public mut prop identifier: Token

功能：构造 RefType 类型的关键字。

返回值：一个基本类型关键字词法单元，如 var a : A = A() 中的 A。

prop lAngle

public mut prop lAngle: Token

功能：获取或设置 RefType 节点中的左尖括号。

返回值：左尖括号词法单元，可能为空的 Token。

prop typeArguments

public mut prop typeArguments: ArrayList<TypeNode>

功能：获取或设置 RefType 节点中的实例化类型。

返回值：实例化类型的列表，可能为空，如 var a : Array<Int32> 中的 Int32。

prop rAngle

public mut prop rAngle: Token

功能：获取或设置 RefType 节点中的右尖括号。

返回值：右尖括号词法单元，可能为空的 Token。

class QualifiedType

public class QualifiedType <: TypeNode {
    public init()
    public init(input: Tokens)
    public mut prop baseType: TypeNode
    public mut prop dot: Token
    public mut prop identifier: Token
    public mut prop lAngle: Token
    public mut prop typeArguments: ArrayList<TypeNode>
    public mut prop rAngle: Token
}

QualifiedType 表示一个用户自定义成员类型，如 var a : T.a 中的 T.a, 其中 T 是包名，a 是从 T 包中导入的类型。

init

public init(input: Tokens)

功能：构造 QualifiedType 实例。

参数：

input：将要构造 QualifiedType 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 QualifiedType 节点。

prop baseType

public mut prop baseType: Expr

功能：获取或设置 QualifiedType 节点的成员访问类型主体。

返回值：一个表达式节点，如 var a : T.a 中的 T。

prop dot

public mut prop dot: Token

功能：获取或设置 QualifiedType 节点中的 . 。

返回值：. 的词法单元。

prop identifier

public mut prop identifier: Token

功能：获取或设置 QualifiedType 节点成员的标识符。

返回值：节点成员标识符的词法单元，如 var a : T.a 中的 a。

prop lAngle

public mut prop lAngle: Token

功能：获取或设置 QualifiedType 节点中的左尖括号。

返回值：左尖括号词法单元，可能为空的 Token。

prop typeArguments

public mut prop typeArguments: ArrayList<TypeNode>

功能：获取或设置 QualifiedType 节点中的实例化类型。

返回值：实例化类型的列表，可能为空，如 T.a<Int32> 中的 Int32。

prop rAngle

public mut prop rAngle: Token

功能：获取或设置 QualifiedType 节点中的右尖括号。

返回值：右尖括号词法单元，可能为空的 Token。

class ParenType

public class ParenType <: TypeNode {
    public init()
    public init(input: Tokens)
    public mut prop lParen: Token
    public mut prop parenthesizedType: TypeNode
    public mut prop rParen: Token
}

ParenType 表示括号类型节点，如 var a: (Int64) 中的 (Int64)。

init

public init(input: Tokens)

功能：构造 ParenType 实例。

参数：

input：将要构造 ParenType 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ParenType 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 ParenType 节点中的左括号。

返回值：左括号词法单元。

prop parenthesizedType

public mut prop parenthesizedType: TypeNode

功能：获取或设置 ParenType 节点中括起来的类型。

返回值：一个表达式节点，如 (Int64) 中的 Int64。

prop rParen

public mut prop rParen: Token

功能：获取或设置 ParenType 节点中的右括号。

返回值：右括号词法单元。

class TupleType

public class TupleType <: TypeNode {
    public init()
    public init(input: Tokens)
    public mut prop lParen: Token
    public mut prop types: ArrayList<TypeNode>
    public mut prop rParen: Token
}

TupleType 表示元组类型节点，如 var a : (Int64, Int32) 中的 (Int64, Int32)。

init

public init(input: Tokens)

功能：构造 TupleType 实例。

参数：

input：将要构造 TupleType 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 TupleType 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 TupleType 节点中的左括号。

返回值：左括号词法单元。

prop types

public mut prop types: ArrayList<TypeNode>

功能：获取或设置 TupleType 节点中的类型节点列表。

返回值：类型节点序列。

prop rParen

public mut prop rParen: Token

功能：获取或设置 TupleType 节点中的右括号。

返回值：右括号词法单元。

class ThisType

public class ThisType <: TypeNode {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
}

ThisType 表示 This 类型节点。

init

public init(input: Tokens)

功能：构造 ThisType 实例。

参数：

input：将要构造 ThisType 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ThisType 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 ThisType 节点关键字 This。

返回值：This 关键字的词法单元。

class PrefixType

public class PrefixType <: TypeNode {
    public init()
    public init(input: Tokens)
    public mut prop prefixOps: Tokens
    public mut prop baseType: TypeNode
}

PrefixType 表示带问号的前缀类型节点，如：var a : ?A 中的 ?A。

init

public init(input: Tokens)

功能：构造 PrefixType 实例。

参数：

input：将要构造 PrefixType 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 PrefixType 节点。

prop prefixOps

public mut prop prefixOps: Tokens

功能：获取或设置 PrefixType 节点中前缀操作符集合。

返回值：包含多个问号的词法单元集合。

prop baseType

public mut prop baseType: TypeNode

功能：获取或设置 PrefixType 节点中的类型节点。

返回值：一个类型节点，如 var a: ?A 中的 A。

class VArrayType

public class VArrayType <: TypeNode {
    public init()
    public init(input: Tokens)
    public mut prop keyword: Token
    public mut prop lAngle: Token
    public mut prop elementTy: TypeNode
    public mut prop dollar: Token
    public mut prop size: Token
    public mut prop rAngle: Token
}

VArrayType 表示 VArray 类型节点，使用泛型 VArray<T, size: Int64> 表示 VArray 类型。

init

public init(input: Tokens)

功能：构造 VArrayType 实例。

参数：

input：将要构造 VArrayType 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 VArrayType 节点。

prop keyword

public mut prop keyword: Token

功能：获取或设置 VArrayType 节点的关键字 VArray。

返回值：VArray 关键字的词法单元。

prop lAngle

public mut prop lAngle: Token

功能：获取或设置 VArrayType 节点左尖括号。

返回值：左尖括号的词法单元。

prop elementTy

public mut prop elementTy: TypeNode

功能：获取或设置 VArrayType 节点中的类型变元。

返回值：一个类型节点，如 VArray<Int16, $0> 中的 Int16。

prop dollar

public mut prop dollar: Token

功能：获取或设置 VArrayType 节点中的操作符 $。

返回值：操作符 $ 的词法单元。

prop size

public mut prop size: Token

功能：获取或设置 VArrayType 节点中类型的长度。

返回值：类型长度的词法单元。

prop rAngle

public mut prop rAngle: Token

功能：获取或设置 VArrayType 节点右尖括号。

返回值：右尖括号的词法单元。

class ConstPattern

public class ConstPattern <: Pattern {
    public init()
    public init(input: Tokens)
    public mut prop litConstExpr: LitConstExpr
}

ConstPattern 表示常量模式节点，常量模式可以是整数字面量、字符字节字面量、浮点数字面量、字符字面量、布尔字面量、字符串字面量等字面量。

一个 ConstPattern 节点：case 1 => 0 中的 1。

init

public init(input: Tokens)

功能：构造 ConstPattern 实例。

参数：

input：将要构造 ConstPattern 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ConstPattern 节点。

prop litConstExpr

public mut prop litConstExpr: LitConstExpr

功能：获取或设置 ConstPattern 节点中的字面量表达式。

返回值：LitConstExpr 类型的字面量表达式节点。

class WildcardPattern

public class WildcardPattern <: Pattern {
    public init()
    public init(input: Tokens)
    public mut prop wildcard: Token
}

WildcardPattern 表示通配符模式节点，使用下划线 _ 表示，可以匹配任意值。通配符模式通常作为最后一个 case 中的模式，用来匹配其他 case 未覆盖到的情况。

init

public init(input: Tokens)

功能：构造 WildcardPattern 实例。

参数：

input：将要构造 WildcardPattern 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 WildcardPattern 节点。

prop wildcard

public mut prop wildcard: Token

功能：获取或设置 WildcardPattern 节点中的 _ 操作符。

返回值：_ 操作符的词法单元。

class VarPattern

public class VarPattern <: Pattern {
    public init()
    public init(input: Tokens)
    public mut prop identifier: Token
}

VarPattern 表示绑定模式节点，使用一个合法的标识符表示，一般适用于声明节点中。

一个节点: case n => 0 中的 n。

init

public init(input: Tokens)

功能：构造 VarPattern 实例。

参数：

input：将要构造 VarPattern 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 VarPattern 节点。

prop identifier

public mut prop identifier: Token

功能：获取或设置 VarPattern 节点中的标识符。

返回值：标识符的词法单元。

class VarOrEnumPattern

public class VarOrEnumPattern <: Pattern {
    public init()
    public init(input: Tokens)
    public mut prop identifier: Token
}

VarOrEnumPattern 表示当模式的标识符为 Enum 构造器时的节点，如 case RED 中的 RED 为 Enum 构造器。

init

public init(input: Tokens)

功能：构造 VarOrEnumPattern 实例。

参数：

input：将要构造 VarOrEnumPattern 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 VarOrEnumPattern 节点。

prop identifier

public mut prop identifier: Token

功能：获取或设置 VarOrEnumPattern 节点中的标识符。

返回值：标识符的词法单元。

class TypePattern

public class TypePattern <: Pattern {
    public init()
    public init(input: Tokens)
    public mut prop pattern: Pattern
    public mut prop colon: Token
    public mut prop patternType: TypeNode
}

TypePattern 表示当类型模式节点。用于判断一个值的运行时类型是否是某个类型的子类型。

一个 TypePattern 节点：case b: Base => 0 中的 b: Base。

init

public init(input: Tokens)

功能：构造 TypePattern 实例。

参数：

input：将要构造 TypePattern 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 TypePattern 节点。

prop pattern

public mut prop pattern: Pattern

功能：获取或设置 TypePattern 节点中的模式。

返回值：一个模式节点。

prop colon

public mut prop colon: Token

功能：获取或设置 TypePattern 节点中的 : 操作符。

返回值：: 操作符的词法单元节点。

prop patternType

public mut prop patternType: TypeNode

功能：获取或设置 TypePattern 节点中的待匹配的模式类型。

返回值：一个类型节点。

class EnumPattern

public class EnumPattern <: Pattern {
    public init()
    public init(input: Tokens)
    public mut prop constructor: Expr
    public mut prop lParen: Token
    public mut prop patterns: ArrayList<Pattern>
    public mut prop rParen: Token
}

EnumPattern 表示当 enum 模式节点。用于匹配 enum 的 constructor。

一个 EnumPattern 节点：case Year(n) => 1 中的 Year(n)。

init

public init(input: Tokens)

功能：构造 EnumPattern 实例。

参数：

input：将要构造 EnumPattern 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 EnumPattern 节点。

prop constructor

public mut prop constructor: Expr

功能：获取或设置 EnumPattern 节点中的构造器。

返回值：一个构造器表达式节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 EnumPattern 节点中的左括号。

返回值：左括号的词法单元。

prop patterns

public mut prop patterns: ArrayList<Pattern>

功能：获取或设置 EnumPattern 节点中有参构造器内的模式节点列表。

返回值：一组模式节点集合。

prop lParen

public mut prop lParen: Token

功能：获取或设置 EnumPattern 节点中的右括号。

返回值：右括号的词法单元。

class TuplePattern

public class TuplePattern <: Pattern {
    public init()
    public init(input: Tokens)
    public mut prop lParen: Token
    public mut prop patterns: ArrayList<Pattern>
    public mut prop rParen: Token
}

TuplePattern 表示当 Tuple 模式节点。用于 tuple 值的匹配。

一个 TuplePattern 节点：case ("Bob", age) => 1 中的 ("Bob", age)

init

public init(input: Tokens)

功能：构造 TuplePattern 实例。

参数：

input：将要构造 TuplePattern 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 TuplePattern 节点。

prop lParen

public mut prop lParen: Token

功能：获取或设置 TuplePattern 节点中的左括号。

返回值：左括号的词法单元。

prop patterns

public mut prop patterns: ArrayList<Pattern>

功能：获取或设置 TuplePattern 节点中的多个 pattern。

返回值：一组 pattern 节点。

prop rParen

public mut prop rParen: Token

功能：获取或设置 TuplePattern 节点中的右括号。

返回值：右括号的词法单元。

class ExceptTypePattern

public class ExceptTypePattern <: Pattern {
    public init()
    public init(input: Tokens)
    public mut prop pattern: Pattern
    public mut prop colon: Token
    public mut prop types: ArrayList<TypeNode>
}

ExceptTypePattern 表示一个用于的异常模式状态下的节点，如： e: Exception1 | Exception2。

init

public init(input: Tokens)

功能：构造 ExceptTypePattern 实例。

参数：

input：将要构造 ExceptTypePattern 类型的词法单元集合 (Tokens)。

异常：

ASTException：输入的 Tokens 类型无法构造为 ExceptTypePattern 节点。

prop pattern

public mut prop pattern: Pattern

功能：获取或设置 ExceptTypePattern 节点中的模式节点。

返回值：一个模式节点。

prop colon

public mut prop colon: Token

功能：获取或设置 ExceptTypePattern 节点中的 : 。

返回值：: 操作符的词法单元。

prop types

public mut prop types: ArrayList<TypeNode>

功能：获取或设置 ExceptTypePattern 节点中有类型列表。

返回值：一组类型节点集合。

interface ToTokens

public interface ToTokens {
    func toTokens(): Tokens
}

功能：实现仓颉基本类型或自定义类型到 Tokens 的转换接口，作为支持quote插值操作必须实现的接口，本库中目前提供以下类型的 ToTokens 扩展 + Token, Tokens + Int64, Int32, Int16, Int8 + UInt64, UInt32, UInt16, UInt8 + Float64, Float32, Float16 + Bool, Char, String

extend Token <: ToTokens

extend Token <: ToTokens

此扩展用于实现 Token 的 toTokens 函数。

extend Tokens <: ToTokens

extend Tokens <: ToTokens

此扩展用于实现 Tokens 的 toTokens 函数。

extend Int64 <: ToTokens

extend Int64 <: ToTokens

此扩展用于实现 Int64 的 toTokens 函数。

extend Int32 <: ToTokens

extend Int32 <: ToTokens

此扩展用于实现 Int32 的 toTokens 函数。

extend Int16 <: ToTokens

extend Int16 <: ToTokens

此扩展用于实现 Int16 的 toTokens 函数。

extend Int8 <: ToTokens

extend Int8 <: ToTokens

此扩展用于实现 Int8 的 toTokens 函数。

extend UInt64 <: ToTokens

extend UInt64 <: ToTokens

此扩展用于实现 UInt64 的 toTokens 函数。

extend UInt32 <: ToTokens

extend UInt32 <: ToTokens

此扩展用于实现 UInt32 的 toTokens 函数。

extend UInt16 <: ToTokens

extend UInt16 <: ToTokens

此扩展用于实现 UInt16 的 toTokens 函数。

extend UInt8 <: ToTokens

extend UInt8 <: ToTokens

此扩展用于实现 UInt8 的 toTokens 函数。

extend Float64 <: ToTokens

extend Float64 <: ToTokens

此扩展用于实现 Float64 的 toTokens 函数。

extend Float32 <: ToTokens

extend Float32 <: ToTokens

此扩展用于实现 Float32 的 toTokens 函数。

extend Float16 <: ToTokens

extend Float16 <: ToTokens

此扩展用于实现 Float16 的 toTokens 函数。

extend Bool <: ToTokens

extend Bool <: ToTokens

此扩展用于实现 Bool 的 toTokens 函数。

extend Char <: ToTokens

extend Char <: ToTokens

此扩展用于实现 Char 的 toTokens 函数。

extend String <: ToTokens

extend String <: ToTokens

此扩展用于实现 String 的 toTokens 函数。

extend ArrayList <: ToTokens

extend ArrayList<T> <: ToTokens

此扩展主要用于实现 ArrayList 的 toTokens 函数, 目前支持的类型有 Decl, Node, Constructor, Argument, FuncParam, MatchCase, Modifier, Annotation, ImportList, Pattern, TypeNode等。

extend Array <: ToTokens

extend Array<T> <: ToTokens

此扩展主要用于实现 Array 的 toTokens 函数，仅支持数值类型，Char 类型，Bool 类型，String 类型等。

class ASTException

public class ASTException <: Exception {
    public init()
    public init(message: String)
}

Ast库的异常类，在ast库调用过程中发生异常时使用。

init

public init()

功能：无参构造函数。

init

public init(message: String)

参数：

message：异常信息

class ParseASTException

public class ParseASTException <: Exception {
    public init()
    public init(message: String)
}

Ast库的解析异常类，在节点解析过程中发生异常时使用。

init

public init()

功能：无参构造函数。

init

public init(message: String)

参数：

message：异常信息

enum TokenKind

public enum TokenKind <: ToString {
    DOT|                      /*  "."           */
    COMMA|                    /*  ","           */
    LPAREN|                   /*  "("           */
    RPAREN|                   /*  ")"           */
    LSQUARE|                  /*  "["           */
    RSQUARE|                  /*  "]"           */
    LCURL|                    /*  "{"           */
    RCURL|                    /*  "}"           */
    EXP|                      /*  "**"          */
    MUL|                      /*  "*"           */
    MOD|                      /*  "%"           */
    DIV|                      /*  "/"           */
    ADD|                      /*  "+"           */
    SUB|                      /*  "-"           */
    INCR|                     /*  "++"          */
    DECR|                     /*  "--"          */
    AND|                      /*  "&&"          */
    OR|                       /*  "||"          */
    COALESCING|               /*  "??"          */
    PIPELINE|                 /*  "|>"          */
    COMPOSITION|              /*  "~>"          */
    NOT|                      /*  "!"           */
    BITAND|                   /*  "&"           */
    BITOR|                    /*  "|"           */
    BITXOR|                   /*  "^"           */
    BITNOT|                   /*  "~"           */
    LSHIFT|                   /*  "<<"          */
    RSHIFT|                   /*  ">>"          */
    COLON|                    /*  ":"           */
    SEMI|                     /*  ";"           */
    ASSIGN|                   /*  "="           */
    ADD_ASSIGN|               /*  "+="          */
    SUB_ASSIGN|               /*  "-="          */
    MUL_ASSIGN|               /*  "*="          */
    EXP_ASSIGN|               /*  "**="         */
    DIV_ASSIGN|               /*  "/="          */
    MOD_ASSIGN|               /*  "%="          */
    AND_ASSIGN|               /*  "&&="         */
    OR_ASSIGN|                /*  "||="         */
    BITAND_ASSIGN|            /*  "&="          */
    BITOR_ASSIGN|             /*  "|="          */
    BITXOR_ASSIGN|            /*  "^="          */
    LSHIFT_ASSIGN|            /*  "<<="         */
    RSHIFT_ASSIGN|            /*  ">>="         */
    ARROW|                    /*  "->"          */
    BACKARROW|                /*  "<-"          */
    DOUBLE_ARROW|             /*  "=>"          */
    RANGEOP|                  /*  ".."          */
    CLOSEDRANGEOP|            /*  "..="         */
    ELLIPSIS|                 /*  "..."         */
    HASH|                     /*  "#"           */
    AT|                       /*  "@"           */
    QUEST|                    /*  "?"           */
    LT|                       /*  "<"           */
    GT|                       /*  ">"           */
    LE|                       /*  "<="          */
    GE|                       /*  ">="          */
    IS|                       /*  "is"          */
    AS|                       /*  "as"          */
    NOTEQ|                    /*  "!="          */
    EQUAL|                    /*  "=="          */
    WILDCARD|                 /*  "_"           */
    INT8|                     /*  "Int8"        */
    INT16|                    /*  "Int16"       */
    INT32|                    /*  "Int32"       */
    INT64|                    /*  "Int64"       */
    INTNATIVE|                /*  "IntNative"   */
    UINT8|                    /*  "UInt8"       */
    UINT16|                   /*  "UInt16"      */
    UINT32|                   /*  "UInt32"      */
    UINT64|                   /*  "UInt64"      */
    UINTNATIVE|               /*  "UIntNative"  */
    FLOAT16|                  /*  "Float16"     */
    FLOAT32|                  /*  "Float32"     */
    FLOAT64|                  /*  "Float64"     */
    CHAR|                     /*  "Char"        */
    BOOLEAN|                  /*  "Bool"        */
    NOTHING|                  /*  "Nothing"     */
    UNIT|                     /*  "Unit"        */
    STRUCT|                   /*  "struct"      */
    ENUM|                     /*  "enum"        */
    CFUNC|                    /*  "CFunc"       */
    VARRAY|                   /*  "VArray"      */
    THISTYPE|                 /*  "This"        */
    PACKAGE|                  /*  "package"     */
    IMPORT|                   /*  "import"      */
    CLASS|                    /*  "class"       */
    INTERFACE|                /*  "interface"   */
    FUNC|                     /*  "func"        */
    MACRO|                    /*  "macro"       */
    QUOTE|                    /*  "quote"       */
    DOLLAR|                   /*  "$"           */
    LET|                      /*  "let"         */
    VAR|                      /*  "var"         */
    CONST|                    /*  "const"       */
    TYPE|                     /*  "type"        */
    INIT|                     /*  "init"        */
    THIS|                     /*  "this"        */
    SUPER|                    /*  "super"       */
    IF|                       /*  "if"          */
    ELSE|                     /*  "else"        */
    CASE|                     /*  "case"        */
    TRY|                      /*  "try"         */
    CATCH|                    /*  "catch"       */
    FINALLY|                  /*  "finally"     */
    FOR|                      /*  "for"         */
    DO|                       /*  "do"          */
    WHILE|                    /*  "while"       */
    THROW|                    /*  "throw"       */
    RETURN|                   /*  "return"      */
    CONTINUE|                 /*  "continue"    */
    BREAK|                    /*  "break"       */
    IN|                       /*  "in"          */
    NOT_IN|                   /*  "!in"         */
    MATCH|                    /*  "match"       */
    FROM|                     /*  "from"        */
    WHERE|                    /*  "where"       */
    EXTEND|                   /*  "extend"      */
    WITH|                     /*  "with"        */
    PROP|                     /*  "prop"        */
    STATIC|                   /*  "static"      */
    PUBLIC|                   /*  "public"      */
    PRIVATE|                  /*  "private"     */
    PROTECTED|                /*  "protected"   */
    OVERRIDE|                 /*  "override"    */
    REDEF|                    /*  "redef"       */
    ABSTRACT|                 /*  "abstract"    */
    SEALED|                   /*  "sealed"      */
    OPEN|                     /*  "open"        */
    FOREIGN|                  /*  "foreign"     */
    INOUT|                    /*  "inout"       */
    MUT|                      /*  "mut"         */
    UNSAFE|                   /*  "unsafe"      */
    OPERATOR|                 /*  "operator"    */
    SPAWN|                    /*  "spawn"       */
    SYNCHRONIZED|             /*  "synchronized */
    UPPERBOUND|               /*  "<:"          */
    MAIN|                     /*  "main"        */
    IDENTIFIER|               /*  "x"           */
    INTEGER_LITERAL|          /*  e.g. "1"      */
    CHAR_BYTE_LITERAL|        /*  e.g. "b'x'"   */
    FLOAT_LITERAL|            /*  e.g. "'1.0'"  */
    COMMENT|                  /*  e.g. "/*xx*/" */
    NL|                       /*  newline         */
    END|                      /*  end of file     */
    SENTINEL|                 /*  ";"             */
    CHAR_LITERAL|             /*  e.g. "'x'"      */
    STRING_LITERAL|           /*  e.g. ""xx""     */
    JSTRING_LITERAL|          /*  e.g. "J"xx""     */
    BYTE_STRING_ARRAY_LITERAL /*  e.g. "b"xx""       */
    MULTILINE_STRING|         /*  e.g. """"aaa""""   */
    MULTILINE_RAW_STRING|     /*  e.g. "#"aaa"#"     */
    BOOL_LITERAL|             /*  "true" or "false"  */
    UNIT_LITERAL|             /*  "()"               */
    DOLLAR_IDENTIFIER|        /*  e.g. "$x"          */
    ANNOTATION|               /*  e.g. "@When"       */
    ILLEGAL

    public operator func ==(right: TokenKind): Bool
    public operator func !=(right: TokenKind): Bool
    public func toString(): String
}

枚举类型 TokenKind 内部的构造器列举了仓颉编译内部所有的词法结构，包括符号、关键字、标识符、换行等。

operator func ==

public operator func == (r: Position): Bool

功能：重载等号操作符，用于比较两个 TokenKind 是否相等。

返回值：布尔类型。

operator func !=

public operator func != (r: Position): Bool

功能：重载不等号操作符，用于比较两个 TokenKind 是否相等。

返回值：布尔类型。

func toString

public func toString(): String

功能：将 TokenKind 类型转化为字符串类型表示。

返回值：String 类型的字面量值。

func getTokenKind

public func getTokenKind(no: UInt16): TokenKind

功能：将词法单元种类序号转化为 TokenKind。

参数：

no：需要转换的 UInt16 序号

class TokensIterator

public class TokensIterator <: Iterator<Token> {
    public init(tokens: Tokens)
    public func peek(): Option<Token>
    public func seeing(kind: TokenKind): Bool
    public func next(): Option<Token>
    public func iterator(): Iterator<Token>
}

此类主要实现 Tokens 的迭代器功能。

init

public init(tokens: Tokens)

功能：创建 TokensIterator 实例。

参数：

tokens：传入 Tokens

func peek

public func peek(): Option<Token>

功能：获取迭代器中的当前值。

返回值：返回 Option<Token> 类型，当遍历结束后，返回 None

func seeing

public func seeing(kind: TokenKind): Bool

功能：判断当前节点的 Token 类型是否是传入的类型。

参数：

kind：需要判断的 TokenKind 类型

返回值：如果当前节点的 TokenKind 与传入类型相同，返回 true，否则返回 false

func next

public func next(): Option<Token>

功能：获取迭代器中的下一个值。

返回值：返回 Option<Token> 类型，当遍历结束后，返回 None

func iterator

public func iterator(): Iterator<Token>

功能：获取当前迭代器实例。

返回值：当前迭代器实例

func compareTokens

public func compareTokens(tokens1: Tokens, tokens2: Tokens): Bool

功能：用于比较两个Tokens是否一致

参数：

tokens1：需要比较的第一个 Tokens
tokens2：需要比较的第二个 Tokens

返回值：如果两个 Tokens 内容相同（除了换行符、结束符和位置信息）则返回 true

总结：仓颉 AST 包提供了丰富的语法树节点用于表示仓颉源码。由于节点种类丰富、不同节点间属性不同，使用过程可能会发生混淆不清的情况，为此我们为每个 AST 节点实现了 dump 函数（具体见 [func dump] 章节）方便实时查看语法树节点的整体结构，避免重复查看该手册带来的困扰。

仓颉源码解析函数

仓颉 ast 包提供语法解析函数可将仓颉源码的词法单元 (Tokens) 解析为 AST 节点对象。

func cangjieLex

public func cangjieLex(code: String): Tokens

功能：将字符串转换为 Tokens 类型。

参数：

code: 待词法解析的字符串。

返回值：词法解析得到的 Tokens。

异常：

IllegalMemoryException：申请内存失败，抛出异常。
IllegalArgumentException：输入的 code 无法被正确的解析为 Tokens 抛出异常。

func parseProgram

public func parseProgram(input: Tokens): Program

功能：用于解析单个仓颉文件的源码，获取一个 Program 类型的节点。

参数：

input: 待解析源码的词法单元（Tokens）。

返回值：一个 Program 类型的节点。

异常：

ParseASTException：输入的 Tokens 类型无法构造为 Program 节点。

func parseDecl

public func parseDecl(input: Tokens, astKind !: String = ""): Decl

功能：用于解析一组词法单元，获取一个 Decl 类型的节点。

参数：

input: 待解析源码的词法单元（Tokens）。
astKind: 用于指定解析特定的节点类型，有效支持的值为：PrimaryCtorDecl 和 PropMemberDecl。

返回值：一个 Decl 类型的节点。

异常：

ParseASTException：输入的 Tokens 类型无法构造为 Decl 节点。

func parseDeclFragment

public func parseDeclFragment(input: Tokens, startFrom !: Int64 = 0): (Decl, Int64)

功能：用于解析一组词法单元，获取一个 Decl 类型的节点和继续解析节点的索引。

参数：

input: 待解析源码的词法单元（Tokens）。
startFrom: 起始位置

返回值：语法树节点，继续解析的位置。

异常：

ParseASTException：输入的 Tokens 类型无法构造为 Decl 节点。

func parseExpr

public func parseExpr(input: Tokens): Expr

功能：用于解析一组词法单元，获取一个 Expr 类型的节点。

参数：

input: 待解析源码的词法单元（Tokens）。

返回值：一个 Expr 类型的节点。

异常：

ParseASTException：输入的 Tokens 类型无法构造为 Expr 节点。

func parseExprFragment

public func parseExprFragment(input: Tokens, startFrom !: Int64 = 0): (Expr, Int64)

功能：用于解析一组词法单元，获取一个 Expr 类型的节点和继续解析节点的索引。

参数：

input: 待解析源码的词法单元（Tokens）。
startFrom: 起始位置

返回值：语法树节点，继续解析的位置。

异常：

ParseASTException：输入的 Tokens 类型无法构造为 Expr 节点。

Visitor

public open abstract class Visitor {
    public func breakTraverse(): Unit
    open protected func visit(_: Node): Unit
    open protected func visit(_: Expr) : Unit
    open protected func visit(_: Program): Unit
    open protected func visit(_: PackageHeader): Unit
    open protected func visit(_: Argument): Unit
    open protected func visit(_: Annotation): Unit
    open protected func visit(_: Modifier): Unit
    ...
}

Visitor 是一个抽象类，其内部默认定义了访问不同类型 AST 节点访问（visit）函数，visit 函数搭配 traverse 一起使用，可实现对节点的访问和修改, 所有 visit 函数都有默认为空的实现，可以按需实现需要的 visit 方法。该类需要被继承使用，并允许子类重新定义访问函数。

func breakTraverse

public func breakTraverse(): Unit

功能：用于重写 visit 函数中，通过调用该函数来终止继续遍历子节点的行为。

使用示例

将仓颉源码解析为 AST 对象示例

如下有一个类 Data，它的代码如下:

class Data {
    var a: Int32
    init(a_: Int32) {
        a = a_
    }
}

利用解析函数将上述代码解析为一个 Decl 对象，代码如下所示：

from std import ast.*
main() {
    let input: Tokens = quote(
        class Data {
            var a: Int32
            init(a_: Int32) {
                a = a_
            }
        }
    )
    let decl = parseDecl(input) // 获取一个 Decl 声明节点
    var classDecl = match (decl as ClassDecl) { // decl 的具体类型为 ClassDecl, 将其进行类型转化。
        case Some(v) => v
        case None => throw Exception()
    }
    0
}

操作 AST 对象示例

获取 ClassDecl 类型的节点后，可以对该节点进行增、删、改、查等操作。代码如下所示：

from std import ast.*
main() {
    let input: Tokens = quote(
        class Data {
            var a: Int32
            init(a_: Int32) {
                a = a_
            }
        }
    )
    let decl = parseDecl(input) // 获取一个 Decl 声明节点
    var classDecl = match (decl as ClassDecl) { // decl 的具体类型为 ClassDecl, 将其进行类型转化。
        case Some(v) => v
        case None => throw Exception()
    }
    var identifier = classDecl.identifier
    // 为该节点增加一个成员函数用于获取a的值
    var funcdecl = FuncDecl(quote(func getValue() {a}))
    classDecl.body.decls.append(funcdecl)
    println("Identifier value is ${identifier.value}")
    println("ClassDecl body size is ${classDecl.body.decls.size}")
    0
}

运行结果：

Identifier value is Data
ClassDecl body size is 3

自定义访问函数遍历 AST 对象示例

定义访问变量声明节点的行为：继承 Visitor 并重写访问函数，找到未定义变量，将他的变量词法单元存起来。

class MyVisitor <: Visitor {
    public var unitializedVars = Tokens() // 存储变量词法单元
    override public func visit(varDecl: VarDecl) {
        match (varDecl.expr) {
            case Some(s) => ()
            case None => unitializedVars.append(varDecl.identifier)
        }
        breakTraverse() // 不会继续遍历 varDecl 的子节点
        return
    }
}

main(): Int64 {
    let input = quote(
        var a : Int64
    )
    let varDecl = parseDecl(input)
    let visitor = MyVisitor() /* MyVisitor中定义了对 varDecl 节点的处理*/
    varDecl.traverse(visitor) /* 实现对 varDecl 节点的处理 */
    println("Unitialized VarDecl size is {visitor.unitializedVars.size}")
    0
}

运行结果：

Unitialized VarDecl size is 1

Macro With Context

仓颉 ast 包提供了 Macro With Context 的相关函数，用于在宏展开时可以获取展开过程中的上下文相关信息。

在嵌套宏场景下，内层宏可以调用库函数 AssertParentContext 来保证内层宏调用一定嵌套在特定的外层宏调用中。如果内层宏调用这个函数时没有嵌套在给定的外层宏调用中，该函数将抛出一个错误。同时，函数 InsideParentContext 也用于检查内层宏调用是否嵌套在特定的外层宏调用，但是返回一个布尔值。

func AssertParentContext

public func AssertParentContext(parentMacroName: String): Unit

功能：检查当前宏调用是否在特定的宏调用内;若检查不符合预期，编译器出现一个错误提示。

参数：

parentMacroName: 待检查的外层宏调用的名字。

func InsideParentContext

public func InsideParentContext(parentMacroName: String): Bool

功能：检查当前宏调用是否在特定的宏调用内，返回一个布尔值。

参数：

parentMacroName: 待检查的外层宏调用的名字。

返回值：若当前宏嵌套在特定的宏调用内，返回 true。

在嵌套宏场景下，内层宏也可以通过发送键/值对的方式与外层宏通信。当内层宏执行时，通过调用标准库函数 SetItem 向外层宏发送信息；随后，当外层宏执行时，调用标准库函数 GetChildMessages 接收每一个内层宏发送的信息（一组键/值对映射）。

func SetItem

public func SetItem(key:String, value:String)：Unit

功能：内层宏通过该接口发送 string 类型的信息到外层宏。

参数：

key: 发送的关键字，用于检索信息。
value: 要发送的 String 类型的信息。

func SetItem

public func SetItem(key:String, value:Int64)：Unit

功能：内层宏通过该接口发送 Int64 类型的信息到外层宏。

参数：

key: 发送的关键字，用于检索信息。
value: 要发送的 Int64 类型的信息。

func SetItem

public func SetItem(key:String, value:Bool)：Unit

功能：内层宏通过该接口发送 Bool 类型的信息到外层宏。

参数：

key: 发送的关键字，用于检索信息。
value: 要发送的 Bool 类型的信息。

class MacroMessage

public class MacroMessage {
    public func hasItem(key: String): Bool
    public func getString(key: String): String
    public func getInt64(key: String): Int64
    public func getBool(key: String):Bool
}

func hasItem

public func hasItem(key:String): Bool

功能：检查是否有 key 值对应的相关信息。

参数：

key: 用于检索的关键字名字。

返回值：若存在 key 值对应的相关信息，返回 true。

func getString

public func getString(key:String): String

功能：获取对应 key 值的 String 类型信息。

参数：

key: 用于检索的关键字的名字。

返回值：返回存在 key 值对应的 String 类型的信息。

异常：

不存在 key 值对应的 String 类型的信息。

func getInt64

public func getInt64(key:String): Int64

功能：获取对应 key 值的 Int64 类型信息。

参数：

key: 用于检索的关键字的名字。

返回值：返回存在 key 值对应的 Int64 类型的信息。

异常：

不存在 key 值对应的 Int64 类型的信息。

func getBool

public func getBool(key:String): Bool

功能：获取对应 key 值的 Bool 类型信息。

参数：

key: 用于检索的关键字的名字。

返回值：返回存在 key 值对应的 Bool 类型的信息。

异常：

不存在 key 值对应的 Bool 类型的信息。

func GetChildMessages

public func GetChildMessages(children:String): ArrayList<MacroMessage>

功能：获取特定内层宏发送的信息。

参数：

children: 待接收信息的内层宏名称。

返回值：返回一组 MacroMessage 的对象。

需要注意的是， Macro With Context 的相关函数只能作为函数被直接调用，不能作为赋值给变量，不能作为实参或返回值使用。

示例

宏定义如下：

public macro Outter(input: Tokens): Tokens {
    return input
}

public macro Inner(input: Tokens): Tokens {
    AssertParentContext("Outter")
    return input
}

宏调用如下：

@Outter var a = 0
@Inner var b = 0 // error: The macro call 'Inner' should with the surround code contains a call 'Outer'.

如上代码所示，Inner 宏在定义时使用了 AssertParentContext 函数用于检查其在调用阶段是否位于 Outter 宏中，在代码示例的宏调用场景下，由于 Outter 和 Inner 在调用时不存在这样的嵌套关系，因此编译器将报告一个错误。

宏定义如下：

public macro Outter(input: Tokens): Tokens {
    let messages = GetChildMessages("Inner")
    for (m in messages) {
        let value1 = m.getString("key1") // get value: "value1"
        let value2 = m.getString("key2") // get value: "value2"
    }
    return input
}

public macro Inner(input: Tokens): Tokens {
    AssertParentContext("Outer")
    SetItem("key1", "value1")
    SetItem("key2", "value2")
    return input
}

宏调用如下：

@Outter(
    @Inner var cnt = 0
)

在上面的代码中，内层宏 Inner 通过 SetItem 向外层宏发送信息；Outter 宏通过 GetChildMessages 函数接收到 Inner 发送的一组信息对象（Outter 中可以调用多次 Inner）；最后通过该信息对象的 getString 函数接收对应的值。

自定义报错接口

仓颉 ast 包提供了自定义报错接口。方便定义宏的用户，在解析传入tokens时，对错误tokens内容进行自定义报错。

自定义报错接口提供同原生编译器报错一样的输出格式，允许用户报 warning 和 error 两类错误提示信息。

enum DiagReportLevel

public enum DiagReportLevel {
    | ERROR | WARNING
 
    public func level(): Int32
}

该枚举表示报错接口的信息等级。

func level

public func level(): Int32

功能：返回枚举值对应的整型。ERROR 返回 1，WARNING 返回 2。

返回值：枚举值对应的整型

func diagReport

public func diagReport(level: DiagReportLevel, tokens: Tokens, message: String, hint: String): Unit

功能：报错接口，在编译过程的宏展开阶段输出错误提示信息，支持 WARNING 和 ERROR 两个等级的报错。注意该接口在错误等级为 ERROR 时会终止编译过程，但不会终止宏展开过程，建议用户调用接口后直接 return 或者抛出异常来终止宏展开过程。

参数：

level: 报错信息等级
tokens: 报错信息中所引用源码内容对应的 tokens
message: 报错的主信息
hint: 辅助提示信息

异常：

ASTException: 当输入的 tokens 存在以下错误时抛出异常
1. 输入的 tokens 为空
1. 输入的 tokens 中的 token 来自于不同的源文件
1. 输入的 tokens 中首位 token 位置早于末位 token 位置
1. 输入的 tokens 中的 token 位置范围超出了宏调用的位置范围

特殊说明：

该接口会按照 cjc 标准报错的接口，将传入的 tokens 所在行的代码列出，并对 tokens 的内容用波浪线进行标注， message 信息将展示在首行， hint 信息将紧跟波浪线进行展示
报错引用的源码内容目前仅依据第一个 token 的开始位置和最后一个 token 的结束位置确定，不校验中间 token 位置信息的一致性
该接口目前不支持在非宏函数中进行调用，参见下面代码示例

示例

正确使用示例

宏定义文件

// macro_definition.cj
macro package macro_definition
 
from std import ast.*
 
public macro TestDef(input: Tokens): Tokens {
    for (i in 0..input.size) {
        if (input[i].kind == IDENTIFIER) {
            diagReport(DiagReportLevel.ERROR, input[i..(i + 1)], "This expression is not allowed to contain identifier",   "Here is the illegal identifier")
        }
    }
    return input
}

执行文件

// macro_call.cj
package macro_calling
 
from std import ast.*
import macro_definition.*
 
main(): Int64 {
    let a = @TestDef(1)
    let b = @TestDef(a)
    let c = @TestDef(1 + a)
    return 0
}

报错提示信息如下

error: This expression is not allowed to contain identifier
 ==> call.cj:9:22:
  |
9 |     let b = @TestDef(a)
  |                      ^ Here is the illegal identifier
  |
 
error: This expression is not allowed to contain identifier
  ==> call.cj:10:26:
   |
10 |     let c = @TestDef(1 + a)
   |                          ^ Here is the illegal identifier
   |

2 errors generated, 2 errors printed.

在非宏函数中调用

// macro_definition.cj
macro package macro_definition
 
from std import ast.*

func A(input: Tokens) {
    diagReport(DiagReportLevel.ERROR, input, ...)  // 该调用处在普通函数 A 中，diagReport 实际不会执行任何操作
}

public macro M(input: Tokens): Tokens {
    A(input)
}

仓颉用户手册