Struct RustParser 

pub struct RustParser<'config> { /* private fields */ }

A parser for the Rust programming language.

The RustParser is responsible for parsing Rust source code and building an Abstract Syntax Tree (AST). It uses a Pratt parser for handling operator precedence in expressions and supports all Rust syntax features.

Examples

Basic usage:

use oak_core::Parser;
use oak_rust::{RustLanguage, RustParser, SourceText};

let language = RustLanguage::default();
let parser = RustParser::new(&language);
let source = SourceText::new("fn main() { println!(\"Hello, world!\"); }");
let result = parser.parse(source, 0);

// The result contains the parsed AST
assert!(result.is_ok());

Parsing a more complex Rust structure:

use oak_core::Parser;
use oak_rust::{RustLanguage, RustParser, SourceText};

let language = RustLanguage::default();
let parser = RustParser::new(&language);

let source = SourceText::new(
    r#"
struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn new(x: f64, y: f64) -> Self {
        Point { x, y }
    }
}
"#,
);
let result = parser.parse(source, 0);

// Verify that parsing succeeded
assert!(result.is_ok());

Implementations

impl<'config> RustParser<'config>

pub fn parse_param( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_block( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_stmt( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_let_stmt( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_expr_stmt( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_expr( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_use_item( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_const_item( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_mod_item( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

pub fn parse_pub_item( state: &mut ParserState<'_, impl Source, RustLanguage>, ) -> Result<Arc<GreenNode<RustSyntaxKind>>, OakError>

impl<'config> RustParser<'config>

pub fn new(config: &'config RustLanguage) -> Self

Creates a new RustParser with the given language configuration.

Parameters

• config - A reference to the RustLanguage configuration that controls language-specific parsing behavior.

Examples

use oak_rust::{RustLanguage, RustParser};

let language = RustLanguage::default();
let parser = RustParser::new(&language);

pub fn operator_rules(&self) -> &PrattParser<RustLanguage>

Returns a reference to the Pratt parser containing operator precedence rules.

The Pratt parser defines the precedence and associativity of all Rust operators, which is used to correctly parse expressions with multiple operators.

Trait Implementations

impl<'config> Builder<RustLanguage> for RustParser<'config>

fn build_incremental( &self, text: impl Source, changed: usize, cache: IncrementalCache<'_, RustLanguage>, ) -> OakDiagnostics<RustRoot>

Builds a kind tree incrementally using an existing cache.

fn build(&self, text: impl Source) -> OakDiagnostics<<L as Language>::TypedRoot>

Builds a complete kind tree from the given source text.

impl<'config> Clone for RustParser<'config>

fn clone(&self) -> RustParser<'config>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'config> Parser<RustLanguage> for RustParser<'config>

fn parse_incremental( &self, text: impl Source, changed: usize, cache: IncrementalCache<'_, RustLanguage>, ) -> OakDiagnostics<Arc<GreenNode<RustSyntaxKind>>>

Parses source text incrementally using an existing cache.

fn parse( &self, text: impl Source, ) -> OakDiagnostics<Arc<GreenNode<<L as Language>::SyntaxKind>>>

Parses source text into a kind tree.