Address reviewer comments

No breaking changes to the API, attributes formatted consistently.

Signed-off-by: Nick Cameron <nrc@ncameron.org>

benches/benchmark.rs

@@ -54,7 +54,7 @@ where
         b.iter(|| {
             for buf in &payload {
                 message.clear();
-                message.merge(buf, DecodeContext::default()).unwrap();
+                message.merge(buf).unwrap();
                 criterion::black_box(&message);
             }
         })

src/encoding.rs

@@ -184,13 +184,13 @@ where
 /// to a function which is decoding a nested object, then use `enter_recursion`.
 #[derive(Clone, Debug)]
 pub struct DecodeContext {
-    #[cfg(not(feature = "no-recursion-limit"))]
     /// How many times we can recurse in the current decode stack before we hit
     /// the recursion limit.
     ///
     /// The recursion limit is defined by `RECURSION_LIMIT` and cannot be
     /// customized. The recursion limit can be ignored by building the Prost
     /// crate with the `no-recursion-limit` feature (which is set by default).
+    #[cfg(not(feature = "no-recursion-limit"))]
     recurse_count: u32,
 }
 
@@ -211,12 +211,12 @@ impl Default for DecodeContext {
 }
 
 impl DecodeContext {
-    #[cfg(not(feature = "no-recursion-limit"))]
     /// Call this function before recursively decoding.
     ///
     /// There is no `exit` function since this function creates a new `DecodeContext`
     /// to be used at the next level of recursion. Continue to use the old context
     // at the previous level of recursion.
+    #[cfg(not(feature = "no-recursion-limit"))]
     #[inline(always)]
     pub(crate) fn enter_recursion(&self) -> DecodeContext {
         DecodeContext {
@@ -230,12 +230,12 @@ impl DecodeContext {
         DecodeContext {}
     }
 
-    #[cfg(not(feature = "no-recursion-limit"))]
     /// Checks whether the recursion limit has been reached in the stack of
     /// decodes described by the `DecodeContext` at `self.ctx`.
     ///
     /// Returns `Ok<()>` if it is ok to continue recursing.
     /// Returns `Err<DecodeError>` if the recursion limit has been reached.
+    #[cfg(not(feature = "no-recursion-limit"))]
     #[inline(always)]
     pub(crate) fn limit_reached(&self) -> Result<(), DecodeError> {
         if self.recurse_count == 0 {

src/message.rs

@@ -84,7 +84,7 @@ pub trait Message: Debug + Send + Sync {
         Self: Default,
     {
         let mut message = Self::default();
-        Self::merge(&mut message, &mut buf.into_buf(), DecodeContext::default()).map(|_| message)
+        Self::merge(&mut message, &mut buf.into_buf()).map(|_| message)
     }
 
     /// Decodes a length-delimited instance of the message from the buffer.
@@ -101,7 +101,20 @@ pub trait Message: Debug + Send + Sync {
     /// Decodes an instance of the message from a buffer, and merges it into `self`.
     ///
     /// The entire buffer will be consumed.
-    fn merge<B>(&mut self, buf: B, ctx: DecodeContext) -> Result<(), DecodeError>
+    fn merge<B>(&mut self, buf: B) -> Result<(), DecodeError>
+    where
+        B: IntoBuf,
+        Self: Sized,
+    {
+        self.merge_with_context(buf, DecodeContext::default())
+    }
+
+    /// Decodes an instance of the message from a buffer, and merges it into `self`.
+    /// This version takes a `DecodeContext` which contains some state for the
+    /// current decoding. Most users will want to use `merge` without the context.
+    ///
+    /// The entire buffer will be consumed.
+    fn merge_with_context<B>(&mut self, buf: B, ctx: DecodeContext) -> Result<(), DecodeError>
     where
         B: IntoBuf,
         Self: Sized,