Macro Magic

https://docs.rs/macro_magic/latest
Admin
Macro Magic provides attribute macros like `#[export_tokens]` and `#[import_tokens_proc]` to enable...
Tokens:63,843
Snippets:461
Trust Score:9.7
Update:10 months ago
Show doc for...
Tokens:
Raw
### ForeignPath Trait Example Implementation (Rust)

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/trait.ForeignPath_search=

An example of implementing the ForeignPath trait along with `derive_syn_parse::Parse` and `ToTokens` for a custom parsing struct named CustomParsingA. It demonstrates how to extract and return the foreign path.

```Rust
#[derive(derive_syn_parse::Parse)]
struct CustomParsingA {
    foreign_path: syn::Path,
    _comma: syn::token::Comma,
    custom_path: syn::Path,
}

impl ToTokens for CustomParsingA {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(self.foreign_path.to_token_stream());
        tokens.extend(self._comma.to_token_stream());
        tokens.extend(self.custom_path.to_token_stream());
    }
}

impl ForeignPath for CustomParsingA {
    fn foreign_path(&self) -> &syn::Path {
        &self.foreign_path
    }
}
```

--------------------------------

### Usage Example of Custom Parsed Attribute Macro

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_attr_search=std%3A%3Avec

Shows how to invoke an attribute macro that has been configured with custom parsing logic. The example demonstrates passing multiple arguments to the macro, which are then handled by the custom parsing implementation.

```rust
#[my_attribute(foreign::path, some_other::path)]
struct SomeItem {}
```

--------------------------------

### Example Usage of forward_tokens Macro

Source: https://docs.rs/macro_magic/latest/macro_magic/macro.forward_tokens_search=

Demonstrates how to use the `forward_tokens` macro. It shows forwarding the tokens of `LionStruct` to the `receiver` macro and asserting the expected stringified output.

```Rust
#[macro_export]
macro_rules! receiver {
    ($tokens:item) => {
        stringify!($tokens)
    };
}

let result = forward_tokens!(LionStruct, receiver);
assert_eq!(result, "struct LionStruct {}");
```

--------------------------------

### Example Implementation of ForeignPath Trait in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/trait.ForeignPath_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates an example implementation of the `ForeignPath` trait for a custom struct `CustomParsingA` in Rust. This struct derives `syn::Parse` and implements `ToTokens` and `ForeignPath`, showing how to handle foreign paths and custom parsing logic.

```rust
#[derive(derive_syn_parse::Parse)]
struct CustomParsingA {
    foreign_path: syn::Path,
    _comma: syn::token::Comma,
    custom_path: syn::Path,
}

implement ToTokens for CustomParsingA {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(self.foreign_path.to_token_stream());
        tokens.extend(self._comma.to_token_stream());
        tokens.extend(self.custom_path.to_token_stream());
    }
}

implement ForeignPath for CustomParsingA {
    fn foreign_path(&self) -> &syn::Path {
        &self.foreign_path
    }
}
```

--------------------------------

### Forward Tokens Macro Example (Rust)

Source: https://docs.rs/macro_magic/latest/macro_magic/macro.forward_tokens

Demonstrates the usage of the `forward_tokens!` macro to forward tokens from an exported item to a receiving macro. The source item must have the `#[export_tokens]` attribute. An optional 'extra' argument can also be passed.

```rust
macro_rules! receiver {
    ($tokens:item) => {
        stringify!($tokens)
    };
}

let result = forward_tokens!(LionStruct, receiver);
assert_eq!(result, "struct LionStruct {}");
```

--------------------------------

### Rust: Using import_tokens_attr with an External Item

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_attr

Illustrates how to use an attribute macro, like `my_attribute`, which is enhanced by `#[import_tokens_attr]`. This example shows attaching the attribute to a module, referencing an external item by its path.

```rust
#[my_attribute(path::to::AnItem)]
mod my_mod {
    // ...
}
```

--------------------------------

### Rust: Usage Example of Custom Parsed Attribute Macro

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_attr_search=u32+-%3E+bool

Illustrates how to use a proc macro defined with `#[with_custom_parsing(..)]`. The macro `my_attribute` expects two path arguments, where the first is parsed by the default mechanism and the second is parsed by the custom `MyCustomParsing` struct defined previously.

```Rust
// Assuming 'my_attribute' is available in scope (e.g., imported from a crate)

// The usage demonstrates passing two path arguments to the macro.
// The first argument 'foreign::path' is parsed by the default mechanism.
// The second argument 'some_other::path' is parsed by the custom MyCustomParsing struct.
#[my_attribute(foreign::path, some_other::path)]
struct SomeItem {}

```

--------------------------------

### ProcMacro Constructor

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ProcMacro_search=

Information on how to construct a ProcMacro instance from a TokenStream.

```APIDOC
## impl ProcMacro

### pub fn from<T>(tokens: T) -> Result<ProcMacro, Error>

#### Description
Constructs a `ProcMacro` from anything compatible with `TokenStream2`.

#### Parameters
- **tokens** (T where T: Into<TokenStream>) - The input token stream to construct the `ProcMacro` from.

#### Returns
- `Result<ProcMacro, Error>` - A `ProcMacro` instance on success, or an `Error` on failure.
```

--------------------------------

### ForeignPath Trait Definition and Example (Rust)

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/trait.ForeignPath

Defines the ForeignPath trait, which requires implementing a `foreign_path` method returning a `&Path`. The example shows a struct `CustomParsingA` implementing `ForeignPath` and `syn::parse::Parse` for custom token stream parsing.

