Custom Derive: Implementing a ToString Macro in Rust

Procedural macros are a powerful feature in Rust that allows you to generate code at compile time. This challenge will focus on creating a custom derive macro that automatically implements the ToString trait for a given struct or enum. This is a common pattern for simplifying boilerplate code when you want to convert your types into strings.

Problem Description

Your task is to implement a procedural macro that can be derived on structs and enums. This macro, let's call it ToStringDerive, should automatically generate an implementation of a trait similar to std::string::ToString (but we'll define our own simple trait for this exercise). The generated to_string method should produce a string representation of the type.

Key Requirements

1. Create a custom derive macro: The macro should be callable using #[derive(ToStringDerive)].
2. Define a ToString trait: You'll need to define a simple trait named ToString with a single method to_string(&self) -> String.
3. Handle Structs:
   • For a struct with named fields, the output string should list each field name and its string representation (recursively calling to_string if the field type also implements ToString).
   • For a tuple struct, the output string should represent the values of its fields.
4. Handle Enums:
   • For an enum variant without data, the output string should be the variant name.
   • For an enum variant with data, the output string should include the variant name and the string representations of its associated data.
5. Recursive Derivation: If the types of fields or enum data themselves implement ToString, the macro should be able to handle them.

Expected Behavior

When #[derive(ToStringDerive)] is applied to a type, the compiler should generate an implementation of ToString for that type.

Edge Cases

• Empty Structs/Enums: How should an empty struct or enum be represented?
• Nested Types: Ensure that the macro correctly handles nested structs, enums, and their fields.
• Types without ToString: The macro should ideally handle cases where nested types might not implement ToString, perhaps by falling back to Debug or a simple default. For this challenge, assume all relevant nested types will also derive ToStringDerive.

Examples

Example 1: Simple Struct

Input Code:

#[derive(ToStringDerive)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 10, y: 20 };
    println!("{}", p.to_string());
}

Expected Output:

Point { x: "10", y: "20" }

Explanation: The ToStringDerive macro generates an implementation for Point. When to_string() is called on p, it produces a string representing the struct name, followed by its fields and their stringified values.

Example 2: Enum with Variants

Input Code:

#[derive(ToStringDerive)]
enum Color {
    Red,
    Green(u8),
    Blue { r: u8, g: u8, b: u8 },
}

fn main() {
    let r = Color::Red;
    let g = Color::Green(128);
    let b = Color::Blue { r: 255, g: 100, b: 50 };

    println!("{}", r.to_string());
    println!("{}", g.to_string());
    println!("{}", b.to_string());
}

Expected Output:

Red
Green("128")
Blue { r: "255", g: "100", b: "50" }

Explanation: The macro generates implementations for each variant. Red is a simple variant. Green includes its single u8 value. Blue includes its named fields and their stringified values.

Example 3: Nested Struct

Input Code:

#[derive(ToStringDerive)]
struct Location {
    name: String,
    coords: Point,
}

#[derive(ToStringDerive)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let p = Point { x: 1, y: 2 };
    let loc = Location { name: "Home".to_string(), coords: p };
    println!("{}", loc.to_string());
}

Expected Output:

Location { name: "Home", coords: "Point { x: "1", y: "2" }" }

Explanation: The ToStringDerive macro recursively generates the ToString implementation for Location. When stringifying coords, it calls the to_string method generated for the Point struct.

Constraints

• The macro should be implemented as a procedural macro crate.
• You will need to use the syn and quote crates for parsing and generating Rust code.
• Assume all types involved in derivation will also derive ToStringDerive or are primitive types that have a sensible default string representation (e.g., i32, String).

Notes

• This challenge requires understanding of Rust's procedural macro system, specifically custom derive macros.
• You'll need to define your own ToString trait as std::string::ToString is not directly implementable by derive macros in this manner.
• Think about how syn represents Rust code (AST - Abstract Syntax Tree) and how quote can generate code from this representation.
• Consider how to iterate over fields of structs and variants of enums.
• A good starting point is to look at examples of other custom derive macros in Rust.
• The generated to_string method should handle the conversion of primitive types (like i32) to String using their own ToString implementations (e.g., 10.to_string()).