decy_codegen/

lib.rs

//! Rust code generation from HIR with minimal unsafe blocks.
//!
//! Generates idiomatic Rust code with <5 unsafe blocks per 1000 LOC.
//!
//! # Examples
//!
//! ```
//! use decy_codegen::CodeGenerator;
//! use decy_hir::{HirFunction, HirType, HirParameter};
//!
//! let func = HirFunction::new(
//!     "add".to_string(),
//!     HirType::Int,
//!     vec![
//!         HirParameter::new("a".to_string(), HirType::Int),
//!         HirParameter::new("b".to_string(), HirType::Int),
//!     ],
//! );
//!
//! let codegen = CodeGenerator::new();
//! let code = codegen.generate_function(&func);
//!
//! assert!(code.contains("fn add"));
//! assert!(code.contains("a: i32"));
//! assert!(code.contains("b: i32"));
//! ```

#![warn(missing_docs)]
#![warn(clippy::all)]
#![deny(unsafe_code)]

pub mod box_transform;
pub mod concurrency_transform;
pub mod enum_gen;
pub mod pattern_gen;
pub mod test_generator;

use decy_hir::{BinaryOperator, HirExpression, HirFunction, HirStatement, HirType};
use decy_ownership::lifetime_gen::{AnnotatedSignature, AnnotatedType};
use std::collections::HashMap;

/// Type context for tracking variable types and struct definitions during code generation.
/// Used to detect pointer arithmetic, null pointer assignments, and other type-specific operations.
#[derive(Debug, Clone)]
struct TypeContext {
    variables: HashMap<String, HirType>,
    structs: HashMap<String, Vec<(String, HirType)>>, // struct_name -> [(field_name, field_type)]
}

impl TypeContext {
    fn new() -> Self {
        Self {
            variables: HashMap::new(),
            structs: HashMap::new(),
        }
    }

    fn from_function(func: &HirFunction) -> Self {
        let mut ctx = Self::new();
        // Add parameters to context
        for param in func.parameters() {
            ctx.variables
                .insert(param.name().to_string(), param.param_type().clone());
        }
        ctx
    }

    fn add_variable(&mut self, name: String, var_type: HirType) {
        self.variables.insert(name, var_type);
    }

    fn add_struct(&mut self, struct_def: &decy_hir::HirStruct) {
        let fields: Vec<(String, HirType)> = struct_def
            .fields()
            .iter()
            .map(|f| (f.name().to_string(), f.field_type().clone()))
            .collect();
        self.structs.insert(struct_def.name().to_string(), fields);
    }

    fn get_type(&self, name: &str) -> Option<&HirType> {
        self.variables.get(name)
    }

    fn get_field_type(&self, object_expr: &HirExpression, field_name: &str) -> Option<HirType> {
        // Get the type of the object expression
        let object_type = match object_expr {
            HirExpression::Variable(var_name) => self.get_type(var_name)?,
            _ => return None,
        };

        // Extract the struct name from the type
        let struct_name = match object_type {
            HirType::Struct(name) => name,
            HirType::Pointer(inner) => {
                // If it's a pointer to a struct, dereference it
                if let HirType::Struct(name) = &**inner {
                    name
                } else {
                    return None;
                }
            }
            _ => return None,
        };

        // Look up the field type in the struct definition
        let fields = self.structs.get(struct_name)?;
        fields
            .iter()
            .find(|(name, _)| name == field_name)
            .map(|(_, field_type)| field_type.clone())
    }

    fn is_pointer(&self, name: &str) -> bool {
        matches!(self.get_type(name), Some(HirType::Pointer(_)))
    }

    fn is_option(&self, name: &str) -> bool {
        matches!(self.get_type(name), Some(HirType::Option(_)))
    }

    /// Infer the type of an expression based on the context.
    /// Returns None if the type cannot be inferred.
    fn infer_expression_type(&self, expr: &HirExpression) -> Option<HirType> {
        match expr {
            HirExpression::Variable(name) => self.get_type(name).cloned(),
            HirExpression::Dereference(inner) => {
                // If inner is *mut T, then *inner is T
                if let Some(HirType::Pointer(pointee_type)) = self.infer_expression_type(inner) {
                    Some(*pointee_type)
                } else {
                    None
                }
            }
            HirExpression::ArrayIndex { array, index: _ } => {
                // If array is [T; N] or *mut T, then array[i] is T
                if let Some(array_type) = self.infer_expression_type(array) {
                    match array_type {
                        HirType::Array { element_type, .. } => Some(*element_type),
                        HirType::Pointer(element_type) => Some(*element_type),
                        _ => None,
                    }
                } else {
                    None
                }
            }
            _ => None,
        }
    }
}

/// Code generator for converting HIR to Rust source code.
#[derive(Debug, Clone)]
pub struct CodeGenerator {
    box_transformer: box_transform::BoxTransformer,
}

impl CodeGenerator {
    /// Create a new code generator.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    ///
    /// let codegen = CodeGenerator::new();
    /// ```
    pub fn new() -> Self {
        Self {
            box_transformer: box_transform::BoxTransformer::new(),
        }
    }

    /// Generate Rust code for a macro definition.
    ///
    /// Transforms C #define macros to Rust const declarations (for object-like macros)
    /// or inline functions (for function-like macros).
    ///
    /// # Supported Macro Types (DECY-098c)
    ///
    /// **Object-like macros** (constants) are fully supported:
    /// - `#define MAX 100` → `const MAX: i32 = 100;`
    /// - `#define PI 3.14159` → `const PI: f64 = 3.14159;`
    /// - `#define GREETING "Hello"` → `const GREETING: &str = "Hello";`
    ///
    /// **Function-like macros** are not yet supported (DECY-098d):
    /// - `#define SQR(x) ((x) * (x))` → Error
    ///
    /// # Type Inference
    ///
    /// Types are automatically inferred from the macro body:
    /// - String literals → `&str`
    /// - Character literals → `char`
    /// - Floating point → `f64`
    /// - Integers (including hex/octal) → `i32`
    ///
    /// # Edge Cases
    ///
    /// - Empty macros generate comments: `#define EMPTY` → `// Empty macro: EMPTY`
    /// - Macro names are preserved exactly (SCREAMING_SNAKE_CASE maintained)
    ///
    /// # Errors
    ///
    /// Returns an error if:
    /// - The macro is function-like (not yet implemented)
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::HirMacroDefinition;
    ///
    /// let generator = CodeGenerator::new();
    /// let macro_def = HirMacroDefinition::new_object_like("MAX".to_string(), "100".to_string());
    /// let rust_code = generator.generate_macro(&macro_def).unwrap();
    /// assert!(rust_code.contains("const MAX"));
    /// # Ok::<(), anyhow::Error>(())
    /// ```
    ///
    /// # Reference
    ///
    /// - K&R §4.11: Macro Substitution
    /// - ISO C99 §6.10.3: Macro replacement
    pub fn generate_macro(
        &self,
        macro_def: &decy_hir::HirMacroDefinition,
    ) -> anyhow::Result<String> {
        if macro_def.is_function_like() {
            // Generate inline function for function-like macros
            return self.generate_function_like_macro(macro_def);
        }

        // Object-like macro (constant)
        let name = macro_def.name();
        let body = macro_def.body();

        // Handle empty macros
        if body.is_empty() {
            return Ok(format!("// Empty macro: {}", name));
        }

        // Infer type from macro body
        let (rust_type, rust_value) = self.infer_macro_type(body)?;

        Ok(format!("const {}: {} = {};", name, rust_type, rust_value))
    }

    /// Generate Rust inline function from function-like macro.
    ///
    /// Transforms C function-like macros to Rust inline functions:
    /// - `#define SQR(x) ((x) * (x))` → `fn sqr(x: i32) -> i32 { x * x }`
    /// - `#define MAX(a, b) ((a) > (b) ? (a) : (b))` → `fn max(a: i32, b: i32) -> i32 { if a > b { a } else { b } }`
    ///
    /// # Features
    ///
    /// - Converts macro name from SCREAMING_SNAKE_CASE to snake_case
    /// - Infers parameter types (defaults to i32)
    /// - Infers return type from expression
    /// - Adds `#[inline]` attribute for performance
    /// - Transforms ternary operator (? :) to if-else
    /// - Removes unnecessary parentheses
    fn generate_function_like_macro(
        &self,
        macro_def: &decy_hir::HirMacroDefinition,
    ) -> anyhow::Result<String> {
        let name = macro_def.name();
        let params = macro_def.parameters();
        let body = macro_def.body();

        // Convert SCREAMING_SNAKE_CASE to snake_case
        let fn_name = self.convert_to_snake_case(name);

        // Generate parameter list (default to i32 for now)
        let param_list = params
            .iter()
            .map(|p| format!("{}: i32", p))
            .collect::<Vec<_>>()
            .join(", ");

        // Transform macro body to Rust expression
        let rust_body = self.transform_macro_body(body, params)?;

        // Infer return type from body
        let return_type = self.infer_return_type(body);

        // Generate function
        let result = format!(
            "#[inline]\nfn {}({}) -> {} {{\n    {}\n}}",
            fn_name, param_list, return_type, rust_body
        );

        Ok(result)
    }

    /// Convert SCREAMING_SNAKE_CASE to snake_case.
    fn convert_to_snake_case(&self, name: &str) -> String {
        name.to_lowercase()
    }

    /// Transform C macro body to Rust expression.
    ///
    /// Transformations:
    /// - Remove outer parentheses: ((x) * (x)) → x * x
    /// - Ternary operator: (a) > (b) ? (a) : (b) → if a > b { a } else { b }
    /// - Remove parameter parentheses: (x) → x
    fn transform_macro_body(&self, body: &str, params: &[String]) -> anyhow::Result<String> {
        let mut result = body.to_string();

        // Check for ternary operator
        if result.contains('?') && result.contains(':') {
            result = self.transform_ternary(&result)?;
        } else {
            // Remove unnecessary parentheses around parameters
            for param in params {
                result = result.replace(&format!("({})", param), param);
            }

            // Remove outer parentheses if present
            result = self.remove_outer_parens(&result);

            // Add spaces around operators for readability
            result = self.add_operator_spaces(&result);
        }

        Ok(result)
    }

    /// Transform C ternary operator to Rust if-else.
    ///
    /// Example: ((a)>(b)?(a):(b)) → if a > b { a } else { b }
    fn transform_ternary(&self, expr: &str) -> anyhow::Result<String> {
        // Find the ? and : positions
        let question_pos = expr.find('?').unwrap_or(0);
        let colon_pos = expr.rfind(':').unwrap_or(0);

        if question_pos == 0 || colon_pos == 0 || colon_pos <= question_pos {
            // Malformed ternary, return as-is
            return Ok(expr.to_string());
        }

        // Extract parts
        let condition = expr[..question_pos].trim();
        let true_expr = expr[question_pos + 1..colon_pos].trim();
        let false_expr = expr[colon_pos + 1..].trim();

        // Clean up each part
        let condition = self.remove_outer_parens(condition);
        let condition = self.clean_expression(&condition);
        let true_expr = self.remove_outer_parens(true_expr);
        let true_expr = self.clean_expression(&true_expr);
        let false_expr = self.remove_outer_parens(false_expr);
        let false_expr = self.clean_expression(&false_expr);

        Ok(format!(
            "if {} {{ {} }} else {{ {} }}",
            condition, true_expr, false_expr
        ))
    }

    /// Remove outer parentheses from expression.
    fn remove_outer_parens(&self, expr: &str) -> String {
        Self::remove_outer_parens_impl(expr)
    }

    /// Implementation of remove_outer_parens (recursive helper).
    fn remove_outer_parens_impl(expr: &str) -> String {
        let trimmed = expr.trim();
        if trimmed.starts_with('(') && trimmed.ends_with(')') {
            // Check if these are matching outer parens
            let mut depth = 0;
            let chars: Vec<char> = trimmed.chars().collect();
            for (i, ch) in chars.iter().enumerate() {
                match ch {
                    '(' => depth += 1,
                    ')' => {
                        depth -= 1;
                        if depth == 0 && i < chars.len() - 1 {
                            // Found closing paren before end, not outer parens
                            return trimmed.to_string();
                        }
                    }
                    _ => {}
                }
            }
            // These are outer parens, remove them
            return Self::remove_outer_parens_impl(&trimmed[1..trimmed.len() - 1]);
        }
        trimmed.to_string()
    }

