Merge pull request #369 from sigp/fixed-vec

Implement fixed-length lists for BeaconState

eth2/utils/boolean-bitfield/src/lib.rs

@@ -226,7 +226,7 @@ impl Decodable for BooleanBitfield {
 // as the BitVec library and the hex-parser use opposing bit orders.
 fn reverse_bit_order(mut bytes: Vec<u8>) -> Vec<u8> {
     bytes.reverse();
-    bytes.into_iter().map(|b| b.swap_bits()).collect()
+    bytes.into_iter().map(LookupReverse::swap_bits).collect()
 }
 
 impl Serialize for BooleanBitfield {

eth2/utils/fixed_len_vec/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "fixed_len_vec"
+version = "0.1.0"
+authors = ["Paul Hauner <paul@paulhauner.com>"]
+edition = "2018"
+
+[dependencies]
+cached_tree_hash = { path = "../cached_tree_hash" }
+tree_hash = { path = "../tree_hash" }
+serde = "1.0"
+serde_derive = "1.0"
+ssz = { path = "../ssz" }
+typenum = "1.10"

eth2/utils/fixed_len_vec/src/impls.rs

@@ -0,0 +1,70 @@
+use super::*;
+// use cached_tree_hash::CachedTreeHash;
+// use ssz::{Decodable, Encodable};
+// use tree_hash::TreeHash;
+
+impl<T, N: Unsigned> tree_hash::TreeHash for FixedLenVec<T, N>
+where
+    T: tree_hash::TreeHash,
+{
+    fn tree_hash_type() -> tree_hash::TreeHashType {
+        tree_hash::TreeHashType::Vector
+    }
+
+    fn tree_hash_packed_encoding(&self) -> Vec<u8> {
+        unreachable!("Vector should never be packed.")
+    }
+
+    fn tree_hash_packing_factor() -> usize {
+        unreachable!("Vector should never be packed.")
+    }
+
+    fn tree_hash_root(&self) -> Vec<u8> {
+        tree_hash::impls::vec_tree_hash_root(&self.vec)
+    }
+}
+
+impl<T, N: Unsigned> cached_tree_hash::CachedTreeHash for FixedLenVec<T, N>
+where
+    T: cached_tree_hash::CachedTreeHash + tree_hash::TreeHash,
+{
+    fn new_tree_hash_cache(
+        &self,
+        depth: usize,
+    ) -> Result<cached_tree_hash::TreeHashCache, cached_tree_hash::Error> {
+        let (cache, _overlay) = cached_tree_hash::vec::new_tree_hash_cache(&self.vec, depth)?;
+
+        Ok(cache)
+    }
+
+    fn tree_hash_cache_schema(&self, depth: usize) -> cached_tree_hash::BTreeSchema {
+        cached_tree_hash::vec::produce_schema(&self.vec, depth)
+    }
+
+    fn update_tree_hash_cache(
+        &self,
+        cache: &mut cached_tree_hash::TreeHashCache,
+    ) -> Result<(), cached_tree_hash::Error> {
+        cached_tree_hash::vec::update_tree_hash_cache(&self.vec, cache)?;
+
+        Ok(())
+    }
+}
+
+impl<T, N: Unsigned> ssz::Encodable for FixedLenVec<T, N>
+where
+    T: ssz::Encodable,
+{
+    fn ssz_append(&self, s: &mut ssz::SszStream) {
+        s.append_vec(&self.vec)
+    }
+}
+
+impl<T, N: Unsigned> ssz::Decodable for FixedLenVec<T, N>
+where
+    T: ssz::Decodable + Default,
+{
+    fn ssz_decode(bytes: &[u8], index: usize) -> Result<(Self, usize), ssz::DecodeError> {
+        ssz::decode_ssz_list(bytes, index).and_then(|(vec, i)| Ok((vec.into(), i)))
+    }
+}

eth2/utils/fixed_len_vec/src/lib.rs

@@ -0,0 +1,118 @@
+use serde_derive::{Deserialize, Serialize};
+use std::marker::PhantomData;
+use std::ops::{Index, IndexMut};
+use std::slice::SliceIndex;
+use typenum::Unsigned;
+
+pub use typenum;
+
+mod impls;
+
+#[derive(Debug, PartialEq, Clone, Serialize, Deserialize)]
+pub struct FixedLenVec<T, N>
+where
+    N: Unsigned,
+{
+    vec: Vec<T>,
+    _phantom: PhantomData<N>,
+}
+
+impl<T, N: Unsigned> FixedLenVec<T, N> {
+    pub fn len(&self) -> usize {
+        self.vec.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn capacity() -> usize {
+        N::to_usize()
+    }
+}
+
+impl<T: Default, N: Unsigned> From<Vec<T>> for FixedLenVec<T, N> {
+    fn from(mut vec: Vec<T>) -> Self {
+        vec.resize_with(Self::capacity(), Default::default);
+
+        Self {
+            vec,
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<T, N: Unsigned> Into<Vec<T>> for FixedLenVec<T, N> {
+    fn into(self) -> Vec<T> {
+        self.vec
+    }
+}
+
+impl<T, N: Unsigned> Default for FixedLenVec<T, N> {
+    fn default() -> Self {
+        Self {
+            vec: Vec::default(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<T, N: Unsigned, I: SliceIndex<[T]>> Index<I> for FixedLenVec<T, N> {
+    type Output = I::Output;
+
+    #[inline]
+    fn index(&self, index: I) -> &Self::Output {
+        Index::index(&self.vec, index)
+    }
+}
+
+impl<T, N: Unsigned, I: SliceIndex<[T]>> IndexMut<I> for FixedLenVec<T, N> {
+    #[inline]
+    fn index_mut(&mut self, index: I) -> &mut Self::Output {
+        IndexMut::index_mut(&mut self.vec, index)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use typenum::*;
+
+    #[test]
+    fn indexing() {
+        let vec = vec![1, 2];
+
+        let mut fixed: FixedLenVec<u64, U8192> = vec.clone().into();
+
+        assert_eq!(fixed[0], 1);
+        assert_eq!(&fixed[0..1], &vec[0..1]);
+        assert_eq!((&fixed[..]).len(), 8192);
+
+        fixed[1] = 3;
+        assert_eq!(fixed[1], 3);
+    }
+
+    #[test]
+    fn length() {
+        let vec = vec![42; 5];
+        let fixed: FixedLenVec<u64, U4> = FixedLenVec::from(vec.clone());
+        assert_eq!(&fixed[..], &vec[0..4]);
+
+        let vec = vec![42; 3];
+        let fixed: FixedLenVec<u64, U4> = FixedLenVec::from(vec.clone());
+        assert_eq!(&fixed[0..3], &vec[..]);
+        assert_eq!(&fixed[..], &vec![42, 42, 42, 0][..]);
+
+        let vec = vec![];
+        let fixed: FixedLenVec<u64, U4> = FixedLenVec::from(vec.clone());
+        assert_eq!(&fixed[..], &vec![0, 0, 0, 0][..]);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        assert_eq!(2 + 2, 4);
+    }
+}

eth2/utils/hashing/src/lib.rs

@@ -35,7 +35,7 @@ pub fn merkle_root(values: &[Vec<u8>]) -> Option<Vec<u8>> {
     }
 
     // the root hash will be at index 1
-    return Some(o[1].clone());
+    Some(o[1].clone())
 }
 
 #[cfg(test)]

eth2/utils/ssz_derive/src/lib.rs

@@ -100,6 +100,7 @@ pub fn ssz_encode_derive(input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as DeriveInput);
 
     let name = &item.ident;
+    let (impl_generics, ty_generics, where_clause) = &item.generics.split_for_impl();
 
     let struct_data = match &item.data {
         syn::Data::Struct(s) => s,
@@ -109,7 +110,7 @@ pub fn ssz_encode_derive(input: TokenStream) -> TokenStream {
     let field_idents = get_serializable_named_field_idents(&struct_data);
 
     let output = quote! {
-        impl ssz::Encodable for #name {
+        impl #impl_generics ssz::Encodable for #name #ty_generics #where_clause {
             fn ssz_append(&self, s: &mut ssz::SszStream) {
                 #(
                     s.append(&self.#field_idents);
@@ -140,6 +141,7 @@ pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as DeriveInput);
 
     let name = &item.ident;
+    let (impl_generics, ty_generics, where_clause) = &item.generics.split_for_impl();
 
     let struct_data = match &item.data {
         syn::Data::Struct(s) => s,
@@ -169,7 +171,7 @@ pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
     }
 
     let output = quote! {
-        impl ssz::Decodable for #name {
+        impl #impl_generics ssz::Decodable for #name #ty_generics #where_clause {
             fn ssz_decode(bytes: &[u8], i: usize) -> Result<(Self, usize), ssz::DecodeError> {
                 #(
                     #quotes

eth2/utils/test_random_derive/src/lib.rs

@@ -21,6 +21,7 @@ fn should_use_default(field: &syn::Field) -> bool {
 pub fn test_random_derive(input: TokenStream) -> TokenStream {
     let derived_input = parse_macro_input!(input as DeriveInput);
     let name = &derived_input.ident;
+    let (impl_generics, ty_generics, where_clause) = &derived_input.generics.split_for_impl();
 
     let struct_data = match &derived_input.data {
         syn::Data::Struct(s) => s,
@@ -48,8 +49,8 @@ pub fn test_random_derive(input: TokenStream) -> TokenStream {
     }
 
     let output = quote! {
-        impl<T: RngCore> TestRandom<T> for #name {
-            fn random_for_test(rng: &mut T) -> Self {
+        impl #impl_generics TestRandom for #name #ty_generics #where_clause {
+            fn random_for_test(rng: &mut impl rand::RngCore) -> Self {
                Self {
                     #(
                         #quotes

eth2/utils/tree_hash_derive/src/lib.rs

@@ -43,6 +43,7 @@ fn should_skip_hashing(field: &syn::Field) -> bool {
 #[proc_macro_derive(CachedTreeHash, attributes(tree_hash))]
 pub fn subtree_derive(input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as DeriveInput);
+    let (impl_generics, ty_generics, where_clause) = &item.generics.split_for_impl();
 
     let name = &item.ident;
 
@@ -56,7 +57,7 @@ pub fn subtree_derive(input: TokenStream) -> TokenStream {
     let idents_c = idents_a.clone();
 
     let output = quote! {
-        impl cached_tree_hash::CachedTreeHash for #name {
+        impl #impl_generics cached_tree_hash::CachedTreeHash for #name #ty_generics #where_clause {
             fn new_tree_hash_cache(&self, depth: usize) -> Result<cached_tree_hash::TreeHashCache, cached_tree_hash::Error> {
                 let tree = cached_tree_hash::TreeHashCache::from_subtrees(
                     self,
@@ -119,6 +120,7 @@ pub fn tree_hash_derive(input: TokenStream) -> TokenStream {
     let item = parse_macro_input!(input as DeriveInput);
 
     let name = &item.ident;
+    let (impl_generics, ty_generics, where_clause) = &item.generics.split_for_impl();
 
     let struct_data = match &item.data {
         syn::Data::Struct(s) => s,
@@ -128,7 +130,7 @@ pub fn tree_hash_derive(input: TokenStream) -> TokenStream {
     let idents = get_hashable_named_field_idents(&struct_data);
 
     let output = quote! {
-        impl tree_hash::TreeHash for #name {
+        impl #impl_generics tree_hash::TreeHash for #name #ty_generics #where_clause {
             fn tree_hash_type() -> tree_hash::TreeHashType {
                 tree_hash::TreeHashType::Container
             }