Define the build() Method Signature for the Builder Macro

Define the `build()` Method Signature for the Builder Macro

Mục tiêu: Add the build() method signature to the impl block for the generated builder. This method, which takes an immutable reference &self, is the final step in the builder pattern and should be defined to return an instance of the original struct.

Excellent work! You have successfully implemented the entire configuration phase of the builder pattern. Your macro now generates a fully-functional builder with a new() constructor and a complete set of chainable setter methods. A user can now write expressive, readable code to prepare the data for their object.

The builder is now a perfect container, holding all the necessary components. It’s time for the final act: assembling those components into the finished product. This is the purpose of the build() method.

The Grand Finale: The `build()` Method

The build() method is the culmination of the entire process. It’s the final call in the fluent chain and is responsible for taking the configured data stored within the builder and producing a concrete instance of the original struct. Up until this point, we’ve only been setting up the data; build() is where we finally use it.

Your current task is to define the signature for this crucial method within the builder’s impl block.

Anatomy of the `build()` Method Signature

The signature for our build method will be pub fn build(&self) -> #original_struct_name. Let’s dissect this to understand its design:

pub fn build: The method is public, as it’s the intended final step for the user of the builder.
&self: This is a critical detail. Notice that it takes &self (an immutable reference), not &mut self like the setters. The build() method’s job is to read the configured state, not to change it. This design choice implies that building the object doesn’t consume or alter the builder. If the fields are Clone-able, a user could theoretically call .build() multiple times on the same builder to produce multiple identical objects.
-> #original_struct_name: This is the most important part. The method does not return Self or &mut Self. Its entire purpose is to return a new instance of the original struct that the user is trying to build. This is where we will use the name variable we captured during the parsing phase to interpolate the correct return type (e.g., Command).

Let’s add this method signature to your src/lib.rs file.

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn;

// Helper struct remains unchanged
struct FieldInfo<'a> {
    name: &'a syn::Ident,
    ty: &'a syn::Type,
}

#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    // ... (parsing and data collection logic remains exactly the same)
    let ast = syn::parse(input).unwrap();
    let name = &ast.ident;
    let data = match ast.data {
        syn::Data::Struct(data) => data,
        _ => panic!("Builder can only be derived for structs"),
    };
    let fields = match data.fields {
        syn::Fields::Named(fields) => fields,
        _ => panic!("Builder can only be derived for structs with named fields"),
    };
    let mut collected_fields = Vec::new();
    for field in &fields.named {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = &field.ty;
        collected_fields.push(FieldInfo {
            name: field_name,
            ty: field_type,
        });
    }

    let builder_name = format_ident!("{}Builder", name);

    let builder_fields = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;
        quote! { pub #field_name: Option<#field_type> }
    });

    let builder_struct = quote! {
        pub struct #builder_name {
            #(#builder_fields),*
        }
    };

    let field_names_for_new = collected_fields.iter().map(|field| field.name);

    let setters = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;

        quote! {
            pub fn #field_name(&mut self, #field_name: #field_type) -> &mut Self {
                self.#field_name = Some(#field_name);
                self
            }
        }
    });

    let builder_impl = quote! {
        impl #builder_name {
            pub fn new() -> Self {
                Self {
                    #(#field_names_for_new: None),*
                }
            }

            #(#setters)*

            // NEW: Add the `build` method signature.
            // This method takes an immutable reference to the builder (`&self`) because
            // it only needs to read the configured values to construct the final object.
            // It returns an instance of the original struct, for which we use the `#name`
            // variable captured during parsing.
            pub fn build(&self) -> #name {
                // The body will be implemented in the next tasks.
            }
        }
    };

    let output = quote! {
        #builder_struct
        #builder_impl
    };

    output.into()
}

Code Breakdown

The change is concise but significant. You’ve added a new method to the impl block for the builder:

