enumerable: make fields private

Author: carllerche

tests/tests/enumerable.rs

@@ -11,30 +11,14 @@ fn test_manual_impl() {
 
     static ENUM_STRUCT_FIELDS: &[NamedField<'static>] = &[NamedField::new("x")];
     static ENUM_VARIANTS: &[VariantDef<'static>] = &[
-        VariantDef {
-            name: "Struct",
-            fields: Fields::NamedStatic(&ENUM_STRUCT_FIELDS),
-            is_dynamic: false,
-        },
-        VariantDef {
-            name: "Tuple",
-            fields: Fields::Unnamed,
-            is_dynamic: false,
-        },
-        VariantDef {
-            name: "Unit",
-            fields: Fields::Unnamed,
-            is_dynamic: false,
-        },
+        VariantDef::new("Struct", Fields::NamedStatic(&ENUM_STRUCT_FIELDS), false),
+        VariantDef::new("Tuple", Fields::Unnamed, false),
+        VariantDef::new("Unit", Fields::Unnamed, false),
     ];
 
     impl Enumerable for Enum {
         fn definition(&self) -> EnumDef<'_> {
-            EnumDef {
-                name: "Enum",
-                variants: ENUM_VARIANTS,
-                is_dynamic: false,
-            }
+            EnumDef::new("Enum", ENUM_VARIANTS, false)
         }
     }
 

valuable-derive/src/expand.rs

@@ -119,11 +119,11 @@ fn derive_enum(input: &syn::DeriveInput, data: &syn::DataEnum) -> TokenStream {
                 let variant_name = &variant.ident;
                 let variant_name_literal = variant_name.to_string();
                 variant_defs.push(quote! {
-                    ::valuable::VariantDef {
-                        name: #variant_name_literal,
-                        fields: ::valuable::field::Fields::NamedStatic(#named_fields_static_name),
-                        is_dynamic: false,
-                    },
+                    ::valuable::VariantDef::new(
+                        #variant_name_literal,
+                        ::valuable::field::Fields::NamedStatic(#named_fields_static_name),
+                        false,
+                    ),
                 });
 
                 let fields: Vec<_> = variant
@@ -149,11 +149,11 @@ fn derive_enum(input: &syn::DeriveInput, data: &syn::DataEnum) -> TokenStream {
                 let variant_name = &variant.ident;
                 let variant_name_literal = variant_name.to_string();
                 variant_defs.push(quote! {
-                    ::valuable::VariantDef {
-                        name: #variant_name_literal,
-                        fields: ::valuable::field::Fields::Unnamed,
-                        is_dynamic: false,
-                    },
+                    ::valuable::VariantDef::new(
+                        #variant_name_literal,
+                        ::valuable::field::Fields::Unnamed,
+                        false,
+                    ),
                 });
 
                 let bindings: Vec<_> = (0..variant.fields.len())
@@ -174,11 +174,11 @@ fn derive_enum(input: &syn::DeriveInput, data: &syn::DataEnum) -> TokenStream {
                 let variant_name = &variant.ident;
                 let variant_name_literal = variant_name.to_string();
                 variant_defs.push(quote! {
-                    ::valuable::VariantDef {
-                        name: #variant_name_literal,
-                        fields: ::valuable::field::Fields::Unnamed,
-                        is_dynamic: false,
-                    },
+                    ::valuable::VariantDef::new(
+                        #variant_name_literal,
+                        ::valuable::field::Fields::Unnamed,
+                        false,
+                    ),
                 });
 
                 visit_variants.push(quote! {
@@ -204,11 +204,11 @@ fn derive_enum(input: &syn::DeriveInput, data: &syn::DataEnum) -> TokenStream {
     let enumerable_impl = quote! {
         impl #impl_generics ::valuable::Enumerable for #name #ty_generics #where_clause {
             fn definition(&self) -> ::valuable::EnumDef<'_> {
-                ::valuable::EnumDef {
-                    name: #name_literal,
-                    variants: #variants_static_name,
-                    is_dynamic: false,
-                }
+                ::valuable::EnumDef::new(
+                    #name_literal,
+                    #variants_static_name,
+                    false,
+                )
             }
         }
     };

valuable/src/enumerable.rs

@@ -9,30 +9,42 @@ pub trait Enumerable: Valuable {
 
 pub struct EnumDef<'a> {
     /// Enum type name
-    pub name: &'a str,
+    name: &'a str,
 
     /// Known variants
-    pub variants: &'a [VariantDef<'a>],
+    variants: &'a [VariantDef<'a>],
 
     /// `true` when not all variants are statically known
-    pub is_dynamic: bool,
+    is_dynamic: bool,
 }
 
 pub struct VariantDef<'a> {
     /// Variant name
-    pub name: &'a str,
+    name: &'a str,
 
-    pub fields: Fields<'a>,
+    fields: Fields<'a>,
 
     /// Are all fields statically known?
-    pub is_dynamic: bool,
+    is_dynamic: bool,
 }
 
 pub struct Variant<'a> {
     pub name: &'a str,
 }
 
-impl EnumDef<'_> {
+impl<'a> EnumDef<'a> {
+    pub const fn new(
+        name: &'a str,
+        variants: &'a [VariantDef<'a>],
+        is_dynamic: bool,
+    ) -> EnumDef<'a> {
+        EnumDef {
+            name,
+            variants,
+            is_dynamic,
+        }
+    }
+
     pub fn name(&self) -> &str {
         self.name
     }
@@ -46,7 +58,33 @@ impl EnumDef<'_> {
     }
 }
 
-impl Variant<'_> {
+impl<'a> VariantDef<'a> {
+    pub const fn new(name: &'a str, fields: Fields<'a>, is_dynamic: bool) -> VariantDef<'a> {
+        VariantDef {
+            name,
+            fields,
+            is_dynamic,
+        }
+    }
+
+    pub fn name(&self) -> &str {
+        self.name
+    }
+
+    pub fn fields(&self) -> &Fields<'_> {
+        &self.fields
+    }
+
+    pub fn is_dynamic(&self) -> bool {
+        self.is_dynamic
+    }
+}
+
+impl<'a> Variant<'a> {
+    pub const fn new(name: &'a str) -> Variant<'a> {
+        Variant { name }
+    }
+
     pub fn name(&self) -> &str {
         self.name
     }