From fe652480a18d5132e4d8a30ebc473234c06d4847 Mon Sep 17 00:00:00 2001
From: Jakob Degen <jakobdegen@meta.com>
Date: Wed, 15 May 2024 23:08:29 -0700
Subject: [PATCH] gazebo: Add `variant_name_lowercase`

Summary:
As it says in the title, need it next diff.

You can't really implement this on top of gazebo, at least not if you're hoping to get out a `&'static str`

Reviewed By: stepancheg

Differential Revision: D57251553

fbshipit-source-id: 63b2e4786aed7c06846b438fe7c3f1ec2a9d7d49
---
 gazebo/src/variants.rs       | 25 ++++++++++++++++++++++---
 gazebo_derive/src/variant.rs | 11 +++++++++++
 2 files changed, 33 insertions(+), 3 deletions(-)

diff --git a/gazebo/src/variants.rs b/gazebo/src/variants.rs
index 8a00ab4..96118d9 100644
--- a/gazebo/src/variants.rs
+++ b/gazebo/src/variants.rs
@@ -92,6 +92,8 @@ pub use gazebo_derive::VariantName;
 
 pub trait VariantName {
     fn variant_name(&self) -> &'static str;
+
+    fn variant_name_lowercase(&self) -> &'static str;
 }
 
 impl<T> VariantName for Option<T> {
@@ -101,6 +103,13 @@ impl<T> VariantName for Option<T> {
             None => "None",
         }
     }
+
+    fn variant_name_lowercase(&self) -> &'static str {
+        match self {
+            Self::Some(_) => "some",
+            None => "none",
+        }
+    }
 }
 
 impl<T, E> VariantName for Result<T, E> {
@@ -110,6 +119,13 @@ impl<T, E> VariantName for Result<T, E> {
             Self::Err(_) => "Err",
         }
     }
+
+    fn variant_name_lowercase(&self) -> &'static str {
+        match self {
+            Self::Ok(_) => "ok",
+            Self::Err(_) => "err",
+        }
+    }
 }
 
 #[cfg(test)]
@@ -125,16 +141,19 @@ mod tests {
         enum MyEnum {
             Foo,
             Bar(usize),
-            Baz { field: usize },
+            FooBaz { field: usize },
         }
 
         let x = MyEnum::Foo;
         assert_eq!(x.variant_name(), "Foo");
+        assert_eq!(x.variant_name_lowercase(), "foo");
 
         let x = MyEnum::Bar(1);
         assert_eq!(x.variant_name(), "Bar");
+        assert_eq!(x.variant_name_lowercase(), "bar");
 
-        let x = MyEnum::Baz { field: 1 };
-        assert_eq!(x.variant_name(), "Baz");
+        let x = MyEnum::FooBaz { field: 1 };
+        assert_eq!(x.variant_name(), "FooBaz");
+        assert_eq!(x.variant_name_lowercase(), "foo_baz");
     }
 }
diff --git a/gazebo_derive/src/variant.rs b/gazebo_derive/src/variant.rs
index 2bcc447..288ba47 100644
--- a/gazebo_derive/src/variant.rs
+++ b/gazebo_derive/src/variant.rs
@@ -18,6 +18,7 @@ use syn::Ident;
 pub(crate) fn derive_variant_names(input: DeriveInput) -> syn::Result<proc_macro::TokenStream> {
     if let Data::Enum(data_enum) = input.data {
         let mut variant_body = Vec::new();
+        let mut variant_lowercase_body = Vec::new();
         for variant in data_enum.variants {
             let variant_name = &variant.ident;
             let patterns = match variant.fields {
@@ -26,9 +27,13 @@ pub(crate) fn derive_variant_names(input: DeriveInput) -> syn::Result<proc_macro
                 Fields::Unnamed(_) => quote! { (..) },
             };
             let variant_name_str = variant_name.to_string();
+            let variant_name_lowercase_str = to_snake_case(&variant_name_str);
             variant_body.push(quote! {
                 Self::#variant_name #patterns => #variant_name_str
             });
+            variant_lowercase_body.push(quote! {
+                Self::#variant_name #patterns => #variant_name_lowercase_str
+            });
         }
 
         let name = &input.ident;
@@ -41,6 +46,12 @@ pub(crate) fn derive_variant_names(input: DeriveInput) -> syn::Result<proc_macro
                         #(#variant_body,)*
                     }
                 }
+
+                fn variant_name_lowercase(&self) -> &'static str {
+                    match self {
+                        #(#variant_lowercase_body,)*
+                    }
+                }
             }
         };