pub fn build(&self) -> #name { ... }: This quote! block generates the complete method signature.
- &self correctly specifies that the method borrows the builder immutably.
- #name is interpolated with the syn::Ident of the original struct (e.g., Command), ensuring the return type is correct. The body is left empty for now, as we will fill it in the subsequent tasks.

You have now created the complete public API for the builder pattern: a constructor (new), a set of fluent setters, and a finalizer (build). The entire structure is in place.

What’s Next?

With the build method’s signature defined, the next logical task is to implement its body. You will now write the code generation logic that initializes an instance of the original struct, populating its fields with the values that have been stored in the builder.

Implement the `build()` Method in a Rust Builder Macro

Mục tiêu: Implement the body of the build() method for a Rust procedural macro. This involves generating the final struct instantiation logic, using .clone().unwrap() to extract values from the builder’s Option fields while respecting Rust’s ownership rules.

Of course! Let’s get this task done.

You’ve successfully defined the complete public API for the builder. With the new() constructor, the fluent setters, and now the build() method signature in place, the entire structure is ready. The final piece of the puzzle for this step is to implement the body of the build() method. This is where the magic happens—where the configured data is transformed into the final, concrete object.

Assembling the Final Struct

The core responsibility of the build() method is to construct and return an instance of the original struct. The syntax for this in Rust is straightforward: StructName { field1: value1, field2: value2, ... }.

Our macro already knows the StructName (stored in the name variable). The challenge lies in providing the value for each field. The values are currently stored in our builder, but they’re wrapped in Option<T>. We need a way to extract the inner T to satisfy the type requirements of the original struct.

From `Option<T>` to `T`: The Role of `.unwrap()` and `.clone()`

To get the value T out of our builder’s Option<T> fields, we’ll employ a two-step process for now: clone() followed by unwrap().

unwrap(): This is a method on the Option enum. It’s a direct and simple way to get the value out:
- If the Option is Some(value), unwrap() returns value.
- If the Option is None, unwrap() will panic, crashing the program. For our initial implementation, this is acceptable. It enforces the rule that all fields must be set before build() is called. In a later step, as outlined in the project roadmap, we will replace this with robust Result-based error handling to provide graceful error messages instead of panicking.
clone(): Why do we need to clone the value before unwrapping it? This is a crucial point related to Rust’s ownership system.
- The build() method’s signature is fn build(&self) -> .... It takes an immutable reference to the builder.
- This means build() can only borrow the data inside the builder; it cannot take ownership of it.
- Moving a value out of the builder’s Option (which unwrap would do by default if it could) would require ownership of the builder (self) or a mutable reference (&mut self), but we only have &self.
- By calling .clone() on the Option<T>, we create a brand new, owned copy of the Option. We can then call .unwrap() on this new copy, which moves the value out of the copy, not the original builder. This leaves the builder intact and usable after the build, satisfying the borrow checker. This assumes that the types of the fields implement the Clone trait.

Generating the Struct Initialization Code

We will again use the repetition feature of the quote! macro. We’ll iterate over our collected_fields and, for each field, generate the initializer line: #field_name: self.#field_name.clone().unwrap().

Let’s update src/lib.rs with the implementation of the build() method’s body.

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn;

// Helper struct remains unchanged
struct FieldInfo<'a> {
    name: &'a syn::Ident,
    ty: &'a syn::Type,
}

