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

//! ASTRegApply implementation for impl block mutations

use ryo_mutations::basic::{AddImplMutation, RemoveImplMutation};
use ryo_mutations::MutationResult;
use ryo_source::pure::{PureGenerics, PureImpl, PureItem};
use ryo_symbol::SymbolKind;

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

impl ASTRegApply for AddImplMutation {
    fn apply_to_registry(&self, ctx: &mut ASTMutationContext) -> MutationResult {
        // Use the provided symbol_id as the parent module
        let module_id = self.parent;

        // Verify the target is a module
        if ctx.symbol_registry.kind(module_id) != Some(SymbolKind::Mod) {
            return MutationResult {
                mutation_type: "AddImpl".to_string(),
                changes: 0,
                description: format!("Target symbol {} is not a module", module_id),
            };
        }

        // Create the impl block
        let impl_item = PureImpl {
            attrs: vec![],
            generics: PureGenerics::default(),
            is_unsafe: false,
            trait_: self.trait_name.clone(),
            self_ty: self.target.clone(),
            items: vec![],
        };

        // Register impl - name format: <impl Type> or <impl Trait for Type>
        let impl_name = if let Some(trait_name) = &self.trait_name {
            format!("<impl {} for {}>", trait_name, self.target)
        } else {
            format!("<impl {}>", self.target)
        };

        let parent_path = match ctx.symbol_registry.path(module_id) {
            Some(p) => p,
            None => {
                return MutationResult {
                    mutation_type: "AddImpl".to_string(),
                    changes: 0,
                    description: format!("Module {} not found in registry", module_id),
                };
            }
        };

        let impl_path = match parent_path.child(&impl_name) {
            Ok(p) => p,
            Err(_) => {
                return MutationResult {
                    mutation_type: "AddImpl".to_string(),
                    changes: 0,
                    description: format!("Failed to create path for impl '{}'", impl_name),
                };
            }
        };

        match ctx.symbol_registry.register(impl_path, SymbolKind::Impl) {
            Ok(impl_id) => {
                ctx.ast_registry
                    .set(impl_id, PureItem::Impl(impl_item.clone()));

                // Add to module_items for file generation
                let mut items = ctx
                    .ast_registry
                    .get_module_items(module_id)
                    .cloned()
                    .unwrap_or_default();
                items.push(PureItem::Impl(impl_item));
                ctx.ast_registry.set_module_items(module_id, items);

                MutationResult {
                    mutation_type: "AddImpl".to_string(),
                    changes: 1,
                    description: format!("Added impl {} to module {}", impl_name, module_id),
                }
            }
            Err(e) => MutationResult {
                mutation_type: "AddImpl".to_string(),
                changes: 0,
                description: format!("Failed to register impl '{}': {:?}", impl_name, e),
            },
        }
    }
}

impl ASTRegApply for RemoveImplMutation {
    fn apply_to_registry(&self, ctx: &mut ASTMutationContext) -> MutationResult {
        // Use the provided symbol_id directly
        let impl_id = self.symbol_id;

        // Verify the target is an impl block
        if ctx.symbol_registry.kind(impl_id) != Some(SymbolKind::Impl) {
            return MutationResult {
                mutation_type: "RemoveImpl".to_string(),
                changes: 0,
                description: format!("Symbol {} is not an impl block", impl_id),
            };
        }

        // Remove from AST registry
        ctx.ast_registry.remove(impl_id);

        MutationResult {
            mutation_type: "RemoveImpl".to_string(),
            changes: 1,
            description: format!("Removed impl block {}", impl_id),
        }
    }
}