aboutsummaryrefslogtreecommitdiff
path: root/vendor/syn/src/path.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/syn/src/path.rs')
-rw-r--r--vendor/syn/src/path.rs877
1 files changed, 0 insertions, 877 deletions
diff --git a/vendor/syn/src/path.rs b/vendor/syn/src/path.rs
deleted file mode 100644
index 975154a..0000000
--- a/vendor/syn/src/path.rs
+++ /dev/null
@@ -1,877 +0,0 @@
-use super::*;
-use crate::punctuated::Punctuated;
-
-ast_struct! {
- /// A path at which a named item is exported (e.g. `std::collections::HashMap`).
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub struct Path {
- pub leading_colon: Option<Token![::]>,
- pub segments: Punctuated<PathSegment, Token![::]>,
- }
-}
-
-impl<T> From<T> for Path
-where
- T: Into<PathSegment>,
-{
- fn from(segment: T) -> Self {
- let mut path = Path {
- leading_colon: None,
- segments: Punctuated::new(),
- };
- path.segments.push_value(segment.into());
- path
- }
-}
-
-impl Path {
- /// Determines whether this is a path of length 1 equal to the given
- /// ident.
- ///
- /// For them to compare equal, it must be the case that:
- ///
- /// - the path has no leading colon,
- /// - the number of path segments is 1,
- /// - the first path segment has no angle bracketed or parenthesized
- /// path arguments, and
- /// - the ident of the first path segment is equal to the given one.
- ///
- /// # Example
- ///
- /// ```
- /// use proc_macro2::TokenStream;
- /// use syn::{Attribute, Error, Meta, Result};
- ///
- /// fn get_serde_meta_item(attr: &Attribute) -> Result<Option<&TokenStream>> {
- /// if attr.path().is_ident("serde") {
- /// match &attr.meta {
- /// Meta::List(meta) => Ok(Some(&meta.tokens)),
- /// bad => Err(Error::new_spanned(bad, "unrecognized attribute")),
- /// }
- /// } else {
- /// Ok(None)
- /// }
- /// }
- /// ```
- pub fn is_ident<I>(&self, ident: &I) -> bool
- where
- I: ?Sized,
- Ident: PartialEq<I>,
- {
- match self.get_ident() {
- Some(id) => id == ident,
- None => false,
- }
- }
-
- /// If this path consists of a single ident, returns the ident.
- ///
- /// A path is considered an ident if:
- ///
- /// - the path has no leading colon,
- /// - the number of path segments is 1, and
- /// - the first path segment has no angle bracketed or parenthesized
- /// path arguments.
- pub fn get_ident(&self) -> Option<&Ident> {
- if self.leading_colon.is_none()
- && self.segments.len() == 1
- && self.segments[0].arguments.is_none()
- {
- Some(&self.segments[0].ident)
- } else {
- None
- }
- }
-
- /// An error if this path is not a single ident, as defined in `get_ident`.
- #[cfg(feature = "parsing")]
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- pub fn require_ident(&self) -> Result<&Ident> {
- self.get_ident().ok_or_else(|| {
- crate::error::new2(
- self.segments.first().unwrap().ident.span(),
- self.segments.last().unwrap().ident.span(),
- "expected this path to be an identifier",
- )
- })
- }
-}
-
-ast_struct! {
- /// A segment of a path together with any path arguments on that segment.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub struct PathSegment {
- pub ident: Ident,
- pub arguments: PathArguments,
- }
-}
-
-impl<T> From<T> for PathSegment
-where
- T: Into<Ident>,
-{
- fn from(ident: T) -> Self {
- PathSegment {
- ident: ident.into(),
- arguments: PathArguments::None,
- }
- }
-}
-
-ast_enum! {
- /// Angle bracketed or parenthesized arguments of a path segment.
- ///
- /// ## Angle bracketed
- ///
- /// The `<'a, T>` in `std::slice::iter<'a, T>`.
- ///
- /// ## Parenthesized
- ///
- /// The `(A, B) -> C` in `Fn(A, B) -> C`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub enum PathArguments {
- None,
- /// The `<'a, T>` in `std::slice::iter<'a, T>`.
- AngleBracketed(AngleBracketedGenericArguments),
- /// The `(A, B) -> C` in `Fn(A, B) -> C`.
- Parenthesized(ParenthesizedGenericArguments),
- }
-}
-
-impl Default for PathArguments {
- fn default() -> Self {
- PathArguments::None
- }
-}
-
-impl PathArguments {
- pub fn is_empty(&self) -> bool {
- match self {
- PathArguments::None => true,
- PathArguments::AngleBracketed(bracketed) => bracketed.args.is_empty(),
- PathArguments::Parenthesized(_) => false,
- }
- }
-
- pub fn is_none(&self) -> bool {
- match self {
- PathArguments::None => true,
- PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => false,
- }
- }
-}
-
-ast_enum! {
- /// An individual generic argument, like `'a`, `T`, or `Item = T`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- #[non_exhaustive]
- pub enum GenericArgument {
- /// A lifetime argument.
- Lifetime(Lifetime),
- /// A type argument.
- Type(Type),
- /// A const expression. Must be inside of a block.
- ///
- /// NOTE: Identity expressions are represented as Type arguments, as
- /// they are indistinguishable syntactically.
- Const(Expr),
- /// A binding (equality constraint) on an associated type: the `Item =
- /// u8` in `Iterator<Item = u8>`.
- AssocType(AssocType),
- /// An equality constraint on an associated constant: the `PANIC =
- /// false` in `Trait<PANIC = false>`.
- AssocConst(AssocConst),
- /// An associated type bound: `Iterator<Item: Display>`.
- Constraint(Constraint),
- }
-}
-
-ast_struct! {
- /// Angle bracketed arguments of a path segment: the `<K, V>` in `HashMap<K,
- /// V>`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub struct AngleBracketedGenericArguments {
- pub colon2_token: Option<Token![::]>,
- pub lt_token: Token![<],
- pub args: Punctuated<GenericArgument, Token![,]>,
- pub gt_token: Token![>],
- }
-}
-
-ast_struct! {
- /// A binding (equality constraint) on an associated type: the `Item = u8`
- /// in `Iterator<Item = u8>`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub struct AssocType {
- pub ident: Ident,
- pub generics: Option<AngleBracketedGenericArguments>,
- pub eq_token: Token![=],
- pub ty: Type,
- }
-}
-
-ast_struct! {
- /// An equality constraint on an associated constant: the `PANIC = false` in
- /// `Trait<PANIC = false>`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub struct AssocConst {
- pub ident: Ident,
- pub generics: Option<AngleBracketedGenericArguments>,
- pub eq_token: Token![=],
- pub value: Expr,
- }
-}
-
-ast_struct! {
- /// An associated type bound: `Iterator<Item: Display>`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub struct Constraint {
- pub ident: Ident,
- pub generics: Option<AngleBracketedGenericArguments>,
- pub colon_token: Token![:],
- pub bounds: Punctuated<TypeParamBound, Token![+]>,
- }
-}
-
-ast_struct! {
- /// Arguments of a function path segment: the `(A, B) -> C` in `Fn(A,B) ->
- /// C`.
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub struct ParenthesizedGenericArguments {
- pub paren_token: token::Paren,
- /// `(A, B)`
- pub inputs: Punctuated<Type, Token![,]>,
- /// `C`
- pub output: ReturnType,
- }
-}
-
-ast_struct! {
- /// The explicit Self type in a qualified path: the `T` in `<T as
- /// Display>::fmt`.
- ///
- /// The actual path, including the trait and the associated item, is stored
- /// separately. The `position` field represents the index of the associated
- /// item qualified with this Self type.
- ///
- /// ```text
- /// <Vec<T> as a::b::Trait>::AssociatedItem
- /// ^~~~~~ ~~~~~~~~~~~~~~^
- /// ty position = 3
- ///
- /// <Vec<T>>::AssociatedItem
- /// ^~~~~~ ^
- /// ty position = 0
- /// ```
- #[cfg_attr(doc_cfg, doc(cfg(any(feature = "full", feature = "derive"))))]
- pub struct QSelf {
- pub lt_token: Token![<],
- pub ty: Box<Type>,
- pub position: usize,
- pub as_token: Option<Token![as]>,
- pub gt_token: Token![>],
- }
-}
-
-#[cfg(feature = "parsing")]
-pub(crate) mod parsing {
- use super::*;
-
- use crate::ext::IdentExt as _;
- use crate::parse::{Parse, ParseStream, Result};
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for Path {
- fn parse(input: ParseStream) -> Result<Self> {
- Self::parse_helper(input, false)
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for GenericArgument {
- fn parse(input: ParseStream) -> Result<Self> {
- if input.peek(Lifetime) && !input.peek2(Token![+]) {
- return Ok(GenericArgument::Lifetime(input.parse()?));
- }
-
- if input.peek(Lit) || input.peek(token::Brace) {
- return const_argument(input).map(GenericArgument::Const);
- }
-
- let mut argument: Type = input.parse()?;
-
- match argument {
- Type::Path(mut ty)
- if ty.qself.is_none()
- && ty.path.leading_colon.is_none()
- && ty.path.segments.len() == 1
- && match &ty.path.segments[0].arguments {
- PathArguments::None | PathArguments::AngleBracketed(_) => true,
- PathArguments::Parenthesized(_) => false,
- } =>
- {
- if let Some(eq_token) = input.parse::<Option<Token![=]>>()? {
- let segment = ty.path.segments.pop().unwrap().into_value();
- let ident = segment.ident;
- let generics = match segment.arguments {
- PathArguments::None => None,
- PathArguments::AngleBracketed(arguments) => Some(arguments),
- PathArguments::Parenthesized(_) => unreachable!(),
- };
- return if input.peek(Lit) || input.peek(token::Brace) {
- Ok(GenericArgument::AssocConst(AssocConst {
- ident,
- generics,
- eq_token,
- value: const_argument(input)?,
- }))
- } else {
- Ok(GenericArgument::AssocType(AssocType {
- ident,
- generics,
- eq_token,
- ty: input.parse()?,
- }))
- };
- }
-
- #[cfg(feature = "full")]
- if let Some(colon_token) = input.parse::<Option<Token![:]>>()? {
- let segment = ty.path.segments.pop().unwrap().into_value();
- return Ok(GenericArgument::Constraint(Constraint {
- ident: segment.ident,
- generics: match segment.arguments {
- PathArguments::None => None,
- PathArguments::AngleBracketed(arguments) => Some(arguments),
- PathArguments::Parenthesized(_) => unreachable!(),
- },
- colon_token,
- bounds: {
- let mut bounds = Punctuated::new();
- loop {
- if input.peek(Token![,]) || input.peek(Token![>]) {
- break;
- }
- let value: TypeParamBound = input.parse()?;
- bounds.push_value(value);
- if !input.peek(Token![+]) {
- break;
- }
- let punct: Token![+] = input.parse()?;
- bounds.push_punct(punct);
- }
- bounds
- },
- }));
- }
-
- argument = Type::Path(ty);
- }
- _ => {}
- }
-
- Ok(GenericArgument::Type(argument))
- }
- }
-
- pub(crate) fn const_argument(input: ParseStream) -> Result<Expr> {
- let lookahead = input.lookahead1();
-
- if input.peek(Lit) {
- let lit = input.parse()?;
- return Ok(Expr::Lit(lit));
- }
-
- if input.peek(Ident) {
- let ident: Ident = input.parse()?;
- return Ok(Expr::Path(ExprPath {
- attrs: Vec::new(),
- qself: None,
- path: Path::from(ident),
- }));
- }
-
- if input.peek(token::Brace) {
- #[cfg(feature = "full")]
- {
- let block: ExprBlock = input.parse()?;
- return Ok(Expr::Block(block));
- }
-
- #[cfg(not(feature = "full"))]
- {
- let begin = input.fork();
- let content;
- braced!(content in input);
- content.parse::<Expr>()?;
- let verbatim = verbatim::between(&begin, input);
- return Ok(Expr::Verbatim(verbatim));
- }
- }
-
- Err(lookahead.error())
- }
-
- impl AngleBracketedGenericArguments {
- /// Parse `::<…>` with mandatory leading `::`.
- ///
- /// The ordinary [`Parse`] impl for `AngleBracketedGenericArguments`
- /// parses optional leading `::`.
- #[cfg(feature = "full")]
- #[cfg_attr(doc_cfg, doc(cfg(all(feature = "parsing", feature = "full"))))]
- pub fn parse_turbofish(input: ParseStream) -> Result<Self> {
- let colon2_token: Token![::] = input.parse()?;
- Self::do_parse(Some(colon2_token), input)
- }
-
- pub(crate) fn do_parse(
- colon2_token: Option<Token![::]>,
- input: ParseStream,
- ) -> Result<Self> {
- Ok(AngleBracketedGenericArguments {
- colon2_token,
- lt_token: input.parse()?,
- args: {
- let mut args = Punctuated::new();
- loop {
- if input.peek(Token![>]) {
- break;
- }
- let value: GenericArgument = input.parse()?;
- args.push_value(value);
- if input.peek(Token![>]) {
- break;
- }
- let punct: Token![,] = input.parse()?;
- args.push_punct(punct);
- }
- args
- },
- gt_token: input.parse()?,
- })
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for AngleBracketedGenericArguments {
- fn parse(input: ParseStream) -> Result<Self> {
- let colon2_token: Option<Token![::]> = input.parse()?;
- Self::do_parse(colon2_token, input)
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for ParenthesizedGenericArguments {
- fn parse(input: ParseStream) -> Result<Self> {
- let content;
- Ok(ParenthesizedGenericArguments {
- paren_token: parenthesized!(content in input),
- inputs: content.parse_terminated(Type::parse, Token![,])?,
- output: input.call(ReturnType::without_plus)?,
- })
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- impl Parse for PathSegment {
- fn parse(input: ParseStream) -> Result<Self> {
- Self::parse_helper(input, false)
- }
- }
-
- impl PathSegment {
- fn parse_helper(input: ParseStream, expr_style: bool) -> Result<Self> {
- if input.peek(Token![super])
- || input.peek(Token![self])
- || input.peek(Token![crate])
- || cfg!(feature = "full") && input.peek(Token![try])
- {
- let ident = input.call(Ident::parse_any)?;
- return Ok(PathSegment::from(ident));
- }
-
- let ident = if input.peek(Token![Self]) {
- input.call(Ident::parse_any)?
- } else {
- input.parse()?
- };
-
- if !expr_style && input.peek(Token![<]) && !input.peek(Token![<=])
- || input.peek(Token![::]) && input.peek3(Token![<])
- {
- Ok(PathSegment {
- ident,
- arguments: PathArguments::AngleBracketed(input.parse()?),
- })
- } else {
- Ok(PathSegment::from(ident))
- }
- }
- }
-
- impl Path {
- /// Parse a `Path` containing no path arguments on any of its segments.
- ///
- /// # Example
- ///
- /// ```
- /// use syn::{Path, Result, Token};
- /// use syn::parse::{Parse, ParseStream};
- ///
- /// // A simplified single `use` statement like:
- /// //
- /// // use std::collections::HashMap;
- /// //
- /// // Note that generic parameters are not allowed in a `use` statement
- /// // so the following must not be accepted.
- /// //
- /// // use a::<b>::c;
- /// struct SingleUse {
- /// use_token: Token![use],
- /// path: Path,
- /// }
- ///
- /// impl Parse for SingleUse {
- /// fn parse(input: ParseStream) -> Result<Self> {
- /// Ok(SingleUse {
- /// use_token: input.parse()?,
- /// path: input.call(Path::parse_mod_style)?,
- /// })
- /// }
- /// }
- /// ```
- #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
- pub fn parse_mod_style(input: ParseStream) -> Result<Self> {
- Ok(Path {
- leading_colon: input.parse()?,
- segments: {
- let mut segments = Punctuated::new();
- loop {
- if !input.peek(Ident)
- && !input.peek(Token![super])
- && !input.peek(Token![self])
- && !input.peek(Token![Self])
- && !input.peek(Token![crate])
- {
- break;
- }
- let ident = Ident::parse_any(input)?;
- segments.push_value(PathSegment::from(ident));
- if !input.peek(Token![::]) {
- break;
- }
- let punct = input.parse()?;
- segments.push_punct(punct);
- }
- if segments.is_empty() {
- return Err(input.parse::<Ident>().unwrap_err());
- } else if segments.trailing_punct() {
- return Err(input.error("expected path segment after `::`"));
- }
- segments
- },
- })
- }
-
- pub(crate) fn parse_helper(input: ParseStream, expr_style: bool) -> Result<Self> {
- let mut path = Path {
- leading_colon: input.parse()?,
- segments: {
- let mut segments = Punctuated::new();
- let value = PathSegment::parse_helper(input, expr_style)?;
- segments.push_value(value);
- segments
- },
- };
- Path::parse_rest(input, &mut path, expr_style)?;
- Ok(path)
- }
-
- pub(crate) fn parse_rest(
- input: ParseStream,
- path: &mut Self,
- expr_style: bool,
- ) -> Result<()> {
- while input.peek(Token![::]) && !input.peek3(token::Paren) {
- let punct: Token![::] = input.parse()?;
- path.segments.push_punct(punct);
- let value = PathSegment::parse_helper(input, expr_style)?;
- path.segments.push_value(value);
- }
- Ok(())
- }
-
- pub(crate) fn is_mod_style(&self) -> bool {
- self.segments
- .iter()
- .all(|segment| segment.arguments.is_none())
- }
- }
-
- pub(crate) fn qpath(input: ParseStream, expr_style: bool) -> Result<(Option<QSelf>, Path)> {
- if input.peek(Token![<]) {
- let lt_token: Token![<] = input.parse()?;
- let this: Type = input.parse()?;
- let path = if input.peek(Token![as]) {
- let as_token: Token![as] = input.parse()?;
- let path: Path = input.parse()?;
- Some((as_token, path))
- } else {
- None
- };
- let gt_token: Token![>] = input.parse()?;
- let colon2_token: Token![::] = input.parse()?;
- let mut rest = Punctuated::new();
- loop {
- let path = PathSegment::parse_helper(input, expr_style)?;
- rest.push_value(path);
- if !input.peek(Token![::]) {
- break;
- }
- let punct: Token![::] = input.parse()?;
- rest.push_punct(punct);
- }
- let (position, as_token, path) = match path {
- Some((as_token, mut path)) => {
- let pos = path.segments.len();
- path.segments.push_punct(colon2_token);
- path.segments.extend(rest.into_pairs());
- (pos, Some(as_token), path)
- }
- None => {
- let path = Path {
- leading_colon: Some(colon2_token),
- segments: rest,
- };
- (0, None, path)
- }
- };
- let qself = QSelf {
- lt_token,
- ty: Box::new(this),
- position,
- as_token,
- gt_token,
- };
- Ok((Some(qself), path))
- } else {
- let path = Path::parse_helper(input, expr_style)?;
- Ok((None, path))
- }
- }
-}
-
-#[cfg(feature = "printing")]
-pub(crate) mod printing {
- use super::*;
- use crate::print::TokensOrDefault;
- #[cfg(feature = "parsing")]
- use crate::spanned::Spanned;
- #[cfg(feature = "parsing")]
- use proc_macro2::Span;
- use proc_macro2::TokenStream;
- use quote::ToTokens;
- use std::cmp;
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for Path {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- self.leading_colon.to_tokens(tokens);
- self.segments.to_tokens(tokens);
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for PathSegment {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- self.ident.to_tokens(tokens);
- self.arguments.to_tokens(tokens);
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for PathArguments {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- match self {
- PathArguments::None => {}
- PathArguments::AngleBracketed(arguments) => {
- arguments.to_tokens(tokens);
- }
- PathArguments::Parenthesized(arguments) => {
- arguments.to_tokens(tokens);
- }
- }
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for GenericArgument {
- #[allow(clippy::match_same_arms)]
- fn to_tokens(&self, tokens: &mut TokenStream) {
- match self {
- GenericArgument::Lifetime(lt) => lt.to_tokens(tokens),
- GenericArgument::Type(ty) => ty.to_tokens(tokens),
- GenericArgument::Const(expr) => match expr {
- Expr::Lit(expr) => expr.to_tokens(tokens),
-
- Expr::Path(expr)
- if expr.attrs.is_empty()
- && expr.qself.is_none()
- && expr.path.get_ident().is_some() =>
- {
- expr.to_tokens(tokens);
- }
-
- #[cfg(feature = "full")]
- Expr::Block(expr) => expr.to_tokens(tokens),
-
- #[cfg(not(feature = "full"))]
- Expr::Verbatim(expr) => expr.to_tokens(tokens),
-
- // ERROR CORRECTION: Add braces to make sure that the
- // generated code is valid.
- _ => token::Brace::default().surround(tokens, |tokens| {
- expr.to_tokens(tokens);
- }),
- },
- GenericArgument::AssocType(assoc) => assoc.to_tokens(tokens),
- GenericArgument::AssocConst(assoc) => assoc.to_tokens(tokens),
- GenericArgument::Constraint(constraint) => constraint.to_tokens(tokens),
- }
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for AngleBracketedGenericArguments {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- self.colon2_token.to_tokens(tokens);
- self.lt_token.to_tokens(tokens);
-
- // Print lifetimes before types/consts/bindings, regardless of their
- // order in self.args.
- let mut trailing_or_empty = true;
- for param in self.args.pairs() {
- match param.value() {
- GenericArgument::Lifetime(_) => {
- param.to_tokens(tokens);
- trailing_or_empty = param.punct().is_some();
- }
- GenericArgument::Type(_)
- | GenericArgument::Const(_)
- | GenericArgument::AssocType(_)
- | GenericArgument::AssocConst(_)
- | GenericArgument::Constraint(_) => {}
- }
- }
- for param in self.args.pairs() {
- match param.value() {
- GenericArgument::Type(_)
- | GenericArgument::Const(_)
- | GenericArgument::AssocType(_)
- | GenericArgument::AssocConst(_)
- | GenericArgument::Constraint(_) => {
- if !trailing_or_empty {
- <Token![,]>::default().to_tokens(tokens);
- }
- param.to_tokens(tokens);
- trailing_or_empty = param.punct().is_some();
- }
- GenericArgument::Lifetime(_) => {}
- }
- }
-
- self.gt_token.to_tokens(tokens);
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for AssocType {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- self.ident.to_tokens(tokens);
- self.generics.to_tokens(tokens);
- self.eq_token.to_tokens(tokens);
- self.ty.to_tokens(tokens);
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for AssocConst {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- self.ident.to_tokens(tokens);
- self.generics.to_tokens(tokens);
- self.eq_token.to_tokens(tokens);
- self.value.to_tokens(tokens);
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for Constraint {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- self.ident.to_tokens(tokens);
- self.generics.to_tokens(tokens);
- self.colon_token.to_tokens(tokens);
- self.bounds.to_tokens(tokens);
- }
- }
-
- #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
- impl ToTokens for ParenthesizedGenericArguments {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- self.paren_token.surround(tokens, |tokens| {
- self.inputs.to_tokens(tokens);
- });
- self.output.to_tokens(tokens);
- }
- }
-
- pub(crate) fn print_path(tokens: &mut TokenStream, qself: &Option<QSelf>, path: &Path) {
- let qself = match qself {
- Some(qself) => qself,
- None => {
- path.to_tokens(tokens);
- return;
- }
- };
- qself.lt_token.to_tokens(tokens);
- qself.ty.to_tokens(tokens);
-
- let pos = cmp::min(qself.position, path.segments.len());
- let mut segments = path.segments.pairs();
- if pos > 0 {
- TokensOrDefault(&qself.as_token).to_tokens(tokens);
- path.leading_colon.to_tokens(tokens);
- for (i, segment) in segments.by_ref().take(pos).enumerate() {
- if i + 1 == pos {
- segment.value().to_tokens(tokens);
- qself.gt_token.to_tokens(tokens);
- segment.punct().to_tokens(tokens);
- } else {
- segment.to_tokens(tokens);
- }
- }
- } else {
- qself.gt_token.to_tokens(tokens);
- path.leading_colon.to_tokens(tokens);
- }
- for segment in segments {
- segment.to_tokens(tokens);
- }
- }
-
- #[cfg(feature = "parsing")]
- #[cfg_attr(doc_cfg, doc(cfg(all(feature = "parsing", feature = "printing"))))]
- impl Spanned for QSelf {
- fn span(&self) -> Span {
- struct QSelfDelimiters<'a>(&'a QSelf);
-
- impl<'a> ToTokens for QSelfDelimiters<'a> {
- fn to_tokens(&self, tokens: &mut TokenStream) {
- self.0.lt_token.to_tokens(tokens);
- self.0.gt_token.to_tokens(tokens);
- }
- }
-
- QSelfDelimiters(self).span()
- }
- }
-}
Copyright © 2024 Valentin A. Popov. All Rights Reverse Engineered.