Merge pull request #9 from ImaMapleTree/feature/release-1.0.0-stabilize-and-support-union

Implement Union Constructors

Author: ImaMapleTree

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "derive-ctor"
-version = "0.2.3"
-description = "Adds `#[derive(ctor)]` which allows for the auto-generation of struct and enum constructors."
+version = "1.0.0"
+description = "Adds `#[derive(ctor)]` which allows for the auto-generation of struct, enum, and union constructors."
 keywords = ["derive", "macro", "trait", "procedural", "no_std"]
 authors = ["Evan Cowin"]
 license = "MIT"
@@ -11,9 +11,10 @@ exclude = [".github/*", ".gitignore"]
 categories = ["no-std", "rust-patterns"]
 
 [features]
-default = ["structs", "enums"]
+default = ["structs", "enums", "unions"]
 enums = ["dep:heck"]
 structs = []
+unions = []
 
 [lib]
 proc-macro = true

Cargo.toml

@@ -1,11 +1,11 @@
 # derive-ctor
 
-`derive-ctor` is a Rust procedural macro crate that allows you to easily generate constructor methods for your structs.
-With the `#[derive(ctor)]` attribute, you can automatically create a constructor(s) for structs and enums. The crate also
+**derive-ctor** is a Rust procedural macro crate that allows you to easily generate constructor methods for your structs.
+With the `#[derive(ctor)]` attribute, you can automatically create a constructor(s) for structs, enums, and unions. The crate also
 provides various options to customize the generated constructor methods.
 
 ## Features
-- Automatically generate a constructor method for structs and enums with `#[derive(ctor)]`.
+- Automatically generate a constructor method for structs, enums, and unions with `#[derive(ctor)]`.
 - Customize the name and visibility of the auto-generated constructor using `#[ctor(visibility method_name)]`.
   - Supports const constructors by adding the "const" keyword.
   - Provide a list of names to generate multiple constructors.
@@ -25,7 +25,7 @@ Add `derive-ctor` to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-derive-ctor = "0.2.3"
+derive-ctor = "1.0.0"
 ```
 
 Annotate your struct with `#[derive(ctor)]` to automatically generate a `new` constructor:
@@ -97,7 +97,7 @@ struct OtherStruct {
 let default2: OtherStruct = Default::default();
 ```
 
-## Enum Configurations
+## Enum and Union Configurations
 
 By default, a constructor will be generated for each variant. This constructor by default will match the name of its
 respective variant and will be public. This default behaviour can be changed by annotating the enum with
@@ -146,6 +146,27 @@ let v3 = MyEnum::new_variant3();
 
 If a variant is derived with `#[ctor(none)]` it will **not** have a constructor generated for it.
 
+Unions express the same behaviours as enums except applicable to the fields of the union rather than the variants of
+an enum.
+
+```rust
+use derive_ctor::ctor;
+
+#[derive(ctor)]
+#[ctor(prefix = new, vis = pub(crate))]
+union MyUnion {
+    #[ctor(const new)]
+    v1: i32,
+    v2: f32,
+    v3: u32
+}
+
+const VAL: MyUnion = MyUnion::new(100);
+let v2 = MyUnion::new_v2(123.231);
+let v3 = MyUnion::new_v3(414224); 
+```
+
+
 ## Field Configurations
 
 Fields can also be annotated with `#[ctor(PROPERTY)]` to change their behaviour in the generated methods.

README.md

@@ -4,21 +4,21 @@ use alloc::string::ToString;
 use alloc::vec;
 use alloc::vec::Vec;
 
-#[cfg(feature = "enums")]
 use heck::ToSnakeCase;
 
 use crate::constants::{CONFIG_PROP_ERR_MSG, ENUM_PROP_VIS as VIS, ENUM_PROP_VISIBILITY as VISIBILITY, ENUM_PROP_PREFIX as PREFIX};
-use crate::structs::{CtorAttribute, CtorDefinition, CtorStructConfiguration, };
-use crate::try_parse_attributes_with_default;
+use crate::structs::CtorStructConfiguration;
+use crate::{CtorAttribute, CtorDefinition, try_parse_attributes_with_default};
+use crate::fields::generate_ctor_meta;
+
 use proc_macro2::Span;
 use quote::quote;
 use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
 use syn::token::{Comma, Pub};
 use syn::{token, Data, DeriveInput, Error, Fields, Generics, Ident, Variant, Visibility};
-use crate::fields::generate_ctor_meta;
 
-static ENUM_CTOR_PROPS: &str = "\"prefix\", \"visibility\", \"vis\"";
+const ENUM_CTOR_PROPS: &str = "\"prefix\", \"visibility\", \"vis\"";
 
 enum EnumConfigItem {
     Visibility { visibility: Visibility },
@@ -98,14 +98,6 @@ impl Parse for EnumConfigItem {
     }
 }
 
-#[cfg(not(feature = "enums"))]
-pub(crate) fn create_enum_token_stream(derive_input: DeriveInput) -> TokenStream {
-    use syn::spanned::Spanned;
-    TokenStream::from(Error::new(Span::call_site(),
-        "\"enums\" feature must be enabled to use #[derive(ctor)] on enums.").to_compile_error())
-}
-
-#[cfg(feature = "enums")]
 pub(crate) fn create_enum_token_stream(derive_input: DeriveInput) -> TokenStream {
     if let Data::Enum(data) = derive_input.data {
         let configuration = match try_parse_attributes_with_default(&derive_input.attrs, || { 
@@ -125,7 +117,6 @@ pub(crate) fn create_enum_token_stream(derive_input: DeriveInput) -> TokenStream
     panic!("Expected Enum data")
 }
 
-#[cfg(feature = "enums")]
 fn create_ctor_enum_impl(
     ident: Ident,
     generics: Generics,
@@ -202,7 +193,6 @@ fn create_ctor_enum_impl(
     })
 }
 
-#[cfg(feature = "enums")]
 fn convert_to_snakecase(method_ident: Ident) -> Result<Ident, Error> {
     let ident_string = method_ident.to_string();
     let trimmed_start_str = ident_string.trim_start_matches('_');
@@ -218,7 +208,7 @@ fn convert_to_snakecase(method_ident: Ident) -> Result<Ident, Error> {
     syn::parse_str(&snake_case)
 }
 
-#[test] #[cfg(feature = "enums")]
+#[test]
 fn test_convert_to_snakecase() {
     assert_eq!(
         convert_to_snakecase(Ident::new("A", Span::mixed_site())).unwrap(),

src/enums.rs

@@ -16,9 +16,7 @@ use crate::constants::{
     CONFIG_PROP_ERR_MSG, FIELD_PROP_CLONED as CLONED, FIELD_PROP_DEFAULT as DEFAULT,
     FIELD_PROP_EXPR as EXPR, FIELD_PROP_INTO as INTO, FIELD_PROP_ITER as ITER,
 };
-use crate::structs::CtorAttribute;
-use crate::structs::CtorAttribute::DefaultAll;
-use crate::{consume_delimited, is_phantom_data, try_parse_attributes};
+use crate::{consume_delimited, CtorAttribute, is_phantom_data, try_parse_attributes};
 
 const FIELD_PROPS: &str = "\"cloned\", \"default\", \"expr\", \"into\", \"iter\"";
 
@@ -219,7 +217,7 @@ pub(crate) fn generate_ctor_meta(
         let mut gen_configuration = None;
 
         match &configuration {
-            None if ctor_attributes.contains(&DefaultAll) => {
+            None if ctor_attributes.contains(&CtorAttribute::DefaultAll) => {
                 gen_configuration = Some(FieldConfigProperty::Default)
             }
             None if is_phantom_data(&field.ty) => {

src/fields.rs

@@ -1,31 +1,89 @@
 #![no_std]
 #![doc = include_str!("../README.md")]
+#![allow(dead_code)]
 
 extern crate alloc;
 use alloc::format;
 use alloc::string::ToString;
+use alloc::collections::BTreeSet as HashSet;
 
 use crate::constants::CTOR_WORD;
+#[cfg(feature = "enums")]
 use crate::enums::create_enum_token_stream;
+#[cfg(feature = "structs")]
+use crate::structs::create_struct_token_stream;
+#[cfg(feature = "unions")]
+use crate::unions::create_union_token_stream;
+
 use proc_macro::TokenStream;
-use proc_macro2::Delimiter;
+use proc_macro2::{Delimiter, Ident, Span};
 use quote::ToTokens;
-use structs::create_struct_token_stream;
 use syn::parse::discouraged::AnyDelimiter;
 use syn::parse::Parse;
 use syn::parse::ParseStream;
-use syn::parse_macro_input;
+use syn::{parse_macro_input, Visibility};
 use syn::spanned::Spanned;
 use syn::Attribute;
 use syn::Data;
 use syn::DeriveInput;
 use syn::Error;
+use syn::token::Pub;
 use syn::Type;
 
+
 pub(crate) mod constants;
+#[cfg(feature = "enums")]
 pub(crate) mod enums;
+#[cfg(any(feature = "enums", feature = "structs", feature = "unions"))]
 pub(crate) mod fields;
+#[cfg(feature = "structs")]
 pub(crate) mod structs;
+#[cfg(feature = "unions")]
+pub(crate) mod unions;
+
+pub(crate) struct CtorDefinition {
+    pub(crate) visibility: Visibility,
+    pub(crate) ident: Ident,
+    pub(crate) attrs: HashSet<CtorAttribute>,
+}
+
+#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) enum CtorAttribute {
+    Const,
+    DefaultAll,
+    Default,
+}
+
+impl Default for CtorDefinition {
+    fn default() -> Self {
+        Self {
+            visibility: Visibility::Public(Pub {
+                span: Span::call_site(),
+            }),
+            ident: Ident::new("new", Span::mixed_site()),
+            attrs: Default::default(),
+        }
+    }
+}
+
+#[cfg(not(feature = "enums"))]
+pub(crate) fn create_enum_token_stream(_derive_input: DeriveInput) -> TokenStream {
+    use proc_macro2::Span;
+    TokenStream::from(Error::new(Span::call_site(),
+        "\"enums\" feature must be enabled to use #[derive(ctor)] on enums.").to_compile_error())
+}
+
+#[cfg(not(feature = "structs"))]
+pub(crate) fn create_struct_token_stream(_derive_input: DeriveInput) -> TokenStream {
+    TokenStream::from(Error::new(Span::call_site(),
+        "\"structs\" feature must be enabled to use #[derive(ctor)] on structs.").to_compile_error())
+}
+
+#[cfg(not(feature = "unions"))]
+pub(crate) fn create_union_token_stream(_derive_input: DeriveInput) -> TokenStream {
+    TokenStream::from(Error::new(Span::call_site(),
+        "\"unions\" feature must be enabled to use #[derive(ctor)] on unions.").to_compile_error())
+}
 
 #[proc_macro_derive(ctor, attributes(ctor))]
 pub fn derive_ctor(input: TokenStream) -> TokenStream {
@@ -34,9 +92,7 @@ pub fn derive_ctor(input: TokenStream) -> TokenStream {
     match &derive_input.data {
         Data::Struct(_) => create_struct_token_stream(derive_input),
         Data::Enum(_) => create_enum_token_stream(derive_input),
-        Data::Union(_) => TokenStream::from(
-            Error::new(derive_input.span(), "Unions are not yet supported by ctor").to_compile_error(),
-        ),
+        Data::Union(_) => create_union_token_stream(derive_input)
     }
 }
 

src/lib.rs

@@ -6,43 +6,16 @@ use alloc::vec;
 use alloc::vec::Vec;
 use proc_macro::TokenStream;
 
-use proc_macro2::{Delimiter, Span};
+use proc_macro2::Delimiter;
 use quote::quote;
 use syn::{Data, DeriveInput, Error, Fields, Generics, Ident, Visibility};
 use syn::parse::{Parse, ParseStream};
-use syn::token::{Comma, Const, Pub};
+use syn::token::{Comma, Const};
 
-use CtorAttribute::DefaultAll;
-
-use crate::{consume_delimited, try_parse_attributes_with_default};
+use crate::{consume_delimited, CtorAttribute, CtorDefinition, try_parse_attributes_with_default};
 use crate::constants::{DEFAULT_CTOR_ERR_MSG, ENUM_VARIATION_PROP_NONE as NONE, NESTED_PROP_ALL as ALL, STRUCT_PROP_DEFAULT as DEFAULT};
 use crate::fields::generate_ctor_meta;
 
-pub(crate) struct CtorDefinition {
-    pub(crate) visibility: Visibility,
-    pub(crate) ident: Ident,
-    pub(crate) attrs: HashSet<CtorAttribute>,
-}
-
-#[derive(Hash, PartialEq, Eq, PartialOrd, Ord)]
-pub(crate) enum CtorAttribute {
-    Const,
-    DefaultAll,
-    Default,
-}
-
-impl Default for CtorDefinition {
-    fn default() -> Self {
-        Self {
-            visibility: Visibility::Public(Pub {
-                span: Span::call_site(),
-            }),
-            ident: Ident::new("new", Span::mixed_site()),
-            attrs: Default::default(),
-        }
-    }
-}
-
 pub(crate) struct CtorStructConfiguration {
     pub(crate) definitions: Vec<CtorDefinition>,
     pub(crate) is_none: bool,
@@ -99,7 +72,7 @@ impl Parse for CtorStructConfiguration {
                                 Ok(buffer.parse::<Ident>()?.to_string() == ALL)
                             })
                         {
-                            attributes.insert(DefaultAll);
+                            attributes.insert(CtorAttribute::DefaultAll);
                         }
                         attributes.insert(CtorAttribute::Default);
                     }
@@ -128,13 +101,6 @@ impl Parse for CtorStructConfiguration {
     }
 }
 
-#[cfg(not(feature = "structs"))]
-pub(crate) fn create_struct_token_stream(derive_input: DeriveInput) -> TokenStream {
-    TokenStream::from(Error::new(Span::call_site(),
-        "\"structs\" feature must be enabled to use #[derive(ctor)] on structs.").to_compile_error())
-}
-
-#[cfg(feature = "structs")]
 pub(crate) fn create_struct_token_stream(derive_input: DeriveInput) -> TokenStream {
     if let Data::Struct(data) = derive_input.data {
         let configuration = match try_parse_attributes_with_default(&derive_input.attrs, || {