Attribute Macro for Generating Debugging Information

Procedural macros are a powerful feature in Rust that allow you to modify code at compile time. This challenge focuses on implementing a derive attribute macro that automatically generates debugging information for structs. This is useful for quickly inspecting the state of your data structures during development and debugging, without needing to manually write println! statements everywhere.

Problem Description

You are tasked with creating a procedural macro named DebugInfo that can be applied to structs. When applied, the macro will generate a dbg!-like function specific to that struct, which prints the name and value of each field in the struct. The generated function should take a single argument of the struct type and print the field names and values to standard output in a clear and readable format.

Key Requirements:

• The macro must be a derive macro, meaning it can be applied using #[derive(DebugInfo)].
• The generated function should be named dbg_<StructName>, where <StructName> is the name of the struct.
• The generated function should iterate through the fields of the struct and print each field's name and value using println!("{}: {:?},", name, value);.
• The generated function should end with a newline character (\n) to ensure proper formatting.
• The macro should handle structs with any number of fields.
• The macro should generate code that compiles and runs correctly.

Expected Behavior:

When the DebugInfo derive macro is applied to a struct, a new function with the specified name is generated. Calling this function with an instance of the struct will print the name and value of each field to standard output.

Edge Cases to Consider:

• Structs with private fields: The macro should still generate the function, but it might not be able to access private fields. The generated code should not panic if it encounters a private field; it should simply skip it.
• Structs with complex field types (e.g., nested structs, enums): The macro should handle these types gracefully, printing their values using the {:?} debug formatting.
• Empty structs: The macro should still generate a function, even if the struct has no fields.

Examples

Example 1:

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

fn main() {
    let p = Point { x: 10, y: 20 };
    dbg_Point(p);
}

Output:

x: 10,y: 20,

Explanation: The DebugInfo macro generates a function dbg_Point that prints the x and y fields of the Point struct.

Example 2:

#[derive(DebugInfo)]
struct Person {
    name: String,
    age: u8,
    is_active: bool,
}

fn main() {
    let person = Person { name: "Alice".to_string(), age: 30, is_active: true };
    dbg_Person(person);
}

Output:

name: "Alice",age: 30,is_active: true,

Explanation: The DebugInfo macro generates a function dbg_Person that prints the name, age, and is_active fields of the Person struct.

Example 3:

#[derive(DebugInfo)]
struct EmptyStruct;

fn main() {
    let empty = EmptyStruct;
    dbg_EmptyStruct(empty);
}

Output:

Explanation: The DebugInfo macro generates a function dbg_EmptyStruct that does nothing because the struct has no fields.

Constraints

• The generated code must be valid Rust code.
• The macro must compile without errors or warnings.
• The generated function must be named correctly based on the struct's name.
• The output format must match the specified format: field_name: field_value,.
• The macro should handle structs with up to 10 fields. (This is a simplification to keep the challenge manageable; a production-ready macro would handle more.)

Notes

• You will need to create a new Rust crate with the proc-macro feature enabled.
• Use the syn and quote crates to parse and generate Rust code. Add these to your Cargo.toml: syn = { version = "1.0", features = ["full"] } and quote = "1.0".
• The derive macro API provides functions for parsing attributes and fields.
• Consider using quote::format_ident! to generate the function name dynamically.
• Remember to handle the case where the struct has no fields.
• Focus on generating the correct code; you don't need to write the main function or the struct definitions in your macro. The examples provide those.
• Error handling is not required for this challenge. Assume the input is always a valid struct definition.