syn/
path.rs

1#[cfg(feature = "parsing")]
2use crate::error::Result;
3use crate::expr::Expr;
4use crate::generics::TypeParamBound;
5use crate::ident::Ident;
6use crate::lifetime::Lifetime;
7use crate::punctuated::Punctuated;
8use crate::token;
9use crate::ty::{ReturnType, Type};
10
11ast_struct! {
12    /// A path at which a named item is exported (e.g. `std::collections::HashMap`).
13    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
14    pub struct Path {
15        pub leading_colon: Option<Token![::]>,
16        pub segments: Punctuated<PathSegment, Token![::]>,
17    }
18}
19
20impl<T> From<T> for Path
21where
22    T: Into<PathSegment>,
23{
24    fn from(segment: T) -> Self {
25        let mut path = Path {
26            leading_colon: None,
27            segments: Punctuated::new(),
28        };
29        path.segments.push_value(segment.into());
30        path
31    }
32}
33
34impl Path {
35    /// Determines whether this is a path of length 1 equal to the given
36    /// ident.
37    ///
38    /// For them to compare equal, it must be the case that:
39    ///
40    /// - the path has no leading colon,
41    /// - the number of path segments is 1,
42    /// - the first path segment has no angle bracketed or parenthesized
43    ///   path arguments, and
44    /// - the ident of the first path segment is equal to the given one.
45    ///
46    /// # Example
47    ///
48    /// ```
49    /// use proc_macro2::TokenStream;
50    /// use syn::{Attribute, Error, Meta, Result};
51    ///
52    /// fn get_serde_meta_item(attr: &Attribute) -> Result<Option<&TokenStream>> {
53    ///     if attr.path().is_ident("serde") {
54    ///         match &attr.meta {
55    ///             Meta::List(meta) => Ok(Some(&meta.tokens)),
56    ///             bad => Err(Error::new_spanned(bad, "unrecognized attribute")),
57    ///         }
58    ///     } else {
59    ///         Ok(None)
60    ///     }
61    /// }
62    /// ```
63    pub fn is_ident<I>(&self, ident: &I) -> bool
64    where
65        I: ?Sized,
66        Ident: PartialEq<I>,
67    {
68        match self.get_ident() {
69            Some(id) => id == ident,
70            None => false,
71        }
72    }
73
74    /// If this path consists of a single ident, returns the ident.
75    ///
76    /// A path is considered an ident if:
77    ///
78    /// - the path has no leading colon,
79    /// - the number of path segments is 1, and
80    /// - the first path segment has no angle bracketed or parenthesized
81    ///   path arguments.
82    pub fn get_ident(&self) -> Option<&Ident> {
83        if self.leading_colon.is_none()
84            && self.segments.len() == 1
85            && self.segments[0].arguments.is_none()
86        {
87            Some(&self.segments[0].ident)
88        } else {
89            None
90        }
91    }
92
93    /// An error if this path is not a single ident, as defined in `get_ident`.
94    #[cfg(feature = "parsing")]
95    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
96    pub fn require_ident(&self) -> Result<&Ident> {
97        self.get_ident().ok_or_else(|| {
98            crate::error::new2(
99                self.segments.first().unwrap().ident.span(),
100                self.segments.last().unwrap().ident.span(),
101                "expected this path to be an identifier",
102            )
103        })
104    }
105}
106
107ast_struct! {
108    /// A segment of a path together with any path arguments on that segment.
109    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
110    pub struct PathSegment {
111        pub ident: Ident,
112        pub arguments: PathArguments,
113    }
114}
115
116impl<T> From<T> for PathSegment
117where
118    T: Into<Ident>,
119{
120    fn from(ident: T) -> Self {
121        PathSegment {
122            ident: ident.into(),
123            arguments: PathArguments::None,
124        }
125    }
126}
127
128ast_enum! {
129    /// Angle bracketed or parenthesized arguments of a path segment.
130    ///
131    /// ## Angle bracketed
132    ///
133    /// The `<'a, T>` in `std::slice::iter<'a, T>`.
134    ///
135    /// ## Parenthesized
136    ///
137    /// The `(A, B) -> C` in `Fn(A, B) -> C`.
138    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
139    pub enum PathArguments {
140        None,
141        /// The `<'a, T>` in `std::slice::iter<'a, T>`.
142        AngleBracketed(AngleBracketedGenericArguments),
143        /// The `(A, B) -> C` in `Fn(A, B) -> C`.
144        Parenthesized(ParenthesizedGenericArguments),
145    }
146}
147
148impl Default for PathArguments {
149    fn default() -> Self {
150        PathArguments::None
151    }
152}
153
154impl PathArguments {
155    pub fn is_empty(&self) -> bool {
156        match self {
157            PathArguments::None => true,
158            PathArguments::AngleBracketed(bracketed) => bracketed.args.is_empty(),
159            PathArguments::Parenthesized(_) => false,
160        }
161    }
162
163    pub fn is_none(&self) -> bool {
164        match self {
165            PathArguments::None => true,
166            PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => false,
167        }
168    }
169}
170
171ast_enum! {
172    /// An individual generic argument, like `'a`, `T`, or `Item = T`.
173    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
174    #[non_exhaustive]
175    pub enum GenericArgument {
176        /// A lifetime argument.
177        Lifetime(Lifetime),
178        /// A type argument.
179        Type(Type),
180        /// A const expression. Must be inside of a block.
181        ///
182        /// NOTE: Identity expressions are represented as Type arguments, as
183        /// they are indistinguishable syntactically.
184        Const(Expr),
185        /// A binding (equality constraint) on an associated type: the `Item =
186        /// u8` in `Iterator<Item = u8>`.
187        AssocType(AssocType),
188        /// An equality constraint on an associated constant: the `PANIC =
189        /// false` in `Trait<PANIC = false>`.
190        AssocConst(AssocConst),
191        /// An associated type bound: `Iterator<Item: Display>`.
192        Constraint(Constraint),
193    }
194}
195
196ast_struct! {
197    /// Angle bracketed arguments of a path segment: the `<K, V>` in `HashMap<K,
198    /// V>`.
199    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
200    pub struct AngleBracketedGenericArguments {
201        pub colon2_token: Option<Token![::]>,
202        pub lt_token: Token![<],
203        pub args: Punctuated<GenericArgument, Token![,]>,
204        pub gt_token: Token![>],
205    }
206}
207
208ast_struct! {
209    /// A binding (equality constraint) on an associated type: the `Item = u8`
210    /// in `Iterator<Item = u8>`.
211    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
212    pub struct AssocType {
213        pub ident: Ident,
214        pub generics: Option<AngleBracketedGenericArguments>,
215        pub eq_token: Token![=],
216        pub ty: Type,
217    }
218}
219
220ast_struct! {
221    /// An equality constraint on an associated constant: the `PANIC = false` in
222    /// `Trait<PANIC = false>`.
223    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
224    pub struct AssocConst {
225        pub ident: Ident,
226        pub generics: Option<AngleBracketedGenericArguments>,
227        pub eq_token: Token![=],
228        pub value: Expr,
229    }
230}
231
232ast_struct! {
233    /// An associated type bound: `Iterator<Item: Display>`.
234    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
235    pub struct Constraint {
236        pub ident: Ident,
237        pub generics: Option<AngleBracketedGenericArguments>,
238        pub colon_token: Token![:],
239        pub bounds: Punctuated<TypeParamBound, Token![+]>,
240    }
241}
242
243ast_struct! {
244    /// Arguments of a function path segment: the `(A, B) -> C` in `Fn(A,B) ->
245    /// C`.
246    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
247    pub struct ParenthesizedGenericArguments {
248        pub paren_token: token::Paren,
249        /// `(A, B)`
250        pub inputs: Punctuated<Type, Token![,]>,
251        /// `C`
252        pub output: ReturnType,
253    }
254}
255
256ast_struct! {
257    /// The explicit Self type in a qualified path: the `T` in `<T as
258    /// Display>::fmt`.
259    ///
260    /// The actual path, including the trait and the associated item, is stored
261    /// separately. The `position` field represents the index of the associated
262    /// item qualified with this Self type.
263    ///
264    /// ```text
265    /// <Vec<T> as a::b::Trait>::AssociatedItem
266    ///  ^~~~~~    ~~~~~~~~~~~~~~^
267    ///  ty        position = 3
268    ///
269    /// <Vec<T>>::AssociatedItem
270    ///  ^~~~~~   ^
271    ///  ty       position = 0
272    /// ```
273    #[cfg_attr(docsrs, doc(cfg(any(feature = "full", feature = "derive"))))]
274    pub struct QSelf {
275        pub lt_token: Token![<],
276        pub ty: Box<Type>,
277        pub position: usize,
278        pub as_token: Option<Token![as]>,
279        pub gt_token: Token![>],
280    }
281}
282
283#[cfg(feature = "parsing")]
284pub(crate) mod parsing {
285    use crate::error::Result;
286    #[cfg(feature = "full")]
287    use crate::expr::ExprBlock;
288    use crate::expr::{Expr, ExprPath};
289    use crate::ext::IdentExt as _;
290    #[cfg(feature = "full")]
291    use crate::generics::TypeParamBound;
292    use crate::ident::Ident;
293    use crate::lifetime::Lifetime;
294    use crate::lit::Lit;
295    use crate::parse::{Parse, ParseStream};
296    #[cfg(feature = "full")]
297    use crate::path::Constraint;
298    use crate::path::{
299        AngleBracketedGenericArguments, AssocConst, AssocType, GenericArgument,
300        ParenthesizedGenericArguments, Path, PathArguments, PathSegment, QSelf,
301    };
302    use crate::punctuated::Punctuated;
303    use crate::token;
304    use crate::ty::{ReturnType, Type};
305    #[cfg(not(feature = "full"))]
306    use crate::verbatim;
307
308    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
309    impl Parse for Path {
310        fn parse(input: ParseStream) -> Result<Self> {
311            Self::parse_helper(input, false)
312        }
313    }
314
315    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
316    impl Parse for GenericArgument {
317        fn parse(input: ParseStream) -> Result<Self> {
318            if input.peek(Lifetime) && !input.peek2(Token![+]) {
319                return Ok(GenericArgument::Lifetime(input.parse()?));
320            }
321
322            if input.peek(Lit) || input.peek(token::Brace) {
323                return const_argument(input).map(GenericArgument::Const);
324            }
325
326            let mut argument: Type = input.parse()?;
327
328            match argument {
329                Type::Path(mut ty)
330                    if ty.qself.is_none()
331                        && ty.path.leading_colon.is_none()
332                        && ty.path.segments.len() == 1
333                        && match &ty.path.segments[0].arguments {
334                            PathArguments::None | PathArguments::AngleBracketed(_) => true,
335                            PathArguments::Parenthesized(_) => false,
336                        } =>
337                {
338                    if let Some(eq_token) = input.parse::<Option<Token![=]>>()? {
339                        let segment = ty.path.segments.pop().unwrap().into_value();
340                        let ident = segment.ident;
341                        let generics = match segment.arguments {
342                            PathArguments::None => None,
343                            PathArguments::AngleBracketed(arguments) => Some(arguments),
344                            PathArguments::Parenthesized(_) => unreachable!(),
345                        };
346                        return if input.peek(Lit) || input.peek(token::Brace) {
347                            Ok(GenericArgument::AssocConst(AssocConst {
348                                ident,
349                                generics,
350                                eq_token,
351                                value: const_argument(input)?,
352                            }))
353                        } else {
354                            Ok(GenericArgument::AssocType(AssocType {
355                                ident,
356                                generics,
357                                eq_token,
358                                ty: input.parse()?,
359                            }))
360                        };
361                    }
362
363                    #[cfg(feature = "full")]
364                    if let Some(colon_token) = input.parse::<Option<Token![:]>>()? {
365                        let segment = ty.path.segments.pop().unwrap().into_value();
366                        return Ok(GenericArgument::Constraint(Constraint {
367                            ident: segment.ident,
368                            generics: match segment.arguments {
369                                PathArguments::None => None,
370                                PathArguments::AngleBracketed(arguments) => Some(arguments),
371                                PathArguments::Parenthesized(_) => unreachable!(),
372                            },
373                            colon_token,
374                            bounds: {
375                                let mut bounds = Punctuated::new();
376                                loop {
377                                    if input.peek(Token![,]) || input.peek(Token![>]) {
378                                        break;
379                                    }
380                                    bounds.push_value({
381                                        let allow_precise_capture = false;
382                                        let allow_tilde_const = true;
383                                        TypeParamBound::parse_single(
384                                            input,
385                                            allow_precise_capture,
386                                            allow_tilde_const,
387                                        )?
388                                    });
389                                    if !input.peek(Token![+]) {
390                                        break;
391                                    }
392                                    let punct: Token![+] = input.parse()?;
393                                    bounds.push_punct(punct);
394                                }
395                                bounds
396                            },
397                        }));
398                    }
399
400                    argument = Type::Path(ty);
401                }
402                _ => {}
403            }
404
405            Ok(GenericArgument::Type(argument))
406        }
407    }
408
409    pub(crate) fn const_argument(input: ParseStream) -> Result<Expr> {
410        let lookahead = input.lookahead1();
411
412        if input.peek(Lit) {
413            let lit = input.parse()?;
414            return Ok(Expr::Lit(lit));
415        }
416
417        if input.peek(Ident) {
418            let ident: Ident = input.parse()?;
419            return Ok(Expr::Path(ExprPath {
420                attrs: Vec::new(),
421                qself: None,
422                path: Path::from(ident),
423            }));
424        }
425
426        if input.peek(token::Brace) {
427            #[cfg(feature = "full")]
428            {
429                let block: ExprBlock = input.parse()?;
430                return Ok(Expr::Block(block));
431            }
432
433            #[cfg(not(feature = "full"))]
434            {
435                let begin = input.fork();
436                let content;
437                braced!(content in input);
438                content.parse::<Expr>()?;
439                let verbatim = verbatim::between(&begin, input);
440                return Ok(Expr::Verbatim(verbatim));
441            }
442        }
443
444        Err(lookahead.error())
445    }
446
447    impl AngleBracketedGenericArguments {
448        /// Parse `::<…>` with mandatory leading `::`.
449        ///
450        /// The ordinary [`Parse`] impl for `AngleBracketedGenericArguments`
451        /// parses optional leading `::`.
452        #[cfg(feature = "full")]
453        #[cfg_attr(docsrs, doc(cfg(all(feature = "parsing", feature = "full"))))]
454        pub fn parse_turbofish(input: ParseStream) -> Result<Self> {
455            let colon2_token: Token![::] = input.parse()?;
456            Self::do_parse(Some(colon2_token), input)
457        }
458
459        pub(crate) fn do_parse(
460            colon2_token: Option<Token![::]>,
461            input: ParseStream,
462        ) -> Result<Self> {
463            Ok(AngleBracketedGenericArguments {
464                colon2_token,
465                lt_token: input.parse()?,
466                args: {
467                    let mut args = Punctuated::new();
468                    loop {
469                        if input.peek(Token![>]) {
470                            break;
471                        }
472                        let value: GenericArgument = input.parse()?;
473                        args.push_value(value);
474                        if input.peek(Token![>]) {
475                            break;
476                        }
477                        let punct: Token![,] = input.parse()?;
478                        args.push_punct(punct);
479                    }
480                    args
481                },
482                gt_token: input.parse()?,
483            })
484        }
485    }
486
487    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
488    impl Parse for AngleBracketedGenericArguments {
489        fn parse(input: ParseStream) -> Result<Self> {
490            let colon2_token: Option<Token![::]> = input.parse()?;
491            Self::do_parse(colon2_token, input)
492        }
493    }
494
495    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
496    impl Parse for ParenthesizedGenericArguments {
497        fn parse(input: ParseStream) -> Result<Self> {
498            let content;
499            Ok(ParenthesizedGenericArguments {
500                paren_token: parenthesized!(content in input),
501                inputs: content.parse_terminated(Type::parse, Token![,])?,
502                output: input.call(ReturnType::without_plus)?,
503            })
504        }
505    }
506
507    #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
508    impl Parse for PathSegment {
509        fn parse(input: ParseStream) -> Result<Self> {
510            Self::parse_helper(input, false)
511        }
512    }
513
514    impl PathSegment {
515        fn parse_helper(input: ParseStream, expr_style: bool) -> Result<Self> {
516            if input.peek(Token![super])
517                || input.peek(Token![self])
518                || input.peek(Token![crate])
519                || cfg!(feature = "full") && input.peek(Token![try])
520            {
521                let ident = input.call(Ident::parse_any)?;
522                return Ok(PathSegment::from(ident));
523            }
524
525            let ident = if input.peek(Token![Self]) {
526                input.call(Ident::parse_any)?
527            } else {
528                input.parse()?
529            };
530
531            if !expr_style
532                && input.peek(Token![<])
533                && !input.peek(Token![<=])
534                && !input.peek(Token![<<=])
535                || input.peek(Token![::]) && input.peek3(Token![<])
536            {
537                Ok(PathSegment {
538                    ident,
539                    arguments: PathArguments::AngleBracketed(input.parse()?),
540                })
541            } else {
542                Ok(PathSegment::from(ident))
543            }
544        }
545    }
546
547    impl Path {
548        /// Parse a `Path` containing no path arguments on any of its segments.
549        ///
550        /// # Example
551        ///
552        /// ```
553        /// use syn::{Path, Result, Token};
554        /// use syn::parse::{Parse, ParseStream};
555        ///
556        /// // A simplified single `use` statement like:
557        /// //
558        /// //     use std::collections::HashMap;
559        /// //
560        /// // Note that generic parameters are not allowed in a `use` statement
561        /// // so the following must not be accepted.
562        /// //
563        /// //     use a::<b>::c;
564        /// struct SingleUse {
565        ///     use_token: Token![use],
566        ///     path: Path,
567        /// }
568        ///
569        /// impl Parse for SingleUse {
570        ///     fn parse(input: ParseStream) -> Result<Self> {
571        ///         Ok(SingleUse {
572        ///             use_token: input.parse()?,
573        ///             path: input.call(Path::parse_mod_style)?,
574        ///         })
575        ///     }
576        /// }
577        /// ```
578        #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
579        pub fn parse_mod_style(input: ParseStream) -> Result<Self> {
580            Ok(Path {
581                leading_colon: input.parse()?,
582                segments: {
583                    let mut segments = Punctuated::new();
584                    loop {
585                        if !input.peek(Ident)
586                            && !input.peek(Token![super])
587                            && !input.peek(Token![self])
588                            && !input.peek(Token![Self])
589                            && !input.peek(Token![crate])
590                        {
591                            break;
592                        }
593                        let ident = Ident::parse_any(input)?;
594                        segments.push_value(PathSegment::from(ident));
595                        if !input.peek(Token![::]) {
596                            break;
597                        }
598                        let punct = input.parse()?;
599                        segments.push_punct(punct);
600                    }
601                    if segments.is_empty() {
602                        return Err(input.parse::<Ident>().unwrap_err());
603                    } else if segments.trailing_punct() {
604                        return Err(input.error("expected path segment after `::`"));
605                    }
606                    segments
607                },
608            })
609        }
610
611        pub(crate) fn parse_helper(input: ParseStream, expr_style: bool) -> Result<Self> {
612            let mut path = Path {
613                leading_colon: input.parse()?,
614                segments: {
615                    let mut segments = Punctuated::new();
616                    let value = PathSegment::parse_helper(input, expr_style)?;
617                    segments.push_value(value);
618                    segments
619                },
620            };
621            Path::parse_rest(input, &mut path, expr_style)?;
622            Ok(path)
623        }
624
625        pub(crate) fn parse_rest(
626            input: ParseStream,
627            path: &mut Self,
628            expr_style: bool,
629        ) -> Result<()> {
630            while input.peek(Token![::]) && !input.peek3(token::Paren) {
631                let punct: Token![::] = input.parse()?;
632                path.segments.push_punct(punct);
633                let value = PathSegment::parse_helper(input, expr_style)?;
634                path.segments.push_value(value);
635            }
636            Ok(())
637        }
638
639        pub(crate) fn is_mod_style(&self) -> bool {
640            self.segments
641                .iter()
642                .all(|segment| segment.arguments.is_none())
643        }
644    }
645
646    pub(crate) fn qpath(input: ParseStream, expr_style: bool) -> Result<(Option<QSelf>, Path)> {
647        if input.peek(Token![<]) {
648            let lt_token: Token![<] = input.parse()?;
649            let this: Type = input.parse()?;
650            let path = if input.peek(Token![as]) {
651                let as_token: Token![as] = input.parse()?;
652                let path: Path = input.parse()?;
653                Some((as_token, path))
654            } else {
655                None
656            };
657            let gt_token: Token![>] = input.parse()?;
658            let colon2_token: Token![::] = input.parse()?;
659            let mut rest = Punctuated::new();
660            loop {
661                let path = PathSegment::parse_helper(input, expr_style)?;
662                rest.push_value(path);
663                if !input.peek(Token![::]) {
664                    break;
665                }
666                let punct: Token![::] = input.parse()?;
667                rest.push_punct(punct);
668            }
669            let (position, as_token, path) = match path {
670                Some((as_token, mut path)) => {
671                    let pos = path.segments.len();
672                    path.segments.push_punct(colon2_token);
673                    path.segments.extend(rest.into_pairs());
674                    (pos, Some(as_token), path)
675                }
676                None => {
677                    let path = Path {
678                        leading_colon: Some(colon2_token),
679                        segments: rest,
680                    };
681                    (0, None, path)
682                }
683            };
684            let qself = QSelf {
685                lt_token,
686                ty: Box::new(this),
687                position,
688                as_token,
689                gt_token,
690            };
691            Ok((Some(qself), path))
692        } else {
693            let path = Path::parse_helper(input, expr_style)?;
694            Ok((None, path))
695        }
696    }
697}
698
699#[cfg(feature = "printing")]
700pub(crate) mod printing {
701    use crate::generics;
702    use crate::path::{
703        AngleBracketedGenericArguments, AssocConst, AssocType, Constraint, GenericArgument,
704        ParenthesizedGenericArguments, Path, PathArguments, PathSegment, QSelf,
705    };
706    use crate::print::TokensOrDefault;
707    #[cfg(feature = "parsing")]
708    use crate::spanned::Spanned;
709    #[cfg(feature = "parsing")]
710    use proc_macro2::Span;
711    use proc_macro2::TokenStream;
712    use quote::ToTokens;
713    use std::cmp;
714
715    pub(crate) enum PathStyle {
716        Expr,
717        Mod,
718        AsWritten,
719    }
720
721    impl Copy for PathStyle {}
722
723    impl Clone for PathStyle {
724        fn clone(&self) -> Self {
725            *self
726        }
727    }
728
729    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
730    impl ToTokens for Path {
731        fn to_tokens(&self, tokens: &mut TokenStream) {
732            print_path(tokens, self, PathStyle::AsWritten);
733        }
734    }
735
736    pub(crate) fn print_path(tokens: &mut TokenStream, path: &Path, style: PathStyle) {
737        path.leading_colon.to_tokens(tokens);
738        for segment in path.segments.pairs() {
739            print_path_segment(tokens, segment.value(), style);
740            segment.punct().to_tokens(tokens);
741        }
742    }
743
744    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
745    impl ToTokens for PathSegment {
746        fn to_tokens(&self, tokens: &mut TokenStream) {
747            print_path_segment(tokens, self, PathStyle::AsWritten);
748        }
749    }
750
751    fn print_path_segment(tokens: &mut TokenStream, segment: &PathSegment, style: PathStyle) {
752        segment.ident.to_tokens(tokens);
753        print_path_arguments(tokens, &segment.arguments, style);
754    }
755
756    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
757    impl ToTokens for PathArguments {
758        fn to_tokens(&self, tokens: &mut TokenStream) {
759            print_path_arguments(tokens, self, PathStyle::AsWritten);
760        }
761    }
762
763    fn print_path_arguments(tokens: &mut TokenStream, arguments: &PathArguments, style: PathStyle) {
764        match arguments {
765            PathArguments::None => {}
766            PathArguments::AngleBracketed(arguments) => {
767                print_angle_bracketed_generic_arguments(tokens, arguments, style);
768            }
769            PathArguments::Parenthesized(arguments) => {
770                print_parenthesized_generic_arguments(tokens, arguments, style);
771            }
772        }
773    }
774
775    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
776    impl ToTokens for GenericArgument {
777        #[allow(clippy::match_same_arms)]
778        fn to_tokens(&self, tokens: &mut TokenStream) {
779            match self {
780                GenericArgument::Lifetime(lt) => lt.to_tokens(tokens),
781                GenericArgument::Type(ty) => ty.to_tokens(tokens),
782                GenericArgument::Const(expr) => {
783                    generics::printing::print_const_argument(expr, tokens);
784                }
785                GenericArgument::AssocType(assoc) => assoc.to_tokens(tokens),
786                GenericArgument::AssocConst(assoc) => assoc.to_tokens(tokens),
787                GenericArgument::Constraint(constraint) => constraint.to_tokens(tokens),
788            }
789        }
790    }
791
792    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
793    impl ToTokens for AngleBracketedGenericArguments {
794        fn to_tokens(&self, tokens: &mut TokenStream) {
795            print_angle_bracketed_generic_arguments(tokens, self, PathStyle::AsWritten);
796        }
797    }
798
799    pub(crate) fn print_angle_bracketed_generic_arguments(
800        tokens: &mut TokenStream,
801        arguments: &AngleBracketedGenericArguments,
802        style: PathStyle,
803    ) {
804        if let PathStyle::Mod = style {
805            return;
806        }
807
808        conditionally_print_turbofish(tokens, &arguments.colon2_token, style);
809        arguments.lt_token.to_tokens(tokens);
810
811        // Print lifetimes before types/consts/bindings, regardless of their
812        // order in args.
813        let mut trailing_or_empty = true;
814        for param in arguments.args.pairs() {
815            match param.value() {
816                GenericArgument::Lifetime(_) => {
817                    param.to_tokens(tokens);
818                    trailing_or_empty = param.punct().is_some();
819                }
820                GenericArgument::Type(_)
821                | GenericArgument::Const(_)
822                | GenericArgument::AssocType(_)
823                | GenericArgument::AssocConst(_)
824                | GenericArgument::Constraint(_) => {}
825            }
826        }
827        for param in arguments.args.pairs() {
828            match param.value() {
829                GenericArgument::Type(_)
830                | GenericArgument::Const(_)
831                | GenericArgument::AssocType(_)
832                | GenericArgument::AssocConst(_)
833                | GenericArgument::Constraint(_) => {
834                    if !trailing_or_empty {
835                        <Token![,]>::default().to_tokens(tokens);
836                    }
837                    param.to_tokens(tokens);
838                    trailing_or_empty = param.punct().is_some();
839                }
840                GenericArgument::Lifetime(_) => {}
841            }
842        }
843
844        arguments.gt_token.to_tokens(tokens);
845    }
846
847    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
848    impl ToTokens for AssocType {
849        fn to_tokens(&self, tokens: &mut TokenStream) {
850            self.ident.to_tokens(tokens);
851            self.generics.to_tokens(tokens);
852            self.eq_token.to_tokens(tokens);
853            self.ty.to_tokens(tokens);
854        }
855    }
856
857    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
858    impl ToTokens for AssocConst {
859        fn to_tokens(&self, tokens: &mut TokenStream) {
860            self.ident.to_tokens(tokens);
861            self.generics.to_tokens(tokens);
862            self.eq_token.to_tokens(tokens);
863            generics::printing::print_const_argument(&self.value, tokens);
864        }
865    }
866
867    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
868    impl ToTokens for Constraint {
869        fn to_tokens(&self, tokens: &mut TokenStream) {
870            self.ident.to_tokens(tokens);
871            self.generics.to_tokens(tokens);
872            self.colon_token.to_tokens(tokens);
873            self.bounds.to_tokens(tokens);
874        }
875    }
876
877    #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
878    impl ToTokens for ParenthesizedGenericArguments {
879        fn to_tokens(&self, tokens: &mut TokenStream) {
880            print_parenthesized_generic_arguments(tokens, self, PathStyle::AsWritten);
881        }
882    }
883
884    fn print_parenthesized_generic_arguments(
885        tokens: &mut TokenStream,
886        arguments: &ParenthesizedGenericArguments,
887        style: PathStyle,
888    ) {
889        if let PathStyle::Mod = style {
890            return;
891        }
892
893        conditionally_print_turbofish(tokens, &None, style);
894        arguments.paren_token.surround(tokens, |tokens| {
895            arguments.inputs.to_tokens(tokens);
896        });
897        arguments.output.to_tokens(tokens);
898    }
899
900    pub(crate) fn print_qpath(
901        tokens: &mut TokenStream,
902        qself: &Option<QSelf>,
903        path: &Path,
904        style: PathStyle,
905    ) {
906        let qself = match qself {
907            Some(qself) => qself,
908            None => {
909                print_path(tokens, path, style);
910                return;
911            }
912        };
913        qself.lt_token.to_tokens(tokens);
914        qself.ty.to_tokens(tokens);
915
916        let pos = cmp::min(qself.position, path.segments.len());
917        let mut segments = path.segments.pairs();
918        if pos > 0 {
919            TokensOrDefault(&qself.as_token).to_tokens(tokens);
920            path.leading_colon.to_tokens(tokens);
921            for (i, segment) in segments.by_ref().take(pos).enumerate() {
922                print_path_segment(tokens, segment.value(), PathStyle::AsWritten);
923                if i + 1 == pos {
924                    qself.gt_token.to_tokens(tokens);
925                }
926                segment.punct().to_tokens(tokens);
927            }
928        } else {
929            qself.gt_token.to_tokens(tokens);
930            path.leading_colon.to_tokens(tokens);
931        }
932        for segment in segments {
933            print_path_segment(tokens, segment.value(), style);
934            segment.punct().to_tokens(tokens);
935        }
936    }
937
938    fn conditionally_print_turbofish(
939        tokens: &mut TokenStream,
940        colon2_token: &Option<Token![::]>,
941        style: PathStyle,
942    ) {
943        match style {
944            PathStyle::Expr => TokensOrDefault(colon2_token).to_tokens(tokens),
945            PathStyle::Mod => unreachable!(),
946            PathStyle::AsWritten => colon2_token.to_tokens(tokens),
947        }
948    }
949
950    #[cfg(feature = "parsing")]
951    #[cfg_attr(docsrs, doc(cfg(all(feature = "parsing", feature = "printing"))))]
952    impl Spanned for QSelf {
953        fn span(&self) -> Span {
954            struct QSelfDelimiters<'a>(&'a QSelf);
955
956            impl<'a> ToTokens for QSelfDelimiters<'a> {
957                fn to_tokens(&self, tokens: &mut TokenStream) {
958                    self.0.lt_token.to_tokens(tokens);
959                    self.0.gt_token.to_tokens(tokens);
960                }
961            }
962
963            QSelfDelimiters(self).span()
964        }
965    }
966}
syn/path.rs

syn/
path.rs
