depyler-core 4.1.1

//! Hashlib Module Code Generation - EXTREME TDD
//!
//! Handles Python `hashlib` module conversions to Rust digest crates.
//! Single-shot compilation: No manual lifetime annotations needed.
//!
//! Coverage target: 100% line coverage, 100% branch coverage
//!
//! ## Supported Hash Algorithms
//! - `hashlib.md5()` → md5 crate
//! - `hashlib.sha1()` → sha1 crate
//! - `hashlib.sha224()` → sha2 crate (Sha224)
//! - `hashlib.sha256()` → sha2 crate (Sha256)
//! - `hashlib.sha384()` → sha2 crate (Sha384)
//! - `hashlib.sha512()` → sha2 crate (Sha512)
//! - `hashlib.sha3_256()` → sha3 crate
//! - `hashlib.sha3_512()` → sha3 crate
//! - `hashlib.blake2b()` → blake2 crate
//! - `hashlib.blake2s()` → blake2 crate
//! - `hashlib.new(name)` → dynamic hash selection
//!
//! ## Design Principles
//! 1. Use Digest trait for unified interface
//! 2. Strategic Cloning: Clone hasher when needed for multiple updates
//! 3. Hex encoding via hex crate for hexdigest()

use crate::hir::{HirExpr, Literal};
use crate::rust_gen::context::{CodeGenContext, ToRustExpr};
use anyhow::{bail, Result};
use syn::parse_quote;

/// Convert Python hashlib module function calls to Rust
///
/// # Supported Constructors
/// - `hashlib.md5()` / `hashlib.md5(data)`
/// - `hashlib.sha1()` / `hashlib.sha1(data)`
/// - `hashlib.sha224()` / `hashlib.sha224(data)`
/// - `hashlib.sha256()` / `hashlib.sha256(data)`
/// - `hashlib.sha384()` / `hashlib.sha384(data)`
/// - `hashlib.sha512()` / `hashlib.sha512(data)`
/// - `hashlib.sha3_256()` / `hashlib.sha3_256(data)`
/// - `hashlib.sha3_512()` / `hashlib.sha3_512(data)`
/// - `hashlib.blake2b()` / `hashlib.blake2b(data)`
/// - `hashlib.blake2s()` / `hashlib.blake2s(data)`
/// - `hashlib.new(name, data)`
///
/// # Complexity: 5 (delegated to dispatch helper)
pub fn convert_hashlib_method(
    method: &str,
    args: &[HirExpr],
    ctx: &mut CodeGenContext,
) -> Result<Option<syn::Expr>> {
    let arg_exprs: Vec<syn::Expr> = args
        .iter()
        .map(|arg| arg.to_rust_expr(ctx))
        .collect::<Result<Vec<_>>>()?;

    let result = dispatch_hashlib_constructor(method, args, &arg_exprs, ctx)?;
    Ok(Some(result))
}

fn dispatch_hashlib_constructor(
    method: &str,
    args: &[HirExpr],
    arg_exprs: &[syn::Expr],
    ctx: &mut CodeGenContext,
) -> Result<syn::Expr> {
    match method {
        "md5" => convert_md5(arg_exprs, ctx),
        "sha1" => convert_sha1(arg_exprs, ctx),
        "sha224" => convert_sha224(arg_exprs, ctx),
        "sha256" => convert_sha256(arg_exprs, ctx),
        "sha384" => convert_sha384(arg_exprs, ctx),
        "sha512" => convert_sha512(arg_exprs, ctx),
        "sha3_224" => convert_sha3_224(arg_exprs, ctx),
        "sha3_256" => convert_sha3_256(arg_exprs, ctx),
        "sha3_384" => convert_sha3_384(arg_exprs, ctx),
        "sha3_512" => convert_sha3_512(arg_exprs, ctx),
        "blake2b" => convert_blake2b(arg_exprs, ctx),
        "blake2s" => convert_blake2s(arg_exprs, ctx),
        "new" => convert_new(args, arg_exprs, ctx),
        _ => bail!("hashlib.{} not implemented yet", method),
    }
}

