ryo_executor/executor/registry/converters/
enum_.rs

1//! EnumConverter: Converts MutationSpec::AddVariant and RemoveVariant
2
3use crate::engine::ASTRegApply;
4use crate::executor::registry::converters::ResolveTargetSymbol;
5use crate::executor::registry::{ConvertError, MutationConverter};
6use crate::executor::spec::{MutationSpec, VariantKind};
7use ryo_analysis::AnalysisContext;
8use ryo_mutations::{AddVariantMutation, RemoveVariantMutation};
9
10/// Converter for Enum variant mutations (AddVariant, RemoveVariant)
11#[derive(Debug, Clone, Default)]
12pub struct EnumConverter;
13
14impl EnumConverter {
15    pub fn new() -> Self {
16        Self
17    }
18}
19
20// EnumConverter uses the default implementation of ResolveTargetSymbol
21impl ResolveTargetSymbol for EnumConverter {}
22
23impl MutationConverter for EnumConverter {
24    fn spec_kinds(&self) -> &'static [&'static str] {
25        &["AddVariant", "RemoveVariant"]
26    }
27
28    fn convert_v2(
29        &self,
30        spec: &MutationSpec,
31        ctx: &AnalysisContext,
32    ) -> Result<Vec<Box<dyn ASTRegApply>>, ConvertError> {
33        use ryo_source::pure::{PureField, PureFields, PureType, PureVis};
34
35        match spec {
36            MutationSpec::AddVariant {
37                target: target_symbol,
38                variant_name,
39                variant_kind,
40            } => {
41                // Resolve target_symbol to SymbolId
42                let symbol_id = self.resolve_target_symbol(target_symbol, ctx)?;
43
44                let fields = match variant_kind {
45                    VariantKind::Unit => PureFields::Unit,
46                    VariantKind::Tuple { types } => {
47                        PureFields::Tuple(types.iter().map(|t| PureType::Path(t.clone())).collect())
48                    }
49                    VariantKind::Struct { fields } => {
50                        let pure_fields: Vec<PureField> = fields
51                            .iter()
52                            .map(|(n, t)| PureField {
53                                attrs: Vec::new(),
54                                vis: PureVis::Private,
55                                name: n.clone(),
56                                ty: PureType::Path(t.clone()),
57                            })
58                            .collect();
59                        PureFields::Named(pure_fields)
60                    }
61                };
62                let mutation = AddVariantMutation::new(symbol_id, variant_name, fields);
63                Ok(vec![Box::new(mutation)])
64            }
65            MutationSpec::RemoveVariant {
66                target: target_symbol,
67                variant_name,
68            } => {
69                // Resolve target_symbol to SymbolId
70                let symbol_id = self.resolve_target_symbol(target_symbol, ctx)?;
71                let mutation = RemoveVariantMutation::new(symbol_id, variant_name);
72                Ok(vec![Box::new(mutation)])
73            }
74            _ => Err(ConvertError::TypeMismatch {
75                expected: "AddVariant or RemoveVariant",
76                actual: spec.kind_name().to_string(),
77            }),
78        }
79    }
80}
81
82#[cfg(test)]
83mod tests {
84    use super::*;
85    use crate::executor::spec::MutationTargetSymbol;
86    use ryo_symbol::{SymbolKind, SymbolPath, SymbolRegistry};
87
88    fn create_test_symbol_id() -> ryo_symbol::SymbolId {
89        let mut registry = SymbolRegistry::new();
90        let path = SymbolPath::parse("test_crate::Status").unwrap();
91        registry.register(path, SymbolKind::Enum).unwrap()
92    }
93
94    #[test]
95    fn test_enum_converter_spec_kinds() {
96        let converter = EnumConverter::new();
97        assert_eq!(converter.spec_kinds(), &["AddVariant", "RemoveVariant"]);
98    }
99
100    #[test]
101    fn test_enum_converter_can_handle_add_variant() {
102        let converter = EnumConverter::new();
103        let id = create_test_symbol_id();
104
105        let spec = MutationSpec::AddVariant {
106            target: MutationTargetSymbol::ById(id),
107            variant_name: "Pending".into(),
108            variant_kind: VariantKind::Unit,
109        };
110        assert!(converter.can_handle(&spec));
111    }
112
113    #[test]
114    fn test_enum_converter_can_handle_remove_variant() {
115        let converter = EnumConverter::new();
116        let id = create_test_symbol_id();
117
118        let spec = MutationSpec::RemoveVariant {
119            target: MutationTargetSymbol::ById(id),
120            variant_name: "Pending".into(),
121        };
122        assert!(converter.can_handle(&spec));
123    }
124}
ryo_executor/executor/registry/converters/enum_.rs

ryo_executor/executor/registry/converters/
enum_.rs
