zigsyn 0.1.0

A pure Rust Zig syntax scanner and parser.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

//! Pure Rust scanner and parser for Zig source code.
//!
//! `zigsyn` parses Zig syntax into a structured AST while preserving token-level
//! information for lossless inspection.
//!
//! # Example
//!
//! ```
//! let file = zigsyn::parse_source("pub fn main() void {}")?;
//! assert_eq!(file.members.len(), 1);
//! # Ok::<(), anyhow::Error>(())
//! ```

use std::collections::HashMap;
use std::fs;
use std::path::Path;

use anyhow::Context;

pub mod ast;
pub mod error;
pub mod parser;
pub mod scanner;
pub mod token;

pub use error::Error;
pub use parser::Parser;

/// Parses a Zig source string into an AST file.
pub fn parse_source<S: AsRef<str>>(source: S) -> anyhow::Result<ast::File> {
    Parser::from(source.as_ref()).parse_file()
}

/// Reads and parses a Zig source file.
pub fn parse_file<P: AsRef<Path>>(path: P) -> anyhow::Result<ast::File> {
    Parser::from_file(path)?.parse_file()
}

/// Parses every `.zig` file directly under `dir`.
pub fn parse_dir<P: AsRef<Path>>(dir: P) -> anyhow::Result<HashMap<String, ast::File>> {
    let dir = dir.as_ref();
    let mut files = HashMap::new();

    for entry in fs::read_dir(dir).with_context(|| format!("failed to read {}", dir.display()))? {
        let entry = entry?;
        let path = entry.path();
        if path.extension().and_then(|ext| ext.to_str()) != Some("zig") {
            continue;
        }

        let name = path
            .file_name()
            .and_then(|name| name.to_str())
            .map(ToOwned::to_owned)
            .with_context(|| format!("non UTF-8 file name: {}", path.display()))?;
        files.insert(name, parse_file(path)?);
    }

    Ok(files)
}