Struct ParsedSource 

pub struct ParsedSource { /* private fields */ }

A source file plus its parse tree; the input to lowering and to the syntax-diagnostic pass.

Implementations

impl ParsedSource

pub fn source_id(&self) -> &SourceId

The identity of the parsed source.

pub fn text(&self) -> &str

The original source text.

pub fn tree(&self) -> &Tree

The tree-sitter parse tree.

Examples found in repository

examples/conformance.rs (line 29)

fn main() {
    let path = std::env::args()
        .nth(1)
        .expect("usage: conformance <corpus.json>");
    let raw = std::fs::read_to_string(&path).expect("corpus file readable");
    let corpus: Vec<String> = parse_json_strings(&raw);

    let mut failures = 0usize;
    let mut report = String::new();
    for (index, query) in corpus.iter().enumerate() {
        let source = surrealguard_syntax::source::SourceId::new(format!("corpus:{index}"));
        let Ok(parsed) = surrealguard_syntax::parse::parse_source(source, query.as_str()) else {
            failures += 1;
            let _ = writeln!(report, "#{index}: parser returned no tree");
            continue;
        };
        if let Some(range) = first_broken_range(parsed.tree().root_node()) {
            failures += 1;
            let snippet: String = query[range.clone()].chars().take(60).collect();
            let context: String = query.chars().take(80).collect();
            let _ = writeln!(
                report,
                "#{index}: ERROR at {range:?}: `{}`\n    in: {}",
                snippet.replace('\n', " "),
                context.replace('\n', " ")
            );
        }
    }

    print!("{report}");
    println!(
        "---\n{failures}/{} corpus entries fail to parse",
        corpus.len()
    );
    if failures > 0 {
        std::process::exit(1);
    }
}

pub fn root_kind(&self) -> &str

Kind of the root CST node ("SurrealQL" for a well-formed parse).

pub fn has_error(&self) -> bool

Whether the tree contains any error or missing nodes.

pub fn syntax_diagnostics(&self) -> &[SyntaxDiagnostic]

The recoverable syntax problems collected during parsing.

Trait Implementations

impl Debug for ParsedSource

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.