100 lines
2.6 KiB
Markdown
100 lines
2.6 KiB
Markdown
Rust Tree-sitter
|
|
===========================
|
|
|
|
[](https://travis-ci.org/tree-sitter/rust-tree-sitter)
|
|
[](https://ci.appveyor.com/project/maxbrunsfeld/rust-tree-sitter/branch/master)
|
|
[](https://crates.io/crates/tree-sitter)
|
|
|
|
Rust bindings to the [Tree-sitter][] parsing library.
|
|
|
|
### Basic Usage
|
|
|
|
First, create a parser:
|
|
|
|
```rust
|
|
let parser = Parser::new();
|
|
```
|
|
|
|
Then assign a language to the parser. Tree-sitter languages consist of generated C code. To use them from rust, you must declare them as `extern "C"` functions and invoke them with `unsafe`:
|
|
|
|
```rust
|
|
extern "C" fn tree_sitter_c() -> Language;
|
|
extern "C" fn tree_sitter_rust() -> Language;
|
|
extern "C" fn tree_sitter_javascript() -> Language;
|
|
|
|
parser.set_language(unsafe { tree_sitter_rust() }).unwrap();
|
|
```
|
|
|
|
Now you can parse source code:
|
|
|
|
```rust
|
|
let source_code = "fn test() {}";
|
|
|
|
let tree = parser.parse_str(source_code, None);
|
|
let root_node = tree.root_node();
|
|
assert_eq!(root_node.kind(), "source_file");
|
|
assert_eq!(root_node.start_position().column, 0);
|
|
assert_eq!(root_node.end_position().column, 12);
|
|
```
|
|
|
|
### Editing
|
|
|
|
Once you have a syntax tree, you can update it when your source code changes:
|
|
|
|
```rust
|
|
let new_source_code = "fn test(a: u32) {}"
|
|
|
|
tree.edit(InputEdit {
|
|
start_byte: 8,
|
|
old_end_byte: 8,
|
|
new_end_byte: 14,
|
|
start_position: Point::new(0, 8),
|
|
old_end_position: Point::new(0, 8),
|
|
new_end_position: Point::new(0, 14),
|
|
});
|
|
let new_tree = parser.parse_str(new_source_code, Some(&tree));
|
|
```
|
|
|
|
### Text Input
|
|
|
|
|
|
The code can be provided either as a simple string or by any type that implements Tree-sitter's `Utf8Input` or `Utf16Input` traits:
|
|
|
|
```rust
|
|
struct LineWiseInput {
|
|
lines: &'static [&'static str],
|
|
row: usize,
|
|
column: usize,
|
|
}
|
|
|
|
impl tree_sitter::Utf8Input for LineWiseInput {
|
|
fn read(&mut self) -> &[u8] {
|
|
if self.row < self.lines.len() {
|
|
let result = &self.lines[self.row].as_bytes()[self.column..];
|
|
self.row += 1;
|
|
self.column = 0;
|
|
result
|
|
} else {
|
|
&[]
|
|
}
|
|
}
|
|
|
|
fn seek(&mut self, _byte: u32, position: Point) {
|
|
self.row = position.row as usize;
|
|
self.column = position.column as usize;
|
|
}
|
|
}
|
|
|
|
let mut input = LineBasedInput {
|
|
lines: &[
|
|
"pub fn main() {",
|
|
"}",
|
|
],
|
|
row: 0,
|
|
column: 0
|
|
};
|
|
|
|
let tree = parser.parse_utf8(&mut input, None).unwrap();
|
|
```
|
|
|
|
[tree-sitter]: https://github.com/tree-sitter/tree-sitter
|