feat: add Variant trait and derive macro

Author: khrynczenko

.gitignore

@@ -0,0 +1,2 @@
+/target
+/Cargo.lock

Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "tagname"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[dependencies]
+tagname_derive = { path = "tagname_derive" }
+
+[workspace]
+members = ["tagname_derive"]

src/lib.rs

@@ -0,0 +1,5 @@
+pub use tagname_derive::Variant;
+
+pub trait Variant {
+    fn tag_name(&self) -> &'static str;
+}

tagname_derive/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "tagname_derive"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[lib]
+proc-macro = true
+
+[dependencies]
+syn = "1.0"
+quote = "1.0"
+proc-macro2 = "1.0.47"
+

tagname_derive/src/lib.rs

@@ -0,0 +1,57 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{Ident, Variant};
+
+#[proc_macro_derive(Variant)]
+pub fn variant_derive(input: TokenStream) -> TokenStream {
+    let ast = syn::parse(input).unwrap();
+
+    // Build the trait implementation
+    impl_variant_derive_macro(ast)
+}
+
+fn impl_variant_derive_macro(ast: syn::DeriveInput) -> TokenStream {
+    let name = &ast.ident;
+    let variants: Vec<Variant> = match ast.data {
+        syn::Data::Enum(enum_data) => enum_data
+            .variants
+            .into_pairs()
+            .into_iter()
+            .map(|pair| pair.into_value())
+            .collect(),
+        _ => panic!("cannot derive Variant for non-enum types"),
+    };
+
+    let variants_with_fields = variants.iter().cloned().filter(|v| !v.fields.is_empty());
+    let variants_without_fields = variants.iter().cloned().filter(|v| v.fields.is_empty());
+    let with_field_tags: Vec<Ident> = variants_with_fields.into_iter().map(|v| v.ident).collect();
+    let no_field_tags: Vec<Ident> = variants_without_fields
+        .into_iter()
+        .map(|v| v.ident)
+        .collect();
+
+    let gen = quote! {
+        impl Variant for #name {
+            fn tag_name(&self) -> &'static str {
+                match self {
+                    #(
+                        #name::#with_field_tags(_) => stringify!(#with_field_tags)
+                    ),*,
+                    #(
+                        #name::#no_field_tags => stringify!(#no_field_tags)
+                    ),*
+                }
+            }
+        }
+    };
+    gen.into()
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        let result = 2 + 2;
+        assert_eq!(result, 4);
+    }
+}

tests/variant.rs

@@ -0,0 +1,18 @@
+use tagname::Variant;
+
+#[derive(Variant)]
+enum MyVariant {
+    Yes,
+    No,
+    Maybe(usize),
+}
+
+#[test]
+fn return_correct_tag_names() {
+    let v1 = MyVariant::Yes;
+    let v2 = MyVariant::No;
+    let v3 = MyVariant::Maybe(1);
+    assert_eq!(v1.tag_name(), "Yes");
+    assert_eq!(v2.tag_name(), "No");
+    assert_eq!(v3.tag_name(), "Maybe");
+}