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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! ASTRegApply implementation for use statement mutations

use ryo_mutations::basic::{AddUseMutation, RemoveUseMutation};
use ryo_mutations::MutationResult;
use ryo_source::pure::{PureItem, PureUse, PureUseTree, PureVis};
use ryo_symbol::SymbolKind;

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

impl ASTRegApply for AddUseMutation {
    fn apply_to_registry(&self, ctx: &mut ASTMutationContext) -> MutationResult {
        // Find crate root module
        let module_id = ctx
            .symbol_registry
            .iter()
            .filter(|(id, _)| ctx.symbol_registry.kind(*id) == Some(SymbolKind::Mod))
            .find(|(_, path)| path.to_string() == "crate")
            .map(|(id, _)| id);

        let module_id = match module_id {
            Some(id) => id,
            None => {
                return MutationResult {
                    mutation_type: "AddUse".to_string(),
                    changes: 0,
                    description: "Crate root module not found".to_string(),
                };
            }
        };

        // Check if use statement already exists
        let exists = ctx
            .symbol_registry
            .iter()
            .filter(|(id, _)| ctx.symbol_registry.kind(*id) == Some(SymbolKind::Use))
            .any(|(_, path)| path.name() == self.path);

        if exists {
            return MutationResult {
                mutation_type: "AddUse".to_string(),
                changes: 0,
                description: format!("Use statement '{}' already exists", self.path),
            };
        }

        // Parse path into PureUseTree
        let tree = parse_path_to_tree(&self.path);

        // Create the use statement
        let use_item = PureUse {
            vis: PureVis::Private,
            tree,
        };

        // Use the path as the name for registration
        let use_path = ctx
            .symbol_registry
            .path(module_id)
            .and_then(|p| p.child(&self.path).ok());

        if let Some(path) = use_path {
            if let Ok(use_id) = ctx.symbol_registry.register(path, SymbolKind::Use) {
                ctx.ast_registry.set(use_id, PureItem::Use(use_item));

                return MutationResult {
                    mutation_type: "AddUse".to_string(),
                    changes: 1,
                    description: format!("Added use statement '{}'", self.path),
                };
            }
        }

        MutationResult {
            mutation_type: "AddUse".to_string(),
            changes: 0,
            description: format!("Failed to register use statement '{}'", self.path),
        }
    }
}

impl ASTRegApply for RemoveUseMutation {
    fn apply_to_registry(&self, ctx: &mut ASTMutationContext) -> MutationResult {
        let use_id = ctx
            .symbol_registry
            .iter()
            .filter(|(id, _)| ctx.symbol_registry.kind(*id) == Some(SymbolKind::Use))
            .find(|(_, path)| {
                if self.path.contains("::") {
                    path.to_string() == self.path || path.name() == self.path
                } else {
                    path.name() == self.path
                }
            })
            .map(|(id, _)| id);

        let use_id = match use_id {
            Some(id) => id,
            None => {
                return MutationResult {
                    mutation_type: "RemoveUse".to_string(),
                    changes: 0,
                    description: format!("Use statement '{}' not found", self.path),
                };
            }
        };

        ctx.ast_registry.remove(use_id);

        MutationResult {
            mutation_type: "RemoveUse".to_string(),
            changes: 1,
            description: format!("Removed use statement '{}'", self.path),
        }
    }
}

/// Parse a path string into PureUseTree
fn parse_path_to_tree(path: &str) -> PureUseTree {
    let parts: Vec<&str> = path.split("::").collect();
    if parts.is_empty() {
        return PureUseTree::Name(path.to_string());
    }

    // Build tree from right to left
    let mut tree = PureUseTree::Name(
        parts
            .last()
            .expect("is_empty() guard above guarantees a last element")
            .to_string(),
    );
    for part in parts.iter().rev().skip(1) {
        tree = PureUseTree::Path {
            path: part.to_string(),
            tree: Box::new(tree),
        };
    }
    tree
}