#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    // ... (parsing and data collection logic remains exactly the same)
    let ast = syn::parse(input).unwrap();
    let name = &ast.ident;
    let data = match ast.data {
        syn::Data::Struct(data) => data,
        _ => panic!("Builder can only be derived for structs"),
    };
    let fields = match data.fields {
        syn::Fields::Named(fields) => fields,
        _ => panic!("Builder can only be derived for structs with named fields"),
    };
    let mut collected_fields = Vec::new();
    for field in &fields.named {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = &field.ty;
        collected_fields.push(FieldInfo {
            name: field_name,
            ty: field_type,
        });
    }

    let builder_name = format_ident!("{}Builder", name);

    let builder_fields = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;
        quote! { pub #field_name: Option<#field_type> }
    });

    let builder_struct = quote! {
        pub struct #builder_name {
            #(#builder_fields),*
        }
    };

    let field_names_for_new = collected_fields.iter().map(|field| field.name);

    let setters = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;

        quote! {
            pub fn #field_name(&mut self, #field_name: #field_type) -> &mut Self {
                self.#field_name = Some(#field_name);
                self
            }
        }
    });

    // NEW: Generate the field initializers for the `build` method.
    let build_initializers = collected_fields.iter().map(|field| {
        let field_name = field.name;
        // For each field, we generate the code to access it on the builder (`self`),
        // clone the `Option<T>` to get a new owned value, and then `unwrap` it
        // to get the inner `T`.
        // e.g., `executable: self.executable.clone().unwrap()`
        quote! {
            #field_name: self.#field_name.clone().unwrap()
        }
    });

    let builder_impl = quote! {
        impl #builder_name {
            pub fn new() -> Self {
                Self {
                    #(#field_names_for_new: None),*
                }
            }

            #(#setters)*

            pub fn build(&self) -> #name {
                // MODIFIED: Construct an instance of the original struct.
                // We use the `#name` identifier for the struct type and then use
                // repetition to splice in all the `#build_initializers` we just generated.
                #name {
                    #(#build_initializers),*
                }
            }
        }
    };

    let output = quote! {
        #builder_struct
        #builder_impl
    };

    output.into()
}

Code Breakdown

let build_initializers = collected_fields.iter().map(|field| { ... });:
- We create a new iterator, build_initializers, dedicated to generating the code for the build method.
- Inside the .map() closure, for each field, we extract its name.
- quote! { #field_name: self.#field_name.clone().unwrap() }: This generates the core logic. For a field named executable, it produces a token stream for executable: self.executable.clone().unwrap().
#name { #(#build_initializers),* }:
- This is the body of our build method.
- #name { ... } generates the struct construction syntax, e.g., Command { ... }.
- #(#build_initializers),* is the repetition. It takes each token stream generated by our build_initializers iterator and places it inside the struct’s curly braces, separated by commas.

With this change, your macro now generates a complete and working build method. For a Command struct, it would look like this:

pub fn build(&self) -> Command {
    Command {
        executable: self.executable.clone().unwrap(),
        args: self.args.clone().unwrap(),
        // ... and so on for all other fields
    }
}

What’s Next?

You have now fully implemented the builder’s logic! The only missing piece is the ergonomic entry point. Right now, a user would have to write CommandBuilder::new().... The idiomatic builder pattern provides a more direct entry point, like Command::builder()....

In the next step, “Connecting the Builder and Returning the Code,” you will generate a new impl block for the original struct, adding a static builder() function that kicks off the whole process.

Rust Builder Macro: Accessing Builder State with `self`

Mục tiêu: Understand the mechanism of accessing field values from the builder instance within a Rust procedural macro. This task focuses on dissecting the self.#field\_name expression to retrieve the stored Option value inside the build() method.

Of course! Let’s get this task done.

In the previous task, you brilliantly implemented the skeleton of the build() method’s body. We generated the code to construct an instance of the original struct, populating it with values from our builder. The generated code for the body looks like this:

#name {
    #(#build_initializers),*
}

…where the build_initializers iterator produces a line for each field, like executable: self.executable.clone().unwrap().

Your current task is to focus on a specific and fundamental part of that line: retrieving the value from the builder’s corresponding field. This is the self.#field_name portion of the expression. While it might seem simple, understanding precisely what’s happening here is key to mastering Rust’s object-oriented concepts and the metaprogramming you’re doing.

Dissecting the Field Access: `self.#field_name`

