syn/
ty.rs

1use crate::attr::Attribute;
2use crate::expr::Expr;
3use crate::generics::{BoundLifetimes, TypeParamBound};
4use crate::ident::Ident;
5use crate::lifetime::Lifetime;
6use crate::lit::LitStr;
7use crate::mac::Macro;
8use crate::path::{Path, QSelf};
9use crate::punctuated::Punctuated;
10use crate::token;
11use proc_macro2::TokenStream;
12
13ast_enum_of_structs! {
14    /// The possible types that a Rust value could have.
15    ///
16    /// # Syntax tree enum
17    ///
18    /// This type is a [syntax tree enum].
19    ///
20    /// [syntax tree enum]: crate::expr::Expr#syntax-tree-enums
21    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
22    #[non_exhaustive]
23    pub enum Type {
24        /// A fixed size array type: `[T; n]`.
25        Array(TypeArray),
26
27        /// A bare function type: `fn(usize) -> bool`.
28        BareFn(TypeBareFn),
29
30        /// A type contained within invisible delimiters.
31        Group(TypeGroup),
32
33        /// An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or
34        /// a lifetime.
35        ImplTrait(TypeImplTrait),
36
37        /// Indication that a type should be inferred by the compiler: `_`.
38        Infer(TypeInfer),
39
40        /// A macro in the type position.
41        Macro(TypeMacro),
42
43        /// The never type: `!`.
44        Never(TypeNever),
45
46        /// A parenthesized type equivalent to the inner type.
47        Paren(TypeParen),
48
49        /// A path like `std::slice::Iter`, optionally qualified with a
50        /// self-type as in `<Vec<T> as SomeTrait>::Associated`.
51        Path(TypePath),
52
53        /// A raw pointer type: `*const T` or `*mut T`.
54        Ptr(TypePtr),
55
56        /// A reference type: `&'a T` or `&'a mut T`.
57        Reference(TypeReference),
58
59        /// A dynamically sized slice type: `[T]`.
60        Slice(TypeSlice),
61
62        /// A trait object type `dyn Bound1 + Bound2 + Bound3` where `Bound` is a
63        /// trait or a lifetime.
64        TraitObject(TypeTraitObject),
65
66        /// A tuple type: `(A, B, C, String)`.
67        Tuple(TypeTuple),
68
69        /// Tokens in type position not interpreted by Syn.
70        Verbatim(TokenStream),
71
72        // For testing exhaustiveness in downstream code, use the following idiom:
73        //
74        //     match ty {
75        //         #![cfg_attr(test, deny(non_exhaustive_omitted_patterns))]
76        //
77        //         Type::Array(ty) => {...}
78        //         Type::BareFn(ty) => {...}
79        //         ...
80        //         Type::Verbatim(ty) => {...}
81        //
82        //         _ => { /* some sane fallback */ }
83        //     }
84        //
85        // This way we fail your tests but don't break your library when adding
86        // a variant. You will be notified by a test failure when a variant is
87        // added, so that you can add code to handle it, but your library will
88        // continue to compile and work for downstream users in the interim.
89    }
90}
91
92ast_struct! {
93    /// A fixed size array type: `[T; n]`.
94    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
95    pub struct TypeArray {
96        pub bracket_token: token::Bracket,
97        pub elem: Box<Type>,
98        pub semi_token: Token![;],
99        pub len: Expr,
100    }
101}
102
103ast_struct! {
104    /// A bare function type: `fn(usize) -> bool`.
105    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
106    pub struct TypeBareFn {
107        pub lifetimes: Option<BoundLifetimes>,
108        pub unsafety: Option<Token![unsafe]>,
109        pub abi: Option<Abi>,
110        pub fn_token: Token![fn],
111        pub paren_token: token::Paren,
112        pub inputs: Punctuated<BareFnArg, Token![,]>,
113        pub variadic: Option<BareVariadic>,
114        pub output: ReturnType,
115    }
116}
117
118ast_struct! {
119    /// A type contained within invisible delimiters.
120    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
121    pub struct TypeGroup {
122        pub group_token: token::Group,
123        pub elem: Box<Type>,
124    }
125}
126
127ast_struct! {
128    /// An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or
129    /// a lifetime.
130    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
131    pub struct TypeImplTrait {
132        pub impl_token: Token![impl],
133        pub bounds: Punctuated<TypeParamBound, Token![+]>,
134    }
135}
136
137ast_struct! {
138    /// Indication that a type should be inferred by the compiler: `_`.
139    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
140    pub struct TypeInfer {
141        pub underscore_token: Token![_],
142    }
143}
144
145ast_struct! {
146    /// A macro in the type position.
147    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
148    pub struct TypeMacro {
149        pub mac: Macro,
150    }
151}
152
153ast_struct! {
154    /// The never type: `!`.
155    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
156    pub struct TypeNever {
157        pub bang_token: Token![!],
158    }
159}
160
161ast_struct! {
162    /// A parenthesized type equivalent to the inner type.
163    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
164    pub struct TypeParen {
165        pub paren_token: token::Paren,
166        pub elem: Box<Type>,
167    }
168}
169
170ast_struct! {
171    /// A path like `std::slice::Iter`, optionally qualified with a
172    /// self-type as in `<Vec<T> as SomeTrait>::Associated`.
173    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
174    pub struct TypePath {
175        pub qself: Option<QSelf>,
176        pub path: Path,
177    }
178}
179
180ast_struct! {
181    /// A raw pointer type: `*const T` or `*mut T`.
182    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
183    pub struct TypePtr {
184        pub star_token: Token![*],
185        pub const_token: Option<Token![const]>,
186        pub mutability: Option<Token![mut]>,
187        pub elem: Box<Type>,
188    }
189}
190
191ast_struct! {
192    /// A reference type: `&'a T` or `&'a mut T`.
193    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
194    pub struct TypeReference {
195        pub and_token: Token![&],
196        pub lifetime: Option<Lifetime>,
197        pub mutability: Option<Token![mut]>,
198        pub elem: Box<Type>,
199    }
200}
201
202ast_struct! {
203    /// A dynamically sized slice type: `[T]`.
204    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
205    pub struct TypeSlice {
206        pub bracket_token: token::Bracket,
207        pub elem: Box<Type>,
208    }
209}
210
211ast_struct! {
212    /// A trait object type `dyn Bound1 + Bound2 + Bound3` where `Bound` is a
213    /// trait or a lifetime.
214    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
215    pub struct TypeTraitObject {
216        pub dyn_token: Option<Token![dyn]>,
217        pub bounds: Punctuated<TypeParamBound, Token![+]>,
218    }
219}
220
221ast_struct! {
222    /// A tuple type: `(A, B, C, String)`.
223    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
224    pub struct TypeTuple {
225        pub paren_token: token::Paren,
226        pub elems: Punctuated<Type, Token![,]>,
227    }
228}
229
230ast_struct! {
231    /// The binary interface of a function: `extern "C"`.
232    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
233    pub struct Abi {
234        pub extern_token: Token![extern],
235        pub name: Option<LitStr>,
236    }
237}
238
239ast_struct! {
240    /// An argument in a function type: the `usize` in `fn(usize) -> bool`.
241    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
242    pub struct BareFnArg {
243        pub attrs: Vec<Attribute>,
244        pub name: Option<(Ident, Token![:])>,
245        pub ty: Type,
246    }
247}
248
249ast_struct! {
250    /// The variadic argument of a function pointer like `fn(usize, ...)`.
251    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
252    pub struct BareVariadic {
253        pub attrs: Vec<Attribute>,
254        pub name: Option<(Ident, Token![:])>,
255        pub dots: Token![...],
256        pub comma: Option<Token![,]>,
257    }
258}
259
260ast_enum! {
261    /// Return type of a function signature.
262    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
263    pub enum ReturnType {
264        /// Return type is not specified.
265        ///
266        /// Functions default to `()` and closures default to type inference.
267        Default,
268        /// A particular type is returned.
269        Type(Token![->], Box<Type>),
270    }
271}
272
273#[cfg(feature = "parsing")]
274pub(crate) mod parsing {
275    use crate::attr::Attribute;
276    use crate::error::{self, Result};
277    use crate::ext::IdentExt as _;
278    use crate::generics::{BoundLifetimes, TraitBound, TraitBoundModifier, TypeParamBound};
279    use crate::ident::Ident;
280    use crate::lifetime::Lifetime;
281    use crate::mac::{self, Macro};
282    use crate::parse::{Parse, ParseStream};
283    use crate::path;
284    use crate::path::{Path, PathArguments, QSelf};
285    use crate::punctuated::Punctuated;
286    use crate::token;
287    use crate::ty::{
288        Abi, BareFnArg, BareVariadic, ReturnType, Type, TypeArray, TypeBareFn, TypeGroup,
289        TypeImplTrait, TypeInfer, TypeMacro, TypeNever, TypeParen, TypePath, TypePtr,
290        TypeReference, TypeSlice, TypeTraitObject, TypeTuple,
291    };
292    use crate::verbatim;
293    use proc_macro2::Span;
294
295    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
296    impl Parse for Type {
297        fn parse(input: ParseStream) -> Result<Self> {
298            let allow_plus = true;
299            let allow_group_generic = true;
300            ambig_ty(input, allow_plus, allow_group_generic)
301        }
302    }
303
304    impl Type {
305        /// In some positions, types may not contain the `+` character, to
306        /// disambiguate them. For example in the expression `1 as T`, T may not
307        /// contain a `+` character.
308        ///
309        /// This parser does not allow a `+`, while the default parser does.
310        #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
311        pub fn without_plus(input: ParseStream) -> Result<Self> {
312            let allow_plus = false;
313            let allow_group_generic = true;
314            ambig_ty(input, allow_plus, allow_group_generic)
315        }
316    }
317
318    pub(crate) fn ambig_ty(
319        input: ParseStream,
320        allow_plus: bool,
321        allow_group_generic: bool,
322    ) -> Result<Type> {
323        let begin = input.fork();
324
325        if input.peek(token::Group) {
326            let mut group: TypeGroup = input.parse()?;
327            if input.peek(Token![::]) && input.peek3(Ident::peek_any) {
328                if let Type::Path(mut ty) = *group.elem {
329                    Path::parse_rest(input, &mut ty.path, false)?;
330                    return Ok(Type::Path(ty));
331                } else {
332                    return Ok(Type::Path(TypePath {
333                        qself: Some(QSelf {
334                            lt_token: Token![<](group.group_token.span),
335                            position: 0,
336                            as_token: None,
337                            gt_token: Token![>](group.group_token.span),
338                            ty: group.elem,
339                        }),
340                        path: Path::parse_helper(input, false)?,
341                    }));
342                }
343            } else if input.peek(Token![<]) && allow_group_generic
344                || input.peek(Token![::]) && input.peek3(Token![<])
345            {
346                if let Type::Path(mut ty) = *group.elem {
347                    let arguments = &mut ty.path.segments.last_mut().unwrap().arguments;
348                    if arguments.is_none() {
349                        *arguments = PathArguments::AngleBracketed(input.parse()?);
350                        Path::parse_rest(input, &mut ty.path, false)?;
351                        return Ok(Type::Path(ty));
352                    } else {
353                        group.elem = Box::new(Type::Path(ty));
354                    }
355                }
356            }
357            return Ok(Type::Group(group));
358        }
359
360        let mut lifetimes = None::<BoundLifetimes>;
361        let mut lookahead = input.lookahead1();
362        if lookahead.peek(Token![for]) {
363            lifetimes = input.parse()?;
364            lookahead = input.lookahead1();
365            if !lookahead.peek(Ident)
366                && !lookahead.peek(Token![fn])
367                && !lookahead.peek(Token![unsafe])
368                && !lookahead.peek(Token![extern])
369                && !lookahead.peek(Token![super])
370                && !lookahead.peek(Token![self])
371                && !lookahead.peek(Token![Self])
372                && !lookahead.peek(Token![crate])
373                || input.peek(Token![dyn])
374            {
375                return Err(lookahead.error());
376            }
377        }
378
379        if lookahead.peek(token::Paren) {
380            let content;
381            let paren_token = parenthesized!(content in input);
382            if content.is_empty() {
383                return Ok(Type::Tuple(TypeTuple {
384                    paren_token,
385                    elems: Punctuated::new(),
386                }));
387            }
388            if content.peek(Lifetime) {
389                return Ok(Type::Paren(TypeParen {
390                    paren_token,
391                    elem: Box::new(Type::TraitObject(content.parse()?)),
392                }));
393            }
394            if content.peek(Token![?]) {
395                return Ok(Type::TraitObject(TypeTraitObject {
396                    dyn_token: None,
397                    bounds: {
398                        let mut bounds = Punctuated::new();
399                        bounds.push_value(TypeParamBound::Trait(TraitBound {
400                            paren_token: Some(paren_token),
401                            ..content.parse()?
402                        }));
403                        while let Some(plus) = input.parse()? {
404                            bounds.push_punct(plus);
405                            bounds.push_value({
406                                let allow_precise_capture = false;
407                                let allow_tilde_const = false;
408                                TypeParamBound::parse_single(
409                                    input,
410                                    allow_precise_capture,
411                                    allow_tilde_const,
412                                )?
413                            });
414                        }
415                        bounds
416                    },
417                }));
418            }
419            let mut first: Type = content.parse()?;
420            if content.peek(Token![,]) {
421                return Ok(Type::Tuple(TypeTuple {
422                    paren_token,
423                    elems: {
424                        let mut elems = Punctuated::new();
425                        elems.push_value(first);
426                        elems.push_punct(content.parse()?);
427                        while !content.is_empty() {
428                            elems.push_value(content.parse()?);
429                            if content.is_empty() {
430                                break;
431                            }
432                            elems.push_punct(content.parse()?);
433                        }
434                        elems
435                    },
436                }));
437            }
438            if allow_plus && input.peek(Token![+]) {
439                loop {
440                    let first = match first {
441                        Type::Path(TypePath { qself: None, path }) => {
442                            TypeParamBound::Trait(TraitBound {
443                                paren_token: Some(paren_token),
444                                modifier: TraitBoundModifier::None,
445                                lifetimes: None,
446                                path,
447                            })
448                        }
449                        Type::TraitObject(TypeTraitObject {
450                            dyn_token: None,
451                            bounds,
452                        }) => {
453                            if bounds.len() > 1 || bounds.trailing_punct() {
454                                first = Type::TraitObject(TypeTraitObject {
455                                    dyn_token: None,
456                                    bounds,
457                                });
458                                break;
459                            }
460                            match bounds.into_iter().next().unwrap() {
461                                TypeParamBound::Trait(trait_bound) => {
462                                    TypeParamBound::Trait(TraitBound {
463                                        paren_token: Some(paren_token),
464                                        ..trait_bound
465                                    })
466                                }
467                                other @ (TypeParamBound::Lifetime(_)
468                                | TypeParamBound::PreciseCapture(_)
469                                | TypeParamBound::Verbatim(_)) => other,
470                            }
471                        }
472                        _ => break,
473                    };
474                    return Ok(Type::TraitObject(TypeTraitObject {
475                        dyn_token: None,
476                        bounds: {
477                            let mut bounds = Punctuated::new();
478                            bounds.push_value(first);
479                            while let Some(plus) = input.parse()? {
480                                bounds.push_punct(plus);
481                                bounds.push_value({
482                                    let allow_precise_capture = false;
483                                    let allow_tilde_const = false;
484                                    TypeParamBound::parse_single(
485                                        input,
486                                        allow_precise_capture,
487                                        allow_tilde_const,
488                                    )?
489                                });
490                            }
491                            bounds
492                        },
493                    }));
494                }
495            }
496            Ok(Type::Paren(TypeParen {
497                paren_token,
498                elem: Box::new(first),
499            }))
500        } else if lookahead.peek(Token![fn])
501            || lookahead.peek(Token![unsafe])
502            || lookahead.peek(Token![extern])
503        {
504            let mut bare_fn: TypeBareFn = input.parse()?;
505            bare_fn.lifetimes = lifetimes;
506            Ok(Type::BareFn(bare_fn))
507        } else if lookahead.peek(Ident)
508            || input.peek(Token![super])
509            || input.peek(Token![self])
510            || input.peek(Token![Self])
511            || input.peek(Token![crate])
512            || lookahead.peek(Token![::])
513            || lookahead.peek(Token![<])
514        {
515            let ty: TypePath = input.parse()?;
516            if ty.qself.is_some() {
517                return Ok(Type::Path(ty));
518            }
519
520            if input.peek(Token![!]) && !input.peek(Token![!=]) && ty.path.is_mod_style() {
521                let bang_token: Token![!] = input.parse()?;
522                let (delimiter, tokens) = mac::parse_delimiter(input)?;
523                return Ok(Type::Macro(TypeMacro {
524                    mac: Macro {
525                        path: ty.path,
526                        bang_token,
527                        delimiter,
528                        tokens,
529                    },
530                }));
531            }
532
533            if lifetimes.is_some() || allow_plus && input.peek(Token![+]) {
534                let mut bounds = Punctuated::new();
535                bounds.push_value(TypeParamBound::Trait(TraitBound {
536                    paren_token: None,
537                    modifier: TraitBoundModifier::None,
538                    lifetimes,
539                    path: ty.path,
540                }));
541                if allow_plus {
542                    while input.peek(Token![+]) {
543                        bounds.push_punct(input.parse()?);
544                        if !(input.peek(Ident::peek_any)
545                            || input.peek(Token![::])
546                            || input.peek(Token![?])
547                            || input.peek(Lifetime)
548                            || input.peek(token::Paren))
549                        {
550                            break;
551                        }
552                        bounds.push_value({
553                            let allow_precise_capture = false;
554                            let allow_tilde_const = false;
555                            TypeParamBound::parse_single(
556                                input,
557                                allow_precise_capture,
558                                allow_tilde_const,
559                            )?
560                        });
561                    }
562                }
563                return Ok(Type::TraitObject(TypeTraitObject {
564                    dyn_token: None,
565                    bounds,
566                }));
567            }
568
569            Ok(Type::Path(ty))
570        } else if lookahead.peek(Token![dyn]) {
571            let dyn_token: Token![dyn] = input.parse()?;
572            let dyn_span = dyn_token.span;
573            let star_token: Option<Token![*]> = input.parse()?;
574            let bounds = TypeTraitObject::parse_bounds(dyn_span, input, allow_plus)?;
575            return Ok(if star_token.is_some() {
576                Type::Verbatim(verbatim::between(&begin, input))
577            } else {
578                Type::TraitObject(TypeTraitObject {
579                    dyn_token: Some(dyn_token),
580                    bounds,
581                })
582            });
583        } else if lookahead.peek(token::Bracket) {
584            let content;
585            let bracket_token = bracketed!(content in input);
586            let elem: Type = content.parse()?;
587            if content.peek(Token![;]) {
588                Ok(Type::Array(TypeArray {
589                    bracket_token,
590                    elem: Box::new(elem),
591                    semi_token: content.parse()?,
592                    len: content.parse()?,
593                }))
594            } else {
595                Ok(Type::Slice(TypeSlice {
596                    bracket_token,
597                    elem: Box::new(elem),
598                }))
599            }
600        } else if lookahead.peek(Token![*]) {
601            input.parse().map(Type::Ptr)
602        } else if lookahead.peek(Token![&]) {
603            input.parse().map(Type::Reference)
604        } else if lookahead.peek(Token![!]) && !input.peek(Token![=]) {
605            input.parse().map(Type::Never)
606        } else if lookahead.peek(Token![impl]) {
607            TypeImplTrait::parse(input, allow_plus).map(Type::ImplTrait)
608        } else if lookahead.peek(Token![_]) {
609            input.parse().map(Type::Infer)
610        } else if lookahead.peek(Lifetime) {
611            input.parse().map(Type::TraitObject)
612        } else {
613            Err(lookahead.error())
614        }
615    }
616
617    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
618    impl Parse for TypeSlice {
619        fn parse(input: ParseStream) -> Result<Self> {
620            let content;
621            Ok(TypeSlice {
622                bracket_token: bracketed!(content in input),
623                elem: content.parse()?,
624            })
625        }
626    }
627
628    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
629    impl Parse for TypeArray {
630        fn parse(input: ParseStream) -> Result<Self> {
631            let content;
632            Ok(TypeArray {
633                bracket_token: bracketed!(content in input),
634                elem: content.parse()?,
635                semi_token: content.parse()?,
636                len: content.parse()?,
637            })
638        }
639    }
640
641    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
642    impl Parse for TypePtr {
643        fn parse(input: ParseStream) -> Result<Self> {
644            let star_token: Token![*] = input.parse()?;
645
646            let lookahead = input.lookahead1();
647            let (const_token, mutability) = if lookahead.peek(Token![const]) {
648                (Some(input.parse()?), None)
649            } else if lookahead.peek(Token![mut]) {
650                (None, Some(input.parse()?))
651            } else {
652                return Err(lookahead.error());
653            };
654
655            Ok(TypePtr {
656                star_token,
657                const_token,
658                mutability,
659                elem: Box::new(input.call(Type::without_plus)?),
660            })
661        }
662    }
663
664    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
665    impl Parse for TypeReference {
666        fn parse(input: ParseStream) -> Result<Self> {
667            Ok(TypeReference {
668                and_token: input.parse()?,
669                lifetime: input.parse()?,
670                mutability: input.parse()?,
671                // & binds tighter than +, so we don't allow + here.
672                elem: Box::new(input.call(Type::without_plus)?),
673            })
674        }
675    }
676
677    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
678    impl Parse for TypeBareFn {
679        fn parse(input: ParseStream) -> Result<Self> {
680            let args;
681            let mut variadic = None;
682
683            Ok(TypeBareFn {
684                lifetimes: input.parse()?,
685                unsafety: input.parse()?,
686                abi: input.parse()?,
687                fn_token: input.parse()?,
688                paren_token: parenthesized!(args in input),
689                inputs: {
690                    let mut inputs = Punctuated::new();
691
692                    while !args.is_empty() {
693                        let attrs = args.call(Attribute::parse_outer)?;
694
695                        if inputs.empty_or_trailing()
696                            && (args.peek(Token![...])
697                                || (args.peek(Ident) || args.peek(Token![_]))
698                                    && args.peek2(Token![:])
699                                    && args.peek3(Token![...]))
700                        {
701                            variadic = Some(parse_bare_variadic(&args, attrs)?);
702                            break;
703                        }
704
705                        let allow_self = inputs.is_empty();
706                        let arg = parse_bare_fn_arg(&args, allow_self)?;
707                        inputs.push_value(BareFnArg { attrs, ..arg });
708                        if args.is_empty() {
709                            break;
710                        }
711
712                        let comma = args.parse()?;
713                        inputs.push_punct(comma);
714                    }
715
716                    inputs
717                },
718                variadic,
719                output: input.call(ReturnType::without_plus)?,
720            })
721        }
722    }
723
724    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
725    impl Parse for TypeNever {
726        fn parse(input: ParseStream) -> Result<Self> {
727            Ok(TypeNever {
728                bang_token: input.parse()?,
729            })
730        }
731    }
732
733    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
734    impl Parse for TypeInfer {
735        fn parse(input: ParseStream) -> Result<Self> {
736            Ok(TypeInfer {
737                underscore_token: input.parse()?,
738            })
739        }
740    }
741
742    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
743    impl Parse for TypeTuple {
744        fn parse(input: ParseStream) -> Result<Self> {
745            let content;
746            let paren_token = parenthesized!(content in input);
747
748            if content.is_empty() {
749                return Ok(TypeTuple {
750                    paren_token,
751                    elems: Punctuated::new(),
752                });
753            }
754
755            let first: Type = content.parse()?;
756            Ok(TypeTuple {
757                paren_token,
758                elems: {
759                    let mut elems = Punctuated::new();
760                    elems.push_value(first);
761                    elems.push_punct(content.parse()?);
762                    while !content.is_empty() {
763                        elems.push_value(content.parse()?);
764                        if content.is_empty() {
765                            break;
766                        }
767                        elems.push_punct(content.parse()?);
768                    }
769                    elems
770                },
771            })
772        }
773    }
774
775    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
776    impl Parse for TypeMacro {
777        fn parse(input: ParseStream) -> Result<Self> {
778            Ok(TypeMacro {
779                mac: input.parse()?,
780            })
781        }
782    }
783
784    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
785    impl Parse for TypePath {
786        fn parse(input: ParseStream) -> Result<Self> {
787            let expr_style = false;
788            let (qself, path) = path::parsing::qpath(input, expr_style)?;
789            Ok(TypePath { qself, path })
790        }
791    }
792
793    impl ReturnType {
794        #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
795        pub fn without_plus(input: ParseStream) -> Result<Self> {
796            let allow_plus = false;
797            Self::parse(input, allow_plus)
798        }
799
800        pub(crate) fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> {
801            if input.peek(Token![->]) {
802                let arrow = input.parse()?;
803                let allow_group_generic = true;
804                let ty = ambig_ty(input, allow_plus, allow_group_generic)?;
805                Ok(ReturnType::Type(arrow, Box::new(ty)))
806            } else {
807                Ok(ReturnType::Default)
808            }
809        }
810    }
811
812    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
813    impl Parse for ReturnType {
814        fn parse(input: ParseStream) -> Result<Self> {
815            let allow_plus = true;
816            Self::parse(input, allow_plus)
817        }
818    }
819
820    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
821    impl Parse for TypeTraitObject {
822        fn parse(input: ParseStream) -> Result<Self> {
823            let allow_plus = true;
824            Self::parse(input, allow_plus)
825        }
826    }
827
828    impl TypeTraitObject {
829        #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
830        pub fn without_plus(input: ParseStream) -> Result<Self> {
831            let allow_plus = false;
832            Self::parse(input, allow_plus)
833        }
834
835        // Only allow multiple trait references if allow_plus is true.
836        pub(crate) fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> {
837            let dyn_token: Option<Token![dyn]> = input.parse()?;
838            let dyn_span = match &dyn_token {
839                Some(token) => token.span,
840                None => input.span(),
841            };
842            let bounds = Self::parse_bounds(dyn_span, input, allow_plus)?;
843            Ok(TypeTraitObject { dyn_token, bounds })
844        }
845
846        fn parse_bounds(
847            dyn_span: Span,
848            input: ParseStream,
849            allow_plus: bool,
850        ) -> Result<Punctuated<TypeParamBound, Token![+]>> {
851            let allow_precise_capture = false;
852            let allow_tilde_const = false;
853            let bounds = TypeParamBound::parse_multiple(
854                input,
855                allow_plus,
856                allow_precise_capture,
857                allow_tilde_const,
858            )?;
859            let mut last_lifetime_span = None;
860            let mut at_least_one_trait = false;
861            for bound in &bounds {
862                match bound {
863                    TypeParamBound::Trait(_) => {
864                        at_least_one_trait = true;
865                        break;
866                    }
867                    TypeParamBound::Lifetime(lifetime) => {
868                        last_lifetime_span = Some(lifetime.ident.span());
869                    }
870                    TypeParamBound::PreciseCapture(_) | TypeParamBound::Verbatim(_) => {
871                        unreachable!()
872                    }
873                }
874            }
875            // Just lifetimes like `'a + 'b` is not a TraitObject.
876            if !at_least_one_trait {
877                let msg = "at least one trait is required for an object type";
878                return Err(error::new2(dyn_span, last_lifetime_span.unwrap(), msg));
879            }
880            Ok(bounds)
881        }
882    }
883
884    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
885    impl Parse for TypeImplTrait {
886        fn parse(input: ParseStream) -> Result<Self> {
887            let allow_plus = true;
888            Self::parse(input, allow_plus)
889        }
890    }
891
892    impl TypeImplTrait {
893        #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
894        pub fn without_plus(input: ParseStream) -> Result<Self> {
895            let allow_plus = false;
896            Self::parse(input, allow_plus)
897        }
898
899        pub(crate) fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> {
900            let impl_token: Token![impl] = input.parse()?;
901            let allow_precise_capture = true;
902            let allow_tilde_const = false;
903            let bounds = TypeParamBound::parse_multiple(
904                input,
905                allow_plus,
906                allow_precise_capture,
907                allow_tilde_const,
908            )?;
909            let mut last_nontrait_span = None;
910            let mut at_least_one_trait = false;
911            for bound in &bounds {
912                match bound {
913                    TypeParamBound::Trait(_) => {
914                        at_least_one_trait = true;
915                        break;
916                    }
917                    TypeParamBound::Lifetime(lifetime) => {
918                        last_nontrait_span = Some(lifetime.ident.span());
919                    }
920                    TypeParamBound::PreciseCapture(precise_capture) => {
921                        #[cfg(feature = "full")]
922                        {
923                            last_nontrait_span = Some(precise_capture.gt_token.span);
924                        }
925                        #[cfg(not(feature = "full"))]
926                        {
927                            _ = precise_capture;
928                            unreachable!();
929                        }
930                    }
931                    TypeParamBound::Verbatim(_) => {
932                        // ~const Trait
933                        at_least_one_trait = true;
934                        break;
935                    }
936                }
937            }
938            if !at_least_one_trait {
939                let msg = "at least one trait must be specified";
940                return Err(error::new2(
941                    impl_token.span,
942                    last_nontrait_span.unwrap(),
943                    msg,
944                ));
945            }
946            Ok(TypeImplTrait { impl_token, bounds })
947        }
948    }
949
950    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
951    impl Parse for TypeGroup {
952        fn parse(input: ParseStream) -> Result<Self> {
953            let group = crate::group::parse_group(input)?;
954            Ok(TypeGroup {
955                group_token: group.token,
956                elem: group.content.parse()?,
957            })
958        }
959    }
960
961    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
962    impl Parse for TypeParen {
963        fn parse(input: ParseStream) -> Result<Self> {
964            let allow_plus = false;
965            Self::parse(input, allow_plus)
966        }
967    }
968
969    impl TypeParen {
970        fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> {
971            let content;
972            Ok(TypeParen {
973                paren_token: parenthesized!(content in input),
974                elem: Box::new({
975                    let allow_group_generic = true;
976                    ambig_ty(&content, allow_plus, allow_group_generic)?
977                }),
978            })
979        }
980    }
981
982    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
983    impl Parse for BareFnArg {
984        fn parse(input: ParseStream) -> Result<Self> {
985            let allow_self = false;
986            parse_bare_fn_arg(input, allow_self)
987        }
988    }
989
990    fn parse_bare_fn_arg(input: ParseStream, allow_self: bool) -> Result<BareFnArg> {
991        let attrs = input.call(Attribute::parse_outer)?;
992
993        let begin = input.fork();
994
995        let has_mut_self = allow_self && input.peek(Token![mut]) && input.peek2(Token![self]);
996        if has_mut_self {
997            input.parse::<Token![mut]>()?;
998        }
999
1000        let mut has_self = false;
1001        let mut name = if (input.peek(Ident) || input.peek(Token![_]) || {
1002            has_self = allow_self && input.peek(Token![self]);
1003            has_self
1004        }) && input.peek2(Token![:])
1005            && !input.peek2(Token![::])
1006        {
1007            let name = input.call(Ident::parse_any)?;
1008            let colon: Token![:] = input.parse()?;
1009            Some((name, colon))
1010        } else {
1011            has_self = false;
1012            None
1013        };
1014
1015        let ty = if allow_self && !has_self && input.peek(Token![mut]) && input.peek2(Token![self])
1016        {
1017            input.parse::<Token![mut]>()?;
1018            input.parse::<Token![self]>()?;
1019            None
1020        } else if has_mut_self && name.is_none() {
1021            input.parse::<Token![self]>()?;
1022            None
1023        } else {
1024            Some(input.parse()?)
1025        };
1026
1027        let ty = match ty {
1028            Some(ty) if !has_mut_self => ty,
1029            _ => {
1030                name = None;
1031                Type::Verbatim(verbatim::between(&begin, input))
1032            }
1033        };
1034
1035        Ok(BareFnArg { attrs, name, ty })
1036    }
1037
1038    fn parse_bare_variadic(input: ParseStream, attrs: Vec<Attribute>) -> Result<BareVariadic> {
1039        Ok(BareVariadic {
1040            attrs,
1041            name: if input.peek(Ident) || input.peek(Token![_]) {
1042                let name = input.call(Ident::parse_any)?;
1043                let colon: Token![:] = input.parse()?;
1044                Some((name, colon))
1045            } else {
1046                None
1047            },
1048            dots: input.parse()?,
1049            comma: input.parse()?,
1050        })
1051    }
1052
1053    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
1054    impl Parse for Abi {
1055        fn parse(input: ParseStream) -> Result<Self> {
1056            Ok(Abi {
1057                extern_token: input.parse()?,
1058                name: input.parse()?,
1059            })
1060        }
1061    }
1062
1063    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
1064    impl Parse for Option<Abi> {
1065        fn parse(input: ParseStream) -> Result<Self> {
1066            if input.peek(Token![extern]) {
1067                input.parse().map(Some)
1068            } else {
1069                Ok(None)
1070            }
1071        }
1072    }
1073}
1074
1075#[cfg(feature = "printing")]
1076mod printing {
1077    use crate::attr::FilterAttrs;
1078    use crate::path;
1079    use crate::path::printing::PathStyle;
1080    use crate::print::TokensOrDefault;
1081    use crate::ty::{
1082        Abi, BareFnArg, BareVariadic, ReturnType, TypeArray, TypeBareFn, TypeGroup, TypeImplTrait,
1083        TypeInfer, TypeMacro, TypeNever, TypeParen, TypePath, TypePtr, TypeReference, TypeSlice,
1084        TypeTraitObject, TypeTuple,
1085    };
1086    use proc_macro2::TokenStream;
1087    use quote::{ToTokens, TokenStreamExt};
1088
1089    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1090    impl ToTokens for TypeSlice {
1091        fn to_tokens(&self, tokens: &mut TokenStream) {
1092            self.bracket_token.surround(tokens, |tokens| {
1093                self.elem.to_tokens(tokens);
1094            });
1095        }
1096    }
1097
1098    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1099    impl ToTokens for TypeArray {
1100        fn to_tokens(&self, tokens: &mut TokenStream) {
1101            self.bracket_token.surround(tokens, |tokens| {
1102                self.elem.to_tokens(tokens);
1103                self.semi_token.to_tokens(tokens);
1104                self.len.to_tokens(tokens);
1105            });
1106        }
1107    }
1108
1109    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1110    impl ToTokens for TypePtr {
1111        fn to_tokens(&self, tokens: &mut TokenStream) {
1112            self.star_token.to_tokens(tokens);
1113            match &self.mutability {
1114                Some(tok) => tok.to_tokens(tokens),
1115                None => {
1116                    TokensOrDefault(&self.const_token).to_tokens(tokens);
1117                }
1118            }
1119            self.elem.to_tokens(tokens);
1120        }
1121    }
1122
1123    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1124    impl ToTokens for TypeReference {
1125        fn to_tokens(&self, tokens: &mut TokenStream) {
1126            self.and_token.to_tokens(tokens);
1127            self.lifetime.to_tokens(tokens);
1128            self.mutability.to_tokens(tokens);
1129            self.elem.to_tokens(tokens);
1130        }
1131    }
1132
1133    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1134    impl ToTokens for TypeBareFn {
1135        fn to_tokens(&self, tokens: &mut TokenStream) {
1136            self.lifetimes.to_tokens(tokens);
1137            self.unsafety.to_tokens(tokens);
1138            self.abi.to_tokens(tokens);
1139            self.fn_token.to_tokens(tokens);
1140            self.paren_token.surround(tokens, |tokens| {
1141                self.inputs.to_tokens(tokens);
1142                if let Some(variadic) = &self.variadic {
1143                    if !self.inputs.empty_or_trailing() {
1144                        let span = variadic.dots.spans[0];
1145                        Token![,](span).to_tokens(tokens);
1146                    }
1147                    variadic.to_tokens(tokens);
1148                }
1149            });
1150            self.output.to_tokens(tokens);
1151        }
1152    }
1153
1154    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1155    impl ToTokens for TypeNever {
1156        fn to_tokens(&self, tokens: &mut TokenStream) {
1157            self.bang_token.to_tokens(tokens);
1158        }
1159    }
1160
1161    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1162    impl ToTokens for TypeTuple {
1163        fn to_tokens(&self, tokens: &mut TokenStream) {
1164            self.paren_token.surround(tokens, |tokens| {
1165                self.elems.to_tokens(tokens);
1166                // If we only have one argument, we need a trailing comma to
1167                // distinguish TypeTuple from TypeParen.
1168                if self.elems.len() == 1 && !self.elems.trailing_punct() {
1169                    <Token![,]>::default().to_tokens(tokens);
1170                }
1171            });
1172        }
1173    }
1174
1175    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1176    impl ToTokens for TypePath {
1177        fn to_tokens(&self, tokens: &mut TokenStream) {
1178            path::printing::print_qpath(tokens, &self.qself, &self.path, PathStyle::AsWritten);
1179        }
1180    }
1181
1182    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1183    impl ToTokens for TypeTraitObject {
1184        fn to_tokens(&self, tokens: &mut TokenStream) {
1185            self.dyn_token.to_tokens(tokens);
1186            self.bounds.to_tokens(tokens);
1187        }
1188    }
1189
1190    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1191    impl ToTokens for TypeImplTrait {
1192        fn to_tokens(&self, tokens: &mut TokenStream) {
1193            self.impl_token.to_tokens(tokens);
1194            self.bounds.to_tokens(tokens);
1195        }
1196    }
1197
1198    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1199    impl ToTokens for TypeGroup {
1200        fn to_tokens(&self, tokens: &mut TokenStream) {
1201            self.group_token.surround(tokens, |tokens| {
1202                self.elem.to_tokens(tokens);
1203            });
1204        }
1205    }
1206
1207    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1208    impl ToTokens for TypeParen {
1209        fn to_tokens(&self, tokens: &mut TokenStream) {
1210            self.paren_token.surround(tokens, |tokens| {
1211                self.elem.to_tokens(tokens);
1212            });
1213        }
1214    }
1215
1216    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1217    impl ToTokens for TypeInfer {
1218        fn to_tokens(&self, tokens: &mut TokenStream) {
1219            self.underscore_token.to_tokens(tokens);
1220        }
1221    }
1222
1223    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1224    impl ToTokens for TypeMacro {
1225        fn to_tokens(&self, tokens: &mut TokenStream) {
1226            self.mac.to_tokens(tokens);
1227        }
1228    }
1229
1230    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1231    impl ToTokens for ReturnType {
1232        fn to_tokens(&self, tokens: &mut TokenStream) {
1233            match self {
1234                ReturnType::Default => {}
1235                ReturnType::Type(arrow, ty) => {
1236                    arrow.to_tokens(tokens);
1237                    ty.to_tokens(tokens);
1238                }
1239            }
1240        }
1241    }
1242
1243    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1244    impl ToTokens for BareFnArg {
1245        fn to_tokens(&self, tokens: &mut TokenStream) {
1246            tokens.append_all(self.attrs.outer());
1247            if let Some((name, colon)) = &self.name {
1248                name.to_tokens(tokens);
1249                colon.to_tokens(tokens);
1250            }
1251            self.ty.to_tokens(tokens);
1252        }
1253    }
1254
1255    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1256    impl ToTokens for BareVariadic {
1257        fn to_tokens(&self, tokens: &mut TokenStream) {
1258            tokens.append_all(self.attrs.outer());
1259            if let Some((name, colon)) = &self.name {
1260                name.to_tokens(tokens);
1261                colon.to_tokens(tokens);
1262            }
1263            self.dots.to_tokens(tokens);
1264            self.comma.to_tokens(tokens);
1265        }
1266    }
1267
1268    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
1269    impl ToTokens for Abi {
1270        fn to_tokens(&self, tokens: &mut TokenStream) {
1271            self.extern_token.to_tokens(tokens);
1272            self.name.to_tokens(tokens);
1273        }
1274    }
1275}
syn/ty.rs

syn/
ty.rs