```rust
pub trait ForeignPath {
    // Required method
    fn foreign_path(&self) -> &Path;
}

#[derive(derive_syn_parse::Parse)]
struct CustomParsingA {
    foreign_path: syn::Path,
    _comma: syn::token::Comma,
    custom_path: syn::Path,
}

impl ToTokens for CustomParsingA {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(self.foreign_path.to_token_stream());
        tokens.extend(self._comma.to_token_stream());
        tokens.extend(self.custom_path.to_token_stream());
    }
}

impl ForeignPath for CustomParsingA {
    fn foreign_path(&self) -> &syn::Path {
        &self.foreign_path
    }
}
```

--------------------------------

### ProcMacro Implementations

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ProcMacro_search=

Details on the Clone implementation for ProcMacro.

```APIDOC
### impl Clone for ProcMacro

#### fn clone(&self) -> ProcMacro

##### Description
Returns a duplicate of the value.

#### Returns
- `ProcMacro` - A cloned instance of the `ProcMacro`.
```

```APIDOC
#### fn clone_from(&mut self, source: &Self)

##### Description
Performs copy-assignment from `source`.
```

--------------------------------

### Generic Implementations for T in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=std%3A%3Avec

This section details various blanket implementations for any type `T` in Rust. These include `Any`, `Borrow`, `BorrowMut`, `CloneToUninit` (experimental), `From<T>` for `T`, `Into<U>` where `U: From<T>`, `ToOwned`, `TryFrom<U>` where `U: Into<T>`, and `TryInto<U>` where `U: TryFrom<T>`.

```rust
// impl<T> Any for T
// impl<T> Borrow<T> for T
// impl<T> BorrowMut<T> for T
// impl<T> CloneToUninit for T
// impl<T> From<T> for T
// impl<T, U> Into<U> for T
// impl<T> ToOwned for T
// impl<T, U> TryFrom<U> for T
// impl<T, U> TryInto<U> for T
```

--------------------------------

### Implement Any Trait for Generic Type T in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ForwardTokensArgs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the blanket implementation of the `Any` trait for any type `T` that is `'static + ?Sized`. This provides a `type_id` method to get the `TypeId` of the type.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
fn type_id(&self) -> TypeId
```

--------------------------------

### Get Attribute Representation of ProcMacroType in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implements the `to_attr` method for the `ProcMacroType` enum, returning an `Attribute` representation. This method is part of the enum's functionality to interact with macro attributes.

```rust
impl ProcMacroType {
    pub fn to_attr(&self) -> Attribute
}
```

--------------------------------

### Get String Representation of ProcMacroType in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implements the `to_str` method for the `ProcMacroType` enum, returning a static string slice representing the macro type. This is useful for logging or display purposes.

```rust
impl ProcMacroType {
    pub fn to_str(&self) -> &'static str
}
```

--------------------------------

### Generic Blanket Implementations in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates common blanket implementations provided for generic types in Rust, such as `Any`, `Borrow`, `CloneToUninit`, `From`, `Into`, `ToOwned`, `TryFrom`, and `TryInto`. These are applied to `ProcMacroType`.

```rust
impl<T> Any for T where T: 'static + ?Sized
impl<T> Borrow<T> for T where T: ?Sized
impl<T> BorrowMut<T> for T where T: ?Sized
impl<T> CloneToUninit for T where T: Clone
impl<T> From<T> for T
impl<T, U> Into<U> for T where U: From<T>
impl<T> ToOwned for T where T: Clone
impl<T, U> TryFrom<U> for T where U: Into<T>
impl<T, U> TryInto<U> for T where U: TryFrom<T>
```

--------------------------------

### Type Conversion Utilities for ForwardTokensExtraArg (Rust)

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ForwardTokensExtraArg_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Showcases blanket implementations of traits like `Any`, `Borrow`, `From`, `Into`, `Spanned`, `TryFrom`, and `TryInto` for `ForwardTokensExtraArg`. These enable various type conversions and introspection capabilities.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
impl<T> Borrow<T> for T
where T: ?Sized,
impl<T> BorrowMut<T> for T
where T: ?Sized,
impl<T> From<T> for T
impl<T, U> Into<U> for T
where U: From<T>,
impl<T> Spanned for T
where T: Spanned + ?Sized,
impl<T, U> TryFrom<U> for T
where U: Into<T>,
impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

```

--------------------------------

### Implement Blanket Implementations for Generic Types in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ImportedTokens_search=u32+-%3E+bool

Illustrates the implementation of common blanket traits for generic types, including 'Any', 'Borrow', 'BorrowMut', 'From', 'Into', 'TryFrom', and 'TryInto'. These implementations provide fundamental functionalities like type identity, borrowing, and conversions.

```rust
impl<T> Any for T where T: 'static + ?Sized {
    fn type_id(&self) -> TypeId
}

impl<T> Borrow<T> for T where T: ?Sized {
    fn borrow(&self) -> &T
}

impl<T> BorrowMut<T> for T where T: ?Sized {
    fn borrow_mut(&mut self) -> &mut T
}

impl<T> From<T> for T {
    fn from(t: T) -> T
}

impl<T, U> Into<U> for T where U: From<T> {
    fn into(self) -> U
}

impl<T, U> TryFrom<U> for T where U: Into<T> {
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
}

impl<T, U> TryInto<U> for T where U: TryFrom<T> {
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
}
```

--------------------------------

### ProcMacro Struct Documentation

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ProcMacro_search=

Details about the ProcMacro struct, its fields, and their purposes.