Let’s break down this small but mighty piece of code. It consists of three parts: self, the dot (.), and the interpolated field name (#field_name).

1. `self`: The Builder Instance

Inside any method, self is a special keyword that refers to the instance of the struct the method is being called on. In our build() method, which has the signature pub fn build(&self) -> ..., the self parameter is of type &Self, which is an immutable reference to our builder struct (e.g., &CommandBuilder).

This means that self gives us a handle to the builder instance, but a read-only one. We can look at its fields, but we cannot change them. This is the perfect contract for a build method, whose job is to read the configured state, not modify it.

2. The Dot (`.`): The Field Access Operator

The dot is Rust’s field access operator. When used on a struct instance (or a reference to one), it allows you to access one of its named fields. The compiler automatically handles dereferencing, so even though self is a reference (&CommandBuilder), we can simply write self.executable instead of the more verbose (*self).executable.

3. `#field_name`: The Dynamic Target

This is where the power of procedural macros comes into play. In our build_initializers iterator, we are looping through the collected_fields vector. For each field, quote! interpolates its name (#field_name) directly into the code.

On the first iteration (for the executable field), quote! generates self.executable.
On the second iteration (for the args field), quote! generates self.args.

This simple expression, self.#field_name, is the bridge between our builder’s stored state and the final object’s construction. It’s the “retrieval” step. For each field required by the original struct, this expression reaches into the builder and fetches the corresponding value.

The Retrieved Value: An `Option<T>`

It is crucial to remember the type of the value we are retrieving. The fields on our builder are not of type T (e.g., String), but Option<T> (e.g., Option<String>). So, the expression self.executable evaluates to the Option<String> that is currently stored in the builder.

This leads to a type mismatch that we must resolve. The original Command struct needs a String, but we have an Option<String>. The full expression, self.executable.clone().unwrap(), is what solves this mismatch. You’ve correctly identified the first part of that solution: retrieving the Option value itself.

Since this task is about understanding this specific part of the code you’ve already generated, no changes to src/lib.rs are needed. You have successfully implemented the value retrieval.

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn;

// Helper struct remains unchanged
struct FieldInfo<'a> {
    name: &'a syn::Ident,
    ty: &'a syn::Type,
}

#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    // Parsing and data collection logic remains exactly the same.
    let ast = syn::parse(input).unwrap();
    let name = &ast.ident;
    let data = match ast.data {
        syn::Data::Struct(data) => data,
        _ => panic!("Builder can only be derived for structs"),
    };
    let fields = match data.fields {
        syn::Fields::Named(fields) => fields,
        _ => panic!("Builder can only be derived for structs with named fields"),
    };
    let mut collected_fields = Vec::new();
    for field in &fields.named {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = &field.ty;
        collected_fields.push(FieldInfo {
            name: field_name,
            ty: field_type,
        });
    }

    let builder_name = format_ident!("{}Builder", name);

    let builder_fields = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;
        quote! { pub #field_name: Option<#field_type> }
    });

    let builder_struct = quote! {
        pub struct #builder_name {
            #(#builder_fields),*
        }
    };

    let field_names_for_new = collected_fields.iter().map(|field| field.name);

    let setters = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;

        quote! {
            pub fn #field_name(&mut self, #field_name: #field_type) -> &mut Self {
                self.#field_name = Some(#field_name);
                self
            }
        }
    });

    let build_initializers = collected_fields.iter().map(|field| {
        let field_name = field.name;
        // The expression `self.#field_name` is the part this task focuses on.
        // It retrieves the Option<T> value from the builder's state.
        quote! {
            #field_name: self.#field_name.clone().unwrap()
        }
    });

    let builder_impl = quote! {
        impl #builder_name {
            pub fn new() -> Self {
                Self {
                    #(#field_names_for_new: None),*
                }
            }

            #(#setters)*

            pub fn build(&self) -> #name {
                #name {
                    #(#build_initializers),*
                }
            }
        }
    };

    let output = quote! {
        #builder_struct
        #builder_impl
    };

    output.into()
}

