//lib.rs use proc_macro::{TokenStream}; use proc_macro2::{Span}; use syn::{parse_macro_input, DeriveInput, Ident}; use quote::quote; #[proc_macro_derive(Builder)] pub fn derive(input: TokenStream) -> TokenStream { let input = parse_macro_input!(input as DeriveInput); let command = Ident::new(input.ident.to_string().as_str(), Span::call_site()); let cbuilder_name = format!("{}Builder", input.ident.to_string()); let command_builder = Ident::new(cbuilder_name.as_str(), Span::call_site()); let type_definition = quote! { pub struct #command_builder { executable: Option<String>, args: Option<Vec<String>>, env: Option<Vec<String>>, current_dir: Option<String>, } }; let methods = quote! { impl #command { pub fn builder() -> #command_builder { #command_builder { executable: None, args: None, env: None, current_dir: None, } } } impl #command_builder { // use std::error::Error; // type Error: Error; fn executable(&mut self, executable: String) -> &mut Self { self.executable = Some(executable); self } fn args(&mut self, args: Vec<String>) -> &mut Self { self.args = Some(args); self } fn env(&mut self, env: Vec<String>) -> &mut Self { self.env = Some(env); self } fn current_dir(&mut self, current_dir: String) -> &mut Self { self.current_dir = Some(current_dir); self } fn build(&mut self) -> Result<#command, Box<dyn Error>> { let c = #command { executable: self.executable.unwrap().into(), args: self.args.unwrap().into(), env: self.env.unwrap().into(), current_dir: self.current_dir.unwrap().into() }; Ok(c) } } }; let tokens = quote! { #type_definition #methods }; tokens.into() } // tests/progress.rs #[test] fn tests() { let t = trybuild::TestCases::new(); t.pass("tests/01-parse.rs"); t.pass("tests/02-create-builder.rs"); t.pass("tests/03-call-setters.rs"); // t.pass("tests/04-call-build.rs"); //t.pass("tests/05-method-chaining.rs"); //t.pass("tests/06-optional-field.rs"); //t.pass("tests/07-repeated-field.rs"); //t.compile_fail("tests/08-unrecognized-attribute.rs"); //t.pass("tests/09-redefined-prelude-types.rs"); }