ryo-executor 0.1.0

[experimental] Mutation execution engine for RYO - parallel execution, conflict detection, workspace management
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! V2 ASTRegApply implementation for LoopToIteratorMutation
//!
//! Converts for loops to iterator chains:
//! - `let mut v = Vec::new(); for x in iter { v.push(f(x)) }` → `let v = iter.map(f).collect()`
//! - `for x in iter { if cond { v.push(x) } }` → `iter.filter(cond).collect()`

use ryo_analysis::SymbolKind;
use ryo_mutations::idiom::LoopToIteratorMutation;
use ryo_mutations::{Mutation, MutationResult};
use ryo_source::pure::{PureImplItem, PureItem};

use crate::engine::{ASTMutationContext, ASTRegApply};

impl ASTRegApply for LoopToIteratorMutation {
    fn apply_to_registry(&self, ctx: &mut ASTMutationContext) -> MutationResult {
        let mut total_changes = 0;

        // Process standalone functions
        let fn_ids: Vec<_> = ctx
            .symbol_registry
            .iter()
            .filter(|(id, _)| matches!(ctx.symbol_registry.kind(*id), Some(SymbolKind::Function)))
            .map(|(id, _)| id)
            .collect();

        for id in fn_ids {
            if let Some(PureItem::Fn(f)) = ctx.ast_registry.get_mut(id) {
                total_changes += self.transform_block(&mut f.body);
            }
        }

        // Process impl blocks (methods)
        let impl_ids: Vec<_> = ctx
            .symbol_registry
            .iter()
            .filter(|(id, _)| matches!(ctx.symbol_registry.kind(*id), Some(SymbolKind::Impl)))
            .map(|(id, _)| id)
            .collect();

        for id in impl_ids {
            if let Some(PureItem::Impl(imp)) = ctx.ast_registry.get_mut(id) {
                for impl_item in &mut imp.items {
                    if let PureImplItem::Fn(f) = impl_item {
                        total_changes += self.transform_block(&mut f.body);
                    }
                }
            }
        }

        MutationResult {
            mutation_type: self.mutation_type().to_string(),
            changes: total_changes,
            description: if total_changes > 0 {
                format!("Converted {} for loop(s) to iterator chains", total_changes)
            } else {
                "No for loops converted".to_string()
            },
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::engine::ASTMutationEngine;
    use ryo_analysis::testing::ContextBuilder;

    #[test]
    fn test_v2_loop_to_iter_map_collect() {
        let mut ctx = ContextBuilder::new()
            .with_file(
                "src/lib.rs",
                r#"
fn process(items: Vec<i32>) -> Vec<i32> {
    let mut result = Vec::new();
    for x in items {
        result.push(x * 2);
    }
    result
}
"#,
            )
            .build();

        let mutation = LoopToIteratorMutation::new();
        let result = ASTMutationEngine::execute_ast_reg(&mutation, &mut ctx);

        assert_eq!(result.result.changes, 1);
    }

    #[test]
    fn test_v2_loop_to_iter_no_changes() {
        let mut ctx = ContextBuilder::new()
            .with_file(
                "src/lib.rs",
                r#"
fn process(items: Vec<i32>) -> Vec<i32> {
    items.into_iter().map(|x| x * 2).collect()
}
"#,
            )
            .build();

        let mutation = LoopToIteratorMutation::new();
        let result = ASTMutationEngine::execute_ast_reg(&mutation, &mut ctx);

        assert_eq!(result.result.changes, 0);
    }
}