ryo_executor/executor/registry/converters/

stmt.rs

//! StmtConverter: Converts statement-level MutationSpec variants to Mutations
//!
//! Handles:
//! - ReplaceExpr
//! - RemoveStatement
//! - InsertStatement
//! - ReplaceStatement

use crate::engine::ASTRegApply;
use crate::executor::registry::converters::ResolveTargetSymbol;
use crate::executor::registry::{ConvertError, MutationConverter};
use crate::executor::spec::{MutationSpec, StmtInsertPosition};
use ryo_analysis::AnalysisContext;
use ryo_analysis::SymbolPath;
use ryo_mutations::basic::stmt::{
    InsertPosition, InsertStatementMutation, RemoveStatementMutation, ReplaceExprAtMutation,
    ReplaceExprMutation, ReplaceStatementMutation,
};
use ryo_source::pure::{PureExpr, PureStmt, ToPure};

/// Converter for statement-level mutations
#[derive(Debug, Clone, Default)]
pub struct StmtConverter;

impl StmtConverter {
    pub fn new() -> Self {
        Self
    }

    /// Parse a Rust expression string into PureExpr (used for `old_expr` / match keys).
    ///
    /// Match keys go through full parse → `to_pure()` normalization so that
    /// whitespace / token-spacing variants on the *match side* don't perturb
    /// equality comparison.
    pub fn parse_expr(expr_str: &str) -> Result<PureExpr, ConvertError> {
        let expr: syn::Expr = syn::parse_str(expr_str).map_err(|e| {
            ConvertError::Parse(format!("Failed to parse expression '{}': {}", expr_str, e))
        })?;
        Ok(expr.to_pure())
    }

    /// Parse a Rust statement string into PureStmt (used for `old_stmt` / `reference_pattern`).
    ///
    /// See `parse_expr` for the match-key normalization rationale.
    pub fn parse_stmt(stmt_str: &str) -> Result<PureStmt, ConvertError> {
        // Try parsing as a statement first
        let stmt_with_semi = if stmt_str.ends_with(';') {
            stmt_str.to_string()
        } else {
            format!("{};", stmt_str)
        };

        let stmt: syn::Stmt = syn::parse_str(&stmt_with_semi).map_err(|e| {
            ConvertError::Parse(format!("Failed to parse statement '{}': {}", stmt_str, e))
        })?;

        // Use ToPure trait implementation for syn::Stmt
        Ok(stmt.to_pure())
    }

    /// Build a verbatim **replacement** expression carrier from a raw source string.
    ///
    /// Used for `new_expr` (the *output* side of ReplaceExpr / ReplaceExprAt).
    /// The string is still syntax-checked via `syn::parse_str` (so a malformed
    /// expression is rejected up-front and the converter never emits garbage),
    /// but the parsed AST is **discarded** — `PureExpr::Verbatim(raw)` preserves
    /// the user-provided byte sequence 1:1 through `to_source`.
    ///
    /// This is the wire that connects the B-3 carrier (PureExpr::Verbatim) to
    /// producer paths so that DSL-shaped replacements survive prettyplease.
    pub fn build_verbatim_expr(expr_str: &str) -> Result<PureExpr, ConvertError> {
        // Validate syntactic well-formedness; discard the parsed shape.
        let _: syn::Expr = syn::parse_str(expr_str).map_err(|e| {
            ConvertError::Parse(format!("Failed to parse expression '{}': {}", expr_str, e))
        })?;
        Ok(PureExpr::Verbatim(expr_str.to_string()))
    }

    /// Build a verbatim **replacement** statement carrier from a raw source string.
    ///
    /// Used for `new_stmt` (ReplaceStatement) and `stmt` (InsertStatement) —
    /// the *output* side. See `build_verbatim_expr` for the parse-then-discard
    /// rationale; this wraps in `PureStmt::Verbatim` (the B-3-cont carrier).
    pub fn build_verbatim_stmt(stmt_str: &str) -> Result<PureStmt, ConvertError> {
        let stmt_with_semi = if stmt_str.ends_with(';') {
            stmt_str.to_string()
        } else {
            format!("{};", stmt_str)
        };
        let _: syn::Stmt = syn::parse_str(&stmt_with_semi).map_err(|e| {
            ConvertError::Parse(format!("Failed to parse statement '{}': {}", stmt_str, e))
        })?;
        // The line-splice pass in `PureFile::to_source` replaces the **entire
        // stub line** (including the synthetic trailing `;` emitted by the
        // stub) with the raw bytes carried here. If the caller forgot the
        // terminator, the post-splice line would be a bare expression — and
        // a later round-trip through `syn::parse_file` would either drop or
        // re-shape it. Carrying the normalized `stmt_with_semi` keeps the
        // user's *interior* spacing 1:1 while guaranteeing a valid stmt line.
        Ok(PureStmt::Verbatim(stmt_with_semi))
    }