/// Convert hashlib hash object instance methods
///
/// # Supported Methods
/// - `.update(data)` → hasher.update(data)
/// - `.digest()` → hasher.finalize()
/// - `.hexdigest()` → hex::encode(hasher.finalize())
/// - `.copy()` → hasher.clone()
pub fn convert_hashlib_instance_method(
    method: &str,
    args: &[HirExpr],
    ctx: &mut CodeGenContext,
) -> Result<Option<syn::Expr>> {
    let arg_exprs: Vec<syn::Expr> = args
        .iter()
        .map(|arg| arg.to_rust_expr(ctx))
        .collect::<Result<Vec<_>>>()?;

    let result = match method {
        "update" => convert_update(&arg_exprs, ctx)?,
        "digest" => convert_digest(ctx)?,
        "hexdigest" => convert_hexdigest(ctx)?,
        "copy" => convert_copy()?,
        "name" => convert_name()?,
        "digest_size" => convert_digest_size()?,
        "block_size" => convert_block_size()?,
        _ => bail!("hashlib hash object method '{}' not implemented", method),
    };

    Ok(Some(result))
}

// =============================================================================
// Hash Algorithm Constructors
// =============================================================================

fn convert_md5(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_md5 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { md5::Md5::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use md5::Digest;
                let mut hasher = md5::Md5::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha1(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha1 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha1::Sha1::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha1::Digest;
                let mut hasher = sha1::Sha1::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha224(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha2 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha2::Sha224::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha2::Digest;
                let mut hasher = sha2::Sha224::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha256(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha2 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha2::Sha256::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha2::Digest;
                let mut hasher = sha2::Sha256::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha384(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha2 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha2::Sha384::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha2::Digest;
                let mut hasher = sha2::Sha384::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha512(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha2 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha2::Sha512::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha2::Digest;
                let mut hasher = sha2::Sha512::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha3_224(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha3 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha3::Sha3_224::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha3::Digest;
                let mut hasher = sha3::Sha3_224::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha3_256(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha3 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha3::Sha3_256::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha3::Digest;
                let mut hasher = sha3::Sha3_256::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha3_384(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha3 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha3::Sha3_384::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha3::Digest;
                let mut hasher = sha3::Sha3_384::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_sha3_512(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_sha3 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { sha3::Sha3_512::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use sha3::Digest;
                let mut hasher = sha3::Sha3_512::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_blake2b(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_blake2 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { blake2::Blake2b512::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use blake2::Digest;
                let mut hasher = blake2::Blake2b512::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

fn convert_blake2s(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_blake2 = true;
    ctx.needs_digest = true;

    if arg_exprs.is_empty() {
        Ok(parse_quote! { blake2::Blake2s256::new() })
    } else {
        let data = &arg_exprs[0];
        Ok(parse_quote! {
            {
                use blake2::Digest;
                let mut hasher = blake2::Blake2s256::new();
                hasher.update(#data.as_bytes());
                hasher
            }
        })
    }
}

/// hashlib.new(name, data=b'') - Create hasher by name
fn convert_new(
    args: &[HirExpr],
    arg_exprs: &[syn::Expr],
    ctx: &mut CodeGenContext,
) -> Result<syn::Expr> {
    if arg_exprs.is_empty() {
        bail!("hashlib.new() requires algorithm name argument");
    }

    // Check if we can determine the algorithm at compile time
    if let Some(HirExpr::Literal(Literal::String(alg_name))) = args.first() {
        convert_new_static(alg_name, arg_exprs.get(1), ctx)
    } else {
        convert_new_dynamic(arg_exprs, ctx)
    }
}

/// Static dispatch: algorithm name known at compile time
fn convert_new_static(
    alg_name: &str,
    data_expr: Option<&syn::Expr>,
    ctx: &mut CodeGenContext,
) -> Result<syn::Expr> {
    let alg_lower = alg_name.to_lowercase();
    let args = match data_expr {
        Some(data) => std::slice::from_ref(data).to_vec(),
        None => vec![],
    };

    match alg_lower.as_str() {
        "md5" => convert_md5(&args, ctx),
        "sha1" => convert_sha1(&args, ctx),
        "sha224" => convert_sha224(&args, ctx),
        "sha256" => convert_sha256(&args, ctx),
        "sha384" => convert_sha384(&args, ctx),
        "sha512" => convert_sha512(&args, ctx),
        "sha3_256" | "sha3-256" => convert_sha3_256(&args, ctx),
        "sha3_512" | "sha3-512" => convert_sha3_512(&args, ctx),
        "blake2b" => convert_blake2b(&args, ctx),
        "blake2s" => convert_blake2s(&args, ctx),
        _ => bail!("hashlib.new(): unsupported algorithm '{}'", alg_name),
    }
}

/// Dynamic dispatch: algorithm name not known at compile time
fn convert_new_dynamic(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_digest = true;
    ctx.needs_sha2 = true;
    ctx.needs_md5 = true;
    ctx.needs_sha1 = true;

    let name = &arg_exprs[0];
    Ok(parse_quote! {
        depyler_runtime::create_hasher(#name)?
    })
}

// =============================================================================
// Instance Methods
// =============================================================================

fn convert_update(arg_exprs: &[syn::Expr], ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    if arg_exprs.is_empty() {
        bail!("hash.update() requires data argument");
    }
    ctx.needs_digest = true;

    let data = &arg_exprs[0];
    // Note: The actual object reference is handled by the caller
    // This generates the method call portion
    Ok(parse_quote! { self.update(#data.as_bytes()) })
}

fn convert_digest(ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_digest = true;
    // finalize() consumes self, so we need clone() for Python semantics
    Ok(parse_quote! { self.clone().finalize().to_vec() })
}

fn convert_hexdigest(ctx: &mut CodeGenContext) -> Result<syn::Expr> {
    ctx.needs_digest = true;
    ctx.needs_hex = true;
    // finalize() consumes self, so we need clone() for Python semantics
    Ok(parse_quote! { hex::encode(self.clone().finalize()) })
}

fn convert_copy() -> Result<syn::Expr> {
    Ok(parse_quote! { self.clone() })
}

fn convert_name() -> Result<syn::Expr> {
    // Would need runtime type info; provide static name where possible
    Ok(parse_quote! { self.name() })
}

fn convert_digest_size() -> Result<syn::Expr> {
    Ok(parse_quote! { self.output_size() })
}

fn convert_block_size() -> Result<syn::Expr> {
    Ok(parse_quote! { self.block_size() })
}

// =============================================================================
// Tests
// =============================================================================

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_md5_no_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_md5(&[], &mut ctx).unwrap();
        assert!(ctx.needs_md5);
        assert!(ctx.needs_digest);
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Md5"));
    }

    #[test]
    fn test_md5_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { "hello" };
        let result = convert_md5(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
    }

    #[test]
    fn test_sha1_no_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_sha1(&[], &mut ctx).unwrap();
        assert!(ctx.needs_sha1);
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha1"));
    }

    #[test]
    fn test_sha256_no_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_sha256(&[], &mut ctx).unwrap();
        assert!(ctx.needs_sha2);
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha256"));
    }

    #[test]
    fn test_sha256_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { "test" };
        let result = convert_sha256(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
    }

    #[test]
    fn test_sha512_no_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_sha512(&[], &mut ctx).unwrap();
        assert!(ctx.needs_sha2);
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha512"));
    }

    #[test]
    fn test_sha3_256_no_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_sha3_256(&[], &mut ctx).unwrap();
        assert!(ctx.needs_sha3);
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_256"));
    }

    #[test]
    fn test_blake2b_no_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_blake2b(&[], &mut ctx).unwrap();
        assert!(ctx.needs_blake2);
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Blake2b512"));
    }

    #[test]
    fn test_blake2s_no_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_blake2s(&[], &mut ctx).unwrap();
        assert!(ctx.needs_blake2);
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Blake2s256"));
    }

    #[test]
    fn test_hexdigest() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hexdigest(&mut ctx).unwrap();
        assert!(ctx.needs_hex);
        let code = quote::quote!(#result).to_string();
        // quote! may produce "hex :: encode" with spaces
        assert!(code.contains("hex") && code.contains("encode"));
    }

    #[test]
    fn test_digest() {
        let mut ctx = CodeGenContext::default();
        let result = convert_digest(&mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("finalize"));
    }

    #[test]
    fn test_copy() {
        let result = convert_copy().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("clone"));
    }

    #[test]
    fn test_update_requires_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_update(&[], &mut ctx);
        assert!(result.is_err());
    }

    #[test]
    fn test_update_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { "data" };
        let result = convert_update(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
    }

    #[test]
    fn test_convert_hashlib_method_dispatch() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha256", &[], &mut ctx).unwrap();
        assert!(result.is_some());
    }

    #[test]
    fn test_convert_hashlib_method_unsupported() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("unsupported", &[], &mut ctx);
        assert!(result.is_err());
    }

    #[test]
    fn test_new_requires_name() {
        let mut ctx = CodeGenContext::default();
        let result = convert_new(&[], &[], &mut ctx);
        assert!(result.is_err());
    }

    #[test]
    fn test_new_with_known_algorithm() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha256".to_string()));
        let name_expr: syn::Expr = parse_quote! { "sha256" };
        let _result = convert_new(&[name_hir], &[name_expr], &mut ctx).unwrap();
        assert!(ctx.needs_sha2);
    }

    #[test]
    fn test_new_unsupported_algorithm() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("unsupported".to_string()));
        let name_expr: syn::Expr = parse_quote! { "unsupported" };
        let result = convert_new(&[name_hir], &[name_expr], &mut ctx);
        assert!(result.is_err());
    }

    #[test]
    fn test_all_sha2_variants() {
        let mut ctx = CodeGenContext::default();

        let _ = convert_sha224(&[], &mut ctx).unwrap();
        let _ = convert_sha256(&[], &mut ctx).unwrap();
        let _ = convert_sha384(&[], &mut ctx).unwrap();
        let _ = convert_sha512(&[], &mut ctx).unwrap();

        assert!(ctx.needs_sha2);
    }

    #[test]
    fn test_all_sha3_variants() {
        let mut ctx = CodeGenContext::default();

        let _ = convert_sha3_224(&[], &mut ctx).unwrap();
        let _ = convert_sha3_256(&[], &mut ctx).unwrap();
        let _ = convert_sha3_384(&[], &mut ctx).unwrap();
        let _ = convert_sha3_512(&[], &mut ctx).unwrap();

        assert!(ctx.needs_sha3);
    }

    #[test]
    fn test_instance_method_dispatch() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_instance_method("hexdigest", &[], &mut ctx).unwrap();
        assert!(result.is_some());
    }

    #[test]
    fn test_instance_method_unsupported() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_instance_method("unsupported", &[], &mut ctx);
        assert!(result.is_err());
    }

    // ============ Direct API coverage tests for hashlib ============

    #[test]
    fn test_s9b6_hashlib_sha256_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha256", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha256"));
        assert!(ctx.needs_sha2);
    }

    #[test]
    fn test_s9b6_hashlib_sha512_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha512", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha512"));
        assert!(ctx.needs_sha2);
    }

    #[test]
    fn test_s9b6_hashlib_sha224_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha224", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha224"));
    }

    #[test]
    fn test_s9b6_hashlib_sha384_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha384", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha384"));
    }

    #[test]
    fn test_s9b6_hashlib_md5_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("md5", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Md5"));
        assert!(ctx.needs_md5);
    }

    #[test]
    fn test_s9b6_hashlib_sha1_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha1", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha1"));
        assert!(ctx.needs_sha1);
    }

    #[test]
    fn test_s9b6_hashlib_blake2b_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("blake2b", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Blake2b512"));
        assert!(ctx.needs_blake2);
    }

    #[test]
    fn test_s9b6_hashlib_blake2s_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("blake2s", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Blake2s256"));
        assert!(ctx.needs_blake2);
    }

    #[test]
    fn test_s9b6_hashlib_sha3_224_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha3_224", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_224"));
        assert!(ctx.needs_sha3);
    }

    #[test]
    fn test_s9b6_hashlib_sha3_256_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha3_256", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_256"));
    }

    #[test]
    fn test_s9b6_hashlib_sha3_384_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha3_384", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_384"));
    }

    #[test]
    fn test_s9b6_hashlib_sha3_512_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_method("sha3_512", &[], &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_512"));
    }

    #[test]
    fn test_s9b6_hashlib_sha256_with_data() {
        let mut ctx = CodeGenContext::default();
        let args = vec![HirExpr::Literal(Literal::Bytes(b"hello".to_vec()))];
        let result = convert_hashlib_method("sha256", &args, &mut ctx).unwrap().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha256"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b6_hashlib_hexdigest_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hexdigest(&mut ctx).unwrap();
        assert!(ctx.needs_hex);
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("finalize"));
    }

    #[test]
    fn test_s9b6_hashlib_digest_output() {
        let mut ctx = CodeGenContext::default();
        let result = convert_digest(&mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("finalize"));
    }

    #[test]
    fn test_s9b6_hashlib_copy_output() {
        let result = convert_copy().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("clone"));
    }

    #[test]
    fn test_s9b6_hashlib_update_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_update(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b6_hashlib_update_no_data() {
        let mut ctx = CodeGenContext::default();
        let result = convert_update(&[], &mut ctx);
        assert!(result.is_err());
    }

    #[test]
    fn test_s9b6_hashlib_new_sha256() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha256".to_string()));
        let name_expr: syn::Expr = parse_quote! { "sha256" };
        let result = convert_new(&[name_hir], &[name_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha256"));
    }

    #[test]
    fn test_s9b6_hashlib_new_md5() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("md5".to_string()));
        let name_expr: syn::Expr = parse_quote! { "md5" };
        let result = convert_new(&[name_hir], &[name_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Md5"));
    }

    #[test]
    fn test_s9b6_hashlib_new_sha1() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha1".to_string()));
        let name_expr: syn::Expr = parse_quote! { "sha1" };
        let result = convert_new(&[name_hir], &[name_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha1"));
    }

    #[test]
    fn test_s9b6_hashlib_instance_digest() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_instance_method("digest", &[], &mut ctx).unwrap();
        assert!(result.is_some());
    }

    #[test]
    fn test_s9b6_hashlib_instance_hexdigest() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_instance_method("hexdigest", &[], &mut ctx).unwrap();
        assert!(result.is_some());
    }

    #[test]
    fn test_s9b6_hashlib_instance_copy() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_instance_method("copy", &[], &mut ctx).unwrap();
        assert!(result.is_some());
    }

    #[test]
    fn test_s9b6_hashlib_instance_update() {
        let mut ctx = CodeGenContext::default();
        let data = HirExpr::Literal(Literal::Bytes(b"data".to_vec()));
        let result = convert_hashlib_instance_method("update", &[data], &mut ctx).unwrap();
        assert!(result.is_some());
    }

    // ============ S9B7: Data argument branch coverage for all algorithms ============

    #[test]
    fn test_s9b7_hashlib_sha1_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_sha1(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Sha1"));
        assert!(ctx.needs_sha1);
        assert!(ctx.needs_digest);
    }

    #[test]
    fn test_s9b7_hashlib_sha224_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_sha224(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Sha224"));
        assert!(ctx.needs_sha2);
        assert!(ctx.needs_digest);
    }

    #[test]
    fn test_s9b7_hashlib_sha384_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_sha384(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Sha384"));
        assert!(ctx.needs_sha2);
    }

    #[test]
    fn test_s9b7_hashlib_sha512_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_sha512(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Sha512"));
        assert!(ctx.needs_sha2);
    }

    #[test]
    fn test_s9b7_hashlib_sha3_224_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_sha3_224(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Sha3_224"));
        assert!(ctx.needs_sha3);
    }

    #[test]
    fn test_s9b7_hashlib_sha3_256_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_sha3_256(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Sha3_256"));
        assert!(ctx.needs_sha3);
    }

    #[test]
    fn test_s9b7_hashlib_sha3_384_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_sha3_384(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Sha3_384"));
        assert!(ctx.needs_sha3);
    }

    #[test]
    fn test_s9b7_hashlib_sha3_512_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_sha3_512(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Sha3_512"));
        assert!(ctx.needs_sha3);
    }

    #[test]
    fn test_s9b7_hashlib_blake2b_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_blake2b(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Blake2b512"));
        assert!(ctx.needs_blake2);
        assert!(ctx.needs_digest);
    }

    #[test]
    fn test_s9b7_hashlib_blake2s_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_blake2s(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Blake2s256"));
        assert!(ctx.needs_blake2);
        assert!(ctx.needs_digest);
    }

    // ============ S9B7: convert_new with data arg ============

    #[test]
    fn test_s9b7_hashlib_new_sha256_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha256".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"payload".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha256" };
        let data_expr: syn::Expr = parse_quote! { b"payload" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha256"));
        assert!(code.contains("update"));
        assert!(ctx.needs_sha2);
    }

    #[test]
    fn test_s9b7_hashlib_new_md5_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("md5".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"test".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "md5" };
        let data_expr: syn::Expr = parse_quote! { b"test" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Md5"));
        assert!(code.contains("update"));
        assert!(ctx.needs_md5);
    }

    #[test]
    fn test_s9b7_hashlib_new_sha1_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha1".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"abc".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha1" };
        let data_expr: syn::Expr = parse_quote! { b"abc" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha1"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_sha224_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha224".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"x".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha224" };
        let data_expr: syn::Expr = parse_quote! { b"x" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha224"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_sha384_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha384".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"y".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha384" };
        let data_expr: syn::Expr = parse_quote! { b"y" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha384"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_sha512_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha512".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"z".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha512" };
        let data_expr: syn::Expr = parse_quote! { b"z" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha512"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_sha3_256_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha3_256".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"d".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha3_256" };
        let data_expr: syn::Expr = parse_quote! { b"d" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_256"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_sha3_512_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha3_512".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"e".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha3_512" };
        let data_expr: syn::Expr = parse_quote! { b"e" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_512"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_blake2b_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("blake2b".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"f".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "blake2b" };
        let data_expr: syn::Expr = parse_quote! { b"f" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Blake2b512"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_blake2s_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("blake2s".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"g".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "blake2s" };
        let data_expr: syn::Expr = parse_quote! { b"g" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Blake2s256"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_sha3_dash_256_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha3-256".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"h".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha3-256" };
        let data_expr: syn::Expr = parse_quote! { b"h" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_256"));
        assert!(code.contains("update"));
    }

    #[test]
    fn test_s9b7_hashlib_new_sha3_dash_512_with_data() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Literal(Literal::String("sha3-512".to_string()));
        let data_hir = HirExpr::Literal(Literal::Bytes(b"i".to_vec()));
        let name_expr: syn::Expr = parse_quote! { "sha3-512" };
        let data_expr: syn::Expr = parse_quote! { b"i" };
        let result = convert_new(&[name_hir, data_hir], &[name_expr, data_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("Sha3_512"));
        assert!(code.contains("update"));
    }

    // ============ S9B7: Instance methods - name, digest_size, block_size ============

    #[test]
    fn test_s9b7_hashlib_convert_name() {
        let result = convert_name().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("name"));
    }

    #[test]
    fn test_s9b7_hashlib_convert_digest_size() {
        let result = convert_digest_size().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("output_size"));
    }

    #[test]
    fn test_s9b7_hashlib_convert_block_size() {
        let result = convert_block_size().unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("block_size"));
    }

    #[test]
    fn test_s9b7_hashlib_instance_name_dispatch() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_instance_method("name", &[], &mut ctx).unwrap();
        assert!(result.is_some());
        let code = quote::quote!(#(result.unwrap())).to_string();
        // Just ensure dispatch works
        assert!(result.is_some());
    }

    #[test]
    fn test_s9b7_hashlib_instance_digest_size_dispatch() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_instance_method("digest_size", &[], &mut ctx).unwrap();
        assert!(result.is_some());
    }

    #[test]
    fn test_s9b7_hashlib_instance_block_size_dispatch() {
        let mut ctx = CodeGenContext::default();
        let result = convert_hashlib_instance_method("block_size", &[], &mut ctx).unwrap();
        assert!(result.is_some());
    }

    // ============ S9B7: Dynamic dispatch (non-literal algorithm name) ============

    #[test]
    fn test_s9b7_hashlib_new_dynamic_dispatch() {
        let mut ctx = CodeGenContext::default();
        let name_hir = HirExpr::Var("algo_name".to_string());
        let name_expr: syn::Expr = parse_quote! { algo_name };
        let result = convert_new(&[name_hir], &[name_expr], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("create_hasher"));
        assert!(ctx.needs_digest);
        assert!(ctx.needs_sha2);
        assert!(ctx.needs_md5);
        assert!(ctx.needs_sha1);
    }

    // ============ S9B7: convert_md5 with data (direct call) ============

    #[test]
    fn test_s9b7_hashlib_md5_with_data() {
        let mut ctx = CodeGenContext::default();
        let data: syn::Expr = parse_quote! { b"hello" };
        let result = convert_md5(&[data], &mut ctx).unwrap();
        let code = quote::quote!(#result).to_string();
        assert!(code.contains("update"));
        assert!(code.contains("Md5"));
        assert!(ctx.needs_md5);
        assert!(ctx.needs_digest);
    }
}