tree-sitter-rust

tree-sitter-rust is the official Rust language grammar for tree-sitter, the incremental parsing library used by editors and developer tools to build concrete syntax trees. It defines Rust’s syntax (traits, generics, macros, lifetimes, pattern matching) in a declarative grammar that compiles to a generated C parser plus bindings for Rust, Node.js, Python, Go, and Swift.

Editors, linters, and static-analysis tools consume this grammar to parse Rust source incrementally and error-tolerantly, powering syntax highlighting, code folding, and structural navigation without invoking rustc.

What You Get

• A complete, actively maintained Rust grammar covering traits, generics, macros, lifetimes, and async syntax
• A generated, dependency-free C parser (parser.c) compiled from the grammar for use in any host language
• Official bindings for Rust, Go, Node.js, Python, and Swift for embedding the grammar directly in tooling
• Highlight and tag queries (queries/highlights.scm) mapping syntax nodes to editor highlighting categories
• A corpus of test fixtures (test/corpus) validating grammar correctness against real Rust code samples

Common Use Cases

• Editor syntax highlighting - power tree-sitter-based highlighting for Rust files in editors like Neovim, Helix, and Zed
• Code navigation tooling - build ‘jump to definition’ and structural outlines by querying the parsed Rust syntax tree
• Static analysis and linters - traverse the concrete syntax tree to implement custom Rust lint rules without invoking rustc
• Language server implementations - use the grammar as the incremental parsing layer underneath a Rust LSP server

Under The Hood

Architecture - The grammar is authored in grammar.js as a JavaScript DSL describing Rust’s syntax rules (items, expressions, patterns, macros, lifetimes). The tree-sitter CLI compiles this into a generated, table-driven src/parser.c, with src/node-types.json describing the resulting AST node schema; a small external scanner handles a few lexical edge cases (like raw strings) that the declarative grammar can’t express directly.

Tech Stack - The grammar source is JavaScript, but the shipped artifact is generated C code with zero runtime dependencies beyond tree-sitter-language; the repo ships first-class bindings for Rust (Cargo.toml), Go (go.mod), Node.js (package.json, binding.gyp), Python (pyproject.toml, setup.py), and Swift (Package.swift).

Code Quality - Correctness is validated through a test/corpus directory of annotated Rust snippets paired with expected parse trees; CI runs across the various language bindings before each Cargo/npm/PyPI release, keeping the grammar current as Rust language features (async, GATs, etc.) evolve.

API Design - Consumers interact through a minimal surface: a single exported language constant handed to the generic tree-sitter runtime API, so there’s effectively no Rust-specific API to learn beyond tree-sitter’s own parser/query interface, keeping integration overhead low.