feature: const variants of into, from, try_from, and default

num_enum/src/lib.rs

@@ -8,7 +8,8 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
 pub use ::num_enum_derive::{
-    Default, FromPrimitive, IntoPrimitive, TryFromPrimitive, UnsafeFromPrimitive,
+    ConstDefault, ConstFromPrimitive, ConstIntoPrimitive, ConstTryFromPrimitive, Default,
+    FromPrimitive, IntoPrimitive, TryFromPrimitive, UnsafeFromPrimitive,
 };
 
 use ::core::fmt;
@@ -28,6 +29,13 @@ pub trait TryFromPrimitive: Sized {
     fn try_from_primitive(number: Self::Primitive) -> Result<Self, Self::Error>;
 }
 
+pub trait ConstTryFromPrimitive: Sized {
+    type Primitive: Copy + Eq + fmt::Debug;
+    type Error;
+
+    const NAME: &'static str;
+}
+
 pub trait UnsafeFromPrimitive: Sized {
     type Primitive: Copy + Eq;
 
@@ -84,6 +92,38 @@ impl<Enum: TryFromPrimitive> fmt::Display for TryFromPrimitiveError<Enum> {
 #[cfg(feature = "std")]
 impl<Enum: TryFromPrimitive> ::std::error::Error for TryFromPrimitiveError<Enum> {}
 
+#[derive(Copy, Clone, PartialEq, Eq)]
+pub struct ConstTryFromPrimitiveError<Enum: ConstTryFromPrimitive> {
+    pub number: Enum::Primitive,
+}
+
+impl<Enum: ConstTryFromPrimitive> ConstTryFromPrimitiveError<Enum> {
+    pub const fn new(number: Enum::Primitive) -> Self {
+        Self { number }
+    }
+}
+
+impl<Enum: ConstTryFromPrimitive> fmt::Debug for ConstTryFromPrimitiveError<Enum> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.debug_struct("ConstTryFromPrimitiveError")
+            .field("number", &self.number)
+            .finish()
+    }
+}
+impl<Enum: ConstTryFromPrimitive> fmt::Display for ConstTryFromPrimitiveError<Enum> {
+    fn fmt(&self, stream: &'_ mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            stream,
+            "No discriminant in enum `{name}` matches the value `{input:?}`",
+            name = Enum::NAME,
+            input = self.number,
+        )
+    }
+}
+
+#[cfg(feature = "std")]
+impl<Enum: ConstTryFromPrimitive> ::std::error::Error for ConstTryFromPrimitiveError<Enum> {}
+
 // This trait exists to try to give a more clear error message when someone attempts to derive both FromPrimitive and TryFromPrimitive.
 // This isn't allowed because both end up creating a `TryFrom<primitive>` implementation.
 // TryFromPrimitive explicitly implements TryFrom<primitive> with Error=TryFromPrimitiveError, which conflicts with:
@@ -93,3 +133,7 @@ impl<Enum: TryFromPrimitive> ::std::error::Error for TryFromPrimitiveError<Enum>
 // It is subject to change in any release regardless of semver.
 #[doc(hidden)]
 pub trait CannotDeriveBothFromPrimitiveAndTryFromPrimitive {}
+
+// Similar, for const primitive coercion methods.
+#[doc(hidden)]
+pub trait CannotDeriveBothConstFromPrimitiveAndConstTryFromPrimitive {}

num_enum/tests/const_default.rs

@@ -0,0 +1,37 @@
+#![allow(non_upper_case_globals)]
+
+// Guard against https://github.com/illicitonion/num_enum/issues/27
+mod alloc {}
+mod core {}
+mod num_enum {}
+mod std {}
+
+#[test]
+fn default() {
+    #[derive(Debug, Eq, PartialEq, ::num_enum::ConstDefault)]
+    #[repr(u8)]
+    enum Enum {
+        #[allow(unused)]
+        Zero = 0,
+        #[num_enum(default)]
+        NonZero = 1,
+    }
+
+    const nz: Enum = Enum::const_default();
+    assert_eq!(Enum::NonZero, nz);
+}
+
+#[test]
+fn default_standard_default_attribute() {
+    #[derive(Debug, Eq, PartialEq, ::num_enum::ConstDefault)]
+    #[repr(u8)]
+    enum Enum {
+        #[allow(unused)]
+        Zero = 0,
+        #[default]
+        NonZero = 1,
+    }
+
+    const nz: Enum = Enum::const_default();
+    assert_eq!(Enum::NonZero, nz);
+}

num_enum/tests/const_from_primitive.rs

