Remove GAT in Buf trait

Due to rust-lang/rust-analyzer#19502
the GAT in Buf renders autocomplete useless in methods generic over
Buf.

Author: robinhundt

cryprot-core/src/buf.rs

@@ -14,20 +14,26 @@ use crate::alloc::{HugePageMemory, allocate_zeroed_vec};
 pub trait Buf<T>:
     Default + Debug + Deref<Target = [T]> + DerefMut + Send + Sync + 'static + private::Sealed
 {
-    /// The 'kind' of this Buf implementation. This is e.g. `Vec<E>` for `Vec<T>
-    /// as Buf<T>`.
-    ///
-    /// This associated type can be used to create Bufs of the same kind, but
-    /// with a different inner type.
-    type BufKind<E>: Buf<E>
-    where
-        E: Zeroable + Clone + Default + Debug + Send + Sync + 'static;
     /// Create a new `Buf` of length `len` with all elements set to zero.
     ///
     /// Implementations of this directly allocate zeroed memory and do not write
     /// zeroes to the elements explicitly.
     fn zeroed(len: usize) -> Self;
 
+    /// Create a new [`Buf`] of the same kind but for two-element arrays of
+    /// `T``.
+    ///
+    /// This method is useful in methods generic over Buf which need a temporary
+    /// buffer over arrays of size two of `T`, that is the same kind of buffer
+    /// the method is called with. That is, a `fn foo(b: impl Buf<T>)`
+    /// called with a [`HugePageMemory`] can use this method to create a
+    /// `HugePageMemory<[T;2]>`.
+    //
+    // Note: Ideally we would use a GAT on Buf for this, but sadly due to
+    // https://github.com/rust-lang/rust-analyzer/issues/19502 in rust-analyzer,
+    // this renders autocomplete unusable in methods generic over Buf.
+    fn zeroed_arr2(len: usize) -> impl Buf<[T; 2]>;
+
     /// Capacity of the `Buf`.
     fn capacity(&self) -> usize;
 
@@ -49,15 +55,14 @@ pub trait Buf<T>:
 }
 
 impl<T: Zeroable + Clone + Default + Debug + Send + Sync + 'static> Buf<T> for Vec<T> {
-    type BufKind<E>
-        = Vec<E>
-    where
-        E: Zeroable + Clone + Default + Debug + Send + Sync + 'static;
-
     fn zeroed(len: usize) -> Self {
         allocate_zeroed_vec(len)
     }
 
+    fn zeroed_arr2(len: usize) -> impl Buf<[T; 2]> {
+        allocate_zeroed_vec(len)
+    }
+
     fn capacity(&self) -> usize {
         self.capacity()
     }
@@ -79,15 +84,14 @@ impl<T: Zeroable + Clone + Default + Debug + Send + Sync + 'static> Buf<T> for V
 }
 
 impl<T: Zeroable + Clone + Default + Debug + Send + Sync + 'static> Buf<T> for HugePageMemory<T> {
-    type BufKind<E>
-        = HugePageMemory<E>
-    where
-        E: Zeroable + Clone + Default + Debug + Send + Sync + 'static;
-
     fn zeroed(len: usize) -> Self {
         HugePageMemory::zeroed(len)
     }
 
+    fn zeroed_arr2(len: usize) -> impl Buf<[T; 2]> {
+        HugePageMemory::zeroed(len)
+    }
+
     fn capacity(&self) -> usize {
         self.capacity()
     }

cryprot-ot/src/adapter.rs

@@ -184,7 +184,7 @@ where
         B: Buf<Block>,
         F: FnMut(usize) -> Block + Send,
     {
-        let mut r_ots: B::BufKind<[Block; 2]> = B::BufKind::zeroed(ots.len());
+        let mut r_ots = B::zeroed_arr2(ots.len());
         self.0.send_into(&mut r_ots).await?;
         let mut send_buf: Vec<Block> = Vec::zeroed(COR_CHUNK_SIZE);
         let (mut tx, _) = self.connection().byte_stream().await?;