Tree-sitter Rust Grammar for Python

Warnings

• breaking The `Language.build_library()` method, used for compiling Tree-sitter grammars from source at runtime, was removed from the `tree-sitter` Python library (formerly `py-tree-sitter`) around version 0.22. This means on-the-fly grammar compilation is no longer directly supported by the Python bindings.
  Fix: For pre-packaged grammars like `tree-sitter-rust`, use `pip install` which provides pre-compiled binaries. For custom grammars, compile them manually to a `.so` (or `.dll`/`.dylib`) file using the `tree-sitter` CLI tool and load with `tree_sitter.Language('/path/to/grammar.so', 'grammar_name')`.
• gotcha The `tree-sitter-rust` package provides only the Rust grammar definition; it relies on the core `tree-sitter` Python library for the parser engine itself. Forgetting to install `tree-sitter` will lead to `ModuleNotFoundError` or `RuntimeError` when attempting to use the parser.
  Fix: Ensure both `tree-sitter` and `tree-sitter-rust` are installed: `pip install tree-sitter tree-sitter-rust`.
• gotcha The `parser.parse()` method expects a `bytes` object as input for the source code, not a `str`. Passing a Python string directly will result in a `TypeError`.
  Fix: Encode the input string to bytes, typically using UTF-8: `parser.parse(bytes(code_string, 'utf8'))`.
• gotcha Incompatibilities between the `tree-sitter` core library version and the `tree-sitter-rust` grammar version can lead to runtime errors or incorrect parsing, especially if mixing installation methods or manually compiling grammars.
  Fix: Always install both `tree-sitter` and `tree-sitter-rust` via `pip` to ensure compatible pre-compiled versions are used. If issues persist, try updating both: `pip install --upgrade tree-sitter tree-sitter-rust`.

Install

• pip install tree-sitter tree-sitter-rust Install core library and Rust grammar

Imports

• language

  from tree_sitter_rust import language

  The `tree-sitter-rust` package exposes a `language` callable (which returns the `LanguageFn` object), not a `Language` class directly. This callable is then passed to `tree_sitter.Language()` to initialize the grammar for the parser.

Quickstart

This quickstart demonstrates how to initialize a Tree-sitter parser with the Rust grammar, parse a simple Rust code snippet, and then inspect the resulting syntax tree's root node and traverse its structure.

import tree_sitter
from tree_sitter import Language, Parser
from tree_sitter_rust import language

# Example Rust code to parse
rust_code = '''
fn main() {
    let message = "Hello, world!";
    println!("{}", message);
}
'''

# 1. Load the Rust language grammar
# The `language` object imported is a callable that returns the actual LanguageFn.
RUST_LANGUAGE = Language(language())

# 2. Create a parser and set its language
parser = Parser()
parser.set_language(RUST_LANGUAGE)

# 3. Parse the code (input must be bytes)
tree = parser.parse(bytes(rust_code, "utf8"))

# 4. Get the root node of the syntax tree
root_node = tree.root_node

print(f"Root node type: {root_node.type}")
print(f"Root node text: {root_node.text}")
print(f"Tree S-expression: {root_node.sexp()}")

# Example of traversing the tree
print("\nWalking the tree nodes:")
cursor = tree.walk()

# Start at the root
def traverse(cursor, indent=0):
    print("  " * indent + f"Node: {cursor.node.type} [start: {cursor.node.start_point}, end: {cursor.node.end_point}]")
    if cursor.goto_first_child():
        traverse(cursor, indent + 1)
        while cursor.goto_next_sibling():
            traverse(cursor, indent + 1)
        cursor.goto_parent() # Go back up after visiting all siblings

traverse(cursor)