12 个版本

0.4.2 2024 年 4 月 19 日
0.4.1 2023 年 11 月 5 日
0.3.4 2023 年 6 月 11 日
0.3.2 2023 年 3 月 27 日
0.1.2 2022 年 8 月 23 日

#2537开发工具

Download history 991/week @ 2024-04-28 957/week @ 2024-05-05 1415/week @ 2024-05-12 1426/week @ 2024-05-19 1335/week @ 2024-05-26 2347/week @ 2024-06-02 1611/week @ 2024-06-09 1760/week @ 2024-06-16 2646/week @ 2024-06-23 1250/week @ 2024-06-30 1518/week @ 2024-07-07 2233/week @ 2024-07-14 1683/week @ 2024-07-21 1778/week @ 2024-07-28 1499/week @ 2024-08-04 2246/week @ 2024-08-11

7,380 每月下载量
5 个包中使用(通过 rust-sitter

MIT 许可证

56KB
825

Rust Sitter

Crates.io

Rust Sitter 通过利用 Tree Sitter 解析器生成器,使在 Rust 中创建高效的解析器变得简单。使用 Rust Sitter,您可以使用 Rust 代码的注释来定义整个语法,并由宏为您生成解析器和类型安全的绑定!

安装

首先,将 Rust/Tree Sitter 添加到您的 Cargo.toml

[dependencies]
rust-sitter = "0.4.2"

[build-dependencies]
rust-sitter-tool = "0.4.2"

注意:默认情况下,Rust Sitter 使用 Tree Sitter 的一个纯 Rust 运行时分支来支持 wasm32-unknown-unknown。要使用标准的 C 运行时,请禁用默认功能并启用 tree-sitter-standard 功能

第一步是配置您的 build.rs 以编译和链接生成的 Tree Sitter 解析器

use std::path::PathBuf;

fn main() {
    println!("cargo:rerun-if-changed=src");
    rust_sitter_tool::build_parsers(&PathBuf::from("src/main.rs"));
}

定义语法

现在我们已经将 Rust Sitter 添加到项目中,我们可以定义我们的语法。Rust Sitter 语法定义在注解的 Rust 模块中。首先,我们定义将包含我们语法的模块

#[rust_sitter::grammar("arithmetic")]
mod grammar {

}

然后,在模块内部,我们可以定义单个 AST 节点。在这个简单的示例中,我们将定义一个可以用于数学表达式的表达式。请注意,我们将此类型注释为 #[rust_sitter::language] 以指示它是根 AST 类型。

#[rust_sitter::language]
pub enum Expr {
    Number(u32),
    Add(Box<Expr>, Box<Expr>)
}

现在我们已经定义了类型,我们必须注释枚举变体来描述如何在解析的文本中识别它们。首先,我们可以应用 rust_sitter::leaf 来使用正则表达式匹配对应于数字的数字,并定义一个将结果字符串解析为 u32 的转换。

Number(
    #[rust_sitter::leaf(pattern = r"\d+", transform = |v| v.parse().unwrap())]
    u32,
)

对于Add变体,事情要复杂一些。首先,我们需要添加一个与+相对应的额外字段,该字段必须位于两个子表达式之间。这可以通过使用text参数实现,该参数属于rust_sitter::leaf,它指示解析器匹配特定的字符串。由于我们将解析为(),因此我们不需要提供转换。

Add(
    Box<Expr>,
    #[rust_sitter::leaf(text = "+")] (),
    Box<Expr>,
)

然而,如果我们尝试编译此语法,则会因为表达式(如1 + 2 + 3)存在冲突的解析树而出现错误,这些表达式可以解析为(1 + 2) + 31 + (2 + 3)。我们希望前者,因此可以添加进一步注解指定我们希望此规则具有左结合性。

#[rust_sitter::prec_left(1)]
Add(
    Box<Expr>,
    #[rust_sitter::leaf(text = "+")] (),
    Box<Expr>,
)

综合来看,我们的语法如下

#[rust_sitter::grammar("arithmetic")]
mod grammar {
    #[rust_sitter::language]
    pub enum Expr {
        Number(
            #[rust_sitter::leaf(pattern = r"\d+", transform = |v| v.parse().unwrap())]
            u32,
        ),
        #[rust_sitter::prec_left(1)]
        Add(
            Box<Expr>,
            #[rust_sitter::leaf(text = "+")] (),
            Box<Expr>,
        )
    }
}

然后我们可以使用此语法解析文本

dbg!(grammar::parse("1+2+3"));
/*
grammar::parse("1+2+3") = Ok(Add(
    Add(
        Number(
            1,
        ),
        (),
        Number(
            2,
        ),
    ),
    (),
    Number(
        3,
    ),
))
*/

类型注解

Rust Sitter支持一系列可以应用于你的语法中的类型和字段的注解。这些注解可以用来控制解析器的行为,以及如何构建生成的AST。

#[rust_sitter::语言]

此注解标记了解析的入口点,并确定解析后将返回哪种AST类型。语法中只能标记一种类型作为入口点。

#[rust_sitter::language]
struct Code {
    ...
}

#[rust_sitter::extra]

此注解标记一个节点为额外节点,在解析时可以安全地跳过。这对于处理空白符/换行符/注释非常有用。

#[rust_sitter::extra]
struct Whitespace {
    #[rust_sitter::leaf(pattern = r"\s")]
    _whitespace: (),
}

字段注解

#[rust_sitter::leaf(...)]

可以使用#[rust_sitter::leaf(...)]注解来定义AST中的叶子节点。此注解接受多个参数,用于控制解析器的行为

  • pattern参数接受一个正则表达式,用于匹配叶子节点的文本。此参数是必需的。
  • text参数接受一个用于匹配叶子节点文本的字符串。此参数与pattern参数互斥。
  • transform参数接受一个函数,用于将匹配的文本(一个&str)转换为所需类型。如果目标类型是(),则此参数是可选的。

leaf可以应用于结构体/枚举变体中的字段(如上所示),或者直接应用于没有字段的类型

#[rust_sitter::leaf(text = "9")]
struct BigDigit;

enum SmallDigit {
    #[rust_sitter::leaf(text = "0")]
    Zero,
    #[rust_sitter::leaf(text = "1")]
    One,
}

#[rust_sitter::prec(...)] / #[rust_sitter::prec_left(...)] / #[rust_sitter::prec_right(...)]

此注释可用于定义非左/右结合的运算符。此注释接受一个参数,即运算符的优先级(优先级越高,绑定越紧密)。

#[rust_sitter::跳过(...)]

此注释可用于定义一个不对应输入字符串中任何内容的字段,例如一些元数据。此注释接受一个参数,即在运行时用于填充该字段的价值。

#[rust_sitter::单词]

此注释将字段标记为 Tree Sitter 单词,这在处理涉及关键字错误的场景中很有用。语法中只有一个字段可以标记为单词。

特殊类型

Rust Sitter 几种特殊类型,可用于定义更复杂的语法。

Vec<T>

要解析重复的结构,可以使用 Vec<T> 解析 T 的列表。请注意,Vec<T> 类型 不能 包裹在另一个 Vec 中(如果需要,创建额外的结构)。一个 Vec 字段有两个特殊属性可以应用,用于控制解析行为。

#[rust_sitter::delimited(...)] 属性可用于指定列表元素之间的分隔符,并接受与匿名字段相同格式的参数。例如,我们可以定义一个解析逗号分隔表达式列表的语法

pub struct CommaSeparatedExprs {
    #[rust_sitter::delimited(
        #[rust_sitter::leaf(text = ",")]
        ()
    )]
    numbers: Vec<Expr>,
}