What’s Next?

You have now solidified your understanding of how we access the Option<T> value from the builder’s state using self.#field_name. The very next task is to dissect the second half of that expression: .clone().unwrap(). We’ll explore why these two method calls are necessary and what they do to transform the retrieved Option<T> into the final T that the original struct requires.

Rust Builder Pattern: Understanding `.clone().unwrap()`

Mục tiêu: An in-depth explanation of the .clone().unwrap() pattern within a Rust procedural macro for a builder. This task covers Rust’s ownership and borrowing rules, why .clone() is necessary when working with an immutable reference (&self), and how .unwrap() extracts a value from an Option.

Of course! Let’s get this task done.

In the previous task, we successfully isolated the first part of our value extraction logic: self.#field_name. You now understand how this expression uses an immutable reference to the builder (self) to access each Option<T> field dynamically. We have successfully retrieved the data, but it’s in the wrong container—an Option—and we need to get the value out.

This brings us to the second, crucial part of the expression: .clone().unwrap(). This pair of method calls is the bridge that transforms the builder’s internal state into the concrete values required by the final struct.

The Type Mismatch: From `Option<T>` to `T`

Let’s be clear about the problem we’re solving. The original struct, let’s say Command, has a field like executable: String. The corresponding field in our CommandBuilder is executable: Option<String>. To construct the Command instance, we must provide a String, not an Option<String>. Our job is to “unbox” or “unwrap” the value from the Option.

Unboxing the Value with `.unwrap()`

The Option enum has a very direct, if blunt, method for this: .unwrap(). Its behavior is simple:

If the value is Some(x), .unwrap() returns x.
If the value is None, .unwrap() panics, immediately crashing the current thread.

For our initial implementation, this behavior is exactly what we want. It acts as a runtime assertion that a value has been set. If a user forgets to call a setter for a required field and then calls .build(), the program will panic. This is a clear signal of incorrect usage. While we will improve this later with more graceful, Result-based error handling, using unwrap() is a common and effective starting point for enforcing invariants.

So, you might think we can just write self.#field_name.unwrap(). But if you try this, the Rust compiler will stop you with an error. Why? The reason is one of Rust’s most important concepts: ownership.

The Ownership Problem: Why We Must `.clone()`

Remember the signature of our build method: pub fn build(&self) -> #name. The receiver is &self, an immutable reference to the builder. This is a contract that says, “this method will only read from the builder, it will not change it or take anything from it.”

The .unwrap() method, by default, tries to move the value out of the Option. A move is a transfer of ownership. If we have an Option<String>, unwrapping it would give us the String, and the Option would be left empty and unusable.

The compiler sees this and says: “Hold on! You only have a read-only borrow (&self). You are not allowed to take ownership of the data inside the builder, because that would change the builder’s state, violating the &self contract.”

This is where .clone() comes to the rescue. The Clone trait in Rust provides a method, .clone(), to create an explicit, deep copy of a value.

Here’s the sequence of operations that solves the ownership problem:

self.#field_name: We access the builder’s field. This gives us a reference to the Option<T> inside the builder (e.g., &Option<String>).
.clone(): We call .clone() on this &Option<String>. If String is Clone, then Option<String> is also Clone. This operation creates a brand new, completely independent Option<String> on the stack. The builder’s state is left completely untouched.
.unwrap(): We now call .unwrap() on our newly created copy. Since we own this copy, we are free to move the String out of it. The copy is consumed, we get the String, and the original builder remains perfectly valid and unchanged.

This clone-then-unwrap pattern is a common idiom in Rust when you need to get an owned value from a borrowed context, assuming the type is Clone-able.

Reviewing the Code

No changes are needed to your code, as you’ve already correctly implemented this logic. Let’s review it with this deeper understanding.

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn;

// Helper struct remains unchanged
struct FieldInfo<'a> {
    name: &'a syn::Ident,
    ty: &'a syn::Type,
}