```APIDOC
## Struct ProcMacro

### Description
Generically parses a proc macro definition with support for all variants.

### Fields
- **proc_fn** (ItemFn) - The underlying proc macro function definition.
- **macro_type** (ProcMacroType) - Specifies the type of this proc macro, i.e., attribute vs. normal vs. derive.
- **tokens_ident** (Ident) - Specifies the `Ident` for the `tokens` parameter of this proc macro function definition. For normal and derive macros this is the only parameter, and for attribute macros this is the second parameter.
- **attr_ident** (Option<Ident>) - Specifies the `Ident` for the `attr` parameter of this proc macro function definition, if it is an attribute macro. Otherwise, this will be set to `None`.
```

--------------------------------

### Implement TryInto for Generic Types in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.AttrItemWithExtra_search=std%3A%3Avec

Demonstrates the blanket implementation of the `TryInto` trait for generic types `T` and `U` where `U` can be created from `T`. This allows for fallible conversion between types that implement `TryFrom`.

```rust
impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
}
```

--------------------------------

### Implement Clone for ProcMacro in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ProcMacro_search=

Demonstrates the implementation of the `Clone` trait for the `ProcMacro` struct, allowing for the creation of duplicate instances. It includes methods for cloning and clone-from operations.

```rust
impl Clone for ProcMacro {
    fn clone(&self) -> ProcMacro
    fn clone_from(&mut self, source: &Self)
}
```

--------------------------------

### Using import_tokens_proc with MACRO_MAGIC_ROOT override (Expr) in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_proc_search=std%3A%3Avec

Illustrates using `import_tokens_proc` with an expression that evaluates to a string-compatible type to override `MACRO_MAGIC_ROOT`. This enables dynamic generation of the root path using string formatting and other Rust expressions, offering flexibility in managing macro contexts.

```rust
#[import_tokens_proc(format!("{}::__private::macro_magic", generate_crate_access_2018("my_crate")))]
pub fn my_macro(tokens: TokenStream) -> TokenStream {
    // ..
}
```

--------------------------------

### Custom Parsing for Attribute Macros in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_attr_search=std%3A%3Avec

Demonstrates how to implement custom parsing for attribute macros using `#[with_custom_parsing(..)]`. This involves defining a struct that implements `syn::parse::Parse` and `quote::ToTokens`, and then using magic variables like `__custom_tokens` within the proc macro.

```rust
#[derive(Parse)]
struct MyCustomParsing {
    foreign_path: syn::Path,
    _comma: syn::token::Comma,
    custom_path: syn::Path,
}

impl ToTokens for MyCustomParsing {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(self.foreign_path.to_token_stream());
        tokens.extend(self._comma.to_token_stream());
        tokens.extend(self.custom_path.to_token_stream());
    }
}

impl ForeignPath for MyCustomParsing {
    fn foreign_path(&self) -> &syn::Path {
        &self.foreign_path
    }
}

#[import_tokens_attr]
#[with_custom_parsing(MyCustomParsing)]
#[proc_macro_attribute]
pub fn my_attribute(attr: TokenStream, tokens: TokenStream) -> TokenStream {
    let external_item = parse_macro_input!(attr as Item);
    let attached_item = parse_macro_input!(tokens as Item);
    let custom_parsed_item = parse_macro_input!(__custom_tokens as MyCustomParsing);
    // ...
}
```

--------------------------------

### Proc Support Feature Configuration (Rust)

Source: https://docs.rs/macro_magic/latest/src/macro_magic/lib.rs

Illustrates how to enable the `proc_support` feature for `macro_magic` in `Cargo.toml`. This feature is necessary for macros like `import_tokens_proc` and `import_tokens_attr`.

```toml
[dependencies.macro_magic]
version = "0.x.y"
features = ["proc_support"]
```

--------------------------------

### Using import_tokens_proc with MACRO_MAGIC_ROOT override (Path) in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_proc_search=std%3A%3Avec

Demonstrates how to use the `import_tokens_proc` attribute macro with an explicit path to override the default `MACRO_MAGIC_ROOT`. This allows for dynamic control over the root path used by the macro, essential for managing dependencies in complex projects.

```rust
#[import_tokens_proc(my_crate::__private::macro_magic)]
pub fn my_macro(tokens: TokenStream) -> TokenStream {
    // ..
}
```

--------------------------------

### Implement TryInto for Generic Types in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.AttrItemWithExtra_search=u32+-%3E+bool

Provides a generic implementation of `TryInto` for types `T` that can be converted into type `U` where `U` implements `TryFrom<T>`. This allows for fallible conversions between types.

```rust
impl<T, U> TryInto<U> for T
where
    U: TryFrom<T>,
{
    type Error = <U as TryFrom<T>>::Error;

    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error> {
        U::try_from(self)
    }
}
```

--------------------------------

### Implement PartialEq for ProcMacroType in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=std%3A%3Avec

This Rust code demonstrates the implementation of the `PartialEq` trait for the `ProcMacroType` enum. It includes the `eq` and `ne` methods for comparing two `ProcMacroType` instances for equality.

```rust
fn eq(&self, other: &ProcMacroType) -> bool
fn ne(&self, other: &Rhs) -> bool
```

--------------------------------

### Construct ProcMacro from TokenStream in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ProcMacro_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides a function to construct a ProcMacro instance from any type that can be converted into a TokenStream. This is useful for parsing macro input.

```rust
pub fn from<T>(tokens: T) -> Result<ProcMacro, Error>
where T: Into<TokenStream>,
Constructs a `ProcMacro` from anything compatible with `TokenStream2`.
```

--------------------------------

### Overriding `MACRO_MAGIC_ROOT` with `import_tokens_proc`

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_proc_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to override the `MACRO_MAGIC_ROOT` path within the context of code generated by the `import_tokens_proc` attribute macro. This can be done by providing a module path or any `Expr` that evaluates to a type compatible with `Into<String>`, allowing for dynamic path generation.