#[rust_sitter::repeat(...)] 属性可用于指定解析器的额外配置。目前,只有一个可用的参数:non_empty,它接受一个布尔值,指定列表是否必须至少包含一个元素。例如,我们可以定义一个解析非空逗号分隔数字列表的语法

pub struct CommaSeparatedExprs {
    #[rust_sitter::repeat(non_empty = true)]
    #[rust_sitter::delimited(
        #[rust_sitter::leaf(text = ",")]
        ()
    )]
    numbers: Vec<Expr>,
}

Option<T>

为了解析可选结构,您可以使用一个 Option<T> 来解析单个 T 或无内容。类似于 VecOption<T> 类型 不能 被另一个 Option 包裹(如果需要,请创建额外的结构)。例如,我们可以使前一个示例中的列表元素为可选,以便可以解析如 1,,2 这样的字符串

pub struct CommaSeparatedExprs {
    #[rust_sitter::repeat(non_empty = true)]
    #[rust_sitter::delimited(
        #[rust_sitter::leaf(text = ",")]
        ()
    )]
    numbers: Vec<Option<Expr>>,
}

rust_sitter::跨越<T>

当使用 Rust Sitter 为诊断工具提供动力时,访问标记与解析节点对应的文本部分的跨度可能很有帮助。为此,您可以使用 Spanned<T> 类型,该类型捕获了底层的解析 T 和对应子字符串的开始(包含)和结束(不包含)的索引对。Spanned 类型可以在任何地方使用,并且不影响解析逻辑。例如,我们可以捕获我们之前的示例中表达式的跨度

pub struct CommaSeparatedExprs {
    #[rust_sitter::repeat(non_empty = true)]
    #[rust_sitter::delimited(
        #[rust_sitter::leaf(text = ",")]
        ()
    )]
    numbers: Vec<Option<Spanned<Expr>>>,
}

盒子<T>

在解析时,会自动在内部类型周围构造盒子,但 Rust Sitter 除此之外不做任何额外操作。

依赖关系

~1.5MB
~35K SLoC