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

//! ASTRegApply implementation for field mutations

use ryo_mutations::basic::{AddFieldMutation, RemoveFieldMutation};
use ryo_mutations::MutationResult;
use ryo_source::pure::{PureField, PureFields, PureItem, PureType, PureVis};

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

impl ASTRegApply for AddFieldMutation {
    fn apply_to_registry(&self, ctx: &mut ASTMutationContext) -> MutationResult {
        let target_id = self.struct_id;

        // Get the AST
        let ast = match ctx.get_ast_mut(target_id) {
            Some(ast) => ast,
            None => {
                return MutationResult {
                    mutation_type: "AddField".to_string(),
                    changes: 0,
                    description: format!("AST not found for {:?}", target_id),
                };
            }
        };

        // Modify the struct
        if let PureItem::Struct(s) = ast {
            // Check if field already exists
            if let PureFields::Named(fields) = &s.fields {
                if fields.iter().any(|f| f.name == self.field_name) {
                    return MutationResult {
                        mutation_type: "AddField".to_string(),
                        changes: 0,
                        description: format!("Field '{}' already exists", self.field_name),
                    };
                }
            }

            // Create new field
            let new_field = PureField {
                attrs: Vec::new(),
                vis: if self.is_pub {
                    PureVis::Public
                } else {
                    PureVis::Private
                },
                name: self.field_name.clone(),
                ty: PureType::Path(self.field_type.clone()),
            };

            // Add the field
            match &mut s.fields {
                PureFields::Named(fields) => {
                    fields.push(new_field);
                }
                PureFields::Unit => {
                    s.fields = PureFields::Named(vec![new_field]);
                }
                PureFields::Tuple(_) => {
                    return MutationResult {
                        mutation_type: "AddField".to_string(),
                        changes: 0,
                        description: "Cannot add named field to tuple struct".to_string(),
                    };
                }
            }

            ctx.emit_modified(
                target_id,
                ModificationType::FieldAdded(self.field_name.clone()),
            );

            MutationResult {
                mutation_type: "AddField".to_string(),
                changes: 1,
                description: format!("Added field '{}'", self.field_name),
            }
        } else {
            MutationResult {
                mutation_type: "AddField".to_string(),
                changes: 0,
                description: format!("{:?} is not a struct", target_id),
            }
        }
    }
}

impl ASTRegApply for RemoveFieldMutation {
    fn apply_to_registry(&self, ctx: &mut ASTMutationContext) -> MutationResult {
        let target_id = self.struct_id;

        // Get the AST
        let ast = match ctx.get_ast_mut(target_id) {
            Some(ast) => ast,
            None => {
                return MutationResult {
                    mutation_type: "RemoveField".to_string(),
                    changes: 0,
                    description: format!("AST not found for {:?}", target_id),
                };
            }
        };

        // Modify the struct
        if let PureItem::Struct(s) = ast {
            if let PureFields::Named(fields) = &mut s.fields {
                let original_len = fields.len();
                fields.retain(|f| f.name != self.field_name);

                if fields.len() < original_len {
                    ctx.emit_modified(
                        target_id,
                        ModificationType::FieldRemoved(self.field_name.clone()),
                    );

                    return MutationResult {
                        mutation_type: "RemoveField".to_string(),
                        changes: 1,
                        description: format!("Removed field '{}'", self.field_name),
                    };
                }
            }

            MutationResult {
                mutation_type: "RemoveField".to_string(),
                changes: 0,
                description: format!("Field '{}' not found", self.field_name),
            }
        } else {
            MutationResult {
                mutation_type: "RemoveField".to_string(),
                changes: 0,
                description: format!("{:?} is not a struct", target_id),
            }
        }
    }
}