```rust
#[import_tokens_proc(my_crate::__private::macro_magic)]
pub fn my_macro(tokens: TokenStream) -> TokenStream {
    // ..
}
```

```rust
#[import_tokens_proc(format!("{}::__private::macro_magic", generate_crate_access_2018("my_crate")))]
pub fn my_macro(tokens: TokenStream) -> TokenStream {
    // ..
}
```

--------------------------------

### ForeignPath Trait Documentation

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/trait.ForeignPath_search=std%3A%3Avec

Documentation for the `ForeignPath` trait, used for structs that will be passed to `#[with_custom_parsing(..)]` and need to implement `syn::parse::Parse`.

```APIDOC
## Trait ForeignPath

### Description
Should be implemented by structs that will be passed to `#[with_custom_parsing(..)]`. Such structs should also implement `syn::parse::Parse`.

### §Example
```rust
#[derive(derive_syn_parse::Parse)]
struct CustomParsingA {
    foreign_path: syn::Path,
    _comma: syn::token::Comma,
    custom_path: syn::Path,
}

impl ToTokens for CustomParsingA {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(self.foreign_path.to_token_stream());
        tokens.extend(self._comma.to_token_stream());
        tokens.extend(self.custom_path.to_token_stream());
    }
}

impl ForeignPath for CustomParsingA {
    fn foreign_path(&self) -> &syn::Path {
        &self.foreign_path
    }
}
```

## Required Methods

#### `fn foreign_path(&self) -> &Path`

**Description**: Returns the path of the foreign item whose tokens will be imported. This is used with custom parsing. See `ForeignPath` for more info.

**Returns**: A reference to the `Path` of the foreign item.
```

--------------------------------

### PartialEq Implementation for ProcMacroType in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implements `PartialEq` for `ProcMacroType`, allowing comparison of enum variants for equality. Includes methods for `eq` (equality) and `ne` (inequality).

```rust
impl PartialEq for ProcMacroType {
    fn eq(&self, other: &ProcMacroType) -> bool
    fn ne(&self, other: &Rhs) -> bool
}
```

--------------------------------

### ForeignPath Trait Documentation

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/trait.ForeignPath_search=

Documentation for the `ForeignPath` trait, which should be implemented by structs intended for custom parsing with `#[with_custom_parsing(..)]`. These structs must also implement `syn::parse::Parse`.

```APIDOC
## Trait: ForeignPath

### Description
This trait should be implemented by structs that will be passed to `#[with_custom_parsing(..)]`. Such structs should also implement `syn::parse::Parse`.

### Required Methods
#### fn foreign_path(&self) -> &Path

- **Description**: Returns the path of the foreign item whose tokens will be imported. This is used with custom parsing. See `ForeignPath` for more info.
- **Signature**: `fn foreign_path(&self) -> &Path;`

### Example Usage
```rust
#[derive(derive_syn_parse::Parse)]
struct CustomParsingA {
    foreign_path: syn::Path,
    _comma: syn::token::Comma,
    custom_path: syn::Path,
}

impl ToTokens for CustomParsingA {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(self.foreign_path.to_token_stream());
        tokens.extend(self._comma.to_token_stream());
        tokens.extend(self.custom_path.to_token_stream());
    }
}

impl ForeignPath for CustomParsingA {
    fn foreign_path(&self) -> &syn::Path {
        &self.foreign_path
    }
}
```

### Implementors
(Details on implementors would typically be listed here if available in the source documentation.)
```

--------------------------------

### Proc Support with Syn and TokenStream2 (Rust)

Source: https://docs.rs/macro_magic/latest/src/macro_magic/lib.rs_search=

This snippet showcases the conditional compilation of proc_support features in the RS Macro Magic project. It utilizes the 'syn' crate for parsing Rust code and 'syn::__private::TokenStream2' for token stream manipulation. These are essential for creating procedural macros in Rust.

```rust
#[cfg(feature = "proc_support")]
pub use syn;

#[cfg(feature = "proc_support")]
pub use syn::__private::TokenStream2;
```

--------------------------------

### import_tokens Macro

Source: https://docs.rs/macro_magic/latest/macro_magic/index

Allows direct import of tokens from an external item marked with `#[export_tokens]` when its path is known at compile-time, without requiring additional parsing.

```APIDOC
## import_tokens! macro

### Description
Directly imports tokens from an external `#[export_tokens]` item when its path is known at compile-time.

### Method
Macro

### Endpoint
N/A

### Parameters
#### Path Parameter
- **path_to_exported_item** (string) - Required - The path to the exported item.

### Request Example
```rust
let imported_tokens = macro_magic::import_tokens!("path::to::exported::item");
```

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A
```

--------------------------------

### Implement TryFrom for Trait in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ImportTokensArgs_search=u32+-%3E+bool

Demonstrates the `TryFrom` trait implementation for generic types `T` and `U` within the Rust programming language. This allows for fallible conversions from type `U` into type `T`, returning a `Result` to indicate success or failure.

```rust
impl<T, U> TryFrom<U> for T
where
    U: Into<T>,
{
    type Error = Infallible;

    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error> {
        // Implementation details
    }
}
```

--------------------------------

### Parse for ForwardTokensArgs

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ForwardTokensArgs_search=

Implementation of the `Parse` trait for `ForwardTokensArgs`, allowing it to be constructed from a parse buffer.

```APIDOC
## Trait Implementation: Parse for ForwardTokensArgs