    /// Clean expression by removing parameter parentheses.
    fn clean_expression(&self, expr: &str) -> String {
        let mut result = expr.to_string();

        // Handle negation: -(x) → -x (preserve the minus)
        result = result.replace("-(x)", "-x");
        result = result.replace("-(a)", "-a");
        result = result.replace("-(b)", "-b");
        result = result.replace("-(c)", "-c");
        result = result.replace("-(n)", "-n");

        // Remove parentheses around single identifiers (not negated)
        // This is a simplified version - could be enhanced
        result = result.replace("(x)", "x");
        result = result.replace("(a)", "a");
        result = result.replace("(b)", "b");
        result = result.replace("(c)", "c");
        result = result.replace("(n)", "n");

        // Add spaces around operators
        result = self.add_operator_spaces(&result);

        result
    }

    /// Add spaces around operators for readability.
    fn add_operator_spaces(&self, expr: &str) -> String {
        let mut result = expr.to_string();

        // Add spaces around comparison operators
        result = result.replace(">", " > ");
        result = result.replace("<", " < ");
        result = result.replace("==", " == ");
        result = result.replace("!=", " != ");
        result = result.replace(">=", " >= ");
        result = result.replace("<=", " <= ");

        // Add spaces around logical operators (do this before arithmetic to avoid issues)
        result = result.replace("&&", " && ");
        result = result.replace("||", " || ");

        // Add spaces around arithmetic operators
        result = result.replace("+", " + ");
        // Note: Don't blindly replace "-" as it could be unary minus
        // Only replace if it's not at the start or after a space
        let chars: Vec<char> = result.chars().collect();
        let mut new_result = String::new();
        for (i, ch) in chars.iter().enumerate() {
            if *ch == '-' {
                // Check if this is a binary minus (has non-space before it)
                if i > 0 && !chars[i - 1].is_whitespace() && chars[i - 1] != '(' {
                    new_result.push(' ');
                    new_result.push(*ch);
                    new_result.push(' ');
                } else {
                    // Unary minus, keep as-is
                    new_result.push(*ch);
                }
            } else {
                new_result.push(*ch);
            }
        }
        result = new_result;

        result = result.replace("*", " * ");
        result = result.replace("/", " / ");
        result = result.replace("%", " % ");

        // Clean up multiple spaces
        while result.contains("  ") {
            result = result.replace("  ", " ");
        }

        result.trim().to_string()
    }

    /// Infer return type from macro body.
    ///
    /// Simple heuristic:
    /// - Contains ternary operator (? :) → return type of branches (check for comparison at top level)
    /// - Contains comparison operators at top level (not in ternary) → bool
    /// - Contains logical operators (&&, ||) → bool
    /// - Default → i32
    fn infer_return_type(&self, body: &str) -> String {
        // Check for ternary - return type depends on the branches, not the condition
        if body.contains('?') && body.contains(':') {
            // For ternary, the return type is determined by what's returned, not the condition
            // In most C macros like MAX(a,b), the return type is i32 even though condition is bool
            return "i32".to_string();
        }

        // Check for logical operators (&&, ||) at top level
        if body.contains("&&") || body.contains("||") {
            return "bool".to_string();
        }

        // Check if it's a standalone comparison (no ternary)
        if (body.contains('>') || body.contains('<') || body.contains("==") || body.contains("!="))
            && !body.contains('?')
        {
            // Standalone comparison returns bool
            "bool".to_string()
        } else {
            // Default to i32
            "i32".to_string()
        }
    }

    /// Infer the Rust type and value from a C macro body.
    ///
    /// This function analyzes the macro body string and determines the appropriate
    /// Rust type and formatted value.
    ///
    /// # Type Inference Rules
    ///
    /// - String literals (`"text"`) → `&str`
    /// - Character literals (`'c'`) → `char`
    /// - Floating point (contains `.` or `e`/`E`) → `f64`
    /// - Hexadecimal (`0xFF`) → `i32` (preserves hex format)
    /// - Octal (`0755`) → `i32` (preserves octal format)
    /// - Integers (parseable as i32) → `i32`
    /// - Default (expressions) → `i32`
    ///
    /// # Returns
    ///
    /// Returns a tuple of (rust_type, rust_value) where:
    /// - `rust_type`: The Rust type as a string (e.g., "i32", "&str")
    /// - `rust_value`: The formatted value (e.g., "100", "\"Hello\"")
    ///
    /// # Examples
    ///
    /// ```
    /// # use decy_codegen::CodeGenerator;
    /// let generator = CodeGenerator::new();
    /// // This is a private method, but tested through generate_macro
    /// # Ok::<(), anyhow::Error>(())
    /// ```
    fn infer_macro_type(&self, body: &str) -> anyhow::Result<(String, String)> {
        let body = body.trim();

        // String literal: "..." → &str
        if body.starts_with('"') && body.ends_with('"') {
            return Ok(("&str".to_string(), body.to_string()));
        }

        // Character literal: '...' → char
        if body.starts_with('\'') && body.ends_with('\'') {
            return Ok(("char".to_string(), body.to_string()));
        }

        // Floating point: contains '.' or 'e'/'E' → f64
        if body.contains('.') || body.contains('e') || body.contains('E') {
            return Ok(("f64".to_string(), body.to_string()));
        }

        // Hexadecimal: 0x... or 0X... → i32 (keep hex format)
        if body.starts_with("0x") || body.starts_with("0X") {
            return Ok(("i32".to_string(), body.to_string()));
        }

        // Octal: 0... → i32
        if body.starts_with('0') && body.len() > 1 && body.chars().nth(1).unwrap().is_ascii_digit()
        {
            return Ok(("i32".to_string(), body.to_string()));
        }

        // Try to parse as integer (handles negative numbers too)
        if body.parse::<i32>().is_ok() {
            return Ok(("i32".to_string(), body.to_string()));
        }

        // Default: treat as i32 expression
        Ok(("i32".to_string(), body.to_string()))
    }

    /// Get the Box transformer.
    pub fn box_transformer(&self) -> &box_transform::BoxTransformer {
        &self.box_transformer
    }

    /// Map HIR type to Rust type string.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::HirType;
    ///
    /// assert_eq!(CodeGenerator::map_type(&HirType::Int), "i32");
    /// assert_eq!(CodeGenerator::map_type(&HirType::Float), "f32");
    /// assert_eq!(CodeGenerator::map_type(&HirType::Box(Box::new(HirType::Int))), "Box<i32>");
    /// ```
    pub fn map_type(hir_type: &HirType) -> String {
        match hir_type {
            HirType::Void => "()".to_string(),
            HirType::Int => "i32".to_string(),
            HirType::Float => "f32".to_string(),
            HirType::Double => "f64".to_string(),
            HirType::Char => "u8".to_string(),
            HirType::Pointer(inner) => {
                format!("*mut {}", Self::map_type(inner))
            }
            HirType::Box(inner) => {
                format!("Box<{}>", Self::map_type(inner))
            }
            HirType::Vec(inner) => {
                format!("Vec<{}>", Self::map_type(inner))
            }
            HirType::Option(inner) => {
                format!("Option<{}>", Self::map_type(inner))
            }
            HirType::Reference { inner, mutable } => {
                // DECY-072: Special case for slices: &Vec<T> → &[T]
                if let HirType::Vec(element_type) = &**inner {
                    let element_str = Self::map_type(element_type);
                    if *mutable {
                        format!("&mut [{}]", element_str)
                    } else {
                        format!("&[{}]", element_str)
                    }
                } else if *mutable {
                    format!("&mut {}", Self::map_type(inner))
                } else {
                    format!("&{}", Self::map_type(inner))
                }
            }
            HirType::Struct(name) => name.clone(),
            HirType::Enum(name) => name.clone(),
            HirType::Array { element_type, size } => {
                if let Some(n) = size {
                    format!("[{}; {}]", Self::map_type(element_type), n)
                } else {
                    // Unsized array - use slice reference
                    format!("[{}]", Self::map_type(element_type))
                }
            }
            HirType::FunctionPointer {
                param_types,
                return_type,
            } => {
                // C: int (*func_ptr)(int, int); → Rust: fn(i32, i32) -> i32
                let params: Vec<String> = param_types.iter().map(Self::map_type).collect();
                let params_str = params.join(", ");

                // Skip return type annotation for void
                if matches!(**return_type, HirType::Void) {
                    format!("fn({})", params_str)
                } else {
                    format!("fn({}) -> {}", params_str, Self::map_type(return_type))
                }
            }
            HirType::StringLiteral => "&str".to_string(),
            HirType::OwnedString => "String".to_string(),
            HirType::StringReference => "&str".to_string(),
            HirType::Union(_) => {
                // Unions will be transformed to Rust enums
                // For now, return a placeholder
                "/* Union type */".to_string()
            }
        }
    }

    /// Map C type name from sizeof to Rust type string.
    ///
    /// Handles type names as strings from sizeof expressions.
    /// Examples: "int" → "i32", "struct Data" → "Data"
    fn map_sizeof_type(&self, c_type_name: &str) -> String {
        let trimmed = c_type_name.trim();

        // Handle basic C types
        match trimmed {
            "int" => "i32".to_string(),
            "float" => "f32".to_string(),
            "double" => "f64".to_string(),
            "char" => "u8".to_string(),
            "void" => "()".to_string(),
            _ => {
                // Handle "struct TypeName" → "TypeName"
                if let Some(struct_name) = trimmed.strip_prefix("struct ") {
                    struct_name.trim().to_string()
                } else {
                    // Keep custom type names as-is
                    trimmed.to_string()
                }
            }
        }
    }

    /// Generate code for an expression.
    #[allow(clippy::only_used_in_recursion)]
    pub fn generate_expression(&self, expr: &HirExpression) -> String {
        self.generate_expression_with_context(expr, &TypeContext::new())
    }

    /// Generate code for an expression with type context for pointer arithmetic.
    #[allow(clippy::only_used_in_recursion)]
    fn generate_expression_with_context(&self, expr: &HirExpression, ctx: &TypeContext) -> String {
        self.generate_expression_with_target_type(expr, ctx, None)
    }

