Standardizing Internal APIs

In this lesson, you will learn how to create "glue" traits to standardize how different procedural macros communicate within a large codebase.

The Problem: Macro Silos

In complex projects, you often have multiple procedural macros (like #[derive(Serialize)] and #[derive(Validator)]) that need to share metadata about a struct. If these macros rely on ad-hoc parsing of the TokenStream, they become tightly coupled to specific syntax and brittle to changes. If you rename a field or add an attribute, you have to hunt down and update every macro that touches that data.

The Solution: Internal Trait Abstractions

Instead of letting macros parse raw tokens independently, you should define a private internal crate (e.g., my_macro_utils) that contains a standard set of "Data Exchange Traits."

These traits act as a contract for your macros. By forcing your macros to consume a structured internal object (rather than raw syn nodes), you decouple the parsing logic from the code generation logic.

// Internal trait that all macro-compatible types must implement
pub trait MacroMetadata {
    fn field_names(&self) -> Vec<String>;
    fn validation_rules(&self) -> Vec<Rule>;
}

// Your procedural macro then converts the AST to this common trait,
// ensuring every macro operates on the same standard interface.

Streamlining Interaction

When a new developer joins or a new macro is needed, they don't need to know the intricate details of how the first macro parsed the AST. They simply write an adapter that implements MacroMetadata for the target struct.

1. Parser Phase: The macro parses the tokens into an internal struct.
2. Standardization Phase: The parser maps that struct to your internal MacroMetadata trait.
3. Generation Phase: All subsequent macros consume the trait object, making them "syntax-agnostic."

This approach turns your collection of disparate macros into a cohesive ecosystem. By centralizing the representation of your internal API, you ensure that if the structure of your domain objects changes, you only update the trait implementation in one place, and all your macros instantly "know" about the change.

Key Takeaway: Use internal trait abstractions to create a common language between your macros, decoupling raw syntax parsing from your business logic generation.