    /// Build a verbatim **replacement** statement carrier where a missing
    /// `;` terminator is honored as **tail-expression intent** instead of
    /// being auto-completed.
    ///
    /// Used for `new_stmt` (ReplaceStatement) only. RL043 (needless-return)
    /// replaces a trailing `return expr;` with the bare `expr` — with the
    /// `build_verbatim_stmt` semi auto-completion the splice emits `expr;`,
    /// the function loses its tail expression, and the post-mutation cargo
    /// check fails with "mismatched types" (2026-06-12 bulk-lint sweep v1).
    ///
    /// Contract: a terminator-less string that parses as a bare expression
    /// is carried verbatim (no `;`); anything else (e.g. `let x = 1`)
    /// falls back to the normalizing `build_verbatim_stmt` path, keeping
    /// existing semi-completion behavior for statement-shaped input.
    /// Mid-block placement of a non-unit bare expression is caught by the
    /// post-mutation cargo check (caller responsibility, same as any other
    /// type-changing replacement).
    pub fn build_verbatim_replacement_stmt(stmt_str: &str) -> Result<PureStmt, ConvertError> {
        let trimmed = stmt_str.trim_end();
        if !trimmed.ends_with(';') {
            match syn::parse_str::<syn::Expr>(trimmed) {
                // `let pat = init` parses as syn::Expr::Let (let-chain
                // grammar leniency) but is statement-shaped input — keep
                // it on the semi-completion path.
                Ok(expr) if !matches!(expr, syn::Expr::Let(_)) => {
                    return Ok(PureStmt::Verbatim(trimmed.to_string()));
                }
                _ => {}
            }
        }
        Self::build_verbatim_stmt(stmt_str)
    }

    /// Convert StmtInsertPosition to internal InsertPosition
    fn convert_position(pos: &StmtInsertPosition) -> InsertPosition {
        match pos {
            StmtInsertPosition::Start => InsertPosition::Start,
            StmtInsertPosition::End => InsertPosition::End,
            StmtInsertPosition::BeforePattern => InsertPosition::BeforePattern,
            StmtInsertPosition::AfterPattern => InsertPosition::AfterPattern,
        }
    }
}

// StmtConverter uses the default implementation of ResolveTargetSymbol
impl ResolveTargetSymbol for StmtConverter {}

