Make Debug impl optional for types

prost-build/src/code_generator.rs

@@ -188,6 +188,7 @@ impl<'a> CodeGenerator<'a> {
             "#[derive(Clone, PartialEq, {}::Message)]\n",
             self.config.prost_path.as_deref().unwrap_or("::prost")
         ));
+        self.append_skip_debug(&fq_message_name);
         self.push_indent();
         self.buf.push_str("pub struct ");
         self.buf.push_str(&to_upper_camel(&message_name));
@@ -280,6 +281,19 @@ impl<'a> CodeGenerator<'a> {
         }
     }
 
+    fn should_skip_debug(&self, fq_message_name: &str) -> bool {
+        assert_eq!(b'.', fq_message_name.as_bytes()[0]);
+        self.config.skip_debug.get(fq_message_name).next().is_some()
+    }
+
+    fn append_skip_debug(&mut self, fq_message_name: &str) {
+        if self.should_skip_debug(fq_message_name) {
+            push_indent(self.buf, self.depth);
+            self.buf.push_str("#[prost(skip_debug)]");
+            self.buf.push('\n');
+        }
+    }
+
     fn append_enum_attributes(&mut self, fq_message_name: &str) {
         assert_eq!(b'.', fq_message_name.as_bytes()[0]);
         for attribute in self.config.enum_attributes.get(fq_message_name) {
@@ -532,6 +546,8 @@ impl<'a> CodeGenerator<'a> {
             self.config.prost_path.as_deref().unwrap_or("::prost")
         ));
         self.push_indent();
+        self.append_skip_debug(&fq_message_name);
+        self.push_indent();
         self.buf.push_str("pub enum ");
         self.buf.push_str(&to_upper_camel(oneof.name()));
         self.buf.push_str(" {\n");
@@ -637,9 +653,16 @@ impl<'a> CodeGenerator<'a> {
         self.append_type_attributes(&fq_proto_enum_name);
         self.append_enum_attributes(&fq_proto_enum_name);
         self.push_indent();
-        self.buf.push_str(
-            &format!("#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, {}::Enumeration)]\n",self.config.prost_path.as_deref().unwrap_or("::prost")),
-        );
+        let dbg = if self.should_skip_debug(&fq_proto_enum_name) {
+            ""
+        } else {
+            "Debug, "
+        };
+        self.buf.push_str(&format!(
+            "#[derive(Clone, Copy, {}PartialEq, Eq, Hash, PartialOrd, Ord, {}::Enumeration)]\n",
+            dbg,
+            self.config.prost_path.as_deref().unwrap_or("::prost"),
+        ));
         self.push_indent();
         self.buf.push_str("#[repr(i32)]\n");
         self.push_indent();

prost-build/src/lib.rs

@@ -254,6 +254,7 @@ pub struct Config {
     default_package_filename: String,
     protoc_args: Vec<OsString>,
     disable_comments: PathMap<()>,
+    skip_debug: PathMap<()>,
     skip_protoc_run: bool,
     include_file: Option<PathBuf>,
     prost_path: Option<String>,
@@ -607,6 +608,19 @@ impl Config {
         self
     }
 
+    /// Skips generating `impl Debug` for types
+    pub fn skip_debug<I, S>(&mut self, paths: I) -> &mut Self
+    where
+        I: IntoIterator<Item = S>,
+        S: AsRef<str>,
+    {
+        self.skip_debug.clear();
+        for matcher in paths {
+            self.skip_debug.insert(matcher.as_ref().to_string(), ());
+        }
+        self
+    }
+
     /// Declare an externally provided Protobuf package or type.
     ///
     /// `extern_path` allows `prost` types in external crates to be referenced in generated code.
@@ -1221,6 +1235,7 @@ impl default::Default for Config {
             default_package_filename: "_".to_string(),
             protoc_args: Vec::new(),
             disable_comments: PathMap::default(),
+            skip_debug: PathMap::default(),
             skip_protoc_run: false,
             include_file: None,
             prost_path: None,
@@ -1245,6 +1260,7 @@ impl fmt::Debug for Config {
             .field("default_package_filename", &self.default_package_filename)
             .field("protoc_args", &self.protoc_args)
             .field("disable_comments", &self.disable_comments)
+            .field("skip_debug", &self.skip_debug)
             .field("prost_path", &self.prost_path)
             .finish()
     }

prost-derive/src/lib.rs

@@ -23,6 +23,12 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
 
     let ident = input.ident;
 
+    syn::custom_keyword!(skip_debug);
+    let skip_debug = input
+        .attrs
+        .into_iter()
+        .any(|a| a.path.is_ident("prost") && a.parse_args::<skip_debug>().is_ok());
+
     let variant_data = match input.data {
         Data::Struct(variant_data) => variant_data,
         Data::Enum(..) => bail!("Message can not be derived for an enum"),
@@ -165,26 +171,6 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
         }
     };
 
-    let debugs = unsorted_fields.iter().map(|&(ref field_ident, ref field)| {
-        let wrapper = field.debug(quote!(self.#field_ident));
-        let call = if is_struct {
-            quote!(builder.field(stringify!(#field_ident), &wrapper))
-        } else {
-            quote!(builder.field(&wrapper))
-        };
-        quote! {
-             let builder = {
-                 let wrapper = #wrapper;
-                 #call
-             };
-        }
-    });
-    let debug_builder = if is_struct {
-        quote!(f.debug_struct(stringify!(#ident)))
-    } else {
-        quote!(f.debug_tuple(stringify!(#ident)))
-    };
-
     let expanded = quote! {
         impl #impl_generics ::prost::Message for #ident #ty_generics #where_clause {
             #[allow(unused_variables)]
@@ -223,14 +209,44 @@ fn try_message(input: TokenStream) -> Result<TokenStream, Error> {
                 #default
             }
         }
+    };
+    let expanded = if skip_debug {
+        expanded
+    } else {
+        let debugs = unsorted_fields.iter().map(|&(ref field_ident, ref field)| {
+            let wrapper = field.debug(quote!(self.#field_ident));
+            let call = if is_struct {
+                quote!(builder.field(stringify!(#field_ident), &wrapper))
+            } else {
+                quote!(builder.field(&wrapper))
+            };
+            quote! {
+                 let builder = {
+                     let wrapper = #wrapper;
+                     #call
+                 };
+            }
+        });
+        let debug_builder = if is_struct {
+            quote!(f.debug_struct(stringify!(#ident)))
+        } else {
+            quote!(f.debug_tuple(stringify!(#ident)))
+        };
+        quote! {
+            #expanded
 
-        impl #impl_generics ::core::fmt::Debug for #ident #ty_generics #where_clause {
-            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-                let mut builder = #debug_builder;
-                #(#debugs;)*
-                builder.finish()
+            impl #impl_generics ::core::fmt::Debug for #ident #ty_generics #where_clause {
+                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                    let mut builder = #debug_builder;
+                    #(#debugs;)*
+                    builder.finish()
+                }
             }
         }
+    };
+
+    let expanded = quote! {
+        #expanded
 
         #methods
     };
@@ -342,6 +358,12 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
 
     let ident = input.ident;
 
+    syn::custom_keyword!(skip_debug);
+    let skip_debug = input
+        .attrs
+        .into_iter()
+        .any(|a| a.path.is_ident("prost") && a.parse_args::<skip_debug>().is_ok());
+
     let variants = match input.data {
         Data::Enum(DataEnum { variants, .. }) => variants,
         Data::Struct(..) => bail!("Oneof can not be derived for a struct"),
@@ -424,16 +446,6 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
         quote!(#ident::#variant_ident(ref value) => #encoded_len)
     });
 
-    let debug = fields.iter().map(|&(ref variant_ident, ref field)| {
-        let wrapper = field.debug(quote!(*value));
-        quote!(#ident::#variant_ident(ref value) => {
-            let wrapper = #wrapper;
-            f.debug_tuple(stringify!(#variant_ident))
-                .field(&wrapper)
-                .finish()
-        })
-    });
-
     let expanded = quote! {
         impl #impl_generics #ident #ty_generics #where_clause {
             /// Encodes the message to a buffer.
@@ -467,10 +479,27 @@ fn try_oneof(input: TokenStream) -> Result<TokenStream, Error> {
             }
         }
 
-        impl #impl_generics ::core::fmt::Debug for #ident #ty_generics #where_clause {
-            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-                match *self {
-                    #(#debug,)*
+    };
+    let expanded = if skip_debug {
+        expanded
+    } else {
+        let debug = fields.iter().map(|&(ref variant_ident, ref field)| {
+            let wrapper = field.debug(quote!(*value));
+            quote!(#ident::#variant_ident(ref value) => {
+                let wrapper = #wrapper;
+                f.debug_tuple(stringify!(#variant_ident))
+                    .field(&wrapper)
+                    .finish()
+            })
+        });
+        quote! {
+            #expanded
+
+            impl #impl_generics ::core::fmt::Debug for #ident #ty_generics #where_clause {
+                fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
+                    match *self {
+                        #(#debug,)*
+                    }
                 }
             }
         }