derive_defs/

codegen.rs

//! Proc-macro code generation.
//!
//! This module generates the actual proc-macro code from resolved definitions.
//!
//! # Generated Code Structure
//!
//! The generated code creates attribute macros that:
//! 1. Parse the input item (struct/enum)
//! 2. Apply configured derives and attributes
//! 3. Handle runtime modifiers (`add`, `omit`, `omit_attrs`)
//!
//! # Example Output
//!
//! For a definition like:
//! ```toml
//! [defs.serialization]
//! traits = ["Clone", "Serialize", "Deserialize"]
//! attrs = ['#[serde(rename_all = "camelCase")]']
//! ```
//!
//! The generated code will be:
//! ```rust,ignore
//! #[proc_macro_attribute]
//! pub fn serialization(
//!     args: TokenStream,
//!     input: TokenStream,
//! ) -> TokenStream {
//!     // Parse modifiers from args
//!     // Apply derives and attrs to input
//! }
//! ```

use std::path::Path;

use crate::resolver::ResolvedConfig;
use crate::{Error, Result};

/// Header template for generated code.
const HEADER_TEMPLATE: &str = include_str!("../templates/header.rs");

/// Macro function template.
const MACRO_TEMPLATE: &str = include_str!("../templates/macro.rs");

/// Generate proc-macro code to the default `OUT_DIR`.
///
/// This function reads the `OUT_DIR` environment variable set by Cargo
/// during the build process and writes the generated code to
/// `$OUT_DIR/derive_defs.rs`.
///
/// # Errors
///
/// Returns an error if:
/// - The `OUT_DIR` environment variable is not set
/// - The output file cannot be written
///
/// # Panics
///
/// Panics if `OUT_DIR` is not set. This should only happen outside of a build script.
///
/// # Example
///
/// ```no_run
/// // In your build.rs
/// derive_defs::generate("derive_defs.toml").unwrap();
/// ```
pub fn generate(config: ResolvedConfig) -> Result<()> {
    let out_dir =
        std::env::var("OUT_DIR").map_err(|_| Error::Validation("OUT_DIR not set".to_string()))?;
    let output_path = Path::new(&out_dir).join("derive_defs.rs");

    generate_to(config, &output_path)
}

/// Generate proc-macro code to a specific output path.
///
/// Similar to [`generate`], but allows specifying a custom output path instead
/// of using `OUT_DIR`.
///
/// # Errors
///
/// Returns an error if the output file cannot be written.
///
/// # Example
///
/// ```no_run
/// use derive_defs::resolver::{ResolvedConfig, ResolvedDef};
/// use std::collections::HashMap;
///
/// let config = ResolvedConfig {
///     defs: HashMap::new(),
/// };
/// derive_defs::codegen::generate_to(config, "/tmp/output.rs").unwrap();
/// ```
pub fn generate_to<P: AsRef<Path>>(config: ResolvedConfig, output: P) -> Result<()> {
    let code = generate_code(config);

    std::fs::write(output.as_ref(), code).map_err(Error::CodegenWrite)?;

    Ok(())
}

/// Generate Rust code string from resolved configuration.
fn generate_code(config: ResolvedConfig) -> String {
    let mut code = String::new();

    // Add header with imports and argument parser
    code.push_str(HEADER_TEMPLATE);
    code.push('\n');

    // Generate each macro
    for (name, def) in config.defs {
        let macro_name = name.replace('.', "_");

        // Build the derive list
        let derive_list = if def.traits.is_empty() {
            String::new()
        } else {
            def.traits.join(", ")
        };

        // Build the attribute list
        let attr_list = def.attrs.join("\n");

        // Generate the macro function
        code.push_str(&generate_macro(&macro_name, &derive_list, &attr_list));
        code.push('\n');
    }

    code
}

