feat(derive): add default attr for skipped fields

Prevents the skipped field from needing to implement the `Default` trait.

Usage:

```rs
struct Test {
    #[prost(int32, tag = "1")]
    a: i32,
    #[prost(skip)]
    c: i32,
    #[prost(skip, default = "create_foo")]
    d: Foo,
}

struct Foo(i32);

pub fn create_foo() -> Foo {
    Foo(12)
}
```

Author: maxpowa

prost-derive/src/field/mod.rs

@@ -94,7 +94,7 @@ impl Field {
     /// Returns a statement which encodes the field.
     pub fn encode(&self, prost_path: &Path, ident: TokenStream) -> TokenStream {
         match *self {
-            Field::Skip(ref ignore) => ignore.encode(ident),
+            Field::Skip(_) => TokenStream::default(),
             Field::Scalar(ref scalar) => scalar.encode(prost_path, ident),
             Field::Message(ref message) => message.encode(prost_path, ident),
             Field::Map(ref map) => map.encode(prost_path, ident),
@@ -107,7 +107,7 @@ impl Field {
     /// value into the field.
     pub fn merge(&self, prost_path: &Path, ident: TokenStream) -> TokenStream {
         match *self {
-            Field::Skip(ref ignore) => ignore.merge(ident),
+            Field::Skip(_) => TokenStream::default(),
             Field::Scalar(ref scalar) => scalar.merge(prost_path, ident),
             Field::Message(ref message) => message.merge(prost_path, ident),
             Field::Map(ref map) => map.merge(prost_path, ident),
@@ -119,7 +119,7 @@ impl Field {
     /// Returns an expression which evaluates to the encoded length of the field.
     pub fn encoded_len(&self, prost_path: &Path, ident: TokenStream) -> TokenStream {
         match *self {
-            Field::Skip(ref ignore) => ignore.encoded_len(ident),
+            Field::Skip(_) => quote!(0),
             Field::Scalar(ref scalar) => scalar.encoded_len(prost_path, ident),
             Field::Map(ref map) => map.encoded_len(prost_path, ident),
             Field::Message(ref msg) => msg.encoded_len(prost_path, ident),
@@ -131,7 +131,7 @@ impl Field {
     /// Returns a statement which clears the field.
     pub fn clear(&self, ident: TokenStream) -> TokenStream {
         match *self {
-            Field::Skip(ref ignore) => ignore.clear(ident),
+            Field::Skip(ref skip) => skip.clear(ident),
             Field::Scalar(ref scalar) => scalar.clear(ident),
             Field::Message(ref message) => message.clear(ident),
             Field::Map(ref map) => map.clear(ident),

prost-derive/src/field/skip.rs

@@ -1,21 +1,44 @@
 use anyhow::{bail, Error};
 use proc_macro2::TokenStream;
 use quote::quote;
-use syn::{Meta};
+use syn::{Meta, Lit, MetaNameValue, Path, Expr, ExprLit};
 
 use crate::field::{set_bool, word_attr};
 
 #[derive(Clone)]
-pub struct Field;
+pub struct Field {
+    pub default_fn: Option<Path>,
+}
 
 impl Field {
     pub fn new(attrs: &[Meta]) -> Result<Option<Field>, Error> {
         let mut skip = false;
+        let mut default_fn = None;
         let mut unknown_attrs = Vec::new();
 
         for attr in attrs {
             if word_attr("skip", attr) {
-                set_bool(&mut skip, "duplicate ignore attribute")?;
+                set_bool(&mut skip, "duplicate skip attribute")?;
+            } else if let Meta::NameValue(MetaNameValue { path, value, .. }) = attr {
+                if path.is_ident("default") {
+                    let lit_str = match value {
+                        // There has to be a better way...
+                        Expr::Lit(ExprLit { lit: Lit::Str(lit), .. }) => Some(lit),
+                        _ => None,
+                    };
+                    if let Some(lit) = lit_str {
+                        let fn_path: Path = syn::parse_str(&lit.value())
+                            .map_err(|_| anyhow::anyhow!("invalid path for default function"))?;
+                        if default_fn.is_some() {
+                            bail!("duplicate default attribute for skipped field");
+                        }
+                        default_fn = Some(fn_path);
+                    } else {
+                        bail!("default attribute value must be a string literal");
+                    }
+                } else {
+                    unknown_attrs.push(attr);
+                }
             } else {
                 unknown_attrs.push(attr);
             }
@@ -27,30 +50,24 @@ impl Field {
 
         if !unknown_attrs.is_empty() {
             bail!(
-                "unknown attribute(s) for ignored field: #[prost({})]",
+                "unknown attribute(s) for skipped field: #[prost({})]",
                 quote!(#(#unknown_attrs),*)
             );
         }
 
-        Ok(Some(Field))
+        Ok(Some(Field { default_fn }))
     }
 
-    /// Returns a statement which non-ops, since the field is ignored.
-    pub fn encode(&self, _: TokenStream) -> TokenStream {
-        quote!()
-    }
-
-    /// Returns an expression which evaluates to the default value of the ignored field.
-    pub fn merge(&self, ident: TokenStream) -> TokenStream {
-        quote!(#ident.get_or_insert_with(::core::default::Default::default))
-    }
-
-    /// Returns an expression which evaluates to 0
-    pub fn encoded_len(&self, _: TokenStream) -> TokenStream {
-        quote!(0)
+    pub fn clear(&self, ident: TokenStream) -> TokenStream {
+        let default = self.default_value();
+        quote!( #ident = #default; )
     }
 
-    pub fn clear(&self, ident: TokenStream) -> TokenStream {
-        quote!(#ident = ::core::default::Default::default)
+    pub fn default_value(&self) -> TokenStream {
+        if let Some(ref path) = self.default_fn {
+            quote! { #path() }
+        } else {
+            quote! { ::core::default::Default::default() }
+        }
     }
 }

prost-derive/src/lib.rs

@@ -85,14 +85,19 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
     let unsorted_fields = fields.clone();
 
     // Filter out ignored fields
-    fields.retain(|(_, field)| matches!(field, Field::Skip(..)));
+    fields.retain(|(_, field)| !matches!(field, Field::Skip(..)));
 
     // Sort the fields by tag number so that fields will be encoded in tag order.
     // TODO: This encodes oneof fields in the position of their lowest tag,
     // regardless of the currently occupied variant, is that consequential?
+    let all_fields = unsorted_fields.clone();
+    let mut active_fields = all_fields.clone();
+    // Filter out skipped fields for encoding/decoding/length
+    active_fields.retain(|(_, field)| !matches!(field, Field::Skip(_)));
+    // Sort the active fields by tag number so that fields will be encoded in tag order.
     // See: https://protobuf.dev/programming-guides/encoding/#order
-    fields.sort_by_key(|(_, field)| field.tags().into_iter().min().unwrap());
-    let fields = fields;
+    active_fields.sort_by_key(|(_, field)| field.tags().into_iter().min().unwrap());
+    let fields = active_fields;
 
     if let Some(duplicate_tag) = fields
         .iter()
@@ -131,29 +136,36 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
         }
     });
 
-    let struct_name = if fields.is_empty() {
+    let struct_name = if all_fields.is_empty() {
         quote!()
     } else {
         quote!(
             const STRUCT_NAME: &'static str = stringify!(#ident);
         )
     };
 
-    let clear = fields
+    let clear = all_fields
         .iter()
         .map(|(field_ident, field)| field.clear(quote!(self.#field_ident)));
 
+    // For Default implementation, use all_fields (including skipped)
     let default = if is_struct {
-        let default = fields.iter().map(|(field_ident, field)| {
-            let value = field.default(&prost_path);
+        let default = all_fields.iter().map(|(field_ident, field)| {
+            let value = match field {
+                Field::Skip(skip_field) => skip_field.default_value(),
+                _ => field.default(&prost_path),
+            };
             quote!(#field_ident: #value,)
         });
         quote! {#ident {
             #(#default)*
         }}
     } else {
-        let default = fields.iter().map(|(_, field)| {
-            let value = field.default(&prost_path);
+        let default = all_fields.iter().map(|(_, field)| {
+            let value = match field {
+                Field::Skip(skip_field) => skip_field.default_value(),
+                _ => field.default(&prost_path),
+            };
             quote!(#value,)
         });
         quote! {#ident (