Assign Rust default variant with attribute, validate presence (closes #43)

Author: kossnocorp

lang/rs/tree/src/context/convert/config.rs

@@ -0,0 +1,12 @@
+use crate::prelude::internal::*;
+
+impl RSConvertContext {
+    pub fn config(&self) -> &RsConfigLang {
+        &self.config
+    }
+
+    pub fn assign_config(&mut self, config: RsConfigLang) -> &mut Self {
+        self.config = config;
+        self
+    }
+}

lang/rs/tree/src/context/convert/mod.rs

@@ -13,6 +13,9 @@ pub use ids::*;
 mod naming;
 pub use naming::*;
 
+mod config;
+pub use config::*;
+
 #[derive(Default)]
 pub struct RSConvertContext {
     resolve: RSConvertResolve,

lang/rs/tree/src/enum/convert.rs

@@ -23,6 +23,18 @@ impl RSConvert<RSEnum> for GTUnion {
 
         trim_variant_names(&name, &mut variants, &mut variant_names);
 
+        if context.config().derive.contains(&"Default".into()) {
+            let default_attrs = variants
+                .iter()
+                .flat_map(|variant| variant.attributes.iter().find(|attr| attr.0 == "default"));
+            let count = default_attrs.clone().count();
+            if count == 0 {
+                return Err(RSConverterError::MissingDefaultVariant(self.span.clone()).into());
+            } else if count > 1 {
+                return Err(RSConverterError::MultipleDefaultVariants(self.span.clone()).into());
+            }
+        }
+
         let r#enum = RSEnum {
             id,
             doc,
@@ -55,6 +67,10 @@ fn convert_variant(
 
     context.enter_parent(RSContextParent::EnumVariant(variant_name.clone()));
 
+    if GTAttribute::find_flag(descriptor.attributes(), "default") {
+        attributes.push(RSAttribute("default".into()));
+    }
+
     let descriptor = match descriptor {
         GTDescriptor::Literal(literal) => {
             let str = render_literal(literal);
@@ -970,4 +986,130 @@ mod tests {
         "#
         );
     }
+
+    #[test]
+    fn test_attr_default() {
+        let mut context = Gtrs::convert_context_with_parent("Status");
+        let mut config = RsConfigLang::default();
+        config.derive.push("Default".into());
+        context.assign_config(config);
+        let union = Gt::union(descriptor_nodes![
+            Gt::primitive_string(),
+            node_with!(
+                Gt::primitive_number(),
+                attributes = vec![attribute_node!(default)]
+            ),
+        ]);
+        assert_debug_snapshot!(
+            convert_node_with(union, &mut context),
+            @r#"
+        RSEnum {
+            id: GTDefinitionId(
+                GTModuleId(
+                    "module",
+                ),
+                "Status",
+            ),
+            doc: None,
+            attributes: [
+                RSAttribute(
+                    "derive(Debug, Clone, PartialEq, Serialize, Deserialize)",
+                ),
+                RSAttribute(
+                    "serde(untagged)",
+                ),
+            ],
+            name: RSIdentifier(
+                "Status",
+            ),
+            variants: [
+                RSEnumVariant {
+                    doc: None,
+                    attributes: [],
+                    name: RSIdentifier(
+                        "String",
+                    ),
+                    descriptor: Some(
+                        Descriptor(
+                            Primitive(
+                                String,
+                            ),
+                        ),
+                    ),
+                },
+                RSEnumVariant {
+                    doc: None,
+                    attributes: [
+                        RSAttribute(
+                            "default",
+                        ),
+                    ],
+                    name: RSIdentifier(
+                        "Number",
+                    ),
+                    descriptor: Some(
+                        Descriptor(
+                            Primitive(
+                                Float64,
+                            ),
+                        ),
+                    ),
+                },
+            ],
+        }
+        "#
+        );
+    }
+
+    #[test]
+    fn test_attr_default_missing_err() {
+        let mut context = Gtrs::convert_context_with_parent("Status");
+        let mut config = RsConfigLang::default();
+        config.derive.push("Default".into());
+        context.assign_config(config);
+        let union = Gt::union(descriptor_nodes![
+            Gt::primitive_string(),
+            Gt::primitive_number()
+        ]);
+        assert_debug_snapshot!(
+            convert_node_err_with(union, &mut context),
+            @"
+        MissingDefaultVariant(
+            GTSpan(
+                0,
+                0,
+            ),
+        )
+        "
+        );
+    }
+
+    #[test]
+    fn test_attr_default_multiple_err() {
+        let mut context = Gtrs::convert_context_with_parent("Status");
+        let mut config = RsConfigLang::default();
+        config.derive.push("Default".into());
+        context.assign_config(config);
+        let union = Gt::union(descriptor_nodes![
+            node_with!(
+                Gt::primitive_string(),
+                attributes = vec![attribute_node!(default)]
+            ),
+            node_with!(
+                Gt::primitive_number(),
+                attributes = vec![attribute_node!(default)]
+            )
+        ]);
+        assert_debug_snapshot!(
+            convert_node_err_with(union, &mut context),
+            @"
+        MultipleDefaultVariants(
+            GTSpan(
+                0,
+                0,
+            ),
+        )
+        "
+        );
+    }
 }

lang/rs/tree/src/error/convert.rs

@@ -10,4 +10,10 @@ pub enum RSConverterError {
     #[error("Tried to convert unresolved reference")]
     #[diagnostic(code(GTRSC102))]
     UnresolvedReference(#[label("this reference")] GTSpan),
+    #[error("Missing default variant for enum with derived Default")]
+    #[diagnostic(code(GTRSC103))]
+    MissingDefaultVariant(#[label("enum")] GTSpan),
+    #[error("Multiple default variants for enum with derived Default")]
+    #[diagnostic(code(GTRSC104))]
+    MultipleDefaultVariants(#[label("enum")] GTSpan),
 }

lang/rs/tree/src/test.rs

@@ -11,6 +11,17 @@ pub fn convert_node_with<GtNode: RSConvert<Node>, Node>(
     gt_node.convert(context).unwrap()
 }
 
+pub fn convert_node_err_with<GtNode: RSConvert<Node>, Node>(
+    gt_node: GtNode,
+    context: &mut RSConvertContext,
+) -> miette::Report
+where
+    Node: std::fmt::Debug,
+{
+    let result = gt_node.convert(context);
+    result.unwrap_err()
+}
+
 pub struct Gtrs {}
 
 impl Gtrs {

parser/src/test/mod.rs

@@ -450,6 +450,14 @@ impl Gt {
         }
     }
 
+    pub fn attribute_flag(name: &str) -> GTAttribute {
+        GTAttribute {
+            span: (0, 2).into(),
+            name: Self::attribute_name(name),
+            descriptor: None,
+        }
+    }
+
     pub fn attribute_name(value: &str) -> GTAttributeName {
         GTAttributeName {
             span: (0, 0).into(),
@@ -491,15 +499,20 @@ macro_rules! node_with {
         node
     }};
 }
-
 #[macro_export]
 macro_rules! attribute_node {
+    // key = value
     ($key:ident = $value:expr) => {
         Gt::attribute(
             stringify!($key),
             Gt::attribute_assignment(Gt::literal_string($value)),
         )
     };
+
+    // flag-style: attribute_node!(default)
+    ($key:ident) => {
+        Gt::attribute_flag(stringify!($key))
+    };
 }
 
 #[macro_export]

parser/src/tree/attribute/mod.rs

@@ -70,4 +70,10 @@ impl GTAttribute {
         }
         None
     }
+
+    pub fn find_flag(attributes: &Vec<GTAttribute>, name: &str) -> bool {
+        attributes
+            .iter()
+            .any(|attr| attr.is_it(name) && attr.descriptor.is_none())
+    }
 }