Struct GenericsWithWhere 

pub struct GenericsWithWhere {
    pub generics: Generics,
}

A GenericsWithWhere struct to handle the parsing of Rust generics with an explicit where clause.

This wrapper addresses the limitation in the syn crate where parsing Generics directly from a ParseStream does not automatically handle associated where clauses. By integrating where clause parsing into the GenericsWithWhere, this struct provides a seamless way to capture both the generics and their constraints in scenarios where the where clause is crucial for type constraints and bounds in Rust macros and code generation.

Usage :

let parsed_generics: macro_tools ::generic_params ::GenericsWithWhere
= syn ::parse_str( "< T: Clone, U: Default = Default1 > where T: Default" ).unwrap();
assert!( parsed_generics.generics.params.len() == 2 );
assert!( parsed_generics.generics.where_clause.is_some() );

Fields

generics: Generics

Syn’s generics parameters.

Implementations

impl GenericsWithWhere

pub fn unwrap(self) -> Generics

Unwraps the GenericsWithWhere to retrieve the inner syn ::Generics.

pub fn parse_from_str(s: &str) -> Result<GenericsWithWhere>

Parses a string to a GenericsWithWhere, specifically designed to handle generics syntax with where clauses effectively.

This function provides a convenient way to parse generic parameters and their associated where clauses from a string slice, returning a GenericsWithWhere instance.

Arguments

• s - The string slice containing the generics and optional where clause (e.g., "< T: Debug > where T: Default").

Returns

Returns a syn ::Result which is Ok(GenericsWithWhere) on successful parsing, or Err(syn ::Error) if the input string does not conform to valid Rust generics syntax.

Errors

Returns a syn ::Error if the input string s cannot be parsed as valid Rust generics or a where clause.

Examples

use macro_tools ::generic_params ::GenericsWithWhere;

let parsed = GenericsWithWhere ::parse_from_str( "< T: Clone, U: Default = Default1 > where T: Default" ).unwrap();
assert!( parsed.generics.params.len() == 2 );
assert!( parsed.generics.where_clause.is_some() );

let parsed_no_where = GenericsWithWhere ::parse_from_str( "< T >" ).unwrap();
assert!( parsed_no_where.generics.params.len() == 1 );
assert!( parsed_no_where.generics.where_clause.is_none() );

let parsed_only_where = GenericsWithWhere ::parse_from_str( "where T: Debug" ).unwrap();
assert!( parsed_only_where.generics.params.is_empty() );
assert!( parsed_only_where.generics.where_clause.is_some() );

Trait Implementations

impl Debug for GenericsWithWhere

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Generics> for GenericsWithWhere

fn from(generics: Generics) -> Self

Converts to this type from the input type.

impl From<GenericsWithWhere> for Generics

fn from(g: GenericsWithWhere) -> Self

Converts to this type from the input type.

impl Parse for GenericsWithWhere

fn parse(input: ParseStream<'_>) -> Result<Self>

impl ToTokens for GenericsWithWhere

fn to_tokens(&self, tokens: &mut TokenStream)

Write self to the given TokenStream.

fn to_token_stream(&self) -> TokenStream

Convert self directly into a TokenStream object.

fn into_token_stream(self) -> TokenStream

where Self: Sized,

Convert self directly into a TokenStream object.