### Description
Allows `ForwardTokensArgs` to be parsed from input.

### Method
- **parse** (`__parse_input`: &ParseBuffer<'_>) -> Result<ForwardTokensArgs, Error>

### Endpoint
N/A (Trait implementation)

### Parameters
#### Path Parameters
N/A

#### Query Parameters
N/A

#### Request Body
N/A

### Request Example
N/A (Direct parsing function)

### Response
#### Success Response (N/A - Function return type)
- **ForwardTokensArgs** (ForwardTokensArgs) - The parsed arguments.

#### Response Example
N/A
```

--------------------------------

### Trait Implementations for ProcMacroType

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This section details various trait implementations for the ProcMacroType enum, including Clone, Debug, PartialEq, Copy, Eq, and more.

```APIDOC
## Trait Implementations for ProcMacroType

### impl Clone for ProcMacroType

#### fn clone(&self) -> ProcMacroType
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.

### impl Debug for ProcMacroType

#### fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>
Formats the value using the given formatter.

### impl PartialEq for ProcMacroType

#### fn eq(&self, other: &ProcMacroType) -> bool
Tests for `self` and `other` values to be equal, and is used by `==`.

#### fn ne(&self, other: &Rhs) -> bool
Tests for `!=`.

### impl Copy for ProcMacroType

### impl Eq for ProcMacroType

### impl StructuralPartialEq for ProcMacroType
```

--------------------------------

### Convert ForwardTokensExtraArg to TokenStream (Rust)

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ForwardTokensExtraArg_search=u32+-%3E+bool

Provides methods to convert a ForwardTokensExtraArg instance into a TokenStream. This includes direct conversion using `to_token_stream` and consuming conversion using `into_token_stream`, both essential for macro code generation.

```rust
impl ToTokens for ForwardTokensExtraArg {
    fn to_tokens(&self, tokens: &mut TokenStream)
    fn to_token_stream(&self) -> TokenStream
    fn into_token_stream(self) -> TokenStream where Self: Sized,
}
```

--------------------------------

### Implement Any Trait for Generic Type T in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.AttrItemWithExtra_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the blanket implementation of the `Any` trait for any type `T` that is `'static` and `?Sized`. This allows types implementing `Any` to be queried for their `TypeId`, facilitating dynamic type identification.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
{
    fn type_id(&self) -> TypeId
}
```

--------------------------------

### ProcMacro::from

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ProcMacro_search=std%3A%3Avec

Constructs a `ProcMacro` from any type that can be converted into a `TokenStream`. This is useful for parsing macro input.

```APIDOC
## Function ProcMacro::from<T>

### Description
Constructs a `ProcMacro` from anything compatible with `TokenStream2`.

### Method
`pub fn from<T>(tokens: T) -> Result<ProcMacro, Error>`

### Parameters
- **tokens** (`T` where `T: Into<TokenStream>`) - The input that can be converted into a `TokenStream`.

### Return Value
- `Result<ProcMacro, Error>` - Returns a `ProcMacro` on success or an `Error` on failure.
```

--------------------------------

### Trait Implementations for ImportTokensArgs

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ImportTokensArgs_search=

Details the trait implementations available for the ImportTokensArgs struct, including `Parse`, `Freeze`, `RefUnwindSafe`, `Send`, `Sync`, `Unpin`, `UnwindSafe`, `Any`, `Borrow`, `BorrowMut`, `From`, `Into`, `TryFrom`, and `TryInto`.

```APIDOC
## Trait Implementations for ImportTokensArgs

### impl Parse for ImportTokensArgs
*   `fn parse(__parse_input: &ParseBuffer<'_>) -> Result<ImportTokensArgs, Error>`

### Auto Trait Implementations
*   `impl Freeze for ImportTokensArgs`
*   `impl RefUnwindSafe for ImportTokensArgs`
*   `impl !Send for ImportTokensArgs`
*   `impl !Sync for ImportTokensArgs`
*   `impl Unpin for ImportTokensArgs`
*   `impl UnwindSafe for ImportTokensArgs`

### Blanket Implementations
*   `impl<T> Any for T`
    *   `fn type_id(&self) -> TypeId`
*   `impl<T> Borrow<T> for T`
    *   `fn borrow(&self) -> &T`
*   `impl<T> BorrowMut<T> for T`
    *   `fn borrow_mut(&mut self) -> &mut T`
*   `impl<T> From<T> for T`
    *   `fn from(t: T) -> T`
*   `impl<T, U> Into<U> for T where U: From<T>`
    *   `fn into(self) -> U`
*   `impl<T, U> TryFrom<U> for T where U: Into<T>`
    *   `type Error = Infallible`
    *   `fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`
*   `impl<T, U> TryInto<U> for T where U: TryFrom<T>`
    *   `type Error = <U as TryFrom<T>>::Error`
    *   `fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`
```

--------------------------------

### Implement Clone for ProcMacroType in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=std%3A%3Avec

This Rust code demonstrates the implementation of the `Clone` trait for the `ProcMacroType` enum. It provides the `clone` and `clone_from` methods, allowing instances of `ProcMacroType` to be duplicated.

```rust
fn clone(&self) -> ProcMacroType
fn clone_from(&mut self, source: &Self)
```

--------------------------------

### Core Macro Support in Rust (with proc_support)

Source: https://docs.rs/macro_magic/latest/src/macro_magic/lib.rs_search=

The `mm_core` module provides internal code for `macro_magic` macros. The `proc_support` feature must be enabled to use its contents, which include dependencies like `syn` and `quote`.

```rust
#[cfg(feature = "proc_support")]
pub use macro_magic_core::*;
```

--------------------------------

### Copy and Eq Implementations for ProcMacroType in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides `Copy` and `Eq` trait implementations for `ProcMacroType`. `Copy` allows simple bitwise copies, and `Eq` signifies that equality comparison is reflexive, symmetric, and transitive.

```rust
impl Copy for ProcMacroType
impl Eq for ProcMacroType
```

--------------------------------

### Attribute Macro: import_tokens_attr with MACRO_MAGIC_ROOT Override

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_attr_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use `import_tokens_attr` with an optional argument to override the `MACRO_MAGIC_ROOT` path, allowing dynamic path generation.

```APIDOC
## PUT /api/users/{userId}

### Description
This endpoint updates an existing user's information. You must provide the user's ID in the path and the fields to update in the request body.

### Method
PUT

### Endpoint
/api/users/{userId}

### Parameters
#### Path Parameters
- **userId** (string) - Required - The unique identifier of the user to update.

#### Request Body
- **email** (string) - Optional - The new email address for the user.
- **password** (string) - Optional - The new password for the user.

### Request Example
```json
{
  "email": "john.doe.updated@example.com"
}
```

### Response
#### Success Response (200)
- **message** (string) - A confirmation message indicating successful user update.

#### Response Example
```json
{
  "message": "User account updated successfully."
}
```
```

--------------------------------

### Rust: Implement import_tokens_internal

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/fn.import_tokens_internal_search=std%3A%3Avec

Provides the internal implementation for the `import_tokens` macro. This function can be used directly within other proc macros to leverage `import_tokens` functionality. It requires a `TokenStream2` compatible with `ImportTokensArgs` as input and returns a `Result` containing either the processed `TokenStream` or an `Error`.

```Rust
pub fn import_tokens_internal<T>(tokens: T) -> Result<TokenStream, Error>
where
    T: Into<TokenStream>,

```

```Rust
use macro_magic_core::*
use quote::quote;

let some_ident = quote!(my_tokens);
let some_path = quote!(other_crate::exported_item);
let tokens = import_tokens_internal(quote!(let #some_ident = other_crate::ExportedItem)).unwrap();
assert_eq!(
    tokens.to_string(),
    "other_crate :: __export_tokens_tt_exported_item ! { my_tokens , \" 
    :: macro_magic :: __private :: import_tokens_inner }"
);

```

```Rust
let my_tokens: TokenStream2;

```

--------------------------------

### macro_magic_root Function

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/fn.macro_magic_root_search=u32+-%3E+bool

Provides safe access to the macro_magic root directory, respecting the MACRO_MAGIC_ROOT environment variable.

```APIDOC
## macro_magic_root

### Description
Safely access the `macro_magic` root based on the `MACRO_MAGIC_ROOT` env var, which defaults to `::macro_magic`, but can be configured via the `[env]` section of `.cargo/config.toml`.

### Method
N/A (This is a function, not an HTTP endpoint)

### Endpoint
N/A

### Parameters
None

### Request Example
N/A

### Response
#### Success Response
- **Path** (Path) - The root path for macro_magic.

#### Response Example
```
// Example usage (conceptual)
let root_path = macro_magic::macro_magic_root();
println!("Macro magic root: {}", root_path.display());
```
```

--------------------------------

### Proc Support Feature in Rust (Rust)

Source: https://docs.rs/macro_magic/latest/src/macro_magic/lib.rs_search=u32+-%3E+bool

This code snippet defines the public re-exports for the 'proc_support' feature in the rs_macro_magic project. It makes the 'syn' crate and 'TokenStream2' (from syn::__private) available when the 'proc_support' feature is enabled. This is commonly used for procedural macro development in Rust.

```rust
#[cfg(feature = "proc_support")]
    pub use syn;

    #[cfg(feature = "proc_support")]
    pub use syn::__private::TokenStream2;

```

--------------------------------

### ProcMacroType Trait Implementations

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/enum.ProcMacroType_search=u32+-%3E+bool

Details the trait implementations for the ProcMacroType enum, including Clone, Debug, PartialEq, Copy, Eq, and blanket implementations.

```APIDOC
## Trait Implementations for ProcMacroType

### `impl Clone for ProcMacroType`
#### `fn clone(&self) -> ProcMacroType`
Returns a duplicate of the value.

#### `fn clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

### `impl Debug for ProcMacroType`
#### `fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`
Formats the value using the given formatter.

### `impl PartialEq for ProcMacroType`
#### `fn eq(&self, other: &ProcMacroType) -> bool`
Tests for `self` and `other` values to be equal.

#### `fn ne(&self, other: &ProcMacroType) -> bool`
Tests for `!=`.

### `impl Copy for ProcMacroType`

### `impl Eq for ProcMacroType`

### `impl StructuralPartialEq for ProcMacroType`

### Blanket Implementations
Includes implementations for `Any`, `Borrow`, `BorrowMut`, `CloneToUninit`, `From`, `Into`, `ToOwned`, `TryFrom`, and `TryInto` for generic types.
```

--------------------------------

### Implement !Sync for ImportTokensArgs in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ImportTokensArgs_search=

Indicates that `ImportTokensArgs` does not implement the `Sync` trait, meaning it cannot be safely shared between threads.

```rust
impl !Sync for ImportTokensArgs
```

--------------------------------

### Implement TryInto for ForwardTokensArgs in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ForwardTokensArgs

Implements the `TryInto` trait for `ForwardTokensArgs`. This allows attempting to convert `ForwardTokensArgs` into another type `U`. The conversion returns a `Result` which is either `Ok(U)` on success or an error type defined by `U`'s `TryFrom` implementation on failure.

```rust
impl<T, U> TryInto<U> for T where U: TryFrom<T> {
    type Error = <U as TryFrom<T>>::Error;
    fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
}
```

--------------------------------

### Import Tokens Macros in Rust (with proc_support)

Source: https://docs.rs/macro_magic/latest/src/macro_magic/lib.rs_search=std%3A%3Avec

These macros, when the `proc_support` feature is enabled, allow importing and utilizing token streams exported by `#[export_tokens]` from other locations. They are essential for building complex macro systems.

```rust
/// Import tokens using a procedural macro call.
///
/// This macro allows you to import and use the token stream of an item
/// marked with `#[export_tokens]` within a procedural macro context.
/// Requires the `proc_support` feature.
#[proc_macro_attribute] pub fn import_tokens_proc(attr: TokenStream, item: TokenStream) -> TokenStream;

/// Import tokens using an attribute macro call.
///
/// This macro allows you to import and use the token stream of an item
/// marked with `#[export_tokens]` directly as an attribute.
/// Requires the `proc_support` feature.
#[proc_macro_attribute] pub fn import_tokens_attr(attr: TokenStream, item: TokenStream) -> TokenStream;

/// Import tokens using an attribute macro call with verbatim output.
///
/// Similar to `import_tokens_attr`, but preserves the original formatting and token details
/// of the imported tokens more accurately.
/// Requires the `proc_support` feature.
#[proc_macro_attribute] pub fn import_tokens_attr_verbatim(attr: TokenStream, item: TokenStream) -> TokenStream;

/// A macro that allows for custom parsing logic when importing tokens.
///
/// This is a more advanced macro for scenarios requiring fine-grained control over
/// how imported tokens are parsed and processed.
/// Requires the `proc_support` feature.
#[proc_macro_attribute] pub fn with_custom_parsing(attr: TokenStream, item: TokenStream) -> TokenStream;

/// Import tokens into the current scope.
///
/// This macro provides a convenient way to bring exported tokens into the current scope,
/// making them available for use. Requires the `proc_support` feature.
#[proc_macro] pub fn import_tokens(input: TokenStream) -> TokenStream;
```

--------------------------------

### Internal Function: forward_tokens_internal

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/fn.forward_tokens_internal

Provides the internal implementation for the forward_tokens macro. This function is generally not intended for direct use but is available if needed.

```APIDOC
## Function forward_tokens_internal

### Description
The internal implementation for the `forward_tokens` macro. You shouldn’t need to call this in any circumstances but it is provided just in case.

### Method
Internal Function (not directly callable via HTTP)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response
- **TokenStream**: The processed token stream.
- **Error**: An error if the processing fails.

#### Response Example
```json
{
  "result": "TokenStream or Error"
}
```
```

--------------------------------

### ImportTokensArgs Struct

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ImportTokensArgs_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Defines the structure for arguments used in parsing import_tokens_internal function arguments. It holds the tokens variable identifier and the source path.

```APIDOC
## Struct ImportTokensArgs

### Description
Used to parse the args for the `import_tokens_internal` function. You shouldn’t need to use this directly.

### Fields
- **tokens_var_ident** (Ident) - Required - The `Ident` for the `tokens` variable. Usually called `tokens` but could be something different, hence this variable.
- **source_path** (Path) - Required - The `Path` where the item we are importing can be found.
```

--------------------------------

### Generic Trait Implementations for ForwardTokensExtraArg (Rust)

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ForwardTokensExtraArg_search=u32+-%3E+bool

Showcases the blanket trait implementations for ForwardTokensExtraArg, including Any, Borrow, From, Into, Spanned, and TryFrom/TryInto. These implementations provide standard Rust functionality and interoperability, enabling ForwardTokensExtraArg to be used within the broader Rust ecosystem.

```rust
impl<T> Any for T where T: 'static + ?Sized
impl<T> Borrow<T> for T where T: ?Sized
impl<T> BorrowMut<T> for T where T: ?Sized
impl<T> From<T> for T
impl<T, U> Into<U> for T where U: From<T>
impl<T> Spanned for T where T: Spanned + ?Sized
impl<T, U> TryFrom<U> for T where U: Into<T>
impl<T, U> TryInto<U> for T where U: TryFrom<T>
```

--------------------------------

### Implement Custom Parsing for Attribute Macros in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_attr_search=

This snippet demonstrates how to implement custom parsing for attribute macros using `#[with_custom_parsing(..)]`. It requires implementing `syn::parse::Parse`, `quote::ToTokens`, and `ForeignPath` for a custom struct. The macro then uses this struct to parse custom input, making the parsed tokens available via `__custom_tokens`.

```rust
use proc_macro2::TokenStream;
use syn::{parse_macro_input, Item};
use syn::parse::Parse;
use quote::ToTokens;

// Assume ForeignPath trait and #[import_tokens_attr] are defined elsewhere
// trait ForeignPath { fn foreign_path(&self) -> &syn::Path; }
// #[proc_macro_attribute] fn import_tokens_attr(attr: TokenStream, tokens: TokenStream) -> TokenStream { /* ... */ }

#[derive(syn::Parse)]
struct MyCustomParsing {
    foreign_path: syn::Path,
    _comma: syn::token::Comma,
    custom_path: syn::Path,
}

impl ToTokens for MyCustomParsing {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(self.foreign_path.to_token_stream());
        tokens.extend(self._comma.to_token_stream());
        tokens.extend(self.custom_path.to_token_stream());
    }
}

impl ForeignPath for MyCustomParsing {
    fn foreign_path(&self) -> &syn::Path {
        &self.foreign_path
    }
}

#[proc_macro_attribute]
pub fn my_attribute(attr: TokenStream, tokens: TokenStream) -> TokenStream {
    let external_item = parse_macro_input!(attr as Item);
    let attached_item = parse_macro_input!(tokens as Item);
    let custom_parsed_item = parse_macro_input!(__custom_tokens as MyCustomParsing);
    // ... implementation using custom_parsed_item and __source_path if needed
    TokenStream::new() // Placeholder
}

// Usage example:
// #[my_attribute(foreign::path, some_other::path)]
// struct SomeItem {}
```

--------------------------------

### Import Tokens Macro (Procedural)

Source: https://docs.rs/macro_magic/latest/src/macro_magic/lib.rs_search=u32+-%3E+bool

The #[import_tokens_proc] macro allows importing the tokens of an external item for use in procedural macro definitions. This requires the 'proc_support' feature.

```rust
/// Imports tokens from an item marked with `#[export_tokens]` for use in procedural macros.
///
/// This macro requires the `proc_support` feature to be enabled.
///
/// # Examples
///
/// ```rust
/// #[macro_magic::export_tokens]
/// fn my_helper_macro_logic() {
///     println!("Hello from imported logic!");
/// }
///
/// #[macro_magic::import_tokens_proc(my_helper_macro_logic)]
/// macro_rules! call_imported_logic {
///     () => {
///         my_helper_macro_logic!(); // Macros can now be called
///     };
/// }
///
/// call_imported_logic!();
/// ```
#[cfg(feature = "proc_support")]
pub use macro_magic_macros::import_tokens_proc;
```

--------------------------------

### Implement TryFrom for ForwardTokensArgs in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ForwardTokensArgs

Implements the `TryFrom` trait for `ForwardTokensArgs`. This allows attempting to convert from a type `U` into `ForwardTokensArgs`. The conversion returns a `Result` which is either `Ok(ForwardTokensArgs)` on success or an `Infallible` error on failure.

```rust
impl<T, U> TryFrom<U> for T where U: Into<T> {
    type Error = Infallible;
    fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
}
```

--------------------------------

### Custom Parsing Implementation in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/attr.import_tokens_attr

Defines a custom parsing struct `MyCustomParsing` that implements `syn::parse::Parse`, `quote::ToTokens`, and `ForeignPath`. This allows attribute macros to accept custom arguments for determining foreign paths. It's used in conjunction with `#[import_tokens_attr]` and `#[with_custom_parsing]` within a proc macro crate.

```rust
#[derive(Parse)]
struct MyCustomParsing {
    foreign_path: syn::Path,
    _comma: syn::token::Comma,
    custom_path: syn::Path,
}

impl ToTokens for MyCustomParsing {
    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
        tokens.extend(self.foreign_path.to_token_stream());
        tokens.extend(self._comma.to_token_stream());
        tokens.extend(self.custom_path.to_token_stream());
    }
}

impl ForeignPath for MyCustomParsing {
    fn foreign_path(&self) -> &syn::Path {
        &self.foreign_path
    }
}
#[import_tokens_attr]
#[with_custom_parsing(MyCustomParsing)]
#[proc_macro_attribute]
pub fn my_attribute(attr: TokenStream, tokens: TokenStream) -> TokenStream {
    let external_item = parse_macro_input!(attr as Item);
    let attached_item = parse_macro_input!(tokens as Item);
    let custom_parsed_item = parse_macro_input!(__custom_tokens as MyCustomParsing);
    // ...
}
```

--------------------------------

### Implement Freeze for ImportTokensArgs in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/struct.ImportTokensArgs_search=

Demonstrates the implementation of the `Freeze` auto trait for `ImportTokensArgs`. This indicates that the struct can be safely frozen (made immutable) across threads.

```rust
impl Freeze for ImportTokensArgs
```

--------------------------------

### Implement Internal Token Importing Logic in Rust

Source: https://docs.rs/macro_magic/latest/macro_magic/mm_core/fn.import_tokens_internal_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides the internal implementation for the `import_tokens` macro. This function can be used directly within other procedural macros to leverage `import_tokens` functionality. It expects a `TokenStream2` that can be parsed into `ImportTokensArgs`, representing a `let` variable declaration pointing to an `#[export_tokens]` item.

```rust
pub fn import_tokens_internal<T>(tokens: T) -> Result<TokenStream, Error>
where
    T: Into<TokenStream>,

```

```rust
use macro_magic_core::*
use quote::quote;

let some_ident = quote!(my_tokens);
let some_path = quote!(other_crate::exported_item);
let tokens = import_tokens_internal(quote!(let #some_ident = other_crate::ExportedItem)).unwrap();
assert_eq!(
    tokens.to_string(),
    "other_crate :: __export_tokens_tt_exported_item ! { my_tokens , \" :: macro_magic :: __private :: import_tokens_inner }"
);

// If these tokens were emitted as part of a proc macro, they would expand to a variable declaration like:
// let my_tokens: TokenStream2;
// where `my_tokens` contains the tokens of `ExportedItem`.

```

--------------------------------

### Import Tokens Macros in Rust (with proc_support)

Source: https://docs.rs/macro_magic/latest/src/macro_magic/lib.rs_search=

These macros (`import_tokens`, `import_tokens_attr`, `import_tokens_proc`, `with_custom_parsing`) require the `proc_support` feature to be enabled. They allow importing tokens from exported items.

```rust
#[cfg(feature = "proc_support")]
pub use macro_magic_macros::{
    import_tokens, import_tokens_attr, import_tokens_attr_verbatim, import_tokens_proc,
    with_custom_parsing,
};
```
Tokens:
Raw