ctutils: group alloc-dependent impls under alloc submodules (#1393)

Gets rid of repetitive `#[cfg(feature = "alloc")]` gating by putting all
of the gated functionality for a given module under a `mod alloc`
submodule.

Author: tarcieri

ctutils/src/traits/ct_assign.rs

@@ -8,9 +8,6 @@ use core::{
     },
 };
 
-#[cfg(feature = "alloc")]
-use alloc::{boxed::Box, vec::Vec};
-
 #[cfg(doc)]
 use core::num::NonZero;
 
@@ -136,82 +133,82 @@ where
 
 impl<T, const N: usize> CtAssignSlice for [T; N] where [T]: CtAssign {}
 
-#[cfg(feature = "alloc")]
-impl<T> CtAssign for Box<T>
-where
-    T: CtAssign,
-{
+#[cfg(feature = "subtle")]
+impl CtAssign for subtle::Choice {
     #[inline]
-    #[track_caller]
     fn ct_assign(&mut self, rhs: &Self, choice: Choice) {
-        (**self).ct_assign(rhs, choice);
+        *self = Self::ct_select(self, rhs, choice);
     }
 }
 
-#[cfg(feature = "alloc")]
-impl<T> CtAssign for Box<[T]>
+#[cfg(feature = "subtle")]
+impl<T> CtAssign for subtle::CtOption<T>
 where
-    [T]: CtAssign,
+    T: Default + subtle::ConditionallySelectable,
 {
     #[inline]
-    #[track_caller]
     fn ct_assign(&mut self, rhs: &Self, choice: Choice) {
-        self.ct_assign(&**rhs, choice);
+        use subtle::ConditionallySelectable as _;
+        self.conditional_assign(rhs, choice.into());
     }
 }
-
 #[cfg(feature = "alloc")]
-impl<T> CtAssign<[T]> for Box<[T]>
-where
-    [T]: CtAssign,
-{
-    #[inline]
-    #[track_caller]
-    fn ct_assign(&mut self, rhs: &[T], choice: Choice) {
-        (**self).ct_assign(rhs, choice);
+mod alloc {
+    use super::{Choice, CtAssign};
+    use ::alloc::{boxed::Box, vec::Vec};
+
+    impl<T> CtAssign for Box<T>
+    where
+        T: CtAssign,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_assign(&mut self, rhs: &Self, choice: Choice) {
+            (**self).ct_assign(rhs, choice);
+        }
     }
-}
 
-#[cfg(feature = "alloc")]
-impl<T> CtAssign for Vec<T>
-where
-    [T]: CtAssign,
-{
-    #[inline]
-    #[track_caller]
-    fn ct_assign(&mut self, rhs: &Self, choice: Choice) {
-        self.ct_assign(rhs.as_slice(), choice);
+    impl<T> CtAssign for Box<[T]>
+    where
+        [T]: CtAssign,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_assign(&mut self, rhs: &Self, choice: Choice) {
+            self.ct_assign(&**rhs, choice);
+        }
     }
-}
 
-#[cfg(feature = "alloc")]
-impl<T> CtAssign<[T]> for Vec<T>
-where
-    [T]: CtAssign,
-{
-    #[inline]
-    #[track_caller]
-    fn ct_assign(&mut self, rhs: &[T], choice: Choice) {
-        self.as_mut_slice().ct_assign(rhs, choice);
+    impl<T> CtAssign<[T]> for Box<[T]>
+    where
+        [T]: CtAssign,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_assign(&mut self, rhs: &[T], choice: Choice) {
+            (**self).ct_assign(rhs, choice);
+        }
     }
-}
 
-#[cfg(feature = "subtle")]
-impl CtAssign for subtle::Choice {
-    #[inline]
-    fn ct_assign(&mut self, rhs: &Self, choice: Choice) {
-        *self = Self::ct_select(self, rhs, choice);
+    impl<T> CtAssign for Vec<T>
+    where
+        [T]: CtAssign,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_assign(&mut self, rhs: &Self, choice: Choice) {
+            self.ct_assign(rhs.as_slice(), choice);
+        }
     }
-}
 
-#[cfg(feature = "subtle")]
-impl<T> CtAssign for subtle::CtOption<T>
-where
-    T: Default + subtle::ConditionallySelectable,
-{
-    #[inline]
-    fn ct_assign(&mut self, rhs: &Self, choice: Choice) {
-        use subtle::ConditionallySelectable as _;
-        self.conditional_assign(rhs, choice.into());
+    impl<T> CtAssign<[T]> for Vec<T>
+    where
+        [T]: CtAssign,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_assign(&mut self, rhs: &[T], choice: Choice) {
+            self.as_mut_slice().ct_assign(rhs, choice);
+        }
     }
 }

ctutils/src/traits/ct_eq.rs

@@ -10,8 +10,6 @@ use core::{
 
 #[cfg(feature = "subtle")]
 use crate::CtOption;
-#[cfg(feature = "alloc")]
-use alloc::{boxed::Box, vec::Vec};
 
 /// Constant-time equality: like `(Partial)Eq` with [`Choice`] instead of [`bool`].
 ///
@@ -164,82 +162,83 @@ where
 
 impl<T, const N: usize> CtEqSlice for [T; N] where [T]: CtEq {}
 
-#[cfg(feature = "alloc")]
-impl<T> CtEq for Box<T>
-where
-    T: CtEq,
-{
+#[cfg(feature = "subtle")]
+impl CtEq for subtle::Choice {
     #[inline]
-    #[track_caller]
-    fn ct_eq(&self, rhs: &Self) -> Choice {
-        (**self).ct_eq(rhs)
+    fn ct_eq(&self, other: &Self) -> Choice {
+        self.unwrap_u8().ct_eq(&other.unwrap_u8())
     }
 }
 
-#[cfg(feature = "alloc")]
-impl<T> CtEq for Box<[T]>
+#[cfg(feature = "subtle")]
+impl<T> CtEq for subtle::CtOption<T>
 where
-    [T]: CtEq,
+    T: CtEq + Default + subtle::ConditionallySelectable,
 {
     #[inline]
-    #[track_caller]
-    fn ct_eq(&self, rhs: &Self) -> Choice {
-        self.ct_eq(&**rhs)
+    fn ct_eq(&self, other: &Self) -> Choice {
+        CtOption::from(*self).ct_eq(&CtOption::from(*other))
     }
 }
 
 #[cfg(feature = "alloc")]
-impl<T> CtEq<[T]> for Box<[T]>
-where
-    [T]: CtEq,
-{
-    #[inline]
-    #[track_caller]
-    fn ct_eq(&self, rhs: &[T]) -> Choice {
-        (**self).ct_eq(rhs)
+mod alloc {
+    use super::{Choice, CtEq};
+    use ::alloc::{boxed::Box, vec::Vec};
+
+    impl<T> CtEq for Box<T>
+    where
+        T: CtEq,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_eq(&self, rhs: &Self) -> Choice {
+            (**self).ct_eq(rhs)
+        }
     }
-}
 
-#[cfg(feature = "alloc")]
-impl<T> CtEq for Vec<T>
-where
-    [T]: CtEq,
-{
-    #[inline]
-    #[track_caller]
-    fn ct_eq(&self, rhs: &Self) -> Choice {
-        self.ct_eq(rhs.as_slice())
+    impl<T> CtEq for Box<[T]>
+    where
+        [T]: CtEq,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_eq(&self, rhs: &Self) -> Choice {
+            self.ct_eq(&**rhs)
+        }
     }
-}
 
-#[cfg(feature = "alloc")]
-impl<T> CtEq<[T]> for Vec<T>
-where
-    [T]: CtEq,
-{
-    #[inline]
-    #[track_caller]
-    fn ct_eq(&self, rhs: &[T]) -> Choice {
-        self.as_slice().ct_eq(rhs)
+    impl<T> CtEq<[T]> for Box<[T]>
+    where
+        [T]: CtEq,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_eq(&self, rhs: &[T]) -> Choice {
+            (**self).ct_eq(rhs)
+        }
     }
-}
 
-#[cfg(feature = "subtle")]
-impl CtEq for subtle::Choice {
-    #[inline]
-    fn ct_eq(&self, other: &Self) -> Choice {
-        self.unwrap_u8().ct_eq(&other.unwrap_u8())
+    impl<T> CtEq for Vec<T>
+    where
+        [T]: CtEq,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_eq(&self, rhs: &Self) -> Choice {
+            self.ct_eq(rhs.as_slice())
+        }
     }
-}
 
-#[cfg(feature = "subtle")]
-impl<T> CtEq for subtle::CtOption<T>
-where
-    T: CtEq + Default + subtle::ConditionallySelectable,
-{
-    #[inline]
-    fn ct_eq(&self, other: &Self) -> Choice {
-        CtOption::from(*self).ct_eq(&CtOption::from(*other))
+    impl<T> CtEq<[T]> for Vec<T>
+    where
+        [T]: CtEq,
+    {
+        #[inline]
+        #[track_caller]
+        fn ct_eq(&self, rhs: &[T]) -> Choice {
+            self.as_slice().ct_eq(rhs)
+        }
     }
 }
 

ctutils/src/traits/ct_find.rs

@@ -1,8 +1,5 @@
 use crate::{Choice, CtAssign, CtOption};
 
-#[cfg(feature = "alloc")]
-use alloc::{boxed::Box, vec::Vec};
-
 #[cfg(doc)]
 use core::iter::Iterator;
 
@@ -54,30 +51,35 @@ where
 }
 
 #[cfg(feature = "alloc")]
-impl<T> CtFind<T> for Box<[T]>
-where
-    T: CtAssign + Default,
-{
-    #[inline]
-    fn ct_find<P>(&self, predicate: P) -> CtOption<T>
+mod alloc {
+    use super::{Choice, CtAssign, CtFind, CtOption};
+    use ::alloc::{boxed::Box, vec::Vec};
+
+    impl<T> CtFind<T> for Box<[T]>
     where
-        P: Fn(&T) -> Choice,
+        T: CtAssign + Default,
     {
-        (**self).ct_find(predicate)
+        #[inline]
+        fn ct_find<P>(&self, predicate: P) -> CtOption<T>
+        where
+            P: Fn(&T) -> Choice,
+        {
+            (**self).ct_find(predicate)
+        }
     }
-}
 
-#[cfg(feature = "alloc")]
-impl<T> CtFind<T> for Vec<T>
-where
-    T: CtAssign + Default,
-{
-    #[inline]
-    fn ct_find<P>(&self, predicate: P) -> CtOption<T>
+    #[cfg(feature = "alloc")]
+    impl<T> CtFind<T> for Vec<T>
     where
-        P: Fn(&T) -> Choice,
+        T: CtAssign + Default,
     {
-        self.as_slice().ct_find(predicate)
+        #[inline]
+        fn ct_find<P>(&self, predicate: P) -> CtOption<T>
+        where
+            P: Fn(&T) -> Choice,
+        {
+            self.as_slice().ct_find(predicate)
+        }
     }
 }