/// Generate a single macro function.
#[allow(clippy::literal_string_with_formatting_args)]
fn generate_macro(name: &str, derive_list: &str, attr_list: &str) -> String {
    MACRO_TEMPLATE
        .replace("{name}", name)
        .replace("{derive_list:?}", &format!("{derive_list:?}"))
        .replace("{attr_list:?}", &format!("{attr_list:?}"))
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::resolver::ResolvedDef;
    use std::collections::HashMap;

    #[test]
    fn test_generate_code() {
        let mut defs = HashMap::new();
        defs.insert(
            "serialization".to_string(),
            ResolvedDef {
                name: "serialization".to_string(),
                traits: vec![
                    "Clone".to_string(),
                    "Serialize".to_string(),
                    "Deserialize".to_string(),
                ],
                attrs: vec!["#[serde(rename_all = \"camelCase\")]".to_string()],
            },
        );

        let config = ResolvedConfig { defs };
        let code = generate_code(config);

        assert!(code.contains("proc_macro_attribute"));
        assert!(code.contains("fn serialization"));
        // The quote! template uses #(#derives),* which expands at runtime
        assert!(code.contains("#[derive(#(#derives),*)]"));
        assert!(code.contains("serde(rename_all"));
        assert!(code.contains("struct DefArgs"));
        assert!(code.contains("impl Parse for DefArgs"));
        // Verify the traits are in the parse_trait_list call
        assert!(code.contains("\"Clone, Serialize, Deserialize\""));
    }

    /// Test that generated code converts trait strings to `proc_macro2::Ident`.
    ///
    /// This test specifically guards against the bug where trait names were
    /// passed directly to quote! as strings, resulting in string literals
    /// instead of identifiers in the generated #[derive(...)] attribute.
    #[test]
    fn test_generated_code_converts_traits_to_idents() {
        let mut defs = HashMap::new();
        defs.insert(
            "model".to_string(),
            ResolvedDef {
                name: "model".to_string(),
                traits: vec!["Debug".to_string(), "Clone".to_string()],
                attrs: vec![],
            },
        );

        let config = ResolvedConfig { defs };
        let code = generate_code(config);

        // The generated code must convert String to proc_macro2::Ident
        // before using in quote! macro to avoid "expected path, found literal" error
        assert!(
            code.contains("proc_macro2::Ident::new"),
            "Generated code should convert trait names to proc_macro2::Ident"
        );

        // Check that the code uses call_site() span for the Idents
        assert!(
            code.contains("proc_macro2::Span::call_site()"),
            "Generated code should use call_site() span for Idents"
        );

        // Check that derives are declared as Vec<proc_macro2::Ident>
        assert!(
            code.contains("Vec<proc_macro2::Ident>"),
            "Generated code should declare derives as Vec<proc_macro2::Ident>"
        );
    }

    /// Test that generated code properly handles the derive attribute construction.
    ///
    /// This ensures the generated code will produce valid #[derive(Trait1, Trait2)]
    /// syntax when compiled and executed.
    #[test]
    fn test_generated_code_derive_construction() {
        let mut defs = HashMap::new();
        defs.insert(
            "test".to_string(),
            ResolvedDef {
                name: "test".to_string(),
                traits: vec!["Debug".to_string()],
                attrs: vec![],
            },
        );

        let config = ResolvedConfig { defs };
        let code = generate_code(config);

        // Check that the generated code has the proper structure for building derives
        assert!(
            code.contains("let derives: Vec<proc_macro2::Ident>"),
            "Generated code should create a typed Vec of Idents for derives"
        );

        // The code should iterate over final_derives and convert each to Ident
        // Note: In the generated code, this spans multiple lines:
        //   let derives: Vec<proc_macro2::Ident> = final_derives
        //       .iter()
        //       .map(...)
        assert!(
            code.contains("final_derives") && code.contains(".iter()"),
            "Generated code should iterate over final_derives"
        );

        // The quote! should use the derives variable (which is now Vec<Ident>)
        assert!(
            code.contains("#(#derives),*"),
            "Generated code should use derives in quote! macro"
        );
    }

    #[test]
    fn test_generate_code_empty_traits() {
        let mut defs = HashMap::new();
        defs.insert(
            "empty".to_string(),
            ResolvedDef {
                name: "empty".to_string(),
                traits: vec![],
                attrs: vec!["#[repr(C)]".to_string()],
            },
        );

        let config = ResolvedConfig { defs };
        let code = generate_code(config);

        assert!(code.contains("fn empty"));
        assert!(!code.contains("derive()")); // Empty derive list should not be generated
        assert!(code.contains("repr(C)"));

        // When traits are empty, the code should use quote! {}
        assert!(
            code.contains("let derive_attr = if final_derives.is_empty()"),
            "Generated code should check for empty derives"
        );
    }

    #[test]
    fn test_generate_code_namespaced() {
        let mut defs = HashMap::new();
        defs.insert(
            "common.serialization".to_string(),
            ResolvedDef {
                name: "common.serialization".to_string(),
                traits: vec!["Clone".to_string()],
                attrs: vec![],
            },
        );

        let config = ResolvedConfig { defs };
        let code = generate_code(config);

        // Namespaced names should have dots replaced with underscores
        assert!(code.contains("fn common_serialization"));
    }

    /// Test that generated code includes all necessary helper functions.
    #[test]
    fn test_generated_code_includes_helpers() {
        let config = ResolvedConfig {
            defs: HashMap::new(),
        };
        let code = generate_code(config);

        assert!(
            code.contains("fn parse_trait_list"),
            "Generated code should include parse_trait_list function"
        );
        assert!(
            code.contains("fn filter_attrs"),
            "Generated code should include filter_attrs function"
        );
    }

    /// Test that generated code handles runtime modifications (omit/add).
    #[test]
    fn test_generated_code_handles_runtime_mods() {
        let mut defs = HashMap::new();
        defs.insert(
            "configurable".to_string(),
            ResolvedDef {
                name: "configurable".to_string(),
                traits: vec!["Debug".to_string(), "Clone".to_string()],
                attrs: vec![],
            },
        );

        let config = ResolvedConfig { defs };
        let code = generate_code(config);

        // Check for omit handling
        assert!(
            code.contains("omit_traits"),
            "Generated code should handle omit_traits"
        );

        // Check for add handling
        assert!(
            code.contains("add_traits"),
            "Generated code should handle add_traits"
        );

        // Check for filtering logic
        assert!(
            code.contains(".filter(|t| !omit_traits.contains(t))"),
            "Generated code should filter omitted traits"
        );
    }
}