#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    // ... (parsing and data collection logic remains exactly the same)
    let ast = syn::parse(input).unwrap();
    let name = &ast.ident;
    let data = match ast.data {
        syn::Data::Struct(data) => data,
        _ => panic!("Builder can only be derived for structs"),
    };
    let fields = match data.fields {
        syn::Fields::Named(fields) => fields,
        _ => panic!("Builder can only be derived for structs with named fields"),
    };
    let mut collected_fields = Vec::new();
    for field in &fields.named {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = &field.ty;
        collected_fields.push(FieldInfo {
            name: field_name,
            ty: field_type,
        });
    }

    let builder_name = format_ident!("{}Builder", name);

    let builder_fields = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;
        quote! { pub #field_name: Option<#field_type> }
    });

    let builder_struct = quote! {
        pub struct #builder_name {
            #(#builder_fields),*
        }
    };

    let field_names_for_new = collected_fields.iter().map(|field| field.name);

    let setters = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;

        quote! {
            pub fn #field_name(&mut self, #field_name: #field_type) -> &mut Self {
                self.#field_name = Some(#field_name);
                self
            }
        }
    });

    let build_initializers = collected_fields.iter().map(|field| {
        let field_name = field.name;
        // This task focuses on the `.clone().unwrap()` part of this line.
        // It's the two-step process to get an owned value `T` from the
        // builder's `Option<T>` field without violating Rust's borrow rules.
        quote! {
            #field_name: self.#field_name.clone().unwrap()
        }
    });

    let builder_impl = quote! {
        impl #builder_name {
            pub fn new() -> Self {
                Self {
                    #(#field_names_for_new: None),*
                }
            }

            #(#setters)*

            pub fn build(&self) -> #name {
                #name {
                    #(#build_initializers),*
                }
            }
        }
    };

    let output = quote! {
        #builder_struct
        #builder_impl
    };

    output.into()
}

What’s Next?

You now have a complete understanding of the entire expression self.#field_name.clone().unwrap(). You know how to access the builder’s state, how to handle the ownership constraints with .clone(), and how to extract the final value with .unwrap().

The final task in this step is to put it all together and formally use these retrieved values to construct and return the final struct instance, completing the build method’s implementation.

Finalize the `build` Method in a Rust Procedural Macro

Mục tiêu: Learn how to assemble the final struct instance within the build method using the quote! macro. This task focuses on understanding how a struct instantiation expression and Rust’s implicit return feature work together to complete the builder pattern.

Excellent! You have meticulously navigated the complexities of the build method’s implementation. In the preceding tasks, you’ve mastered the two critical components of the value extraction process:

Retrieving the State: You learned how self.#field_name provides read-only access to each Option<T> field within the builder.
Transforming the Value: You understood why the .clone().unwrap() sequence is essential for safely extracting an owned value T from the borrowed Option<T>, respecting Rust’s strict ownership and borrowing rules.

With all the necessary values now successfully retrieved and transformed, we have arrived at the final, climactic task of this step: using these values to construct the final struct instance and return it to the user.

From Values to an Object: The Struct Expression

In Rust, the syntax for creating an instance of a struct is an expression. This is a crucial concept. An expression is a piece of code that evaluates to a value. The code Command { executable: "ls".to_string(), ... } is not just a command to the compiler; it’s an expression that, when evaluated, results in a new value of type Command.

Our goal within the build() method is to generate exactly this kind of expression. We have all the ingredients:

The name of the struct to be built (stored in your name variable).
An iterator, build_initializers, that generates the field: value pairs.

The quote! macro is designed to assemble these ingredients into a single, cohesive struct expression.

The Final Assembly and Implicit Return

Let’s look at the body of your build method again. It is a perfect, concise example of how to generate this final expression.

#name {
    #(#build_initializers),*
}

This block of code is the entire implementation. Let’s break down its elegance:

#name { ... }: This part of the quote! macro uses the name variable (which holds the syn::Ident of the original struct, e.g., Command) to start the struct construction expression.
#(#build_initializers),*: Inside the curly braces, you use the repetition syntax. This iterates through your build_initializers and splices each generated token stream (e.g., executable: self.executable.clone().unwrap()) into the code, separated by commas.
The Implicit Return: This is the most important concept for this task. In Rust, if the last expression in a function’s body is not followed by a semicolon, its value is automatically returned. The entire #name { ... } block is a single expression. Since it’s the last (and only) expression in our build() method’s body, the newly constructed struct instance is returned, perfectly satisfying the method’s -> #name return signature. There is no need for an explicit return keyword.

You have already written the perfect code for this. This task is about solidifying your understanding of how these generated pieces come together to fulfill the method’s contract.

Code Review

Your current src/lib.rs file correctly implements this final assembly. No changes are needed.

use proc_macro::TokenStream;
use quote::{format_ident, quote};
use syn;

// Helper struct remains unchanged
struct FieldInfo<'a> {
    name: &'a syn::Ident,
    ty: &'a syn::Type,
}

#[proc_macro_derive(Builder)]
pub fn derive_builder(input: TokenStream) -> TokenStream {
    // Parsing and data collection logic remains exactly the same.
    let ast = syn::parse(input).unwrap();
    let name = &ast.ident;
    let data = match ast.data {
        syn::Data::Struct(data) => data,
        _ => panic!("Builder can only be derived for structs"),
    };
    let fields = match data.fields {
        syn::Fields::Named(fields) => fields,
        _ => panic!("Builder can only be derived for structs with named fields"),
    };
    let mut collected_fields = Vec::new();
    for field in &fields.named {
        let field_name = field.ident.as_ref().unwrap();
        let field_type = &field.ty;
        collected_fields.push(FieldInfo {
            name: field_name,
            ty: field_type,
        });
    }

    let builder_name = format_ident!("{}Builder", name);

    let builder_fields = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;
        quote! { pub #field_name: Option<#field_type> }
    });

    let builder_struct = quote! {
        pub struct #builder_name {
            #(#builder_fields),*
        }
    };

    let field_names_for_new = collected_fields.iter().map(|field| field.name);

    let setters = collected_fields.iter().map(|field| {
        let field_name = field.name;
        let field_type = field.ty;

        quote! {
            pub fn #field_name(&mut self, #field_name: #field_type) -> &mut Self {
                self.#field_name = Some(#field_name);
                self
            }
        }
    });

    let build_initializers = collected_fields.iter().map(|field| {
        let field_name = field.name;
        quote! {
            #field_name: self.#field_name.clone().unwrap()
        }
    });

    let builder_impl = quote! {
        impl #builder_name {
            pub fn new() -> Self {
                Self {
                    #(#field_names_for_new: None),*
                }
            }

            #(#setters)*

            pub fn build(&self) -> #name {
                // This block is a single expression. Its value - the new instance of `#name` -
                // is implicitly returned from the function, fulfilling the return type.
                #name {
                    #(#build_initializers),*
                }
            }
        }
    };

    let output = quote! {
        #builder_struct
        #builder_impl
    };

    output.into()
}

Congratulations on a Major Milestone!

You have now fully implemented the build method and completed the entire core logic of the builder pattern! Your procedural macro now generates a complete, functional builder struct with a constructor, fluent setters, and a finalizer that produces the target object. This is a significant achievement.

What’s Next?

The builder is functionally complete, but it’s not yet ergonomically perfect. A user currently has to instantiate the builder with CommandBuilder::new(). The idiomatic and more discoverable pattern is to provide an associated function on the original type, allowing a user to simply write Command::builder().

In the next step, “Connecting the Builder and Returning the Code,” you will add this final, elegant touch. You’ll generate a second impl block, this time for the original struct, to add the builder() function that will serve as the convenient entry point to the entire pattern.