WIP add skip_if macro attribute

WIP Default impl

Author: oknozor

protocol-derive/Cargo.toml

@@ -16,7 +16,7 @@ proc-macro = true
 # N.B. protocol-derive should not depend on the protocol crate.
 # This causes releasing to be a pain - which one first - neither is possible!
 [dependencies]
-syn = { version = "1.0.60", features = ["default", "extra-traits"] }
+syn = { version = "1.0.60", features = ["default", "extra-traits", "parsing"] }
 quote = "1.0.9"
 proc-macro2 = "1.0.24"
 

protocol-derive/src/attr.rs

@@ -2,6 +2,8 @@ use crate::format::{self, Format};
 
 use proc_macro2::{Span, TokenStream};
 use syn;
+use syn::{ExprPath, ExprBinary, ExprUnary, Expr};
+use quote::ToTokens;
 
 #[derive(Debug)]
 pub enum Protocol {
@@ -13,6 +15,35 @@ pub enum Protocol {
         prefix_subfield_names: Vec<syn::Ident>,
     },
     FixedLength(usize),
+    SkipIf(SkipExpression),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum SkipExpression {
+    PathExp(ExprPath),
+    BinaryExp(ExprBinary),
+    UnaryExp(ExprUnary),
+}
+
+impl SkipExpression {
+    pub fn parse_from(exp: &str) -> SkipExpression {
+        let expr = syn::parse_str::<Expr>(exp).unwrap();
+
+        match expr {
+            Expr::Binary(e) => SkipExpression::BinaryExp(e),
+            Expr::Unary(e) => SkipExpression::UnaryExp(e),
+            Expr::Path(e) => SkipExpression::PathExp(e),
+            _ => panic!("Unexpected skip expression")
+        }
+    }
+
+    pub fn to_token_stream(&self) -> TokenStream {
+        match self {
+            SkipExpression::PathExp(e) => e.to_token_stream(),
+            SkipExpression::BinaryExp(e) => e.to_token_stream(),
+            SkipExpression::UnaryExp(ref e) => e.to_token_stream()
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -37,7 +68,7 @@ pub fn repr(attrs: &[syn::Attribute]) -> Option<syn::Ident> {
 }
 
 pub fn protocol(attrs: &[syn::Attribute])
-    -> Option<Protocol> {
+                -> Option<Protocol> {
     let meta_list = attrs.iter().filter_map(|attr| match attr.parse_meta() {
         Ok(syn::Meta::List(meta_list)) => {
             if meta_list.path.get_ident() == Some(&syn::Ident::new("protocol", proc_macro2::Span::call_site())) {
@@ -46,17 +77,31 @@ pub fn protocol(attrs: &[syn::Attribute])
                 // Unrelated attribute.
                 None
             }
-        },
+        }
         _ => None,
     }).next();
 
-    let meta_list: syn::MetaList = if let Some(meta_list) = meta_list { meta_list } else { return None };
+    let meta_list: syn::MetaList = if let Some(meta_list) = meta_list { meta_list } else { return None; };
     let mut nested_metas = meta_list.nested.into_iter();
 
     match nested_metas.next() {
         Some(syn::NestedMeta::Meta(syn::Meta::List(nested_list))) => {
             match &nested_list.path.get_ident().expect("meta is not an ident").to_string()[..] {
                 // #[protocol(length_prefix(<kind>(<prefix field name>)))]
+                "skip_if" => {
+                    let expression = expect::meta_list::single_element(nested_list).unwrap();
+                    let expression = match expression {
+                        syn::NestedMeta::Lit(syn::Lit::Str(s)) => {
+                            SkipExpression::parse_from(&s.value())
+                        }
+                        syn::NestedMeta::Meta(syn::Meta::Path(path)) => {
+                            todo!("Path literal not implemented yet")
+                        }
+                        _ => panic!("OH no! ! ")
+                    };
+
+                    Some(Protocol::SkipIf(expression))
+                }
                 "fixed_length" => {
                     let nested_list = expect::meta_list::single_literal(nested_list)
                         .expect("expected a nested list");
@@ -71,7 +116,7 @@ pub fn protocol(attrs: &[syn::Attribute])
                 }
                 "length_prefix" => {
                     let nested_list = expect::meta_list::nested_list(nested_list)
-                                            .expect("expected a nested list");
+                        .expect("expected a nested list");
                     let prefix_kind = match &nested_list.path.get_ident().expect("nested list is not an ident").to_string()[..] {
                         "bytes" => LengthPrefixKind::Bytes,
                         "elements" => LengthPrefixKind::Elements,
@@ -82,9 +127,9 @@ pub fn protocol(attrs: &[syn::Attribute])
                     let (prefix_field_name, prefix_subfield_names) = match length_prefix_expr {
                         syn::NestedMeta::Lit(syn::Lit::Str(s)) => {
                             let mut parts: Vec<_> = s.value()
-                                                     .split(".")
-                                                     .map(|s| syn::Ident::new(s, Span::call_site()))
-                                                     .collect();
+                                .split(".")
+                                .map(|s| syn::Ident::new(s, Span::call_site()))
+                                .collect();
 
                             if parts.len() < 1 {
                                 panic!("there must be at least one field mentioned");
@@ -94,7 +139,7 @@ pub fn protocol(attrs: &[syn::Attribute])
                             let subfield_idents = parts.into_iter().collect();
 
                             (field_ident, subfield_idents)
-                        },
+                        }
                         syn::NestedMeta::Meta(syn::Meta::Path(path)) => match path.get_ident() {
                             Some(field_ident) => (field_ident.clone(), Vec::new()),
                             None => panic!("path is not an ident"),
@@ -103,15 +148,15 @@ pub fn protocol(attrs: &[syn::Attribute])
                     };
 
                     Some(Protocol::LengthPrefix { kind: prefix_kind, prefix_field_name, prefix_subfield_names })
-                },
+                }
                 "discriminator" => {
                     let literal = expect::meta_list::single_literal(nested_list)
-                                        .expect("expected a single literal");
+                        .expect("expected a single literal");
                     Some(Protocol::Discriminator(literal))
-                },
+                }
                 name => panic!("#[protocol({})] is not valid", name),
             }
-        },
+        }
         Some(syn::NestedMeta::Meta(syn::Meta::NameValue(name_value))) => {
             match name_value.path.get_ident() {
                 Some(ident) => {
@@ -198,3 +243,32 @@ mod attribute {
     }
 }
 
+#[cfg(test)]
+mod test {
+    use crate::attr::SkipExpression;
+
+    #[test]
+    fn should_parse_skip_expression() {
+        let binary = "a == b";
+        let parse_result = SkipExpression::parse_from(binary);
+        assert!(matches!(parse_result, SkipExpression::BinaryExp(_)));
+
+        let unary = "!b";
+        let parse_result = SkipExpression::parse_from(unary);
+        assert!(matches!(parse_result, SkipExpression::UnaryExp(_)));
+
+        let path = "hello";
+        let parse_result = SkipExpression::parse_from(path);
+        assert!(matches!(parse_result, SkipExpression::PathExp(_)));
+    }
+
+    #[test]
+    fn should_convert_expression_to_token() {
+        let binary = "a == b";
+        let parse_result = SkipExpression::parse_from(binary);
+        let tokens = parse_result.to_token_stream();
+        let expression = quote! { #tokens };
+        assert_eq!(expression.to_string(), "a == b");
+    }
+}
+

protocol-derive/src/codegen/enums.rs

@@ -47,7 +47,7 @@ pub fn read_variant(plan: &plan::Enum)
     let discriminator_match_branches = plan.variants.iter().map(|variant| {
         let variant_name = &variant.ident;
         let discriminator_literal = variant.discriminator_literal();
-        let initializer = codegen::read_fields(&variant.fields);
+        let initializer = codegen::read_enum_fields(&variant.fields);
 
         quote! {
             #discriminator_literal => {

protocol-derive/src/codegen/mod.rs

@@ -1,15 +1,25 @@
 use proc_macro2::TokenStream;
 use syn;
-use syn::Field;
+use syn::{Field};
 
 use crate::attr;
+use syn::spanned::Spanned;
 
 pub mod enums;
 
-pub fn read_fields(fields: &syn::Fields)
-                   -> TokenStream {
+pub fn read_struct_field(fields: &syn::Fields)
+                         -> TokenStream {
     match *fields {
-        syn::Fields::Named(ref fields_named) => read_named_fields(fields_named),
+        syn::Fields::Named(ref fields_named) => read_named_fields_struct(fields_named),
+        syn::Fields::Unnamed(ref fields_unnamed) => read_unnamed_fields(fields_unnamed),
+        syn::Fields::Unit => quote!(),
+    }
+}
+
+pub fn read_enum_fields(fields: &syn::Fields)
+                        -> TokenStream {
+    match *fields {
+        syn::Fields::Named(ref fields_named) => read_named_fields_enum(fields_named),
         syn::Fields::Unnamed(ref fields_unnamed) => read_unnamed_fields(fields_unnamed),
         syn::Fields::Unit => quote!(),
     }
@@ -24,13 +34,56 @@ pub fn write_fields(fields: &syn::Fields)
     }
 }
 
+pub fn name_fields_declarations(fields: &syn::Fields) -> TokenStream {
+    if let syn::Fields::Named(ref fields_named) = fields {
+        let fields_variables: Vec<TokenStream> = fields_named.named.iter().map(|field| {
+            let field_name = &field.ident;
+            let field_ty = &field.ty;
+            // This field may store the length prefix of one or more other field.
+            let update_hints = update_hints_after_read(field, &fields_named.named);
+            let update_hints_fixed = update_hint_fixed_length(field, &fields_named.named);
+
+            if let Some(skip_condition) = maybe_skip(field.clone()) {
+                quote! {
+                    #update_hints_fixed
+                    let skip_condition_path = if let Ok(skip_condition) = #skip_condition {
+                        skip_condition
+                    } else {
+                        false
+                    };
+
+                    __hints.set_skip(skip_condition_path);
+                    let #field_name = protocol::Parcel::read_field(__io_reader, __settings, &mut __hints);
+                    let res = &#field_name;
+                    #update_hints
+                    __hints.next_field();
+                }
+            } else {
+                quote! {
+                    #update_hints_fixed
+                    let #field_name: Result<#field_ty, _> = protocol::Parcel::read_field(__io_reader, __settings, &mut __hints);
+                    let res = &#field_name;
+                    #update_hints
+                    __hints.next_field();
+                }
+            }
+        }).collect();
+
+        quote! {
+            #( #fields_variables)*
+        }
+    } else {
+        quote!()
+    }
+}
+
 /// Generates code that builds a initializes
 /// an item with named fields by parsing
 /// each of the fields.
 ///
 /// Returns  `{ ..field initializers.. }`.
-fn read_named_fields(fields_named: &syn::FieldsNamed)
-                     -> TokenStream {
+fn read_named_fields_enum(fields_named: &syn::FieldsNamed)
+                          -> TokenStream {
     let field_initializers: Vec<_> = fields_named.named.iter().map(|field| {
         let field_name = &field.ident;
         let field_ty = &field.ty;
@@ -52,6 +105,21 @@ fn read_named_fields(fields_named: &syn::FieldsNamed)
     quote! { { #( #field_initializers ),* } }
 }
 
+/// Generates code that builds a initializes
+/// an item with named fields by parsing
+/// each of the fields.
+///
+/// Returns  `{ ..field initializers.. }`.
+fn read_named_fields_struct(fields_named: &syn::FieldsNamed)
+                            -> TokenStream {
+    let field_initializers: Vec<_> = fields_named.named.iter().map(|field| {
+        let field_name = &field.ident;
+        quote! { #field_name: #field_name? }
+    }).collect();
+
+    quote! { { #( #field_initializers ),* } }
+}
+
 fn update_hints_after_read<'a>(field: &'a syn::Field,
                                fields: impl IntoIterator<Item=&'a syn::Field> + Clone)
                                -> TokenStream {
@@ -89,6 +157,14 @@ fn update_hint_fixed_length<'a>(field: &'a syn::Field,
     }
 }
 
+fn maybe_skip(field: syn::Field) -> Option<TokenStream> {
+    if let Some(attr::Protocol::SkipIf(expr)) = attr::protocol(&field.attrs) {
+        Some(expr.to_token_stream())
+    } else {
+        None
+    }
+}
+
 fn update_hints_after_write<'a>(field: &'a syn::Field,
                                 fields: impl IntoIterator<Item=&'a syn::Field> + Clone)
                                 -> TokenStream {

protocol-derive/src/lib.rs

@@ -73,8 +73,9 @@ fn build_generics(ast: &syn::DeriveInput) -> (Vec<proc_macro2::TokenStream>, Vec
 fn impl_parcel_for_struct(ast: &syn::DeriveInput,
                           strukt: &syn::DataStruct) -> proc_macro2::TokenStream {
     let strukt_name = &ast.ident;
-    let read_fields = codegen::read_fields(&strukt.fields);
+    let read_fields = codegen::read_struct_field(&strukt.fields);
     let write_fields = codegen::write_fields(&strukt.fields);
+    let named_field_variables = codegen::name_fields_declarations(&strukt.fields);
 
     impl_trait_for(ast, quote!(protocol::Parcel), quote! {
         const TYPE_NAME: &'static str = stringify!(#strukt_name);
@@ -87,7 +88,7 @@ fn impl_parcel_for_struct(ast: &syn::DeriveInput,
             // Each type gets its own hints.
             let mut __hints = protocol::hint::Hints::default();
             __hints.begin_fields();
-
+            #named_field_variables
             Ok(#strukt_name # read_fields)
         }
 

protocol/src/hint.rs

@@ -5,6 +5,7 @@ pub type FieldIndex = usize;
 /// Hints given when reading parcels.
 #[derive(Clone, Debug, PartialEq)]
 pub struct Hints {
+    pub skip_hint: Option<bool>,
     pub current_field_index: Option<FieldIndex>,
     /// The fields for which a length prefix
     /// was already present earlier in the layout.
@@ -31,6 +32,7 @@ pub enum LengthPrefixKind {
 impl Default for Hints {
     fn default() -> Self {
         Hints {
+            skip_hint: None,
             current_field_index: None,
             known_field_lengths: HashMap::new(),
         }
@@ -60,7 +62,7 @@ mod protocol_derive_helpers {
         #[doc(hidden)]
         pub fn next_field(&mut self) {
             *self.current_field_index.as_mut()
-                .expect("cannot increment next field when not in a struct")+= 1;
+                .expect("cannot increment next field when not in a struct") += 1;
         }
 
         // Sets the length of a variable-sized field by its 0-based index.
@@ -71,6 +73,13 @@ mod protocol_derive_helpers {
                                 kind: LengthPrefixKind) {
             self.known_field_lengths.insert(field_index, FieldLength { kind, length });
         }
+
+        // A type skipped is assumed to be Option<T>, we need to set this to bypass
+        // the default Option read method
+        #[doc(hidden)]
+        pub fn set_skip(&mut self, do_skip: bool) {
+            self.skip_hint = Some(do_skip);
+        }
     }
 }