impl MutationConverter for StmtConverter {
    fn spec_kinds(&self) -> &'static [&'static str] {
        &[
            "ReplaceExpr",
            "RemoveStatement",
            "InsertStatement",
            "ReplaceStatement",
        ]
    }

    fn convert_v2(
        &self,
        spec: &MutationSpec,
        ctx: &AnalysisContext,
    ) -> Result<Vec<Box<dyn ASTRegApply>>, ConvertError> {
        match spec {
            MutationSpec::ReplaceExpr {
                fn_id,
                old_expr,
                new_expr,
                replace_all,
                symbol_path,
                ..
            } => {
                // B-3 carrier wire-up: preserve user-provided bytes for the
                // *output* expression. `old_expr` still goes through
                // parse-normalize because it's a match key.
                let new = Self::build_verbatim_expr(new_expr)?;

                // If symbol_path is provided, use position-based replacement
                if let Some(path_str) = symbol_path {
                    let path = SymbolPath::parse(path_str).map_err(|e| {
                        ConvertError::Parse(format!("Invalid symbol_path '{}': {}", path_str, e))
                    })?;

                    if !path.has_body_segment() {
                        return Err(ConvertError::Parse(format!(
                            "symbol_path '{}' must contain $body segment for position-based replacement",
                            path_str
                        )));
                    }

                    let (fn_path, indices) = path.split_at_body().ok_or_else(|| {
                        ConvertError::Parse(format!(
                            "Failed to extract function path from symbol_path '{}'",
                            path_str
                        ))
                    })?;

                    // Lookup SymbolId from function path
                    let fn_id = ctx.registry.lookup(&fn_path).ok_or_else(|| {
                        ConvertError::TargetNotFound(format!(
                            "Function '{}' not found in registry",
                            fn_path
                        ))
                    })?;

                    let mutation = ReplaceExprAtMutation::new(fn_id, indices, new);
                    return Ok(vec![Box::new(mutation)]);
                }

                let old = Self::parse_expr(old_expr)?;

                // If fn_id is None, generate mutations for all functions
                let mutations: Vec<Box<dyn ASTRegApply>> = if let Some(id) = fn_id {
                    let mut mutation = ReplaceExprMutation::new(old.clone(), new.clone(), *id);
                    mutation.replace_all = *replace_all;
                    vec![Box::new(mutation)]
                } else {
                    use ryo_analysis::SymbolKind;
                    ctx.registry
                        .iter()
                        .filter(|(id, _)| {
                            matches!(ctx.registry.kind(*id), Some(SymbolKind::Function))
                        })
                        .map(|(id, _)| {
                            let mut mutation =
                                ReplaceExprMutation::new(old.clone(), new.clone(), id);
                            mutation.replace_all = *replace_all;
                            Box::new(mutation) as Box<dyn ASTRegApply>
                        })
                        .collect()
                };

                Ok(mutations)
            }

            MutationSpec::RemoveStatement {
                fn_id,
                pattern,
                remove_all,
                ..
            } => {
                let target_stmt = Self::parse_stmt(pattern)?;

                // If fn_id is None, generate mutations for all functions
                let mutations: Vec<Box<dyn ASTRegApply>> = if let Some(id) = fn_id {
                    let mut mutation =
                        RemoveStatementMutation::new(target_stmt.clone(), pattern.clone(), *id);
                    mutation.remove_all = *remove_all;
                    vec![Box::new(mutation)]
                } else {
                    use ryo_analysis::SymbolKind;
                    ctx.registry
                        .iter()
                        .filter(|(id, _)| {
                            matches!(ctx.registry.kind(*id), Some(SymbolKind::Function))
                        })
                        .map(|(id, _)| {
                            let mut mutation = RemoveStatementMutation::new(
                                target_stmt.clone(),
                                pattern.clone(),
                                id,
                            );
                            mutation.remove_all = *remove_all;
                            Box::new(mutation) as Box<dyn ASTRegApply>
                        })
                        .collect()
                };

                Ok(mutations)
            }

            MutationSpec::InsertStatement {
                fn_id,
                stmt,
                position,
                reference_pattern,
                ..
            } => {
                // B-3-cont carrier wire-up: preserve user-provided bytes for
                // the *inserted* statement. `reference_pattern` stays parsed
                // because it's used as a structural match key.
                let pure_stmt = Self::build_verbatim_stmt(stmt)?;
                let reference_stmt = reference_pattern
                    .as_ref()
                    .map(|p| Self::parse_stmt(p))
                    .transpose()?;

                let mut mutation = InsertStatementMutation::new(pure_stmt, *fn_id);
                mutation.position = Self::convert_position(position);
                mutation.reference_stmt = reference_stmt;

                Ok(vec![Box::new(mutation)])
            }

            MutationSpec::ReplaceStatement {
                fn_id,
                old_stmt,
                new_stmt,
                ..
            } => {
                let old = Self::parse_stmt(old_stmt)?;
                // B-3-cont carrier wire-up for the *output* statement.
                // Terminator-less expression input is honored as
                // tail-expression intent (RL043 `return x;` → `x`).
                let new = Self::build_verbatim_replacement_stmt(new_stmt)?;

                // If fn_id is None, generate mutations for all functions
                let mutations: Vec<Box<dyn ASTRegApply>> = if let Some(id) = fn_id {
                    vec![Box::new(ReplaceStatementMutation::new(
                        old.clone(),
                        new.clone(),
                        *id,
                    ))]
                } else {
                    use ryo_analysis::SymbolKind;
                    ctx.registry
                        .iter()
                        .filter(|(id, _)| {
                            matches!(ctx.registry.kind(*id), Some(SymbolKind::Function))
                        })
                        .map(|(id, _)| {
                            Box::new(ReplaceStatementMutation::new(old.clone(), new.clone(), id))
                                as Box<dyn ASTRegApply>
                        })
                        .collect()
                };

                Ok(mutations)
            }

            _ => Err(ConvertError::TypeMismatch {
                expected: "ReplaceExpr|RemoveStatement|InsertStatement|ReplaceStatement",
                actual: spec.kind_name().to_string(),
            }),
        }
    }
}

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

    #[test]
    fn test_stmt_converter_spec_kinds() {
        let converter = StmtConverter::new();
        let kinds = converter.spec_kinds();
        assert!(kinds.contains(&"ReplaceExpr"));
        assert!(kinds.contains(&"RemoveStatement"));
        assert!(kinds.contains(&"InsertStatement"));
        assert!(kinds.contains(&"ReplaceStatement"));
    }

    #[test]
    fn test_stmt_converter_can_handle() {
        let converter = StmtConverter::new();

        let replace_expr_spec = MutationSpec::ReplaceExpr {
            module_id: None,
            fn_id: None,
            old_expr: "a + b".into(),
            new_expr: "c + d".into(),
            replace_all: true,
            symbol_path: None,
        };
        assert!(converter.can_handle(&replace_expr_spec));

        let remove_stmt_spec = MutationSpec::RemoveStatement {
            module_id: None,
            fn_id: None,
            pattern: "println!".into(),
            remove_all: true,
            symbol_path: None,
        };
        assert!(converter.can_handle(&remove_stmt_spec));

        let insert_stmt_spec = MutationSpec::InsertStatement {
            module_id: None,
            fn_id: SymbolId::default(),
            stmt: "let x = 1".into(),
            position: StmtInsertPosition::Start,
            reference_pattern: None,
            symbol_path: None,
        };
        assert!(converter.can_handle(&insert_stmt_spec));

        let replace_stmt_spec = MutationSpec::ReplaceStatement {
            module_id: None,
            fn_id: None,
            old_stmt: "let x = 1".into(),
            new_stmt: "let x = 2".into(),
            symbol_path: None,
        };
        assert!(converter.can_handle(&replace_stmt_spec));
    }

    // -------------------------------------------------------------------------
    // A-patch: B-3 / B-3-cont carrier wire-up — `new_expr` / `new_stmt` / `stmt`
    // are emitted as Verbatim, preserving user-provided byte sequences so that
    // DSL-shaped replacements survive prettyplease.
    // -------------------------------------------------------------------------

    #[test]
    fn build_verbatim_expr_preserves_raw_bytes_with_unusual_spacing() {
        // prettyplease would normally collapse the doubled spaces and the
        // unusual macro spacing — Verbatim must pass them through 1:1.
        let raw = "html ! { < div   id = \"x\" > { value } < / div > }";
        match StmtConverter::build_verbatim_expr(raw).unwrap() {
            PureExpr::Verbatim(s) => assert_eq!(s, raw),
            other => panic!("expected PureExpr::Verbatim, got {:?}", other),
        }
    }

    #[test]
    fn build_verbatim_stmt_appends_trailing_semicolon_if_missing() {
        // The line-splice pass replaces the whole stub line (which includes
        // a synthetic `;`), so the carrier MUST itself terminate the stmt.
        match StmtConverter::build_verbatim_stmt("let x = 1").unwrap() {
            PureStmt::Verbatim(s) => assert_eq!(s, "let x = 1;"),
            other => panic!("expected PureStmt::Verbatim, got {:?}", other),
        }
    }

    #[test]
    fn build_verbatim_stmt_preserves_user_terminator_and_interior_spacing() {
        // Interior raw spacing is preserved; the existing `;` is not doubled.
        let raw = "let  x   =   foo ! { a , b } ;";
        match StmtConverter::build_verbatim_stmt(raw).unwrap() {
            PureStmt::Verbatim(s) => assert_eq!(s, raw),
            other => panic!("expected PureStmt::Verbatim, got {:?}", other),
        }
    }

    #[test]
    fn build_verbatim_expr_rejects_syntactically_invalid_input() {
        // Malformed inputs must be caught at the converter boundary so the
        // raw stub never reaches `PureFile::to_source`.
        assert!(StmtConverter::build_verbatim_expr("let x = ;").is_err());
    }

    #[test]
    fn build_verbatim_stmt_rejects_syntactically_invalid_input() {
        assert!(StmtConverter::build_verbatim_stmt("@@@ nonsense @@@").is_err());
    }

    // -------------------------------------------------------------------------
    // RL043 tail-expression replacement pins (2026-06-12 bulk-lint sweep)
    // -------------------------------------------------------------------------

    #[test]
    fn build_verbatim_replacement_stmt_honors_tail_expr_intent() {
        // Terminator-less bare expression is carried verbatim WITHOUT a
        // synthetic `;`, so the replaced statement can become the block's
        // tail expression (RL043 `return x;` → `x`). With semi
        // auto-completion the splice emitted `x;` and the post-mutation
        // cargo check failed with "mismatched types".
        match StmtConverter::build_verbatim_replacement_stmt("sum").unwrap() {
            PureStmt::Verbatim(s) => assert_eq!(s, "sum"),
            other => panic!("expected PureStmt::Verbatim, got {:?}", other),
        }
    }

    #[test]
    fn build_verbatim_replacement_stmt_keeps_semi_completion_for_let() {
        // `let pat = init` parses as syn::Expr::Let (let-chain grammar
        // leniency) but is statement-shaped input — it must stay on the
        // normalizing semi-completion path (regression pin for
        // v2_replace_statement_basic).
        match StmtConverter::build_verbatim_replacement_stmt("let new_value = 20").unwrap() {
            PureStmt::Verbatim(s) => assert_eq!(s, "let new_value = 20;"),
            other => panic!("expected PureStmt::Verbatim, got {:?}", other),
        }
    }

    #[test]
    fn build_verbatim_replacement_stmt_passes_explicit_terminator_through() {
        // An explicit `;` is statement intent — unchanged passthrough.
        match StmtConverter::build_verbatim_replacement_stmt("foo();").unwrap() {
            PureStmt::Verbatim(s) => assert_eq!(s, "foo();"),
            other => panic!("expected PureStmt::Verbatim, got {:?}", other),
        }
    }
}