Syn read file and add line to function

Question

I'm trying to parse a file with syn, and add a line to the single function in it. However, it seems to not modify the file at all when writing it back out. I'm fairly sure that I don't understand fully proc-macro and am using it wrong.

In my Cargo.toml I define a lib and bin like so:

[lib]
name = "gen"
path = "src/gen.rs"
proc-macro = true

[[bin]]
name = "main"
path = "src/main.rs"

In my gen.rs file, I define a macro to take in the input, get the function and modify it like so:

use proc_macro::TokenStream;
use quote::quote;

#[proc_macro]
pub fn gen(input: TokenStream) -> TokenStream {
    let item = syn::parse(input.clone());

    match item {
        Ok(mut v) => {
            let fn_item = match &mut v {
                syn::Item::Fn(fn_item) => fn_item,
                _ => panic!("expected fn"),
            };
            fn_item.block.stmts.insert(
                0,
                syn::parse(quote!(println!("count me in");).into()).unwrap(),
            );

            use quote::ToTokens;
            return v.into_token_stream().into();
        }
        Err(error) => {
            println!("{:?}", error);
            return input;
        }
    };
}

Now in my main.rs file, I read the file, convert it to a TokenStream, and use my macro on it and write out the output to a file:

fn main() {
    if let Err(error) = try_main() {
        let _ = writeln!(io::stderr(), "{}", error);
        process::exit(1);
    }
}

fn try_main() -> Result<(), Error> {
    let mut args = env::args_os();
    let _ = args.next(); // executable name

    let filepath = PathBuf::from("./src/file-to-parse.rs");

    let code = fs::read_to_string(&filepath).map_err(Error::ReadFile)?;
    let syntax = syn::parse_file(&code).map_err({
        |error| Error::ParseFile {
            error,
            filepath,
            source_code: code,
        }
    })?;

    let mut token_stream = TokenStream::new();
    syntax.to_tokens(&mut token_stream);
    let file_contents_updated = gen::gen!(&token_stream);

    std::fs::write("./src/file-updated.rs", file_contents_updated.to_string());

    Ok(())
}

Running this, my output file looks the same as the input. For reference, my input file looks like:

fn init() {
    println!("Hello, world!");
}

Answer 1

Yes, you've been misunderstood what proc macros do.

gen::gen!(&token_stream) will invoke gen!() at compile time with the literal tokens & token_stream. Since that doesn't look very much like a function, syn will fail to parse this, and your code will println!("{:?}", error); return input; (which by the way, is a bad idea for proc macro: parsing failure should abort compilation. Use return err.into_compile_error().into()). So it will return its input, meaning the output will be the same as the input.

You can use syn and quote for general purpose code generation, but you should not use proc macros for that - rather, use them as libraries. That is, gen::gen(token_stream) instead of gen::gen!(&token_stream). You can also not mark it proc_macro and put it in the same crate.