Remove tree hashing from ssz crate

eth2/utils/ssz_derive/src/lib.rs

@@ -188,157 +188,3 @@ pub fn ssz_decode_derive(input: TokenStream) -> TokenStream {
     };
     output.into()
 }
-
-/// Returns a Vec of `syn::Ident` for each named field in the struct, whilst filtering out fields
-/// that should not be tree hashed.
-///
-/// # Panics
-/// Any unnamed struct field (like in a tuple struct) will raise a panic at compile time.
-fn get_tree_hashable_named_field_idents<'a>(
-    struct_data: &'a syn::DataStruct,
-) -> Vec<&'a syn::Ident> {
-    struct_data
-        .fields
-        .iter()
-        .filter_map(|f| {
-            if should_skip_tree_hash(&f) {
-                None
-            } else {
-                Some(match &f.ident {
-                    Some(ref ident) => ident,
-                    _ => panic!("ssz_derive only supports named struct fields."),
-                })
-            }
-        })
-        .collect()
-}
-
-/// Returns true if some field has an attribute declaring it should not be tree-hashed.
-///
-/// The field attribute is: `#[tree_hash(skip_hashing)]`
-fn should_skip_tree_hash(field: &syn::Field) -> bool {
-    for attr in &field.attrs {
-        if attr.into_token_stream().to_string() == "# [ tree_hash ( skip_hashing ) ]" {
-            return true;
-        }
-    }
-    false
-}
-
-/// Implements `ssz::TreeHash` for some `struct`.
-///
-/// Fields are processed in the order they are defined.
-#[proc_macro_derive(TreeHash, attributes(tree_hash))]
-pub fn ssz_tree_hash_derive(input: TokenStream) -> TokenStream {
-    let item = parse_macro_input!(input as DeriveInput);
-
-    let name = &item.ident;
-
-    let struct_data = match &item.data {
-        syn::Data::Struct(s) => s,
-        _ => panic!("ssz_derive only supports structs."),
-    };
-
-    let field_idents = get_tree_hashable_named_field_idents(&struct_data);
-
-    let output = quote! {
-        impl ssz::TreeHash for #name {
-            fn hash_tree_root(&self) -> Vec<u8> {
-                let mut list: Vec<Vec<u8>> = Vec::new();
-                #(
-                    list.push(self.#field_idents.hash_tree_root());
-                )*
-
-                ssz::merkle_hash(&mut list)
-            }
-        }
-    };
-    output.into()
-}
-
-/// Returns `true` if some `Ident` should be considered to be a signature type.
-fn type_ident_is_signature(ident: &syn::Ident) -> bool {
-    match ident.to_string().as_ref() {
-        "Signature" => true,
-        "AggregateSignature" => true,
-        _ => false,
-    }
-}
-
-/// Takes a `Field` where the type (`ty`) portion is a path (e.g., `types::Signature`) and returns
-/// the final `Ident` in that path.
-///
-/// E.g., for `types::Signature` returns `Signature`.
-fn final_type_ident(field: &syn::Field) -> &syn::Ident {
-    match &field.ty {
-        syn::Type::Path(path) => &path.path.segments.last().unwrap().value().ident,
-        _ => panic!("ssz_derive only supports Path types."),
-    }
-}
-
-/// Implements `ssz::TreeHash` for some `struct`, whilst excluding any fields following and
-/// including a field that is of type "Signature" or "AggregateSignature".
-///
-/// See:
-/// https://github.com/ethereum/eth2.0-specs/blob/master/specs/simple-serialize.md#signed-roots
-///
-/// This is a rather horrendous macro, it will read the type of the object as a string and decide
-/// if it's a signature by matching that string against "Signature" or "AggregateSignature". So,
-/// it's important that you use those exact words as your type -- don't alias it to something else.
-///
-/// If you can think of a better way to do this, please make an issue!
-///
-/// Fields are processed in the order they are defined.
-#[proc_macro_derive(SignedRoot, attributes(signed_root))]
-pub fn ssz_signed_root_derive(input: TokenStream) -> TokenStream {
-    let item = parse_macro_input!(input as DeriveInput);
-
-    let name = &item.ident;
-
-    let struct_data = match &item.data {
-        syn::Data::Struct(s) => s,
-        _ => panic!("ssz_derive only supports structs."),
-    };
-
-    let mut field_idents: Vec<&syn::Ident> = vec![];
-
-    let field_idents = get_signed_root_named_field_idents(&struct_data);
-
-    let output = quote! {
-        impl ssz::SignedRoot for #name {
-            fn signed_root(&self) -> Vec<u8> {
-                let mut list: Vec<Vec<u8>> = Vec::new();
-                #(
-                    list.push(self.#field_idents.hash_tree_root());
-                )*
-
-                ssz::merkle_hash(&mut list)
-            }
-        }
-    };
-    output.into()
-}
-
-fn get_signed_root_named_field_idents(struct_data: &syn::DataStruct) -> Vec<&syn::Ident> {
-    struct_data
-        .fields
-        .iter()
-        .filter_map(|f| {
-            if should_skip_signed_root(&f) {
-                None
-            } else {
-                Some(match &f.ident {
-                    Some(ref ident) => ident,
-                    _ => panic!("ssz_derive only supports named struct fields"),
-                })
-            }
-        })
-        .collect()
-}
-
-fn should_skip_signed_root(field: &syn::Field) -> bool {
-    field
-        .attrs
-        .iter()
-        .any(|attr| attr.into_token_stream().to_string() == "# [ signed_root ( skip_hashing ) ]")
-}