Vacro Parser

The Declarative Parsing Kernel for Vacro

Introduction

Vacro Parser is the core declarative parsing engine of the Vacro framework. It provides a macro_rules!-like DSL to simplify the writing of syn-based parsers for Rust Procedural Macros.

It allows you to define AST structures and parsing logic declaratively, eliminating the boilerplate of imperative input.parse()? calls.

Installation

Add this to your Cargo.toml:

[dependencies]
vacro-parser = "0.1.4"

Core Features

1. define!: Define Parsing Structs

Use define! to define a struct that automatically implements syn::parse::Parse.

use syn::{Ident, Type, GenericParam, FnArg, parse_macro_input};

// Define a struct named MyFn, it automatically implements the Parse trait
vacro::define!(MyFn:
    fn
    #(?: <#(generic*[,]: GenericParam)>)
    #(name: Ident)
    ( #(args*[,]: FnArg) )
    #(?: -> #(ret: Type))
);

// Usage in a proc-macro
// fn parse_my_fn(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
//     let my_fn = parse_macro_input!(input as MyFn);
//     println!("Function name: {}", my_fn.name);
//     proc_macro::TokenStream::new()
// }

2. bind!: On-the-fly Parsing

Use bind! to consume a portion of a TokenStream within existing imperative logic.

use syn::{Ident, Type, Token};
use vacro::bind;

fn parser(input: syn::parse::ParseStream) -> syn::Result<()> {
    // Parse a function signature pattern on the fly
    bind!(
        let captured = (input ->
            fn #(name: Ident) #(?: -> #(ret: Type))
        )?;
    );
    
    // Access captured fields directly
    println!("Name: {}", captured.name);
    if let Some(ret_type) = captured.ret {
        // ...
    }
    Ok(())
}

Syntax Reference

License

Licensed under either of Apache License, Version 2.0 or MIT license at your option.