Processed some of the feedback

Cargo.toml

@@ -33,7 +33,7 @@ derive = ["bincode_derive"]
 bincode_derive = { path = "derive", version = "2.0.0-dev", optional = true }
 serde = { version = "1.0.130", optional = true }
 
-# Used for derive tests
+# Used for tests
 [dev-dependencies]
 serde_derive = "1.0.130"
 serde_json = "1.0.68"

derive/src/error.rs

@@ -1,4 +1,4 @@
-use crate::prelude::*;
+use crate::{generate::StreamBuilder, prelude::*};
 use std::fmt;
 
 #[derive(Debug)]
@@ -44,27 +44,13 @@ impl Error {
 
     pub fn throw_with_span(self, span: Span) -> TokenStream {
         // compile_error!($message)
-        vec![
+        let mut builder = StreamBuilder::new();
-            TokenTree::Ident(Ident::new("compile_error", span)),
+        builder.ident_str("compile_error");
-            TokenTree::Punct({
+        builder.punct('!');
-                let mut punct = Punct::new('!', Spacing::Alone);
+        builder.group(Delimiter::Brace, |b| {
-                punct.set_span(span);
+            b.lit_str(self.to_string());
-                punct
-            }),
-            TokenTree::Group({
-                let mut group = Group::new(Delimiter::Brace, {
-                    TokenTree::Literal({
-                        let mut string = Literal::string(&self.to_string());
-                        string.set_span(span);
-                        string
-                    })
-                    .into()
         });
-                group.set_span(span);
+        builder.set_span_on_all_tokens(span);
-                group
+        builder.stream
-            }),
-        ]
-        .into_iter()
-        .collect()
     }
 }

derive/src/generate/generate_fn.rs

@@ -1,7 +1,9 @@
 use super::{ImplFor, StreamBuilder};
 use crate::prelude::Delimiter;
+
+/// A builder for functions.
 pub struct FnBuilder<'a, 'b> {
-    generate: &'b mut ImplFor<'a>,
+    generate: Option<&'b mut ImplFor<'a>>,
     name: String,
 
     lifetime_and_generics: Vec<(String, Vec<String>)>,
@@ -13,7 +15,7 @@ pub struct FnBuilder<'a, 'b> {
 impl<'a, 'b> FnBuilder<'a, 'b> {
     pub(super) fn new(generate: &'b mut ImplFor<'a>, name: impl Into<String>) -> Self {
         Self {
-            generate,
+            generate: Some(generate),
             name: name.into(),
             lifetime_and_generics: Vec::new(),
             self_arg: FnSelfArg::None,
@@ -22,6 +24,30 @@ impl<'a, 'b> FnBuilder<'a, 'b> {
         }
     }
 
+    #[cfg(test)]
+    #[doc(hidden)]
+    #[allow(unused)]
+    pub fn for_test() -> Self {
+        Self {
+            generate: None,
+            name: String::new(),
+            lifetime_and_generics: Vec::new(),
+            self_arg: FnSelfArg::None,
+            args: Vec::new(),
+            return_type: None,
+        }
+    }
+
+    /// Add a generic parameter. Keep in mind that this is *not* a valid lifetime.
+    ///
+    /// `dependencies` are the optional dependencies of the parameter.
+    ///
+    /// ```ignore
+    /// let mut builder: FnBuilder = ...;
+    /// builder
+    ///     .with_generic("D", None) // fn Foo<D>()
+    ///     .with_generic("E", &["Encodable"]); // fn foo<D, E: Encodable>();
+    /// ```
     pub fn with_generic<T, U, V>(mut self, name: T, dependencies: U) -> Self
     where
         T: Into<String>,
@@ -52,7 +78,7 @@ impl<'a, 'b> FnBuilder<'a, 'b> {
 
     pub fn body(self, body_builder: impl FnOnce(&mut StreamBuilder)) {
         let FnBuilder {
-            generate,
+            mut generate,
             name,
             lifetime_and_generics,
             self_arg,
@@ -108,9 +134,10 @@ impl<'a, 'b> FnBuilder<'a, 'b> {
             builder.push_parsed(&return_type);
         }
 
-        generate.group.append(builder);
+        let generator = generate.take().unwrap();
 
-        generate.group.group(Delimiter::Brace, body_builder);
+        generator.group.append(builder);
+        generator.group.group(Delimiter::Brace, body_builder);
     }
 }
 

derive/src/generate/stream_builder.rs

@@ -6,7 +6,7 @@ use std::str::FromStr;
 #[must_use]
 #[derive(Default)]
 pub struct StreamBuilder {
-    pub(super) stream: TokenStream,
+    pub(crate) stream: TokenStream,
 }
 
 impl StreamBuilder {
@@ -83,6 +83,11 @@ impl StreamBuilder {
         ]);
     }
 
+    pub fn lit_str(&mut self, str: impl AsRef<str>) {
+        self.stream
+            .extend([TokenTree::Literal(Literal::string(str.as_ref()))]);
+    }
+
     pub fn lit_u32(&mut self, val: u32) {
         self.stream
             .extend([TokenTree::Literal(Literal::u32_unsuffixed(val))]);
@@ -92,4 +97,14 @@ impl StreamBuilder {
         self.stream
             .extend([TokenTree::Literal(Literal::usize_unsuffixed(val))]);
     }
+
+    pub fn set_span_on_all_tokens(&mut self, span: Span) {
+        self.stream = std::mem::take(&mut self.stream)
+            .into_iter()
+            .map(|mut token| {
+                token.set_span(span);
+                token
+            })
+            .collect();
+    }
 }

src/config.rs

@@ -47,7 +47,7 @@ pub struct Configuration<E = LittleEndian, I = Varint, A = SkipFixedArrayLength>
 }
 
 impl Configuration {
-    /// The default config. By default this will be:
+    /// The default config for bincode 2.0. By default this will be:
     /// - Little endian
     /// - Variable int encoding
     /// - Skip fixed array length