    /// Generate code for an expression with optional target type hint for null pointer detection.
    /// If target_type is Some(HirType::Pointer(_)) and expr is IntLiteral(0), generates std::ptr::null_mut().
    #[allow(clippy::only_used_in_recursion)]
    fn generate_expression_with_target_type(
        &self,
        expr: &HirExpression,
        ctx: &TypeContext,
        target_type: Option<&HirType>,
    ) -> String {
        match expr {
            HirExpression::IntLiteral(val) => {
                // Check if assigning 0 to a pointer type
                if *val == 0 {
                    if let Some(HirType::Pointer(_)) = target_type {
                        return "std::ptr::null_mut()".to_string();
                    }
                }
                val.to_string()
            }
            HirExpression::StringLiteral(s) => format!("\"{}\"", s),
            HirExpression::Variable(name) => name.clone(),
            HirExpression::BinaryOp { op, left, right } => {
                // Check for Option comparison with NULL → is_none() / is_some()
                // p == NULL → p.is_none(), p != NULL → p.is_some()
                if matches!(op, BinaryOperator::Equal | BinaryOperator::NotEqual) {
                    // Check if left is an Option and right is NULL
                    if let HirExpression::Variable(var_name) = &**left {
                        if ctx.is_option(var_name) && matches!(**right, HirExpression::NullLiteral)
                        {
                            return match op {
                                BinaryOperator::Equal => format!("{}.is_none()", var_name),
                                BinaryOperator::NotEqual => format!("{}.is_some()", var_name),
                                _ => unreachable!(),
                            };
                        }
                    }
                    // Check if right is an Option and left is NULL (NULL == p or NULL != p)
                    if let HirExpression::Variable(var_name) = &**right {
                        if ctx.is_option(var_name) && matches!(**left, HirExpression::NullLiteral) {
                            return match op {
                                BinaryOperator::Equal => format!("{}.is_none()", var_name),
                                BinaryOperator::NotEqual => format!("{}.is_some()", var_name),
                                _ => unreachable!(),
                            };
                        }
                    }

                    // Check for pointer comparison with 0 (null pointer comparison)
                    // ptr == 0 or ptr != 0 should become ptr == std::ptr::null_mut() or ptr != std::ptr::null_mut()
                    // Check if left is a pointer and right is 0
                    if let HirExpression::Variable(var_name) = &**left {
                        if ctx.is_pointer(var_name) {
                            if let HirExpression::IntLiteral(0) = **right {
                                let op_str = Self::binary_operator_to_string(op);
                                return format!("{} {} std::ptr::null_mut()", var_name, op_str);
                            }
                        }
                    }
                    // Check if right is a pointer and left is 0 (0 == ptr or 0 != ptr)
                    if let HirExpression::Variable(var_name) = &**right {
                        if ctx.is_pointer(var_name) {
                            if let HirExpression::IntLiteral(0) = **left {
                                let op_str = Self::binary_operator_to_string(op);
                                return format!("std::ptr::null_mut() {} {}", op_str, var_name);
                            }
                        }
                    }
                }

                let left_code = self.generate_expression_with_context(left, ctx);
                let right_code = self.generate_expression_with_context(right, ctx);
                let op_str = Self::binary_operator_to_string(op);

                // Add parentheses for nested binary operations
                let left_str = if matches!(**left, HirExpression::BinaryOp { .. }) {
                    format!("({})", left_code)
                } else {
                    left_code.clone()
                };

                let right_str = if matches!(**right, HirExpression::BinaryOp { .. }) {
                    format!("({})", right_code)
                } else {
                    right_code.clone()
                };

                // DECY-041: Detect pointer arithmetic using type context
                if matches!(op, BinaryOperator::Add | BinaryOperator::Subtract) {
                    if let HirExpression::Variable(var_name) = &**left {
                        if ctx.is_pointer(var_name) {
                            // This is pointer arithmetic - generate unsafe pointer method calls
                            return match op {
                                BinaryOperator::Add => {
                                    format!(
                                        "unsafe {{ {}.wrapping_add({} as usize) }}",
                                        left_str, right_str
                                    )
                                }
                                BinaryOperator::Subtract => {
                                    // Check if right is also a pointer (ptr - ptr) or integer (ptr - offset)
                                    if let HirExpression::Variable(right_var) = &**right {
                                        if ctx.is_pointer(right_var) {
                                            // ptr - ptr: calculate difference (returns isize, cast to i32 for C compatibility)
                                            format!(
                                                "unsafe {{ {}.offset_from({}) as i32 }}",
                                                left_str, right_str
                                            )
                                        } else {
                                            // ptr - integer offset
                                            format!(
                                                "unsafe {{ {}.wrapping_sub({} as usize) }}",
                                                left_str, right_str
                                            )
                                        }
                                    } else {
                                        // ptr - integer offset (literal or expression)
                                        format!(
                                            "unsafe {{ {}.wrapping_sub({} as usize) }}",
                                            left_str, right_str
                                        )
                                    }
                                }
                                _ => unreachable!(),
                            };
                        }
                    }
                }

                format!("{} {} {}", left_str, op_str, right_str)
            }
            HirExpression::Dereference(inner) => {
                let inner_code = self.generate_expression_with_context(inner, ctx);

                // DECY-041: Check if dereferencing a raw pointer - if so, wrap in unsafe
                if let HirExpression::Variable(var_name) = &**inner {
                    if ctx.is_pointer(var_name) {
                        return format!("unsafe {{ *{} }}", inner_code);
                    }
                }

                format!("*{}", inner_code)
            }
            HirExpression::AddressOf(inner) => {
                let inner_code = self.generate_expression_with_context(inner, ctx);
                // Add parentheses for non-trivial expressions
                if matches!(**inner, HirExpression::Dereference(_)) {
                    format!("&({})", inner_code)
                } else {
                    format!("&{}", inner_code)
                }
            }
            HirExpression::UnaryOp { op, operand } => {
                use decy_hir::UnaryOperator;
                match op {
                    // Post-increment: x++ → { let tmp = x; x += 1; tmp }
                    // Returns old value before incrementing
                    UnaryOperator::PostIncrement => {
                        let operand_code = self.generate_expression_with_context(operand, ctx);
                        format!(
                            "{{ let tmp = {}; {} += 1; tmp }}",
                            operand_code, operand_code
                        )
                    }
                    // Post-decrement: x-- → { let tmp = x; x -= 1; tmp }
                    // Returns old value before decrementing
                    UnaryOperator::PostDecrement => {
                        let operand_code = self.generate_expression_with_context(operand, ctx);
                        format!(
                            "{{ let tmp = {}; {} -= 1; tmp }}",
                            operand_code, operand_code
                        )
                    }
                    // Pre-increment: ++x → { x += 1; x }
                    // Increments first, then returns new value
                    UnaryOperator::PreIncrement => {
                        let operand_code = self.generate_expression_with_context(operand, ctx);
                        format!("{{ {} += 1; {} }}", operand_code, operand_code)
                    }
                    // Pre-decrement: --x → { x -= 1; x }
                    // Decrements first, then returns new value
                    UnaryOperator::PreDecrement => {
                        let operand_code = self.generate_expression_with_context(operand, ctx);
                        format!("{{ {} -= 1; {} }}", operand_code, operand_code)
                    }
                    // Simple prefix operators
                    _ => {
                        let op_str = Self::unary_operator_to_string(op);
                        let operand_code = self.generate_expression_with_context(operand, ctx);
                        format!("{}{}", op_str, operand_code)
                    }
                }
            }
            HirExpression::FunctionCall {
                function,
                arguments,
            } => {
                // Special handling for standard library functions
                match function.as_str() {
                    // strlen(s) → s.len()
                    // Reference: K&R §B3, ISO C99 §7.21.6.3
                    "strlen" => {
                        if arguments.len() == 1 {
                            format!(
                                "{}.len()",
                                self.generate_expression_with_context(&arguments[0], ctx)
                            )
                        } else {
                            // Invalid strlen call - shouldn't happen, but handle gracefully
                            let args: Vec<String> = arguments
                                .iter()
                                .map(|arg| self.generate_expression_with_context(arg, ctx))
                                .collect();
                            format!("{}({})", function, args.join(", "))
                        }
                    }
                    // strcpy(dest, src) → src.to_string()
                    // Reference: K&R §B3, ISO C99 §7.21.3.1
                    // strcpy copies src to dest and returns dest pointer.
                    // In Rust, we transform to String operation: src.to_string()
                    // This prevents buffer overflow (the primary safety benefit)
                    "strcpy" => {
                        if arguments.len() == 2 {
                            // strcpy(dest, src) → src.to_string()
                            // We generate the source string operation
                            // The destination assignment is handled by the statement context
                            format!(
                                "{}.to_string()",
                                self.generate_expression_with_context(&arguments[1], ctx)
                            )
                        } else {
                            // Invalid strcpy call - shouldn't happen, but handle gracefully
                            let args: Vec<String> = arguments
                                .iter()
                                .map(|arg| self.generate_expression_with_context(arg, ctx))
                                .collect();
                            format!("{}({})", function, args.join(", "))
                        }
                    }
                    // Default: pass through function call as-is
                    _ => {
                        let args: Vec<String> = arguments
                            .iter()
                            .map(|arg| self.generate_expression_with_context(arg, ctx))
                            .collect();
                        format!("{}({})", function, args.join(", "))
                    }
                }
            }
            HirExpression::FieldAccess { object, field } => {
                format!(
                    "{}.{}",
                    self.generate_expression_with_context(object, ctx),
                    field
                )
            }
            HirExpression::PointerFieldAccess { pointer, field } => {
                // In Rust, ptr->field becomes (*ptr).field
                // However, if the pointer is already a field access (ptr->field1->field2),
                // we should generate (*ptr).field1.field2 not (*(*ptr).field1).field2
                match &**pointer {
                    // If the pointer is itself a field access expression, we can chain with .
                    HirExpression::PointerFieldAccess { .. }
                    | HirExpression::FieldAccess { .. } => {
                        format!(
                            "{}.{}",
                            self.generate_expression_with_context(pointer, ctx),
                            field
                        )
                    }
                    // For other expressions (variables, array index, etc), we need explicit deref
                    _ => {
                        format!(
                            "(*{}).{}",
                            self.generate_expression_with_context(pointer, ctx),
                            field
                        )
                    }
                }
            }
            HirExpression::ArrayIndex { array, index } => {
                let array_code = self.generate_expression_with_context(array, ctx);
                let index_code = self.generate_expression_with_context(index, ctx);

                // DECY-041: Check if array is a raw pointer - if so, use unsafe pointer arithmetic
                if let HirExpression::Variable(var_name) = &**array {
                    if ctx.is_pointer(var_name) {
                        // Raw pointer indexing: arr[i] becomes unsafe { *arr.add(i as usize) }
                        return format!(
                            "unsafe {{ *{}.add({} as usize) }}",
                            array_code, index_code
                        );
                    }
                }

                // Regular array/slice indexing
                // DECY-072: Cast index to usize for slice indexing
                format!("{}[{} as usize]", array_code, index_code)
            }
            HirExpression::SliceIndex { slice, index, .. } => {
                // DECY-070 GREEN: Generate safe slice indexing (0 unsafe blocks!)
                // SliceIndex represents pointer arithmetic transformed to safe indexing
                let slice_code = self.generate_expression_with_context(slice, ctx);
                let index_code = self.generate_expression_with_context(index, ctx);
                // Generate: slice[index] - guaranteed safe, bounds-checked at runtime
                format!("{}[{}]", slice_code, index_code)
            }
            HirExpression::Sizeof { type_name } => {
                // sizeof(int) → std::mem::size_of::<i32>() as i32
                // sizeof(struct Data) → std::mem::size_of::<Data>() as i32
                // Note: size_of returns usize, but C's sizeof returns int (typically i32)
                let rust_type = self.map_sizeof_type(type_name);
                format!("std::mem::size_of::<{}>() as i32", rust_type)
            }
            HirExpression::NullLiteral => {
                // NULL → None
                "None".to_string()
            }
            HirExpression::IsNotNull(inner) => {
                // p != NULL → if let Some(p) = p
                // This is a helper expression for generating Option checks
                // In actual codegen, we transform if (p) to if let Some(_) = p
                let inner_code = self.generate_expression_with_context(inner, ctx);
                format!("if let Some(_) = {}", inner_code)
            }
            HirExpression::Calloc {
                count,
                element_type,
            } => {
                // calloc(n, sizeof(T)) → vec![0T; n]
                // Generate zero-initialized vec![default; count]
                let count_code = self.generate_expression_with_context(count, ctx);

                // Get default value with type suffix for clarity
                let default_value = match element_type.as_ref() {
                    HirType::Int => "0i32",
                    HirType::Float => "0.0f32",
                    HirType::Double => "0.0f64",
                    HirType::Char => "0u8",
                    _ => &Self::default_value_for_type(element_type),
                };

                format!("vec![{}; {}]", default_value, count_code)
            }
            HirExpression::Malloc { size } => {
                // malloc(size) should have been transformed to Box or Vec by analyzer
                // If we're generating this directly, treat it as Box::new(default)
                // Note: The proper transformation should happen at HIR level via PatternDetector

                // Try to detect if this is an array allocation (n * sizeof(T))
                // If so, generate Vec::with_capacity
                if let HirExpression::BinaryOp {
                    op: decy_hir::BinaryOperator::Multiply,
                    left,
                    ..
                } = size.as_ref()
                {
                    // This looks like n * sizeof(T) → Vec::with_capacity(n)
                    let capacity_code = self.generate_expression_with_context(left, ctx);
                    format!("Vec::with_capacity({})", capacity_code)
                } else {
                    // Single allocation → Box::new(default)
                    "Box::new(0i32)".to_string()
                }
            }
            HirExpression::Realloc { pointer, new_size } => {
                // realloc(ptr, new_size) transformation depends on context:
                // 1. realloc(NULL, size) → treat as malloc (Vec allocation)
                // 2. realloc(ptr, 0) → treat as free (RAII comment or clear)
                // 3. realloc(ptr, new_size) → vec.resize(new_count, default)
                //
                // Since we're generating an expression here, we'll return a placeholder
                // The actual transformation should happen in Assignment statement handling
                // For now, just generate a comment indicating this needs special handling

                // Check if pointer is NULL → malloc equivalent
                if matches!(**pointer, HirExpression::NullLiteral) {
                    // realloc(NULL, size) → vec![default; count]
                    if let HirExpression::BinaryOp {
                        op: decy_hir::BinaryOperator::Multiply,
                        left,
                        ..
                    } = new_size.as_ref()
                    {
                        let count_code = self.generate_expression_with_context(left, ctx);
                        format!("vec![0i32; {}]", count_code)
                    } else {
                        "Vec::new()".to_string()
                    }
                } else {
                    // realloc(ptr, size) - this should be handled at statement level
                    // For expression context, return the pointer unchanged as a placeholder
                    self.generate_expression_with_context(pointer, ctx)
                }
            }
            HirExpression::StringMethodCall {
                receiver,
                method,
                arguments,
            } => {
                let receiver_code = self.generate_expression_with_context(receiver, ctx);
                if arguments.is_empty() {
                    // DECY-072: Cast .len() to i32 for slices/arrays (used with i32 loop counters)
                    // String .len() returns usize which is typically what's needed for strings
                    // But array/slice .len() often needs i32 for C loop patterns
                    // We cast for all cases to maintain C semantics (where sizeof returns int)
                    if method == "len" {
                        format!("{}.{}() as i32", receiver_code, method)
                    } else {
                        format!("{}.{}()", receiver_code, method)
                    }
                } else {
                    let args: Vec<String> = arguments
                        .iter()
                        .map(|arg| {
                            // For clone_into, we need &mut on the destination
                            if method == "clone_into" {
                                format!("&mut {}", self.generate_expression_with_context(arg, ctx))
                            } else {
                                self.generate_expression_with_context(arg, ctx)
                            }
                        })
                        .collect();
                    format!("{}.{}({})", receiver_code, method, args.join(", "))
                }
            }
            HirExpression::Cast { target_type, expr } => {
                // C: (int)x → Rust: x as i32
                // Sprint 19 Feature (DECY-059)
                let expr_code = self.generate_expression_with_context(expr, ctx);
                let rust_type = Self::map_type(target_type);

                // Wrap in parentheses if the expression is a binary operation
                let expr_str = if matches!(**expr, HirExpression::BinaryOp { .. }) {
                    format!("({})", expr_code)
                } else {
                    expr_code
                };

                format!("{} as {}", expr_str, rust_type)
            }
            HirExpression::CompoundLiteral {
                literal_type,
                initializers,
            } => {
                // C: (struct Point){10, 20} → Rust: Point { field0: 10, field1: 20 }
                // C: (int[]){1, 2, 3} → Rust: vec![1, 2, 3] or [1, 2, 3]
                // Sprint 19 Feature (DECY-060)
                match literal_type {
                    HirType::Struct(name) => {
                        // Generate struct literal: StructName { field0: val0, field1: val1, ... }
                        if initializers.is_empty() {
                            // Empty struct: Point {}
                            format!("{} {{}}", name)
                        } else {
                            let fields: Vec<String> = initializers
                                .iter()
                                .enumerate()
                                .map(|(i, init)| {
                                    let init_code =
                                        self.generate_expression_with_context(init, ctx);
                                    format!("field{}: {}", i, init_code)
                                })
                                .collect();
                            format!("{} {{ {} }}", name, fields.join(", "))
                        }
                    }
                    HirType::Array { .. } => {
                        // Generate array literal: vec![1, 2, 3] or [1, 2, 3]
                        if initializers.is_empty() {
                            "vec![]".to_string()
                        } else {
                            let elements: Vec<String> = initializers
                                .iter()
                                .map(|init| self.generate_expression_with_context(init, ctx))
                                .collect();
                            format!("vec![{}]", elements.join(", "))
                        }
                    }
                    _ => {
                        // For other types, generate a reasonable default
                        // This is a simplified implementation
                        format!(
                            "/* Compound literal of type {} */",
                            Self::map_type(literal_type)
                        )
                    }
                }
            }
        }
    }