@@ -0,0 +1,116 @@
+#![allow(non_upper_case_globals)]
+
+use ::num_enum::ConstFromPrimitive;
+
+// Guard against https://github.com/illicitonion/num_enum/issues/27
+mod alloc {}
+mod core {}
+mod num_enum {}
+mod std {}
+
+macro_rules! has_from_primitive_number {
+    ( $type:ty ) => {
+        paste::paste! {
+            #[test]
+            fn [<has_from_primitive_number_ $type>]() {
+                #[derive(Debug, Eq, PartialEq, ConstFromPrimitive)]
+                #[repr($type)]
+                enum Enum {
+                    Zero = 0,
+                    #[num_enum(default)]
+                    NonZero = 1,
+                }
+
+                const zero: Enum = Enum::const_from(0 as $type);
+                assert_eq!(zero, Enum::Zero);
+
+                const one: Enum = Enum::const_from(1 as $type);
+                assert_eq!(one, Enum::NonZero);
+
+                const two: Enum = Enum::const_from(2 as $type);
+                assert_eq!(two, Enum::NonZero);
+            }
+        }
+    };
+}
+
+has_from_primitive_number!(u8);
+has_from_primitive_number!(u16);
+has_from_primitive_number!(u32);
+has_from_primitive_number!(u64);
+has_from_primitive_number!(usize);
+has_from_primitive_number!(i8);
+has_from_primitive_number!(i16);
+has_from_primitive_number!(i32);
+has_from_primitive_number!(i64);
+has_from_primitive_number!(isize);
+// repr with 128-bit type is unstable
+// has_from_primitive_number!(u128);
+// has_from_primitive_number!(i128);
+
+#[test]
+fn has_from_primitive_number_standard_default_attribute() {
+    #[derive(Debug, Eq, PartialEq, ConstFromPrimitive)]
+    #[repr(u8)]
+    enum Enum {
+        Zero = 0,
+        #[default]
+        NonZero = 1,
+    }
+
+    const zero: Enum = Enum::const_from(0_u8);
+    assert_eq!(zero, Enum::Zero);
+
+    const one: Enum = Enum::const_from(1_u8);
+    assert_eq!(one, Enum::NonZero);
+
+    const two: Enum = Enum::const_from(2_u8);
+    assert_eq!(two, Enum::NonZero);
+}
+
+#[test]
+fn from_primitive_number_catch_all() {
+    #[derive(Debug, Eq, PartialEq, ConstFromPrimitive)]
+    #[repr(u8)]
+    enum Enum {
+        Zero = 0,
+        #[num_enum(catch_all)]
+        NonZero(u8),
+    }
+
+    const zero: Enum = Enum::const_from(0_u8);
+    assert_eq!(zero, Enum::Zero);
+
+    const one: Enum = Enum::const_from(1_u8);
+    assert_eq!(one, Enum::NonZero(1_u8));
+
+    const two: Enum = Enum::const_from(2_u8);
+    assert_eq!(two, Enum::NonZero(2_u8));
+}
+
+#[cfg(feature = "complex-expressions")]
+#[test]
+fn from_primitive_number_with_inclusive_range() {
+    #[derive(Debug, Eq, PartialEq, ConstFromPrimitive)]
+    #[repr(u8)]
+    enum Enum {
+        Zero = 0,
+        #[num_enum(alternatives = [2..=255])]
+        NonZero,
+    }
+
+    const zero: Enum = Enum::const_from(0_u8);
+    assert_eq!(zero, Enum::Zero);
+
+    const one: Enum = Enum::const_from(1_u8);
+    assert_eq!(one, Enum::NonZero);
+
+    const two: Enum = Enum::const_from(2_u8);
+    assert_eq!(two, Enum::NonZero);
+
+    const three: Enum = Enum::const_from(3_u8);
+    assert_eq!(three, Enum::NonZero);
+
+    const twofivefive: Enum = Enum::const_from(255_u8);
+    assert_eq!(twofivefive, Enum::NonZero);
+}

num_enum/tests/const_into_primitive.rs

@@ -0,0 +1,52 @@
+#![allow(non_upper_case_globals)]
+
+use ::num_enum::ConstIntoPrimitive;
+
+// Guard against https://github.com/illicitonion/num_enum/issues/27
+mod alloc {}
+mod core {}
+mod num_enum {}
+mod std {}
+
+#[derive(ConstIntoPrimitive)]
+#[repr(u8)]
+enum Enum {
+    Zero,
+    One,
+    Two,
+}
+
+#[test]
+fn simple() {
+    const zero: u8 = Enum::Zero.const_into();
+    assert_eq!(zero, 0u8);
+    assert_eq!(zero, Enum::Zero.into());
+
+    const one: u8 = Enum::One.const_into();
+    assert_eq!(one, 1u8);
+    assert_eq!(one, Enum::One.into());
+
+    const two: u8 = Enum::Two.const_into();
+    assert_eq!(two, 2u8);
+    assert_eq!(two, Enum::Two.into());
+}
+
+#[test]
+fn catch_all() {
+    #[derive(Debug, Eq, PartialEq, ConstIntoPrimitive)]
+    #[repr(u8)]
+    enum Enum {
+        Zero = 0,
+        #[num_enum(catch_all)]
+        NonZero(u8),
+    }
+
+    const zero: u8 = Enum::Zero.const_into();
+    assert_eq!(zero, 0u8);
+
+    const one: u8 = Enum::NonZero(1u8).const_into();
+    assert_eq!(one, 1u8);
+
+    const two: u8 = Enum::NonZero(2u8).const_into();
+    assert_eq!(two, 2u8);
+}