syn/
generics.rs

Help
1use super::*;
2use crate::punctuated::{Iter, IterMut, Punctuated};
3#[cfg(all(feature = "printing", feature = "extra-traits"))]
4use std::fmt::{self, Debug};
5#[cfg(all(feature = "printing", feature = "extra-traits"))]
6use std::hash::{Hash, Hasher};
7
8ast_struct! {
9    /// Lifetimes and type parameters attached to a declaration of a function,
10    /// enum, trait, etc.
11    ///
12    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
13    /// feature.*
14    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
15    pub struct Generics {
16        pub lt_token: Option<Token![<]>,
17        pub params: Punctuated<GenericParam, Token![,]>,
18        pub gt_token: Option<Token![>]>,
19        pub where_clause: Option<WhereClause>,
20    }
21}
22
23ast_enum_of_structs! {
24    /// A generic type parameter, lifetime, or const generic: `T: Into<String>`,
25    /// `'a: 'b`, `const LEN: usize`.
26    ///
27    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
28    /// feature.*
29    ///
30    /// # Syntax tree enum
31    ///
32    /// This type is a [syntax tree enum].
33    ///
34    /// [syntax tree enum]: Expr#syntax-tree-enums
35    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
36    pub enum GenericParam {
37        /// A generic type parameter: `T: Into<String>`.
38        Type(TypeParam),
39
40        /// A lifetime definition: `'a: 'b + 'c + 'd`.
41        Lifetime(LifetimeDef),
42
43        /// A const generic parameter: `const LENGTH: usize`.
44        Const(ConstParam),
45    }
46}
47
48ast_struct! {
49    /// A generic type parameter: `T: Into<String>`.
50    ///
51    /// *This type is available only if Syn is built with the `"derive"` or
52    /// `"full"` feature.*
53    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
54    pub struct TypeParam {
55        pub attrs: Vec<Attribute>,
56        pub ident: Ident,
57        pub colon_token: Option<Token![:]>,
58        pub bounds: Punctuated<TypeParamBound, Token![+]>,
59        pub eq_token: Option<Token![=]>,
60        pub default: Option<Type>,
61    }
62}
63
64ast_struct! {
65    /// A lifetime definition: `'a: 'b + 'c + 'd`.
66    ///
67    /// *This type is available only if Syn is built with the `"derive"` or
68    /// `"full"` feature.*
69    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
70    pub struct LifetimeDef {
71        pub attrs: Vec<Attribute>,
72        pub lifetime: Lifetime,
73        pub colon_token: Option<Token![:]>,
74        pub bounds: Punctuated<Lifetime, Token![+]>,
75    }
76}
77
78ast_struct! {
79    /// A const generic parameter: `const LENGTH: usize`.
80    ///
81    /// *This type is available only if Syn is built with the `"derive"` or
82    /// `"full"` feature.*
83    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
84    pub struct ConstParam {
85        pub attrs: Vec<Attribute>,
86        pub const_token: Token![const],
87        pub ident: Ident,
88        pub colon_token: Token![:],
89        pub ty: Type,
90        pub eq_token: Option<Token![=]>,
91        pub default: Option<Expr>,
92    }
93}
94
95impl Default for Generics {
96    fn default() -> Self {
97        Generics {
98            lt_token: None,
99            params: Punctuated::new(),
100            gt_token: None,
101            where_clause: None,
102        }
103    }
104}
105
106impl Generics {
107    /// Returns an
108    /// <code
109    ///   style="padding-right:0;">Iterator&lt;Item = &amp;</code><a
110    ///   href="struct.TypeParam.html"><code
111    ///   style="padding-left:0;padding-right:0;">TypeParam</code></a><code
112    ///   style="padding-left:0;">&gt;</code>
113    /// over the type parameters in `self.params`.
114    pub fn type_params(&self) -> TypeParams {
115        TypeParams(self.params.iter())
116    }
117
118    /// Returns an
119    /// <code
120    ///   style="padding-right:0;">Iterator&lt;Item = &amp;mut </code><a
121    ///   href="struct.TypeParam.html"><code
122    ///   style="padding-left:0;padding-right:0;">TypeParam</code></a><code
123    ///   style="padding-left:0;">&gt;</code>
124    /// over the type parameters in `self.params`.
125    pub fn type_params_mut(&mut self) -> TypeParamsMut {
126        TypeParamsMut(self.params.iter_mut())
127    }
128
129    /// Returns an
130    /// <code
131    ///   style="padding-right:0;">Iterator&lt;Item = &amp;</code><a
132    ///   href="struct.LifetimeDef.html"><code
133    ///   style="padding-left:0;padding-right:0;">LifetimeDef</code></a><code
134    ///   style="padding-left:0;">&gt;</code>
135    /// over the lifetime parameters in `self.params`.
136    pub fn lifetimes(&self) -> Lifetimes {
137        Lifetimes(self.params.iter())
138    }
139
140    /// Returns an
141    /// <code
142    ///   style="padding-right:0;">Iterator&lt;Item = &amp;mut </code><a
143    ///   href="struct.LifetimeDef.html"><code
144    ///   style="padding-left:0;padding-right:0;">LifetimeDef</code></a><code
145    ///   style="padding-left:0;">&gt;</code>
146    /// over the lifetime parameters in `self.params`.
147    pub fn lifetimes_mut(&mut self) -> LifetimesMut {
148        LifetimesMut(self.params.iter_mut())
149    }
150
151    /// Returns an
152    /// <code
153    ///   style="padding-right:0;">Iterator&lt;Item = &amp;</code><a
154    ///   href="struct.ConstParam.html"><code
155    ///   style="padding-left:0;padding-right:0;">ConstParam</code></a><code
156    ///   style="padding-left:0;">&gt;</code>
157    /// over the constant parameters in `self.params`.
158    pub fn const_params(&self) -> ConstParams {
159        ConstParams(self.params.iter())
160    }
161
162    /// Returns an
163    /// <code
164    ///   style="padding-right:0;">Iterator&lt;Item = &amp;mut </code><a
165    ///   href="struct.ConstParam.html"><code
166    ///   style="padding-left:0;padding-right:0;">ConstParam</code></a><code
167    ///   style="padding-left:0;">&gt;</code>
168    /// over the constant parameters in `self.params`.
169    pub fn const_params_mut(&mut self) -> ConstParamsMut {
170        ConstParamsMut(self.params.iter_mut())
171    }
172
173    /// Initializes an empty `where`-clause if there is not one present already.
174    pub fn make_where_clause(&mut self) -> &mut WhereClause {
175        self.where_clause.get_or_insert_with(|| WhereClause {
176            where_token: <Token![where]>::default(),
177            predicates: Punctuated::new(),
178        })
179    }
180}
181
182pub struct TypeParams<'a>(Iter<'a, GenericParam>);
183
184impl<'a> Iterator for TypeParams<'a> {
185    type Item = &'a TypeParam;
186
187    fn next(&mut self) -> Option<Self::Item> {
188        let next = match self.0.next() {
189            Some(item) => item,
190            None => return None,
191        };
192        if let GenericParam::Type(type_param) = next {
193            Some(type_param)
194        } else {
195            self.next()
196        }
197    }
198}
199
200pub struct TypeParamsMut<'a>(IterMut<'a, GenericParam>);
201
202impl<'a> Iterator for TypeParamsMut<'a> {
203    type Item = &'a mut TypeParam;
204
205    fn next(&mut self) -> Option<Self::Item> {
206        let next = match self.0.next() {
207            Some(item) => item,
208            None => return None,
209        };
210        if let GenericParam::Type(type_param) = next {
211            Some(type_param)
212        } else {
213            self.next()
214        }
215    }
216}
217
218pub struct Lifetimes<'a>(Iter<'a, GenericParam>);
219
220impl<'a> Iterator for Lifetimes<'a> {
221    type Item = &'a LifetimeDef;
222
223    fn next(&mut self) -> Option<Self::Item> {
224        let next = match self.0.next() {
225            Some(item) => item,
226            None => return None,
227        };
228        if let GenericParam::Lifetime(lifetime) = next {
229            Some(lifetime)
230        } else {
231            self.next()
232        }
233    }
234}
235
236pub struct LifetimesMut<'a>(IterMut<'a, GenericParam>);
237
238impl<'a> Iterator for LifetimesMut<'a> {
239    type Item = &'a mut LifetimeDef;
240
241    fn next(&mut self) -> Option<Self::Item> {
242        let next = match self.0.next() {
243            Some(item) => item,
244            None => return None,
245        };
246        if let GenericParam::Lifetime(lifetime) = next {
247            Some(lifetime)
248        } else {
249            self.next()
250        }
251    }
252}
253
254pub struct ConstParams<'a>(Iter<'a, GenericParam>);
255
256impl<'a> Iterator for ConstParams<'a> {
257    type Item = &'a ConstParam;
258
259    fn next(&mut self) -> Option<Self::Item> {
260        let next = match self.0.next() {
261            Some(item) => item,
262            None => return None,
263        };
264        if let GenericParam::Const(const_param) = next {
265            Some(const_param)
266        } else {
267            self.next()
268        }
269    }
270}
271
272pub struct ConstParamsMut<'a>(IterMut<'a, GenericParam>);
273
274impl<'a> Iterator for ConstParamsMut<'a> {
275    type Item = &'a mut ConstParam;
276
277    fn next(&mut self) -> Option<Self::Item> {
278        let next = match self.0.next() {
279            Some(item) => item,
280            None => return None,
281        };
282        if let GenericParam::Const(const_param) = next {
283            Some(const_param)
284        } else {
285            self.next()
286        }
287    }
288}
289
290/// Returned by `Generics::split_for_impl`.
291///
292/// *This type is available only if Syn is built with the `"derive"` or `"full"`
293/// feature and the `"printing"` feature.*
294#[cfg(feature = "printing")]
295#[cfg_attr(
296    doc_cfg,
297    doc(cfg(all(any(feature = "full", feature = "derive"), feature = "printing")))
298)]
299pub struct ImplGenerics<'a>(&'a Generics);
300
301/// Returned by `Generics::split_for_impl`.
302///
303/// *This type is available only if Syn is built with the `"derive"` or `"full"`
304/// feature and the `"printing"` feature.*
305#[cfg(feature = "printing")]
306#[cfg_attr(
307    doc_cfg,
308    doc(cfg(all(any(feature = "full", feature = "derive"), feature = "printing")))
309)]
310pub struct TypeGenerics<'a>(&'a Generics);
311
312/// Returned by `TypeGenerics::as_turbofish`.
313///
314/// *This type is available only if Syn is built with the `"derive"` or `"full"`
315/// feature and the `"printing"` feature.*
316#[cfg(feature = "printing")]
317#[cfg_attr(
318    doc_cfg,
319    doc(cfg(all(any(feature = "full", feature = "derive"), feature = "printing")))
320)]
321pub struct Turbofish<'a>(&'a Generics);
322
323#[cfg(feature = "printing")]
324impl Generics {
325    /// Split a type's generics into the pieces required for impl'ing a trait
326    /// for that type.
327    ///
328    /// ```
329    /// # use proc_macro2::{Span, Ident};
330    /// # use quote::quote;
331    /// #
332    /// # let generics: syn::Generics = Default::default();
333    /// # let name = Ident::new("MyType", Span::call_site());
334    /// #
335    /// let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
336    /// quote! {
337    ///     impl #impl_generics MyTrait for #name #ty_generics #where_clause {
338    ///         // ...
339    ///     }
340    /// }
341    /// # ;
342    /// ```
343    ///
344    /// *This method is available only if Syn is built with the `"derive"` or
345    /// `"full"` feature and the `"printing"` feature.*
346    #[cfg_attr(
347        doc_cfg,
348        doc(cfg(all(any(feature = "full", feature = "derive"), feature = "printing")))
349    )]
350    pub fn split_for_impl(&self) -> (ImplGenerics, TypeGenerics, Option<&WhereClause>) {
351        (
352            ImplGenerics(self),
353            TypeGenerics(self),
354            self.where_clause.as_ref(),
355        )
356    }
357}
358
359#[cfg(feature = "printing")]
360macro_rules! generics_wrapper_impls {
361    ($ty:ident) => {
362        #[cfg(feature = "clone-impls")]
363        #[cfg_attr(doc_cfg, doc(cfg(feature = "clone-impls")))]
364        impl<'a> Clone for $ty<'a> {
365            fn clone(&self) -> Self {
366                $ty(self.0)
367            }
368        }
369
370        #[cfg(feature = "extra-traits")]
371        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
372        impl<'a> Debug for $ty<'a> {
373            fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
374                formatter
375                    .debug_tuple(stringify!($ty))
376                    .field(self.0)
377                    .finish()
378            }
379        }
380
381        #[cfg(feature = "extra-traits")]
382        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
383        impl<'a> Eq for $ty<'a> {}
384
385        #[cfg(feature = "extra-traits")]
386        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
387        impl<'a> PartialEq for $ty<'a> {
388            fn eq(&self, other: &Self) -> bool {
389                self.0 == other.0
390            }
391        }
392
393        #[cfg(feature = "extra-traits")]
394        #[cfg_attr(doc_cfg, doc(cfg(feature = "extra-traits")))]
395        impl<'a> Hash for $ty<'a> {
396            fn hash<H: Hasher>(&self, state: &mut H) {
397                self.0.hash(state);
398            }
399        }
400    };
401}
402
403#[cfg(feature = "printing")]
404generics_wrapper_impls!(ImplGenerics);
405#[cfg(feature = "printing")]
406generics_wrapper_impls!(TypeGenerics);
407#[cfg(feature = "printing")]
408generics_wrapper_impls!(Turbofish);
409
410#[cfg(feature = "printing")]
411impl<'a> TypeGenerics<'a> {
412    /// Turn a type's generics like `<X, Y>` into a turbofish like `::<X, Y>`.
413    ///
414    /// *This method is available only if Syn is built with the `"derive"` or
415    /// `"full"` feature and the `"printing"` feature.*
416    pub fn as_turbofish(&self) -> Turbofish {
417        Turbofish(self.0)
418    }
419}
420
421ast_struct! {
422    /// A set of bound lifetimes: `for<'a, 'b, 'c>`.
423    ///
424    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
425    /// feature.*
426    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
427    pub struct BoundLifetimes {
428        pub for_token: Token![for],
429        pub lt_token: Token![<],
430        pub lifetimes: Punctuated<LifetimeDef, Token![,]>,
431        pub gt_token: Token![>],
432    }
433}
434
435impl Default for BoundLifetimes {
436    fn default() -> Self {
437        BoundLifetimes {
438            for_token: Default::default(),
439            lt_token: Default::default(),
440            lifetimes: Punctuated::new(),
441            gt_token: Default::default(),
442        }
443    }
444}
445
446impl LifetimeDef {
447    pub fn new(lifetime: Lifetime) -> Self {
448        LifetimeDef {
449            attrs: Vec::new(),
450            lifetime,
451            colon_token: None,
452            bounds: Punctuated::new(),
453        }
454    }
455}
456
457impl From<Ident> for TypeParam {
458    fn from(ident: Ident) -> Self {
459        TypeParam {
460            attrs: vec![],
461            ident,
462            colon_token: None,
463            bounds: Punctuated::new(),
464            eq_token: None,
465            default: None,
466        }
467    }
468}
469
470ast_enum_of_structs! {
471    /// A trait or lifetime used as a bound on a type parameter.
472    ///
473    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
474    /// feature.*
475    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
476    pub enum TypeParamBound {
477        Trait(TraitBound),
478        Lifetime(Lifetime),
479    }
480}
481
482ast_struct! {
483    /// A trait used as a bound on a type parameter.
484    ///
485    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
486    /// feature.*
487    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
488    pub struct TraitBound {
489        pub paren_token: Option<token::Paren>,
490        pub modifier: TraitBoundModifier,
491        /// The `for<'a>` in `for<'a> Foo<&'a T>`
492        pub lifetimes: Option<BoundLifetimes>,
493        /// The `Foo<&'a T>` in `for<'a> Foo<&'a T>`
494        pub path: Path,
495    }
496}
497
498ast_enum! {
499    /// A modifier on a trait bound, currently only used for the `?` in
500    /// `?Sized`.
501    ///
502    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
503    /// feature.*
504    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
505    pub enum TraitBoundModifier {
506        None,
507        Maybe(Token![?]),
508    }
509}
510
511ast_struct! {
512    /// A `where` clause in a definition: `where T: Deserialize<'de>, D:
513    /// 'static`.
514    ///
515    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
516    /// feature.*
517    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
518    pub struct WhereClause {
519        pub where_token: Token![where],
520        pub predicates: Punctuated<WherePredicate, Token![,]>,
521    }
522}
523
524ast_enum_of_structs! {
525    /// A single predicate in a `where` clause: `T: Deserialize<'de>`.
526    ///
527    /// *This type is available only if Syn is built with the `"derive"` or `"full"`
528    /// feature.*
529    ///
530    /// # Syntax tree enum
531    ///
532    /// This type is a [syntax tree enum].
533    ///
534    /// [syntax tree enum]: Expr#syntax-tree-enums
535    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
536    pub enum WherePredicate {
537        /// A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`.
538        Type(PredicateType),
539
540        /// A lifetime predicate in a `where` clause: `'a: 'b + 'c`.
541        Lifetime(PredicateLifetime),
542
543        /// An equality predicate in a `where` clause (unsupported).
544        Eq(PredicateEq),
545    }
546}
547
548ast_struct! {
549    /// A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`.
550    ///
551    /// *This type is available only if Syn is built with the `"derive"` or
552    /// `"full"` feature.*
553    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
554    pub struct PredicateType {
555        /// Any lifetimes from a `for` binding
556        pub lifetimes: Option<BoundLifetimes>,
557        /// The type being bounded
558        pub bounded_ty: Type,
559        pub colon_token: Token![:],
560        /// Trait and lifetime bounds (`Clone+Send+'static`)
561        pub bounds: Punctuated<TypeParamBound, Token![+]>,
562    }
563}
564
565ast_struct! {
566    /// A lifetime predicate in a `where` clause: `'a: 'b + 'c`.
567    ///
568    /// *This type is available only if Syn is built with the `"derive"` or
569    /// `"full"` feature.*
570    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
571    pub struct PredicateLifetime {
572        pub lifetime: Lifetime,
573        pub colon_token: Token![:],
574        pub bounds: Punctuated<Lifetime, Token![+]>,
575    }
576}
577
578ast_struct! {
579    /// An equality predicate in a `where` clause (unsupported).
580    ///
581    /// *This type is available only if Syn is built with the `"derive"` or
582    /// `"full"` feature.*
583    #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
584    pub struct PredicateEq {
585        pub lhs_ty: Type,
586        pub eq_token: Token![=],
587        pub rhs_ty: Type,
588    }
589}
590
591#[cfg(feature = "parsing")]
592pub mod parsing {
593    use super::*;
594    use crate::ext::IdentExt;
595    use crate::parse::{Parse, ParseStream, Result};
596
597    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
598    impl Parse for Generics {
599        fn parse(input: ParseStream) -> Result<Self> {
600            if !input.peek(Token![<]) {
601                return Ok(Generics::default());
602            }
603
604            let lt_token: Token![<] = input.parse()?;
605
606            let mut params = Punctuated::new();
607            loop {
608                if input.peek(Token![>]) {
609                    break;
610                }
611
612                let attrs = input.call(Attribute::parse_outer)?;
613                let lookahead = input.lookahead1();
614                if lookahead.peek(Lifetime) {
615                    params.push_value(GenericParam::Lifetime(LifetimeDef {
616                        attrs,
617                        ..input.parse()?
618                    }));
619                } else if lookahead.peek(Ident) {
620                    params.push_value(GenericParam::Type(TypeParam {
621                        attrs,
622                        ..input.parse()?
623                    }));
624                } else if lookahead.peek(Token![const]) {
625                    params.push_value(GenericParam::Const(ConstParam {
626                        attrs,
627                        ..input.parse()?
628                    }));
629                } else if input.peek(Token![_]) {
630                    params.push_value(GenericParam::Type(TypeParam {
631                        attrs,
632                        ident: input.call(Ident::parse_any)?,
633                        colon_token: None,
634                        bounds: Punctuated::new(),
635                        eq_token: None,
636                        default: None,
637                    }));
638                } else {
639                    return Err(lookahead.error());
640                }
641
642                if input.peek(Token![>]) {
643                    break;
644                }
645                let punct = input.parse()?;
646                params.push_punct(punct);
647            }
648
649            let gt_token: Token![>] = input.parse()?;
650
651            Ok(Generics {
652                lt_token: Some(lt_token),
653                params,
654                gt_token: Some(gt_token),
655                where_clause: None,
656            })
657        }
658    }
659
660    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
661    impl Parse for GenericParam {
662        fn parse(input: ParseStream) -> Result<Self> {
663            let attrs = input.call(Attribute::parse_outer)?;
664
665            let lookahead = input.lookahead1();
666            if lookahead.peek(Ident) {
667                Ok(GenericParam::Type(TypeParam {
668                    attrs,
669                    ..input.parse()?
670                }))
671            } else if lookahead.peek(Lifetime) {
672                Ok(GenericParam::Lifetime(LifetimeDef {
673                    attrs,
674                    ..input.parse()?
675                }))
676            } else if lookahead.peek(Token![const]) {
677                Ok(GenericParam::Const(ConstParam {
678                    attrs,
679                    ..input.parse()?
680                }))
681            } else {
682                Err(lookahead.error())
683            }
684        }
685    }
686
687    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
688    impl Parse for LifetimeDef {
689        fn parse(input: ParseStream) -> Result<Self> {
690            let has_colon;
691            Ok(LifetimeDef {
692                attrs: input.call(Attribute::parse_outer)?,
693                lifetime: input.parse()?,
694                colon_token: {
695                    if input.peek(Token![:]) {
696                        has_colon = true;
697                        Some(input.parse()?)
698                    } else {
699                        has_colon = false;
700                        None
701                    }
702                },
703                bounds: {
704                    let mut bounds = Punctuated::new();
705                    if has_colon {
706                        loop {
707                            if input.peek(Token![,]) || input.peek(Token![>]) {
708                                break;
709                            }
710                            let value = input.parse()?;
711                            bounds.push_value(value);
712                            if !input.peek(Token![+]) {
713                                break;
714                            }
715                            let punct = input.parse()?;
716                            bounds.push_punct(punct);
717                        }
718                    }
719                    bounds
720                },
721            })
722        }
723    }
724
725    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
726    impl Parse for BoundLifetimes {
727        fn parse(input: ParseStream) -> Result<Self> {
728            Ok(BoundLifetimes {
729                for_token: input.parse()?,
730                lt_token: input.parse()?,
731                lifetimes: {
732                    let mut lifetimes = Punctuated::new();
733                    while !input.peek(Token![>]) {
734                        lifetimes.push_value(input.parse()?);
735                        if input.peek(Token![>]) {
736                            break;
737                        }
738                        lifetimes.push_punct(input.parse()?);
739                    }
740                    lifetimes
741                },
742                gt_token: input.parse()?,
743            })
744        }
745    }
746
747    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
748    impl Parse for Option<BoundLifetimes> {
749        fn parse(input: ParseStream) -> Result<Self> {
750            if input.peek(Token![for]) {
751                input.parse().map(Some)
752            } else {
753                Ok(None)
754            }
755        }
756    }
757
758    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
759    impl Parse for TypeParam {
760        fn parse(input: ParseStream) -> Result<Self> {
761            let attrs = input.call(Attribute::parse_outer)?;
762            let ident: Ident = input.parse()?;
763            let colon_token: Option<Token![:]> = input.parse()?;
764
765            let begin_bound = input.fork();
766            let mut is_maybe_const = false;
767            let mut bounds = Punctuated::new();
768            if colon_token.is_some() {
769                loop {
770                    if input.peek(Token![,]) || input.peek(Token![>]) || input.peek(Token![=]) {
771                        break;
772                    }
773                    if input.peek(Token![~]) && input.peek2(Token![const]) {
774                        input.parse::<Token![~]>()?;
775                        input.parse::<Token![const]>()?;
776                        is_maybe_const = true;
777                    }
778                    let value: TypeParamBound = input.parse()?;
779                    bounds.push_value(value);
780                    if !input.peek(Token![+]) {
781                        break;
782                    }
783                    let punct: Token![+] = input.parse()?;
784                    bounds.push_punct(punct);
785                }
786            }
787
788            let mut eq_token: Option<Token![=]> = input.parse()?;
789            let mut default = if eq_token.is_some() {
790                Some(input.parse::<Type>()?)
791            } else {
792                None
793            };
794
795            if is_maybe_const {
796                bounds.clear();
797                eq_token = None;
798                default = Some(Type::Verbatim(verbatim::between(begin_bound, input)));
799            }
800
801            Ok(TypeParam {
802                attrs,
803                ident,
804                colon_token,
805                bounds,
806                eq_token,
807                default,
808            })
809        }
810    }
811
812    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
813    impl Parse for TypeParamBound {
814        fn parse(input: ParseStream) -> Result<Self> {
815            if input.peek(Lifetime) {
816                return input.parse().map(TypeParamBound::Lifetime);
817            }
818
819            if input.peek(token::Paren) {
820                let content;
821                let paren_token = parenthesized!(content in input);
822                let mut bound: TraitBound = content.parse()?;
823                bound.paren_token = Some(paren_token);
824                return Ok(TypeParamBound::Trait(bound));
825            }
826
827            input.parse().map(TypeParamBound::Trait)
828        }
829    }
830
831    impl TypeParamBound {
832        pub(crate) fn parse_multiple(
833            input: ParseStream,
834            allow_plus: bool,
835        ) -> Result<Punctuated<Self, Token![+]>> {
836            let mut bounds = Punctuated::new();
837            loop {
838                bounds.push_value(input.parse()?);
839                if !(allow_plus && input.peek(Token![+])) {
840                    break;
841                }
842                bounds.push_punct(input.parse()?);
843                if !(input.peek(Ident::peek_any)
844                    || input.peek(Token![::])
845                    || input.peek(Token![?])
846                    || input.peek(Lifetime)
847                    || input.peek(token::Paren))
848                {
849                    break;
850                }
851            }
852            Ok(bounds)
853        }
854    }
855
856    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
857    impl Parse for TraitBound {
858        fn parse(input: ParseStream) -> Result<Self> {
859            #[cfg(feature = "full")]
860            let tilde_const = if input.peek(Token![~]) && input.peek2(Token![const]) {
861                let tilde_token = input.parse::<Token![~]>()?;
862                let const_token = input.parse::<Token![const]>()?;
863                Some((tilde_token, const_token))
864            } else {
865                None
866            };
867
868            let modifier: TraitBoundModifier = input.parse()?;
869            let lifetimes: Option<BoundLifetimes> = input.parse()?;
870
871            let mut path: Path = input.parse()?;
872            if path.segments.last().unwrap().arguments.is_empty()
873                && (input.peek(token::Paren) || input.peek(Token![::]) && input.peek3(token::Paren))
874            {
875                input.parse::<Option<Token![::]>>()?;
876                let args: ParenthesizedGenericArguments = input.parse()?;
877                let parenthesized = PathArguments::Parenthesized(args);
878                path.segments.last_mut().unwrap().arguments = parenthesized;
879            }
880
881            #[cfg(feature = "full")]
882            {
883                if let Some((tilde_token, const_token)) = tilde_const {
884                    path.segments.insert(
885                        0,
886                        PathSegment {
887                            ident: Ident::new("const", const_token.span),
888                            arguments: PathArguments::None,
889                        },
890                    );
891                    let (_const, punct) = path.segments.pairs_mut().next().unwrap().into_tuple();
892                    *punct.unwrap() = Token![::](tilde_token.span);
893                }
894            }
895
896            Ok(TraitBound {
897                paren_token: None,
898                modifier,
899                lifetimes,
900                path,
901            })
902        }
903    }
904
905    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
906    impl Parse for TraitBoundModifier {
907        fn parse(input: ParseStream) -> Result<Self> {
908            if input.peek(Token![?]) {
909                input.parse().map(TraitBoundModifier::Maybe)
910            } else {
911                Ok(TraitBoundModifier::None)
912            }
913        }
914    }
915
916    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
917    impl Parse for ConstParam {
918        fn parse(input: ParseStream) -> Result<Self> {
919            let mut default = None;
920            Ok(ConstParam {
921                attrs: input.call(Attribute::parse_outer)?,
922                const_token: input.parse()?,
923                ident: input.parse()?,
924                colon_token: input.parse()?,
925                ty: input.parse()?,
926                eq_token: {
927                    if input.peek(Token![=]) {
928                        let eq_token = input.parse()?;
929                        default = Some(path::parsing::const_argument(input)?);
930                        Some(eq_token)
931                    } else {
932                        None
933                    }
934                },
935                default,
936            })
937        }
938    }
939
940    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
941    impl Parse for WhereClause {
942        fn parse(input: ParseStream) -> Result<Self> {
943            Ok(WhereClause {
944                where_token: input.parse()?,
945                predicates: {
946                    let mut predicates = Punctuated::new();
947                    loop {
948                        if input.is_empty()
949                            || input.peek(token::Brace)
950                            || input.peek(Token![,])
951                            || input.peek(Token![;])
952                            || input.peek(Token![:]) && !input.peek(Token![::])
953                            || input.peek(Token![=])
954                        {
955                            break;
956                        }
957                        let value = input.parse()?;
958                        predicates.push_value(value);
959                        if !input.peek(Token![,]) {
960                            break;
961                        }
962                        let punct = input.parse()?;
963                        predicates.push_punct(punct);
964                    }
965                    predicates
966                },
967            })
968        }
969    }
970
971    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
972    impl Parse for Option<WhereClause> {
973        fn parse(input: ParseStream) -> Result<Self> {
974            if input.peek(Token![where]) {
975                input.parse().map(Some)
976            } else {
977                Ok(None)
978            }
979        }
980    }
981
982    #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
983    impl Parse for WherePredicate {
984        fn parse(input: ParseStream) -> Result<Self> {
985            if input.peek(Lifetime) && input.peek2(Token![:]) {
986                Ok(WherePredicate::Lifetime(PredicateLifetime {
987                    lifetime: input.parse()?,
988                    colon_token: input.parse()?,
989                    bounds: {
990                        let mut bounds = Punctuated::new();
991                        loop {
992                            if input.is_empty()
993                                || input.peek(token::Brace)
994                                || input.peek(Token![,])
995                                || input.peek(Token![;])
996                                || input.peek(Token![:])
997                                || input.peek(Token![=])
998                            {
999                                break;
1000                            }
1001                            let value = input.parse()?;
1002                            bounds.push_value(value);
1003                            if !input.peek(Token![+]) {
1004                                break;
1005                            }
1006                            let punct = input.parse()?;
1007                            bounds.push_punct(punct);
1008                        }
1009                        bounds
1010                    },
1011                }))
1012            } else {
1013                Ok(WherePredicate::Type(PredicateType {
1014                    lifetimes: input.parse()?,
1015                    bounded_ty: input.parse()?,
1016                    colon_token: input.parse()?,
1017                    bounds: {
1018                        let mut bounds = Punctuated::new();
1019                        loop {
1020                            if input.is_empty()
1021                                || input.peek(token::Brace)
1022                                || input.peek(Token![,])
1023                                || input.peek(Token![;])
1024                                || input.peek(Token![:]) && !input.peek(Token![::])
1025                                || input.peek(Token![=])
1026                            {
1027                                break;
1028                            }
1029                            let value = input.parse()?;
1030                            bounds.push_value(value);
1031                            if !input.peek(Token![+]) {
1032                                break;
1033                            }
1034                            let punct = input.parse()?;
1035                            bounds.push_punct(punct);
1036                        }
1037                        bounds
1038                    },
1039                }))
1040            }
1041        }
1042    }
1043}
1044
1045#[cfg(feature = "printing")]
1046mod printing {
1047    use super::*;
1048    use crate::attr::FilterAttrs;
1049    use crate::print::TokensOrDefault;
1050    #[cfg(feature = "full")]
1051    use crate::punctuated::Pair;
1052    use proc_macro2::TokenStream;
1053    #[cfg(feature = "full")]
1054    use proc_macro2::TokenTree;
1055    use quote::{ToTokens, TokenStreamExt};
1056
1057    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1058    impl ToTokens for Generics {
1059        fn to_tokens(&self, tokens: &mut TokenStream) {
1060            if self.params.is_empty() {
1061                return;
1062            }
1063
1064            TokensOrDefault(&self.lt_token).to_tokens(tokens);
1065
1066            // Print lifetimes before types and consts, regardless of their
1067            // order in self.params.
1068            //
1069            // TODO: ordering rules for const parameters vs type parameters have
1070            // not been settled yet. https://github.com/rust-lang/rust/issues/44580
1071            let mut trailing_or_empty = true;
1072            for param in self.params.pairs() {
1073                if let GenericParam::Lifetime(_) = **param.value() {
1074                    param.to_tokens(tokens);
1075                    trailing_or_empty = param.punct().is_some();
1076                }
1077            }
1078            for param in self.params.pairs() {
1079                match **param.value() {
1080                    GenericParam::Type(_) | GenericParam::Const(_) => {
1081                        if !trailing_or_empty {
1082                            <Token![,]>::default().to_tokens(tokens);
1083                            trailing_or_empty = true;
1084                        }
1085                        param.to_tokens(tokens);
1086                    }
1087                    GenericParam::Lifetime(_) => {}
1088                }
1089            }
1090
1091            TokensOrDefault(&self.gt_token).to_tokens(tokens);
1092        }
1093    }
1094
1095    impl<'a> ToTokens for ImplGenerics<'a> {
1096        fn to_tokens(&self, tokens: &mut TokenStream) {
1097            if self.0.params.is_empty() {
1098                return;
1099            }
1100
1101            TokensOrDefault(&self.0.lt_token).to_tokens(tokens);
1102
1103            // Print lifetimes before types and consts, regardless of their
1104            // order in self.params.
1105            //
1106            // TODO: ordering rules for const parameters vs type parameters have
1107            // not been settled yet. https://github.com/rust-lang/rust/issues/44580
1108            let mut trailing_or_empty = true;
1109            for param in self.0.params.pairs() {
1110                if let GenericParam::Lifetime(_) = **param.value() {
1111                    param.to_tokens(tokens);
1112                    trailing_or_empty = param.punct().is_some();
1113                }
1114            }
1115            for param in self.0.params.pairs() {
1116                if let GenericParam::Lifetime(_) = **param.value() {
1117                    continue;
1118                }
1119                if !trailing_or_empty {
1120                    <Token![,]>::default().to_tokens(tokens);
1121                    trailing_or_empty = true;
1122                }
1123                match *param.value() {
1124                    GenericParam::Lifetime(_) => unreachable!(),
1125                    GenericParam::Type(param) => {
1126                        // Leave off the type parameter defaults
1127                        tokens.append_all(param.attrs.outer());
1128                        param.ident.to_tokens(tokens);
1129                        if !param.bounds.is_empty() {
1130                            TokensOrDefault(&param.colon_token).to_tokens(tokens);
1131                            param.bounds.to_tokens(tokens);
1132                        }
1133                    }
1134                    GenericParam::Const(param) => {
1135                        // Leave off the const parameter defaults
1136                        tokens.append_all(param.attrs.outer());
1137                        param.const_token.to_tokens(tokens);
1138                        param.ident.to_tokens(tokens);
1139                        param.colon_token.to_tokens(tokens);
1140                        param.ty.to_tokens(tokens);
1141                    }
1142                }
1143                param.punct().to_tokens(tokens);
1144            }
1145
1146            TokensOrDefault(&self.0.gt_token).to_tokens(tokens);
1147        }
1148    }
1149
1150    impl<'a> ToTokens for TypeGenerics<'a> {
1151        fn to_tokens(&self, tokens: &mut TokenStream) {
1152            if self.0.params.is_empty() {
1153                return;
1154            }
1155
1156            TokensOrDefault(&self.0.lt_token).to_tokens(tokens);
1157
1158            // Print lifetimes before types and consts, regardless of their
1159            // order in self.params.
1160            //
1161            // TODO: ordering rules for const parameters vs type parameters have
1162            // not been settled yet. https://github.com/rust-lang/rust/issues/44580
1163            let mut trailing_or_empty = true;
1164            for param in self.0.params.pairs() {
1165                if let GenericParam::Lifetime(def) = *param.value() {
1166                    // Leave off the lifetime bounds and attributes
1167                    def.lifetime.to_tokens(tokens);
1168                    param.punct().to_tokens(tokens);
1169                    trailing_or_empty = param.punct().is_some();
1170                }
1171            }
1172            for param in self.0.params.pairs() {
1173                if let GenericParam::Lifetime(_) = **param.value() {
1174                    continue;
1175                }
1176                if !trailing_or_empty {
1177                    <Token![,]>::default().to_tokens(tokens);
1178                    trailing_or_empty = true;
1179                }
1180                match *param.value() {
1181                    GenericParam::Lifetime(_) => unreachable!(),
1182                    GenericParam::Type(param) => {
1183                        // Leave off the type parameter defaults
1184                        param.ident.to_tokens(tokens);
1185                    }
1186                    GenericParam::Const(param) => {
1187                        // Leave off the const parameter defaults
1188                        param.ident.to_tokens(tokens);
1189                    }
1190                }
1191                param.punct().to_tokens(tokens);
1192            }
1193
1194            TokensOrDefault(&self.0.gt_token).to_tokens(tokens);
1195        }
1196    }
1197
1198    impl<'a> ToTokens for Turbofish<'a> {
1199        fn to_tokens(&self, tokens: &mut TokenStream) {
1200            if !self.0.params.is_empty() {
1201                <Token![::]>::default().to_tokens(tokens);
1202                TypeGenerics(self.0).to_tokens(tokens);
1203            }
1204        }
1205    }
1206
1207    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1208    impl ToTokens for BoundLifetimes {
1209        fn to_tokens(&self, tokens: &mut TokenStream) {
1210            self.for_token.to_tokens(tokens);
1211            self.lt_token.to_tokens(tokens);
1212            self.lifetimes.to_tokens(tokens);
1213            self.gt_token.to_tokens(tokens);
1214        }
1215    }
1216
1217    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1218    impl ToTokens for LifetimeDef {
1219        fn to_tokens(&self, tokens: &mut TokenStream) {
1220            tokens.append_all(self.attrs.outer());
1221            self.lifetime.to_tokens(tokens);
1222            if !self.bounds.is_empty() {
1223                TokensOrDefault(&self.colon_token).to_tokens(tokens);
1224                self.bounds.to_tokens(tokens);
1225            }
1226        }
1227    }
1228
1229    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1230    impl ToTokens for TypeParam {
1231        fn to_tokens(&self, tokens: &mut TokenStream) {
1232            tokens.append_all(self.attrs.outer());
1233            self.ident.to_tokens(tokens);
1234            if !self.bounds.is_empty() {
1235                TokensOrDefault(&self.colon_token).to_tokens(tokens);
1236                self.bounds.to_tokens(tokens);
1237            }
1238            if let Some(default) = &self.default {
1239                #[cfg(feature = "full")]
1240                {
1241                    if self.eq_token.is_none() {
1242                        if let Type::Verbatim(default) = default {
1243                            let mut iter = default.clone().into_iter().peekable();
1244                            while let Some(token) = iter.next() {
1245                                if let TokenTree::Punct(q) = token {
1246                                    if q.as_char() == '~' {
1247                                        if let Some(TokenTree::Ident(c)) = iter.peek() {
1248                                            if c == "const" {
1249                                                if self.bounds.is_empty() {
1250                                                    TokensOrDefault(&self.colon_token)
1251                                                        .to_tokens(tokens);
1252                                                }
1253                                                return default.to_tokens(tokens);
1254                                            }
1255                                        }
1256                                    }
1257                                }
1258                            }
1259                        }
1260                    }
1261                }
1262                TokensOrDefault(&self.eq_token).to_tokens(tokens);
1263                default.to_tokens(tokens);
1264            }
1265        }
1266    }
1267
1268    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1269    impl ToTokens for TraitBound {
1270        fn to_tokens(&self, tokens: &mut TokenStream) {
1271            let to_tokens = |tokens: &mut TokenStream| {
1272                #[cfg(feature = "full")]
1273                let skip = match self.path.segments.pairs().next() {
1274                    Some(Pair::Punctuated(t, p)) if t.ident == "const" => {
1275                        Token![~](p.spans[0]).to_tokens(tokens);
1276                        t.to_tokens(tokens);
1277                        1
1278                    }
1279                    _ => 0,
1280                };
1281                self.modifier.to_tokens(tokens);
1282                self.lifetimes.to_tokens(tokens);
1283                #[cfg(feature = "full")]
1284                {
1285                    self.path.leading_colon.to_tokens(tokens);
1286                    tokens.append_all(self.path.segments.pairs().skip(skip));
1287                }
1288                #[cfg(not(feature = "full"))]
1289                {
1290                    self.path.to_tokens(tokens);
1291                }
1292            };
1293            match &self.paren_token {
1294                Some(paren) => paren.surround(tokens, to_tokens),
1295                None => to_tokens(tokens),
1296            }
1297        }
1298    }
1299
1300    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1301    impl ToTokens for TraitBoundModifier {
1302        fn to_tokens(&self, tokens: &mut TokenStream) {
1303            match self {
1304                TraitBoundModifier::None => {}
1305                TraitBoundModifier::Maybe(t) => t.to_tokens(tokens),
1306            }
1307        }
1308    }
1309
1310    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1311    impl ToTokens for ConstParam {
1312        fn to_tokens(&self, tokens: &mut TokenStream) {
1313            tokens.append_all(self.attrs.outer());
1314            self.const_token.to_tokens(tokens);
1315            self.ident.to_tokens(tokens);
1316            self.colon_token.to_tokens(tokens);
1317            self.ty.to_tokens(tokens);
1318            if let Some(default) = &self.default {
1319                TokensOrDefault(&self.eq_token).to_tokens(tokens);
1320                default.to_tokens(tokens);
1321            }
1322        }
1323    }
1324
1325    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1326    impl ToTokens for WhereClause {
1327        fn to_tokens(&self, tokens: &mut TokenStream) {
1328            if !self.predicates.is_empty() {
1329                self.where_token.to_tokens(tokens);
1330                self.predicates.to_tokens(tokens);
1331            }
1332        }
1333    }
1334
1335    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1336    impl ToTokens for PredicateType {
1337        fn to_tokens(&self, tokens: &mut TokenStream) {
1338            self.lifetimes.to_tokens(tokens);
1339            self.bounded_ty.to_tokens(tokens);
1340            self.colon_token.to_tokens(tokens);
1341            self.bounds.to_tokens(tokens);
1342        }
1343    }
1344
1345    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1346    impl ToTokens for PredicateLifetime {
1347        fn to_tokens(&self, tokens: &mut TokenStream) {
1348            self.lifetime.to_tokens(tokens);
1349            self.colon_token.to_tokens(tokens);
1350            self.bounds.to_tokens(tokens);
1351        }
1352    }
1353
1354    #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
1355    impl ToTokens for PredicateEq {
1356        fn to_tokens(&self, tokens: &mut TokenStream) {
1357            self.lhs_ty.to_tokens(tokens);
1358            self.eq_token.to_tokens(tokens);
1359            self.rhs_ty.to_tokens(tokens);
1360        }
1361    }
1362}
syn/generics.rs

syn/
generics.rs