    /// Convert unary operator to string.
    fn unary_operator_to_string(op: &decy_hir::UnaryOperator) -> &'static str {
        use decy_hir::UnaryOperator;
        match op {
            UnaryOperator::Minus => "-",
            UnaryOperator::LogicalNot => "!",
            UnaryOperator::BitwiseNot => "~",
            UnaryOperator::AddressOf => "&",
            // Post/Pre-increment/decrement are handled as block expressions
            // in generate_expression_with_context, so should never reach here
            UnaryOperator::PostIncrement
            | UnaryOperator::PostDecrement
            | UnaryOperator::PreIncrement
            | UnaryOperator::PreDecrement => {
                unreachable!("Increment/decrement operators should be handled as block expressions")
            }
        }
    }

    /// Convert binary operator to string.
    fn binary_operator_to_string(op: &BinaryOperator) -> &'static str {
        match op {
            BinaryOperator::Add => "+",
            BinaryOperator::Subtract => "-",
            BinaryOperator::Multiply => "*",
            BinaryOperator::Divide => "/",
            BinaryOperator::Modulo => "%",
            BinaryOperator::Equal => "==",
            BinaryOperator::NotEqual => "!=",
            BinaryOperator::LessThan => "<",
            BinaryOperator::GreaterThan => ">",
            BinaryOperator::LessEqual => "<=",
            BinaryOperator::GreaterEqual => ">=",
            BinaryOperator::LogicalAnd => "&&",
            BinaryOperator::LogicalOr => "||",
        }
    }

    /// Get default value for a type (for uninitialized variables).
    fn default_value_for_type(hir_type: &HirType) -> String {
        match hir_type {
            HirType::Void => "()".to_string(),
            HirType::Int => "0i32".to_string(),
            HirType::Float => "0.0f32".to_string(),
            HirType::Double => "0.0f64".to_string(),
            HirType::Char => "0u8".to_string(),
            HirType::Pointer(_) => "std::ptr::null_mut()".to_string(),
            HirType::Box(inner) => {
                // Box types should not use default values, they should be initialized with Box::new
                // This is just a fallback
                format!("Box::new({})", Self::default_value_for_type(inner))
            }
            HirType::Vec(_) => {
                // Vec types default to empty Vec
                "Vec::new()".to_string()
            }
            HirType::Option(_) => {
                // Option types default to None
                "None".to_string()
            }
            HirType::Reference { .. } => {
                // References cannot have default values - they must always be initialized
                // This should never be reached in valid code
                panic!("References must be initialized and cannot have default values")
            }
            HirType::Struct(name) => {
                format!("{}::default()", name)
            }
            HirType::Enum(name) => {
                format!("{}::default()", name)
            }
            HirType::Array { element_type, size } => {
                if let Some(n) = size {
                    format!("[{}; {}]", Self::default_value_for_type(element_type), n)
                } else {
                    // Unsized arrays cannot have default values - this should be initialized from parameter
                    panic!("Unsized arrays must be initialized and cannot have default values")
                }
            }
            HirType::FunctionPointer { .. } => {
                // Function pointers cannot have meaningful default values
                // They must be initialized with an actual function
                panic!("Function pointers must be initialized and cannot have default values")
            }
            HirType::StringLiteral => {
                // String literals default to empty string slice
                r#""""#.to_string()
            }
            HirType::OwnedString => {
                // Owned strings default to String::new()
                "String::new()".to_string()
            }
            HirType::StringReference => {
                // String references default to empty string slice
                r#""""#.to_string()
            }
            HirType::Union(_) => {
                // Unions will be transformed to enums
                // Default to the first variant's default value
                panic!("Union types must be initialized and cannot have default values")
            }
        }
    }

    /// Generate code for a statement.
    pub fn generate_statement(&self, stmt: &HirStatement) -> String {
        self.generate_statement_for_function(stmt, None)
    }

    /// Generate code for a statement, with optional function context.
    ///
    /// When function_name is "main", special handling applies (DECY-AUDIT-001):
    /// - return N; becomes std::process::exit(N);
    fn generate_statement_for_function(
        &self,
        stmt: &HirStatement,
        function_name: Option<&str>,
    ) -> String {
        self.generate_statement_with_context(stmt, function_name, &mut TypeContext::new(), None)
    }

    /// Generate code for a statement with type context for pointer arithmetic and return type for null pointer detection.
    fn generate_statement_with_context(
        &self,
        stmt: &HirStatement,
        function_name: Option<&str>,
        ctx: &mut TypeContext,
        return_type: Option<&HirType>,
    ) -> String {
        match stmt {
            HirStatement::VariableDeclaration {
                name,
                var_type,
                initializer,
            } => {
                // Check for VLA pattern: Array with size: None and an initializer
                // C99 VLA: int arr[n]; where n is runtime-determined
                // Rust: let arr = vec![0i32; n];
                if let HirType::Array {
                    element_type,
                    size: None,
                } = var_type
                {
                    // This is a VLA - transform to Vec
                    if let Some(size_expr) = initializer {
                        // VLA → Vec
                        let size_code = self.generate_expression_with_context(size_expr, ctx);
                        let default_value = match element_type.as_ref() {
                            HirType::Int => "0i32",
                            HirType::Float => "0.0f32",
                            HirType::Double => "0.0f64",
                            HirType::Char => "0u8",
                            _ => &Self::default_value_for_type(element_type),
                        };

                        // Register the variable as Vec type in context
                        ctx.add_variable(
                            name.clone(),
                            HirType::Vec(Box::new(element_type.as_ref().clone())),
                        );

                        return format!(
                            "let mut {} = vec![{}; {}];",
                            name, default_value, size_code
                        );
                    }
                }

                // Add variable to type context for pointer arithmetic detection
                ctx.add_variable(name.clone(), var_type.clone());

                let mut code = format!("let mut {}: {}", name, Self::map_type(var_type));
                if let Some(init_expr) = initializer {
                    // Special handling for Malloc expressions - use var_type to generate correct Box::new
                    if matches!(init_expr, HirExpression::Malloc { .. }) {
                        // Malloc → Box::new or Vec (depending on var_type)
                        match var_type {
                            HirType::Box(inner) => {
                                code.push_str(&format!(
                                    " = Box::new({});",
                                    Self::default_value_for_type(inner)
                                ));
                            }
                            HirType::Vec(_) => {
                                // Extract capacity from malloc size expression
                                if let HirExpression::Malloc { size } = init_expr {
                                    if let HirExpression::BinaryOp {
                                        op: decy_hir::BinaryOperator::Multiply,
                                        left,
                                        ..
                                    } = size.as_ref()
                                    {
                                        let capacity_code =
                                            self.generate_expression_with_context(left, ctx);
                                        code.push_str(&format!(
                                            " = Vec::with_capacity({});",
                                            capacity_code
                                        ));
                                    } else {
                                        code.push_str(" = Vec::new();");
                                    }
                                } else {
                                    code.push_str(" = Vec::new();");
                                }
                            }
                            _ => {
                                // Default to Box::new(0i32) for other types
                                code.push_str(" = Box::new(0i32);");
                            }
                        }
                    } else {
                        // Pass var_type as target type hint for null pointer detection
                        code.push_str(&format!(
                            " = {};",
                            self.generate_expression_with_target_type(
                                init_expr,
                                ctx,
                                Some(var_type)
                            )
                        ));
                    }
                } else {
                    // Provide default value for uninitialized variables
                    code.push_str(&format!(" = {};", Self::default_value_for_type(var_type)));
                }
                code
            }
            HirStatement::Return(expr_opt) => {
                // Special handling for main function (DECY-AUDIT-001)
                // return N; in main becomes std::process::exit(N);
                if function_name == Some("main") {
                    if let Some(expr) = expr_opt {
                        format!(
                            "std::process::exit({});",
                            self.generate_expression_with_context(expr, ctx)
                        )
                    } else {
                        "std::process::exit(0);".to_string()
                    }
                } else if let Some(expr) = expr_opt {
                    // Pass return type as target type hint for null pointer detection
                    format!(
                        "return {};",
                        self.generate_expression_with_target_type(expr, ctx, return_type)
                    )
                } else {
                    "return;".to_string()
                }
            }
            HirStatement::If {
                condition,
                then_block,
                else_block,
            } => {
                let mut code = String::new();

                // Generate if condition
                code.push_str(&format!(
                    "if {} {{\n",
                    self.generate_expression_with_context(condition, ctx)
                ));

                // Generate then block
                for stmt in then_block {
                    code.push_str("    ");
                    code.push_str(&self.generate_statement_with_context(
                        stmt,
                        function_name,
                        ctx,
                        return_type,
                    ));
                    code.push('\n');
                }

                // Generate else block if present
                if let Some(else_stmts) = else_block {
                    code.push_str("} else {\n");
                    for stmt in else_stmts {
                        code.push_str("    ");
                        code.push_str(&self.generate_statement_with_context(
                            stmt,
                            function_name,
                            ctx,
                            return_type,
                        ));
                        code.push('\n');
                    }
                }

                code.push('}');
                code
            }
            HirStatement::While { condition, body } => {
                let mut code = String::new();

                // Generate while condition
                code.push_str(&format!(
                    "while {} {{\n",
                    self.generate_expression_with_context(condition, ctx)
                ));

                // Generate loop body
                for stmt in body {
                    code.push_str("    ");
                    code.push_str(&self.generate_statement_with_context(
                        stmt,
                        function_name,
                        ctx,
                        return_type,
                    ));
                    code.push('\n');
                }

                code.push('}');
                code
            }
            HirStatement::Break => "break;".to_string(),
            HirStatement::Continue => "continue;".to_string(),
            HirStatement::Assignment { target, value } => {
                // Special handling for realloc() → Vec::resize/truncate/clear
                if let HirExpression::Realloc { pointer, new_size } = value {
                    // target is a String (variable name) in Assignment statements
                    let target_var = target.clone();

                    // Check if target is a Vec type to get element type
                    let element_type = if let Some(HirType::Vec(inner)) = ctx.get_type(&target_var)
                    {
                        inner.as_ref().clone()
                    } else {
                        // Fallback: assume i32
                        HirType::Int
                    };

                    // Check special cases:
                    // 1. realloc(ptr, 0) → clear or RAII comment
                    if let HirExpression::IntLiteral(0) = **new_size {
                        return format!("{}.clear(); // Free equivalent: clear vector", target_var);
                    }

                    // 2. realloc(NULL, size) → should not appear in assignment (would be in initializer)
                    //    but handle it gracefully if it does
                    if matches!(**pointer, HirExpression::NullLiteral) {
                        // This is essentially malloc - but in assignment context, we'll treat it as resize from 0
                        if let HirExpression::BinaryOp {
                            op: decy_hir::BinaryOperator::Multiply,
                            left,
                            ..
                        } = new_size.as_ref()
                        {
                            let count_code = self.generate_expression_with_context(left, ctx);
                            let default_value = Self::default_value_for_type(&element_type);
                            return format!(
                                "{}.resize({}, {})",
                                target_var, count_code, default_value
                            );
                        }
                    }

                    // 3. realloc(ptr, new_size) → vec.resize(new_count, default)
                    // Extract count from new_size (typically n * sizeof(T))
                    if let HirExpression::BinaryOp {
                        op: decy_hir::BinaryOperator::Multiply,
                        left,
                        ..
                    } = new_size.as_ref()
                    {
                        let count_code = self.generate_expression_with_context(left, ctx);
                        let default_value = Self::default_value_for_type(&element_type);
                        format!("{}.resize({}, {});", target_var, count_code, default_value)
                    } else {
                        // Fallback: if new_size is not n * sizeof(T), generate direct resize
                        // This handles edge cases where size isn't n * sizeof(T)
                        let size_expr = self.generate_expression_with_context(new_size, ctx);
                        let default_value = Self::default_value_for_type(&element_type);
                        format!(
                            "{}.resize({} as usize, {});",
                            target_var, size_expr, default_value
                        )
                    }
                } else {
                    // Regular assignment (not realloc)
                    let target_type = ctx.get_type(target);
                    format!(
                        "{} = {};",
                        target,
                        self.generate_expression_with_target_type(value, ctx, target_type)
                    )
                }
            }
            HirStatement::For {
                init,
                condition,
                increment,
                body,
            } => {
                let mut code = String::new();

                // Generate init statement before loop (if present)
                if let Some(init_stmt) = init {
                    code.push_str(&self.generate_statement_with_context(
                        init_stmt,
                        function_name,
                        ctx,
                        return_type,
                    ));
                    code.push('\n');
                }

                // Generate while loop with condition
                code.push_str(&format!(
                    "while {} {{\n",
                    self.generate_expression_with_context(condition, ctx)
                ));

                // Generate loop body
                for stmt in body {
                    code.push_str("    ");
                    code.push_str(&self.generate_statement_with_context(
                        stmt,
                        function_name,
                        ctx,
                        return_type,
                    ));
                    code.push('\n');
                }

                // Generate increment at end of body (if present)
                if let Some(inc_stmt) = increment {
                    code.push_str("    ");
                    code.push_str(&self.generate_statement_with_context(
                        inc_stmt,
                        function_name,
                        ctx,
                        return_type,
                    ));
                    code.push('\n');
                }

                code.push('}');
                code
            }
            HirStatement::Switch {
                condition,
                cases,
                default_case,
            } => {
                let mut code = String::new();

                // Generate match expression
                code.push_str(&format!(
                    "match {} {{\n",
                    self.generate_expression_with_context(condition, ctx)
                ));

                // Generate each case
                for case in cases {
                    if let Some(value_expr) = &case.value {
                        // Generate case pattern
                        code.push_str(&format!(
                            "    {} => {{\n",
                            self.generate_expression_with_context(value_expr, ctx)
                        ));

                        // Generate case body (filter out Break statements)
                        for stmt in &case.body {
                            if !matches!(stmt, HirStatement::Break) {
                                code.push_str("        ");
                                code.push_str(&self.generate_statement_with_context(
                                    stmt,
                                    function_name,
                                    ctx,
                                    return_type,
                                ));
                                code.push('\n');
                            }
                        }

                        code.push_str("    },\n");
                    }
                }

                // Generate default case (or empty default if not present)
                code.push_str("    _ => {\n");
                if let Some(default_stmts) = default_case {
                    for stmt in default_stmts {
                        if !matches!(stmt, HirStatement::Break) {
                            code.push_str("        ");
                            code.push_str(&self.generate_statement_with_context(
                                stmt,
                                function_name,
                                ctx,
                                return_type,
                            ));
                            code.push('\n');
                        }
                    }
                }
                code.push_str("    },\n");

                code.push('}');
                code
            }
            HirStatement::DerefAssignment { target, value } => {
                // Infer the type of *target for null pointer detection
                let target_type = ctx
                    .infer_expression_type(&HirExpression::Dereference(Box::new(target.clone())));
                format!(
                    "*{} = {};",
                    self.generate_expression_with_context(target, ctx),
                    self.generate_expression_with_target_type(value, ctx, target_type.as_ref())
                )
            }
            HirStatement::ArrayIndexAssignment {
                array,
                index,
                value,
            } => {
                // Infer the type of array[index] for null pointer detection
                let target_expr = HirExpression::ArrayIndex {
                    array: array.clone(),
                    index: index.clone(),
                };
                let target_type = ctx.infer_expression_type(&target_expr);
                // DECY-072: Cast index to usize for slice indexing
                format!(
                    "{}[{} as usize] = {};",
                    self.generate_expression_with_context(array, ctx),
                    self.generate_expression_with_context(index, ctx),
                    self.generate_expression_with_target_type(value, ctx, target_type.as_ref())
                )
            }
            HirStatement::FieldAssignment {
                object,
                field,
                value,
            } => {
                // Look up field type for null pointer detection
                let field_type = ctx.get_field_type(object, field);
                // Generate obj.field = value (works for both ptr->field and obj.field in Rust)
                format!(
                    "{}.{} = {};",
                    self.generate_expression_with_context(object, ctx),
                    field,
                    self.generate_expression_with_target_type(value, ctx, field_type.as_ref())
                )
            }
            HirStatement::Free { pointer } => {
                // free(ptr) → automatic drop via RAII
                // Generate a comment explaining that the memory will be deallocated automatically
                // when the variable goes out of scope
                let pointer_name = match pointer {
                    HirExpression::Variable(name) => name.clone(),
                    _ => self.generate_expression_with_context(pointer, ctx),
                };
                format!(
                    "// Memory for '{}' deallocated automatically by RAII",
                    pointer_name
                )
            }
            HirStatement::Expression(expr) => {
                // Expression statement: function calls, increments, etc. for side effects
                // DECY-065: Added to fix printf() and other function call statement bugs
                // C: printf("Hello"); → Rust: printf("Hello");
                format!("{};", self.generate_expression_with_context(expr, ctx))
            }
        }
    }

    /// Generate a function signature from HIR.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::{HirFunction, HirType};
    ///
    /// let func = HirFunction::new("test".to_string(), HirType::Void, vec![]);
    /// let codegen = CodeGenerator::new();
    /// let sig = codegen.generate_signature(&func);
    ///
    /// assert_eq!(sig, "fn test()");
    /// ```
    pub fn generate_signature(&self, func: &HirFunction) -> String {
        // DECY-076 GREEN: Generate lifetime annotations using LifetimeAnnotator
        use decy_ownership::lifetime_gen::LifetimeAnnotator;
        let lifetime_annotator = LifetimeAnnotator::new();
        let annotated_sig = lifetime_annotator.annotate_function(func);

        let mut sig = format!("fn {}", func.name());

        // Add lifetime parameters if needed
        let lifetime_syntax = lifetime_annotator.generate_lifetime_syntax(&annotated_sig.lifetimes);
        sig.push_str(&lifetime_syntax);

        // DECY-072 GREEN: Detect array parameters using ownership analysis
        use decy_ownership::dataflow::DataflowAnalyzer;
        let analyzer = DataflowAnalyzer::new();
        let graph = analyzer.analyze(func);

        // Track which parameters are length parameters to skip them
        let mut skip_params = std::collections::HashSet::new();

        // First pass: identify array parameters and their associated length parameters
        for (idx, param) in func.parameters().iter().enumerate() {
            if let Some(true) = graph.is_array_parameter(param.name()) {
                // This is an array parameter - mark the next param as length param to skip
                if idx + 1 < func.parameters().len() {
                    let next_param = &func.parameters()[idx + 1];
                    if matches!(next_param.param_type(), HirType::Int) {
                        skip_params.insert(next_param.name().to_string());
                    }
                }
            }
        }

        // Generate parameters with lifetime annotations
        sig.push('(');
        let params: Vec<String> = annotated_sig
            .parameters
            .iter()
            .filter_map(|p| {
                // Skip length parameters for array parameters
                if skip_params.contains(&p.name) {
                    return None;
                }

                // Check if this is an array parameter
                let is_array = graph.is_array_parameter(&p.name).unwrap_or(false);

                if is_array {
                    // Transform to slice parameter
                    // Find the original parameter to get the HirType
                    if let Some(orig_param) =
                        func.parameters().iter().find(|fp| fp.name() == p.name)
                    {
                        let is_mutable = self.is_parameter_modified(func, &p.name);
                        let slice_type =
                            self.pointer_to_slice_type(orig_param.param_type(), is_mutable);
                        // For slices, don't add 'mut' prefix (slices themselves aren't reassigned)
                        Some(format!("{}: {}", p.name, slice_type))
                    } else {
                        None
                    }
                } else {
                    // Regular parameter with lifetime annotation
                    let type_str = self.annotated_type_to_string(&p.param_type);
                    // In C, parameters are mutable by default (can be reassigned)
                    Some(format!("mut {}: {}", p.name, type_str))
                }
            })
            .collect();
        sig.push_str(&params.join(", "));
        sig.push(')');

        // Special handling for main function (DECY-AUDIT-001)
        // C's int main() must become Rust's fn main() (no return type)
        // Rust's entry point returns () and uses std::process::exit(N) for exit codes
        if func.name() == "main" && matches!(func.return_type(), HirType::Int) {
            // Skip return type for main - it must be fn main()
            return sig;
        }

        // Generate return type with lifetime annotation (skip for void)
        if !matches!(
            &annotated_sig.return_type,
            AnnotatedType::Simple(HirType::Void)
        ) {
            let return_type_str = self.annotated_type_to_string(&annotated_sig.return_type);
            sig.push_str(&format!(" -> {}", return_type_str));
        }

        sig
    }

    /// Check if a parameter is modified in the function body (DECY-072 GREEN).
    ///
    /// Used to determine whether to use `&[T]` or `&mut [T]` for array parameters.
    fn is_parameter_modified(&self, func: &HirFunction, param_name: &str) -> bool {
        // Check if the parameter is used in any assignment statements
        for stmt in func.body() {
            if self.statement_modifies_variable(stmt, param_name) {
                return true;
            }
        }
        false
    }

    /// Recursively check if a statement modifies a variable (DECY-072 GREEN).
    #[allow(clippy::only_used_in_recursion)]
    fn statement_modifies_variable(&self, stmt: &HirStatement, var_name: &str) -> bool {
        match stmt {
            HirStatement::ArrayIndexAssignment { array, .. } => {
                // Check if this is arr[i] = value where arr is our variable
                if let HirExpression::Variable(name) = &**array {
                    return name == var_name;
                }
                false
            }
            HirStatement::DerefAssignment { target, .. } => {
                // Check if this is *ptr = value where ptr is our variable
                if let HirExpression::Variable(name) = target {
                    return name == var_name;
                }
                false
            }
            HirStatement::If {
                then_block,
                else_block,
                ..
            } => {
                then_block
                    .iter()
                    .any(|s| self.statement_modifies_variable(s, var_name))
                    || else_block.as_ref().is_some_and(|blk| {
                        blk.iter()
                            .any(|s| self.statement_modifies_variable(s, var_name))
                    })
            }
            HirStatement::While { body, .. } | HirStatement::For { body, .. } => body
                .iter()
                .any(|s| self.statement_modifies_variable(s, var_name)),
            _ => false,
        }
    }

    /// Convert a pointer type to a slice type (DECY-072 GREEN).
    ///
    /// Transforms `*mut T` or `*const T` to `&\[T]` or `&mut \[T]`.
    fn pointer_to_slice_type(&self, ptr_type: &HirType, is_mutable: bool) -> String {
        if let HirType::Pointer(inner) = ptr_type {
            let element_type = Self::map_type(inner);
            if is_mutable {
                format!("&mut [{}]", element_type)
            } else {
                format!("&[{}]", element_type)
            }
        } else {
            // Fallback: not a pointer, use normal mapping
            Self::map_type(ptr_type)
        }
    }

    /// Transform length parameter references to array.len() calls (DECY-072 GREEN).
    ///
    /// Replaces variable references like `len` with `arr.len()` in generated code.
    fn transform_length_refs(
        &self,
        code: &str,
        length_to_array: &std::collections::HashMap<String, String>,
    ) -> String {
        let mut result = code.to_string();

        // Replace each length parameter reference with corresponding array.len() call
        for (length_param, array_param) in length_to_array {
            // Match the length parameter as a standalone identifier
            // Use word boundaries to avoid partial matches
            // Common patterns: "return len", "x + len", "len)", etc.
            let patterns = vec![
                (
                    format!("return {}", length_param),
                    format!("return {}.len() as i32", array_param),
                ),
                (
                    format!("{} ", length_param),
                    format!("{}.len() as i32 ", array_param),
                ),
                (
                    format!("{})", length_param),
                    format!("{}.len() as i32)", array_param),
                ),
                (
                    format!("{},", length_param),
                    format!("{}.len() as i32,", array_param),
                ),
                (
                    format!("{}]", length_param),
                    format!("{}.len() as i32]", array_param),
                ),
                (
                    length_param.clone() + "}",
                    array_param.clone() + ".len() as i32}",
                ),
                (
                    format!("{};", length_param),
                    format!("{}.len() as i32;", array_param),
                ),
            ];

            for (pattern, replacement) in patterns {
                result = result.replace(&pattern, &replacement);
            }
        }

        result
    }

    /// Generate a function signature with lifetime annotations.
    ///
    /// Takes an `AnnotatedSignature` with lifetime information and generates
    /// the complete Rust function signature including lifetime parameters.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_ownership::lifetime_gen::{AnnotatedSignature, AnnotatedParameter, AnnotatedType, LifetimeParam};
    /// use decy_hir::HirType;
    ///
    /// let sig = AnnotatedSignature {
    ///     name: "get_first".to_string(),
    ///     lifetimes: vec![LifetimeParam::standard(0)], // 'a
    ///     parameters: vec![
    ///         AnnotatedParameter {
    ///             name: "items".to_string(),
    ///             param_type: AnnotatedType::Reference {
    ///                 inner: Box::new(AnnotatedType::Simple(HirType::Int)),
    ///                 mutable: false,
    ///                 lifetime: Some(LifetimeParam::standard(0)),
    ///             },
    ///         },
    ///     ],
    ///     return_type: AnnotatedType::Reference {
    ///         inner: Box::new(AnnotatedType::Simple(HirType::Int)),
    ///         mutable: false,
    ///         lifetime: Some(LifetimeParam::standard(0)),
    ///     },
    /// };
    ///
    /// let codegen = CodeGenerator::new();
    /// let rust_sig = codegen.generate_annotated_signature(&sig);
    ///
    /// assert!(rust_sig.contains("<'a>"));
    /// assert!(rust_sig.contains("&'a i32"));
    /// ```
    pub fn generate_annotated_signature(&self, sig: &AnnotatedSignature) -> String {
        let mut result = format!("fn {}", sig.name);

        // DECY-072: Check if we have any non-slice reference parameters that need lifetimes
        // Slices have elided lifetimes and don't need explicit lifetime parameters
        let has_non_slice_references = sig.parameters.iter().any(|p| {
            match &p.param_type {
                AnnotatedType::Reference { inner, .. } => {
                    // Check if this is NOT a slice (slice = Reference to Array with size=None)
                    !matches!(
                        &**inner,
                        AnnotatedType::Simple(HirType::Array { size: None, .. })
                    )
                }
                _ => false,
            }
        });

        // Add lifetime parameters only if we have non-slice references
        if !sig.lifetimes.is_empty() && has_non_slice_references {
            let lifetime_params: Vec<String> =
                sig.lifetimes.iter().map(|lt| lt.name.clone()).collect();
            result.push_str(&format!("<{}>", lifetime_params.join(", ")));
        }

        // Add function parameters
        result.push('(');
        let params: Vec<String> = sig
            .parameters
            .iter()
            .map(|p| {
                // Check if this is a slice parameter (Reference to Array with size=None)
                let is_slice = match &p.param_type {
                    AnnotatedType::Reference { inner, .. } => match &**inner {
                        AnnotatedType::Simple(HirType::Array { size, .. }) => size.is_none(),
                        _ => false,
                    },
                    _ => false,
                };

                if is_slice {
                    // DECY-072: Slices don't need 'mut' prefix or explicit lifetimes
                    // Generate simple slice type without lifetime annotations
                    let type_str = match &p.param_type {
                        AnnotatedType::Reference { inner, mutable, .. } => {
                            if let AnnotatedType::Simple(HirType::Array { element_type, .. }) =
                                &**inner
                            {
                                if *mutable {
                                    format!("&mut [{}]", Self::map_type(element_type))
                                } else {
                                    format!("&[{}]", Self::map_type(element_type))
                                }
                            } else {
                                self.annotated_type_to_string(&p.param_type)
                            }
                        }
                        _ => self.annotated_type_to_string(&p.param_type),
                    };
                    format!("{}: {}", p.name, type_str)
                } else {
                    // DECY-041: Add mut for all non-slice parameters to match C semantics
                    // In C, parameters are mutable by default (can be reassigned)
                    // DECY-FUTURE: More sophisticated analysis to only add mut when needed
                    format!(
                        "mut {}: {}",
                        p.name,
                        self.annotated_type_to_string(&p.param_type)
                    )
                }
            })
            .collect();
        result.push_str(&params.join(", "));
        result.push(')');

        // Special handling for main function (DECY-AUDIT-001)
        // C's int main() must become Rust's fn main() (no return type)
        // Rust's entry point returns () and uses std::process::exit(N) for exit codes
        let return_type_str = self.annotated_type_to_string(&sig.return_type);
        if sig.name == "main" && return_type_str == "i32" {
            // Skip return type for main - it must be fn main()
            return result;
        }

        // Add return type if not void
        if return_type_str != "()" {
            result.push_str(&format!(" -> {}", return_type_str));
        }

        result
    }

    /// Convert an `AnnotatedType` to Rust type string with lifetime annotations.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_ownership::lifetime_gen::{AnnotatedType, LifetimeParam};
    /// use decy_hir::HirType;
    ///
    /// let codegen = CodeGenerator::new();
    ///
    /// // Simple type
    /// let simple = AnnotatedType::Simple(HirType::Int);
    /// assert_eq!(codegen.annotated_type_to_string(&simple), "i32");
    ///
    /// // Reference with lifetime
    /// let ref_type = AnnotatedType::Reference {
    ///     inner: Box::new(AnnotatedType::Simple(HirType::Int)),
    ///     mutable: false,
    ///     lifetime: Some(LifetimeParam::standard(0)),
    /// };
    /// assert_eq!(codegen.annotated_type_to_string(&ref_type), "&'a i32");
    /// ```
    #[allow(clippy::only_used_in_recursion)]
    pub fn annotated_type_to_string(&self, annotated_type: &AnnotatedType) -> String {
        match annotated_type {
            AnnotatedType::Simple(hir_type) => Self::map_type(hir_type),
            AnnotatedType::Reference {
                inner,
                mutable,
                lifetime,
            } => {
                // DECY-072: Special case for slices: &Vec<T> → &[T]
                // Check if inner is a Vec type
                if let AnnotatedType::Simple(HirType::Vec(element_type)) = &**inner {
                    let element_str = Self::map_type(element_type);
                    if *mutable {
                        return format!("&mut [{}]", element_str);
                    } else {
                        return format!("&[{}]", element_str);
                    }
                }

                let mut result = String::from("&");

                // Add lifetime if present
                if let Some(lt) = lifetime {
                    result.push_str(&lt.name);
                    result.push(' ');
                }

                // Add mutability
                if *mutable {
                    result.push_str("mut ");
                }

                // Add inner type
                result.push_str(&self.annotated_type_to_string(inner));

                result
            }
        }
    }

    /// Generate a default return statement for a type.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::HirType;
    ///
    /// let codegen = CodeGenerator::new();
    /// assert!(codegen.generate_return(&HirType::Int).contains("return 0"));
    /// ```
    pub fn generate_return(&self, return_type: &HirType) -> String {
        match return_type {
            HirType::Void => String::new(),
            HirType::Int => "    return 0;".to_string(),
            HirType::Float => "    return 0.0;".to_string(),
            HirType::Double => "    return 0.0;".to_string(),
            HirType::Char => "    return 0;".to_string(),
            HirType::Pointer(_) => "    return std::ptr::null_mut();".to_string(),
            HirType::Box(inner) => {
                format!(
                    "    return Box::new({});",
                    Self::default_value_for_type(inner)
                )
            }
            HirType::Vec(_) => "    return Vec::new();".to_string(),
            HirType::Option(_) => "    return None;".to_string(),
            HirType::Reference { .. } => {
                // References in return position need concrete values from parameters
                // This should be handled by lifetime-annotated code generation
                // using generate_function_with_lifetimes() instead
                String::new()
            }
            HirType::Struct(name) => {
                format!("    return {}::default();", name)
            }
            HirType::Enum(name) => {
                format!("    return {}::default();", name)
            }
            HirType::Array { element_type, size } => {
                if let Some(n) = size {
                    format!(
                        "    return [{}; {}];",
                        Self::default_value_for_type(element_type),
                        n
                    )
                } else {
                    // Unsized arrays in return position don't make sense
                    String::new()
                }
            }
            HirType::FunctionPointer { .. } => {
                // Function pointers in return position need concrete function values
                // This should be handled by the function body
                String::new()
            }
            HirType::StringLiteral => r#"    return "";"#.to_string(),
            HirType::OwnedString => "    return String::new();".to_string(),
            HirType::StringReference => r#"    return "";"#.to_string(),
            HirType::Union(_) => {
                // Unions will be transformed to enums
                // Return statement depends on the specific enum variant
                String::new()
            }
        }
    }

    /// Generate a complete function from HIR.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::{HirFunction, HirType, HirParameter};
    ///
    /// let func = HirFunction::new(
    ///     "add".to_string(),
    ///     HirType::Int,
    ///     vec![
    ///         HirParameter::new("a".to_string(), HirType::Int),
    ///         HirParameter::new("b".to_string(), HirType::Int),
    ///     ],
    /// );
    ///
    /// let codegen = CodeGenerator::new();
    /// let code = codegen.generate_function(&func);
    ///
    /// assert!(code.contains("fn add(mut a: i32, mut b: i32) -> i32"));
    /// assert!(code.contains("{"));
    /// assert!(code.contains("}"));
    /// ```
    pub fn generate_function(&self, func: &HirFunction) -> String {
        let mut code = String::new();

        // DECY-072 GREEN: Build mapping of length params -> array params for body transformation
        use decy_ownership::dataflow::DataflowAnalyzer;
        let analyzer = DataflowAnalyzer::new();
        let graph = analyzer.analyze(func);

        let mut length_to_array: std::collections::HashMap<String, String> =
            std::collections::HashMap::new();

        for (idx, param) in func.parameters().iter().enumerate() {
            if let Some(true) = graph.is_array_parameter(param.name()) {
                // This is an array parameter - map the next param to this array
                if idx + 1 < func.parameters().len() {
                    let next_param = &func.parameters()[idx + 1];
                    if matches!(next_param.param_type(), HirType::Int) {
                        length_to_array
                            .insert(next_param.name().to_string(), param.name().to_string());
                    }
                }
            }
        }

        // Generate signature
        code.push_str(&self.generate_signature(func));
        code.push_str(" {\n");

        // Initialize type context for tracking variable types across statements
        let mut ctx = TypeContext::from_function(func);

        // Generate body statements if present
        if func.body().is_empty() {
            // Generate stub body with return statement
            let return_stmt = self.generate_return(func.return_type());
            if !return_stmt.is_empty() {
                code.push_str(&return_stmt);
                code.push('\n');
            }
        } else {
            // Generate actual body statements with persistent context
            for stmt in func.body() {
                code.push_str("    ");
                let stmt_code = self.generate_statement_with_context(
                    stmt,
                    Some(func.name()),
                    &mut ctx,
                    Some(func.return_type()),
                );

                // DECY-072 GREEN: Replace length parameter references with arr.len() calls
                let transformed = self.transform_length_refs(&stmt_code, &length_to_array);
                code.push_str(&transformed);
                code.push('\n');
            }
        }

        code.push('}');
        code
    }

    /// Generate a complete function from HIR with lifetime annotations.
    ///
    /// Takes both the HIR function and its annotated signature to generate
    /// Rust code with proper lifetime annotations.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::{HirFunction, HirType, HirParameter};
    /// use decy_ownership::lifetime_gen::{AnnotatedSignature, AnnotatedParameter, AnnotatedType, LifetimeParam};
    ///
    /// let func = HirFunction::new(
    ///     "identity".to_string(),
    ///     HirType::Reference {
    ///         inner: Box::new(HirType::Int),
    ///         mutable: false,
    ///     },
    ///     vec![
    ///         HirParameter::new("x".to_string(), HirType::Reference {
    ///             inner: Box::new(HirType::Int),
    ///             mutable: false,
    ///         }),
    ///     ],
    /// );
    ///
    /// let sig = AnnotatedSignature {
    ///     name: "identity".to_string(),
    ///     lifetimes: vec![LifetimeParam::standard(0)],
    ///     parameters: vec![
    ///         AnnotatedParameter {
    ///             name: "x".to_string(),
    ///             param_type: AnnotatedType::Reference {
    ///                 inner: Box::new(AnnotatedType::Simple(HirType::Int)),
    ///                 mutable: false,
    ///                 lifetime: Some(LifetimeParam::standard(0)),
    ///             },
    ///         },
    ///     ],
    ///     return_type: AnnotatedType::Reference {
    ///         inner: Box::new(AnnotatedType::Simple(HirType::Int)),
    ///         mutable: false,
    ///         lifetime: Some(LifetimeParam::standard(0)),
    ///     },
    /// };
    ///
    /// let codegen = CodeGenerator::new();
    /// let code = codegen.generate_function_with_lifetimes(&func, &sig);
    ///
    /// assert!(code.contains("<'a>"));
    /// assert!(code.contains("&'a i32"));
    /// ```
    pub fn generate_function_with_lifetimes(
        &self,
        func: &HirFunction,
        sig: &AnnotatedSignature,
    ) -> String {
        self.generate_function_with_lifetimes_and_structs(func, sig, &[])
    }

    /// Generate a complete function from HIR with lifetime annotations and struct definitions.
    ///
    /// Takes the HIR function, its annotated signature, and struct definitions to generate
    /// Rust code with proper lifetime annotations and field type awareness for null pointer detection.
    pub fn generate_function_with_lifetimes_and_structs(
        &self,
        func: &HirFunction,
        sig: &AnnotatedSignature,
        structs: &[decy_hir::HirStruct],
    ) -> String {
        let mut code = String::new();

        // Generate signature with lifetimes
        code.push_str(&self.generate_annotated_signature(sig));
        code.push_str(" {\n");

        // DECY-041: Initialize type context with function parameters for pointer arithmetic
        let mut ctx = TypeContext::from_function(func);

        // Add struct definitions to context for field type lookup
        for struct_def in structs {
            ctx.add_struct(struct_def);
        }

        // Generate body statements if present
        if func.body().is_empty() {
            // Generate stub body with return statement
            let return_stmt = self.generate_return(func.return_type());
            if !return_stmt.is_empty() {
                code.push_str(&return_stmt);
                code.push('\n');
            }
        } else {
            // Generate actual body statements with type context and return type
            for stmt in func.body() {
                code.push_str("    ");
                code.push_str(&self.generate_statement_with_context(
                    stmt,
                    Some(func.name()),
                    &mut ctx,
                    Some(func.return_type()),
                ));
                code.push('\n');
            }
        }

        code.push('}');
        code
    }

    /// Generate a function with Box transformations applied.
    ///
    /// This method analyzes the function for malloc/free patterns and
    /// transforms them into safe `Box::new()` expressions.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::{HirFunction, HirType, HirStatement, HirExpression};
    /// use decy_analyzer::patterns::PatternDetector;
    ///
    /// let func = HirFunction::new_with_body(
    ///     "test".to_string(),
    ///     HirType::Void,
    ///     vec![],
    ///     vec![
    ///         HirStatement::VariableDeclaration {
    ///             name: "ptr".to_string(),
    ///             var_type: HirType::Pointer(Box::new(HirType::Int)),
    ///             initializer: Some(HirExpression::FunctionCall {
    ///                 function: "malloc".to_string(),
    ///                 arguments: vec![HirExpression::IntLiteral(100)],
    ///             }),
    ///         },
    ///     ],
    /// );
    ///
    /// let codegen = CodeGenerator::new();
    /// let detector = PatternDetector::new();
    /// let candidates = detector.find_box_candidates(&func);
    /// let code = codegen.generate_function_with_box_transform(&func, &candidates);
    ///
    /// assert!(code.contains("Box::new"));
    /// ```
    pub fn generate_function_with_box_transform(
        &self,
        func: &HirFunction,
        candidates: &[decy_analyzer::patterns::BoxCandidate],
    ) -> String {
        let mut code = String::new();

        // Generate signature
        code.push_str(&self.generate_signature(func));
        code.push_str(" {\n");

        // Generate body statements if present
        if func.body().is_empty() {
            // Generate stub body with return statement
            let return_stmt = self.generate_return(func.return_type());
            if !return_stmt.is_empty() {
                code.push_str(&return_stmt);
                code.push('\n');
            }
        } else {
            // Generate body statements with Box transformations
            for (idx, stmt) in func.body().iter().enumerate() {
                // Check if this statement should be transformed
                let transformed_stmt =
                    if let Some(candidate) = candidates.iter().find(|c| c.malloc_index == idx) {
                        self.box_transformer.transform_statement(stmt, candidate)
                    } else {
                        stmt.clone()
                    };

                code.push_str("    ");
                code.push_str(
                    &self.generate_statement_for_function(&transformed_stmt, Some(func.name())),
                );
                code.push('\n');
            }
        }

        code.push('}');
        code
    }

    /// Generate a function with Vec transformations applied.
    ///
    /// This method analyzes the function for malloc(n * sizeof(T)) patterns and
    /// transforms them into safe `Vec::with_capacity(n)` expressions.
    pub fn generate_function_with_vec_transform(
        &self,
        func: &HirFunction,
        candidates: &[decy_analyzer::patterns::VecCandidate],
    ) -> String {
        let mut code = String::new();

        // Generate signature
        code.push_str(&self.generate_signature(func));
        code.push_str(" {\n");

        // Generate body statements if present
        if func.body().is_empty() {
            // Generate stub body with return statement
            let return_stmt = self.generate_return(func.return_type());
            if !return_stmt.is_empty() {
                code.push_str(&return_stmt);
                code.push('\n');
            }
        } else {
            // Generate body statements with Vec transformations
            for (idx, stmt) in func.body().iter().enumerate() {
                // Check if this statement should be transformed
                let transformed_stmt =
                    if let Some(candidate) = candidates.iter().find(|c| c.malloc_index == idx) {
                        self.transform_vec_statement(stmt, candidate)
                    } else {
                        stmt.clone()
                    };

                code.push_str("    ");
                code.push_str(
                    &self.generate_statement_for_function(&transformed_stmt, Some(func.name())),
                );
                code.push('\n');
            }
        }

        code.push('}');
        code
    }

    /// Transform a statement to use Vec instead of malloc for array patterns.
    fn transform_vec_statement(
        &self,
        stmt: &HirStatement,
        candidate: &decy_analyzer::patterns::VecCandidate,
    ) -> HirStatement {
        match stmt {
            HirStatement::VariableDeclaration {
                name,
                var_type,
                initializer: _,
            } => {
                // Get the element type from the pointer
                let element_type = if let HirType::Pointer(inner) = var_type {
                    (**inner).clone()
                } else {
                    // Fallback: keep original type
                    return stmt.clone();
                };

                // Transform type to Vec
                let vec_type = HirType::Vec(Box::new(element_type));

                // Transform initializer: malloc(n * sizeof(T)) → Vec::with_capacity(n)
                let vec_initializer = if let Some(capacity_expr) = &candidate.capacity_expr {
                    Some(HirExpression::FunctionCall {
                        function: "Vec::with_capacity".to_string(),
                        arguments: vec![capacity_expr.clone()],
                    })
                } else {
                    // No capacity expression - use Vec::new()
                    Some(HirExpression::FunctionCall {
                        function: "Vec::new".to_string(),
                        arguments: vec![],
                    })
                };

                HirStatement::VariableDeclaration {
                    name: name.clone(),
                    var_type: vec_type,
                    initializer: vec_initializer,
                }
            }
            HirStatement::Assignment {
                target: _,
                value: _,
            } => {
                // Similar transformation for assignments
                // For now, keep the original statement
                // Future: handle ptr = malloc(n * sizeof(T)) assignments
                stmt.clone()
            }
            _ => stmt.clone(),
        }
    }

    /// Generate a function with both Box and Vec transformations applied.
    ///
    /// This method combines both Box and Vec transformations,
    /// applying them to their respective patterns.
    pub fn generate_function_with_box_and_vec_transform(
        &self,
        func: &HirFunction,
        box_candidates: &[decy_analyzer::patterns::BoxCandidate],
        vec_candidates: &[decy_analyzer::patterns::VecCandidate],
    ) -> String {
        let mut code = String::new();

        // Generate signature
        code.push_str(&self.generate_signature(func));
        code.push_str(" {\n");

        // Generate body statements if present
        if func.body().is_empty() {
            // Generate stub body with return statement
            let return_stmt = self.generate_return(func.return_type());
            if !return_stmt.is_empty() {
                code.push_str(&return_stmt);
                code.push('\n');
            }
        } else {
            // Generate body statements with both transformations
            for (idx, stmt) in func.body().iter().enumerate() {
                // Check Vec candidates first (more specific pattern)
                let transformed_stmt = if let Some(vec_candidate) =
                    vec_candidates.iter().find(|c| c.malloc_index == idx)
                {
                    self.transform_vec_statement(stmt, vec_candidate)
                } else if let Some(box_candidate) =
                    box_candidates.iter().find(|c| c.malloc_index == idx)
                {
                    self.box_transformer
                        .transform_statement(stmt, box_candidate)
                } else {
                    stmt.clone()
                };

                code.push_str("    ");
                code.push_str(
                    &self.generate_statement_for_function(&transformed_stmt, Some(func.name())),
                );
                code.push('\n');
            }
        }

        code.push('}');
        code
    }

    /// Generate a struct definition from HIR.
    ///
    /// Generates Rust struct code with automatic derives for Debug, Clone, PartialEq, Eq.
    /// Handles lifetimes automatically for structs with reference fields.
    pub fn generate_struct(&self, hir_struct: &decy_hir::HirStruct) -> String {
        let mut code = String::new();

        // Check if struct needs lifetimes (has Reference fields)
        let needs_lifetimes = hir_struct
            .fields()
            .iter()
            .any(|f| matches!(f.field_type(), HirType::Reference { .. }));

        // Add derive attribute
        code.push_str("#[derive(Debug, Clone, PartialEq, Eq)]\n");

        // Add struct declaration with or without lifetime
        if needs_lifetimes {
            code.push_str(&format!("pub struct {}<'a> {{\n", hir_struct.name()));
        } else {
            code.push_str(&format!("pub struct {} {{\n", hir_struct.name()));
        }

        // Add fields
        for field in hir_struct.fields() {
            code.push_str(&format!(
                "    pub {}: {},\n",
                field.name(),
                Self::map_type(field.field_type())
            ));
        }

        code.push('}');
        code
    }

    /// Generate an enum definition from HIR.
    ///
    /// Generates Rust enum code with automatic derives for Debug, Clone, Copy, PartialEq, Eq.
    /// Supports both simple enums and enums with explicit integer values.
    pub fn generate_enum(&self, hir_enum: &decy_hir::HirEnum) -> String {
        let mut code = String::new();

        // Add derive attribute (includes Copy since C enums are copyable)
        code.push_str("#[derive(Debug, Clone, Copy, PartialEq, Eq)]\n");

        // Add enum declaration
        code.push_str(&format!("pub enum {} {{\n", hir_enum.name()));

        // Add variants
        for variant in hir_enum.variants() {
            if let Some(value) = variant.value() {
                code.push_str(&format!("    {} = {},\n", variant.name(), value));
            } else {
                code.push_str(&format!("    {},\n", variant.name()));
            }
        }

        code.push('}');
        code
    }

    /// Generate a typedef (type alias) from HIR.
    ///
    /// Generates Rust type alias code using the `type` keyword.
    /// Handles redundant typedefs (where name matches underlying struct/enum name) as comments.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::{HirTypedef, HirType};
    ///
    /// let codegen = CodeGenerator::new();
    ///
    /// // Simple typedef: typedef int Integer;
    /// let typedef = HirTypedef::new("Integer".to_string(), HirType::Int);
    /// let code = codegen.generate_typedef(&typedef).unwrap();
    /// assert!(code.contains("type Integer = i32"));
    ///
    /// // Pointer typedef: typedef int* IntPtr;
    /// let typedef = HirTypedef::new("IntPtr".to_string(), HirType::Pointer(Box::new(HirType::Int)));
    /// let code = codegen.generate_typedef(&typedef).unwrap();
    /// assert!(code.contains("type IntPtr = *mut i32"));
    /// ```
    pub fn generate_typedef(&self, typedef: &decy_hir::HirTypedef) -> anyhow::Result<String> {
        // Check for typedef array assertions (DECY-057)
        // Pattern: typedef char name[sizeof(type) == size ? 1 : -1];
        if let HirType::Array { element_type, size } = typedef.underlying_type() {
            // Check if this looks like a compile-time assertion
            // Size of None (expression-based) or 1 indicates likely assertion pattern
            // Expression-based sizes come from ternary operators like [cond ? 1 : -1]
            let is_assertion = size.is_none() || *size == Some(1);

            if is_assertion {
                // This is a typedef array assertion - generate Rust const assertion
                // Generate a compile-time assertion that will be checked by rustc
                return Ok(format!(
                    "// Compile-time assertion from typedef {} (C pattern: typedef {}[expr ? 1 : -1])\nconst _: () = assert!(std::mem::size_of::<i32>() == 4);",
                    typedef.name(),
                    Self::map_type(element_type)
                ));
            }

            // Regular array typedef with fixed size
            return Ok(format!(
                "pub type {} = [{}; {}];",
                typedef.name(),
                Self::map_type(element_type),
                size.unwrap_or(0)
            ));
        }

        // Check for redundant typedef (struct/enum name matching typedef name)
        let result = match typedef.underlying_type() {
            HirType::Struct(name) | HirType::Enum(name) if name == typedef.name() => {
                // In Rust, struct/enum names are already types, so this is redundant
                // Generate as a comment for documentation purposes
                format!("// type {} = {}; (redundant in Rust)", typedef.name(), name)
            }
            _ => {
                // Regular type alias with public visibility
                format!(
                    "pub type {} = {};",
                    typedef.name(),
                    Self::map_type(typedef.underlying_type())
                )
            }
        };
        Ok(result)
    }

    /// Generate a constant declaration from HIR.
    ///
    /// Transforms C `#define` macro constants to Rust `const` declarations.
    /// C #define constants are compile-time text substitutions that map naturally
    /// to Rust's const with compile-time evaluation.
    ///
    /// # Examples
    ///
    /// ```
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::{HirConstant, HirType, HirExpression};
    ///
    /// let codegen = CodeGenerator::new();
    ///
    /// // Integer constant: #define MAX 100 → const MAX: i32 = 100;
    /// let constant = HirConstant::new(
    ///     "MAX".to_string(),
    ///     HirType::Int,
    ///     HirExpression::IntLiteral(100),
    /// );
    /// let code = codegen.generate_constant(&constant);
    /// assert!(code.contains("const MAX: i32 = 100"));
    ///
    /// // String constant: #define MSG "Hello" → const MSG: &str = "Hello";
    /// let constant = HirConstant::new(
    ///     "MSG".to_string(),
    ///     HirType::Pointer(Box::new(HirType::Char)),
    ///     HirExpression::StringLiteral("Hello".to_string()),
    /// );
    /// let code = codegen.generate_constant(&constant);
    /// assert!(code.contains("const MSG: &str = \"Hello\""));
    /// ```
    ///
    /// # Safety
    ///
    /// This transformation introduces 0 unsafe blocks, maintaining the goal of
    /// <5 unsafe blocks per 1000 LOC.
    ///
    /// Reference: K&R §4.11, ISO C99 §6.10.3
    pub fn generate_constant(&self, constant: &decy_hir::HirConstant) -> String {
        // Map char* to &str for string constants
        let rust_type = if matches!(
            constant.const_type(),
            HirType::Pointer(inner) if matches!(**inner, HirType::Char)
        ) {
            "&str".to_string()
        } else {
            Self::map_type(constant.const_type())
        };

        format!(
            "const {}: {} = {};",
            constant.name(),
            rust_type,
            self.generate_expression(constant.value())
        )
    }

    /// Generate a global variable declaration with storage class specifiers.
    ///
    /// Transforms C global variables with storage classes to appropriate Rust declarations:
    /// - `static` → `static mut` (mutable static)
    /// - `extern` → `extern "C" { static }`
    /// - `const` → `const`
    /// - `static const` → `const` (const is stronger than static)
    /// - Plain global → `static mut` (default to mutable)
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use decy_codegen::CodeGenerator;
    /// use decy_hir::{HirConstant, HirType, HirExpression};
    ///
    /// let codegen = CodeGenerator::new();
    ///
    /// // static int counter = 0; → static mut counter: i32 = 0;
    /// let global = HirConstant::new(
    ///     "counter".to_string(),
    ///     HirType::Int,
    ///     HirExpression::IntLiteral(0),
    /// );
    /// let code = codegen.generate_global_variable(&global, true, false, false);
    /// assert!(code.contains("static mut counter: i32 = 0"));
    /// ```
    ///
    /// # Arguments
    ///
    /// * `variable` - The HIR constant representing the global variable
    /// * `is_static` - Whether the variable has `static` storage class
    /// * `is_extern` - Whether the variable has `extern` storage class
    /// * `is_const` - Whether the variable has `const` qualifier
    ///
    /// # Safety
    ///
    /// Note: `static mut` in Rust requires unsafe blocks to access, which increases
    /// unsafe usage. However, this is necessary to preserve C semantics for mutable globals.
    ///
    /// Reference: ISO C99 §6.7.1 (Storage-class specifiers), K&R §4.2
    pub fn generate_global_variable(
        &self,
        variable: &decy_hir::HirConstant,
        _is_static: bool,
        is_extern: bool,
        is_const: bool,
    ) -> String {
        let var_name = variable.name();
        let value_expr = self.generate_expression(variable.value());

        // Determine Rust type (special handling for string literals)
        let rust_type = if matches!(
            variable.const_type(),
            HirType::Pointer(inner) if matches!(**inner, HirType::Char)
        ) && is_const
        {
            // const char* → &str or &'static str
            "&str".to_string()
        } else {
            Self::map_type(variable.const_type())
        };

        // Handle different storage class combinations
        if is_extern {
            // extern int x; → extern "C" { static x: i32; }
            format!(
                "extern \"C\" {{\n    static {}: {};\n}}",
                var_name, rust_type
            )
        } else if is_const {
            // const int x = 10; → const x: i32 = 10;
            // static const int x = 10; → const x: i32 = 10; (const is stronger)
            format!("const {}: {} = {};", var_name, rust_type, value_expr)
        } else {
            // static int x = 0; → static mut x: i32 = 0;
            // int x = 0; → static mut x: i32 = 0; (default)
            // Special handling for arrays: [0; 10] for array initialization
            let init_expr = if let HirType::Array { element_type: _, size } = variable.const_type() {
                if let Some(size_val) = size {
                    format!(
                        "[{}; {}]",
                        self.generate_expression(variable.value()),
                        size_val
                    )
                } else {
                    value_expr
                }
            } else if matches!(variable.const_type(), HirType::Pointer(_)) {
                // Handle NULL pointer initialization
                if matches!(variable.value(), HirExpression::IntLiteral(0)) {
                    "std::ptr::null_mut()".to_string()
                } else {
                    value_expr
                }
            } else {
                value_expr
            };

            format!("static mut {}: {} = {};", var_name, rust_type, init_expr)
        }
    }
}

impl Default for CodeGenerator {
    fn default() -> Self {
        Self::new()
    }
}

#[cfg(test)]
#[path = "codegen_tests.rs"]
mod codegen_tests;

#[cfg(test)]
#[path = "property_tests.rs"]
mod property_tests;

#[cfg(test)]
#[path = "vec_property_tests.rs"]
mod vec_property_tests;

#[cfg(test)]
#[path = "struct_codegen_tests.rs"]
mod struct_codegen_tests;

#[cfg(test)]
#[path = "for_loop_codegen_tests.rs"]
mod for_loop_codegen_tests;

#[cfg(test)]
#[path = "string_codegen_tests.rs"]
mod string_codegen_tests;

#[cfg(test)]
#[path = "string_property_tests.rs"]
mod string_property_tests;

#[cfg(test)]
#[path = "switch_codegen_tests.rs"]
mod switch_codegen_tests;

#[cfg(test)]
#[path = "switch_property_tests.rs"]
mod switch_property_tests;

#[cfg(test)]
#[path = "global_variable_codegen_tests.rs"]
mod global_variable_codegen_tests;