ryo-mutations 0.1.0

[experimental] Code transformation primitives for Rust source code
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

//! Field mutations: AddFieldMutation, RemoveFieldMutation, AddStructLiteralFieldMutation, RemoveStructLiteralFieldMutation

use ryo_symbol::SymbolId;

use crate::Mutation;

/// Add a field to an existing struct
#[derive(Debug, Clone)]
pub struct AddFieldMutation {
    pub struct_id: SymbolId,
    pub field_name: String,
    pub field_type: String,
    pub is_pub: bool,
}

impl AddFieldMutation {
    pub fn new(
        struct_id: SymbolId,
        field_name: impl Into<String>,
        field_type: impl Into<String>,
    ) -> Self {
        Self {
            struct_id,
            field_name: field_name.into(),
            field_type: field_type.into(),
            is_pub: false,
        }
    }

    pub fn public(mut self) -> Self {
        self.is_pub = true;
        self
    }
}

impl Mutation for AddFieldMutation {
    fn describe(&self) -> String {
        let vis = if self.is_pub { "pub " } else { "" };
        format!(
            "Add {}{}: {} to struct {}",
            vis, self.field_name, self.field_type, self.struct_id
        )
    }

    fn mutation_type(&self) -> &'static str {
        "AddField"
    }

    fn box_clone(&self) -> Box<dyn Mutation> {
        Box::new(self.clone())
    }
}

/// Remove a field from a struct
#[derive(Debug, Clone)]
pub struct RemoveFieldMutation {
    /// SymbolId for the target struct (required, O(1) access)
    pub struct_id: SymbolId,
    pub field_name: String,
}

impl RemoveFieldMutation {
    pub fn new(struct_id: SymbolId, field_name: impl Into<String>) -> Self {
        Self {
            struct_id,
            field_name: field_name.into(),
        }
    }
}

impl Mutation for RemoveFieldMutation {
    fn describe(&self) -> String {
        format!("Remove field '{}' from {}", self.field_name, self.struct_id)
    }

    fn mutation_type(&self) -> &'static str {
        "RemoveField"
    }

    fn box_clone(&self) -> Box<dyn Mutation> {
        Box::new(self.clone())
    }
}

/// Add a field to all struct literals of a given struct type
#[derive(Debug, Clone)]
pub struct AddStructLiteralFieldMutation {
    /// SymbolId of the struct definition (required, O(1) lookup)
    pub struct_id: SymbolId,
    /// The field name to add
    pub field_name: String,
    /// The value expression (e.g., "None", "Default::default()")
    pub value: String,
}

impl AddStructLiteralFieldMutation {
    pub fn new(
        struct_id: SymbolId,
        field_name: impl Into<String>,
        value: impl Into<String>,
    ) -> Self {
        Self {
            struct_id,
            field_name: field_name.into(),
            value: value.into(),
        }
    }
}

impl Mutation for AddStructLiteralFieldMutation {
    fn describe(&self) -> String {
        format!(
            "Add field '{}' = {} to struct literals ({})",
            self.field_name, self.value, self.struct_id
        )
    }

    fn mutation_type(&self) -> &'static str {
        "AddStructLiteralField"
    }

    fn box_clone(&self) -> Box<dyn Mutation> {
        Box::new(self.clone())
    }
}

/// Remove a field from all struct literals of a given struct type
#[derive(Debug, Clone)]
pub struct RemoveStructLiteralFieldMutation {
    /// SymbolId of the struct definition (required, O(1) lookup)
    pub struct_id: SymbolId,
    /// The field name to remove
    pub field_name: String,
}

impl RemoveStructLiteralFieldMutation {
    pub fn new(struct_id: SymbolId, field_name: impl Into<String>) -> Self {
        Self {
            struct_id,
            field_name: field_name.into(),
        }
    }
}

impl Mutation for RemoveStructLiteralFieldMutation {
    fn describe(&self) -> String {
        format!(
            "Remove field '{}' from struct literals ({})",
            self.field_name, self.struct_id
        )
    }

    fn mutation_type(&self) -> &'static str {
        "RemoveStructLiteralField"
    }

    fn box_clone(&self) -> Box<dyn Mutation> {
        Box::new(self.clone())
    }
}