diff options
Diffstat (limited to 'rust/vendor/syn-0.15.44/src')
41 files changed, 28941 insertions, 0 deletions
diff --git a/rust/vendor/syn-0.15.44/src/attr.rs b/rust/vendor/syn-0.15.44/src/attr.rs new file mode 100644 index 0000000..e0efb57 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/attr.rs @@ -0,0 +1,680 @@ +use super::*; +use punctuated::Punctuated; + +use std::iter; + +use proc_macro2::TokenStream; +#[cfg(not(feature = "parsing"))] +use proc_macro2::{Delimiter, Spacing, TokenTree}; + +#[cfg(feature = "parsing")] +use parse::{ParseStream, Result}; +#[cfg(feature = "extra-traits")] +use std::hash::{Hash, Hasher}; +#[cfg(feature = "extra-traits")] +use tt::TokenStreamHelper; + +ast_struct! { + /// An attribute like `#[repr(transparent)]`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Syntax + /// + /// Rust has six types of attributes. + /// + /// - Outer attributes like `#[repr(transparent)]`. These appear outside or + /// in front of the item they describe. + /// - Inner attributes like `#![feature(proc_macro)]`. These appear inside + /// of the item they describe, usually a module. + /// - Outer doc comments like `/// # Example`. + /// - Inner doc comments like `//! Please file an issue`. + /// - Outer block comments `/** # Example */`. + /// - Inner block comments `/*! Please file an issue */`. + /// + /// The `style` field of type `AttrStyle` distinguishes whether an attribute + /// is outer or inner. Doc comments and block comments are promoted to + /// attributes, as this is how they are processed by the compiler and by + /// `macro_rules!` macros. + /// + /// The `path` field gives the possibly colon-delimited path against which + /// the attribute is resolved. It is equal to `"doc"` for desugared doc + /// comments. The `tts` field contains the rest of the attribute body as + /// tokens. + /// + /// ```text + /// #[derive(Copy)] #[crate::precondition x < 5] + /// ^^^^^^~~~~~~ ^^^^^^^^^^^^^^^^^^^ ~~~~~ + /// path tts path tts + /// ``` + /// + /// Use the [`parse_meta`] method to try parsing the tokens of an attribute + /// into the structured representation that is used by convention across + /// most Rust libraries. + /// + /// [`parse_meta`]: Attribute::parse_meta + /// + /// # Parsing + /// + /// This type does not implement the [`Parse`] trait and thus cannot be + /// parsed directly by [`ParseStream::parse`]. Instead use + /// [`ParseStream::call`] with one of the two parser functions + /// [`Attribute::parse_outer`] or [`Attribute::parse_inner`] depending on + /// which you intend to parse. + /// + /// [`Parse`]: parse::Parse + /// [`ParseStream::parse`]: parse::ParseBuffer::parse + /// [`ParseStream::call`]: parse::ParseBuffer::call + /// + /// ```edition2018 + /// use syn::{Attribute, Ident, Result, Token}; + /// use syn::parse::{Parse, ParseStream}; + /// + /// // Parses a unit struct with attributes. + /// // + /// // #[path = "s.tmpl"] + /// // struct S; + /// struct UnitStruct { + /// attrs: Vec<Attribute>, + /// struct_token: Token![struct], + /// name: Ident, + /// semi_token: Token![;], + /// } + /// + /// impl Parse for UnitStruct { + /// fn parse(input: ParseStream) -> Result<Self> { + /// Ok(UnitStruct { + /// attrs: input.call(Attribute::parse_outer)?, + /// struct_token: input.parse()?, + /// name: input.parse()?, + /// semi_token: input.parse()?, + /// }) + /// } + /// } + /// ``` + pub struct Attribute #manual_extra_traits { + pub pound_token: Token![#], + pub style: AttrStyle, + pub bracket_token: token::Bracket, + pub path: Path, + pub tts: TokenStream, + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for Attribute {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for Attribute { + fn eq(&self, other: &Self) -> bool { + self.style == other.style + && self.pound_token == other.pound_token + && self.bracket_token == other.bracket_token + && self.path == other.path + && TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for Attribute { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + self.style.hash(state); + self.pound_token.hash(state); + self.bracket_token.hash(state); + self.path.hash(state); + TokenStreamHelper(&self.tts).hash(state); + } +} + +impl Attribute { + /// Parses the content of the attribute, consisting of the path and tts, as + /// a [`Meta`] if possible. + /// + /// Deprecated; use `parse_meta` instead. + #[doc(hidden)] + pub fn interpret_meta(&self) -> Option<Meta> { + #[cfg(feature = "parsing")] + { + self.parse_meta().ok() + } + + #[cfg(not(feature = "parsing"))] + { + let name = if self.path.segments.len() == 1 { + &self.path.segments.first().unwrap().value().ident + } else { + return None; + }; + + if self.tts.is_empty() { + return Some(Meta::Word(name.clone())); + } + + let tts = self.tts.clone().into_iter().collect::<Vec<_>>(); + + if tts.len() == 1 { + if let Some(meta) = Attribute::extract_meta_list(name.clone(), &tts[0]) { + return Some(meta); + } + } + + if tts.len() == 2 { + if let Some(meta) = Attribute::extract_name_value(name.clone(), &tts[0], &tts[1]) { + return Some(meta); + } + } + + None + } + } + + /// Parses the content of the attribute, consisting of the path and tts, as + /// a [`Meta`] if possible. + #[cfg(feature = "parsing")] + pub fn parse_meta(&self) -> Result<Meta> { + if let Some(ref colon) = self.path.leading_colon { + return Err(Error::new(colon.spans[0], "expected meta identifier")); + } + + let first_segment = self + .path + .segments + .first() + .expect("paths have at least one segment"); + if let Some(colon) = first_segment.punct() { + return Err(Error::new(colon.spans[0], "expected meta value")); + } + let ident = first_segment.value().ident.clone(); + + let parser = |input: ParseStream| parsing::parse_meta_after_ident(ident, input); + parse::Parser::parse2(parser, self.tts.clone()) + } + + /// Parses zero or more outer attributes from the stream. + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + #[cfg(feature = "parsing")] + pub fn parse_outer(input: ParseStream) -> Result<Vec<Self>> { + let mut attrs = Vec::new(); + while input.peek(Token![#]) { + attrs.push(input.call(parsing::single_parse_outer)?); + } + Ok(attrs) + } + + /// Parses zero or more inner attributes from the stream. + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + #[cfg(feature = "parsing")] + pub fn parse_inner(input: ParseStream) -> Result<Vec<Self>> { + let mut attrs = Vec::new(); + while input.peek(Token![#]) && input.peek2(Token![!]) { + attrs.push(input.call(parsing::single_parse_inner)?); + } + Ok(attrs) + } + + #[cfg(not(feature = "parsing"))] + fn extract_meta_list(ident: Ident, tt: &TokenTree) -> Option<Meta> { + let g = match *tt { + TokenTree::Group(ref g) => g, + _ => return None, + }; + if g.delimiter() != Delimiter::Parenthesis { + return None; + } + let tokens = g.stream().clone().into_iter().collect::<Vec<_>>(); + let nested = match list_of_nested_meta_items_from_tokens(&tokens) { + Some(n) => n, + None => return None, + }; + Some(Meta::List(MetaList { + paren_token: token::Paren(g.span()), + ident: ident, + nested: nested, + })) + } + + #[cfg(not(feature = "parsing"))] + fn extract_name_value(ident: Ident, a: &TokenTree, b: &TokenTree) -> Option<Meta> { + let a = match *a { + TokenTree::Punct(ref o) => o, + _ => return None, + }; + if a.spacing() != Spacing::Alone { + return None; + } + if a.as_char() != '=' { + return None; + } + + match *b { + TokenTree::Literal(ref l) if !l.to_string().starts_with('/') => { + Some(Meta::NameValue(MetaNameValue { + ident: ident, + eq_token: Token]), + lit: Lit::new(l.clone()), + })) + } + TokenTree::Ident(ref v) => match &v.to_string()[..] { + v @ "true" | v @ "false" => Some(Meta::NameValue(MetaNameValue { + ident: ident, + eq_token: Token]), + lit: Lit::Bool(LitBool { + value: v == "true", + span: b.span(), + }), + })), + _ => None, + }, + _ => None, + } + } +} + +#[cfg(not(feature = "parsing"))] +fn nested_meta_item_from_tokens(tts: &[TokenTree]) -> Option<(NestedMeta, &[TokenTree])> { + assert!(!tts.is_empty()); + + match tts[0] { + TokenTree::Literal(ref lit) => { + if lit.to_string().starts_with('/') { + None + } else { + let lit = Lit::new(lit.clone()); + Some((NestedMeta::Literal(lit), &tts[1..])) + } + } + + TokenTree::Ident(ref ident) => { + if tts.len() >= 3 { + if let Some(meta) = Attribute::extract_name_value(ident.clone(), &tts[1], &tts[2]) { + return Some((NestedMeta::Meta(meta), &tts[3..])); + } + } + + if tts.len() >= 2 { + if let Some(meta) = Attribute::extract_meta_list(ident.clone(), &tts[1]) { + return Some((NestedMeta::Meta(meta), &tts[2..])); + } + } + + let nested_meta = if ident == "true" || ident == "false" { + NestedMeta::Literal(Lit::Bool(LitBool { + value: ident == "true", + span: ident.span(), + })) + } else { + NestedMeta::Meta(Meta::Word(ident.clone())) + }; + Some((nested_meta, &tts[1..])) + } + + _ => None, + } +} + +#[cfg(not(feature = "parsing"))] +fn list_of_nested_meta_items_from_tokens( + mut tts: &[TokenTree], +) -> Option<Punctuated<NestedMeta, Token![,]>> { + let mut nested_meta_items = Punctuated::new(); + let mut first = true; + + while !tts.is_empty() { + let prev_comma = if first { + first = false; + None + } else if let TokenTree::Punct(ref op) = tts[0] { + if op.spacing() != Spacing::Alone { + return None; + } + if op.as_char() != ',' { + return None; + } + let tok = Token]); + tts = &tts[1..]; + if tts.is_empty() { + break; + } + Some(tok) + } else { + return None; + }; + let (nested, rest) = match nested_meta_item_from_tokens(tts) { + Some(pair) => pair, + None => return None, + }; + if let Some(comma) = prev_comma { + nested_meta_items.push_punct(comma); + } + nested_meta_items.push_value(nested); + tts = rest; + } + + Some(nested_meta_items) +} + +ast_enum! { + /// Distinguishes between attributes that decorate an item and attributes + /// that are contained within an item. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Outer attributes + /// + /// - `#[repr(transparent)]` + /// - `/// # Example` + /// - `/** Please file an issue */` + /// + /// # Inner attributes + /// + /// - `#![feature(proc_macro)]` + /// - `//! # Example` + /// - `/*! Please file an issue */` + #[cfg_attr(feature = "clone-impls", derive(Copy))] + pub enum AttrStyle { + Outer, + Inner(Token![!]), + } +} + +ast_enum_of_structs! { + /// Content of a compile-time structured attribute. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// ## Word + /// + /// A meta word is like the `test` in `#[test]`. + /// + /// ## List + /// + /// A meta list is like the `derive(Copy)` in `#[derive(Copy)]`. + /// + /// ## NameValue + /// + /// A name-value meta is like the `path = "..."` in `#[path = + /// "sys/windows.rs"]`. + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum Meta { + pub Word(Ident), + /// A structured list within an attribute, like `derive(Copy, Clone)`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub List(MetaList { + pub ident: Ident, + pub paren_token: token::Paren, + pub nested: Punctuated<NestedMeta, Token![,]>, + }), + /// A name-value pair within an attribute, like `feature = "nightly"`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub NameValue(MetaNameValue { + pub ident: Ident, + pub eq_token: Token![=], + pub lit: Lit, + }), + } +} + +impl Meta { + /// Returns the identifier that begins this structured meta item. + /// + /// For example this would return the `test` in `#[test]`, the `derive` in + /// `#[derive(Copy)]`, and the `path` in `#[path = "sys/windows.rs"]`. + pub fn name(&self) -> Ident { + match *self { + Meta::Word(ref meta) => meta.clone(), + Meta::List(ref meta) => meta.ident.clone(), + Meta::NameValue(ref meta) => meta.ident.clone(), + } + } +} + +ast_enum_of_structs! { + /// Element of a compile-time attribute list. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum NestedMeta { + /// A structured meta item, like the `Copy` in `#[derive(Copy)]` which + /// would be a nested `Meta::Word`. + pub Meta(Meta), + + /// A Rust literal, like the `"new_name"` in `#[rename("new_name")]`. + pub Literal(Lit), + } +} + +/// Conventional argument type associated with an invocation of an attribute +/// macro. +/// +/// For example if we are developing an attribute macro that is intended to be +/// invoked on function items as follows: +/// +/// ```edition2018 +/// # const IGNORE: &str = stringify! { +/// #[my_attribute(path = "/v1/refresh")] +/// # }; +/// pub fn refresh() { +/// /* ... */ +/// } +/// ``` +/// +/// The implementation of this macro would want to parse its attribute arguments +/// as type `AttributeArgs`. +/// +/// ```edition2018 +/// extern crate proc_macro; +/// +/// use proc_macro::TokenStream; +/// use syn::{parse_macro_input, AttributeArgs, ItemFn}; +/// +/// # const IGNORE: &str = stringify! { +/// #[proc_macro_attribute] +/// # }; +/// pub fn my_attribute(args: TokenStream, input: TokenStream) -> TokenStream { +/// let args = parse_macro_input!(args as AttributeArgs); +/// let input = parse_macro_input!(input as ItemFn); +/// +/// /* ... */ +/// # "".parse().unwrap() +/// } +/// ``` +pub type AttributeArgs = Vec<NestedMeta>; + +pub trait FilterAttrs<'a> { + type Ret: Iterator<Item = &'a Attribute>; + + fn outer(self) -> Self::Ret; + fn inner(self) -> Self::Ret; +} + +impl<'a, T> FilterAttrs<'a> for T +where + T: IntoIterator<Item = &'a Attribute>, +{ + type Ret = iter::Filter<T::IntoIter, fn(&&Attribute) -> bool>; + + fn outer(self) -> Self::Ret { + #[cfg_attr(feature = "cargo-clippy", allow(trivially_copy_pass_by_ref))] + fn is_outer(attr: &&Attribute) -> bool { + match attr.style { + AttrStyle::Outer => true, + _ => false, + } + } + self.into_iter().filter(is_outer) + } + + fn inner(self) -> Self::Ret { + #[cfg_attr(feature = "cargo-clippy", allow(trivially_copy_pass_by_ref))] + fn is_inner(attr: &&Attribute) -> bool { + match attr.style { + AttrStyle::Inner(_) => true, + _ => false, + } + } + self.into_iter().filter(is_inner) + } +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use ext::IdentExt; + use parse::{Parse, ParseStream, Result}; + #[cfg(feature = "full")] + use private; + + pub fn single_parse_inner(input: ParseStream) -> Result<Attribute> { + let content; + Ok(Attribute { + pound_token: input.parse()?, + style: AttrStyle::Inner(input.parse()?), + bracket_token: bracketed!(content in input), + path: content.call(Path::parse_mod_style)?, + tts: content.parse()?, + }) + } + + pub fn single_parse_outer(input: ParseStream) -> Result<Attribute> { + let content; + Ok(Attribute { + pound_token: input.parse()?, + style: AttrStyle::Outer, + bracket_token: bracketed!(content in input), + path: content.call(Path::parse_mod_style)?, + tts: content.parse()?, + }) + } + + #[cfg(feature = "full")] + impl private { + pub fn attrs(outer: Vec<Attribute>, inner: Vec<Attribute>) -> Vec<Attribute> { + let mut attrs = outer; + attrs.extend(inner); + attrs + } + } + + impl Parse for Meta { + fn parse(input: ParseStream) -> Result<Self> { + let ident = input.call(Ident::parse_any)?; + parse_meta_after_ident(ident, input) + } + } + + impl Parse for MetaList { + fn parse(input: ParseStream) -> Result<Self> { + let ident = input.call(Ident::parse_any)?; + parse_meta_list_after_ident(ident, input) + } + } + + impl Parse for MetaNameValue { + fn parse(input: ParseStream) -> Result<Self> { + let ident = input.call(Ident::parse_any)?; + parse_meta_name_value_after_ident(ident, input) + } + } + + impl Parse for NestedMeta { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Lit) && !(input.peek(LitBool) && input.peek2(Token![=])) { + input.parse().map(NestedMeta::Literal) + } else if private::peek_any_ident(input) { + input.parse().map(NestedMeta::Meta) + } else { + Err(input.error("expected identifier or literal")) + } + } + } + + pub fn parse_meta_after_ident(ident: Ident, input: ParseStream) -> Result<Meta> { + if input.peek(token::Paren) { + parse_meta_list_after_ident(ident, input).map(Meta::List) + } else if input.peek(Token![=]) { + parse_meta_name_value_after_ident(ident, input).map(Meta::NameValue) + } else { + Ok(Meta::Word(ident)) + } + } + + fn parse_meta_list_after_ident(ident: Ident, input: ParseStream) -> Result<MetaList> { + let content; + Ok(MetaList { + ident: ident, + paren_token: parenthesized!(content in input), + nested: content.parse_terminated(NestedMeta::parse)?, + }) + } + + fn parse_meta_name_value_after_ident( + ident: Ident, + input: ParseStream, + ) -> Result<MetaNameValue> { + Ok(MetaNameValue { + ident: ident, + eq_token: input.parse()?, + lit: input.parse()?, + }) + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + use proc_macro2::TokenStream; + use quote::ToTokens; + + impl ToTokens for Attribute { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.pound_token.to_tokens(tokens); + if let AttrStyle::Inner(ref b) = self.style { + b.to_tokens(tokens); + } + self.bracket_token.surround(tokens, |tokens| { + self.path.to_tokens(tokens); + self.tts.to_tokens(tokens); + }); + } + } + + impl ToTokens for MetaList { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.ident.to_tokens(tokens); + self.paren_token.surround(tokens, |tokens| { + self.nested.to_tokens(tokens); + }) + } + } + + impl ToTokens for MetaNameValue { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.ident.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.lit.to_tokens(tokens); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/buffer.rs b/rust/vendor/syn-0.15.44/src/buffer.rs new file mode 100644 index 0000000..eac1fd0 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/buffer.rs @@ -0,0 +1,370 @@ +//! A stably addressed token buffer supporting efficient traversal based on a +//! cheaply copyable cursor. +//! +//! *This module is available if Syn is built with the `"parsing"` feature.* + +// This module is heavily commented as it contains most of the unsafe code in +// Syn, and caution should be used when editing it. The public-facing interface +// is 100% safe but the implementation is fragile internally. + +#[cfg(all( + not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))), + feature = "proc-macro" +))] +use proc_macro as pm; +use proc_macro2::{Delimiter, Group, Ident, Literal, Punct, Spacing, Span, TokenStream, TokenTree}; + +use std::marker::PhantomData; +use std::ptr; + +use private; +use Lifetime; + +/// Internal type which is used instead of `TokenTree` to represent a token tree +/// within a `TokenBuffer`. +enum Entry { + // Mimicking types from proc-macro. + Group(Group, TokenBuffer), + Ident(Ident), + Punct(Punct), + Literal(Literal), + // End entries contain a raw pointer to the entry from the containing + // token tree, or null if this is the outermost level. + End(*const Entry), +} + +/// A buffer that can be efficiently traversed multiple times, unlike +/// `TokenStream` which requires a deep copy in order to traverse more than +/// once. +/// +/// *This type is available if Syn is built with the `"parsing"` feature.* +pub struct TokenBuffer { + // NOTE: Do not derive clone on this - there are raw pointers inside which + // will be messed up. Moving the `TokenBuffer` itself is safe as the actual + // backing slices won't be moved. + data: Box<[Entry]>, +} + +impl TokenBuffer { + // NOTE: DO NOT MUTATE THE `Vec` RETURNED FROM THIS FUNCTION ONCE IT + // RETURNS, THE ADDRESS OF ITS BACKING MEMORY MUST REMAIN STABLE. + fn inner_new(stream: TokenStream, up: *const Entry) -> TokenBuffer { + // Build up the entries list, recording the locations of any Groups + // in the list to be processed later. + let mut entries = Vec::new(); + let mut seqs = Vec::new(); + for tt in stream { + match tt { + TokenTree::Ident(sym) => { + entries.push(Entry::Ident(sym)); + } + TokenTree::Punct(op) => { + entries.push(Entry::Punct(op)); + } + TokenTree::Literal(l) => { + entries.push(Entry::Literal(l)); + } + TokenTree::Group(g) => { + // Record the index of the interesting entry, and store an + // `End(null)` there temporarially. + seqs.push((entries.len(), g)); + entries.push(Entry::End(ptr::null())); + } + } + } + // Add an `End` entry to the end with a reference to the enclosing token + // stream which was passed in. + entries.push(Entry::End(up)); + + // NOTE: This is done to ensure that we don't accidentally modify the + // length of the backing buffer. The backing buffer must remain at a + // constant address after this point, as we are going to store a raw + // pointer into it. + let mut entries = entries.into_boxed_slice(); + for (idx, group) in seqs { + // We know that this index refers to one of the temporary + // `End(null)` entries, and we know that the last entry is + // `End(up)`, so the next index is also valid. + let seq_up = &entries[idx + 1] as *const Entry; + + // The end entry stored at the end of this Entry::Group should + // point to the Entry which follows the Group in the list. + let inner = Self::inner_new(group.stream(), seq_up); + entries[idx] = Entry::Group(group, inner); + } + + TokenBuffer { data: entries } + } + + /// Creates a `TokenBuffer` containing all the tokens from the input + /// `TokenStream`. + /// + /// *This method is available if Syn is built with both the `"parsing"` and + /// `"proc-macro"` features.* + #[cfg(all( + not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))), + feature = "proc-macro" + ))] + pub fn new(stream: pm::TokenStream) -> TokenBuffer { + Self::new2(stream.into()) + } + + /// Creates a `TokenBuffer` containing all the tokens from the input + /// `TokenStream`. + pub fn new2(stream: TokenStream) -> TokenBuffer { + Self::inner_new(stream, ptr::null()) + } + + /// Creates a cursor referencing the first token in the buffer and able to + /// traverse until the end of the buffer. + pub fn begin(&self) -> Cursor { + unsafe { Cursor::create(&self.data[0], &self.data[self.data.len() - 1]) } + } +} + +/// A cheaply copyable cursor into a `TokenBuffer`. +/// +/// This cursor holds a shared reference into the immutable data which is used +/// internally to represent a `TokenStream`, and can be efficiently manipulated +/// and copied around. +/// +/// An empty `Cursor` can be created directly, or one may create a `TokenBuffer` +/// object and get a cursor to its first token with `begin()`. +/// +/// Two cursors are equal if they have the same location in the same input +/// stream, and have the same scope. +/// +/// *This type is available if Syn is built with the `"parsing"` feature.* +#[derive(Copy, Clone, Eq, PartialEq)] +pub struct Cursor<'a> { + // The current entry which the `Cursor` is pointing at. + ptr: *const Entry, + // This is the only `Entry::End(..)` object which this cursor is allowed to + // point at. All other `End` objects are skipped over in `Cursor::create`. + scope: *const Entry, + // Cursor is covariant in 'a. This field ensures that our pointers are still + // valid. + marker: PhantomData<&'a Entry>, +} + +impl<'a> Cursor<'a> { + /// Creates a cursor referencing a static empty TokenStream. + pub fn empty() -> Self { + // It's safe in this situation for us to put an `Entry` object in global + // storage, despite it not actually being safe to send across threads + // (`Ident` is a reference into a thread-local table). This is because + // this entry never includes a `Ident` object. + // + // This wrapper struct allows us to break the rules and put a `Sync` + // object in global storage. + struct UnsafeSyncEntry(Entry); + unsafe impl Sync for UnsafeSyncEntry {} + static EMPTY_ENTRY: UnsafeSyncEntry = UnsafeSyncEntry(Entry::End(0 as *const Entry)); + + Cursor { + ptr: &EMPTY_ENTRY.0, + scope: &EMPTY_ENTRY.0, + marker: PhantomData, + } + } + + /// This create method intelligently exits non-explicitly-entered + /// `None`-delimited scopes when the cursor reaches the end of them, + /// allowing for them to be treated transparently. + unsafe fn create(mut ptr: *const Entry, scope: *const Entry) -> Self { + // NOTE: If we're looking at a `End(..)`, we want to advance the cursor + // past it, unless `ptr == scope`, which means that we're at the edge of + // our cursor's scope. We should only have `ptr != scope` at the exit + // from None-delimited groups entered with `ignore_none`. + while let Entry::End(exit) = *ptr { + if ptr == scope { + break; + } + ptr = exit; + } + + Cursor { + ptr: ptr, + scope: scope, + marker: PhantomData, + } + } + + /// Get the current entry. + fn entry(self) -> &'a Entry { + unsafe { &*self.ptr } + } + + /// Bump the cursor to point at the next token after the current one. This + /// is undefined behavior if the cursor is currently looking at an + /// `Entry::End`. + unsafe fn bump(self) -> Cursor<'a> { + Cursor::create(self.ptr.offset(1), self.scope) + } + + /// If the cursor is looking at a `None`-delimited group, move it to look at + /// the first token inside instead. If the group is empty, this will move + /// the cursor past the `None`-delimited group. + /// + /// WARNING: This mutates its argument. + fn ignore_none(&mut self) { + if let Entry::Group(ref group, ref buf) = *self.entry() { + if group.delimiter() == Delimiter::None { + // NOTE: We call `Cursor::create` here to make sure that + // situations where we should immediately exit the span after + // entering it are handled correctly. + unsafe { + *self = Cursor::create(&buf.data[0], self.scope); + } + } + } + } + + /// Checks whether the cursor is currently pointing at the end of its valid + /// scope. + #[inline] + pub fn eof(self) -> bool { + // We're at eof if we're at the end of our scope. + self.ptr == self.scope + } + + /// If the cursor is pointing at a `Group` with the given delimiter, returns + /// a cursor into that group and one pointing to the next `TokenTree`. + pub fn group(mut self, delim: Delimiter) -> Option<(Cursor<'a>, Span, Cursor<'a>)> { + // If we're not trying to enter a none-delimited group, we want to + // ignore them. We have to make sure to _not_ ignore them when we want + // to enter them, of course. For obvious reasons. + if delim != Delimiter::None { + self.ignore_none(); + } + + if let Entry::Group(ref group, ref buf) = *self.entry() { + if group.delimiter() == delim { + return Some((buf.begin(), group.span(), unsafe { self.bump() })); + } + } + + None + } + + /// If the cursor is pointing at a `Ident`, returns it along with a cursor + /// pointing at the next `TokenTree`. + pub fn ident(mut self) -> Option<(Ident, Cursor<'a>)> { + self.ignore_none(); + match *self.entry() { + Entry::Ident(ref ident) => Some((ident.clone(), unsafe { self.bump() })), + _ => None, + } + } + + /// If the cursor is pointing at an `Punct`, returns it along with a cursor + /// pointing at the next `TokenTree`. + pub fn punct(mut self) -> Option<(Punct, Cursor<'a>)> { + self.ignore_none(); + match *self.entry() { + Entry::Punct(ref op) if op.as_char() != '\'' => { + Some((op.clone(), unsafe { self.bump() })) + } + _ => None, + } + } + + /// If the cursor is pointing at a `Literal`, return it along with a cursor + /// pointing at the next `TokenTree`. + pub fn literal(mut self) -> Option<(Literal, Cursor<'a>)> { + self.ignore_none(); + match *self.entry() { + Entry::Literal(ref lit) => Some((lit.clone(), unsafe { self.bump() })), + _ => None, + } + } + + /// If the cursor is pointing at a `Lifetime`, returns it along with a + /// cursor pointing at the next `TokenTree`. + pub fn lifetime(mut self) -> Option<(Lifetime, Cursor<'a>)> { + self.ignore_none(); + match *self.entry() { + Entry::Punct(ref op) if op.as_char() == '\'' && op.spacing() == Spacing::Joint => { + let next = unsafe { self.bump() }; + match next.ident() { + Some((ident, rest)) => { + let lifetime = Lifetime { + apostrophe: op.span(), + ident: ident, + }; + Some((lifetime, rest)) + } + None => None, + } + } + _ => None, + } + } + + /// Copies all remaining tokens visible from this cursor into a + /// `TokenStream`. + pub fn token_stream(self) -> TokenStream { + let mut tts = Vec::new(); + let mut cursor = self; + while let Some((tt, rest)) = cursor.token_tree() { + tts.push(tt); + cursor = rest; + } + tts.into_iter().collect() + } + + /// If the cursor is pointing at a `TokenTree`, returns it along with a + /// cursor pointing at the next `TokenTree`. + /// + /// Returns `None` if the cursor has reached the end of its stream. + /// + /// This method does not treat `None`-delimited groups as transparent, and + /// will return a `Group(None, ..)` if the cursor is looking at one. + pub fn token_tree(self) -> Option<(TokenTree, Cursor<'a>)> { + let tree = match *self.entry() { + Entry::Group(ref group, _) => group.clone().into(), + Entry::Literal(ref lit) => lit.clone().into(), + Entry::Ident(ref ident) => ident.clone().into(), + Entry::Punct(ref op) => op.clone().into(), + Entry::End(..) => { + return None; + } + }; + + Some((tree, unsafe { self.bump() })) + } + + /// Returns the `Span` of the current token, or `Span::call_site()` if this + /// cursor points to eof. + pub fn span(self) -> Span { + match *self.entry() { + Entry::Group(ref group, _) => group.span(), + Entry::Literal(ref l) => l.span(), + Entry::Ident(ref t) => t.span(), + Entry::Punct(ref o) => o.span(), + Entry::End(..) => Span::call_site(), + } + } +} + +impl private { + pub fn same_scope(a: Cursor, b: Cursor) -> bool { + a.scope == b.scope + } + + #[cfg(procmacro2_semver_exempt)] + pub fn open_span_of_group(cursor: Cursor) -> Span { + match *cursor.entry() { + Entry::Group(ref group, _) => group.span_open(), + _ => cursor.span(), + } + } + + #[cfg(procmacro2_semver_exempt)] + pub fn close_span_of_group(cursor: Cursor) -> Span { + match *cursor.entry() { + Entry::Group(ref group, _) => group.span_close(), + _ => cursor.span(), + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/custom_keyword.rs b/rust/vendor/syn-0.15.44/src/custom_keyword.rs new file mode 100644 index 0000000..f4515c6 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/custom_keyword.rs @@ -0,0 +1,252 @@ +/// Define a type that supports parsing and printing a given identifier as if it +/// were a keyword. +/// +/// # Usage +/// +/// As a convention, it is recommended that this macro be invoked within a +/// module called `kw` or `keyword` and that the resulting parser be invoked +/// with a `kw::` or `keyword::` prefix. +/// +/// ```edition2018 +/// mod kw { +/// syn::custom_keyword!(whatever); +/// } +/// ``` +/// +/// The generated syntax tree node supports the following operations just like +/// any built-in keyword token. +/// +/// - [Peeking] — `input.peek(kw::whatever)` +/// +/// - [Parsing] — `input.parse::<kw::whatever>()?` +/// +/// - [Printing] — `quote!( ... #whatever_token ... )` +/// +/// - Construction from a [`Span`] — `let whatever_token = kw::whatever(sp)` +/// +/// - Field access to its span — `let sp = whatever_token.span` +/// +/// [Peeking]: parse::ParseBuffer::peek +/// [Parsing]: parse::ParseBuffer::parse +/// [Printing]: quote::ToTokens +/// [`Span`]: proc_macro2::Span +/// +/// # Example +/// +/// This example parses input that looks like `bool = true` or `str = "value"`. +/// The key must be either the identifier `bool` or the identifier `str`. If +/// `bool`, the value may be either `true` or `false`. If `str`, the value may +/// be any string literal. +/// +/// The symbols `bool` and `str` are not reserved keywords in Rust so these are +/// not considered keywords in the `syn::token` module. Like any other +/// identifier that is not a keyword, these can be declared as custom keywords +/// by crates that need to use them as such. +/// +/// ```edition2018 +/// use syn::{LitBool, LitStr, Result, Token}; +/// use syn::parse::{Parse, ParseStream}; +/// +/// mod kw { +/// syn::custom_keyword!(bool); +/// syn::custom_keyword!(str); +/// } +/// +/// enum Argument { +/// Bool { +/// bool_token: kw::bool, +/// eq_token: Token![=], +/// value: LitBool, +/// }, +/// Str { +/// str_token: kw::str, +/// eq_token: Token![=], +/// value: LitStr, +/// }, +/// } +/// +/// impl Parse for Argument { +/// fn parse(input: ParseStream) -> Result<Self> { +/// let lookahead = input.lookahead1(); +/// if lookahead.peek(kw::bool) { +/// Ok(Argument::Bool { +/// bool_token: input.parse::<kw::bool>()?, +/// eq_token: input.parse()?, +/// value: input.parse()?, +/// }) +/// } else if lookahead.peek(kw::str) { +/// Ok(Argument::Str { +/// str_token: input.parse::<kw::str>()?, +/// eq_token: input.parse()?, +/// value: input.parse()?, +/// }) +/// } else { +/// Err(lookahead.error()) +/// } +/// } +/// } +/// ``` +#[macro_export(local_inner_macros)] +macro_rules! custom_keyword { + ($ident:ident) => { + #[allow(non_camel_case_types)] + pub struct $ident { + pub span: $crate::export::Span, + } + + #[doc(hidden)] + #[allow(non_snake_case)] + pub fn $ident<__S: $crate::export::IntoSpans<[$crate::export::Span; 1]>>( + span: __S, + ) -> $ident { + $ident { + span: $crate::export::IntoSpans::into_spans(span)[0], + } + } + + impl $crate::export::Default for $ident { + fn default() -> Self { + $ident { + span: $crate::export::Span::call_site(), + } + } + } + + impl_parse_for_custom_keyword!($ident); + impl_to_tokens_for_custom_keyword!($ident); + impl_clone_for_custom_keyword!($ident); + impl_extra_traits_for_custom_keyword!($ident); + }; +} + +// Not public API. +#[cfg(feature = "parsing")] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_parse_for_custom_keyword { + ($ident:ident) => { + // For peek. + impl $crate::token::CustomToken for $ident { + fn peek(cursor: $crate::buffer::Cursor) -> $crate::export::bool { + if let Some((ident, _rest)) = cursor.ident() { + ident == stringify!($ident) + } else { + false + } + } + + fn display() -> &'static $crate::export::str { + concat!("`", stringify!($ident), "`") + } + } + + impl $crate::parse::Parse for $ident { + fn parse(input: $crate::parse::ParseStream) -> $crate::parse::Result<$ident> { + input.step(|cursor| { + if let $crate::export::Some((ident, rest)) = cursor.ident() { + if ident == stringify!($ident) { + return $crate::export::Ok(($ident { span: ident.span() }, rest)); + } + } + $crate::export::Err(cursor.error(concat!( + "expected `", + stringify!($ident), + "`" + ))) + }) + } + } + }; +} + +// Not public API. +#[cfg(not(feature = "parsing"))] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_parse_for_custom_keyword { + ($ident:ident) => {}; +} + +// Not public API. +#[cfg(feature = "printing")] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_to_tokens_for_custom_keyword { + ($ident:ident) => { + impl $crate::export::ToTokens for $ident { + fn to_tokens(&self, tokens: &mut $crate::export::TokenStream2) { + let ident = $crate::Ident::new(stringify!($ident), self.span); + $crate::export::TokenStreamExt::append(tokens, ident); + } + } + }; +} + +// Not public API. +#[cfg(not(feature = "printing"))] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_to_tokens_for_custom_keyword { + ($ident:ident) => {}; +} + +// Not public API. +#[cfg(feature = "clone-impls")] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_clone_for_custom_keyword { + ($ident:ident) => { + impl $crate::export::Copy for $ident {} + + impl $crate::export::Clone for $ident { + fn clone(&self) -> Self { + *self + } + } + }; +} + +// Not public API. +#[cfg(not(feature = "clone-impls"))] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_clone_for_custom_keyword { + ($ident:ident) => {}; +} + +// Not public API. +#[cfg(feature = "extra-traits")] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_extra_traits_for_custom_keyword { + ($ident:ident) => { + impl $crate::export::Debug for $ident { + fn fmt(&self, f: &mut $crate::export::Formatter) -> $crate::export::fmt::Result { + $crate::export::Formatter::write_str( + f, + concat!("Keyword [", stringify!($ident), "]"), + ) + } + } + + impl $crate::export::Eq for $ident {} + + impl $crate::export::PartialEq for $ident { + fn eq(&self, _other: &Self) -> $crate::export::bool { + true + } + } + + impl $crate::export::Hash for $ident { + fn hash<__H: $crate::export::Hasher>(&self, _state: &mut __H) {} + } + }; +} + +// Not public API. +#[cfg(not(feature = "extra-traits"))] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_extra_traits_for_custom_keyword { + ($ident:ident) => {}; +} diff --git a/rust/vendor/syn-0.15.44/src/custom_punctuation.rs b/rust/vendor/syn-0.15.44/src/custom_punctuation.rs new file mode 100644 index 0000000..62aa2ff --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/custom_punctuation.rs @@ -0,0 +1,309 @@ +/// Define a type that supports parsing and printing a multi-character symbol +/// as if it were a punctuation token. +/// +/// # Usage +/// +/// ```edition2018 +/// syn::custom_punctuation!(LeftRightArrow, <=>); +/// ``` +/// +/// The generated syntax tree node supports the following operations just like +/// any built-in punctuation token. +/// +/// - [Peeking] — `input.peek(LeftRightArrow)` +/// +/// - [Parsing] — `input.parse::<LeftRightArrow>()?` +/// +/// - [Printing] — `quote!( ... #lrarrow ... )` +/// +/// - Construction from a [`Span`] — `let lrarrow = LeftRightArrow(sp)` +/// +/// - Construction from multiple [`Span`] — `let lrarrow = LeftRightArrow([sp, sp, sp])` +/// +/// - Field access to its spans — `let spans = lrarrow.spans` +/// +/// [Peeking]: parse::ParseBuffer::peek +/// [Parsing]: parse::ParseBuffer::parse +/// [Printing]: quote::ToTokens +/// [`Span`]: proc_macro2::Span +/// +/// # Example +/// +/// ```edition2018 +/// use proc_macro2::{TokenStream, TokenTree}; +/// use syn::parse::{Parse, ParseStream, Peek, Result}; +/// use syn::punctuated::Punctuated; +/// use syn::Expr; +/// +/// syn::custom_punctuation!(PathSeparator, </>); +/// +/// // expr </> expr </> expr ... +/// struct PathSegments { +/// segments: Punctuated<Expr, PathSeparator>, +/// } +/// +/// impl Parse for PathSegments { +/// fn parse(input: ParseStream) -> Result<Self> { +/// let mut segments = Punctuated::new(); +/// +/// let first = parse_until(input, PathSeparator)?; +/// segments.push_value(syn::parse2(first)?); +/// +/// while input.peek(PathSeparator) { +/// segments.push_punct(input.parse()?); +/// +/// let next = parse_until(input, PathSeparator)?; +/// segments.push_value(syn::parse2(next)?); +/// } +/// +/// Ok(PathSegments { segments }) +/// } +/// } +/// +/// fn parse_until<E: Peek>(input: ParseStream, end: E) -> Result<TokenStream> { +/// let mut tokens = TokenStream::new(); +/// while !input.is_empty() && !input.peek(end) { +/// let next: TokenTree = input.parse()?; +/// tokens.extend(Some(next)); +/// } +/// Ok(tokens) +/// } +/// +/// fn main() { +/// let input = r#" a::b </> c::d::e "#; +/// let _: PathSegments = syn::parse_str(input).unwrap(); +/// } +/// ``` +#[macro_export(local_inner_macros)] +macro_rules! custom_punctuation { + ($ident:ident, $($tt:tt)+) => { + pub struct $ident { + pub spans: custom_punctuation_repr!($($tt)+), + } + + #[doc(hidden)] + #[allow(non_snake_case)] + pub fn $ident<__S: $crate::export::IntoSpans<custom_punctuation_repr!($($tt)+)>>( + spans: __S, + ) -> $ident { + let _validate_len = 0 $(+ custom_punctuation_len!(strict, $tt))*; + $ident { + spans: $crate::export::IntoSpans::into_spans(spans) + } + } + + impl $crate::export::Default for $ident { + fn default() -> Self { + $ident($crate::export::Span::call_site()) + } + } + + impl_parse_for_custom_punctuation!($ident, $($tt)+); + impl_to_tokens_for_custom_punctuation!($ident, $($tt)+); + impl_clone_for_custom_punctuation!($ident, $($tt)+); + impl_extra_traits_for_custom_punctuation!($ident, $($tt)+); + }; +} + +// Not public API. +#[cfg(feature = "parsing")] +#[doc(hidden)] +#[macro_export(local_inner_macros)] +macro_rules! impl_parse_for_custom_punctuation { + ($ident:ident, $($tt:tt)+) => { + impl $crate::token::CustomToken for $ident { + fn peek(cursor: $crate::buffer::Cursor) -> bool { + $crate::token::parsing::peek_punct(cursor, stringify_punct!($($tt)+)) + } + + fn display() -> &'static $crate::export::str { + custom_punctuation_concat!("`", stringify_punct!($($tt)+), "`") + } + } + + impl $crate::parse::Parse for $ident { + fn parse(input: $crate::parse::ParseStream) -> $crate::parse::Result<$ident> { + let spans: custom_punctuation_repr!($($tt)+) = + $crate::token::parsing::punct(input, stringify_punct!($($tt)+))?; + Ok($ident(spans)) + } + } + }; +} + +// Not public API. +#[cfg(not(feature = "parsing"))] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_parse_for_custom_punctuation { + ($ident:ident, $($tt:tt)+) => {}; +} + +// Not public API. +#[cfg(feature = "printing")] +#[doc(hidden)] +#[macro_export(local_inner_macros)] +macro_rules! impl_to_tokens_for_custom_punctuation { + ($ident:ident, $($tt:tt)+) => { + impl $crate::export::ToTokens for $ident { + fn to_tokens(&self, tokens: &mut $crate::export::TokenStream2) { + $crate::token::printing::punct(stringify_punct!($($tt)+), &self.spans, tokens) + } + } + }; +} + +// Not public API. +#[cfg(not(feature = "printing"))] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_to_tokens_for_custom_punctuation { + ($ident:ident, $($tt:tt)+) => {}; +} + +// Not public API. +#[cfg(feature = "clone-impls")] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_clone_for_custom_punctuation { + ($ident:ident, $($tt:tt)+) => { + impl $crate::export::Copy for $ident {} + + impl $crate::export::Clone for $ident { + fn clone(&self) -> Self { + *self + } + } + }; +} + +// Not public API. +#[cfg(not(feature = "clone-impls"))] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_clone_for_custom_punctuation { + ($ident:ident, $($tt:tt)+) => {}; +} + +// Not public API. +#[cfg(feature = "extra-traits")] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_extra_traits_for_custom_punctuation { + ($ident:ident, $($tt:tt)+) => { + impl $crate::export::Debug for $ident { + fn fmt(&self, f: &mut $crate::export::Formatter) -> $crate::export::fmt::Result { + $crate::export::Formatter::write_str(f, stringify!($ident)) + } + } + + impl $crate::export::Eq for $ident {} + + impl $crate::export::PartialEq for $ident { + fn eq(&self, _other: &Self) -> $crate::export::bool { + true + } + } + + impl $crate::export::Hash for $ident { + fn hash<__H: $crate::export::Hasher>(&self, _state: &mut __H) {} + } + }; +} + +// Not public API. +#[cfg(not(feature = "extra-traits"))] +#[doc(hidden)] +#[macro_export] +macro_rules! impl_extra_traits_for_custom_punctuation { + ($ident:ident, $($tt:tt)+) => {}; +} + +// Not public API. +#[doc(hidden)] +#[macro_export(local_inner_macros)] +macro_rules! custom_punctuation_repr { + ($($tt:tt)+) => { + [$crate::export::Span; 0 $(+ custom_punctuation_len!(lenient, $tt))+] + }; +} + +// Not public API. +#[doc(hidden)] +#[macro_export(local_inner_macros)] +#[cfg_attr(rustfmt, rustfmt_skip)] +macro_rules! custom_punctuation_len { + ($mode:ident, +) => { 1 }; + ($mode:ident, +=) => { 2 }; + ($mode:ident, &) => { 1 }; + ($mode:ident, &&) => { 2 }; + ($mode:ident, &=) => { 2 }; + ($mode:ident, @) => { 1 }; + ($mode:ident, !) => { 1 }; + ($mode:ident, ^) => { 1 }; + ($mode:ident, ^=) => { 2 }; + ($mode:ident, :) => { 1 }; + ($mode:ident, ::) => { 2 }; + ($mode:ident, ,) => { 1 }; + ($mode:ident, /) => { 1 }; + ($mode:ident, /=) => { 2 }; + ($mode:ident, .) => { 1 }; + ($mode:ident, ..) => { 2 }; + ($mode:ident, ...) => { 3 }; + ($mode:ident, ..=) => { 3 }; + ($mode:ident, =) => { 1 }; + ($mode:ident, ==) => { 2 }; + ($mode:ident, >=) => { 2 }; + ($mode:ident, >) => { 1 }; + ($mode:ident, <=) => { 2 }; + ($mode:ident, <) => { 1 }; + ($mode:ident, *=) => { 2 }; + ($mode:ident, !=) => { 2 }; + ($mode:ident, |) => { 1 }; + ($mode:ident, |=) => { 2 }; + ($mode:ident, ||) => { 2 }; + ($mode:ident, #) => { 1 }; + ($mode:ident, ?) => { 1 }; + ($mode:ident, ->) => { 2 }; + ($mode:ident, <-) => { 2 }; + ($mode:ident, %) => { 1 }; + ($mode:ident, %=) => { 2 }; + ($mode:ident, =>) => { 2 }; + ($mode:ident, ;) => { 1 }; + ($mode:ident, <<) => { 2 }; + ($mode:ident, <<=) => { 3 }; + ($mode:ident, >>) => { 2 }; + ($mode:ident, >>=) => { 3 }; + ($mode:ident, *) => { 1 }; + ($mode:ident, -) => { 1 }; + ($mode:ident, -=) => { 2 }; + ($mode:ident, ~) => { 1 }; + (lenient, $tt:tt) => { 0 }; + (strict, $tt:tt) => {{ custom_punctuation_unexpected!($tt); 0 }}; +} + +// Not public API. +#[doc(hidden)] +#[macro_export] +macro_rules! custom_punctuation_unexpected { + () => {}; +} + +// Not public API. +#[doc(hidden)] +#[macro_export] +macro_rules! stringify_punct { + ($($tt:tt)+) => { + concat!($(stringify!($tt)),+) + }; +} + +// Not public API. +// Without this, local_inner_macros breaks when looking for concat! +#[doc(hidden)] +#[macro_export] +macro_rules! custom_punctuation_concat { + ($($tt:tt)*) => { + concat!($($tt)*) + }; +} diff --git a/rust/vendor/syn-0.15.44/src/data.rs b/rust/vendor/syn-0.15.44/src/data.rs new file mode 100644 index 0000000..ba749b8 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/data.rs @@ -0,0 +1,387 @@ +use super::*; +use punctuated::Punctuated; + +ast_struct! { + /// An enum variant. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct Variant { + /// Attributes tagged on the variant. + pub attrs: Vec<Attribute>, + + /// Name of the variant. + pub ident: Ident, + + /// Content stored in the variant. + pub fields: Fields, + + /// Explicit discriminant: `Variant = 1` + pub discriminant: Option<(Token![=], Expr)>, + } +} + +ast_enum_of_structs! { + /// Data stored within an enum variant or struct. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum Fields { + /// Named fields of a struct or struct variant such as `Point { x: f64, + /// y: f64 }`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Named(FieldsNamed { + pub brace_token: token::Brace, + pub named: Punctuated<Field, Token![,]>, + }), + + /// Unnamed fields of a tuple struct or tuple variant such as `Some(T)`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Unnamed(FieldsUnnamed { + pub paren_token: token::Paren, + pub unnamed: Punctuated<Field, Token![,]>, + }), + + /// Unit struct or unit variant such as `None`. + pub Unit, + } +} + +impl Fields { + /// Get an iterator over the borrowed [`Field`] items in this object. This + /// iterator can be used to iterate over a named or unnamed struct or + /// variant's fields uniformly. + pub fn iter(&self) -> punctuated::Iter<Field> { + match *self { + Fields::Unit => private::empty_punctuated_iter(), + Fields::Named(ref f) => f.named.iter(), + Fields::Unnamed(ref f) => f.unnamed.iter(), + } + } + + /// Get an iterator over the mutably borrowed [`Field`] items in this + /// object. This iterator can be used to iterate over a named or unnamed + /// struct or variant's fields uniformly. + pub fn iter_mut(&mut self) -> punctuated::IterMut<Field> { + match *self { + Fields::Unit => private::empty_punctuated_iter_mut(), + Fields::Named(ref mut f) => f.named.iter_mut(), + Fields::Unnamed(ref mut f) => f.unnamed.iter_mut(), + } + } +} + +impl<'a> IntoIterator for &'a Fields { + type Item = &'a Field; + type IntoIter = punctuated::Iter<'a, Field>; + + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +impl<'a> IntoIterator for &'a mut Fields { + type Item = &'a mut Field; + type IntoIter = punctuated::IterMut<'a, Field>; + + fn into_iter(self) -> Self::IntoIter { + self.iter_mut() + } +} + +ast_struct! { + /// A field of a struct or enum variant. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct Field { + /// Attributes tagged on the field. + pub attrs: Vec<Attribute>, + + /// Visibility of the field. + pub vis: Visibility, + + /// Name of the field, if any. + /// + /// Fields of tuple structs have no names. + pub ident: Option<Ident>, + + pub colon_token: Option<Token![:]>, + + /// Type of the field. + pub ty: Type, + } +} + +ast_enum_of_structs! { + /// The visibility level of an item: inherited or `pub` or + /// `pub(restricted)`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum Visibility { + /// A public visibility level: `pub`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Public(VisPublic { + pub pub_token: Token![pub], + }), + + /// A crate-level visibility: `crate`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Crate(VisCrate { + pub crate_token: Token![crate], + }), + + /// A visibility level restricted to some path: `pub(self)` or + /// `pub(super)` or `pub(crate)` or `pub(in some::module)`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Restricted(VisRestricted { + pub pub_token: Token![pub], + pub paren_token: token::Paren, + pub in_token: Option<Token![in]>, + pub path: Box<Path>, + }), + + /// An inherited visibility, which usually means private. + pub Inherited, + } +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use ext::IdentExt; + use parse::{Parse, ParseStream, Result}; + + impl Parse for Variant { + fn parse(input: ParseStream) -> Result<Self> { + Ok(Variant { + attrs: input.call(Attribute::parse_outer)?, + ident: input.parse()?, + fields: { + if input.peek(token::Brace) { + Fields::Named(input.parse()?) + } else if input.peek(token::Paren) { + Fields::Unnamed(input.parse()?) + } else { + Fields::Unit + } + }, + discriminant: { + if input.peek(Token![=]) { + let eq_token: Token![=] = input.parse()?; + let discriminant: Expr = input.parse()?; + Some((eq_token, discriminant)) + } else { + None + } + }, + }) + } + } + + impl Parse for FieldsNamed { + fn parse(input: ParseStream) -> Result<Self> { + let content; + Ok(FieldsNamed { + brace_token: braced!(content in input), + named: content.parse_terminated(Field::parse_named)?, + }) + } + } + + impl Parse for FieldsUnnamed { + fn parse(input: ParseStream) -> Result<Self> { + let content; + Ok(FieldsUnnamed { + paren_token: parenthesized!(content in input), + unnamed: content.parse_terminated(Field::parse_unnamed)?, + }) + } + } + + impl Field { + /// Parses a named (braced struct) field. + pub fn parse_named(input: ParseStream) -> Result<Self> { + Ok(Field { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + ident: Some(input.parse()?), + colon_token: Some(input.parse()?), + ty: input.parse()?, + }) + } + + /// Parses an unnamed (tuple struct) field. + pub fn parse_unnamed(input: ParseStream) -> Result<Self> { + Ok(Field { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + ident: None, + colon_token: None, + ty: input.parse()?, + }) + } + } + + impl Parse for Visibility { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Token![pub]) { + Self::parse_pub(input) + } else if input.peek(Token![crate]) { + Self::parse_crate(input) + } else { + Ok(Visibility::Inherited) + } + } + } + + impl Visibility { + fn parse_pub(input: ParseStream) -> Result<Self> { + let pub_token = input.parse::<Token![pub]>()?; + + if input.peek(token::Paren) { + // TODO: optimize using advance_to + let ahead = input.fork(); + let mut content; + parenthesized!(content in ahead); + + if content.peek(Token![crate]) + || content.peek(Token![self]) + || content.peek(Token![super]) + { + return Ok(Visibility::Restricted(VisRestricted { + pub_token: pub_token, + paren_token: parenthesized!(content in input), + in_token: None, + path: Box::new(Path::from(content.call(Ident::parse_any)?)), + })); + } else if content.peek(Token![in]) { + return Ok(Visibility::Restricted(VisRestricted { + pub_token: pub_token, + paren_token: parenthesized!(content in input), + in_token: Some(content.parse()?), + path: Box::new(content.call(Path::parse_mod_style)?), + })); + } + } + + Ok(Visibility::Public(VisPublic { + pub_token: pub_token, + })) + } + + fn parse_crate(input: ParseStream) -> Result<Self> { + if input.peek2(Token![::]) { + Ok(Visibility::Inherited) + } else { + Ok(Visibility::Crate(VisCrate { + crate_token: input.parse()?, + })) + } + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + + use proc_macro2::TokenStream; + use quote::{ToTokens, TokenStreamExt}; + + use print::TokensOrDefault; + + impl ToTokens for Variant { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(&self.attrs); + self.ident.to_tokens(tokens); + self.fields.to_tokens(tokens); + if let Some((ref eq_token, ref disc)) = self.discriminant { + eq_token.to_tokens(tokens); + disc.to_tokens(tokens); + } + } + } + + impl ToTokens for FieldsNamed { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.brace_token.surround(tokens, |tokens| { + self.named.to_tokens(tokens); + }); + } + } + + impl ToTokens for FieldsUnnamed { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.paren_token.surround(tokens, |tokens| { + self.unnamed.to_tokens(tokens); + }); + } + } + + impl ToTokens for Field { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(&self.attrs); + self.vis.to_tokens(tokens); + if let Some(ref ident) = self.ident { + ident.to_tokens(tokens); + TokensOrDefault(&self.colon_token).to_tokens(tokens); + } + self.ty.to_tokens(tokens); + } + } + + impl ToTokens for VisPublic { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.pub_token.to_tokens(tokens) + } + } + + impl ToTokens for VisCrate { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.crate_token.to_tokens(tokens); + } + } + + impl ToTokens for VisRestricted { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.pub_token.to_tokens(tokens); + self.paren_token.surround(tokens, |tokens| { + // TODO: If we have a path which is not "self" or "super" or + // "crate", automatically add the "in" token. + self.in_token.to_tokens(tokens); + self.path.to_tokens(tokens); + }); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/derive.rs b/rust/vendor/syn-0.15.44/src/derive.rs new file mode 100644 index 0000000..401d6b0 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/derive.rs @@ -0,0 +1,258 @@ +use super::*; +use punctuated::Punctuated; + +ast_struct! { + /// Data structure sent to a `proc_macro_derive` macro. + /// + /// *This type is available if Syn is built with the `"derive"` feature.* + pub struct DeriveInput { + /// Attributes tagged on the whole struct or enum. + pub attrs: Vec<Attribute>, + + /// Visibility of the struct or enum. + pub vis: Visibility, + + /// Name of the struct or enum. + pub ident: Ident, + + /// Generics required to complete the definition. + pub generics: Generics, + + /// Data within the struct or enum. + pub data: Data, + } +} + +ast_enum_of_structs! { + /// The storage of a struct, enum or union data structure. + /// + /// *This type is available if Syn is built with the `"derive"` feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum Data { + /// A struct input to a `proc_macro_derive` macro. + /// + /// *This type is available if Syn is built with the `"derive"` + /// feature.* + pub Struct(DataStruct { + pub struct_token: Token![struct], + pub fields: Fields, + pub semi_token: Option<Token![;]>, + }), + + /// An enum input to a `proc_macro_derive` macro. + /// + /// *This type is available if Syn is built with the `"derive"` + /// feature.* + pub Enum(DataEnum { + pub enum_token: Token![enum], + pub brace_token: token::Brace, + pub variants: Punctuated<Variant, Token![,]>, + }), + + /// A tagged union input to a `proc_macro_derive` macro. + /// + /// *This type is available if Syn is built with the `"derive"` + /// feature.* + pub Union(DataUnion { + pub union_token: Token![union], + pub fields: FieldsNamed, + }), + } + + do_not_generate_to_tokens +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use parse::{Parse, ParseStream, Result}; + + impl Parse for DeriveInput { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let vis = input.parse::<Visibility>()?; + + let lookahead = input.lookahead1(); + if lookahead.peek(Token![struct]) { + let struct_token = input.parse::<Token![struct]>()?; + let ident = input.parse::<Ident>()?; + let generics = input.parse::<Generics>()?; + let (where_clause, fields, semi) = data_struct(input)?; + Ok(DeriveInput { + attrs: attrs, + vis: vis, + ident: ident, + generics: Generics { + where_clause: where_clause, + ..generics + }, + data: Data::Struct(DataStruct { + struct_token: struct_token, + fields: fields, + semi_token: semi, + }), + }) + } else if lookahead.peek(Token![enum]) { + let enum_token = input.parse::<Token![enum]>()?; + let ident = input.parse::<Ident>()?; + let generics = input.parse::<Generics>()?; + let (where_clause, brace, variants) = data_enum(input)?; + Ok(DeriveInput { + attrs: attrs, + vis: vis, + ident: ident, + generics: Generics { + where_clause: where_clause, + ..generics + }, + data: Data::Enum(DataEnum { + enum_token: enum_token, + brace_token: brace, + variants: variants, + }), + }) + } else if lookahead.peek(Token![union]) { + let union_token = input.parse::<Token![union]>()?; + let ident = input.parse::<Ident>()?; + let generics = input.parse::<Generics>()?; + let (where_clause, fields) = data_union(input)?; + Ok(DeriveInput { + attrs: attrs, + vis: vis, + ident: ident, + generics: Generics { + where_clause: where_clause, + ..generics + }, + data: Data::Union(DataUnion { + union_token: union_token, + fields: fields, + }), + }) + } else { + Err(lookahead.error()) + } + } + } + + pub fn data_struct( + input: ParseStream, + ) -> Result<(Option<WhereClause>, Fields, Option<Token![;]>)> { + let mut lookahead = input.lookahead1(); + let mut where_clause = None; + if lookahead.peek(Token![where]) { + where_clause = Some(input.parse()?); + lookahead = input.lookahead1(); + } + + if where_clause.is_none() && lookahead.peek(token::Paren) { + let fields = input.parse()?; + + lookahead = input.lookahead1(); + if lookahead.peek(Token![where]) { + where_clause = Some(input.parse()?); + lookahead = input.lookahead1(); + } + + if lookahead.peek(Token![;]) { + let semi = input.parse()?; + Ok((where_clause, Fields::Unnamed(fields), Some(semi))) + } else { + Err(lookahead.error()) + } + } else if lookahead.peek(token::Brace) { + let fields = input.parse()?; + Ok((where_clause, Fields::Named(fields), None)) + } else if lookahead.peek(Token![;]) { + let semi = input.parse()?; + Ok((where_clause, Fields::Unit, Some(semi))) + } else { + Err(lookahead.error()) + } + } + + pub fn data_enum( + input: ParseStream, + ) -> Result<( + Option<WhereClause>, + token::Brace, + Punctuated<Variant, Token![,]>, + )> { + let where_clause = input.parse()?; + + let content; + let brace = braced!(content in input); + let variants = content.parse_terminated(Variant::parse)?; + + Ok((where_clause, brace, variants)) + } + + pub fn data_union(input: ParseStream) -> Result<(Option<WhereClause>, FieldsNamed)> { + let where_clause = input.parse()?; + let fields = input.parse()?; + Ok((where_clause, fields)) + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + + use proc_macro2::TokenStream; + use quote::ToTokens; + + use attr::FilterAttrs; + use print::TokensOrDefault; + + impl ToTokens for DeriveInput { + fn to_tokens(&self, tokens: &mut TokenStream) { + for attr in self.attrs.outer() { + attr.to_tokens(tokens); + } + self.vis.to_tokens(tokens); + match self.data { + Data::Struct(ref d) => d.struct_token.to_tokens(tokens), + Data::Enum(ref d) => d.enum_token.to_tokens(tokens), + Data::Union(ref d) => d.union_token.to_tokens(tokens), + } + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + match self.data { + Data::Struct(ref data) => match data.fields { + Fields::Named(ref fields) => { + self.generics.where_clause.to_tokens(tokens); + fields.to_tokens(tokens); + } + Fields::Unnamed(ref fields) => { + fields.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + TokensOrDefault(&data.semi_token).to_tokens(tokens); + } + Fields::Unit => { + self.generics.where_clause.to_tokens(tokens); + TokensOrDefault(&data.semi_token).to_tokens(tokens); + } + }, + Data::Enum(ref data) => { + self.generics.where_clause.to_tokens(tokens); + data.brace_token.surround(tokens, |tokens| { + data.variants.to_tokens(tokens); + }); + } + Data::Union(ref data) => { + self.generics.where_clause.to_tokens(tokens); + data.fields.to_tokens(tokens); + } + } + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/discouraged.rs b/rust/vendor/syn-0.15.44/src/discouraged.rs new file mode 100644 index 0000000..07bb82a --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/discouraged.rs @@ -0,0 +1,171 @@ +//! Extensions to the parsing API with niche applicability. + +use super::*; + +/// Extensions to the `ParseStream` API to support speculative parsing. +pub trait Speculative { + /// Advance this parse stream to the position of a forked parse stream. + /// + /// This is the opposite operation to [`ParseStream::fork`]. You can fork a + /// parse stream, perform some speculative parsing, then join the original + /// stream to the fork to "commit" the parsing from the fork to the main + /// stream. + /// + /// If you can avoid doing this, you should, as it limits the ability to + /// generate useful errors. That said, it is often the only way to parse + /// syntax of the form `A* B*` for arbitrary syntax `A` and `B`. The problem + /// is that when the fork fails to parse an `A`, it's impossible to tell + /// whether that was because of a syntax error and the user meant to provide + /// an `A`, or that the `A`s are finished and its time to start parsing + /// `B`s. Use with care. + /// + /// Also note that if `A` is a subset of `B`, `A* B*` can be parsed by + /// parsing `B*` and removing the leading members of `A` from the + /// repetition, bypassing the need to involve the downsides associated with + /// speculative parsing. + /// + /// [`ParseStream::fork`]: ParseBuffer::fork + /// + /// # Example + /// + /// There has been chatter about the possibility of making the colons in the + /// turbofish syntax like `path::to::<T>` no longer required by accepting + /// `path::to<T>` in expression position. Specifically, according to [RFC + /// 2544], [`PathSegment`] parsing should always try to consume a following + /// `<` token as the start of generic arguments, and reset to the `<` if + /// that fails (e.g. the token is acting as a less-than operator). + /// + /// This is the exact kind of parsing behavior which requires the "fork, + /// try, commit" behavior that [`ParseStream::fork`] discourages. With + /// `advance_to`, we can avoid having to parse the speculatively parsed + /// content a second time. + /// + /// This change in behavior can be implemented in syn by replacing just the + /// `Parse` implementation for `PathSegment`: + /// + /// ```edition2018 + /// # use syn::ext::IdentExt; + /// use syn::parse::discouraged::Speculative; + /// # use syn::parse::{Parse, ParseStream}; + /// # use syn::{Ident, PathArguments, Result, Token}; + /// + /// 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, + /// # } + /// # } + /// # } + /// + /// impl Parse for PathSegment { + /// fn parse(input: ParseStream) -> Result<Self> { + /// if input.peek(Token![super]) + /// || input.peek(Token![self]) + /// || input.peek(Token![Self]) + /// || input.peek(Token![crate]) + /// || input.peek(Token![extern]) + /// { + /// let ident = input.call(Ident::parse_any)?; + /// return Ok(PathSegment::from(ident)); + /// } + /// + /// let ident = input.parse()?; + /// if input.peek(Token![::]) && input.peek3(Token![<]) { + /// return Ok(PathSegment { + /// ident: ident, + /// arguments: PathArguments::AngleBracketed(input.parse()?), + /// }); + /// } + /// if input.peek(Token![<]) && !input.peek(Token![<=]) { + /// let fork = input.fork(); + /// if let Ok(arguments) = fork.parse() { + /// input.advance_to(&fork); + /// return Ok(PathSegment { + /// ident: ident, + /// arguments: PathArguments::AngleBracketed(arguments), + /// }); + /// } + /// } + /// Ok(PathSegment::from(ident)) + /// } + /// } + /// + /// # syn::parse_str::<PathSegment>("a<b,c>").unwrap(); + /// ``` + /// + /// # Drawbacks + /// + /// The main drawback of this style of speculative parsing is in error + /// presentation. Even if the lookahead is the "correct" parse, the error + /// that is shown is that of the "fallback" parse. To use the same example + /// as the turbofish above, take the following unfinished "turbofish": + /// + /// ```text + /// let _ = f<&'a fn(), for<'a> serde::>(); + /// ``` + /// + /// If this is parsed as generic arguments, we can provide the error message + /// + /// ```text + /// error: expected identifier + /// --> src.rs:L:C + /// | + /// L | let _ = f<&'a fn(), for<'a> serde::>(); + /// | ^ + /// ``` + /// + /// but if parsed using the above speculative parsing, it falls back to + /// assuming that the `<` is a less-than when it fails to parse the generic + /// arguments, and tries to interpret the `&'a` as the start of a labelled + /// loop, resulting in the much less helpful error + /// + /// ```text + /// error: expected `:` + /// --> src.rs:L:C + /// | + /// L | let _ = f<&'a fn(), for<'a> serde::>(); + /// | ^^ + /// ``` + /// + /// This can be mitigated with various heuristics (two examples: show both + /// forks' parse errors, or show the one that consumed more tokens), but + /// when you can control the grammar, sticking to something that can be + /// parsed LL(3) and without the LL(*) speculative parsing this makes + /// possible, displaying reasonable errors becomes much more simple. + /// + /// [RFC 2544]: https://github.com/rust-lang/rfcs/pull/2544 + /// [`PathSegment`]: crate::PathSegment + /// + /// # Performance + /// + /// This method performs a cheap fixed amount of work that does not depend + /// on how far apart the two streams are positioned. + /// + /// # Panics + /// + /// The forked stream in the argument of `advance_to` must have been + /// obtained by forking `self`. Attempting to advance to any other stream + /// will cause a panic. + fn advance_to(&self, fork: &Self); +} + +impl<'a> Speculative for ParseBuffer<'a> { + fn advance_to(&self, fork: &Self) { + if !private::same_scope(self.cursor(), fork.cursor()) { + panic!("Fork was not derived from the advancing parse stream"); + } + + // See comment on `cell` in the struct definition. + self.cell + .set(unsafe { mem::transmute::<Cursor, Cursor<'static>>(fork.cursor()) }) + } +} diff --git a/rust/vendor/syn-0.15.44/src/error.rs b/rust/vendor/syn-0.15.44/src/error.rs new file mode 100644 index 0000000..0b15589 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/error.rs @@ -0,0 +1,223 @@ +use std; +use std::fmt::{self, Debug, Display}; +use std::iter::FromIterator; + +use proc_macro2::{ + Delimiter, Group, Ident, LexError, Literal, Punct, Spacing, Span, TokenStream, TokenTree, +}; +#[cfg(feature = "printing")] +use quote::ToTokens; + +#[cfg(feature = "parsing")] +use buffer::Cursor; +#[cfg(all(procmacro2_semver_exempt, feature = "parsing"))] +use private; +use thread::ThreadBound; + +/// The result of a Syn parser. +pub type Result<T> = std::result::Result<T, Error>; + +/// Error returned when a Syn parser cannot parse the input tokens. +/// +/// Refer to the [module documentation] for details about parsing in Syn. +/// +/// [module documentation]: index.html +/// +/// *This type is available if Syn is built with the `"parsing"` feature.* +// +// TODO: change the parse module link to an intra rustdoc link, currently +// blocked on https://github.com/rust-lang/rust/issues/62830 +pub struct Error { + // Span is implemented as an index into a thread-local interner to keep the + // size small. It is not safe to access from a different thread. We want + // errors to be Send and Sync to play nicely with the Failure crate, so pin + // the span we're given to its original thread and assume it is + // Span::call_site if accessed from any other thread. + start_span: ThreadBound<Span>, + end_span: ThreadBound<Span>, + message: String, +} + +#[cfg(test)] +struct _Test +where + Error: Send + Sync; + +impl Error { + /// Usually the [`ParseStream::error`] method will be used instead, which + /// automatically uses the correct span from the current position of the + /// parse stream. + /// + /// Use `Error::new` when the error needs to be triggered on some span other + /// than where the parse stream is currently positioned. + /// + /// [`ParseStream::error`]: crate::parse::ParseBuffer::error + /// + /// # Example + /// + /// ```edition2018 + /// use syn::{Error, Ident, LitStr, Result, Token}; + /// use syn::parse::ParseStream; + /// + /// // Parses input that looks like `name = "string"` where the key must be + /// // the identifier `name` and the value may be any string literal. + /// // Returns the string literal. + /// fn parse_name(input: ParseStream) -> Result<LitStr> { + /// let name_token: Ident = input.parse()?; + /// if name_token != "name" { + /// // Trigger an error not on the current position of the stream, + /// // but on the position of the unexpected identifier. + /// return Err(Error::new(name_token.span(), "expected `name`")); + /// } + /// input.parse::<Token![=]>()?; + /// let s: LitStr = input.parse()?; + /// Ok(s) + /// } + /// ``` + pub fn new<T: Display>(span: Span, message: T) -> Self { + Error { + start_span: ThreadBound::new(span), + end_span: ThreadBound::new(span), + message: message.to_string(), + } + } + + /// Creates an error with the specified message spanning the given syntax + /// tree node. + /// + /// Unlike the `Error::new` constructor, this constructor takes an argument + /// `tokens` which is a syntax tree node. This allows the resulting `Error` + /// to attempt to span all tokens inside of `tokens`. While you would + /// typically be able to use the `Spanned` trait with the above `Error::new` + /// constructor, implementation limitations today mean that + /// `Error::new_spanned` may provide a higher-quality error message on + /// stable Rust. + /// + /// When in doubt it's recommended to stick to `Error::new` (or + /// `ParseStream::error`)! + #[cfg(feature = "printing")] + pub fn new_spanned<T: ToTokens, U: Display>(tokens: T, message: U) -> Self { + let mut iter = tokens.into_token_stream().into_iter(); + let start = iter.next().map_or_else(Span::call_site, |t| t.span()); + let end = iter.last().map_or(start, |t| t.span()); + Error { + start_span: ThreadBound::new(start), + end_span: ThreadBound::new(end), + message: message.to_string(), + } + } + + /// The source location of the error. + /// + /// Spans are not thread-safe so this function returns `Span::call_site()` + /// if called from a different thread than the one on which the `Error` was + /// originally created. + pub fn span(&self) -> Span { + let start = match self.start_span.get() { + Some(span) => *span, + None => return Span::call_site(), + }; + + #[cfg(procmacro2_semver_exempt)] + { + let end = match self.end_span.get() { + Some(span) => *span, + None => return Span::call_site(), + }; + start.join(end).unwrap_or(start) + } + #[cfg(not(procmacro2_semver_exempt))] + { + start + } + } + + /// Render the error as an invocation of [`compile_error!`]. + /// + /// The [`parse_macro_input!`] macro provides a convenient way to invoke + /// this method correctly in a procedural macro. + /// + /// [`compile_error!`]: https://doc.rust-lang.org/std/macro.compile_error.html + pub fn to_compile_error(&self) -> TokenStream { + let start = self + .start_span + .get() + .cloned() + .unwrap_or_else(Span::call_site); + let end = self.end_span.get().cloned().unwrap_or_else(Span::call_site); + + // compile_error!($message) + TokenStream::from_iter(vec![ + TokenTree::Ident(Ident::new("compile_error", start)), + TokenTree::Punct({ + let mut punct = Punct::new('!', Spacing::Alone); + punct.set_span(start); + punct + }), + TokenTree::Group({ + let mut group = Group::new(Delimiter::Brace, { + TokenStream::from_iter(vec![TokenTree::Literal({ + let mut string = Literal::string(&self.message); + string.set_span(end); + string + })]) + }); + group.set_span(end); + group + }), + ]) + } +} + +#[cfg(feature = "parsing")] +pub fn new_at<T: Display>(scope: Span, cursor: Cursor, message: T) -> Error { + if cursor.eof() { + Error::new(scope, format!("unexpected end of input, {}", message)) + } else { + #[cfg(procmacro2_semver_exempt)] + let span = private::open_span_of_group(cursor); + #[cfg(not(procmacro2_semver_exempt))] + let span = cursor.span(); + Error::new(span, message) + } +} + +impl Debug for Error { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.debug_tuple("Error").field(&self.message).finish() + } +} + +impl Display for Error { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + formatter.write_str(&self.message) + } +} + +impl Clone for Error { + fn clone(&self) -> Self { + let start = self + .start_span + .get() + .cloned() + .unwrap_or_else(Span::call_site); + let end = self.end_span.get().cloned().unwrap_or_else(Span::call_site); + Error { + start_span: ThreadBound::new(start), + end_span: ThreadBound::new(end), + message: self.message.clone(), + } + } +} + +impl std::error::Error for Error { + fn description(&self) -> &str { + "parse error" + } +} + +impl From<LexError> for Error { + fn from(err: LexError) -> Self { + Error::new(Span::call_site(), format!("{:?}", err)) + } +} diff --git a/rust/vendor/syn-0.15.44/src/export.rs b/rust/vendor/syn-0.15.44/src/export.rs new file mode 100644 index 0000000..d952600 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/export.rs @@ -0,0 +1,35 @@ +pub use std::clone::Clone; +pub use std::cmp::{Eq, PartialEq}; +pub use std::convert::From; +pub use std::default::Default; +pub use std::fmt::{self, Debug, Formatter}; +pub use std::hash::{Hash, Hasher}; +pub use std::marker::Copy; +pub use std::option::Option::{None, Some}; +pub use std::result::Result::{Err, Ok}; + +#[cfg(feature = "printing")] +pub extern crate quote; + +pub use proc_macro2::{Span, TokenStream as TokenStream2}; + +pub use span::IntoSpans; + +#[cfg(all( + not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))), + feature = "proc-macro" +))] +pub use proc_macro::TokenStream; + +#[cfg(feature = "printing")] +pub use quote::{ToTokens, TokenStreamExt}; + +#[allow(non_camel_case_types)] +pub type bool = help::Bool; +#[allow(non_camel_case_types)] +pub type str = help::Str; + +mod help { + pub type Bool = bool; + pub type Str = str; +} diff --git a/rust/vendor/syn-0.15.44/src/expr.rs b/rust/vendor/syn-0.15.44/src/expr.rs new file mode 100644 index 0000000..3d0b70a --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/expr.rs @@ -0,0 +1,3821 @@ +use super::*; +use proc_macro2::{Span, TokenStream}; +use punctuated::Punctuated; +#[cfg(feature = "extra-traits")] +use std::hash::{Hash, Hasher}; +#[cfg(all(feature = "parsing", feature = "full"))] +use std::mem; +#[cfg(feature = "extra-traits")] +use tt::TokenStreamHelper; + +ast_enum_of_structs! { + /// A Rust expression. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Syntax tree enums + /// + /// This type is a syntax tree enum. In Syn this and other syntax tree enums + /// are designed to be traversed using the following rebinding idiom. + /// + /// ```edition2018 + /// # use syn::Expr; + /// # + /// # fn example(expr: Expr) { + /// # const IGNORE: &str = stringify! { + /// let expr: Expr = /* ... */; + /// # }; + /// match expr { + /// Expr::MethodCall(expr) => { + /// /* ... */ + /// } + /// Expr::Cast(expr) => { + /// /* ... */ + /// } + /// Expr::If(expr) => { + /// /* ... */ + /// } + /// + /// /* ... */ + /// # _ => {} + /// # } + /// # } + /// ``` + /// + /// We begin with a variable `expr` of type `Expr` that has no fields + /// (because it is an enum), and by matching on it and rebinding a variable + /// with the same name `expr` we effectively imbue our variable with all of + /// the data fields provided by the variant that it turned out to be. So for + /// example above if we ended up in the `MethodCall` case then we get to use + /// `expr.receiver`, `expr.args` etc; if we ended up in the `If` case we get + /// to use `expr.cond`, `expr.then_branch`, `expr.else_branch`. + /// + /// This approach avoids repeating the variant names twice on every line. + /// + /// ```edition2018 + /// # use syn::{Expr, ExprMethodCall}; + /// # + /// # fn example(expr: Expr) { + /// // Repetitive; recommend not doing this. + /// match expr { + /// Expr::MethodCall(ExprMethodCall { method, args, .. }) => { + /// # } + /// # _ => {} + /// # } + /// # } + /// ``` + /// + /// In general, the name to which a syntax tree enum variant is bound should + /// be a suitable name for the complete syntax tree enum type. + /// + /// ```edition2018 + /// # use syn::{Expr, ExprField}; + /// # + /// # fn example(discriminant: ExprField) { + /// // Binding is called `base` which is the name I would use if I were + /// // assigning `*discriminant.base` without an `if let`. + /// if let Expr::Tuple(base) = *discriminant.base { + /// # } + /// # } + /// ``` + /// + /// A sign that you may not be choosing the right variable names is if you + /// see names getting repeated in your code, like accessing + /// `receiver.receiver` or `pat.pat` or `cond.cond`. + pub enum Expr { + /// A box expression: `box f`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Box(ExprBox #full { + pub attrs: Vec<Attribute>, + pub box_token: Token![box], + pub expr: Box<Expr>, + }), + + /// A placement expression: `place <- value`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub InPlace(ExprInPlace #full { + pub attrs: Vec<Attribute>, + pub place: Box<Expr>, + pub arrow_token: Token![<-], + pub value: Box<Expr>, + }), + + /// A slice literal expression: `[a, b, c, d]`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Array(ExprArray #full { + pub attrs: Vec<Attribute>, + pub bracket_token: token::Bracket, + pub elems: Punctuated<Expr, Token![,]>, + }), + + /// A function call expression: `invoke(a, b)`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Call(ExprCall { + pub attrs: Vec<Attribute>, + pub func: Box<Expr>, + pub paren_token: token::Paren, + pub args: Punctuated<Expr, Token![,]>, + }), + + /// A method call expression: `x.foo::<T>(a, b)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub MethodCall(ExprMethodCall #full { + pub attrs: Vec<Attribute>, + pub receiver: Box<Expr>, + pub dot_token: Token![.], + pub method: Ident, + pub turbofish: Option<MethodTurbofish>, + pub paren_token: token::Paren, + pub args: Punctuated<Expr, Token![,]>, + }), + + /// A tuple expression: `(a, b, c, d)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Tuple(ExprTuple #full { + pub attrs: Vec<Attribute>, + pub paren_token: token::Paren, + pub elems: Punctuated<Expr, Token![,]>, + }), + + /// A binary operation: `a + b`, `a * b`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Binary(ExprBinary { + pub attrs: Vec<Attribute>, + pub left: Box<Expr>, + pub op: BinOp, + pub right: Box<Expr>, + }), + + /// A unary operation: `!x`, `*x`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Unary(ExprUnary { + pub attrs: Vec<Attribute>, + pub op: UnOp, + pub expr: Box<Expr>, + }), + + /// A literal in place of an expression: `1`, `"foo"`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Lit(ExprLit { + pub attrs: Vec<Attribute>, + pub lit: Lit, + }), + + /// A cast expression: `foo as f64`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Cast(ExprCast { + pub attrs: Vec<Attribute>, + pub expr: Box<Expr>, + pub as_token: Token![as], + pub ty: Box<Type>, + }), + + /// A type ascription expression: `foo: f64`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Type(ExprType #full { + pub attrs: Vec<Attribute>, + pub expr: Box<Expr>, + pub colon_token: Token![:], + pub ty: Box<Type>, + }), + + /// A `let` guard: `let Some(x) = opt`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Let(ExprLet #full { + pub attrs: Vec<Attribute>, + pub let_token: Token![let], + pub pats: Punctuated<Pat, Token![|]>, + pub eq_token: Token![=], + pub expr: Box<Expr>, + }), + + /// An `if` expression with an optional `else` block: `if expr { ... } + /// else { ... }`. + /// + /// The `else` branch expression may only be an `If` or `Block` + /// expression, not any of the other types of expression. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub If(ExprIf #full { + pub attrs: Vec<Attribute>, + pub if_token: Token![if], + pub cond: Box<Expr>, + pub then_branch: Block, + pub else_branch: Option<(Token![else], Box<Expr>)>, + }), + + /// A while loop: `while expr { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub While(ExprWhile #full { + pub attrs: Vec<Attribute>, + pub label: Option<Label>, + pub while_token: Token![while], + pub cond: Box<Expr>, + pub body: Block, + }), + + /// A for loop: `for pat in expr { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub ForLoop(ExprForLoop #full { + pub attrs: Vec<Attribute>, + pub label: Option<Label>, + pub for_token: Token![for], + pub pat: Box<Pat>, + pub in_token: Token![in], + pub expr: Box<Expr>, + pub body: Block, + }), + + /// Conditionless loop: `loop { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Loop(ExprLoop #full { + pub attrs: Vec<Attribute>, + pub label: Option<Label>, + pub loop_token: Token![loop], + pub body: Block, + }), + + /// A `match` expression: `match n { Some(n) => {}, None => {} }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Match(ExprMatch #full { + pub attrs: Vec<Attribute>, + pub match_token: Token![match], + pub expr: Box<Expr>, + pub brace_token: token::Brace, + pub arms: Vec<Arm>, + }), + + /// A closure expression: `|a, b| a + b`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Closure(ExprClosure #full { + pub attrs: Vec<Attribute>, + pub asyncness: Option<Token![async]>, + pub movability: Option<Token![static]>, + pub capture: Option<Token![move]>, + pub or1_token: Token![|], + pub inputs: Punctuated<FnArg, Token![,]>, + pub or2_token: Token![|], + pub output: ReturnType, + pub body: Box<Expr>, + }), + + /// An unsafe block: `unsafe { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Unsafe(ExprUnsafe #full { + pub attrs: Vec<Attribute>, + pub unsafe_token: Token![unsafe], + pub block: Block, + }), + + /// A blocked scope: `{ ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Block(ExprBlock #full { + pub attrs: Vec<Attribute>, + pub label: Option<Label>, + pub block: Block, + }), + + /// An assignment expression: `a = compute()`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Assign(ExprAssign #full { + pub attrs: Vec<Attribute>, + pub left: Box<Expr>, + pub eq_token: Token![=], + pub right: Box<Expr>, + }), + + /// A compound assignment expression: `counter += 1`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub AssignOp(ExprAssignOp #full { + pub attrs: Vec<Attribute>, + pub left: Box<Expr>, + pub op: BinOp, + pub right: Box<Expr>, + }), + + /// Access of a named struct field (`obj.k`) or unnamed tuple struct + /// field (`obj.0`). + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Field(ExprField { + pub attrs: Vec<Attribute>, + pub base: Box<Expr>, + pub dot_token: Token![.], + pub member: Member, + }), + + /// A square bracketed indexing expression: `vector[2]`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Index(ExprIndex { + pub attrs: Vec<Attribute>, + pub expr: Box<Expr>, + pub bracket_token: token::Bracket, + pub index: Box<Expr>, + }), + + /// A range expression: `1..2`, `1..`, `..2`, `1..=2`, `..=2`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Range(ExprRange #full { + pub attrs: Vec<Attribute>, + pub from: Option<Box<Expr>>, + pub limits: RangeLimits, + pub to: Option<Box<Expr>>, + }), + + /// A path like `std::mem::replace` possibly containing generic + /// parameters and a qualified self-type. + /// + /// A plain identifier like `x` is a path of length 1. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Path(ExprPath { + pub attrs: Vec<Attribute>, + pub qself: Option<QSelf>, + pub path: Path, + }), + + /// A referencing operation: `&a` or `&mut a`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Reference(ExprReference #full { + pub attrs: Vec<Attribute>, + pub and_token: Token![&], + pub mutability: Option<Token![mut]>, + pub expr: Box<Expr>, + }), + + /// A `break`, with an optional label to break and an optional + /// expression. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Break(ExprBreak #full { + pub attrs: Vec<Attribute>, + pub break_token: Token![break], + pub label: Option<Lifetime>, + pub expr: Option<Box<Expr>>, + }), + + /// A `continue`, with an optional label. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Continue(ExprContinue #full { + pub attrs: Vec<Attribute>, + pub continue_token: Token![continue], + pub label: Option<Lifetime>, + }), + + /// A `return`, with an optional value to be returned. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Return(ExprReturn #full { + pub attrs: Vec<Attribute>, + pub return_token: Token![return], + pub expr: Option<Box<Expr>>, + }), + + /// A macro invocation expression: `format!("{}", q)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Macro(ExprMacro #full { + pub attrs: Vec<Attribute>, + pub mac: Macro, + }), + + /// A struct literal expression: `Point { x: 1, y: 1 }`. + /// + /// The `rest` provides the value of the remaining fields as in `S { a: + /// 1, b: 1, ..rest }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Struct(ExprStruct #full { + pub attrs: Vec<Attribute>, + pub path: Path, + pub brace_token: token::Brace, + pub fields: Punctuated<FieldValue, Token![,]>, + pub dot2_token: Option<Token![..]>, + pub rest: Option<Box<Expr>>, + }), + + /// An array literal constructed from one repeated element: `[0u8; N]`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Repeat(ExprRepeat #full { + pub attrs: Vec<Attribute>, + pub bracket_token: token::Bracket, + pub expr: Box<Expr>, + pub semi_token: Token![;], + pub len: Box<Expr>, + }), + + /// A parenthesized expression: `(a + b)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Paren(ExprParen { + pub attrs: Vec<Attribute>, + pub paren_token: token::Paren, + pub expr: Box<Expr>, + }), + + /// An expression contained within invisible delimiters. + /// + /// This variant is important for faithfully representing the precedence + /// of expressions and is related to `None`-delimited spans in a + /// `TokenStream`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Group(ExprGroup #full { + pub attrs: Vec<Attribute>, + pub group_token: token::Group, + pub expr: Box<Expr>, + }), + + /// A try-expression: `expr?`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Try(ExprTry #full { + pub attrs: Vec<Attribute>, + pub expr: Box<Expr>, + pub question_token: Token![?], + }), + + /// An async block: `async { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Async(ExprAsync #full { + pub attrs: Vec<Attribute>, + pub async_token: Token![async], + pub capture: Option<Token![move]>, + pub block: Block, + }), + + /// A try block: `try { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub TryBlock(ExprTryBlock #full { + pub attrs: Vec<Attribute>, + pub try_token: Token![try], + pub block: Block, + }), + + /// A yield expression: `yield expr`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Yield(ExprYield #full { + pub attrs: Vec<Attribute>, + pub yield_token: Token![yield], + pub expr: Option<Box<Expr>>, + }), + + /// Tokens in expression position not interpreted by Syn. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Verbatim(ExprVerbatim #manual_extra_traits { + pub tts: TokenStream, + }), + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for ExprVerbatim {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for ExprVerbatim { + fn eq(&self, other: &Self) -> bool { + TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for ExprVerbatim { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + TokenStreamHelper(&self.tts).hash(state); + } +} + +impl Expr { + #[cfg(all(feature = "parsing", feature = "full"))] + fn replace_attrs(&mut self, new: Vec<Attribute>) -> Vec<Attribute> { + match *self { + Expr::Box(ExprBox { ref mut attrs, .. }) + | Expr::InPlace(ExprInPlace { ref mut attrs, .. }) + | Expr::Array(ExprArray { ref mut attrs, .. }) + | Expr::Call(ExprCall { ref mut attrs, .. }) + | Expr::MethodCall(ExprMethodCall { ref mut attrs, .. }) + | Expr::Tuple(ExprTuple { ref mut attrs, .. }) + | Expr::Binary(ExprBinary { ref mut attrs, .. }) + | Expr::Unary(ExprUnary { ref mut attrs, .. }) + | Expr::Lit(ExprLit { ref mut attrs, .. }) + | Expr::Cast(ExprCast { ref mut attrs, .. }) + | Expr::Type(ExprType { ref mut attrs, .. }) + | Expr::Let(ExprLet { ref mut attrs, .. }) + | Expr::If(ExprIf { ref mut attrs, .. }) + | Expr::While(ExprWhile { ref mut attrs, .. }) + | Expr::ForLoop(ExprForLoop { ref mut attrs, .. }) + | Expr::Loop(ExprLoop { ref mut attrs, .. }) + | Expr::Match(ExprMatch { ref mut attrs, .. }) + | Expr::Closure(ExprClosure { ref mut attrs, .. }) + | Expr::Unsafe(ExprUnsafe { ref mut attrs, .. }) + | Expr::Block(ExprBlock { ref mut attrs, .. }) + | Expr::Assign(ExprAssign { ref mut attrs, .. }) + | Expr::AssignOp(ExprAssignOp { ref mut attrs, .. }) + | Expr::Field(ExprField { ref mut attrs, .. }) + | Expr::Index(ExprIndex { ref mut attrs, .. }) + | Expr::Range(ExprRange { ref mut attrs, .. }) + | Expr::Path(ExprPath { ref mut attrs, .. }) + | Expr::Reference(ExprReference { ref mut attrs, .. }) + | Expr::Break(ExprBreak { ref mut attrs, .. }) + | Expr::Continue(ExprContinue { ref mut attrs, .. }) + | Expr::Return(ExprReturn { ref mut attrs, .. }) + | Expr::Macro(ExprMacro { ref mut attrs, .. }) + | Expr::Struct(ExprStruct { ref mut attrs, .. }) + | Expr::Repeat(ExprRepeat { ref mut attrs, .. }) + | Expr::Paren(ExprParen { ref mut attrs, .. }) + | Expr::Group(ExprGroup { ref mut attrs, .. }) + | Expr::Try(ExprTry { ref mut attrs, .. }) + | Expr::Async(ExprAsync { ref mut attrs, .. }) + | Expr::TryBlock(ExprTryBlock { ref mut attrs, .. }) + | Expr::Yield(ExprYield { ref mut attrs, .. }) => mem::replace(attrs, new), + Expr::Verbatim(_) => Vec::new(), + } + } +} + +ast_enum! { + /// A struct or tuple struct field accessed in a struct literal or field + /// expression. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum Member { + /// A named field like `self.x`. + Named(Ident), + /// An unnamed field like `self.0`. + Unnamed(Index), + } +} + +ast_struct! { + /// The index of an unnamed tuple struct field. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct Index #manual_extra_traits { + pub index: u32, + pub span: Span, + } +} + +impl From<usize> for Index { + fn from(index: usize) -> Index { + assert!(index < u32::max_value() as usize); + Index { + index: index as u32, + span: Span::call_site(), + } + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for Index {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for Index { + fn eq(&self, other: &Self) -> bool { + self.index == other.index + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for Index { + fn hash<H: Hasher>(&self, state: &mut H) { + self.index.hash(state); + } +} + +#[cfg(feature = "full")] +ast_struct! { + /// The `::<>` explicit type parameters passed to a method call: + /// `parse::<u64>()`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct MethodTurbofish { + pub colon2_token: Token![::], + pub lt_token: Token![<], + pub args: Punctuated<GenericMethodArgument, Token![,]>, + pub gt_token: Token![>], + } +} + +#[cfg(feature = "full")] +ast_enum! { + /// An individual generic argument to a method, like `T`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub enum GenericMethodArgument { + /// 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), + } +} + +#[cfg(feature = "full")] +ast_struct! { + /// A field-value pair in a struct literal. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct FieldValue { + /// Attributes tagged on the field. + pub attrs: Vec<Attribute>, + + /// Name or index of the field. + pub member: Member, + + /// The colon in `Struct { x: x }`. If written in shorthand like + /// `Struct { x }`, there is no colon. + pub colon_token: Option<Token![:]>, + + /// Value of the field. + pub expr: Expr, + } +} + +#[cfg(feature = "full")] +ast_struct! { + /// A lifetime labeling a `for`, `while`, or `loop`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct Label { + pub name: Lifetime, + pub colon_token: Token![:], + } +} + +#[cfg(feature = "full")] +ast_struct! { + /// A braced block containing Rust statements. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct Block { + pub brace_token: token::Brace, + /// Statements in a block + pub stmts: Vec<Stmt>, + } +} + +#[cfg(feature = "full")] +ast_enum! { + /// A statement, usually ending in a semicolon. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub enum Stmt { + /// A local (let) binding. + Local(Local), + + /// An item definition. + Item(Item), + + /// Expr without trailing semicolon. + Expr(Expr), + + /// Expression with trailing semicolon. + Semi(Expr, Token![;]), + } +} + +#[cfg(feature = "full")] +ast_struct! { + /// A local `let` binding: `let x: u64 = s.parse()?`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct Local { + pub attrs: Vec<Attribute>, + pub let_token: Token![let], + pub pats: Punctuated<Pat, Token![|]>, + pub ty: Option<(Token![:], Box<Type>)>, + pub init: Option<(Token![=], Box<Expr>)>, + pub semi_token: Token![;], + } +} + +#[cfg(feature = "full")] +ast_enum_of_structs! { + /// A pattern in a local binding, function signature, match expression, or + /// various other places. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum Pat { + /// A pattern that matches any value: `_`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Wild(PatWild { + pub underscore_token: Token![_], + }), + + /// A pattern that binds a new variable: `ref mut binding @ SUBPATTERN`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Ident(PatIdent { + pub by_ref: Option<Token![ref]>, + pub mutability: Option<Token![mut]>, + pub ident: Ident, + pub subpat: Option<(Token![@], Box<Pat>)>, + }), + + /// A struct or struct variant pattern: `Variant { x, y, .. }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Struct(PatStruct { + pub path: Path, + pub brace_token: token::Brace, + pub fields: Punctuated<FieldPat, Token![,]>, + pub dot2_token: Option<Token![..]>, + }), + + /// A tuple struct or tuple variant pattern: `Variant(x, y, .., z)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub TupleStruct(PatTupleStruct { + pub path: Path, + pub pat: PatTuple, + }), + + /// A path pattern like `Color::Red`, optionally qualified with a + /// self-type. + /// + /// Unqualified path patterns can legally refer to variants, structs, + /// constants or associated constants. Qualified path patterns like + /// `<A>::B::C` and `<A as Trait>::B::C` can only legally refer to + /// associated constants. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Path(PatPath { + pub qself: Option<QSelf>, + pub path: Path, + }), + + /// A tuple pattern: `(a, b)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Tuple(PatTuple { + pub paren_token: token::Paren, + pub front: Punctuated<Pat, Token![,]>, + pub dot2_token: Option<Token![..]>, + pub comma_token: Option<Token![,]>, + pub back: Punctuated<Pat, Token![,]>, + }), + + /// A box pattern: `box v`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Box(PatBox { + pub box_token: Token![box], + pub pat: Box<Pat>, + }), + + /// A reference pattern: `&mut (first, second)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Ref(PatRef { + pub and_token: Token![&], + pub mutability: Option<Token![mut]>, + pub pat: Box<Pat>, + }), + + /// A literal pattern: `0`. + /// + /// This holds an `Expr` rather than a `Lit` because negative numbers + /// are represented as an `Expr::Unary`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Lit(PatLit { + pub expr: Box<Expr>, + }), + + /// A range pattern: `1..=2`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Range(PatRange { + pub lo: Box<Expr>, + pub limits: RangeLimits, + pub hi: Box<Expr>, + }), + + /// A dynamically sized slice pattern: `[a, b, i.., y, z]`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Slice(PatSlice { + pub bracket_token: token::Bracket, + pub front: Punctuated<Pat, Token![,]>, + pub middle: Option<Box<Pat>>, + pub dot2_token: Option<Token![..]>, + pub comma_token: Option<Token![,]>, + pub back: Punctuated<Pat, Token![,]>, + }), + + /// A macro in expression position. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Macro(PatMacro { + pub mac: Macro, + }), + + /// Tokens in pattern position not interpreted by Syn. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Verbatim(PatVerbatim #manual_extra_traits { + pub tts: TokenStream, + }), + } +} + +#[cfg(all(feature = "full", feature = "extra-traits"))] +impl Eq for PatVerbatim {} + +#[cfg(all(feature = "full", feature = "extra-traits"))] +impl PartialEq for PatVerbatim { + fn eq(&self, other: &Self) -> bool { + TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(all(feature = "full", feature = "extra-traits"))] +impl Hash for PatVerbatim { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + TokenStreamHelper(&self.tts).hash(state); + } +} + +#[cfg(feature = "full")] +ast_struct! { + /// One arm of a `match` expression: `0...10 => { return true; }`. + /// + /// As in: + /// + /// ```edition2018 + /// # fn f() -> bool { + /// # let n = 0; + /// match n { + /// 0...10 => { + /// return true; + /// } + /// // ... + /// # _ => {} + /// } + /// # false + /// # } + /// ``` + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct Arm { + pub attrs: Vec<Attribute>, + pub leading_vert: Option<Token![|]>, + pub pats: Punctuated<Pat, Token![|]>, + pub guard: Option<(Token![if], Box<Expr>)>, + pub fat_arrow_token: Token![=>], + pub body: Box<Expr>, + pub comma: Option<Token![,]>, + } +} + +#[cfg(feature = "full")] +ast_enum! { + /// Limit types of a range, inclusive or exclusive. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + #[cfg_attr(feature = "clone-impls", derive(Copy))] + pub enum RangeLimits { + /// Inclusive at the beginning, exclusive at the end. + HalfOpen(Token![..]), + /// Inclusive at the beginning and end. + Closed(Token![..=]), + } +} + +#[cfg(feature = "full")] +ast_struct! { + /// A single field in a struct pattern. + /// + /// Patterns like the fields of Foo `{ x, ref y, ref mut z }` are treated + /// the same as `x: x, y: ref y, z: ref mut z` but there is no colon token. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct FieldPat { + pub attrs: Vec<Attribute>, + pub member: Member, + pub colon_token: Option<Token![:]>, + pub pat: Box<Pat>, + } +} + +#[cfg(any(feature = "parsing", feature = "printing"))] +#[cfg(feature = "full")] +fn requires_terminator(expr: &Expr) -> bool { + // see https://github.com/rust-lang/rust/blob/eb8f2586e/src/libsyntax/parse/classify.rs#L17-L37 + match *expr { + Expr::Unsafe(..) + | Expr::Block(..) + | Expr::If(..) + | Expr::Match(..) + | Expr::While(..) + | Expr::Loop(..) + | Expr::ForLoop(..) + | Expr::Async(..) + | Expr::TryBlock(..) => false, + _ => true, + } +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + #[cfg(feature = "full")] + use ext::IdentExt; + use parse::{Parse, ParseStream, Result}; + use path; + + // When we're parsing expressions which occur before blocks, like in an if + // statement's condition, we cannot parse a struct literal. + // + // Struct literals are ambiguous in certain positions + // https://github.com/rust-lang/rfcs/pull/92 + #[derive(Copy, Clone)] + pub struct AllowStruct(bool); + + #[derive(Copy, Clone, PartialEq, PartialOrd)] + enum Precedence { + Any, + Assign, + Range, + Or, + And, + Compare, + BitOr, + BitXor, + BitAnd, + Shift, + Arithmetic, + Term, + Cast, + } + + impl Precedence { + fn of(op: &BinOp) -> Self { + match *op { + BinOp::Add(_) | BinOp::Sub(_) => Precedence::Arithmetic, + BinOp::Mul(_) | BinOp::Div(_) | BinOp::Rem(_) => Precedence::Term, + BinOp::And(_) => Precedence::And, + BinOp::Or(_) => Precedence::Or, + BinOp::BitXor(_) => Precedence::BitXor, + BinOp::BitAnd(_) => Precedence::BitAnd, + BinOp::BitOr(_) => Precedence::BitOr, + BinOp::Shl(_) | BinOp::Shr(_) => Precedence::Shift, + BinOp::Eq(_) + | BinOp::Lt(_) + | BinOp::Le(_) + | BinOp::Ne(_) + | BinOp::Ge(_) + | BinOp::Gt(_) => Precedence::Compare, + BinOp::AddEq(_) + | BinOp::SubEq(_) + | BinOp::MulEq(_) + | BinOp::DivEq(_) + | BinOp::RemEq(_) + | BinOp::BitXorEq(_) + | BinOp::BitAndEq(_) + | BinOp::BitOrEq(_) + | BinOp::ShlEq(_) + | BinOp::ShrEq(_) => Precedence::Assign, + } + } + } + + impl Parse for Expr { + fn parse(input: ParseStream) -> Result<Self> { + ambiguous_expr(input, AllowStruct(true)) + } + } + + #[cfg(feature = "full")] + fn expr_no_struct(input: ParseStream) -> Result<Expr> { + ambiguous_expr(input, AllowStruct(false)) + } + + #[cfg(feature = "full")] + fn parse_expr( + input: ParseStream, + mut lhs: Expr, + allow_struct: AllowStruct, + base: Precedence, + ) -> Result<Expr> { + loop { + if input + .fork() + .parse::<BinOp>() + .ok() + .map_or(false, |op| Precedence::of(&op) >= base) + { + let op: BinOp = input.parse()?; + let precedence = Precedence::of(&op); + let mut rhs = unary_expr(input, allow_struct)?; + loop { + let next = peek_precedence(input); + if next > precedence || next == precedence && precedence == Precedence::Assign { + rhs = parse_expr(input, rhs, allow_struct, next)?; + } else { + break; + } + } + lhs = if precedence == Precedence::Assign { + Expr::AssignOp(ExprAssignOp { + attrs: Vec::new(), + left: Box::new(lhs), + op: op, + right: Box::new(rhs), + }) + } else { + Expr::Binary(ExprBinary { + attrs: Vec::new(), + left: Box::new(lhs), + op: op, + right: Box::new(rhs), + }) + }; + } else if Precedence::Assign >= base + && input.peek(Token![=]) + && !input.peek(Token![==]) + && !input.peek(Token![=>]) + { + let eq_token: Token![=] = input.parse()?; + let mut rhs = unary_expr(input, allow_struct)?; + loop { + let next = peek_precedence(input); + if next >= Precedence::Assign { + rhs = parse_expr(input, rhs, allow_struct, next)?; + } else { + break; + } + } + lhs = Expr::Assign(ExprAssign { + attrs: Vec::new(), + left: Box::new(lhs), + eq_token: eq_token, + right: Box::new(rhs), + }); + } else if Precedence::Range >= base && input.peek(Token![..]) { + let limits: RangeLimits = input.parse()?; + let rhs = if input.is_empty() + || input.peek(Token![,]) + || input.peek(Token![;]) + || !allow_struct.0 && input.peek(token::Brace) + { + None + } else { + let mut rhs = unary_expr(input, allow_struct)?; + loop { + let next = peek_precedence(input); + if next > Precedence::Range { + rhs = parse_expr(input, rhs, allow_struct, next)?; + } else { + break; + } + } + Some(rhs) + }; + lhs = Expr::Range(ExprRange { + attrs: Vec::new(), + from: Some(Box::new(lhs)), + limits: limits, + to: rhs.map(Box::new), + }); + } else if Precedence::Cast >= base && input.peek(Token![as]) { + let as_token: Token![as] = input.parse()?; + let ty = input.call(Type::without_plus)?; + lhs = Expr::Cast(ExprCast { + attrs: Vec::new(), + expr: Box::new(lhs), + as_token: as_token, + ty: Box::new(ty), + }); + } else if Precedence::Cast >= base && input.peek(Token![:]) && !input.peek(Token![::]) { + let colon_token: Token![:] = input.parse()?; + let ty = input.call(Type::without_plus)?; + lhs = Expr::Type(ExprType { + attrs: Vec::new(), + expr: Box::new(lhs), + colon_token: colon_token, + ty: Box::new(ty), + }); + } else { + break; + } + } + Ok(lhs) + } + + #[cfg(not(feature = "full"))] + fn parse_expr( + input: ParseStream, + mut lhs: Expr, + allow_struct: AllowStruct, + base: Precedence, + ) -> Result<Expr> { + loop { + if input + .fork() + .parse::<BinOp>() + .ok() + .map_or(false, |op| Precedence::of(&op) >= base) + { + let op: BinOp = input.parse()?; + let precedence = Precedence::of(&op); + let mut rhs = unary_expr(input, allow_struct)?; + loop { + let next = peek_precedence(input); + if next > precedence || next == precedence && precedence == Precedence::Assign { + rhs = parse_expr(input, rhs, allow_struct, next)?; + } else { + break; + } + } + lhs = Expr::Binary(ExprBinary { + attrs: Vec::new(), + left: Box::new(lhs), + op: op, + right: Box::new(rhs), + }); + } else if Precedence::Cast >= base && input.peek(Token![as]) { + let as_token: Token![as] = input.parse()?; + let ty = input.call(Type::without_plus)?; + lhs = Expr::Cast(ExprCast { + attrs: Vec::new(), + expr: Box::new(lhs), + as_token: as_token, + ty: Box::new(ty), + }); + } else { + break; + } + } + Ok(lhs) + } + + fn peek_precedence(input: ParseStream) -> Precedence { + if let Ok(op) = input.fork().parse() { + Precedence::of(&op) + } else if input.peek(Token![=]) && !input.peek(Token![=>]) { + Precedence::Assign + } else if input.peek(Token![..]) { + Precedence::Range + } else if input.peek(Token![as]) || input.peek(Token![:]) && !input.peek(Token![::]) { + Precedence::Cast + } else { + Precedence::Any + } + } + + // Parse an arbitrary expression. + fn ambiguous_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { + let lhs = unary_expr(input, allow_struct)?; + parse_expr(input, lhs, allow_struct, Precedence::Any) + } + + // <UnOp> <trailer> + // & <trailer> + // &mut <trailer> + // box <trailer> + #[cfg(feature = "full")] + fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { + // TODO: optimize using advance_to + let ahead = input.fork(); + ahead.call(Attribute::parse_outer)?; + if ahead.peek(Token![&]) + || ahead.peek(Token![box]) + || ahead.peek(Token![*]) + || ahead.peek(Token![!]) + || ahead.peek(Token![-]) + { + let attrs = input.call(Attribute::parse_outer)?; + if input.peek(Token![&]) { + Ok(Expr::Reference(ExprReference { + attrs: attrs, + and_token: input.parse()?, + mutability: input.parse()?, + expr: Box::new(unary_expr(input, allow_struct)?), + })) + } else if input.peek(Token![box]) { + Ok(Expr::Box(ExprBox { + attrs: attrs, + box_token: input.parse()?, + expr: Box::new(unary_expr(input, allow_struct)?), + })) + } else { + Ok(Expr::Unary(ExprUnary { + attrs: attrs, + op: input.parse()?, + expr: Box::new(unary_expr(input, allow_struct)?), + })) + } + } else { + trailer_expr(input, allow_struct) + } + } + + #[cfg(not(feature = "full"))] + fn unary_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { + // TODO: optimize using advance_to + let ahead = input.fork(); + ahead.call(Attribute::parse_outer)?; + if ahead.peek(Token![*]) || ahead.peek(Token![!]) || ahead.peek(Token![-]) { + Ok(Expr::Unary(ExprUnary { + attrs: input.call(Attribute::parse_outer)?, + op: input.parse()?, + expr: Box::new(unary_expr(input, allow_struct)?), + })) + } else { + trailer_expr(input, allow_struct) + } + } + + // <atom> (..<args>) ... + // <atom> . <ident> (..<args>) ... + // <atom> . <ident> ... + // <atom> . <lit> ... + // <atom> [ <expr> ] ... + // <atom> ? ... + #[cfg(feature = "full")] + fn trailer_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { + if input.peek(token::Group) { + return input.call(expr_group).map(Expr::Group); + } + + let outer_attrs = input.call(Attribute::parse_outer)?; + + let atom = atom_expr(input, allow_struct)?; + let mut e = trailer_helper(input, atom)?; + + let inner_attrs = e.replace_attrs(Vec::new()); + let attrs = private::attrs(outer_attrs, inner_attrs); + e.replace_attrs(attrs); + Ok(e) + } + + #[cfg(feature = "full")] + fn trailer_helper(input: ParseStream, mut e: Expr) -> Result<Expr> { + loop { + if input.peek(token::Paren) { + let content; + e = Expr::Call(ExprCall { + attrs: Vec::new(), + func: Box::new(e), + paren_token: parenthesized!(content in input), + args: content.parse_terminated(Expr::parse)?, + }); + } else if input.peek(Token![.]) && !input.peek(Token![..]) { + let dot_token: Token![.] = input.parse()?; + let member: Member = input.parse()?; + let turbofish = if member.is_named() && input.peek(Token![::]) { + Some(MethodTurbofish { + colon2_token: input.parse()?, + lt_token: input.parse()?, + args: { + let mut args = Punctuated::new(); + loop { + if input.peek(Token![>]) { + break; + } + let value = input.call(generic_method_argument)?; + args.push_value(value); + if input.peek(Token![>]) { + break; + } + let punct = input.parse()?; + args.push_punct(punct); + } + args + }, + gt_token: input.parse()?, + }) + } else { + None + }; + + if turbofish.is_some() || input.peek(token::Paren) { + if let Member::Named(method) = member { + let content; + e = Expr::MethodCall(ExprMethodCall { + attrs: Vec::new(), + receiver: Box::new(e), + dot_token: dot_token, + method: method, + turbofish: turbofish, + paren_token: parenthesized!(content in input), + args: content.parse_terminated(Expr::parse)?, + }); + continue; + } + } + + e = Expr::Field(ExprField { + attrs: Vec::new(), + base: Box::new(e), + dot_token: dot_token, + member: member, + }); + } else if input.peek(token::Bracket) { + let content; + e = Expr::Index(ExprIndex { + attrs: Vec::new(), + expr: Box::new(e), + bracket_token: bracketed!(content in input), + index: content.parse()?, + }); + } else if input.peek(Token![?]) { + e = Expr::Try(ExprTry { + attrs: Vec::new(), + expr: Box::new(e), + question_token: input.parse()?, + }); + } else { + break; + } + } + Ok(e) + } + + #[cfg(not(feature = "full"))] + fn trailer_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { + let mut e = atom_expr(input, allow_struct)?; + + loop { + if input.peek(token::Paren) { + let content; + e = Expr::Call(ExprCall { + attrs: Vec::new(), + func: Box::new(e), + paren_token: parenthesized!(content in input), + args: content.parse_terminated(Expr::parse)?, + }); + } else if input.peek(Token![.]) { + e = Expr::Field(ExprField { + attrs: Vec::new(), + base: Box::new(e), + dot_token: input.parse()?, + member: input.parse()?, + }); + } else if input.peek(token::Bracket) { + let content; + e = Expr::Index(ExprIndex { + attrs: Vec::new(), + expr: Box::new(e), + bracket_token: bracketed!(content in input), + index: content.parse()?, + }); + } else { + break; + } + } + + Ok(e) + } + + // Parse all atomic expressions which don't have to worry about precedence + // interactions, as they are fully contained. + #[cfg(feature = "full")] + fn atom_expr(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { + if input.peek(token::Group) { + input.call(expr_group).map(Expr::Group) + } else if input.peek(Lit) { + input.parse().map(Expr::Lit) + } else if input.peek(Token![async]) + && (input.peek2(token::Brace) || input.peek2(Token![move]) && input.peek3(token::Brace)) + { + input.call(expr_async).map(Expr::Async) + } else if input.peek(Token![try]) && input.peek2(token::Brace) { + input.call(expr_try_block).map(Expr::TryBlock) + } else if input.peek(Token![|]) + || input.peek(Token![async]) && (input.peek2(Token![|]) || input.peek2(Token![move])) + || input.peek(Token![static]) + || input.peek(Token![move]) + { + expr_closure(input, allow_struct).map(Expr::Closure) + } else if input.peek(Ident) + || input.peek(Token![::]) + || input.peek(Token![<]) + || input.peek(Token![self]) + || input.peek(Token![Self]) + || input.peek(Token![super]) + || input.peek(Token![extern]) + || input.peek(Token![crate]) + { + path_or_macro_or_struct(input, allow_struct) + } else if input.peek(token::Paren) { + paren_or_tuple(input) + } else if input.peek(Token![break]) { + expr_break(input, allow_struct).map(Expr::Break) + } else if input.peek(Token![continue]) { + input.call(expr_continue).map(Expr::Continue) + } else if input.peek(Token![return]) { + expr_ret(input, allow_struct).map(Expr::Return) + } else if input.peek(token::Bracket) { + array_or_repeat(input) + } else if input.peek(Token![let]) { + input.call(expr_let).map(Expr::Let) + } else if input.peek(Token![if]) { + input.parse().map(Expr::If) + } else if input.peek(Token![while]) { + input.parse().map(Expr::While) + } else if input.peek(Token![for]) { + input.parse().map(Expr::ForLoop) + } else if input.peek(Token![loop]) { + input.parse().map(Expr::Loop) + } else if input.peek(Token![match]) { + input.parse().map(Expr::Match) + } else if input.peek(Token![yield]) { + input.call(expr_yield).map(Expr::Yield) + } else if input.peek(Token![unsafe]) { + input.call(expr_unsafe).map(Expr::Unsafe) + } else if input.peek(token::Brace) { + input.call(expr_block).map(Expr::Block) + } else if input.peek(Token![..]) { + expr_range(input, allow_struct).map(Expr::Range) + } else if input.peek(Lifetime) { + let the_label: Label = input.parse()?; + let mut expr = if input.peek(Token![while]) { + Expr::While(input.parse()?) + } else if input.peek(Token![for]) { + Expr::ForLoop(input.parse()?) + } else if input.peek(Token![loop]) { + Expr::Loop(input.parse()?) + } else if input.peek(token::Brace) { + Expr::Block(input.call(expr_block)?) + } else { + return Err(input.error("expected loop or block expression")); + }; + match expr { + Expr::While(ExprWhile { ref mut label, .. }) + | Expr::ForLoop(ExprForLoop { ref mut label, .. }) + | Expr::Loop(ExprLoop { ref mut label, .. }) + | Expr::Block(ExprBlock { ref mut label, .. }) => *label = Some(the_label), + _ => unreachable!(), + } + Ok(expr) + } else { + Err(input.error("expected expression")) + } + } + + #[cfg(not(feature = "full"))] + fn atom_expr(input: ParseStream, _allow_struct: AllowStruct) -> Result<Expr> { + if input.peek(Lit) { + input.parse().map(Expr::Lit) + } else if input.peek(token::Paren) { + input.call(expr_paren).map(Expr::Paren) + } else if input.peek(Ident) + || input.peek(Token![::]) + || input.peek(Token![<]) + || input.peek(Token![self]) + || input.peek(Token![Self]) + || input.peek(Token![super]) + || input.peek(Token![extern]) + || input.peek(Token![crate]) + { + input.parse().map(Expr::Path) + } else { + Err(input.error("unsupported expression; enable syn's features=[\"full\"]")) + } + } + + #[cfg(feature = "full")] + fn path_or_macro_or_struct(input: ParseStream, allow_struct: AllowStruct) -> Result<Expr> { + let expr: ExprPath = input.parse()?; + if expr.qself.is_some() { + return Ok(Expr::Path(expr)); + } + + if input.peek(Token![!]) && !input.peek(Token![!=]) { + let mut contains_arguments = false; + for segment in &expr.path.segments { + match segment.arguments { + PathArguments::None => {} + PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => { + contains_arguments = true; + } + } + } + + if !contains_arguments { + let bang_token: Token![!] = input.parse()?; + let (delimiter, tts) = mac::parse_delimiter(input)?; + return Ok(Expr::Macro(ExprMacro { + attrs: Vec::new(), + mac: Macro { + path: expr.path, + bang_token: bang_token, + delimiter: delimiter, + tts: tts, + }, + })); + } + } + + if allow_struct.0 && input.peek(token::Brace) { + let outer_attrs = Vec::new(); + expr_struct_helper(input, outer_attrs, expr.path).map(Expr::Struct) + } else { + Ok(Expr::Path(expr)) + } + } + + #[cfg(feature = "full")] + fn paren_or_tuple(input: ParseStream) -> Result<Expr> { + let content; + let paren_token = parenthesized!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + if content.is_empty() { + return Ok(Expr::Tuple(ExprTuple { + attrs: inner_attrs, + paren_token: paren_token, + elems: Punctuated::new(), + })); + } + + let first: Expr = content.parse()?; + if content.is_empty() { + return Ok(Expr::Paren(ExprParen { + attrs: inner_attrs, + paren_token: paren_token, + expr: Box::new(first), + })); + } + + let mut elems = Punctuated::new(); + elems.push_value(first); + while !content.is_empty() { + let punct = content.parse()?; + elems.push_punct(punct); + if content.is_empty() { + break; + } + let value = content.parse()?; + elems.push_value(value); + } + Ok(Expr::Tuple(ExprTuple { + attrs: inner_attrs, + paren_token: paren_token, + elems: elems, + })) + } + + #[cfg(feature = "full")] + fn array_or_repeat(input: ParseStream) -> Result<Expr> { + let content; + let bracket_token = bracketed!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + if content.is_empty() { + return Ok(Expr::Array(ExprArray { + attrs: inner_attrs, + bracket_token: bracket_token, + elems: Punctuated::new(), + })); + } + + let first: Expr = content.parse()?; + if content.is_empty() || content.peek(Token![,]) { + let mut elems = Punctuated::new(); + elems.push_value(first); + while !content.is_empty() { + let punct = content.parse()?; + elems.push_punct(punct); + if content.is_empty() { + break; + } + let value = content.parse()?; + elems.push_value(value); + } + Ok(Expr::Array(ExprArray { + attrs: inner_attrs, + bracket_token: bracket_token, + elems: elems, + })) + } else if content.peek(Token![;]) { + let semi_token: Token![;] = content.parse()?; + let len: Expr = content.parse()?; + Ok(Expr::Repeat(ExprRepeat { + attrs: inner_attrs, + bracket_token: bracket_token, + expr: Box::new(first), + semi_token: semi_token, + len: Box::new(len), + })) + } else { + Err(content.error("expected `,` or `;`")) + } + } + + #[cfg(feature = "full")] + fn expr_early(input: ParseStream) -> Result<Expr> { + let mut attrs = input.call(Attribute::parse_outer)?; + let mut expr = if input.peek(Token![if]) { + Expr::If(input.parse()?) + } else if input.peek(Token![while]) { + Expr::While(input.parse()?) + } else if input.peek(Token![for]) { + Expr::ForLoop(input.parse()?) + } else if input.peek(Token![loop]) { + Expr::Loop(input.parse()?) + } else if input.peek(Token![match]) { + Expr::Match(input.parse()?) + } else if input.peek(Token![try]) && input.peek2(token::Brace) { + Expr::TryBlock(input.call(expr_try_block)?) + } else if input.peek(Token![unsafe]) { + Expr::Unsafe(input.call(expr_unsafe)?) + } else if input.peek(token::Brace) { + Expr::Block(input.call(expr_block)?) + } else { + let allow_struct = AllowStruct(true); + let mut expr = unary_expr(input, allow_struct)?; + + attrs.extend(expr.replace_attrs(Vec::new())); + expr.replace_attrs(attrs); + + return parse_expr(input, expr, allow_struct, Precedence::Any); + }; + + if input.peek(Token![.]) || input.peek(Token![?]) { + expr = trailer_helper(input, expr)?; + + attrs.extend(expr.replace_attrs(Vec::new())); + expr.replace_attrs(attrs); + + let allow_struct = AllowStruct(true); + return parse_expr(input, expr, allow_struct, Precedence::Any); + } + + attrs.extend(expr.replace_attrs(Vec::new())); + expr.replace_attrs(attrs); + Ok(expr) + } + + impl Parse for ExprLit { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ExprLit { + attrs: Vec::new(), + lit: input.parse()?, + }) + } + } + + #[cfg(feature = "full")] + fn expr_group(input: ParseStream) -> Result<ExprGroup> { + let group = private::parse_group(input)?; + Ok(ExprGroup { + attrs: Vec::new(), + group_token: group.token, + expr: group.content.parse()?, + }) + } + + #[cfg(not(feature = "full"))] + fn expr_paren(input: ParseStream) -> Result<ExprParen> { + let content; + Ok(ExprParen { + attrs: Vec::new(), + paren_token: parenthesized!(content in input), + expr: content.parse()?, + }) + } + + #[cfg(feature = "full")] + fn generic_method_argument(input: ParseStream) -> Result<GenericMethodArgument> { + // TODO parse const generics as well + input.parse().map(GenericMethodArgument::Type) + } + + #[cfg(feature = "full")] + fn expr_let(input: ParseStream) -> Result<ExprLet> { + Ok(ExprLet { + attrs: Vec::new(), + let_token: input.parse()?, + pats: { + let mut pats = Punctuated::new(); + input.parse::<Option<Token![|]>>()?; + let value: Pat = input.parse()?; + pats.push_value(value); + while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) { + let punct = input.parse()?; + pats.push_punct(punct); + let value: Pat = input.parse()?; + pats.push_value(value); + } + pats + }, + eq_token: input.parse()?, + expr: Box::new(input.call(expr_no_struct)?), + }) + } + + #[cfg(feature = "full")] + impl Parse for ExprIf { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ExprIf { + attrs: Vec::new(), + if_token: input.parse()?, + cond: Box::new(input.call(expr_no_struct)?), + then_branch: input.parse()?, + else_branch: { + if input.peek(Token![else]) { + Some(input.call(else_block)?) + } else { + None + } + }, + }) + } + } + + #[cfg(feature = "full")] + fn else_block(input: ParseStream) -> Result<(Token![else], Box<Expr>)> { + let else_token: Token![else] = input.parse()?; + + let lookahead = input.lookahead1(); + let else_branch = if input.peek(Token![if]) { + input.parse().map(Expr::If)? + } else if input.peek(token::Brace) { + Expr::Block(ExprBlock { + attrs: Vec::new(), + label: None, + block: input.parse()?, + }) + } else { + return Err(lookahead.error()); + }; + + Ok((else_token, Box::new(else_branch))) + } + + #[cfg(feature = "full")] + impl Parse for ExprForLoop { + fn parse(input: ParseStream) -> Result<Self> { + let label: Option<Label> = input.parse()?; + let for_token: Token![for] = input.parse()?; + let pat: Pat = input.parse()?; + let in_token: Token![in] = input.parse()?; + let expr: Expr = input.call(expr_no_struct)?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let stmts = content.call(Block::parse_within)?; + + Ok(ExprForLoop { + attrs: inner_attrs, + label: label, + for_token: for_token, + pat: Box::new(pat), + in_token: in_token, + expr: Box::new(expr), + body: Block { + brace_token: brace_token, + stmts: stmts, + }, + }) + } + } + + #[cfg(feature = "full")] + impl Parse for ExprLoop { + fn parse(input: ParseStream) -> Result<Self> { + let label: Option<Label> = input.parse()?; + let loop_token: Token![loop] = input.parse()?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let stmts = content.call(Block::parse_within)?; + + Ok(ExprLoop { + attrs: inner_attrs, + label: label, + loop_token: loop_token, + body: Block { + brace_token: brace_token, + stmts: stmts, + }, + }) + } + } + + #[cfg(feature = "full")] + impl Parse for ExprMatch { + fn parse(input: ParseStream) -> Result<Self> { + let match_token: Token![match] = input.parse()?; + let expr = expr_no_struct(input)?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + + let mut arms = Vec::new(); + while !content.is_empty() { + arms.push(content.call(Arm::parse)?); + } + + Ok(ExprMatch { + attrs: inner_attrs, + match_token: match_token, + expr: Box::new(expr), + brace_token: brace_token, + arms: arms, + }) + } + } + + #[cfg(all(feature = "full", feature = "printing"))] + impl Parse for ExprInPlace { + fn parse(input: ParseStream) -> Result<Self> { + let msg = "placement expression has been removed from Rust and is no longer parsed"; + Err(input.error(msg)) + } + } + + macro_rules! impl_by_parsing_expr { + ( + $( + $expr_type:ty, $variant:ident, $msg:expr, + )* + ) => { + $( + #[cfg(all(feature = "full", feature = "printing"))] + impl Parse for $expr_type { + fn parse(input: ParseStream) -> Result<Self> { + let mut expr: Expr = input.parse()?; + loop { + match expr { + Expr::$variant(inner) => return Ok(inner), + Expr::Group(next) => expr = *next.expr, + _ => return Err(Error::new_spanned(expr, $msg)), + } + } + } + } + )* + }; + } + + impl_by_parsing_expr! { + ExprBox, Box, "expected box expression", + ExprArray, Array, "expected slice literal expression", + ExprCall, Call, "expected function call expression", + ExprMethodCall, MethodCall, "expected method call expression", + ExprTuple, Tuple, "expected tuple expression", + ExprBinary, Binary, "expected binary operation", + ExprUnary, Unary, "expected unary operation", + ExprCast, Cast, "expected cast expression", + ExprType, Type, "expected type ascription expression", + ExprLet, Let, "expected let guard", + ExprClosure, Closure, "expected closure expression", + ExprUnsafe, Unsafe, "expected unsafe block", + ExprBlock, Block, "expected blocked scope", + ExprAssign, Assign, "expected assignment expression", + ExprAssignOp, AssignOp, "expected compound assignment expression", + ExprField, Field, "expected struct field access", + ExprIndex, Index, "expected indexing expression", + ExprRange, Range, "expected range expression", + ExprReference, Reference, "expected referencing operation", + ExprBreak, Break, "expected break expression", + ExprContinue, Continue, "expected continue expression", + ExprReturn, Return, "expected return expression", + ExprMacro, Macro, "expected macro invocation expression", + ExprStruct, Struct, "expected struct literal expression", + ExprRepeat, Repeat, "expected array literal constructed from one repeated element", + ExprParen, Paren, "expected parenthesized expression", + ExprTry, Try, "expected try expression", + ExprAsync, Async, "expected async block", + ExprTryBlock, TryBlock, "expected try block", + ExprYield, Yield, "expected yield expression", + } + + #[cfg(feature = "full")] + fn expr_try_block(input: ParseStream) -> Result<ExprTryBlock> { + Ok(ExprTryBlock { + attrs: Vec::new(), + try_token: input.parse()?, + block: input.parse()?, + }) + } + + #[cfg(feature = "full")] + fn expr_yield(input: ParseStream) -> Result<ExprYield> { + Ok(ExprYield { + attrs: Vec::new(), + yield_token: input.parse()?, + expr: { + if !input.is_empty() && !input.peek(Token![,]) && !input.peek(Token![;]) { + Some(input.parse()?) + } else { + None + } + }, + }) + } + + #[cfg(feature = "full")] + fn expr_closure(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprClosure> { + let asyncness: Option<Token![async]> = input.parse()?; + let movability: Option<Token![static]> = if asyncness.is_none() { + input.parse()? + } else { + None + }; + let capture: Option<Token![move]> = input.parse()?; + let or1_token: Token![|] = input.parse()?; + + let mut inputs = Punctuated::new(); + loop { + if input.peek(Token![|]) { + break; + } + let value = fn_arg(input)?; + inputs.push_value(value); + if input.peek(Token![|]) { + break; + } + let punct: Token![,] = input.parse()?; + inputs.push_punct(punct); + } + + let or2_token: Token![|] = input.parse()?; + + let (output, body) = if input.peek(Token![->]) { + let arrow_token: Token![->] = input.parse()?; + let ty: Type = input.parse()?; + let body: Block = input.parse()?; + let output = ReturnType::Type(arrow_token, Box::new(ty)); + let block = Expr::Block(ExprBlock { + attrs: Vec::new(), + label: None, + block: body, + }); + (output, block) + } else { + let body = ambiguous_expr(input, allow_struct)?; + (ReturnType::Default, body) + }; + + Ok(ExprClosure { + attrs: Vec::new(), + asyncness: asyncness, + movability: movability, + capture: capture, + or1_token: or1_token, + inputs: inputs, + or2_token: or2_token, + output: output, + body: Box::new(body), + }) + } + + #[cfg(feature = "full")] + fn expr_async(input: ParseStream) -> Result<ExprAsync> { + Ok(ExprAsync { + attrs: Vec::new(), + async_token: input.parse()?, + capture: input.parse()?, + block: input.parse()?, + }) + } + + #[cfg(feature = "full")] + fn fn_arg(input: ParseStream) -> Result<FnArg> { + let pat: Pat = input.parse()?; + + if input.peek(Token![:]) { + Ok(FnArg::Captured(ArgCaptured { + pat: pat, + colon_token: input.parse()?, + ty: input.parse()?, + })) + } else { + Ok(FnArg::Inferred(pat)) + } + } + + #[cfg(feature = "full")] + impl Parse for ExprWhile { + fn parse(input: ParseStream) -> Result<Self> { + let label: Option<Label> = input.parse()?; + let while_token: Token![while] = input.parse()?; + let cond = expr_no_struct(input)?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let stmts = content.call(Block::parse_within)?; + + Ok(ExprWhile { + attrs: inner_attrs, + label: label, + while_token: while_token, + cond: Box::new(cond), + body: Block { + brace_token: brace_token, + stmts: stmts, + }, + }) + } + } + + #[cfg(feature = "full")] + impl Parse for Label { + fn parse(input: ParseStream) -> Result<Self> { + Ok(Label { + name: input.parse()?, + colon_token: input.parse()?, + }) + } + } + + #[cfg(feature = "full")] + impl Parse for Option<Label> { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Lifetime) { + input.parse().map(Some) + } else { + Ok(None) + } + } + } + + #[cfg(feature = "full")] + fn expr_continue(input: ParseStream) -> Result<ExprContinue> { + Ok(ExprContinue { + attrs: Vec::new(), + continue_token: input.parse()?, + label: input.parse()?, + }) + } + + #[cfg(feature = "full")] + fn expr_break(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprBreak> { + Ok(ExprBreak { + attrs: Vec::new(), + break_token: input.parse()?, + label: input.parse()?, + expr: { + if input.is_empty() + || input.peek(Token![,]) + || input.peek(Token![;]) + || !allow_struct.0 && input.peek(token::Brace) + { + None + } else { + let expr = ambiguous_expr(input, allow_struct)?; + Some(Box::new(expr)) + } + }, + }) + } + + #[cfg(feature = "full")] + fn expr_ret(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprReturn> { + Ok(ExprReturn { + attrs: Vec::new(), + return_token: input.parse()?, + expr: { + if input.is_empty() || input.peek(Token![,]) || input.peek(Token![;]) { + None + } else { + // NOTE: return is greedy and eats blocks after it even when in a + // position where structs are not allowed, such as in if statement + // conditions. For example: + // + // if return { println!("A") } {} // Prints "A" + let expr = ambiguous_expr(input, allow_struct)?; + Some(Box::new(expr)) + } + }, + }) + } + + #[cfg(feature = "full")] + impl Parse for FieldValue { + fn parse(input: ParseStream) -> Result<Self> { + let member: Member = input.parse()?; + let (colon_token, value) = if input.peek(Token![:]) || !member.is_named() { + let colon_token: Token![:] = input.parse()?; + let value: Expr = input.parse()?; + (Some(colon_token), value) + } else if let Member::Named(ref ident) = member { + let value = Expr::Path(ExprPath { + attrs: Vec::new(), + qself: None, + path: Path::from(ident.clone()), + }); + (None, value) + } else { + unreachable!() + }; + + Ok(FieldValue { + attrs: Vec::new(), + member: member, + colon_token: colon_token, + expr: value, + }) + } + } + + #[cfg(feature = "full")] + fn expr_struct_helper( + input: ParseStream, + outer_attrs: Vec<Attribute>, + path: Path, + ) -> Result<ExprStruct> { + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + + let mut fields = Punctuated::new(); + loop { + let attrs = content.call(Attribute::parse_outer)?; + // TODO: optimize using advance_to + if content.fork().parse::<Member>().is_err() { + if attrs.is_empty() { + break; + } else { + return Err(content.error("expected struct field")); + } + } + + fields.push(FieldValue { + attrs: attrs, + ..content.parse()? + }); + + if !content.peek(Token![,]) { + break; + } + let punct: Token![,] = content.parse()?; + fields.push_punct(punct); + } + + let (dot2_token, rest) = if fields.empty_or_trailing() && content.peek(Token![..]) { + let dot2_token: Token![..] = content.parse()?; + let rest: Expr = content.parse()?; + (Some(dot2_token), Some(Box::new(rest))) + } else { + (None, None) + }; + + Ok(ExprStruct { + attrs: private::attrs(outer_attrs, inner_attrs), + brace_token: brace_token, + path: path, + fields: fields, + dot2_token: dot2_token, + rest: rest, + }) + } + + #[cfg(feature = "full")] + fn expr_unsafe(input: ParseStream) -> Result<ExprUnsafe> { + let unsafe_token: Token![unsafe] = input.parse()?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let stmts = content.call(Block::parse_within)?; + + Ok(ExprUnsafe { + attrs: inner_attrs, + unsafe_token: unsafe_token, + block: Block { + brace_token: brace_token, + stmts: stmts, + }, + }) + } + + #[cfg(feature = "full")] + pub fn expr_block(input: ParseStream) -> Result<ExprBlock> { + let label: Option<Label> = input.parse()?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let stmts = content.call(Block::parse_within)?; + + Ok(ExprBlock { + attrs: inner_attrs, + label: label, + block: Block { + brace_token: brace_token, + stmts: stmts, + }, + }) + } + + #[cfg(feature = "full")] + fn expr_range(input: ParseStream, allow_struct: AllowStruct) -> Result<ExprRange> { + Ok(ExprRange { + attrs: Vec::new(), + from: None, + limits: input.parse()?, + to: { + if input.is_empty() + || input.peek(Token![,]) + || input.peek(Token![;]) + || !allow_struct.0 && input.peek(token::Brace) + { + None + } else { + let to = ambiguous_expr(input, allow_struct)?; + Some(Box::new(to)) + } + }, + }) + } + + #[cfg(feature = "full")] + impl Parse for RangeLimits { + fn parse(input: ParseStream) -> Result<Self> { + let lookahead = input.lookahead1(); + if lookahead.peek(Token![..=]) { + input.parse().map(RangeLimits::Closed) + } else if lookahead.peek(Token![...]) { + let dot3: Token![...] = input.parse()?; + Ok(RangeLimits::Closed(Token)) + } else if lookahead.peek(Token![..]) { + input.parse().map(RangeLimits::HalfOpen) + } else { + Err(lookahead.error()) + } + } + } + + impl Parse for ExprPath { + fn parse(input: ParseStream) -> Result<Self> { + #[cfg(not(feature = "full"))] + let attrs = Vec::new(); + #[cfg(feature = "full")] + let attrs = input.call(Attribute::parse_outer)?; + + let (qself, path) = path::parsing::qpath(input, true)?; + + Ok(ExprPath { + attrs: attrs, + qself: qself, + path: path, + }) + } + } + + #[cfg(feature = "full")] + impl Parse for Block { + fn parse(input: ParseStream) -> Result<Self> { + let content; + Ok(Block { + brace_token: braced!(content in input), + stmts: content.call(Block::parse_within)?, + }) + } + } + + #[cfg(feature = "full")] + impl Block { + /// Parse the body of a block as zero or more statements, possibly + /// including one trailing expression. + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + /// + /// # Example + /// + /// ```edition2018 + /// use syn::{braced, token, Attribute, Block, Ident, Result, Stmt, Token}; + /// use syn::parse::{Parse, ParseStream}; + /// + /// // Parse a function with no generics or parameter list. + /// // + /// // fn playground { + /// // let mut x = 1; + /// // x += 1; + /// // println!("{}", x); + /// // } + /// struct MiniFunction { + /// attrs: Vec<Attribute>, + /// fn_token: Token![fn], + /// name: Ident, + /// brace_token: token::Brace, + /// stmts: Vec<Stmt>, + /// } + /// + /// impl Parse for MiniFunction { + /// fn parse(input: ParseStream) -> Result<Self> { + /// let outer_attrs = input.call(Attribute::parse_outer)?; + /// let fn_token: Token![fn] = input.parse()?; + /// let name: Ident = input.parse()?; + /// + /// let content; + /// let brace_token = braced!(content in input); + /// let inner_attrs = content.call(Attribute::parse_inner)?; + /// let stmts = content.call(Block::parse_within)?; + /// + /// Ok(MiniFunction { + /// attrs: { + /// let mut attrs = outer_attrs; + /// attrs.extend(inner_attrs); + /// attrs + /// }, + /// fn_token: fn_token, + /// name: name, + /// brace_token: brace_token, + /// stmts: stmts, + /// }) + /// } + /// } + /// ``` + pub fn parse_within(input: ParseStream) -> Result<Vec<Stmt>> { + let mut stmts = Vec::new(); + loop { + while input.peek(Token![;]) { + input.parse::<Token![;]>()?; + } + if input.is_empty() { + break; + } + let s = parse_stmt(input, true)?; + let requires_semicolon = if let Stmt::Expr(ref s) = s { + requires_terminator(s) + } else { + false + }; + stmts.push(s); + if input.is_empty() { + break; + } else if requires_semicolon { + return Err(input.error("unexpected token")); + } + } + Ok(stmts) + } + } + + #[cfg(feature = "full")] + impl Parse for Stmt { + fn parse(input: ParseStream) -> Result<Self> { + parse_stmt(input, false) + } + } + + #[cfg(feature = "full")] + fn parse_stmt(input: ParseStream, allow_nosemi: bool) -> Result<Stmt> { + // TODO: optimize using advance_to + let ahead = input.fork(); + ahead.call(Attribute::parse_outer)?; + + if { + let ahead = ahead.fork(); + // Only parse braces here; paren and bracket will get parsed as + // expression statements + ahead.call(Path::parse_mod_style).is_ok() + && ahead.parse::<Token![!]>().is_ok() + && (ahead.peek(token::Brace) || ahead.peek(Ident)) + } { + stmt_mac(input) + } else if ahead.peek(Token![let]) { + stmt_local(input).map(Stmt::Local) + } else if ahead.peek(Token![pub]) + || ahead.peek(Token![crate]) && !ahead.peek2(Token![::]) + || ahead.peek(Token![extern]) && !ahead.peek2(Token![::]) + || ahead.peek(Token![use]) + || ahead.peek(Token![static]) && (ahead.peek2(Token![mut]) || ahead.peek2(Ident)) + || ahead.peek(Token![const]) + || ahead.peek(Token![unsafe]) && !ahead.peek2(token::Brace) + || ahead.peek(Token![async]) + && (ahead.peek2(Token![unsafe]) + || ahead.peek2(Token![extern]) + || ahead.peek2(Token![fn])) + || ahead.peek(Token![fn]) + || ahead.peek(Token![mod]) + || ahead.peek(Token![type]) + || ahead.peek(Token![existential]) && ahead.peek2(Token![type]) + || ahead.peek(Token![struct]) + || ahead.peek(Token![enum]) + || ahead.peek(Token![union]) && ahead.peek2(Ident) + || ahead.peek(Token![auto]) && ahead.peek2(Token![trait]) + || ahead.peek(Token![trait]) + || ahead.peek(Token![default]) + && (ahead.peek2(Token![unsafe]) || ahead.peek2(Token![impl])) + || ahead.peek(Token![impl]) + || ahead.peek(Token![macro]) + { + input.parse().map(Stmt::Item) + } else { + stmt_expr(input, allow_nosemi) + } + } + + #[cfg(feature = "full")] + fn stmt_mac(input: ParseStream) -> Result<Stmt> { + let attrs = input.call(Attribute::parse_outer)?; + let path = input.call(Path::parse_mod_style)?; + let bang_token: Token![!] = input.parse()?; + let ident: Option<Ident> = input.parse()?; + let (delimiter, tts) = mac::parse_delimiter(input)?; + let semi_token: Option<Token![;]> = input.parse()?; + + Ok(Stmt::Item(Item::Macro(ItemMacro { + attrs: attrs, + ident: ident, + mac: Macro { + path: path, + bang_token: bang_token, + delimiter: delimiter, + tts: tts, + }, + semi_token: semi_token, + }))) + } + + #[cfg(feature = "full")] + fn stmt_local(input: ParseStream) -> Result<Local> { + Ok(Local { + attrs: input.call(Attribute::parse_outer)?, + let_token: input.parse()?, + pats: { + let mut pats = Punctuated::new(); + let value: Pat = input.parse()?; + pats.push_value(value); + while input.peek(Token![|]) && !input.peek(Token![||]) && !input.peek(Token![|=]) { + let punct = input.parse()?; + pats.push_punct(punct); + let value: Pat = input.parse()?; + pats.push_value(value); + } + pats + }, + ty: { + if input.peek(Token![:]) { + let colon_token: Token![:] = input.parse()?; + let ty: Type = input.parse()?; + Some((colon_token, Box::new(ty))) + } else { + None + } + }, + init: { + if input.peek(Token![=]) { + let eq_token: Token![=] = input.parse()?; + let init: Expr = input.parse()?; + Some((eq_token, Box::new(init))) + } else { + None + } + }, + semi_token: input.parse()?, + }) + } + + #[cfg(feature = "full")] + fn stmt_expr(input: ParseStream, allow_nosemi: bool) -> Result<Stmt> { + let mut attrs = input.call(Attribute::parse_outer)?; + let mut e = expr_early(input)?; + + attrs.extend(e.replace_attrs(Vec::new())); + e.replace_attrs(attrs); + + if input.peek(Token![;]) { + return Ok(Stmt::Semi(e, input.parse()?)); + } + + if allow_nosemi || !requires_terminator(&e) { + Ok(Stmt::Expr(e)) + } else { + Err(input.error("expected semicolon")) + } + } + + #[cfg(feature = "full")] + impl Parse for Pat { + fn parse(input: ParseStream) -> Result<Self> { + let lookahead = input.lookahead1(); + if lookahead.peek(Token![_]) { + input.call(pat_wild).map(Pat::Wild) + } else if lookahead.peek(Token![box]) { + input.call(pat_box).map(Pat::Box) + } else if lookahead.peek(Token![-]) || lookahead.peek(Lit) { + pat_lit_or_range(input) + } else if input.peek(Ident) + && ({ + input.peek2(Token![::]) + || input.peek2(Token![!]) + || input.peek2(token::Brace) + || input.peek2(token::Paren) + || input.peek2(Token![..]) + && !{ + let ahead = input.fork(); + ahead.parse::<Ident>()?; + ahead.parse::<RangeLimits>()?; + ahead.is_empty() || ahead.peek(Token![,]) + } + }) + || input.peek(Token![self]) && input.peek2(Token![::]) + || input.peek(Token![::]) + || input.peek(Token![<]) + || input.peek(Token![Self]) + || input.peek(Token![super]) + || input.peek(Token![extern]) + || input.peek(Token![crate]) + { + pat_path_or_macro_or_struct_or_range(input) + } else if input.peek(Token![ref]) + || input.peek(Token![mut]) + || input.peek(Token![self]) + || input.peek(Ident) + { + input.call(pat_ident).map(Pat::Ident) + } else if lookahead.peek(token::Paren) { + input.call(pat_tuple).map(Pat::Tuple) + } else if lookahead.peek(Token![&]) { + input.call(pat_ref).map(Pat::Ref) + } else if lookahead.peek(token::Bracket) { + input.call(pat_slice).map(Pat::Slice) + } else { + Err(lookahead.error()) + } + } + } + + #[cfg(feature = "full")] + fn pat_path_or_macro_or_struct_or_range(input: ParseStream) -> Result<Pat> { + let (qself, path) = path::parsing::qpath(input, true)?; + + if input.peek(Token![..]) { + return pat_range(input, qself, path).map(Pat::Range); + } + + if qself.is_some() { + return Ok(Pat::Path(PatPath { + qself: qself, + path: path, + })); + } + + if input.peek(Token![!]) && !input.peek(Token![!=]) { + let mut contains_arguments = false; + for segment in &path.segments { + match segment.arguments { + PathArguments::None => {} + PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => { + contains_arguments = true; + } + } + } + + if !contains_arguments { + let bang_token: Token![!] = input.parse()?; + let (delimiter, tts) = mac::parse_delimiter(input)?; + return Ok(Pat::Macro(PatMacro { + mac: Macro { + path: path, + bang_token: bang_token, + delimiter: delimiter, + tts: tts, + }, + })); + } + } + + if input.peek(token::Brace) { + pat_struct(input, path).map(Pat::Struct) + } else if input.peek(token::Paren) { + pat_tuple_struct(input, path).map(Pat::TupleStruct) + } else if input.peek(Token![..]) { + pat_range(input, qself, path).map(Pat::Range) + } else { + Ok(Pat::Path(PatPath { + qself: qself, + path: path, + })) + } + } + + #[cfg(feature = "full")] + fn pat_wild(input: ParseStream) -> Result<PatWild> { + Ok(PatWild { + underscore_token: input.parse()?, + }) + } + + #[cfg(feature = "full")] + fn pat_box(input: ParseStream) -> Result<PatBox> { + Ok(PatBox { + box_token: input.parse()?, + pat: input.parse()?, + }) + } + + #[cfg(feature = "full")] + fn pat_ident(input: ParseStream) -> Result<PatIdent> { + Ok(PatIdent { + by_ref: input.parse()?, + mutability: input.parse()?, + ident: input.call(Ident::parse_any)?, + subpat: { + if input.peek(Token![@]) { + let at_token: Token![@] = input.parse()?; + let subpat: Pat = input.parse()?; + Some((at_token, Box::new(subpat))) + } else { + None + } + }, + }) + } + + #[cfg(feature = "full")] + fn pat_tuple_struct(input: ParseStream, path: Path) -> Result<PatTupleStruct> { + Ok(PatTupleStruct { + path: path, + pat: input.call(pat_tuple)?, + }) + } + + #[cfg(feature = "full")] + fn pat_struct(input: ParseStream, path: Path) -> Result<PatStruct> { + let content; + let brace_token = braced!(content in input); + + let mut fields = Punctuated::new(); + while !content.is_empty() && !content.peek(Token![..]) { + let value = content.call(field_pat)?; + fields.push_value(value); + if !content.peek(Token![,]) { + break; + } + let punct: Token![,] = content.parse()?; + fields.push_punct(punct); + } + + let dot2_token = if fields.empty_or_trailing() && content.peek(Token![..]) { + Some(content.parse()?) + } else { + None + }; + + Ok(PatStruct { + path: path, + brace_token: brace_token, + fields: fields, + dot2_token: dot2_token, + }) + } + + #[cfg(feature = "full")] + fn field_pat(input: ParseStream) -> Result<FieldPat> { + let boxed: Option<Token![box]> = input.parse()?; + let by_ref: Option<Token![ref]> = input.parse()?; + let mutability: Option<Token![mut]> = input.parse()?; + let member: Member = input.parse()?; + + if boxed.is_none() && by_ref.is_none() && mutability.is_none() && input.peek(Token![:]) + || member.is_unnamed() + { + return Ok(FieldPat { + attrs: Vec::new(), + member: member, + colon_token: input.parse()?, + pat: input.parse()?, + }); + } + + let ident = match member { + Member::Named(ident) => ident, + Member::Unnamed(_) => unreachable!(), + }; + + let mut pat = Pat::Ident(PatIdent { + by_ref: by_ref, + mutability: mutability, + ident: ident.clone(), + subpat: None, + }); + + if let Some(boxed) = boxed { + pat = Pat::Box(PatBox { + pat: Box::new(pat), + box_token: boxed, + }); + } + + Ok(FieldPat { + member: Member::Named(ident), + pat: Box::new(pat), + attrs: Vec::new(), + colon_token: None, + }) + } + + impl Parse for Member { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Ident) { + input.parse().map(Member::Named) + } else if input.peek(LitInt) { + input.parse().map(Member::Unnamed) + } else { + Err(input.error("expected identifier or integer")) + } + } + } + + #[cfg(feature = "full")] + impl Parse for Arm { + fn parse(input: ParseStream) -> Result<Arm> { + let requires_comma; + Ok(Arm { + attrs: input.call(Attribute::parse_outer)?, + leading_vert: input.parse()?, + pats: { + let mut pats = Punctuated::new(); + let value: Pat = input.parse()?; + pats.push_value(value); + loop { + if !input.peek(Token![|]) { + break; + } + let punct = input.parse()?; + pats.push_punct(punct); + let value: Pat = input.parse()?; + pats.push_value(value); + } + pats + }, + guard: { + if input.peek(Token![if]) { + let if_token: Token![if] = input.parse()?; + let guard: Expr = input.parse()?; + Some((if_token, Box::new(guard))) + } else { + None + } + }, + fat_arrow_token: input.parse()?, + body: { + let body = input.call(expr_early)?; + requires_comma = requires_terminator(&body); + Box::new(body) + }, + comma: { + if requires_comma && !input.is_empty() { + Some(input.parse()?) + } else { + input.parse()? + } + }, + }) + } + } + + impl Parse for Index { + fn parse(input: ParseStream) -> Result<Self> { + let lit: LitInt = input.parse()?; + if let IntSuffix::None = lit.suffix() { + Ok(Index { + index: lit.value() as u32, + span: lit.span(), + }) + } else { + Err(Error::new(lit.span(), "expected unsuffixed integer")) + } + } + } + + #[cfg(feature = "full")] + fn pat_range(input: ParseStream, qself: Option<QSelf>, path: Path) -> Result<PatRange> { + Ok(PatRange { + lo: Box::new(Expr::Path(ExprPath { + attrs: Vec::new(), + qself: qself, + path: path, + })), + limits: input.parse()?, + hi: input.call(pat_lit_expr)?, + }) + } + + #[cfg(feature = "full")] + fn pat_tuple(input: ParseStream) -> Result<PatTuple> { + let content; + let paren_token = parenthesized!(content in input); + + let mut front = Punctuated::new(); + let mut dot2_token = None::<Token![..]>; + let mut comma_token = None::<Token![,]>; + loop { + if content.is_empty() { + break; + } + if content.peek(Token![..]) { + dot2_token = Some(content.parse()?); + comma_token = content.parse()?; + break; + } + let value: Pat = content.parse()?; + front.push_value(value); + if content.is_empty() { + break; + } + let punct = content.parse()?; + front.push_punct(punct); + } + + let mut back = Punctuated::new(); + while !content.is_empty() { + let value: Pat = content.parse()?; + back.push_value(value); + if content.is_empty() { + break; + } + let punct = content.parse()?; + back.push_punct(punct); + } + + Ok(PatTuple { + paren_token: paren_token, + front: front, + dot2_token: dot2_token, + comma_token: comma_token, + back: back, + }) + } + + #[cfg(feature = "full")] + fn pat_ref(input: ParseStream) -> Result<PatRef> { + Ok(PatRef { + and_token: input.parse()?, + mutability: input.parse()?, + pat: input.parse()?, + }) + } + + #[cfg(feature = "full")] + fn pat_lit_or_range(input: ParseStream) -> Result<Pat> { + let lo = input.call(pat_lit_expr)?; + if input.peek(Token![..]) { + Ok(Pat::Range(PatRange { + lo: lo, + limits: input.parse()?, + hi: input.call(pat_lit_expr)?, + })) + } else { + Ok(Pat::Lit(PatLit { expr: lo })) + } + } + + #[cfg(feature = "full")] + fn pat_lit_expr(input: ParseStream) -> Result<Box<Expr>> { + let neg: Option<Token![-]> = input.parse()?; + + let lookahead = input.lookahead1(); + let expr = if lookahead.peek(Lit) { + Expr::Lit(input.parse()?) + } else if lookahead.peek(Ident) + || lookahead.peek(Token![::]) + || lookahead.peek(Token![<]) + || lookahead.peek(Token![self]) + || lookahead.peek(Token![Self]) + || lookahead.peek(Token![super]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![crate]) + { + Expr::Path(input.parse()?) + } else { + return Err(lookahead.error()); + }; + + Ok(Box::new(if let Some(neg) = neg { + Expr::Unary(ExprUnary { + attrs: Vec::new(), + op: UnOp::Neg(neg), + expr: Box::new(expr), + }) + } else { + expr + })) + } + + #[cfg(feature = "full")] + fn pat_slice(input: ParseStream) -> Result<PatSlice> { + let content; + let bracket_token = bracketed!(content in input); + + let mut front = Punctuated::new(); + let mut middle = None; + loop { + if content.is_empty() || content.peek(Token![..]) { + break; + } + let value: Pat = content.parse()?; + if content.peek(Token![..]) { + middle = Some(Box::new(value)); + break; + } + front.push_value(value); + if content.is_empty() { + break; + } + let punct = content.parse()?; + front.push_punct(punct); + } + + let dot2_token: Option<Token![..]> = content.parse()?; + let mut comma_token = None::<Token![,]>; + let mut back = Punctuated::new(); + if dot2_token.is_some() { + comma_token = content.parse()?; + if comma_token.is_some() { + loop { + if content.is_empty() { + break; + } + let value: Pat = content.parse()?; + back.push_value(value); + if content.is_empty() { + break; + } + let punct = content.parse()?; + back.push_punct(punct); + } + } + } + + Ok(PatSlice { + bracket_token: bracket_token, + front: front, + middle: middle, + dot2_token: dot2_token, + comma_token: comma_token, + back: back, + }) + } + + #[cfg(feature = "full")] + impl Member { + fn is_named(&self) -> bool { + match *self { + Member::Named(_) => true, + Member::Unnamed(_) => false, + } + } + + fn is_unnamed(&self) -> bool { + match *self { + Member::Named(_) => false, + Member::Unnamed(_) => true, + } + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + + use proc_macro2::{Literal, TokenStream}; + use quote::{ToTokens, TokenStreamExt}; + + #[cfg(feature = "full")] + use attr::FilterAttrs; + #[cfg(feature = "full")] + use print::TokensOrDefault; + + // If the given expression is a bare `ExprStruct`, wraps it in parenthesis + // before appending it to `TokenStream`. + #[cfg(feature = "full")] + fn wrap_bare_struct(tokens: &mut TokenStream, e: &Expr) { + if let Expr::Struct(_) = *e { + token::Paren::default().surround(tokens, |tokens| { + e.to_tokens(tokens); + }); + } else { + e.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + fn outer_attrs_to_tokens(attrs: &[Attribute], tokens: &mut TokenStream) { + tokens.append_all(attrs.outer()); + } + + #[cfg(feature = "full")] + fn inner_attrs_to_tokens(attrs: &[Attribute], tokens: &mut TokenStream) { + tokens.append_all(attrs.inner()); + } + + #[cfg(not(feature = "full"))] + fn outer_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {} + + #[cfg(not(feature = "full"))] + fn inner_attrs_to_tokens(_attrs: &[Attribute], _tokens: &mut TokenStream) {} + + #[cfg(feature = "full")] + impl ToTokens for ExprBox { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.box_token.to_tokens(tokens); + self.expr.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprInPlace { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.place.to_tokens(tokens); + self.arrow_token.to_tokens(tokens); + self.value.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprArray { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.bracket_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + self.elems.to_tokens(tokens); + }) + } + } + + impl ToTokens for ExprCall { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.func.to_tokens(tokens); + self.paren_token.surround(tokens, |tokens| { + self.args.to_tokens(tokens); + }) + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprMethodCall { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.receiver.to_tokens(tokens); + self.dot_token.to_tokens(tokens); + self.method.to_tokens(tokens); + self.turbofish.to_tokens(tokens); + self.paren_token.surround(tokens, |tokens| { + self.args.to_tokens(tokens); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for MethodTurbofish { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.colon2_token.to_tokens(tokens); + self.lt_token.to_tokens(tokens); + self.args.to_tokens(tokens); + self.gt_token.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for GenericMethodArgument { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + GenericMethodArgument::Type(ref t) => t.to_tokens(tokens), + GenericMethodArgument::Const(ref c) => c.to_tokens(tokens), + } + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprTuple { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.paren_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + self.elems.to_tokens(tokens); + // If we only have one argument, we need a trailing comma to + // distinguish ExprTuple from ExprParen. + if self.elems.len() == 1 && !self.elems.trailing_punct() { + <Token![,]>::default().to_tokens(tokens); + } + }) + } + } + + impl ToTokens for ExprBinary { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.left.to_tokens(tokens); + self.op.to_tokens(tokens); + self.right.to_tokens(tokens); + } + } + + impl ToTokens for ExprUnary { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.op.to_tokens(tokens); + self.expr.to_tokens(tokens); + } + } + + impl ToTokens for ExprLit { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.lit.to_tokens(tokens); + } + } + + impl ToTokens for ExprCast { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.expr.to_tokens(tokens); + self.as_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprType { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.expr.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + fn maybe_wrap_else(tokens: &mut TokenStream, else_: &Option<(Token![else], Box<Expr>)>) { + if let Some((ref else_token, ref else_)) = *else_ { + else_token.to_tokens(tokens); + + // If we are not one of the valid expressions to exist in an else + // clause, wrap ourselves in a block. + match **else_ { + Expr::If(_) | Expr::Block(_) => { + else_.to_tokens(tokens); + } + _ => { + token::Brace::default().surround(tokens, |tokens| { + else_.to_tokens(tokens); + }); + } + } + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprLet { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.let_token.to_tokens(tokens); + self.pats.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + wrap_bare_struct(tokens, &self.expr); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprIf { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.if_token.to_tokens(tokens); + wrap_bare_struct(tokens, &self.cond); + self.then_branch.to_tokens(tokens); + maybe_wrap_else(tokens, &self.else_branch); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprWhile { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.label.to_tokens(tokens); + self.while_token.to_tokens(tokens); + wrap_bare_struct(tokens, &self.cond); + self.body.brace_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + tokens.append_all(&self.body.stmts); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprForLoop { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.label.to_tokens(tokens); + self.for_token.to_tokens(tokens); + self.pat.to_tokens(tokens); + self.in_token.to_tokens(tokens); + wrap_bare_struct(tokens, &self.expr); + self.body.brace_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + tokens.append_all(&self.body.stmts); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprLoop { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.label.to_tokens(tokens); + self.loop_token.to_tokens(tokens); + self.body.brace_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + tokens.append_all(&self.body.stmts); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprMatch { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.match_token.to_tokens(tokens); + wrap_bare_struct(tokens, &self.expr); + self.brace_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + for (i, arm) in self.arms.iter().enumerate() { + arm.to_tokens(tokens); + // Ensure that we have a comma after a non-block arm, except + // for the last one. + let is_last = i == self.arms.len() - 1; + if !is_last && requires_terminator(&arm.body) && arm.comma.is_none() { + <Token![,]>::default().to_tokens(tokens); + } + } + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprAsync { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.async_token.to_tokens(tokens); + self.capture.to_tokens(tokens); + self.block.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprTryBlock { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.try_token.to_tokens(tokens); + self.block.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprYield { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.yield_token.to_tokens(tokens); + self.expr.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprClosure { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.asyncness.to_tokens(tokens); + self.movability.to_tokens(tokens); + self.capture.to_tokens(tokens); + self.or1_token.to_tokens(tokens); + for input in self.inputs.pairs() { + match **input.value() { + FnArg::Captured(ArgCaptured { + ref pat, + ty: Type::Infer(_), + .. + }) => { + pat.to_tokens(tokens); + } + _ => input.value().to_tokens(tokens), + } + input.punct().to_tokens(tokens); + } + self.or2_token.to_tokens(tokens); + self.output.to_tokens(tokens); + self.body.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprUnsafe { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.unsafe_token.to_tokens(tokens); + self.block.brace_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + tokens.append_all(&self.block.stmts); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprBlock { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.label.to_tokens(tokens); + self.block.brace_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + tokens.append_all(&self.block.stmts); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprAssign { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.left.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.right.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprAssignOp { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.left.to_tokens(tokens); + self.op.to_tokens(tokens); + self.right.to_tokens(tokens); + } + } + + impl ToTokens for ExprField { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.base.to_tokens(tokens); + self.dot_token.to_tokens(tokens); + self.member.to_tokens(tokens); + } + } + + impl ToTokens for Member { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + Member::Named(ref ident) => ident.to_tokens(tokens), + Member::Unnamed(ref index) => index.to_tokens(tokens), + } + } + } + + impl ToTokens for Index { + fn to_tokens(&self, tokens: &mut TokenStream) { + let mut lit = Literal::i64_unsuffixed(i64::from(self.index)); + lit.set_span(self.span); + tokens.append(lit); + } + } + + impl ToTokens for ExprIndex { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.expr.to_tokens(tokens); + self.bracket_token.surround(tokens, |tokens| { + self.index.to_tokens(tokens); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprRange { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.from.to_tokens(tokens); + match self.limits { + RangeLimits::HalfOpen(ref t) => t.to_tokens(tokens), + RangeLimits::Closed(ref t) => t.to_tokens(tokens), + } + self.to.to_tokens(tokens); + } + } + + impl ToTokens for ExprPath { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + private::print_path(tokens, &self.qself, &self.path); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprReference { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.and_token.to_tokens(tokens); + self.mutability.to_tokens(tokens); + self.expr.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprBreak { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.break_token.to_tokens(tokens); + self.label.to_tokens(tokens); + self.expr.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprContinue { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.continue_token.to_tokens(tokens); + self.label.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprReturn { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.return_token.to_tokens(tokens); + self.expr.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprMacro { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.mac.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprStruct { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.path.to_tokens(tokens); + self.brace_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + self.fields.to_tokens(tokens); + if self.rest.is_some() { + TokensOrDefault(&self.dot2_token).to_tokens(tokens); + self.rest.to_tokens(tokens); + } + }) + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprRepeat { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.bracket_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + self.expr.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + self.len.to_tokens(tokens); + }) + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprGroup { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.group_token.surround(tokens, |tokens| { + self.expr.to_tokens(tokens); + }); + } + } + + impl ToTokens for ExprParen { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.paren_token.surround(tokens, |tokens| { + inner_attrs_to_tokens(&self.attrs, tokens); + self.expr.to_tokens(tokens); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for ExprTry { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.expr.to_tokens(tokens); + self.question_token.to_tokens(tokens); + } + } + + impl ToTokens for ExprVerbatim { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.tts.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for Label { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.name.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for FieldValue { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.member.to_tokens(tokens); + if let Some(ref colon_token) = self.colon_token { + colon_token.to_tokens(tokens); + self.expr.to_tokens(tokens); + } + } + } + + #[cfg(feature = "full")] + impl ToTokens for Arm { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(&self.attrs); + self.leading_vert.to_tokens(tokens); + self.pats.to_tokens(tokens); + if let Some((ref if_token, ref guard)) = self.guard { + if_token.to_tokens(tokens); + guard.to_tokens(tokens); + } + self.fat_arrow_token.to_tokens(tokens); + self.body.to_tokens(tokens); + self.comma.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatWild { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.underscore_token.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatIdent { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.by_ref.to_tokens(tokens); + self.mutability.to_tokens(tokens); + self.ident.to_tokens(tokens); + if let Some((ref at_token, ref subpat)) = self.subpat { + at_token.to_tokens(tokens); + subpat.to_tokens(tokens); + } + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatStruct { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.path.to_tokens(tokens); + self.brace_token.surround(tokens, |tokens| { + self.fields.to_tokens(tokens); + // NOTE: We need a comma before the dot2 token if it is present. + if !self.fields.empty_or_trailing() && self.dot2_token.is_some() { + <Token![,]>::default().to_tokens(tokens); + } + self.dot2_token.to_tokens(tokens); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatTupleStruct { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.path.to_tokens(tokens); + self.pat.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatPath { + fn to_tokens(&self, tokens: &mut TokenStream) { + private::print_path(tokens, &self.qself, &self.path); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatTuple { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.paren_token.surround(tokens, |tokens| { + self.front.to_tokens(tokens); + if let Some(ref dot2_token) = self.dot2_token { + if !self.front.empty_or_trailing() { + // Ensure there is a comma before the .. token. + <Token![,]>::default().to_tokens(tokens); + } + dot2_token.to_tokens(tokens); + self.comma_token.to_tokens(tokens); + if self.comma_token.is_none() && !self.back.is_empty() { + // Ensure there is a comma after the .. token. + <Token![,]>::default().to_tokens(tokens); + } + } + self.back.to_tokens(tokens); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatBox { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.box_token.to_tokens(tokens); + self.pat.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatRef { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.and_token.to_tokens(tokens); + self.mutability.to_tokens(tokens); + self.pat.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatLit { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.expr.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatRange { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.lo.to_tokens(tokens); + match self.limits { + RangeLimits::HalfOpen(ref t) => t.to_tokens(tokens), + RangeLimits::Closed(ref t) => t.to_tokens(tokens), + } + self.hi.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatSlice { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.bracket_token.surround(tokens, |tokens| { + self.front.to_tokens(tokens); + + // If we need a comma before the middle or standalone .. token, + // then make sure it's present. + if !self.front.empty_or_trailing() + && (self.middle.is_some() || self.dot2_token.is_some()) + { + <Token![,]>::default().to_tokens(tokens); + } + + // If we have an identifier, we always need a .. token. + if self.middle.is_some() { + self.middle.to_tokens(tokens); + TokensOrDefault(&self.dot2_token).to_tokens(tokens); + } else if self.dot2_token.is_some() { + self.dot2_token.to_tokens(tokens); + } + + // Make sure we have a comma before the back half. + if !self.back.is_empty() { + TokensOrDefault(&self.comma_token).to_tokens(tokens); + self.back.to_tokens(tokens); + } else { + self.comma_token.to_tokens(tokens); + } + }) + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatMacro { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.mac.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for PatVerbatim { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.tts.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for FieldPat { + fn to_tokens(&self, tokens: &mut TokenStream) { + if let Some(ref colon_token) = self.colon_token { + self.member.to_tokens(tokens); + colon_token.to_tokens(tokens); + } + self.pat.to_tokens(tokens); + } + } + + #[cfg(feature = "full")] + impl ToTokens for Block { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.brace_token.surround(tokens, |tokens| { + tokens.append_all(&self.stmts); + }); + } + } + + #[cfg(feature = "full")] + impl ToTokens for Stmt { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + Stmt::Local(ref local) => local.to_tokens(tokens), + Stmt::Item(ref item) => item.to_tokens(tokens), + Stmt::Expr(ref expr) => expr.to_tokens(tokens), + Stmt::Semi(ref expr, ref semi) => { + expr.to_tokens(tokens); + semi.to_tokens(tokens); + } + } + } + } + + #[cfg(feature = "full")] + impl ToTokens for Local { + fn to_tokens(&self, tokens: &mut TokenStream) { + outer_attrs_to_tokens(&self.attrs, tokens); + self.let_token.to_tokens(tokens); + self.pats.to_tokens(tokens); + if let Some((ref colon_token, ref ty)) = self.ty { + colon_token.to_tokens(tokens); + ty.to_tokens(tokens); + } + if let Some((ref eq_token, ref init)) = self.init { + eq_token.to_tokens(tokens); + init.to_tokens(tokens); + } + self.semi_token.to_tokens(tokens); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/ext.rs b/rust/vendor/syn-0.15.44/src/ext.rs new file mode 100644 index 0000000..17721d5 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/ext.rs @@ -0,0 +1,145 @@ +//! Extension traits to provide parsing methods on foreign types. +//! +//! *This module is available if Syn is built with the `"parsing"` feature.* + +use proc_macro2::Ident; + +use parse::{ParseStream, Result}; + +#[cfg(syn_can_use_associated_constants)] +use buffer::Cursor; +#[cfg(syn_can_use_associated_constants)] +use parse::Peek; +#[cfg(syn_can_use_associated_constants)] +use sealed::lookahead; +#[cfg(syn_can_use_associated_constants)] +use token::CustomToken; + +/// Additional methods for `Ident` not provided by proc-macro2 or libproc_macro. +/// +/// This trait is sealed and cannot be implemented for types outside of Syn. It +/// is implemented only for `proc_macro2::Ident`. +/// +/// *This trait is available if Syn is built with the `"parsing"` feature.* +pub trait IdentExt: Sized + private::Sealed { + /// Parses any identifier including keywords. + /// + /// This is useful when parsing macro input which allows Rust keywords as + /// identifiers. + /// + /// # Example + /// + /// ```edition2018 + /// use syn::{Error, Ident, Result, Token}; + /// use syn::ext::IdentExt; + /// use syn::parse::ParseStream; + /// + /// mod kw { + /// syn::custom_keyword!(name); + /// } + /// + /// // Parses input that looks like `name = NAME` where `NAME` can be + /// // any identifier. + /// // + /// // Examples: + /// // + /// // name = anything + /// // name = impl + /// fn parse_dsl(input: ParseStream) -> Result<Ident> { + /// input.parse::<kw::name>()?; + /// input.parse::<Token![=]>()?; + /// let name = input.call(Ident::parse_any)?; + /// Ok(name) + /// } + /// ``` + fn parse_any(input: ParseStream) -> Result<Self>; + + /// Peeks any identifier including keywords. Usage: + /// `input.peek(Ident::peek_any)` + /// + /// This is different from `input.peek(Ident)` which only returns true in + /// the case of an ident which is not a Rust keyword. + #[cfg(syn_can_use_associated_constants)] + #[allow(non_upper_case_globals)] + const peek_any: private::PeekFn = private::PeekFn; + + /// Strips the raw marker `r#`, if any, from the beginning of an ident. + /// + /// - unraw(`x`) = `x` + /// - unraw(`move`) = `move` + /// - unraw(`r#move`) = `move` + /// + /// # Example + /// + /// In the case of interop with other languages like Python that have a + /// different set of keywords than Rust, we might come across macro input + /// that involves raw identifiers to refer to ordinary variables in the + /// other language with a name that happens to be a Rust keyword. + /// + /// The function below appends an identifier from the caller's input onto a + /// fixed prefix. Without using `unraw()`, this would tend to produce + /// invalid identifiers like `__pyo3_get_r#move`. + /// + /// ```edition2018 + /// use proc_macro2::Span; + /// use syn::Ident; + /// use syn::ext::IdentExt; + /// + /// fn ident_for_getter(variable: &Ident) -> Ident { + /// let getter = format!("__pyo3_get_{}", variable.unraw()); + /// Ident::new(&getter, Span::call_site()) + /// } + /// ``` + fn unraw(&self) -> Ident; +} + +impl IdentExt for Ident { + fn parse_any(input: ParseStream) -> Result<Self> { + input.step(|cursor| match cursor.ident() { + Some((ident, rest)) => Ok((ident, rest)), + None => Err(cursor.error("expected ident")), + }) + } + + fn unraw(&self) -> Ident { + let string = self.to_string(); + if string.starts_with("r#") { + Ident::new(&string[2..], self.span()) + } else { + self.clone() + } + } +} + +#[cfg(syn_can_use_associated_constants)] +impl Peek for private::PeekFn { + type Token = private::IdentAny; +} + +#[cfg(syn_can_use_associated_constants)] +impl CustomToken for private::IdentAny { + fn peek(cursor: Cursor) -> bool { + cursor.ident().is_some() + } + + fn display() -> &'static str { + "identifier" + } +} + +#[cfg(syn_can_use_associated_constants)] +impl lookahead::Sealed for private::PeekFn {} + +mod private { + use proc_macro2::Ident; + + pub trait Sealed {} + + impl Sealed for Ident {} + + #[cfg(syn_can_use_associated_constants)] + #[derive(Copy, Clone)] + pub struct PeekFn; + #[cfg(syn_can_use_associated_constants)] + pub struct IdentAny; +} diff --git a/rust/vendor/syn-0.15.44/src/file.rs b/rust/vendor/syn-0.15.44/src/file.rs new file mode 100644 index 0000000..30defe7 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/file.rs @@ -0,0 +1,113 @@ +use super::*; + +ast_struct! { + /// A complete file of Rust source code. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + /// + /// # Example + /// + /// Parse a Rust source file into a `syn::File` and print out a debug + /// representation of the syntax tree. + /// + /// ```edition2018 + /// use std::env; + /// use std::fs::File; + /// use std::io::Read; + /// use std::process; + /// + /// fn main() { + /// # } + /// # + /// # fn fake_main() { + /// let mut args = env::args(); + /// let _ = args.next(); // executable name + /// + /// let filename = match (args.next(), args.next()) { + /// (Some(filename), None) => filename, + /// _ => { + /// eprintln!("Usage: dump-syntax path/to/filename.rs"); + /// process::exit(1); + /// } + /// }; + /// + /// let mut file = File::open(&filename).expect("Unable to open file"); + /// + /// let mut src = String::new(); + /// file.read_to_string(&mut src).expect("Unable to read file"); + /// + /// let syntax = syn::parse_file(&src).expect("Unable to parse file"); + /// println!("{:#?}", syntax); + /// } + /// ``` + /// + /// Running with its own source code as input, this program prints output + /// that begins with: + /// + /// ```text + /// File { + /// shebang: None, + /// attrs: [], + /// items: [ + /// ExternCrate( + /// ItemExternCrate { + /// attrs: [], + /// vis: Inherited, + /// extern_token: Extern, + /// crate_token: Crate, + /// ident: Ident { + /// term: Term( + /// "syn" + /// ), + /// span: Span + /// }, + /// rename: None, + /// semi_token: Semi + /// } + /// ), + /// ... + /// ``` + pub struct File { + pub shebang: Option<String>, + pub attrs: Vec<Attribute>, + pub items: Vec<Item>, + } +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use parse::{Parse, ParseStream, Result}; + + impl Parse for File { + fn parse(input: ParseStream) -> Result<Self> { + Ok(File { + shebang: None, + attrs: input.call(Attribute::parse_inner)?, + items: { + let mut items = Vec::new(); + while !input.is_empty() { + items.push(input.parse()?); + } + items + }, + }) + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + use attr::FilterAttrs; + use proc_macro2::TokenStream; + use quote::{ToTokens, TokenStreamExt}; + + impl ToTokens for File { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.inner()); + tokens.append_all(&self.items); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/gen/fold.rs b/rust/vendor/syn-0.15.44/src/gen/fold.rs new file mode 100644 index 0000000..9d9fc25 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/gen/fold.rs @@ -0,0 +1,2958 @@ +// This file is @generated by syn-internal-codegen. +// It is not intended for manual editing. + +#![allow(unreachable_code)] +#[cfg(any(feature = "full", feature = "derive"))] +use gen::helper::fold::*; +use proc_macro2::Span; +#[cfg(any(feature = "full", feature = "derive"))] +use token::{Brace, Bracket, Group, Paren}; +use *; +#[cfg(feature = "full")] +macro_rules! full { + ($e:expr) => { + $e + }; +} +#[cfg(all(feature = "derive", not(feature = "full")))] +macro_rules! full { + ($e:expr) => { + unreachable!() + }; +} +/// Syntax tree traversal to transform the nodes of an owned syntax tree. +/// +/// See the [module documentation] for details. +/// +/// [module documentation]: self +/// +/// *This trait is available if Syn is built with the `"fold"` feature.* +pub trait Fold { + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_abi(&mut self, i: Abi) -> Abi { + fold_abi(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_angle_bracketed_generic_arguments( + &mut self, + i: AngleBracketedGenericArguments, + ) -> AngleBracketedGenericArguments { + fold_angle_bracketed_generic_arguments(self, i) + } + #[cfg(feature = "full")] + fn fold_arg_captured(&mut self, i: ArgCaptured) -> ArgCaptured { + fold_arg_captured(self, i) + } + #[cfg(feature = "full")] + fn fold_arg_self(&mut self, i: ArgSelf) -> ArgSelf { + fold_arg_self(self, i) + } + #[cfg(feature = "full")] + fn fold_arg_self_ref(&mut self, i: ArgSelfRef) -> ArgSelfRef { + fold_arg_self_ref(self, i) + } + #[cfg(feature = "full")] + fn fold_arm(&mut self, i: Arm) -> Arm { + fold_arm(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_attr_style(&mut self, i: AttrStyle) -> AttrStyle { + fold_attr_style(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_attribute(&mut self, i: Attribute) -> Attribute { + fold_attribute(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_bare_fn_arg(&mut self, i: BareFnArg) -> BareFnArg { + fold_bare_fn_arg(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_bare_fn_arg_name(&mut self, i: BareFnArgName) -> BareFnArgName { + fold_bare_fn_arg_name(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_bin_op(&mut self, i: BinOp) -> BinOp { + fold_bin_op(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_binding(&mut self, i: Binding) -> Binding { + fold_binding(self, i) + } + #[cfg(feature = "full")] + fn fold_block(&mut self, i: Block) -> Block { + fold_block(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_bound_lifetimes(&mut self, i: BoundLifetimes) -> BoundLifetimes { + fold_bound_lifetimes(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_const_param(&mut self, i: ConstParam) -> ConstParam { + fold_const_param(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_constraint(&mut self, i: Constraint) -> Constraint { + fold_constraint(self, i) + } + #[cfg(feature = "derive")] + fn fold_data(&mut self, i: Data) -> Data { + fold_data(self, i) + } + #[cfg(feature = "derive")] + fn fold_data_enum(&mut self, i: DataEnum) -> DataEnum { + fold_data_enum(self, i) + } + #[cfg(feature = "derive")] + fn fold_data_struct(&mut self, i: DataStruct) -> DataStruct { + fold_data_struct(self, i) + } + #[cfg(feature = "derive")] + fn fold_data_union(&mut self, i: DataUnion) -> DataUnion { + fold_data_union(self, i) + } + #[cfg(feature = "derive")] + fn fold_derive_input(&mut self, i: DeriveInput) -> DeriveInput { + fold_derive_input(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr(&mut self, i: Expr) -> Expr { + fold_expr(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_array(&mut self, i: ExprArray) -> ExprArray { + fold_expr_array(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_assign(&mut self, i: ExprAssign) -> ExprAssign { + fold_expr_assign(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_assign_op(&mut self, i: ExprAssignOp) -> ExprAssignOp { + fold_expr_assign_op(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_async(&mut self, i: ExprAsync) -> ExprAsync { + fold_expr_async(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_binary(&mut self, i: ExprBinary) -> ExprBinary { + fold_expr_binary(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_block(&mut self, i: ExprBlock) -> ExprBlock { + fold_expr_block(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_box(&mut self, i: ExprBox) -> ExprBox { + fold_expr_box(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_break(&mut self, i: ExprBreak) -> ExprBreak { + fold_expr_break(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_call(&mut self, i: ExprCall) -> ExprCall { + fold_expr_call(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_cast(&mut self, i: ExprCast) -> ExprCast { + fold_expr_cast(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_closure(&mut self, i: ExprClosure) -> ExprClosure { + fold_expr_closure(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_continue(&mut self, i: ExprContinue) -> ExprContinue { + fold_expr_continue(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_field(&mut self, i: ExprField) -> ExprField { + fold_expr_field(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_for_loop(&mut self, i: ExprForLoop) -> ExprForLoop { + fold_expr_for_loop(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_group(&mut self, i: ExprGroup) -> ExprGroup { + fold_expr_group(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_if(&mut self, i: ExprIf) -> ExprIf { + fold_expr_if(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_in_place(&mut self, i: ExprInPlace) -> ExprInPlace { + fold_expr_in_place(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_index(&mut self, i: ExprIndex) -> ExprIndex { + fold_expr_index(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_let(&mut self, i: ExprLet) -> ExprLet { + fold_expr_let(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_lit(&mut self, i: ExprLit) -> ExprLit { + fold_expr_lit(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_loop(&mut self, i: ExprLoop) -> ExprLoop { + fold_expr_loop(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_macro(&mut self, i: ExprMacro) -> ExprMacro { + fold_expr_macro(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_match(&mut self, i: ExprMatch) -> ExprMatch { + fold_expr_match(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_method_call(&mut self, i: ExprMethodCall) -> ExprMethodCall { + fold_expr_method_call(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_paren(&mut self, i: ExprParen) -> ExprParen { + fold_expr_paren(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_path(&mut self, i: ExprPath) -> ExprPath { + fold_expr_path(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_range(&mut self, i: ExprRange) -> ExprRange { + fold_expr_range(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_reference(&mut self, i: ExprReference) -> ExprReference { + fold_expr_reference(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_repeat(&mut self, i: ExprRepeat) -> ExprRepeat { + fold_expr_repeat(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_return(&mut self, i: ExprReturn) -> ExprReturn { + fold_expr_return(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_struct(&mut self, i: ExprStruct) -> ExprStruct { + fold_expr_struct(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_try(&mut self, i: ExprTry) -> ExprTry { + fold_expr_try(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_try_block(&mut self, i: ExprTryBlock) -> ExprTryBlock { + fold_expr_try_block(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_tuple(&mut self, i: ExprTuple) -> ExprTuple { + fold_expr_tuple(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_type(&mut self, i: ExprType) -> ExprType { + fold_expr_type(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_unary(&mut self, i: ExprUnary) -> ExprUnary { + fold_expr_unary(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_unsafe(&mut self, i: ExprUnsafe) -> ExprUnsafe { + fold_expr_unsafe(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_expr_verbatim(&mut self, i: ExprVerbatim) -> ExprVerbatim { + fold_expr_verbatim(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_while(&mut self, i: ExprWhile) -> ExprWhile { + fold_expr_while(self, i) + } + #[cfg(feature = "full")] + fn fold_expr_yield(&mut self, i: ExprYield) -> ExprYield { + fold_expr_yield(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_field(&mut self, i: Field) -> Field { + fold_field(self, i) + } + #[cfg(feature = "full")] + fn fold_field_pat(&mut self, i: FieldPat) -> FieldPat { + fold_field_pat(self, i) + } + #[cfg(feature = "full")] + fn fold_field_value(&mut self, i: FieldValue) -> FieldValue { + fold_field_value(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_fields(&mut self, i: Fields) -> Fields { + fold_fields(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_fields_named(&mut self, i: FieldsNamed) -> FieldsNamed { + fold_fields_named(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_fields_unnamed(&mut self, i: FieldsUnnamed) -> FieldsUnnamed { + fold_fields_unnamed(self, i) + } + #[cfg(feature = "full")] + fn fold_file(&mut self, i: File) -> File { + fold_file(self, i) + } + #[cfg(feature = "full")] + fn fold_fn_arg(&mut self, i: FnArg) -> FnArg { + fold_fn_arg(self, i) + } + #[cfg(feature = "full")] + fn fold_fn_decl(&mut self, i: FnDecl) -> FnDecl { + fold_fn_decl(self, i) + } + #[cfg(feature = "full")] + fn fold_foreign_item(&mut self, i: ForeignItem) -> ForeignItem { + fold_foreign_item(self, i) + } + #[cfg(feature = "full")] + fn fold_foreign_item_fn(&mut self, i: ForeignItemFn) -> ForeignItemFn { + fold_foreign_item_fn(self, i) + } + #[cfg(feature = "full")] + fn fold_foreign_item_macro(&mut self, i: ForeignItemMacro) -> ForeignItemMacro { + fold_foreign_item_macro(self, i) + } + #[cfg(feature = "full")] + fn fold_foreign_item_static(&mut self, i: ForeignItemStatic) -> ForeignItemStatic { + fold_foreign_item_static(self, i) + } + #[cfg(feature = "full")] + fn fold_foreign_item_type(&mut self, i: ForeignItemType) -> ForeignItemType { + fold_foreign_item_type(self, i) + } + #[cfg(feature = "full")] + fn fold_foreign_item_verbatim(&mut self, i: ForeignItemVerbatim) -> ForeignItemVerbatim { + fold_foreign_item_verbatim(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_generic_argument(&mut self, i: GenericArgument) -> GenericArgument { + fold_generic_argument(self, i) + } + #[cfg(feature = "full")] + fn fold_generic_method_argument(&mut self, i: GenericMethodArgument) -> GenericMethodArgument { + fold_generic_method_argument(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_generic_param(&mut self, i: GenericParam) -> GenericParam { + fold_generic_param(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_generics(&mut self, i: Generics) -> Generics { + fold_generics(self, i) + } + #[cfg(feature = "full")] + fn fold_impl_item(&mut self, i: ImplItem) -> ImplItem { + fold_impl_item(self, i) + } + #[cfg(feature = "full")] + fn fold_impl_item_const(&mut self, i: ImplItemConst) -> ImplItemConst { + fold_impl_item_const(self, i) + } + #[cfg(feature = "full")] + fn fold_impl_item_existential(&mut self, i: ImplItemExistential) -> ImplItemExistential { + fold_impl_item_existential(self, i) + } + #[cfg(feature = "full")] + fn fold_impl_item_macro(&mut self, i: ImplItemMacro) -> ImplItemMacro { + fold_impl_item_macro(self, i) + } + #[cfg(feature = "full")] + fn fold_impl_item_method(&mut self, i: ImplItemMethod) -> ImplItemMethod { + fold_impl_item_method(self, i) + } + #[cfg(feature = "full")] + fn fold_impl_item_type(&mut self, i: ImplItemType) -> ImplItemType { + fold_impl_item_type(self, i) + } + #[cfg(feature = "full")] + fn fold_impl_item_verbatim(&mut self, i: ImplItemVerbatim) -> ImplItemVerbatim { + fold_impl_item_verbatim(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_index(&mut self, i: Index) -> Index { + fold_index(self, i) + } + #[cfg(feature = "full")] + fn fold_item(&mut self, i: Item) -> Item { + fold_item(self, i) + } + #[cfg(feature = "full")] + fn fold_item_const(&mut self, i: ItemConst) -> ItemConst { + fold_item_const(self, i) + } + #[cfg(feature = "full")] + fn fold_item_enum(&mut self, i: ItemEnum) -> ItemEnum { + fold_item_enum(self, i) + } + #[cfg(feature = "full")] + fn fold_item_existential(&mut self, i: ItemExistential) -> ItemExistential { + fold_item_existential(self, i) + } + #[cfg(feature = "full")] + fn fold_item_extern_crate(&mut self, i: ItemExternCrate) -> ItemExternCrate { + fold_item_extern_crate(self, i) + } + #[cfg(feature = "full")] + fn fold_item_fn(&mut self, i: ItemFn) -> ItemFn { + fold_item_fn(self, i) + } + #[cfg(feature = "full")] + fn fold_item_foreign_mod(&mut self, i: ItemForeignMod) -> ItemForeignMod { + fold_item_foreign_mod(self, i) + } + #[cfg(feature = "full")] + fn fold_item_impl(&mut self, i: ItemImpl) -> ItemImpl { + fold_item_impl(self, i) + } + #[cfg(feature = "full")] + fn fold_item_macro(&mut self, i: ItemMacro) -> ItemMacro { + fold_item_macro(self, i) + } + #[cfg(feature = "full")] + fn fold_item_macro2(&mut self, i: ItemMacro2) -> ItemMacro2 { + fold_item_macro2(self, i) + } + #[cfg(feature = "full")] + fn fold_item_mod(&mut self, i: ItemMod) -> ItemMod { + fold_item_mod(self, i) + } + #[cfg(feature = "full")] + fn fold_item_static(&mut self, i: ItemStatic) -> ItemStatic { + fold_item_static(self, i) + } + #[cfg(feature = "full")] + fn fold_item_struct(&mut self, i: ItemStruct) -> ItemStruct { + fold_item_struct(self, i) + } + #[cfg(feature = "full")] + fn fold_item_trait(&mut self, i: ItemTrait) -> ItemTrait { + fold_item_trait(self, i) + } + #[cfg(feature = "full")] + fn fold_item_trait_alias(&mut self, i: ItemTraitAlias) -> ItemTraitAlias { + fold_item_trait_alias(self, i) + } + #[cfg(feature = "full")] + fn fold_item_type(&mut self, i: ItemType) -> ItemType { + fold_item_type(self, i) + } + #[cfg(feature = "full")] + fn fold_item_union(&mut self, i: ItemUnion) -> ItemUnion { + fold_item_union(self, i) + } + #[cfg(feature = "full")] + fn fold_item_use(&mut self, i: ItemUse) -> ItemUse { + fold_item_use(self, i) + } + #[cfg(feature = "full")] + fn fold_item_verbatim(&mut self, i: ItemVerbatim) -> ItemVerbatim { + fold_item_verbatim(self, i) + } + #[cfg(feature = "full")] + fn fold_label(&mut self, i: Label) -> Label { + fold_label(self, i) + } + fn fold_lifetime(&mut self, i: Lifetime) -> Lifetime { + fold_lifetime(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lifetime_def(&mut self, i: LifetimeDef) -> LifetimeDef { + fold_lifetime_def(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit(&mut self, i: Lit) -> Lit { + fold_lit(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit_bool(&mut self, i: LitBool) -> LitBool { + fold_lit_bool(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit_byte(&mut self, i: LitByte) -> LitByte { + fold_lit_byte(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit_byte_str(&mut self, i: LitByteStr) -> LitByteStr { + fold_lit_byte_str(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit_char(&mut self, i: LitChar) -> LitChar { + fold_lit_char(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit_float(&mut self, i: LitFloat) -> LitFloat { + fold_lit_float(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit_int(&mut self, i: LitInt) -> LitInt { + fold_lit_int(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit_str(&mut self, i: LitStr) -> LitStr { + fold_lit_str(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_lit_verbatim(&mut self, i: LitVerbatim) -> LitVerbatim { + fold_lit_verbatim(self, i) + } + #[cfg(feature = "full")] + fn fold_local(&mut self, i: Local) -> Local { + fold_local(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_macro(&mut self, i: Macro) -> Macro { + fold_macro(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_macro_delimiter(&mut self, i: MacroDelimiter) -> MacroDelimiter { + fold_macro_delimiter(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_member(&mut self, i: Member) -> Member { + fold_member(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_meta(&mut self, i: Meta) -> Meta { + fold_meta(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_meta_list(&mut self, i: MetaList) -> MetaList { + fold_meta_list(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_meta_name_value(&mut self, i: MetaNameValue) -> MetaNameValue { + fold_meta_name_value(self, i) + } + #[cfg(feature = "full")] + fn fold_method_sig(&mut self, i: MethodSig) -> MethodSig { + fold_method_sig(self, i) + } + #[cfg(feature = "full")] + fn fold_method_turbofish(&mut self, i: MethodTurbofish) -> MethodTurbofish { + fold_method_turbofish(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_nested_meta(&mut self, i: NestedMeta) -> NestedMeta { + fold_nested_meta(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_parenthesized_generic_arguments( + &mut self, + i: ParenthesizedGenericArguments, + ) -> ParenthesizedGenericArguments { + fold_parenthesized_generic_arguments(self, i) + } + #[cfg(feature = "full")] + fn fold_pat(&mut self, i: Pat) -> Pat { + fold_pat(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_box(&mut self, i: PatBox) -> PatBox { + fold_pat_box(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_ident(&mut self, i: PatIdent) -> PatIdent { + fold_pat_ident(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_lit(&mut self, i: PatLit) -> PatLit { + fold_pat_lit(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_macro(&mut self, i: PatMacro) -> PatMacro { + fold_pat_macro(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_path(&mut self, i: PatPath) -> PatPath { + fold_pat_path(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_range(&mut self, i: PatRange) -> PatRange { + fold_pat_range(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_ref(&mut self, i: PatRef) -> PatRef { + fold_pat_ref(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_slice(&mut self, i: PatSlice) -> PatSlice { + fold_pat_slice(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_struct(&mut self, i: PatStruct) -> PatStruct { + fold_pat_struct(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_tuple(&mut self, i: PatTuple) -> PatTuple { + fold_pat_tuple(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_tuple_struct(&mut self, i: PatTupleStruct) -> PatTupleStruct { + fold_pat_tuple_struct(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_verbatim(&mut self, i: PatVerbatim) -> PatVerbatim { + fold_pat_verbatim(self, i) + } + #[cfg(feature = "full")] + fn fold_pat_wild(&mut self, i: PatWild) -> PatWild { + fold_pat_wild(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_path(&mut self, i: Path) -> Path { + fold_path(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_path_arguments(&mut self, i: PathArguments) -> PathArguments { + fold_path_arguments(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_path_segment(&mut self, i: PathSegment) -> PathSegment { + fold_path_segment(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_predicate_eq(&mut self, i: PredicateEq) -> PredicateEq { + fold_predicate_eq(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_predicate_lifetime(&mut self, i: PredicateLifetime) -> PredicateLifetime { + fold_predicate_lifetime(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_predicate_type(&mut self, i: PredicateType) -> PredicateType { + fold_predicate_type(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_qself(&mut self, i: QSelf) -> QSelf { + fold_qself(self, i) + } + #[cfg(feature = "full")] + fn fold_range_limits(&mut self, i: RangeLimits) -> RangeLimits { + fold_range_limits(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_return_type(&mut self, i: ReturnType) -> ReturnType { + fold_return_type(self, i) + } + #[cfg(feature = "full")] + fn fold_stmt(&mut self, i: Stmt) -> Stmt { + fold_stmt(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_trait_bound(&mut self, i: TraitBound) -> TraitBound { + fold_trait_bound(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_trait_bound_modifier(&mut self, i: TraitBoundModifier) -> TraitBoundModifier { + fold_trait_bound_modifier(self, i) + } + #[cfg(feature = "full")] + fn fold_trait_item(&mut self, i: TraitItem) -> TraitItem { + fold_trait_item(self, i) + } + #[cfg(feature = "full")] + fn fold_trait_item_const(&mut self, i: TraitItemConst) -> TraitItemConst { + fold_trait_item_const(self, i) + } + #[cfg(feature = "full")] + fn fold_trait_item_macro(&mut self, i: TraitItemMacro) -> TraitItemMacro { + fold_trait_item_macro(self, i) + } + #[cfg(feature = "full")] + fn fold_trait_item_method(&mut self, i: TraitItemMethod) -> TraitItemMethod { + fold_trait_item_method(self, i) + } + #[cfg(feature = "full")] + fn fold_trait_item_type(&mut self, i: TraitItemType) -> TraitItemType { + fold_trait_item_type(self, i) + } + #[cfg(feature = "full")] + fn fold_trait_item_verbatim(&mut self, i: TraitItemVerbatim) -> TraitItemVerbatim { + fold_trait_item_verbatim(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type(&mut self, i: Type) -> Type { + fold_type(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_array(&mut self, i: TypeArray) -> TypeArray { + fold_type_array(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_bare_fn(&mut self, i: TypeBareFn) -> TypeBareFn { + fold_type_bare_fn(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_group(&mut self, i: TypeGroup) -> TypeGroup { + fold_type_group(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_impl_trait(&mut self, i: TypeImplTrait) -> TypeImplTrait { + fold_type_impl_trait(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_infer(&mut self, i: TypeInfer) -> TypeInfer { + fold_type_infer(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_macro(&mut self, i: TypeMacro) -> TypeMacro { + fold_type_macro(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_never(&mut self, i: TypeNever) -> TypeNever { + fold_type_never(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_param(&mut self, i: TypeParam) -> TypeParam { + fold_type_param(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_param_bound(&mut self, i: TypeParamBound) -> TypeParamBound { + fold_type_param_bound(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_paren(&mut self, i: TypeParen) -> TypeParen { + fold_type_paren(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_path(&mut self, i: TypePath) -> TypePath { + fold_type_path(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_ptr(&mut self, i: TypePtr) -> TypePtr { + fold_type_ptr(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_reference(&mut self, i: TypeReference) -> TypeReference { + fold_type_reference(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_slice(&mut self, i: TypeSlice) -> TypeSlice { + fold_type_slice(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_trait_object(&mut self, i: TypeTraitObject) -> TypeTraitObject { + fold_type_trait_object(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_tuple(&mut self, i: TypeTuple) -> TypeTuple { + fold_type_tuple(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_type_verbatim(&mut self, i: TypeVerbatim) -> TypeVerbatim { + fold_type_verbatim(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_un_op(&mut self, i: UnOp) -> UnOp { + fold_un_op(self, i) + } + #[cfg(feature = "full")] + fn fold_use_glob(&mut self, i: UseGlob) -> UseGlob { + fold_use_glob(self, i) + } + #[cfg(feature = "full")] + fn fold_use_group(&mut self, i: UseGroup) -> UseGroup { + fold_use_group(self, i) + } + #[cfg(feature = "full")] + fn fold_use_name(&mut self, i: UseName) -> UseName { + fold_use_name(self, i) + } + #[cfg(feature = "full")] + fn fold_use_path(&mut self, i: UsePath) -> UsePath { + fold_use_path(self, i) + } + #[cfg(feature = "full")] + fn fold_use_rename(&mut self, i: UseRename) -> UseRename { + fold_use_rename(self, i) + } + #[cfg(feature = "full")] + fn fold_use_tree(&mut self, i: UseTree) -> UseTree { + fold_use_tree(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_variant(&mut self, i: Variant) -> Variant { + fold_variant(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_vis_crate(&mut self, i: VisCrate) -> VisCrate { + fold_vis_crate(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_vis_public(&mut self, i: VisPublic) -> VisPublic { + fold_vis_public(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_vis_restricted(&mut self, i: VisRestricted) -> VisRestricted { + fold_vis_restricted(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_visibility(&mut self, i: Visibility) -> Visibility { + fold_visibility(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_where_clause(&mut self, i: WhereClause) -> WhereClause { + fold_where_clause(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn fold_where_predicate(&mut self, i: WherePredicate) -> WherePredicate { + fold_where_predicate(self, i) + } + fn fold_span(&mut self, i: Span) -> Span { + fold_span(self, i) + } + fn fold_ident(&mut self, i: Ident) -> Ident { + fold_ident(self, i) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_abi<V: Fold + ?Sized>(_visitor: &mut V, _i: Abi) -> Abi { + Abi { + extern_token: Token), + name: (_i.name).map(|it| _visitor.fold_lit_str(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_angle_bracketed_generic_arguments<V: Fold + ?Sized>( + _visitor: &mut V, + _i: AngleBracketedGenericArguments, +) -> AngleBracketedGenericArguments { + AngleBracketedGenericArguments { + colon2_token: (_i.colon2_token) + .map(|it| Token ! [ :: ](tokens_helper(_visitor, &it.spans))), + lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)), + args: FoldHelper::lift(_i.args, |it| _visitor.fold_generic_argument(it)), + gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_arg_captured<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgCaptured) -> ArgCaptured { + ArgCaptured { + pat: _visitor.fold_pat(_i.pat), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + ty: _visitor.fold_type(_i.ty), + } +} +#[cfg(feature = "full")] +pub fn fold_arg_self<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgSelf) -> ArgSelf { + ArgSelf { + mutability: (_i.mutability).map(|it| Token)), + self_token: Token), + } +} +#[cfg(feature = "full")] +pub fn fold_arg_self_ref<V: Fold + ?Sized>(_visitor: &mut V, _i: ArgSelfRef) -> ArgSelfRef { + ArgSelfRef { + and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)), + lifetime: (_i.lifetime).map(|it| _visitor.fold_lifetime(it)), + mutability: (_i.mutability).map(|it| Token)), + self_token: Token), + } +} +#[cfg(feature = "full")] +pub fn fold_arm<V: Fold + ?Sized>(_visitor: &mut V, _i: Arm) -> Arm { + Arm { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + leading_vert: (_i.leading_vert).map(|it| Token ! [ | ](tokens_helper(_visitor, &it.spans))), + pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)), + guard: (_i.guard).map(|it| { + ( + Token.0.span)), + Box::new(_visitor.fold_expr(*(it).1)), + ) + }), + fat_arrow_token: Token ! [ => ](tokens_helper(_visitor, &_i.fat_arrow_token.spans)), + body: Box::new(_visitor.fold_expr(*_i.body)), + comma: (_i.comma).map(|it| Token ! [ , ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_attr_style<V: Fold + ?Sized>(_visitor: &mut V, _i: AttrStyle) -> AttrStyle { + match _i { + AttrStyle::Outer => AttrStyle::Outer, + AttrStyle::Inner(_binding_0) => { + AttrStyle::Inner(Token)) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_attribute<V: Fold + ?Sized>(_visitor: &mut V, _i: Attribute) -> Attribute { + Attribute { + pound_token: Token ! [ # ](tokens_helper(_visitor, &_i.pound_token.spans)), + style: _visitor.fold_attr_style(_i.style), + bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)), + path: _visitor.fold_path(_i.path), + tts: _i.tts, + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_bare_fn_arg<V: Fold + ?Sized>(_visitor: &mut V, _i: BareFnArg) -> BareFnArg { + BareFnArg { + name: (_i.name).map(|it| { + ( + _visitor.fold_bare_fn_arg_name((it).0), + Token ! [ : ](tokens_helper(_visitor, &(it).1.spans)), + ) + }), + ty: _visitor.fold_type(_i.ty), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_bare_fn_arg_name<V: Fold + ?Sized>( + _visitor: &mut V, + _i: BareFnArgName, +) -> BareFnArgName { + match _i { + BareFnArgName::Named(_binding_0) => BareFnArgName::Named(_visitor.fold_ident(_binding_0)), + BareFnArgName::Wild(_binding_0) => { + BareFnArgName::Wild(Token)) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_bin_op<V: Fold + ?Sized>(_visitor: &mut V, _i: BinOp) -> BinOp { + match _i { + BinOp::Add(_binding_0) => { + BinOp::Add(Token ! [ + ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Sub(_binding_0) => { + BinOp::Sub(Token ! [ - ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Mul(_binding_0) => { + BinOp::Mul(Token ! [ * ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Div(_binding_0) => { + BinOp::Div(Token ! [ / ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Rem(_binding_0) => { + BinOp::Rem(Token ! [ % ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::And(_binding_0) => { + BinOp::And(Token ! [ && ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Or(_binding_0) => { + BinOp::Or(Token ! [ || ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::BitXor(_binding_0) => { + BinOp::BitXor(Token ! [ ^ ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::BitAnd(_binding_0) => { + BinOp::BitAnd(Token ! [ & ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::BitOr(_binding_0) => { + BinOp::BitOr(Token ! [ | ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Shl(_binding_0) => { + BinOp::Shl(Token ! [ << ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Shr(_binding_0) => { + BinOp::Shr(Token ! [ >> ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Eq(_binding_0) => { + BinOp::Eq(Token ! [ == ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Lt(_binding_0) => { + BinOp::Lt(Token ! [ < ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Le(_binding_0) => { + BinOp::Le(Token ! [ <= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Ne(_binding_0) => { + BinOp::Ne(Token ! [ != ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Ge(_binding_0) => { + BinOp::Ge(Token ! [ >= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::Gt(_binding_0) => { + BinOp::Gt(Token ! [ > ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::AddEq(_binding_0) => { + BinOp::AddEq(Token ! [ += ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::SubEq(_binding_0) => { + BinOp::SubEq(Token ! [ -= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::MulEq(_binding_0) => { + BinOp::MulEq(Token ! [ *= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::DivEq(_binding_0) => { + BinOp::DivEq(Token ! [ /= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::RemEq(_binding_0) => { + BinOp::RemEq(Token ! [ %= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::BitXorEq(_binding_0) => { + BinOp::BitXorEq(Token ! [ ^= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::BitAndEq(_binding_0) => { + BinOp::BitAndEq(Token ! [ &= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::BitOrEq(_binding_0) => { + BinOp::BitOrEq(Token ! [ |= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::ShlEq(_binding_0) => { + BinOp::ShlEq(Token ! [ <<= ](tokens_helper(_visitor, &_binding_0.spans))) + } + BinOp::ShrEq(_binding_0) => { + BinOp::ShrEq(Token ! [ >>= ](tokens_helper(_visitor, &_binding_0.spans))) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_binding<V: Fold + ?Sized>(_visitor: &mut V, _i: Binding) -> Binding { + Binding { + ident: _visitor.fold_ident(_i.ident), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + ty: _visitor.fold_type(_i.ty), + } +} +#[cfg(feature = "full")] +pub fn fold_block<V: Fold + ?Sized>(_visitor: &mut V, _i: Block) -> Block { + Block { + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + stmts: FoldHelper::lift(_i.stmts, |it| _visitor.fold_stmt(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_bound_lifetimes<V: Fold + ?Sized>( + _visitor: &mut V, + _i: BoundLifetimes, +) -> BoundLifetimes { + BoundLifetimes { + for_token: Token), + lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)), + lifetimes: FoldHelper::lift(_i.lifetimes, |it| _visitor.fold_lifetime_def(it)), + gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_const_param<V: Fold + ?Sized>(_visitor: &mut V, _i: ConstParam) -> ConstParam { + ConstParam { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + const_token: Token), + ident: _visitor.fold_ident(_i.ident), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + ty: _visitor.fold_type(_i.ty), + eq_token: (_i.eq_token).map(|it| Token ! [ = ](tokens_helper(_visitor, &it.spans))), + default: (_i.default).map(|it| _visitor.fold_expr(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_constraint<V: Fold + ?Sized>(_visitor: &mut V, _i: Constraint) -> Constraint { + Constraint { + ident: _visitor.fold_ident(_i.ident), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + } +} +#[cfg(feature = "derive")] +pub fn fold_data<V: Fold + ?Sized>(_visitor: &mut V, _i: Data) -> Data { + match _i { + Data::Struct(_binding_0) => Data::Struct(_visitor.fold_data_struct(_binding_0)), + Data::Enum(_binding_0) => Data::Enum(_visitor.fold_data_enum(_binding_0)), + Data::Union(_binding_0) => Data::Union(_visitor.fold_data_union(_binding_0)), + } +} +#[cfg(feature = "derive")] +pub fn fold_data_enum<V: Fold + ?Sized>(_visitor: &mut V, _i: DataEnum) -> DataEnum { + DataEnum { + enum_token: Token), + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + variants: FoldHelper::lift(_i.variants, |it| _visitor.fold_variant(it)), + } +} +#[cfg(feature = "derive")] +pub fn fold_data_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: DataStruct) -> DataStruct { + DataStruct { + struct_token: Token), + fields: _visitor.fold_fields(_i.fields), + semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(feature = "derive")] +pub fn fold_data_union<V: Fold + ?Sized>(_visitor: &mut V, _i: DataUnion) -> DataUnion { + DataUnion { + union_token: Token), + fields: _visitor.fold_fields_named(_i.fields), + } +} +#[cfg(feature = "derive")] +pub fn fold_derive_input<V: Fold + ?Sized>(_visitor: &mut V, _i: DeriveInput) -> DeriveInput { + DeriveInput { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + data: _visitor.fold_data(_i.data), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr<V: Fold + ?Sized>(_visitor: &mut V, _i: Expr) -> Expr { + match _i { + Expr::Box(_binding_0) => Expr::Box(full!(_visitor.fold_expr_box(_binding_0))), + Expr::InPlace(_binding_0) => Expr::InPlace(full!(_visitor.fold_expr_in_place(_binding_0))), + Expr::Array(_binding_0) => Expr::Array(full!(_visitor.fold_expr_array(_binding_0))), + Expr::Call(_binding_0) => Expr::Call(_visitor.fold_expr_call(_binding_0)), + Expr::MethodCall(_binding_0) => { + Expr::MethodCall(full!(_visitor.fold_expr_method_call(_binding_0))) + } + Expr::Tuple(_binding_0) => Expr::Tuple(full!(_visitor.fold_expr_tuple(_binding_0))), + Expr::Binary(_binding_0) => Expr::Binary(_visitor.fold_expr_binary(_binding_0)), + Expr::Unary(_binding_0) => Expr::Unary(_visitor.fold_expr_unary(_binding_0)), + Expr::Lit(_binding_0) => Expr::Lit(_visitor.fold_expr_lit(_binding_0)), + Expr::Cast(_binding_0) => Expr::Cast(_visitor.fold_expr_cast(_binding_0)), + Expr::Type(_binding_0) => Expr::Type(full!(_visitor.fold_expr_type(_binding_0))), + Expr::Let(_binding_0) => Expr::Let(full!(_visitor.fold_expr_let(_binding_0))), + Expr::If(_binding_0) => Expr::If(full!(_visitor.fold_expr_if(_binding_0))), + Expr::While(_binding_0) => Expr::While(full!(_visitor.fold_expr_while(_binding_0))), + Expr::ForLoop(_binding_0) => Expr::ForLoop(full!(_visitor.fold_expr_for_loop(_binding_0))), + Expr::Loop(_binding_0) => Expr::Loop(full!(_visitor.fold_expr_loop(_binding_0))), + Expr::Match(_binding_0) => Expr::Match(full!(_visitor.fold_expr_match(_binding_0))), + Expr::Closure(_binding_0) => Expr::Closure(full!(_visitor.fold_expr_closure(_binding_0))), + Expr::Unsafe(_binding_0) => Expr::Unsafe(full!(_visitor.fold_expr_unsafe(_binding_0))), + Expr::Block(_binding_0) => Expr::Block(full!(_visitor.fold_expr_block(_binding_0))), + Expr::Assign(_binding_0) => Expr::Assign(full!(_visitor.fold_expr_assign(_binding_0))), + Expr::AssignOp(_binding_0) => { + Expr::AssignOp(full!(_visitor.fold_expr_assign_op(_binding_0))) + } + Expr::Field(_binding_0) => Expr::Field(_visitor.fold_expr_field(_binding_0)), + Expr::Index(_binding_0) => Expr::Index(_visitor.fold_expr_index(_binding_0)), + Expr::Range(_binding_0) => Expr::Range(full!(_visitor.fold_expr_range(_binding_0))), + Expr::Path(_binding_0) => Expr::Path(_visitor.fold_expr_path(_binding_0)), + Expr::Reference(_binding_0) => { + Expr::Reference(full!(_visitor.fold_expr_reference(_binding_0))) + } + Expr::Break(_binding_0) => Expr::Break(full!(_visitor.fold_expr_break(_binding_0))), + Expr::Continue(_binding_0) => { + Expr::Continue(full!(_visitor.fold_expr_continue(_binding_0))) + } + Expr::Return(_binding_0) => Expr::Return(full!(_visitor.fold_expr_return(_binding_0))), + Expr::Macro(_binding_0) => Expr::Macro(full!(_visitor.fold_expr_macro(_binding_0))), + Expr::Struct(_binding_0) => Expr::Struct(full!(_visitor.fold_expr_struct(_binding_0))), + Expr::Repeat(_binding_0) => Expr::Repeat(full!(_visitor.fold_expr_repeat(_binding_0))), + Expr::Paren(_binding_0) => Expr::Paren(_visitor.fold_expr_paren(_binding_0)), + Expr::Group(_binding_0) => Expr::Group(full!(_visitor.fold_expr_group(_binding_0))), + Expr::Try(_binding_0) => Expr::Try(full!(_visitor.fold_expr_try(_binding_0))), + Expr::Async(_binding_0) => Expr::Async(full!(_visitor.fold_expr_async(_binding_0))), + Expr::TryBlock(_binding_0) => { + Expr::TryBlock(full!(_visitor.fold_expr_try_block(_binding_0))) + } + Expr::Yield(_binding_0) => Expr::Yield(full!(_visitor.fold_expr_yield(_binding_0))), + Expr::Verbatim(_binding_0) => Expr::Verbatim(_visitor.fold_expr_verbatim(_binding_0)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_array<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprArray) -> ExprArray { + ExprArray { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)), + elems: FoldHelper::lift(_i.elems, |it| _visitor.fold_expr(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_assign<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAssign) -> ExprAssign { + ExprAssign { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + left: Box::new(_visitor.fold_expr(*_i.left)), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + right: Box::new(_visitor.fold_expr(*_i.right)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_assign_op<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAssignOp) -> ExprAssignOp { + ExprAssignOp { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + left: Box::new(_visitor.fold_expr(*_i.left)), + op: _visitor.fold_bin_op(_i.op), + right: Box::new(_visitor.fold_expr(*_i.right)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_async<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprAsync) -> ExprAsync { + ExprAsync { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + async_token: Token), + capture: (_i.capture).map(|it| Token)), + block: _visitor.fold_block(_i.block), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_binary<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBinary) -> ExprBinary { + ExprBinary { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + left: Box::new(_visitor.fold_expr(*_i.left)), + op: _visitor.fold_bin_op(_i.op), + right: Box::new(_visitor.fold_expr(*_i.right)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_block<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBlock) -> ExprBlock { + ExprBlock { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + label: (_i.label).map(|it| _visitor.fold_label(it)), + block: _visitor.fold_block(_i.block), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_box<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBox) -> ExprBox { + ExprBox { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + box_token: Token), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_break<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprBreak) -> ExprBreak { + ExprBreak { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + break_token: Token), + label: (_i.label).map(|it| _visitor.fold_lifetime(it)), + expr: (_i.expr).map(|it| Box::new(_visitor.fold_expr(*it))), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_call<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprCall) -> ExprCall { + ExprCall { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + func: Box::new(_visitor.fold_expr(*_i.func)), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + args: FoldHelper::lift(_i.args, |it| _visitor.fold_expr(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_cast<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprCast) -> ExprCast { + ExprCast { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + as_token: Token), + ty: Box::new(_visitor.fold_type(*_i.ty)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_closure<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprClosure) -> ExprClosure { + ExprClosure { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + asyncness: (_i.asyncness).map(|it| Token)), + movability: (_i.movability).map(|it| Token)), + capture: (_i.capture).map(|it| Token)), + or1_token: Token ! [ | ](tokens_helper(_visitor, &_i.or1_token.spans)), + inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_fn_arg(it)), + or2_token: Token ! [ | ](tokens_helper(_visitor, &_i.or2_token.spans)), + output: _visitor.fold_return_type(_i.output), + body: Box::new(_visitor.fold_expr(*_i.body)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_continue<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprContinue) -> ExprContinue { + ExprContinue { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + continue_token: Token), + label: (_i.label).map(|it| _visitor.fold_lifetime(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_field<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprField) -> ExprField { + ExprField { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + base: Box::new(_visitor.fold_expr(*_i.base)), + dot_token: Token ! [ . ](tokens_helper(_visitor, &_i.dot_token.spans)), + member: _visitor.fold_member(_i.member), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_for_loop<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprForLoop) -> ExprForLoop { + ExprForLoop { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + label: (_i.label).map(|it| _visitor.fold_label(it)), + for_token: Token), + pat: Box::new(_visitor.fold_pat(*_i.pat)), + in_token: Token), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + body: _visitor.fold_block(_i.body), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_group<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprGroup) -> ExprGroup { + ExprGroup { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + group_token: Group(tokens_helper(_visitor, &_i.group_token.span)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_if<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprIf) -> ExprIf { + ExprIf { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + if_token: Token), + cond: Box::new(_visitor.fold_expr(*_i.cond)), + then_branch: _visitor.fold_block(_i.then_branch), + else_branch: (_i.else_branch).map(|it| { + ( + Token.0.span)), + Box::new(_visitor.fold_expr(*(it).1)), + ) + }), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_in_place<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprInPlace) -> ExprInPlace { + ExprInPlace { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + place: Box::new(_visitor.fold_expr(*_i.place)), + arrow_token: Token ! [ <- ](tokens_helper(_visitor, &_i.arrow_token.spans)), + value: Box::new(_visitor.fold_expr(*_i.value)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_index<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprIndex) -> ExprIndex { + ExprIndex { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)), + index: Box::new(_visitor.fold_expr(*_i.index)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_let<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprLet) -> ExprLet { + ExprLet { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + let_token: Token), + pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprLit) -> ExprLit { + ExprLit { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + lit: _visitor.fold_lit(_i.lit), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_loop<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprLoop) -> ExprLoop { + ExprLoop { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + label: (_i.label).map(|it| _visitor.fold_label(it)), + loop_token: Token), + body: _visitor.fold_block(_i.body), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprMacro) -> ExprMacro { + ExprMacro { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + mac: _visitor.fold_macro(_i.mac), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_match<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprMatch) -> ExprMatch { + ExprMatch { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + match_token: Token), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + arms: FoldHelper::lift(_i.arms, |it| _visitor.fold_arm(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_method_call<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ExprMethodCall, +) -> ExprMethodCall { + ExprMethodCall { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + receiver: Box::new(_visitor.fold_expr(*_i.receiver)), + dot_token: Token ! [ . ](tokens_helper(_visitor, &_i.dot_token.spans)), + method: _visitor.fold_ident(_i.method), + turbofish: (_i.turbofish).map(|it| _visitor.fold_method_turbofish(it)), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + args: FoldHelper::lift(_i.args, |it| _visitor.fold_expr(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_paren<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprParen) -> ExprParen { + ExprParen { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_path<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprPath) -> ExprPath { + ExprPath { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + qself: (_i.qself).map(|it| _visitor.fold_qself(it)), + path: _visitor.fold_path(_i.path), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_range<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprRange) -> ExprRange { + ExprRange { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + from: (_i.from).map(|it| Box::new(_visitor.fold_expr(*it))), + limits: _visitor.fold_range_limits(_i.limits), + to: (_i.to).map(|it| Box::new(_visitor.fold_expr(*it))), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_reference<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprReference) -> ExprReference { + ExprReference { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)), + mutability: (_i.mutability).map(|it| Token)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_repeat<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprRepeat) -> ExprRepeat { + ExprRepeat { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + len: Box::new(_visitor.fold_expr(*_i.len)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_return<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprReturn) -> ExprReturn { + ExprReturn { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + return_token: Token), + expr: (_i.expr).map(|it| Box::new(_visitor.fold_expr(*it))), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprStruct) -> ExprStruct { + ExprStruct { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + path: _visitor.fold_path(_i.path), + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + fields: FoldHelper::lift(_i.fields, |it| _visitor.fold_field_value(it)), + dot2_token: (_i.dot2_token).map(|it| Token)), + rest: (_i.rest).map(|it| Box::new(_visitor.fold_expr(*it))), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_try<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTry) -> ExprTry { + ExprTry { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + question_token: Token ! [ ? ](tokens_helper(_visitor, &_i.question_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_try_block<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTryBlock) -> ExprTryBlock { + ExprTryBlock { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + try_token: Token), + block: _visitor.fold_block(_i.block), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprTuple) -> ExprTuple { + ExprTuple { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + elems: FoldHelper::lift(_i.elems, |it| _visitor.fold_expr(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprType) -> ExprType { + ExprType { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + ty: Box::new(_visitor.fold_type(*_i.ty)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_unary<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprUnary) -> ExprUnary { + ExprUnary { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + op: _visitor.fold_un_op(_i.op), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_unsafe<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprUnsafe) -> ExprUnsafe { + ExprUnsafe { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + unsafe_token: Token), + block: _visitor.fold_block(_i.block), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_expr_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprVerbatim) -> ExprVerbatim { + ExprVerbatim { tts: _i.tts } +} +#[cfg(feature = "full")] +pub fn fold_expr_while<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprWhile) -> ExprWhile { + ExprWhile { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + label: (_i.label).map(|it| _visitor.fold_label(it)), + while_token: Token), + cond: Box::new(_visitor.fold_expr(*_i.cond)), + body: _visitor.fold_block(_i.body), + } +} +#[cfg(feature = "full")] +pub fn fold_expr_yield<V: Fold + ?Sized>(_visitor: &mut V, _i: ExprYield) -> ExprYield { + ExprYield { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + yield_token: Token), + expr: (_i.expr).map(|it| Box::new(_visitor.fold_expr(*it))), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_field<V: Fold + ?Sized>(_visitor: &mut V, _i: Field) -> Field { + Field { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + ident: (_i.ident).map(|it| _visitor.fold_ident(it)), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + ty: _visitor.fold_type(_i.ty), + } +} +#[cfg(feature = "full")] +pub fn fold_field_pat<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldPat) -> FieldPat { + FieldPat { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + member: _visitor.fold_member(_i.member), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + pat: Box::new(_visitor.fold_pat(*_i.pat)), + } +} +#[cfg(feature = "full")] +pub fn fold_field_value<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldValue) -> FieldValue { + FieldValue { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + member: _visitor.fold_member(_i.member), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + expr: _visitor.fold_expr(_i.expr), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_fields<V: Fold + ?Sized>(_visitor: &mut V, _i: Fields) -> Fields { + match _i { + Fields::Named(_binding_0) => Fields::Named(_visitor.fold_fields_named(_binding_0)), + Fields::Unnamed(_binding_0) => Fields::Unnamed(_visitor.fold_fields_unnamed(_binding_0)), + Fields::Unit => Fields::Unit, + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_fields_named<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldsNamed) -> FieldsNamed { + FieldsNamed { + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + named: FoldHelper::lift(_i.named, |it| _visitor.fold_field(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_fields_unnamed<V: Fold + ?Sized>(_visitor: &mut V, _i: FieldsUnnamed) -> FieldsUnnamed { + FieldsUnnamed { + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + unnamed: FoldHelper::lift(_i.unnamed, |it| _visitor.fold_field(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_file<V: Fold + ?Sized>(_visitor: &mut V, _i: File) -> File { + File { + shebang: _i.shebang, + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + items: FoldHelper::lift(_i.items, |it| _visitor.fold_item(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_fn_arg<V: Fold + ?Sized>(_visitor: &mut V, _i: FnArg) -> FnArg { + match _i { + FnArg::SelfRef(_binding_0) => FnArg::SelfRef(_visitor.fold_arg_self_ref(_binding_0)), + FnArg::SelfValue(_binding_0) => FnArg::SelfValue(_visitor.fold_arg_self(_binding_0)), + FnArg::Captured(_binding_0) => FnArg::Captured(_visitor.fold_arg_captured(_binding_0)), + FnArg::Inferred(_binding_0) => FnArg::Inferred(_visitor.fold_pat(_binding_0)), + FnArg::Ignored(_binding_0) => FnArg::Ignored(_visitor.fold_type(_binding_0)), + } +} +#[cfg(feature = "full")] +pub fn fold_fn_decl<V: Fold + ?Sized>(_visitor: &mut V, _i: FnDecl) -> FnDecl { + FnDecl { + fn_token: Token), + generics: _visitor.fold_generics(_i.generics), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_fn_arg(it)), + variadic: (_i.variadic).map(|it| Token ! [ ... ](tokens_helper(_visitor, &it.spans))), + output: _visitor.fold_return_type(_i.output), + } +} +#[cfg(feature = "full")] +pub fn fold_foreign_item<V: Fold + ?Sized>(_visitor: &mut V, _i: ForeignItem) -> ForeignItem { + match _i { + ForeignItem::Fn(_binding_0) => ForeignItem::Fn(_visitor.fold_foreign_item_fn(_binding_0)), + ForeignItem::Static(_binding_0) => { + ForeignItem::Static(_visitor.fold_foreign_item_static(_binding_0)) + } + ForeignItem::Type(_binding_0) => { + ForeignItem::Type(_visitor.fold_foreign_item_type(_binding_0)) + } + ForeignItem::Macro(_binding_0) => { + ForeignItem::Macro(_visitor.fold_foreign_item_macro(_binding_0)) + } + ForeignItem::Verbatim(_binding_0) => { + ForeignItem::Verbatim(_visitor.fold_foreign_item_verbatim(_binding_0)) + } + } +} +#[cfg(feature = "full")] +pub fn fold_foreign_item_fn<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ForeignItemFn, +) -> ForeignItemFn { + ForeignItemFn { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + ident: _visitor.fold_ident(_i.ident), + decl: Box::new(_visitor.fold_fn_decl(*_i.decl)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_foreign_item_macro<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ForeignItemMacro, +) -> ForeignItemMacro { + ForeignItemMacro { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + mac: _visitor.fold_macro(_i.mac), + semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(feature = "full")] +pub fn fold_foreign_item_static<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ForeignItemStatic, +) -> ForeignItemStatic { + ForeignItemStatic { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + static_token: Token), + mutability: (_i.mutability).map(|it| Token)), + ident: _visitor.fold_ident(_i.ident), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + ty: Box::new(_visitor.fold_type(*_i.ty)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_foreign_item_type<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ForeignItemType, +) -> ForeignItemType { + ForeignItemType { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + type_token: Token), + ident: _visitor.fold_ident(_i.ident), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_foreign_item_verbatim<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ForeignItemVerbatim, +) -> ForeignItemVerbatim { + ForeignItemVerbatim { tts: _i.tts } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_generic_argument<V: Fold + ?Sized>( + _visitor: &mut V, + _i: GenericArgument, +) -> GenericArgument { + match _i { + GenericArgument::Lifetime(_binding_0) => { + GenericArgument::Lifetime(_visitor.fold_lifetime(_binding_0)) + } + GenericArgument::Type(_binding_0) => GenericArgument::Type(_visitor.fold_type(_binding_0)), + GenericArgument::Binding(_binding_0) => { + GenericArgument::Binding(_visitor.fold_binding(_binding_0)) + } + GenericArgument::Constraint(_binding_0) => { + GenericArgument::Constraint(_visitor.fold_constraint(_binding_0)) + } + GenericArgument::Const(_binding_0) => { + GenericArgument::Const(_visitor.fold_expr(_binding_0)) + } + } +} +#[cfg(feature = "full")] +pub fn fold_generic_method_argument<V: Fold + ?Sized>( + _visitor: &mut V, + _i: GenericMethodArgument, +) -> GenericMethodArgument { + match _i { + GenericMethodArgument::Type(_binding_0) => { + GenericMethodArgument::Type(_visitor.fold_type(_binding_0)) + } + GenericMethodArgument::Const(_binding_0) => { + GenericMethodArgument::Const(_visitor.fold_expr(_binding_0)) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_generic_param<V: Fold + ?Sized>(_visitor: &mut V, _i: GenericParam) -> GenericParam { + match _i { + GenericParam::Type(_binding_0) => GenericParam::Type(_visitor.fold_type_param(_binding_0)), + GenericParam::Lifetime(_binding_0) => { + GenericParam::Lifetime(_visitor.fold_lifetime_def(_binding_0)) + } + GenericParam::Const(_binding_0) => { + GenericParam::Const(_visitor.fold_const_param(_binding_0)) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_generics<V: Fold + ?Sized>(_visitor: &mut V, _i: Generics) -> Generics { + Generics { + lt_token: (_i.lt_token).map(|it| Token ! [ < ](tokens_helper(_visitor, &it.spans))), + params: FoldHelper::lift(_i.params, |it| _visitor.fold_generic_param(it)), + gt_token: (_i.gt_token).map(|it| Token ! [ > ](tokens_helper(_visitor, &it.spans))), + where_clause: (_i.where_clause).map(|it| _visitor.fold_where_clause(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_impl_item<V: Fold + ?Sized>(_visitor: &mut V, _i: ImplItem) -> ImplItem { + match _i { + ImplItem::Const(_binding_0) => ImplItem::Const(_visitor.fold_impl_item_const(_binding_0)), + ImplItem::Method(_binding_0) => { + ImplItem::Method(_visitor.fold_impl_item_method(_binding_0)) + } + ImplItem::Type(_binding_0) => ImplItem::Type(_visitor.fold_impl_item_type(_binding_0)), + ImplItem::Existential(_binding_0) => { + ImplItem::Existential(_visitor.fold_impl_item_existential(_binding_0)) + } + ImplItem::Macro(_binding_0) => ImplItem::Macro(_visitor.fold_impl_item_macro(_binding_0)), + ImplItem::Verbatim(_binding_0) => { + ImplItem::Verbatim(_visitor.fold_impl_item_verbatim(_binding_0)) + } + } +} +#[cfg(feature = "full")] +pub fn fold_impl_item_const<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ImplItemConst, +) -> ImplItemConst { + ImplItemConst { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + defaultness: (_i.defaultness).map(|it| Token)), + const_token: Token), + ident: _visitor.fold_ident(_i.ident), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + ty: _visitor.fold_type(_i.ty), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + expr: _visitor.fold_expr(_i.expr), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_impl_item_existential<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ImplItemExistential, +) -> ImplItemExistential { + ImplItemExistential { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + existential_token: Token), + type_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_impl_item_macro<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ImplItemMacro, +) -> ImplItemMacro { + ImplItemMacro { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + mac: _visitor.fold_macro(_i.mac), + semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(feature = "full")] +pub fn fold_impl_item_method<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ImplItemMethod, +) -> ImplItemMethod { + ImplItemMethod { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + defaultness: (_i.defaultness).map(|it| Token)), + sig: _visitor.fold_method_sig(_i.sig), + block: _visitor.fold_block(_i.block), + } +} +#[cfg(feature = "full")] +pub fn fold_impl_item_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ImplItemType) -> ImplItemType { + ImplItemType { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + defaultness: (_i.defaultness).map(|it| Token)), + type_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + ty: _visitor.fold_type(_i.ty), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_impl_item_verbatim<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ImplItemVerbatim, +) -> ImplItemVerbatim { + ImplItemVerbatim { tts: _i.tts } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_index<V: Fold + ?Sized>(_visitor: &mut V, _i: Index) -> Index { + Index { + index: _i.index, + span: _visitor.fold_span(_i.span), + } +} +#[cfg(feature = "full")] +pub fn fold_item<V: Fold + ?Sized>(_visitor: &mut V, _i: Item) -> Item { + match _i { + Item::ExternCrate(_binding_0) => { + Item::ExternCrate(_visitor.fold_item_extern_crate(_binding_0)) + } + Item::Use(_binding_0) => Item::Use(_visitor.fold_item_use(_binding_0)), + Item::Static(_binding_0) => Item::Static(_visitor.fold_item_static(_binding_0)), + Item::Const(_binding_0) => Item::Const(_visitor.fold_item_const(_binding_0)), + Item::Fn(_binding_0) => Item::Fn(_visitor.fold_item_fn(_binding_0)), + Item::Mod(_binding_0) => Item::Mod(_visitor.fold_item_mod(_binding_0)), + Item::ForeignMod(_binding_0) => { + Item::ForeignMod(_visitor.fold_item_foreign_mod(_binding_0)) + } + Item::Type(_binding_0) => Item::Type(_visitor.fold_item_type(_binding_0)), + Item::Existential(_binding_0) => { + Item::Existential(_visitor.fold_item_existential(_binding_0)) + } + Item::Struct(_binding_0) => Item::Struct(_visitor.fold_item_struct(_binding_0)), + Item::Enum(_binding_0) => Item::Enum(_visitor.fold_item_enum(_binding_0)), + Item::Union(_binding_0) => Item::Union(_visitor.fold_item_union(_binding_0)), + Item::Trait(_binding_0) => Item::Trait(_visitor.fold_item_trait(_binding_0)), + Item::TraitAlias(_binding_0) => { + Item::TraitAlias(_visitor.fold_item_trait_alias(_binding_0)) + } + Item::Impl(_binding_0) => Item::Impl(_visitor.fold_item_impl(_binding_0)), + Item::Macro(_binding_0) => Item::Macro(_visitor.fold_item_macro(_binding_0)), + Item::Macro2(_binding_0) => Item::Macro2(_visitor.fold_item_macro2(_binding_0)), + Item::Verbatim(_binding_0) => Item::Verbatim(_visitor.fold_item_verbatim(_binding_0)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_const<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemConst) -> ItemConst { + ItemConst { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + const_token: Token), + ident: _visitor.fold_ident(_i.ident), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + ty: Box::new(_visitor.fold_type(*_i.ty)), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_enum<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemEnum) -> ItemEnum { + ItemEnum { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + enum_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + variants: FoldHelper::lift(_i.variants, |it| _visitor.fold_variant(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_existential<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ItemExistential, +) -> ItemExistential { + ItemExistential { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + existential_token: Token), + type_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_extern_crate<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ItemExternCrate, +) -> ItemExternCrate { + ItemExternCrate { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + extern_token: Token), + crate_token: Token), + ident: _visitor.fold_ident(_i.ident), + rename: (_i.rename).map(|it| { + ( + Token.0.span)), + _visitor.fold_ident((it).1), + ) + }), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_fn<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemFn) -> ItemFn { + ItemFn { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + constness: (_i.constness).map(|it| Token)), + asyncness: (_i.asyncness).map(|it| Token)), + unsafety: (_i.unsafety).map(|it| Token)), + abi: (_i.abi).map(|it| _visitor.fold_abi(it)), + ident: _visitor.fold_ident(_i.ident), + decl: Box::new(_visitor.fold_fn_decl(*_i.decl)), + block: Box::new(_visitor.fold_block(*_i.block)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_foreign_mod<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ItemForeignMod, +) -> ItemForeignMod { + ItemForeignMod { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + abi: _visitor.fold_abi(_i.abi), + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + items: FoldHelper::lift(_i.items, |it| _visitor.fold_foreign_item(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_impl<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemImpl) -> ItemImpl { + ItemImpl { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + defaultness: (_i.defaultness).map(|it| Token)), + unsafety: (_i.unsafety).map(|it| Token)), + impl_token: Token), + generics: _visitor.fold_generics(_i.generics), + trait_: (_i.trait_).map(|it| { + ( + ((it).0).map(|it| Token)), + _visitor.fold_path((it).1), + Token.2.span)), + ) + }), + self_ty: Box::new(_visitor.fold_type(*_i.self_ty)), + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + items: FoldHelper::lift(_i.items, |it| _visitor.fold_impl_item(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemMacro) -> ItemMacro { + ItemMacro { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + ident: (_i.ident).map(|it| _visitor.fold_ident(it)), + mac: _visitor.fold_macro(_i.mac), + semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(feature = "full")] +pub fn fold_item_macro2<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemMacro2) -> ItemMacro2 { + ItemMacro2 { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + macro_token: Token), + ident: _visitor.fold_ident(_i.ident), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + args: _i.args, + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + body: _i.body, + } +} +#[cfg(feature = "full")] +pub fn fold_item_mod<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemMod) -> ItemMod { + ItemMod { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + mod_token: Token), + ident: _visitor.fold_ident(_i.ident), + content: (_i.content).map(|it| { + ( + Brace(tokens_helper(_visitor, &(it).0.span)), + FoldHelper::lift((it).1, |it| _visitor.fold_item(it)), + ) + }), + semi: (_i.semi).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(feature = "full")] +pub fn fold_item_static<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemStatic) -> ItemStatic { + ItemStatic { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + static_token: Token), + mutability: (_i.mutability).map(|it| Token)), + ident: _visitor.fold_ident(_i.ident), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + ty: Box::new(_visitor.fold_type(*_i.ty)), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + expr: Box::new(_visitor.fold_expr(*_i.expr)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemStruct) -> ItemStruct { + ItemStruct { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + struct_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + fields: _visitor.fold_fields(_i.fields), + semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(feature = "full")] +pub fn fold_item_trait<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemTrait) -> ItemTrait { + ItemTrait { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + unsafety: (_i.unsafety).map(|it| Token)), + auto_token: (_i.auto_token).map(|it| Token)), + trait_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + supertraits: FoldHelper::lift(_i.supertraits, |it| _visitor.fold_type_param_bound(it)), + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + items: FoldHelper::lift(_i.items, |it| _visitor.fold_trait_item(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_trait_alias<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ItemTraitAlias, +) -> ItemTraitAlias { + ItemTraitAlias { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + trait_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemType) -> ItemType { + ItemType { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + type_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + ty: Box::new(_visitor.fold_type(*_i.ty)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_union<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemUnion) -> ItemUnion { + ItemUnion { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + union_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + fields: _visitor.fold_fields_named(_i.fields), + } +} +#[cfg(feature = "full")] +pub fn fold_item_use<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemUse) -> ItemUse { + ItemUse { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + vis: _visitor.fold_visibility(_i.vis), + use_token: Token), + leading_colon: (_i.leading_colon) + .map(|it| Token ! [ :: ](tokens_helper(_visitor, &it.spans))), + tree: _visitor.fold_use_tree(_i.tree), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_item_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: ItemVerbatim) -> ItemVerbatim { + ItemVerbatim { tts: _i.tts } +} +#[cfg(feature = "full")] +pub fn fold_label<V: Fold + ?Sized>(_visitor: &mut V, _i: Label) -> Label { + Label { + name: _visitor.fold_lifetime(_i.name), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + } +} +pub fn fold_lifetime<V: Fold + ?Sized>(_visitor: &mut V, _i: Lifetime) -> Lifetime { + Lifetime { + apostrophe: _visitor.fold_span(_i.apostrophe), + ident: _visitor.fold_ident(_i.ident), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lifetime_def<V: Fold + ?Sized>(_visitor: &mut V, _i: LifetimeDef) -> LifetimeDef { + LifetimeDef { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + lifetime: _visitor.fold_lifetime(_i.lifetime), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_lifetime(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: Lit) -> Lit { + match _i { + Lit::Str(_binding_0) => Lit::Str(_visitor.fold_lit_str(_binding_0)), + Lit::ByteStr(_binding_0) => Lit::ByteStr(_visitor.fold_lit_byte_str(_binding_0)), + Lit::Byte(_binding_0) => Lit::Byte(_visitor.fold_lit_byte(_binding_0)), + Lit::Char(_binding_0) => Lit::Char(_visitor.fold_lit_char(_binding_0)), + Lit::Int(_binding_0) => Lit::Int(_visitor.fold_lit_int(_binding_0)), + Lit::Float(_binding_0) => Lit::Float(_visitor.fold_lit_float(_binding_0)), + Lit::Bool(_binding_0) => Lit::Bool(_visitor.fold_lit_bool(_binding_0)), + Lit::Verbatim(_binding_0) => Lit::Verbatim(_visitor.fold_lit_verbatim(_binding_0)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit_bool<V: Fold + ?Sized>(_visitor: &mut V, _i: LitBool) -> LitBool { + LitBool { + value: _i.value, + span: _visitor.fold_span(_i.span), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit_byte<V: Fold + ?Sized>(_visitor: &mut V, _i: LitByte) -> LitByte { + let span = _visitor.fold_span(_i.span()); + let mut _i = _i; + _i.set_span(span); + _i +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit_byte_str<V: Fold + ?Sized>(_visitor: &mut V, _i: LitByteStr) -> LitByteStr { + let span = _visitor.fold_span(_i.span()); + let mut _i = _i; + _i.set_span(span); + _i +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit_char<V: Fold + ?Sized>(_visitor: &mut V, _i: LitChar) -> LitChar { + let span = _visitor.fold_span(_i.span()); + let mut _i = _i; + _i.set_span(span); + _i +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit_float<V: Fold + ?Sized>(_visitor: &mut V, _i: LitFloat) -> LitFloat { + let span = _visitor.fold_span(_i.span()); + let mut _i = _i; + _i.set_span(span); + _i +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit_int<V: Fold + ?Sized>(_visitor: &mut V, _i: LitInt) -> LitInt { + let span = _visitor.fold_span(_i.span()); + let mut _i = _i; + _i.set_span(span); + _i +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit_str<V: Fold + ?Sized>(_visitor: &mut V, _i: LitStr) -> LitStr { + let span = _visitor.fold_span(_i.span()); + let mut _i = _i; + _i.set_span(span); + _i +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_lit_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: LitVerbatim) -> LitVerbatim { + LitVerbatim { token: _i.token } +} +#[cfg(feature = "full")] +pub fn fold_local<V: Fold + ?Sized>(_visitor: &mut V, _i: Local) -> Local { + Local { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + let_token: Token), + pats: FoldHelper::lift(_i.pats, |it| _visitor.fold_pat(it)), + ty: (_i.ty).map(|it| { + ( + Token ! [ : ](tokens_helper(_visitor, &(it).0.spans)), + Box::new(_visitor.fold_type(*(it).1)), + ) + }), + init: (_i.init).map(|it| { + ( + Token ! [ = ](tokens_helper(_visitor, &(it).0.spans)), + Box::new(_visitor.fold_expr(*(it).1)), + ) + }), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: Macro) -> Macro { + Macro { + path: _visitor.fold_path(_i.path), + bang_token: Token), + delimiter: _visitor.fold_macro_delimiter(_i.delimiter), + tts: _i.tts, + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_macro_delimiter<V: Fold + ?Sized>( + _visitor: &mut V, + _i: MacroDelimiter, +) -> MacroDelimiter { + match _i { + MacroDelimiter::Paren(_binding_0) => { + MacroDelimiter::Paren(Paren(tokens_helper(_visitor, &_binding_0.span))) + } + MacroDelimiter::Brace(_binding_0) => { + MacroDelimiter::Brace(Brace(tokens_helper(_visitor, &_binding_0.span))) + } + MacroDelimiter::Bracket(_binding_0) => { + MacroDelimiter::Bracket(Bracket(tokens_helper(_visitor, &_binding_0.span))) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_member<V: Fold + ?Sized>(_visitor: &mut V, _i: Member) -> Member { + match _i { + Member::Named(_binding_0) => Member::Named(_visitor.fold_ident(_binding_0)), + Member::Unnamed(_binding_0) => Member::Unnamed(_visitor.fold_index(_binding_0)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_meta<V: Fold + ?Sized>(_visitor: &mut V, _i: Meta) -> Meta { + match _i { + Meta::Word(_binding_0) => Meta::Word(_visitor.fold_ident(_binding_0)), + Meta::List(_binding_0) => Meta::List(_visitor.fold_meta_list(_binding_0)), + Meta::NameValue(_binding_0) => Meta::NameValue(_visitor.fold_meta_name_value(_binding_0)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_meta_list<V: Fold + ?Sized>(_visitor: &mut V, _i: MetaList) -> MetaList { + MetaList { + ident: _visitor.fold_ident(_i.ident), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + nested: FoldHelper::lift(_i.nested, |it| _visitor.fold_nested_meta(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_meta_name_value<V: Fold + ?Sized>( + _visitor: &mut V, + _i: MetaNameValue, +) -> MetaNameValue { + MetaNameValue { + ident: _visitor.fold_ident(_i.ident), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + lit: _visitor.fold_lit(_i.lit), + } +} +#[cfg(feature = "full")] +pub fn fold_method_sig<V: Fold + ?Sized>(_visitor: &mut V, _i: MethodSig) -> MethodSig { + MethodSig { + constness: (_i.constness).map(|it| Token)), + asyncness: (_i.asyncness).map(|it| Token)), + unsafety: (_i.unsafety).map(|it| Token)), + abi: (_i.abi).map(|it| _visitor.fold_abi(it)), + ident: _visitor.fold_ident(_i.ident), + decl: _visitor.fold_fn_decl(_i.decl), + } +} +#[cfg(feature = "full")] +pub fn fold_method_turbofish<V: Fold + ?Sized>( + _visitor: &mut V, + _i: MethodTurbofish, +) -> MethodTurbofish { + MethodTurbofish { + colon2_token: Token ! [ :: ](tokens_helper(_visitor, &_i.colon2_token.spans)), + lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)), + args: FoldHelper::lift(_i.args, |it| _visitor.fold_generic_method_argument(it)), + gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_nested_meta<V: Fold + ?Sized>(_visitor: &mut V, _i: NestedMeta) -> NestedMeta { + match _i { + NestedMeta::Meta(_binding_0) => NestedMeta::Meta(_visitor.fold_meta(_binding_0)), + NestedMeta::Literal(_binding_0) => NestedMeta::Literal(_visitor.fold_lit(_binding_0)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_parenthesized_generic_arguments<V: Fold + ?Sized>( + _visitor: &mut V, + _i: ParenthesizedGenericArguments, +) -> ParenthesizedGenericArguments { + ParenthesizedGenericArguments { + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_type(it)), + output: _visitor.fold_return_type(_i.output), + } +} +#[cfg(feature = "full")] +pub fn fold_pat<V: Fold + ?Sized>(_visitor: &mut V, _i: Pat) -> Pat { + match _i { + Pat::Wild(_binding_0) => Pat::Wild(_visitor.fold_pat_wild(_binding_0)), + Pat::Ident(_binding_0) => Pat::Ident(_visitor.fold_pat_ident(_binding_0)), + Pat::Struct(_binding_0) => Pat::Struct(_visitor.fold_pat_struct(_binding_0)), + Pat::TupleStruct(_binding_0) => { + Pat::TupleStruct(_visitor.fold_pat_tuple_struct(_binding_0)) + } + Pat::Path(_binding_0) => Pat::Path(_visitor.fold_pat_path(_binding_0)), + Pat::Tuple(_binding_0) => Pat::Tuple(_visitor.fold_pat_tuple(_binding_0)), + Pat::Box(_binding_0) => Pat::Box(_visitor.fold_pat_box(_binding_0)), + Pat::Ref(_binding_0) => Pat::Ref(_visitor.fold_pat_ref(_binding_0)), + Pat::Lit(_binding_0) => Pat::Lit(_visitor.fold_pat_lit(_binding_0)), + Pat::Range(_binding_0) => Pat::Range(_visitor.fold_pat_range(_binding_0)), + Pat::Slice(_binding_0) => Pat::Slice(_visitor.fold_pat_slice(_binding_0)), + Pat::Macro(_binding_0) => Pat::Macro(_visitor.fold_pat_macro(_binding_0)), + Pat::Verbatim(_binding_0) => Pat::Verbatim(_visitor.fold_pat_verbatim(_binding_0)), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_box<V: Fold + ?Sized>(_visitor: &mut V, _i: PatBox) -> PatBox { + PatBox { + box_token: Token), + pat: Box::new(_visitor.fold_pat(*_i.pat)), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: PatIdent) -> PatIdent { + PatIdent { + by_ref: (_i.by_ref).map(|it| Token)), + mutability: (_i.mutability).map(|it| Token)), + ident: _visitor.fold_ident(_i.ident), + subpat: (_i.subpat).map(|it| { + ( + Token ! [ @ ](tokens_helper(_visitor, &(it).0.spans)), + Box::new(_visitor.fold_pat(*(it).1)), + ) + }), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_lit<V: Fold + ?Sized>(_visitor: &mut V, _i: PatLit) -> PatLit { + PatLit { + expr: Box::new(_visitor.fold_expr(*_i.expr)), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: PatMacro) -> PatMacro { + PatMacro { + mac: _visitor.fold_macro(_i.mac), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_path<V: Fold + ?Sized>(_visitor: &mut V, _i: PatPath) -> PatPath { + PatPath { + qself: (_i.qself).map(|it| _visitor.fold_qself(it)), + path: _visitor.fold_path(_i.path), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_range<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRange) -> PatRange { + PatRange { + lo: Box::new(_visitor.fold_expr(*_i.lo)), + limits: _visitor.fold_range_limits(_i.limits), + hi: Box::new(_visitor.fold_expr(*_i.hi)), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_ref<V: Fold + ?Sized>(_visitor: &mut V, _i: PatRef) -> PatRef { + PatRef { + and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)), + mutability: (_i.mutability).map(|it| Token)), + pat: Box::new(_visitor.fold_pat(*_i.pat)), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: PatSlice) -> PatSlice { + PatSlice { + bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)), + front: FoldHelper::lift(_i.front, |it| _visitor.fold_pat(it)), + middle: (_i.middle).map(|it| Box::new(_visitor.fold_pat(*it))), + dot2_token: (_i.dot2_token).map(|it| Token)), + comma_token: (_i.comma_token).map(|it| Token ! [ , ](tokens_helper(_visitor, &it.spans))), + back: FoldHelper::lift(_i.back, |it| _visitor.fold_pat(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_struct<V: Fold + ?Sized>(_visitor: &mut V, _i: PatStruct) -> PatStruct { + PatStruct { + path: _visitor.fold_path(_i.path), + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + fields: FoldHelper::lift(_i.fields, |it| _visitor.fold_field_pat(it)), + dot2_token: (_i.dot2_token).map(|it| Token)), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: PatTuple) -> PatTuple { + PatTuple { + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + front: FoldHelper::lift(_i.front, |it| _visitor.fold_pat(it)), + dot2_token: (_i.dot2_token).map(|it| Token)), + comma_token: (_i.comma_token).map(|it| Token ! [ , ](tokens_helper(_visitor, &it.spans))), + back: FoldHelper::lift(_i.back, |it| _visitor.fold_pat(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_tuple_struct<V: Fold + ?Sized>( + _visitor: &mut V, + _i: PatTupleStruct, +) -> PatTupleStruct { + PatTupleStruct { + path: _visitor.fold_path(_i.path), + pat: _visitor.fold_pat_tuple(_i.pat), + } +} +#[cfg(feature = "full")] +pub fn fold_pat_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: PatVerbatim) -> PatVerbatim { + PatVerbatim { tts: _i.tts } +} +#[cfg(feature = "full")] +pub fn fold_pat_wild<V: Fold + ?Sized>(_visitor: &mut V, _i: PatWild) -> PatWild { + PatWild { + underscore_token: Token), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_path<V: Fold + ?Sized>(_visitor: &mut V, _i: Path) -> Path { + Path { + leading_colon: (_i.leading_colon) + .map(|it| Token ! [ :: ](tokens_helper(_visitor, &it.spans))), + segments: FoldHelper::lift(_i.segments, |it| _visitor.fold_path_segment(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_path_arguments<V: Fold + ?Sized>(_visitor: &mut V, _i: PathArguments) -> PathArguments { + match _i { + PathArguments::None => PathArguments::None, + PathArguments::AngleBracketed(_binding_0) => PathArguments::AngleBracketed( + _visitor.fold_angle_bracketed_generic_arguments(_binding_0), + ), + PathArguments::Parenthesized(_binding_0) => { + PathArguments::Parenthesized(_visitor.fold_parenthesized_generic_arguments(_binding_0)) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_path_segment<V: Fold + ?Sized>(_visitor: &mut V, _i: PathSegment) -> PathSegment { + PathSegment { + ident: _visitor.fold_ident(_i.ident), + arguments: _visitor.fold_path_arguments(_i.arguments), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_predicate_eq<V: Fold + ?Sized>(_visitor: &mut V, _i: PredicateEq) -> PredicateEq { + PredicateEq { + lhs_ty: _visitor.fold_type(_i.lhs_ty), + eq_token: Token ! [ = ](tokens_helper(_visitor, &_i.eq_token.spans)), + rhs_ty: _visitor.fold_type(_i.rhs_ty), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_predicate_lifetime<V: Fold + ?Sized>( + _visitor: &mut V, + _i: PredicateLifetime, +) -> PredicateLifetime { + PredicateLifetime { + lifetime: _visitor.fold_lifetime(_i.lifetime), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_lifetime(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_predicate_type<V: Fold + ?Sized>(_visitor: &mut V, _i: PredicateType) -> PredicateType { + PredicateType { + lifetimes: (_i.lifetimes).map(|it| _visitor.fold_bound_lifetimes(it)), + bounded_ty: _visitor.fold_type(_i.bounded_ty), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_qself<V: Fold + ?Sized>(_visitor: &mut V, _i: QSelf) -> QSelf { + QSelf { + lt_token: Token ! [ < ](tokens_helper(_visitor, &_i.lt_token.spans)), + ty: Box::new(_visitor.fold_type(*_i.ty)), + position: _i.position, + as_token: (_i.as_token).map(|it| Token)), + gt_token: Token ! [ > ](tokens_helper(_visitor, &_i.gt_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_range_limits<V: Fold + ?Sized>(_visitor: &mut V, _i: RangeLimits) -> RangeLimits { + match _i { + RangeLimits::HalfOpen(_binding_0) => { + RangeLimits::HalfOpen(Token)) + } + RangeLimits::Closed(_binding_0) => { + RangeLimits::Closed(Token ! [ ..= ](tokens_helper(_visitor, &_binding_0.spans))) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_return_type<V: Fold + ?Sized>(_visitor: &mut V, _i: ReturnType) -> ReturnType { + match _i { + ReturnType::Default => ReturnType::Default, + ReturnType::Type(_binding_0, _binding_1) => ReturnType::Type( + Token ! [ -> ](tokens_helper(_visitor, &_binding_0.spans)), + Box::new(_visitor.fold_type(*_binding_1)), + ), + } +} +#[cfg(feature = "full")] +pub fn fold_stmt<V: Fold + ?Sized>(_visitor: &mut V, _i: Stmt) -> Stmt { + match _i { + Stmt::Local(_binding_0) => Stmt::Local(_visitor.fold_local(_binding_0)), + Stmt::Item(_binding_0) => Stmt::Item(_visitor.fold_item(_binding_0)), + Stmt::Expr(_binding_0) => Stmt::Expr(_visitor.fold_expr(_binding_0)), + Stmt::Semi(_binding_0, _binding_1) => Stmt::Semi( + _visitor.fold_expr(_binding_0), + Token ! [ ; ](tokens_helper(_visitor, &_binding_1.spans)), + ), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_trait_bound<V: Fold + ?Sized>(_visitor: &mut V, _i: TraitBound) -> TraitBound { + TraitBound { + paren_token: (_i.paren_token).map(|it| Paren(tokens_helper(_visitor, &it.span))), + modifier: _visitor.fold_trait_bound_modifier(_i.modifier), + lifetimes: (_i.lifetimes).map(|it| _visitor.fold_bound_lifetimes(it)), + path: _visitor.fold_path(_i.path), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_trait_bound_modifier<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TraitBoundModifier, +) -> TraitBoundModifier { + match _i { + TraitBoundModifier::None => TraitBoundModifier::None, + TraitBoundModifier::Maybe(_binding_0) => { + TraitBoundModifier::Maybe(Token ! [ ? ](tokens_helper(_visitor, &_binding_0.spans))) + } + } +} +#[cfg(feature = "full")] +pub fn fold_trait_item<V: Fold + ?Sized>(_visitor: &mut V, _i: TraitItem) -> TraitItem { + match _i { + TraitItem::Const(_binding_0) => { + TraitItem::Const(_visitor.fold_trait_item_const(_binding_0)) + } + TraitItem::Method(_binding_0) => { + TraitItem::Method(_visitor.fold_trait_item_method(_binding_0)) + } + TraitItem::Type(_binding_0) => TraitItem::Type(_visitor.fold_trait_item_type(_binding_0)), + TraitItem::Macro(_binding_0) => { + TraitItem::Macro(_visitor.fold_trait_item_macro(_binding_0)) + } + TraitItem::Verbatim(_binding_0) => { + TraitItem::Verbatim(_visitor.fold_trait_item_verbatim(_binding_0)) + } + } +} +#[cfg(feature = "full")] +pub fn fold_trait_item_const<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TraitItemConst, +) -> TraitItemConst { + TraitItemConst { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + const_token: Token), + ident: _visitor.fold_ident(_i.ident), + colon_token: Token ! [ : ](tokens_helper(_visitor, &_i.colon_token.spans)), + ty: _visitor.fold_type(_i.ty), + default: (_i.default).map(|it| { + ( + Token ! [ = ](tokens_helper(_visitor, &(it).0.spans)), + _visitor.fold_expr((it).1), + ) + }), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_trait_item_macro<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TraitItemMacro, +) -> TraitItemMacro { + TraitItemMacro { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + mac: _visitor.fold_macro(_i.mac), + semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(feature = "full")] +pub fn fold_trait_item_method<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TraitItemMethod, +) -> TraitItemMethod { + TraitItemMethod { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + sig: _visitor.fold_method_sig(_i.sig), + default: (_i.default).map(|it| _visitor.fold_block(it)), + semi_token: (_i.semi_token).map(|it| Token ! [ ; ](tokens_helper(_visitor, &it.spans))), + } +} +#[cfg(feature = "full")] +pub fn fold_trait_item_type<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TraitItemType, +) -> TraitItemType { + TraitItemType { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + type_token: Token), + ident: _visitor.fold_ident(_i.ident), + generics: _visitor.fold_generics(_i.generics), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + default: (_i.default).map(|it| { + ( + Token ! [ = ](tokens_helper(_visitor, &(it).0.spans)), + _visitor.fold_type((it).1), + ) + }), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_trait_item_verbatim<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TraitItemVerbatim, +) -> TraitItemVerbatim { + TraitItemVerbatim { tts: _i.tts } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type<V: Fold + ?Sized>(_visitor: &mut V, _i: Type) -> Type { + match _i { + Type::Slice(_binding_0) => Type::Slice(_visitor.fold_type_slice(_binding_0)), + Type::Array(_binding_0) => Type::Array(_visitor.fold_type_array(_binding_0)), + Type::Ptr(_binding_0) => Type::Ptr(_visitor.fold_type_ptr(_binding_0)), + Type::Reference(_binding_0) => Type::Reference(_visitor.fold_type_reference(_binding_0)), + Type::BareFn(_binding_0) => Type::BareFn(_visitor.fold_type_bare_fn(_binding_0)), + Type::Never(_binding_0) => Type::Never(_visitor.fold_type_never(_binding_0)), + Type::Tuple(_binding_0) => Type::Tuple(_visitor.fold_type_tuple(_binding_0)), + Type::Path(_binding_0) => Type::Path(_visitor.fold_type_path(_binding_0)), + Type::TraitObject(_binding_0) => { + Type::TraitObject(_visitor.fold_type_trait_object(_binding_0)) + } + Type::ImplTrait(_binding_0) => Type::ImplTrait(_visitor.fold_type_impl_trait(_binding_0)), + Type::Paren(_binding_0) => Type::Paren(_visitor.fold_type_paren(_binding_0)), + Type::Group(_binding_0) => Type::Group(_visitor.fold_type_group(_binding_0)), + Type::Infer(_binding_0) => Type::Infer(_visitor.fold_type_infer(_binding_0)), + Type::Macro(_binding_0) => Type::Macro(_visitor.fold_type_macro(_binding_0)), + Type::Verbatim(_binding_0) => Type::Verbatim(_visitor.fold_type_verbatim(_binding_0)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_array<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeArray) -> TypeArray { + TypeArray { + bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)), + elem: Box::new(_visitor.fold_type(*_i.elem)), + semi_token: Token ! [ ; ](tokens_helper(_visitor, &_i.semi_token.spans)), + len: _visitor.fold_expr(_i.len), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_bare_fn<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeBareFn) -> TypeBareFn { + TypeBareFn { + lifetimes: (_i.lifetimes).map(|it| _visitor.fold_bound_lifetimes(it)), + unsafety: (_i.unsafety).map(|it| Token)), + abi: (_i.abi).map(|it| _visitor.fold_abi(it)), + fn_token: Token), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + inputs: FoldHelper::lift(_i.inputs, |it| _visitor.fold_bare_fn_arg(it)), + variadic: (_i.variadic).map(|it| Token ! [ ... ](tokens_helper(_visitor, &it.spans))), + output: _visitor.fold_return_type(_i.output), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_group<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeGroup) -> TypeGroup { + TypeGroup { + group_token: Group(tokens_helper(_visitor, &_i.group_token.span)), + elem: Box::new(_visitor.fold_type(*_i.elem)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_impl_trait<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TypeImplTrait, +) -> TypeImplTrait { + TypeImplTrait { + impl_token: Token), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_infer<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeInfer) -> TypeInfer { + TypeInfer { + underscore_token: Token), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_macro<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeMacro) -> TypeMacro { + TypeMacro { + mac: _visitor.fold_macro(_i.mac), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_never<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeNever) -> TypeNever { + TypeNever { + bang_token: Token), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_param<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeParam) -> TypeParam { + TypeParam { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + ident: _visitor.fold_ident(_i.ident), + colon_token: (_i.colon_token).map(|it| Token ! [ : ](tokens_helper(_visitor, &it.spans))), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + eq_token: (_i.eq_token).map(|it| Token ! [ = ](tokens_helper(_visitor, &it.spans))), + default: (_i.default).map(|it| _visitor.fold_type(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_param_bound<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TypeParamBound, +) -> TypeParamBound { + match _i { + TypeParamBound::Trait(_binding_0) => { + TypeParamBound::Trait(_visitor.fold_trait_bound(_binding_0)) + } + TypeParamBound::Lifetime(_binding_0) => { + TypeParamBound::Lifetime(_visitor.fold_lifetime(_binding_0)) + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_paren<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeParen) -> TypeParen { + TypeParen { + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + elem: Box::new(_visitor.fold_type(*_i.elem)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_path<V: Fold + ?Sized>(_visitor: &mut V, _i: TypePath) -> TypePath { + TypePath { + qself: (_i.qself).map(|it| _visitor.fold_qself(it)), + path: _visitor.fold_path(_i.path), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_ptr<V: Fold + ?Sized>(_visitor: &mut V, _i: TypePtr) -> TypePtr { + TypePtr { + star_token: Token ! [ * ](tokens_helper(_visitor, &_i.star_token.spans)), + const_token: (_i.const_token).map(|it| Token)), + mutability: (_i.mutability).map(|it| Token)), + elem: Box::new(_visitor.fold_type(*_i.elem)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_reference<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeReference) -> TypeReference { + TypeReference { + and_token: Token ! [ & ](tokens_helper(_visitor, &_i.and_token.spans)), + lifetime: (_i.lifetime).map(|it| _visitor.fold_lifetime(it)), + mutability: (_i.mutability).map(|it| Token)), + elem: Box::new(_visitor.fold_type(*_i.elem)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_slice<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeSlice) -> TypeSlice { + TypeSlice { + bracket_token: Bracket(tokens_helper(_visitor, &_i.bracket_token.span)), + elem: Box::new(_visitor.fold_type(*_i.elem)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_trait_object<V: Fold + ?Sized>( + _visitor: &mut V, + _i: TypeTraitObject, +) -> TypeTraitObject { + TypeTraitObject { + dyn_token: (_i.dyn_token).map(|it| Token)), + bounds: FoldHelper::lift(_i.bounds, |it| _visitor.fold_type_param_bound(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_tuple<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeTuple) -> TypeTuple { + TypeTuple { + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + elems: FoldHelper::lift(_i.elems, |it| _visitor.fold_type(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_type_verbatim<V: Fold + ?Sized>(_visitor: &mut V, _i: TypeVerbatim) -> TypeVerbatim { + TypeVerbatim { tts: _i.tts } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_un_op<V: Fold + ?Sized>(_visitor: &mut V, _i: UnOp) -> UnOp { + match _i { + UnOp::Deref(_binding_0) => { + UnOp::Deref(Token ! [ * ](tokens_helper(_visitor, &_binding_0.spans))) + } + UnOp::Not(_binding_0) => UnOp::Not(Token)), + UnOp::Neg(_binding_0) => { + UnOp::Neg(Token ! [ - ](tokens_helper(_visitor, &_binding_0.spans))) + } + } +} +#[cfg(feature = "full")] +pub fn fold_use_glob<V: Fold + ?Sized>(_visitor: &mut V, _i: UseGlob) -> UseGlob { + UseGlob { + star_token: Token ! [ * ](tokens_helper(_visitor, &_i.star_token.spans)), + } +} +#[cfg(feature = "full")] +pub fn fold_use_group<V: Fold + ?Sized>(_visitor: &mut V, _i: UseGroup) -> UseGroup { + UseGroup { + brace_token: Brace(tokens_helper(_visitor, &_i.brace_token.span)), + items: FoldHelper::lift(_i.items, |it| _visitor.fold_use_tree(it)), + } +} +#[cfg(feature = "full")] +pub fn fold_use_name<V: Fold + ?Sized>(_visitor: &mut V, _i: UseName) -> UseName { + UseName { + ident: _visitor.fold_ident(_i.ident), + } +} +#[cfg(feature = "full")] +pub fn fold_use_path<V: Fold + ?Sized>(_visitor: &mut V, _i: UsePath) -> UsePath { + UsePath { + ident: _visitor.fold_ident(_i.ident), + colon2_token: Token ! [ :: ](tokens_helper(_visitor, &_i.colon2_token.spans)), + tree: Box::new(_visitor.fold_use_tree(*_i.tree)), + } +} +#[cfg(feature = "full")] +pub fn fold_use_rename<V: Fold + ?Sized>(_visitor: &mut V, _i: UseRename) -> UseRename { + UseRename { + ident: _visitor.fold_ident(_i.ident), + as_token: Token), + rename: _visitor.fold_ident(_i.rename), + } +} +#[cfg(feature = "full")] +pub fn fold_use_tree<V: Fold + ?Sized>(_visitor: &mut V, _i: UseTree) -> UseTree { + match _i { + UseTree::Path(_binding_0) => UseTree::Path(_visitor.fold_use_path(_binding_0)), + UseTree::Name(_binding_0) => UseTree::Name(_visitor.fold_use_name(_binding_0)), + UseTree::Rename(_binding_0) => UseTree::Rename(_visitor.fold_use_rename(_binding_0)), + UseTree::Glob(_binding_0) => UseTree::Glob(_visitor.fold_use_glob(_binding_0)), + UseTree::Group(_binding_0) => UseTree::Group(_visitor.fold_use_group(_binding_0)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_variant<V: Fold + ?Sized>(_visitor: &mut V, _i: Variant) -> Variant { + Variant { + attrs: FoldHelper::lift(_i.attrs, |it| _visitor.fold_attribute(it)), + ident: _visitor.fold_ident(_i.ident), + fields: _visitor.fold_fields(_i.fields), + discriminant: (_i.discriminant).map(|it| { + ( + Token ! [ = ](tokens_helper(_visitor, &(it).0.spans)), + _visitor.fold_expr((it).1), + ) + }), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_vis_crate<V: Fold + ?Sized>(_visitor: &mut V, _i: VisCrate) -> VisCrate { + VisCrate { + crate_token: Token), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_vis_public<V: Fold + ?Sized>(_visitor: &mut V, _i: VisPublic) -> VisPublic { + VisPublic { + pub_token: Token), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_vis_restricted<V: Fold + ?Sized>(_visitor: &mut V, _i: VisRestricted) -> VisRestricted { + VisRestricted { + pub_token: Token), + paren_token: Paren(tokens_helper(_visitor, &_i.paren_token.span)), + in_token: (_i.in_token).map(|it| Token)), + path: Box::new(_visitor.fold_path(*_i.path)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_visibility<V: Fold + ?Sized>(_visitor: &mut V, _i: Visibility) -> Visibility { + match _i { + Visibility::Public(_binding_0) => Visibility::Public(_visitor.fold_vis_public(_binding_0)), + Visibility::Crate(_binding_0) => Visibility::Crate(_visitor.fold_vis_crate(_binding_0)), + Visibility::Restricted(_binding_0) => { + Visibility::Restricted(_visitor.fold_vis_restricted(_binding_0)) + } + Visibility::Inherited => Visibility::Inherited, + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_where_clause<V: Fold + ?Sized>(_visitor: &mut V, _i: WhereClause) -> WhereClause { + WhereClause { + where_token: Token), + predicates: FoldHelper::lift(_i.predicates, |it| _visitor.fold_where_predicate(it)), + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn fold_where_predicate<V: Fold + ?Sized>( + _visitor: &mut V, + _i: WherePredicate, +) -> WherePredicate { + match _i { + WherePredicate::Type(_binding_0) => { + WherePredicate::Type(_visitor.fold_predicate_type(_binding_0)) + } + WherePredicate::Lifetime(_binding_0) => { + WherePredicate::Lifetime(_visitor.fold_predicate_lifetime(_binding_0)) + } + WherePredicate::Eq(_binding_0) => { + WherePredicate::Eq(_visitor.fold_predicate_eq(_binding_0)) + } + } +} +pub fn fold_span<V: Fold + ?Sized>(_visitor: &mut V, _i: Span) -> Span { + _i +} +pub fn fold_ident<V: Fold + ?Sized>(_visitor: &mut V, _i: Ident) -> Ident { + let mut _i = _i; + let span = _visitor.fold_span(_i.span()); + _i.set_span(span); + _i +} diff --git a/rust/vendor/syn-0.15.44/src/gen/visit.rs b/rust/vendor/syn-0.15.44/src/gen/visit.rs new file mode 100644 index 0000000..3c551ff --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/gen/visit.rs @@ -0,0 +1,3372 @@ +// This file is @generated by syn-internal-codegen. +// It is not intended for manual editing. + +#![cfg_attr(feature = "cargo-clippy", allow(trivially_copy_pass_by_ref))] +#[cfg(any(feature = "full", feature = "derive"))] +use gen::helper::visit::*; +use proc_macro2::Span; +#[cfg(any(feature = "full", feature = "derive"))] +use punctuated::Punctuated; +use *; +#[cfg(feature = "full")] +macro_rules! full { + ($e:expr) => { + $e + }; +} +#[cfg(all(feature = "derive", not(feature = "full")))] +macro_rules! full { + ($e:expr) => { + unreachable!() + }; +} +#[cfg(any(feature = "full", feature = "derive"))] +macro_rules! skip { + ($($tt:tt)*) => {}; +} +/// Syntax tree traversal to walk a shared borrow of a syntax tree. +/// +/// See the [module documentation] for details. +/// +/// [module documentation]: self +/// +/// *This trait is available if Syn is built with the `"visit"` feature.* +pub trait Visit<'ast> { + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_abi(&mut self, i: &'ast Abi) { + visit_abi(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_angle_bracketed_generic_arguments(&mut self, i: &'ast AngleBracketedGenericArguments) { + visit_angle_bracketed_generic_arguments(self, i) + } + #[cfg(feature = "full")] + fn visit_arg_captured(&mut self, i: &'ast ArgCaptured) { + visit_arg_captured(self, i) + } + #[cfg(feature = "full")] + fn visit_arg_self(&mut self, i: &'ast ArgSelf) { + visit_arg_self(self, i) + } + #[cfg(feature = "full")] + fn visit_arg_self_ref(&mut self, i: &'ast ArgSelfRef) { + visit_arg_self_ref(self, i) + } + #[cfg(feature = "full")] + fn visit_arm(&mut self, i: &'ast Arm) { + visit_arm(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_attr_style(&mut self, i: &'ast AttrStyle) { + visit_attr_style(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_attribute(&mut self, i: &'ast Attribute) { + visit_attribute(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_bare_fn_arg(&mut self, i: &'ast BareFnArg) { + visit_bare_fn_arg(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_bare_fn_arg_name(&mut self, i: &'ast BareFnArgName) { + visit_bare_fn_arg_name(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_bin_op(&mut self, i: &'ast BinOp) { + visit_bin_op(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_binding(&mut self, i: &'ast Binding) { + visit_binding(self, i) + } + #[cfg(feature = "full")] + fn visit_block(&mut self, i: &'ast Block) { + visit_block(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_bound_lifetimes(&mut self, i: &'ast BoundLifetimes) { + visit_bound_lifetimes(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_const_param(&mut self, i: &'ast ConstParam) { + visit_const_param(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_constraint(&mut self, i: &'ast Constraint) { + visit_constraint(self, i) + } + #[cfg(feature = "derive")] + fn visit_data(&mut self, i: &'ast Data) { + visit_data(self, i) + } + #[cfg(feature = "derive")] + fn visit_data_enum(&mut self, i: &'ast DataEnum) { + visit_data_enum(self, i) + } + #[cfg(feature = "derive")] + fn visit_data_struct(&mut self, i: &'ast DataStruct) { + visit_data_struct(self, i) + } + #[cfg(feature = "derive")] + fn visit_data_union(&mut self, i: &'ast DataUnion) { + visit_data_union(self, i) + } + #[cfg(feature = "derive")] + fn visit_derive_input(&mut self, i: &'ast DeriveInput) { + visit_derive_input(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr(&mut self, i: &'ast Expr) { + visit_expr(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_array(&mut self, i: &'ast ExprArray) { + visit_expr_array(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_assign(&mut self, i: &'ast ExprAssign) { + visit_expr_assign(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_assign_op(&mut self, i: &'ast ExprAssignOp) { + visit_expr_assign_op(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_async(&mut self, i: &'ast ExprAsync) { + visit_expr_async(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_binary(&mut self, i: &'ast ExprBinary) { + visit_expr_binary(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_block(&mut self, i: &'ast ExprBlock) { + visit_expr_block(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_box(&mut self, i: &'ast ExprBox) { + visit_expr_box(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_break(&mut self, i: &'ast ExprBreak) { + visit_expr_break(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_call(&mut self, i: &'ast ExprCall) { + visit_expr_call(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_cast(&mut self, i: &'ast ExprCast) { + visit_expr_cast(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_closure(&mut self, i: &'ast ExprClosure) { + visit_expr_closure(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_continue(&mut self, i: &'ast ExprContinue) { + visit_expr_continue(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_field(&mut self, i: &'ast ExprField) { + visit_expr_field(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_for_loop(&mut self, i: &'ast ExprForLoop) { + visit_expr_for_loop(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_group(&mut self, i: &'ast ExprGroup) { + visit_expr_group(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_if(&mut self, i: &'ast ExprIf) { + visit_expr_if(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_in_place(&mut self, i: &'ast ExprInPlace) { + visit_expr_in_place(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_index(&mut self, i: &'ast ExprIndex) { + visit_expr_index(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_let(&mut self, i: &'ast ExprLet) { + visit_expr_let(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_lit(&mut self, i: &'ast ExprLit) { + visit_expr_lit(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_loop(&mut self, i: &'ast ExprLoop) { + visit_expr_loop(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_macro(&mut self, i: &'ast ExprMacro) { + visit_expr_macro(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_match(&mut self, i: &'ast ExprMatch) { + visit_expr_match(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_method_call(&mut self, i: &'ast ExprMethodCall) { + visit_expr_method_call(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_paren(&mut self, i: &'ast ExprParen) { + visit_expr_paren(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_path(&mut self, i: &'ast ExprPath) { + visit_expr_path(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_range(&mut self, i: &'ast ExprRange) { + visit_expr_range(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_reference(&mut self, i: &'ast ExprReference) { + visit_expr_reference(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_repeat(&mut self, i: &'ast ExprRepeat) { + visit_expr_repeat(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_return(&mut self, i: &'ast ExprReturn) { + visit_expr_return(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_struct(&mut self, i: &'ast ExprStruct) { + visit_expr_struct(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_try(&mut self, i: &'ast ExprTry) { + visit_expr_try(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_try_block(&mut self, i: &'ast ExprTryBlock) { + visit_expr_try_block(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_tuple(&mut self, i: &'ast ExprTuple) { + visit_expr_tuple(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_type(&mut self, i: &'ast ExprType) { + visit_expr_type(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_unary(&mut self, i: &'ast ExprUnary) { + visit_expr_unary(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_unsafe(&mut self, i: &'ast ExprUnsafe) { + visit_expr_unsafe(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_verbatim(&mut self, i: &'ast ExprVerbatim) { + visit_expr_verbatim(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_while(&mut self, i: &'ast ExprWhile) { + visit_expr_while(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_yield(&mut self, i: &'ast ExprYield) { + visit_expr_yield(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_field(&mut self, i: &'ast Field) { + visit_field(self, i) + } + #[cfg(feature = "full")] + fn visit_field_pat(&mut self, i: &'ast FieldPat) { + visit_field_pat(self, i) + } + #[cfg(feature = "full")] + fn visit_field_value(&mut self, i: &'ast FieldValue) { + visit_field_value(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_fields(&mut self, i: &'ast Fields) { + visit_fields(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_fields_named(&mut self, i: &'ast FieldsNamed) { + visit_fields_named(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_fields_unnamed(&mut self, i: &'ast FieldsUnnamed) { + visit_fields_unnamed(self, i) + } + #[cfg(feature = "full")] + fn visit_file(&mut self, i: &'ast File) { + visit_file(self, i) + } + #[cfg(feature = "full")] + fn visit_fn_arg(&mut self, i: &'ast FnArg) { + visit_fn_arg(self, i) + } + #[cfg(feature = "full")] + fn visit_fn_decl(&mut self, i: &'ast FnDecl) { + visit_fn_decl(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item(&mut self, i: &'ast ForeignItem) { + visit_foreign_item(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_fn(&mut self, i: &'ast ForeignItemFn) { + visit_foreign_item_fn(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_macro(&mut self, i: &'ast ForeignItemMacro) { + visit_foreign_item_macro(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_static(&mut self, i: &'ast ForeignItemStatic) { + visit_foreign_item_static(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_type(&mut self, i: &'ast ForeignItemType) { + visit_foreign_item_type(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_verbatim(&mut self, i: &'ast ForeignItemVerbatim) { + visit_foreign_item_verbatim(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_generic_argument(&mut self, i: &'ast GenericArgument) { + visit_generic_argument(self, i) + } + #[cfg(feature = "full")] + fn visit_generic_method_argument(&mut self, i: &'ast GenericMethodArgument) { + visit_generic_method_argument(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_generic_param(&mut self, i: &'ast GenericParam) { + visit_generic_param(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_generics(&mut self, i: &'ast Generics) { + visit_generics(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item(&mut self, i: &'ast ImplItem) { + visit_impl_item(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_const(&mut self, i: &'ast ImplItemConst) { + visit_impl_item_const(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_existential(&mut self, i: &'ast ImplItemExistential) { + visit_impl_item_existential(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_macro(&mut self, i: &'ast ImplItemMacro) { + visit_impl_item_macro(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_method(&mut self, i: &'ast ImplItemMethod) { + visit_impl_item_method(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_type(&mut self, i: &'ast ImplItemType) { + visit_impl_item_type(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_verbatim(&mut self, i: &'ast ImplItemVerbatim) { + visit_impl_item_verbatim(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_index(&mut self, i: &'ast Index) { + visit_index(self, i) + } + #[cfg(feature = "full")] + fn visit_item(&mut self, i: &'ast Item) { + visit_item(self, i) + } + #[cfg(feature = "full")] + fn visit_item_const(&mut self, i: &'ast ItemConst) { + visit_item_const(self, i) + } + #[cfg(feature = "full")] + fn visit_item_enum(&mut self, i: &'ast ItemEnum) { + visit_item_enum(self, i) + } + #[cfg(feature = "full")] + fn visit_item_existential(&mut self, i: &'ast ItemExistential) { + visit_item_existential(self, i) + } + #[cfg(feature = "full")] + fn visit_item_extern_crate(&mut self, i: &'ast ItemExternCrate) { + visit_item_extern_crate(self, i) + } + #[cfg(feature = "full")] + fn visit_item_fn(&mut self, i: &'ast ItemFn) { + visit_item_fn(self, i) + } + #[cfg(feature = "full")] + fn visit_item_foreign_mod(&mut self, i: &'ast ItemForeignMod) { + visit_item_foreign_mod(self, i) + } + #[cfg(feature = "full")] + fn visit_item_impl(&mut self, i: &'ast ItemImpl) { + visit_item_impl(self, i) + } + #[cfg(feature = "full")] + fn visit_item_macro(&mut self, i: &'ast ItemMacro) { + visit_item_macro(self, i) + } + #[cfg(feature = "full")] + fn visit_item_macro2(&mut self, i: &'ast ItemMacro2) { + visit_item_macro2(self, i) + } + #[cfg(feature = "full")] + fn visit_item_mod(&mut self, i: &'ast ItemMod) { + visit_item_mod(self, i) + } + #[cfg(feature = "full")] + fn visit_item_static(&mut self, i: &'ast ItemStatic) { + visit_item_static(self, i) + } + #[cfg(feature = "full")] + fn visit_item_struct(&mut self, i: &'ast ItemStruct) { + visit_item_struct(self, i) + } + #[cfg(feature = "full")] + fn visit_item_trait(&mut self, i: &'ast ItemTrait) { + visit_item_trait(self, i) + } + #[cfg(feature = "full")] + fn visit_item_trait_alias(&mut self, i: &'ast ItemTraitAlias) { + visit_item_trait_alias(self, i) + } + #[cfg(feature = "full")] + fn visit_item_type(&mut self, i: &'ast ItemType) { + visit_item_type(self, i) + } + #[cfg(feature = "full")] + fn visit_item_union(&mut self, i: &'ast ItemUnion) { + visit_item_union(self, i) + } + #[cfg(feature = "full")] + fn visit_item_use(&mut self, i: &'ast ItemUse) { + visit_item_use(self, i) + } + #[cfg(feature = "full")] + fn visit_item_verbatim(&mut self, i: &'ast ItemVerbatim) { + visit_item_verbatim(self, i) + } + #[cfg(feature = "full")] + fn visit_label(&mut self, i: &'ast Label) { + visit_label(self, i) + } + fn visit_lifetime(&mut self, i: &'ast Lifetime) { + visit_lifetime(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lifetime_def(&mut self, i: &'ast LifetimeDef) { + visit_lifetime_def(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit(&mut self, i: &'ast Lit) { + visit_lit(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_bool(&mut self, i: &'ast LitBool) { + visit_lit_bool(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_byte(&mut self, i: &'ast LitByte) { + visit_lit_byte(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_byte_str(&mut self, i: &'ast LitByteStr) { + visit_lit_byte_str(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_char(&mut self, i: &'ast LitChar) { + visit_lit_char(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_float(&mut self, i: &'ast LitFloat) { + visit_lit_float(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_int(&mut self, i: &'ast LitInt) { + visit_lit_int(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_str(&mut self, i: &'ast LitStr) { + visit_lit_str(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_verbatim(&mut self, i: &'ast LitVerbatim) { + visit_lit_verbatim(self, i) + } + #[cfg(feature = "full")] + fn visit_local(&mut self, i: &'ast Local) { + visit_local(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_macro(&mut self, i: &'ast Macro) { + visit_macro(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_macro_delimiter(&mut self, i: &'ast MacroDelimiter) { + visit_macro_delimiter(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_member(&mut self, i: &'ast Member) { + visit_member(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_meta(&mut self, i: &'ast Meta) { + visit_meta(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_meta_list(&mut self, i: &'ast MetaList) { + visit_meta_list(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_meta_name_value(&mut self, i: &'ast MetaNameValue) { + visit_meta_name_value(self, i) + } + #[cfg(feature = "full")] + fn visit_method_sig(&mut self, i: &'ast MethodSig) { + visit_method_sig(self, i) + } + #[cfg(feature = "full")] + fn visit_method_turbofish(&mut self, i: &'ast MethodTurbofish) { + visit_method_turbofish(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_nested_meta(&mut self, i: &'ast NestedMeta) { + visit_nested_meta(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_parenthesized_generic_arguments(&mut self, i: &'ast ParenthesizedGenericArguments) { + visit_parenthesized_generic_arguments(self, i) + } + #[cfg(feature = "full")] + fn visit_pat(&mut self, i: &'ast Pat) { + visit_pat(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_box(&mut self, i: &'ast PatBox) { + visit_pat_box(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_ident(&mut self, i: &'ast PatIdent) { + visit_pat_ident(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_lit(&mut self, i: &'ast PatLit) { + visit_pat_lit(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_macro(&mut self, i: &'ast PatMacro) { + visit_pat_macro(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_path(&mut self, i: &'ast PatPath) { + visit_pat_path(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_range(&mut self, i: &'ast PatRange) { + visit_pat_range(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_ref(&mut self, i: &'ast PatRef) { + visit_pat_ref(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_slice(&mut self, i: &'ast PatSlice) { + visit_pat_slice(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_struct(&mut self, i: &'ast PatStruct) { + visit_pat_struct(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_tuple(&mut self, i: &'ast PatTuple) { + visit_pat_tuple(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_tuple_struct(&mut self, i: &'ast PatTupleStruct) { + visit_pat_tuple_struct(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_verbatim(&mut self, i: &'ast PatVerbatim) { + visit_pat_verbatim(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_wild(&mut self, i: &'ast PatWild) { + visit_pat_wild(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_path(&mut self, i: &'ast Path) { + visit_path(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_path_arguments(&mut self, i: &'ast PathArguments) { + visit_path_arguments(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_path_segment(&mut self, i: &'ast PathSegment) { + visit_path_segment(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_predicate_eq(&mut self, i: &'ast PredicateEq) { + visit_predicate_eq(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_predicate_lifetime(&mut self, i: &'ast PredicateLifetime) { + visit_predicate_lifetime(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_predicate_type(&mut self, i: &'ast PredicateType) { + visit_predicate_type(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_qself(&mut self, i: &'ast QSelf) { + visit_qself(self, i) + } + #[cfg(feature = "full")] + fn visit_range_limits(&mut self, i: &'ast RangeLimits) { + visit_range_limits(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_return_type(&mut self, i: &'ast ReturnType) { + visit_return_type(self, i) + } + #[cfg(feature = "full")] + fn visit_stmt(&mut self, i: &'ast Stmt) { + visit_stmt(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_trait_bound(&mut self, i: &'ast TraitBound) { + visit_trait_bound(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_trait_bound_modifier(&mut self, i: &'ast TraitBoundModifier) { + visit_trait_bound_modifier(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item(&mut self, i: &'ast TraitItem) { + visit_trait_item(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_const(&mut self, i: &'ast TraitItemConst) { + visit_trait_item_const(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_macro(&mut self, i: &'ast TraitItemMacro) { + visit_trait_item_macro(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_method(&mut self, i: &'ast TraitItemMethod) { + visit_trait_item_method(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_type(&mut self, i: &'ast TraitItemType) { + visit_trait_item_type(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_verbatim(&mut self, i: &'ast TraitItemVerbatim) { + visit_trait_item_verbatim(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type(&mut self, i: &'ast Type) { + visit_type(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_array(&mut self, i: &'ast TypeArray) { + visit_type_array(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_bare_fn(&mut self, i: &'ast TypeBareFn) { + visit_type_bare_fn(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_group(&mut self, i: &'ast TypeGroup) { + visit_type_group(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_impl_trait(&mut self, i: &'ast TypeImplTrait) { + visit_type_impl_trait(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_infer(&mut self, i: &'ast TypeInfer) { + visit_type_infer(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_macro(&mut self, i: &'ast TypeMacro) { + visit_type_macro(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_never(&mut self, i: &'ast TypeNever) { + visit_type_never(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_param(&mut self, i: &'ast TypeParam) { + visit_type_param(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_param_bound(&mut self, i: &'ast TypeParamBound) { + visit_type_param_bound(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_paren(&mut self, i: &'ast TypeParen) { + visit_type_paren(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_path(&mut self, i: &'ast TypePath) { + visit_type_path(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_ptr(&mut self, i: &'ast TypePtr) { + visit_type_ptr(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_reference(&mut self, i: &'ast TypeReference) { + visit_type_reference(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_slice(&mut self, i: &'ast TypeSlice) { + visit_type_slice(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_trait_object(&mut self, i: &'ast TypeTraitObject) { + visit_type_trait_object(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_tuple(&mut self, i: &'ast TypeTuple) { + visit_type_tuple(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_verbatim(&mut self, i: &'ast TypeVerbatim) { + visit_type_verbatim(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_un_op(&mut self, i: &'ast UnOp) { + visit_un_op(self, i) + } + #[cfg(feature = "full")] + fn visit_use_glob(&mut self, i: &'ast UseGlob) { + visit_use_glob(self, i) + } + #[cfg(feature = "full")] + fn visit_use_group(&mut self, i: &'ast UseGroup) { + visit_use_group(self, i) + } + #[cfg(feature = "full")] + fn visit_use_name(&mut self, i: &'ast UseName) { + visit_use_name(self, i) + } + #[cfg(feature = "full")] + fn visit_use_path(&mut self, i: &'ast UsePath) { + visit_use_path(self, i) + } + #[cfg(feature = "full")] + fn visit_use_rename(&mut self, i: &'ast UseRename) { + visit_use_rename(self, i) + } + #[cfg(feature = "full")] + fn visit_use_tree(&mut self, i: &'ast UseTree) { + visit_use_tree(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_variant(&mut self, i: &'ast Variant) { + visit_variant(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_vis_crate(&mut self, i: &'ast VisCrate) { + visit_vis_crate(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_vis_public(&mut self, i: &'ast VisPublic) { + visit_vis_public(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_vis_restricted(&mut self, i: &'ast VisRestricted) { + visit_vis_restricted(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_visibility(&mut self, i: &'ast Visibility) { + visit_visibility(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_where_clause(&mut self, i: &'ast WhereClause) { + visit_where_clause(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_where_predicate(&mut self, i: &'ast WherePredicate) { + visit_where_predicate(self, i) + } + fn visit_span(&mut self, i: &'ast Span) { + visit_span(self, i) + } + fn visit_ident(&mut self, i: &'ast Ident) { + visit_ident(self, i) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_abi<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Abi) { + tokens_helper(_visitor, &_i.extern_token.span); + if let Some(ref it) = _i.name { + _visitor.visit_lit_str(it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_angle_bracketed_generic_arguments<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast AngleBracketedGenericArguments, +) { + if let Some(ref it) = _i.colon2_token { + tokens_helper(_visitor, &it.spans) + }; + tokens_helper(_visitor, &_i.lt_token.spans); + for el in Punctuated::pairs(&_i.args) { + let it = el.value(); + _visitor.visit_generic_argument(it) + } + tokens_helper(_visitor, &_i.gt_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_arg_captured<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgCaptured) { + _visitor.visit_pat(&_i.pat); + tokens_helper(_visitor, &_i.colon_token.spans); + _visitor.visit_type(&_i.ty); +} +#[cfg(feature = "full")] +pub fn visit_arg_self<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgSelf) { + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + tokens_helper(_visitor, &_i.self_token.span); +} +#[cfg(feature = "full")] +pub fn visit_arg_self_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ArgSelfRef) { + tokens_helper(_visitor, &_i.and_token.spans); + if let Some(ref it) = _i.lifetime { + _visitor.visit_lifetime(it) + }; + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + tokens_helper(_visitor, &_i.self_token.span); +} +#[cfg(feature = "full")] +pub fn visit_arm<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Arm) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.leading_vert { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.pats) { + let it = el.value(); + _visitor.visit_pat(it) + } + if let Some(ref it) = _i.guard { + tokens_helper(_visitor, &(it).0.span); + _visitor.visit_expr(&*(it).1); + }; + tokens_helper(_visitor, &_i.fat_arrow_token.spans); + _visitor.visit_expr(&*_i.body); + if let Some(ref it) = _i.comma { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_attr_style<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast AttrStyle) { + match *_i { + AttrStyle::Outer => {} + AttrStyle::Inner(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_attribute<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Attribute) { + tokens_helper(_visitor, &_i.pound_token.spans); + _visitor.visit_attr_style(&_i.style); + tokens_helper(_visitor, &_i.bracket_token.span); + _visitor.visit_path(&_i.path); + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_bare_fn_arg<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BareFnArg) { + if let Some(ref it) = _i.name { + _visitor.visit_bare_fn_arg_name(&(it).0); + tokens_helper(_visitor, &(it).1.spans); + }; + _visitor.visit_type(&_i.ty); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_bare_fn_arg_name<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast BareFnArgName, +) { + match *_i { + BareFnArgName::Named(ref _binding_0) => { + _visitor.visit_ident(_binding_0); + } + BareFnArgName::Wild(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_bin_op<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast BinOp) { + match *_i { + BinOp::Add(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Sub(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Mul(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Div(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Rem(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::And(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Or(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::BitXor(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::BitAnd(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::BitOr(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Shl(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Shr(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Eq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Lt(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Le(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Ne(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Ge(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::Gt(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::AddEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::SubEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::MulEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::DivEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::RemEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::BitXorEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::BitAndEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::BitOrEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::ShlEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + BinOp::ShrEq(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_binding<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Binding) { + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_type(&_i.ty); +} +#[cfg(feature = "full")] +pub fn visit_block<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Block) { + tokens_helper(_visitor, &_i.brace_token.span); + for it in &_i.stmts { + _visitor.visit_stmt(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_bound_lifetimes<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast BoundLifetimes, +) { + tokens_helper(_visitor, &_i.for_token.span); + tokens_helper(_visitor, &_i.lt_token.spans); + for el in Punctuated::pairs(&_i.lifetimes) { + let it = el.value(); + _visitor.visit_lifetime_def(it) + } + tokens_helper(_visitor, &_i.gt_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_const_param<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ConstParam) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.const_token.span); + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.colon_token.spans); + _visitor.visit_type(&_i.ty); + if let Some(ref it) = _i.eq_token { + tokens_helper(_visitor, &it.spans) + }; + if let Some(ref it) = _i.default { + _visitor.visit_expr(it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_constraint<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Constraint) { + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.colon_token.spans); + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } +} +#[cfg(feature = "derive")] +pub fn visit_data<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Data) { + match *_i { + Data::Struct(ref _binding_0) => { + _visitor.visit_data_struct(_binding_0); + } + Data::Enum(ref _binding_0) => { + _visitor.visit_data_enum(_binding_0); + } + Data::Union(ref _binding_0) => { + _visitor.visit_data_union(_binding_0); + } + } +} +#[cfg(feature = "derive")] +pub fn visit_data_enum<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DataEnum) { + tokens_helper(_visitor, &_i.enum_token.span); + tokens_helper(_visitor, &_i.brace_token.span); + for el in Punctuated::pairs(&_i.variants) { + let it = el.value(); + _visitor.visit_variant(it) + } +} +#[cfg(feature = "derive")] +pub fn visit_data_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DataStruct) { + tokens_helper(_visitor, &_i.struct_token.span); + _visitor.visit_fields(&_i.fields); + if let Some(ref it) = _i.semi_token { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "derive")] +pub fn visit_data_union<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DataUnion) { + tokens_helper(_visitor, &_i.union_token.span); + _visitor.visit_fields_named(&_i.fields); +} +#[cfg(feature = "derive")] +pub fn visit_derive_input<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast DeriveInput) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + _visitor.visit_data(&_i.data); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Expr) { + match *_i { + Expr::Box(ref _binding_0) => { + full!(_visitor.visit_expr_box(_binding_0)); + } + Expr::InPlace(ref _binding_0) => { + full!(_visitor.visit_expr_in_place(_binding_0)); + } + Expr::Array(ref _binding_0) => { + full!(_visitor.visit_expr_array(_binding_0)); + } + Expr::Call(ref _binding_0) => { + _visitor.visit_expr_call(_binding_0); + } + Expr::MethodCall(ref _binding_0) => { + full!(_visitor.visit_expr_method_call(_binding_0)); + } + Expr::Tuple(ref _binding_0) => { + full!(_visitor.visit_expr_tuple(_binding_0)); + } + Expr::Binary(ref _binding_0) => { + _visitor.visit_expr_binary(_binding_0); + } + Expr::Unary(ref _binding_0) => { + _visitor.visit_expr_unary(_binding_0); + } + Expr::Lit(ref _binding_0) => { + _visitor.visit_expr_lit(_binding_0); + } + Expr::Cast(ref _binding_0) => { + _visitor.visit_expr_cast(_binding_0); + } + Expr::Type(ref _binding_0) => { + full!(_visitor.visit_expr_type(_binding_0)); + } + Expr::Let(ref _binding_0) => { + full!(_visitor.visit_expr_let(_binding_0)); + } + Expr::If(ref _binding_0) => { + full!(_visitor.visit_expr_if(_binding_0)); + } + Expr::While(ref _binding_0) => { + full!(_visitor.visit_expr_while(_binding_0)); + } + Expr::ForLoop(ref _binding_0) => { + full!(_visitor.visit_expr_for_loop(_binding_0)); + } + Expr::Loop(ref _binding_0) => { + full!(_visitor.visit_expr_loop(_binding_0)); + } + Expr::Match(ref _binding_0) => { + full!(_visitor.visit_expr_match(_binding_0)); + } + Expr::Closure(ref _binding_0) => { + full!(_visitor.visit_expr_closure(_binding_0)); + } + Expr::Unsafe(ref _binding_0) => { + full!(_visitor.visit_expr_unsafe(_binding_0)); + } + Expr::Block(ref _binding_0) => { + full!(_visitor.visit_expr_block(_binding_0)); + } + Expr::Assign(ref _binding_0) => { + full!(_visitor.visit_expr_assign(_binding_0)); + } + Expr::AssignOp(ref _binding_0) => { + full!(_visitor.visit_expr_assign_op(_binding_0)); + } + Expr::Field(ref _binding_0) => { + _visitor.visit_expr_field(_binding_0); + } + Expr::Index(ref _binding_0) => { + _visitor.visit_expr_index(_binding_0); + } + Expr::Range(ref _binding_0) => { + full!(_visitor.visit_expr_range(_binding_0)); + } + Expr::Path(ref _binding_0) => { + _visitor.visit_expr_path(_binding_0); + } + Expr::Reference(ref _binding_0) => { + full!(_visitor.visit_expr_reference(_binding_0)); + } + Expr::Break(ref _binding_0) => { + full!(_visitor.visit_expr_break(_binding_0)); + } + Expr::Continue(ref _binding_0) => { + full!(_visitor.visit_expr_continue(_binding_0)); + } + Expr::Return(ref _binding_0) => { + full!(_visitor.visit_expr_return(_binding_0)); + } + Expr::Macro(ref _binding_0) => { + full!(_visitor.visit_expr_macro(_binding_0)); + } + Expr::Struct(ref _binding_0) => { + full!(_visitor.visit_expr_struct(_binding_0)); + } + Expr::Repeat(ref _binding_0) => { + full!(_visitor.visit_expr_repeat(_binding_0)); + } + Expr::Paren(ref _binding_0) => { + _visitor.visit_expr_paren(_binding_0); + } + Expr::Group(ref _binding_0) => { + full!(_visitor.visit_expr_group(_binding_0)); + } + Expr::Try(ref _binding_0) => { + full!(_visitor.visit_expr_try(_binding_0)); + } + Expr::Async(ref _binding_0) => { + full!(_visitor.visit_expr_async(_binding_0)); + } + Expr::TryBlock(ref _binding_0) => { + full!(_visitor.visit_expr_try_block(_binding_0)); + } + Expr::Yield(ref _binding_0) => { + full!(_visitor.visit_expr_yield(_binding_0)); + } + Expr::Verbatim(ref _binding_0) => { + _visitor.visit_expr_verbatim(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_expr_array<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprArray) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.bracket_token.span); + for el in Punctuated::pairs(&_i.elems) { + let it = el.value(); + _visitor.visit_expr(it) + } +} +#[cfg(feature = "full")] +pub fn visit_expr_assign<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAssign) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.left); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_expr(&*_i.right); +} +#[cfg(feature = "full")] +pub fn visit_expr_assign_op<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ExprAssignOp, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.left); + _visitor.visit_bin_op(&_i.op); + _visitor.visit_expr(&*_i.right); +} +#[cfg(feature = "full")] +pub fn visit_expr_async<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprAsync) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.async_token.span); + if let Some(ref it) = _i.capture { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_block(&_i.block); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_binary<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBinary) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.left); + _visitor.visit_bin_op(&_i.op); + _visitor.visit_expr(&*_i.right); +} +#[cfg(feature = "full")] +pub fn visit_expr_block<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBlock) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.label { + _visitor.visit_label(it) + }; + _visitor.visit_block(&_i.block); +} +#[cfg(feature = "full")] +pub fn visit_expr_box<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBox) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.box_token.span); + _visitor.visit_expr(&*_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_expr_break<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprBreak) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.break_token.span); + if let Some(ref it) = _i.label { + _visitor.visit_lifetime(it) + }; + if let Some(ref it) = _i.expr { + _visitor.visit_expr(&**it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_call<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCall) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.func); + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.args) { + let it = el.value(); + _visitor.visit_expr(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_cast<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprCast) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.expr); + tokens_helper(_visitor, &_i.as_token.span); + _visitor.visit_type(&*_i.ty); +} +#[cfg(feature = "full")] +pub fn visit_expr_closure<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprClosure) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.asyncness { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.movability { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.capture { + tokens_helper(_visitor, &it.span) + }; + tokens_helper(_visitor, &_i.or1_token.spans); + for el in Punctuated::pairs(&_i.inputs) { + let it = el.value(); + _visitor.visit_fn_arg(it) + } + tokens_helper(_visitor, &_i.or2_token.spans); + _visitor.visit_return_type(&_i.output); + _visitor.visit_expr(&*_i.body); +} +#[cfg(feature = "full")] +pub fn visit_expr_continue<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ExprContinue, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.continue_token.span); + if let Some(ref it) = _i.label { + _visitor.visit_lifetime(it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_field<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprField) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.base); + tokens_helper(_visitor, &_i.dot_token.spans); + _visitor.visit_member(&_i.member); +} +#[cfg(feature = "full")] +pub fn visit_expr_for_loop<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprForLoop) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.label { + _visitor.visit_label(it) + }; + tokens_helper(_visitor, &_i.for_token.span); + _visitor.visit_pat(&*_i.pat); + tokens_helper(_visitor, &_i.in_token.span); + _visitor.visit_expr(&*_i.expr); + _visitor.visit_block(&_i.body); +} +#[cfg(feature = "full")] +pub fn visit_expr_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprGroup) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.group_token.span); + _visitor.visit_expr(&*_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_expr_if<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIf) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.if_token.span); + _visitor.visit_expr(&*_i.cond); + _visitor.visit_block(&_i.then_branch); + if let Some(ref it) = _i.else_branch { + tokens_helper(_visitor, &(it).0.span); + _visitor.visit_expr(&*(it).1); + }; +} +#[cfg(feature = "full")] +pub fn visit_expr_in_place<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprInPlace) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.place); + tokens_helper(_visitor, &_i.arrow_token.spans); + _visitor.visit_expr(&*_i.value); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_index<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprIndex) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.expr); + tokens_helper(_visitor, &_i.bracket_token.span); + _visitor.visit_expr(&*_i.index); +} +#[cfg(feature = "full")] +pub fn visit_expr_let<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLet) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.let_token.span); + for el in Punctuated::pairs(&_i.pats) { + let it = el.value(); + _visitor.visit_pat(it) + } + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_expr(&*_i.expr); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLit) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_lit(&_i.lit); +} +#[cfg(feature = "full")] +pub fn visit_expr_loop<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprLoop) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.label { + _visitor.visit_label(it) + }; + tokens_helper(_visitor, &_i.loop_token.span); + _visitor.visit_block(&_i.body); +} +#[cfg(feature = "full")] +pub fn visit_expr_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMacro) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_macro(&_i.mac); +} +#[cfg(feature = "full")] +pub fn visit_expr_match<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprMatch) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.match_token.span); + _visitor.visit_expr(&*_i.expr); + tokens_helper(_visitor, &_i.brace_token.span); + for it in &_i.arms { + _visitor.visit_arm(it) + } +} +#[cfg(feature = "full")] +pub fn visit_expr_method_call<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ExprMethodCall, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.receiver); + tokens_helper(_visitor, &_i.dot_token.spans); + _visitor.visit_ident(&_i.method); + if let Some(ref it) = _i.turbofish { + _visitor.visit_method_turbofish(it) + }; + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.args) { + let it = el.value(); + _visitor.visit_expr(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_paren<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprParen) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.paren_token.span); + _visitor.visit_expr(&*_i.expr); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprPath) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.qself { + _visitor.visit_qself(it) + }; + _visitor.visit_path(&_i.path); +} +#[cfg(feature = "full")] +pub fn visit_expr_range<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRange) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.from { + _visitor.visit_expr(&**it) + }; + _visitor.visit_range_limits(&_i.limits); + if let Some(ref it) = _i.to { + _visitor.visit_expr(&**it) + }; +} +#[cfg(feature = "full")] +pub fn visit_expr_reference<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ExprReference, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.and_token.spans); + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_expr(&*_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_expr_repeat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprRepeat) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.bracket_token.span); + _visitor.visit_expr(&*_i.expr); + tokens_helper(_visitor, &_i.semi_token.spans); + _visitor.visit_expr(&*_i.len); +} +#[cfg(feature = "full")] +pub fn visit_expr_return<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprReturn) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.return_token.span); + if let Some(ref it) = _i.expr { + _visitor.visit_expr(&**it) + }; +} +#[cfg(feature = "full")] +pub fn visit_expr_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprStruct) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_path(&_i.path); + tokens_helper(_visitor, &_i.brace_token.span); + for el in Punctuated::pairs(&_i.fields) { + let it = el.value(); + _visitor.visit_field_value(it) + } + if let Some(ref it) = _i.dot2_token { + tokens_helper(_visitor, &it.spans) + }; + if let Some(ref it) = _i.rest { + _visitor.visit_expr(&**it) + }; +} +#[cfg(feature = "full")] +pub fn visit_expr_try<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTry) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.expr); + tokens_helper(_visitor, &_i.question_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_expr_try_block<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ExprTryBlock, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.try_token.span); + _visitor.visit_block(&_i.block); +} +#[cfg(feature = "full")] +pub fn visit_expr_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprTuple) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.elems) { + let it = el.value(); + _visitor.visit_expr(it) + } +} +#[cfg(feature = "full")] +pub fn visit_expr_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprType) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_expr(&*_i.expr); + tokens_helper(_visitor, &_i.colon_token.spans); + _visitor.visit_type(&*_i.ty); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_unary<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprUnary) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_un_op(&_i.op); + _visitor.visit_expr(&*_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_expr_unsafe<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprUnsafe) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.unsafe_token.span); + _visitor.visit_block(&_i.block); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_verbatim<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ExprVerbatim, +) { + skip!(_i.tts); +} +#[cfg(feature = "full")] +pub fn visit_expr_while<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprWhile) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.label { + _visitor.visit_label(it) + }; + tokens_helper(_visitor, &_i.while_token.span); + _visitor.visit_expr(&*_i.cond); + _visitor.visit_block(&_i.body); +} +#[cfg(feature = "full")] +pub fn visit_expr_yield<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ExprYield) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.yield_token.span); + if let Some(ref it) = _i.expr { + _visitor.visit_expr(&**it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_field<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Field) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + if let Some(ref it) = _i.ident { + _visitor.visit_ident(it) + }; + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + _visitor.visit_type(&_i.ty); +} +#[cfg(feature = "full")] +pub fn visit_field_pat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldPat) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_member(&_i.member); + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + _visitor.visit_pat(&*_i.pat); +} +#[cfg(feature = "full")] +pub fn visit_field_value<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldValue) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_member(&_i.member); + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + _visitor.visit_expr(&_i.expr); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_fields<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Fields) { + match *_i { + Fields::Named(ref _binding_0) => { + _visitor.visit_fields_named(_binding_0); + } + Fields::Unnamed(ref _binding_0) => { + _visitor.visit_fields_unnamed(_binding_0); + } + Fields::Unit => {} + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_fields_named<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FieldsNamed) { + tokens_helper(_visitor, &_i.brace_token.span); + for el in Punctuated::pairs(&_i.named) { + let it = el.value(); + _visitor.visit_field(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_fields_unnamed<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast FieldsUnnamed, +) { + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.unnamed) { + let it = el.value(); + _visitor.visit_field(it) + } +} +#[cfg(feature = "full")] +pub fn visit_file<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast File) { + skip!(_i.shebang); + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + for it in &_i.items { + _visitor.visit_item(it) + } +} +#[cfg(feature = "full")] +pub fn visit_fn_arg<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FnArg) { + match *_i { + FnArg::SelfRef(ref _binding_0) => { + _visitor.visit_arg_self_ref(_binding_0); + } + FnArg::SelfValue(ref _binding_0) => { + _visitor.visit_arg_self(_binding_0); + } + FnArg::Captured(ref _binding_0) => { + _visitor.visit_arg_captured(_binding_0); + } + FnArg::Inferred(ref _binding_0) => { + _visitor.visit_pat(_binding_0); + } + FnArg::Ignored(ref _binding_0) => { + _visitor.visit_type(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_fn_decl<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast FnDecl) { + tokens_helper(_visitor, &_i.fn_token.span); + _visitor.visit_generics(&_i.generics); + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.inputs) { + let it = el.value(); + _visitor.visit_fn_arg(it) + } + if let Some(ref it) = _i.variadic { + tokens_helper(_visitor, &it.spans) + }; + _visitor.visit_return_type(&_i.output); +} +#[cfg(feature = "full")] +pub fn visit_foreign_item<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ForeignItem) { + match *_i { + ForeignItem::Fn(ref _binding_0) => { + _visitor.visit_foreign_item_fn(_binding_0); + } + ForeignItem::Static(ref _binding_0) => { + _visitor.visit_foreign_item_static(_binding_0); + } + ForeignItem::Type(ref _binding_0) => { + _visitor.visit_foreign_item_type(_binding_0); + } + ForeignItem::Macro(ref _binding_0) => { + _visitor.visit_foreign_item_macro(_binding_0); + } + ForeignItem::Verbatim(ref _binding_0) => { + _visitor.visit_foreign_item_verbatim(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_fn<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ForeignItemFn, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + _visitor.visit_ident(&_i.ident); + _visitor.visit_fn_decl(&*_i.decl); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_macro<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ForeignItemMacro, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_macro(&_i.mac); + if let Some(ref it) = _i.semi_token { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_static<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ForeignItemStatic, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.static_token.span); + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.colon_token.spans); + _visitor.visit_type(&*_i.ty); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_type<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ForeignItemType, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.type_token.span); + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_verbatim<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ForeignItemVerbatim, +) { + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_generic_argument<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast GenericArgument, +) { + match *_i { + GenericArgument::Lifetime(ref _binding_0) => { + _visitor.visit_lifetime(_binding_0); + } + GenericArgument::Type(ref _binding_0) => { + _visitor.visit_type(_binding_0); + } + GenericArgument::Binding(ref _binding_0) => { + _visitor.visit_binding(_binding_0); + } + GenericArgument::Constraint(ref _binding_0) => { + _visitor.visit_constraint(_binding_0); + } + GenericArgument::Const(ref _binding_0) => { + _visitor.visit_expr(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_generic_method_argument<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast GenericMethodArgument, +) { + match *_i { + GenericMethodArgument::Type(ref _binding_0) => { + _visitor.visit_type(_binding_0); + } + GenericMethodArgument::Const(ref _binding_0) => { + _visitor.visit_expr(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_generic_param<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast GenericParam, +) { + match *_i { + GenericParam::Type(ref _binding_0) => { + _visitor.visit_type_param(_binding_0); + } + GenericParam::Lifetime(ref _binding_0) => { + _visitor.visit_lifetime_def(_binding_0); + } + GenericParam::Const(ref _binding_0) => { + _visitor.visit_const_param(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_generics<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Generics) { + if let Some(ref it) = _i.lt_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.params) { + let it = el.value(); + _visitor.visit_generic_param(it) + } + if let Some(ref it) = _i.gt_token { + tokens_helper(_visitor, &it.spans) + }; + if let Some(ref it) = _i.where_clause { + _visitor.visit_where_clause(it) + }; +} +#[cfg(feature = "full")] +pub fn visit_impl_item<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ImplItem) { + match *_i { + ImplItem::Const(ref _binding_0) => { + _visitor.visit_impl_item_const(_binding_0); + } + ImplItem::Method(ref _binding_0) => { + _visitor.visit_impl_item_method(_binding_0); + } + ImplItem::Type(ref _binding_0) => { + _visitor.visit_impl_item_type(_binding_0); + } + ImplItem::Existential(ref _binding_0) => { + _visitor.visit_impl_item_existential(_binding_0); + } + ImplItem::Macro(ref _binding_0) => { + _visitor.visit_impl_item_macro(_binding_0); + } + ImplItem::Verbatim(ref _binding_0) => { + _visitor.visit_impl_item_verbatim(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_impl_item_const<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ImplItemConst, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + if let Some(ref it) = _i.defaultness { + tokens_helper(_visitor, &it.span) + }; + tokens_helper(_visitor, &_i.const_token.span); + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.colon_token.spans); + _visitor.visit_type(&_i.ty); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_expr(&_i.expr); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_impl_item_existential<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ImplItemExistential, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.existential_token.span); + tokens_helper(_visitor, &_i.type_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_impl_item_macro<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ImplItemMacro, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_macro(&_i.mac); + if let Some(ref it) = _i.semi_token { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_impl_item_method<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ImplItemMethod, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + if let Some(ref it) = _i.defaultness { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_method_sig(&_i.sig); + _visitor.visit_block(&_i.block); +} +#[cfg(feature = "full")] +pub fn visit_impl_item_type<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ImplItemType, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + if let Some(ref it) = _i.defaultness { + tokens_helper(_visitor, &it.span) + }; + tokens_helper(_visitor, &_i.type_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_type(&_i.ty); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_impl_item_verbatim<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ImplItemVerbatim, +) { + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_index<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Index) { + skip!(_i.index); + _visitor.visit_span(&_i.span); +} +#[cfg(feature = "full")] +pub fn visit_item<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Item) { + match *_i { + Item::ExternCrate(ref _binding_0) => { + _visitor.visit_item_extern_crate(_binding_0); + } + Item::Use(ref _binding_0) => { + _visitor.visit_item_use(_binding_0); + } + Item::Static(ref _binding_0) => { + _visitor.visit_item_static(_binding_0); + } + Item::Const(ref _binding_0) => { + _visitor.visit_item_const(_binding_0); + } + Item::Fn(ref _binding_0) => { + _visitor.visit_item_fn(_binding_0); + } + Item::Mod(ref _binding_0) => { + _visitor.visit_item_mod(_binding_0); + } + Item::ForeignMod(ref _binding_0) => { + _visitor.visit_item_foreign_mod(_binding_0); + } + Item::Type(ref _binding_0) => { + _visitor.visit_item_type(_binding_0); + } + Item::Existential(ref _binding_0) => { + _visitor.visit_item_existential(_binding_0); + } + Item::Struct(ref _binding_0) => { + _visitor.visit_item_struct(_binding_0); + } + Item::Enum(ref _binding_0) => { + _visitor.visit_item_enum(_binding_0); + } + Item::Union(ref _binding_0) => { + _visitor.visit_item_union(_binding_0); + } + Item::Trait(ref _binding_0) => { + _visitor.visit_item_trait(_binding_0); + } + Item::TraitAlias(ref _binding_0) => { + _visitor.visit_item_trait_alias(_binding_0); + } + Item::Impl(ref _binding_0) => { + _visitor.visit_item_impl(_binding_0); + } + Item::Macro(ref _binding_0) => { + _visitor.visit_item_macro(_binding_0); + } + Item::Macro2(ref _binding_0) => { + _visitor.visit_item_macro2(_binding_0); + } + Item::Verbatim(ref _binding_0) => { + _visitor.visit_item_verbatim(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_item_const<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemConst) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.const_token.span); + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.colon_token.spans); + _visitor.visit_type(&*_i.ty); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_expr(&*_i.expr); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_enum<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemEnum) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.enum_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + tokens_helper(_visitor, &_i.brace_token.span); + for el in Punctuated::pairs(&_i.variants) { + let it = el.value(); + _visitor.visit_variant(it) + } +} +#[cfg(feature = "full")] +pub fn visit_item_existential<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ItemExistential, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.existential_token.span); + tokens_helper(_visitor, &_i.type_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_extern_crate<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ItemExternCrate, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.extern_token.span); + tokens_helper(_visitor, &_i.crate_token.span); + _visitor.visit_ident(&_i.ident); + if let Some(ref it) = _i.rename { + tokens_helper(_visitor, &(it).0.span); + _visitor.visit_ident(&(it).1); + }; + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_fn<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemFn) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + if let Some(ref it) = _i.constness { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.asyncness { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.unsafety { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.abi { + _visitor.visit_abi(it) + }; + _visitor.visit_ident(&_i.ident); + _visitor.visit_fn_decl(&*_i.decl); + _visitor.visit_block(&*_i.block); +} +#[cfg(feature = "full")] +pub fn visit_item_foreign_mod<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ItemForeignMod, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_abi(&_i.abi); + tokens_helper(_visitor, &_i.brace_token.span); + for it in &_i.items { + _visitor.visit_foreign_item(it) + } +} +#[cfg(feature = "full")] +pub fn visit_item_impl<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemImpl) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.defaultness { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.unsafety { + tokens_helper(_visitor, &it.span) + }; + tokens_helper(_visitor, &_i.impl_token.span); + _visitor.visit_generics(&_i.generics); + if let Some(ref it) = _i.trait_ { + if let Some(ref it) = (it).0 { + tokens_helper(_visitor, &it.spans) + }; + _visitor.visit_path(&(it).1); + tokens_helper(_visitor, &(it).2.span); + }; + _visitor.visit_type(&*_i.self_ty); + tokens_helper(_visitor, &_i.brace_token.span); + for it in &_i.items { + _visitor.visit_impl_item(it) + } +} +#[cfg(feature = "full")] +pub fn visit_item_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemMacro) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + if let Some(ref it) = _i.ident { + _visitor.visit_ident(it) + }; + _visitor.visit_macro(&_i.mac); + if let Some(ref it) = _i.semi_token { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_item_macro2<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemMacro2) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.macro_token.span); + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.paren_token.span); + skip!(_i.args); + tokens_helper(_visitor, &_i.brace_token.span); + skip!(_i.body); +} +#[cfg(feature = "full")] +pub fn visit_item_mod<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemMod) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.mod_token.span); + _visitor.visit_ident(&_i.ident); + if let Some(ref it) = _i.content { + tokens_helper(_visitor, &(it).0.span); + for it in &(it).1 { + _visitor.visit_item(it) + } + }; + if let Some(ref it) = _i.semi { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_item_static<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemStatic) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.static_token.span); + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.colon_token.spans); + _visitor.visit_type(&*_i.ty); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_expr(&*_i.expr); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemStruct) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.struct_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + _visitor.visit_fields(&_i.fields); + if let Some(ref it) = _i.semi_token { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_item_trait<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemTrait) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + if let Some(ref it) = _i.unsafety { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.auto_token { + tokens_helper(_visitor, &it.span) + }; + tokens_helper(_visitor, &_i.trait_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.supertraits) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } + tokens_helper(_visitor, &_i.brace_token.span); + for it in &_i.items { + _visitor.visit_trait_item(it) + } +} +#[cfg(feature = "full")] +pub fn visit_item_trait_alias<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ItemTraitAlias, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.trait_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + tokens_helper(_visitor, &_i.eq_token.spans); + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemType) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.type_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_type(&*_i.ty); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_union<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemUnion) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.union_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + _visitor.visit_fields_named(&_i.fields); +} +#[cfg(feature = "full")] +pub fn visit_item_use<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ItemUse) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_visibility(&_i.vis); + tokens_helper(_visitor, &_i.use_token.span); + if let Some(ref it) = _i.leading_colon { + tokens_helper(_visitor, &it.spans) + }; + _visitor.visit_use_tree(&_i.tree); + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_verbatim<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ItemVerbatim, +) { + skip!(_i.tts); +} +#[cfg(feature = "full")] +pub fn visit_label<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Label) { + _visitor.visit_lifetime(&_i.name); + tokens_helper(_visitor, &_i.colon_token.spans); +} +pub fn visit_lifetime<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lifetime) { + _visitor.visit_span(&_i.apostrophe); + _visitor.visit_ident(&_i.ident); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lifetime_def<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LifetimeDef) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_lifetime(&_i.lifetime); + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_lifetime(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Lit) { + match *_i { + Lit::Str(ref _binding_0) => { + _visitor.visit_lit_str(_binding_0); + } + Lit::ByteStr(ref _binding_0) => { + _visitor.visit_lit_byte_str(_binding_0); + } + Lit::Byte(ref _binding_0) => { + _visitor.visit_lit_byte(_binding_0); + } + Lit::Char(ref _binding_0) => { + _visitor.visit_lit_char(_binding_0); + } + Lit::Int(ref _binding_0) => { + _visitor.visit_lit_int(_binding_0); + } + Lit::Float(ref _binding_0) => { + _visitor.visit_lit_float(_binding_0); + } + Lit::Bool(ref _binding_0) => { + _visitor.visit_lit_bool(_binding_0); + } + Lit::Verbatim(ref _binding_0) => { + _visitor.visit_lit_verbatim(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_bool<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitBool) { + skip!(_i.value); + _visitor.visit_span(&_i.span); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_byte<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitByte) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_byte_str<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitByteStr) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_char<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitChar) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_float<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitFloat) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_int<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitInt) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_str<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitStr) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_verbatim<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast LitVerbatim) { + skip!(_i.token); +} +#[cfg(feature = "full")] +pub fn visit_local<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Local) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.let_token.span); + for el in Punctuated::pairs(&_i.pats) { + let it = el.value(); + _visitor.visit_pat(it) + } + if let Some(ref it) = _i.ty { + tokens_helper(_visitor, &(it).0.spans); + _visitor.visit_type(&*(it).1); + }; + if let Some(ref it) = _i.init { + tokens_helper(_visitor, &(it).0.spans); + _visitor.visit_expr(&*(it).1); + }; + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Macro) { + _visitor.visit_path(&_i.path); + tokens_helper(_visitor, &_i.bang_token.spans); + _visitor.visit_macro_delimiter(&_i.delimiter); + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_macro_delimiter<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast MacroDelimiter, +) { + match *_i { + MacroDelimiter::Paren(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.span); + } + MacroDelimiter::Brace(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.span); + } + MacroDelimiter::Bracket(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.span); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_member<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Member) { + match *_i { + Member::Named(ref _binding_0) => { + _visitor.visit_ident(_binding_0); + } + Member::Unnamed(ref _binding_0) => { + _visitor.visit_index(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Meta) { + match *_i { + Meta::Word(ref _binding_0) => { + _visitor.visit_ident(_binding_0); + } + Meta::List(ref _binding_0) => { + _visitor.visit_meta_list(_binding_0); + } + Meta::NameValue(ref _binding_0) => { + _visitor.visit_meta_name_value(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_meta_list<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MetaList) { + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.nested) { + let it = el.value(); + _visitor.visit_nested_meta(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_meta_name_value<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast MetaNameValue, +) { + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_lit(&_i.lit); +} +#[cfg(feature = "full")] +pub fn visit_method_sig<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast MethodSig) { + if let Some(ref it) = _i.constness { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.asyncness { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.unsafety { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.abi { + _visitor.visit_abi(it) + }; + _visitor.visit_ident(&_i.ident); + _visitor.visit_fn_decl(&_i.decl); +} +#[cfg(feature = "full")] +pub fn visit_method_turbofish<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast MethodTurbofish, +) { + tokens_helper(_visitor, &_i.colon2_token.spans); + tokens_helper(_visitor, &_i.lt_token.spans); + for el in Punctuated::pairs(&_i.args) { + let it = el.value(); + _visitor.visit_generic_method_argument(it) + } + tokens_helper(_visitor, &_i.gt_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_nested_meta<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast NestedMeta) { + match *_i { + NestedMeta::Meta(ref _binding_0) => { + _visitor.visit_meta(_binding_0); + } + NestedMeta::Literal(ref _binding_0) => { + _visitor.visit_lit(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_parenthesized_generic_arguments<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast ParenthesizedGenericArguments, +) { + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.inputs) { + let it = el.value(); + _visitor.visit_type(it) + } + _visitor.visit_return_type(&_i.output); +} +#[cfg(feature = "full")] +pub fn visit_pat<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Pat) { + match *_i { + Pat::Wild(ref _binding_0) => { + _visitor.visit_pat_wild(_binding_0); + } + Pat::Ident(ref _binding_0) => { + _visitor.visit_pat_ident(_binding_0); + } + Pat::Struct(ref _binding_0) => { + _visitor.visit_pat_struct(_binding_0); + } + Pat::TupleStruct(ref _binding_0) => { + _visitor.visit_pat_tuple_struct(_binding_0); + } + Pat::Path(ref _binding_0) => { + _visitor.visit_pat_path(_binding_0); + } + Pat::Tuple(ref _binding_0) => { + _visitor.visit_pat_tuple(_binding_0); + } + Pat::Box(ref _binding_0) => { + _visitor.visit_pat_box(_binding_0); + } + Pat::Ref(ref _binding_0) => { + _visitor.visit_pat_ref(_binding_0); + } + Pat::Lit(ref _binding_0) => { + _visitor.visit_pat_lit(_binding_0); + } + Pat::Range(ref _binding_0) => { + _visitor.visit_pat_range(_binding_0); + } + Pat::Slice(ref _binding_0) => { + _visitor.visit_pat_slice(_binding_0); + } + Pat::Macro(ref _binding_0) => { + _visitor.visit_pat_macro(_binding_0); + } + Pat::Verbatim(ref _binding_0) => { + _visitor.visit_pat_verbatim(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_pat_box<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatBox) { + tokens_helper(_visitor, &_i.box_token.span); + _visitor.visit_pat(&*_i.pat); +} +#[cfg(feature = "full")] +pub fn visit_pat_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatIdent) { + if let Some(ref it) = _i.by_ref { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_ident(&_i.ident); + if let Some(ref it) = _i.subpat { + tokens_helper(_visitor, &(it).0.spans); + _visitor.visit_pat(&*(it).1); + }; +} +#[cfg(feature = "full")] +pub fn visit_pat_lit<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatLit) { + _visitor.visit_expr(&*_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_pat_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatMacro) { + _visitor.visit_macro(&_i.mac); +} +#[cfg(feature = "full")] +pub fn visit_pat_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatPath) { + if let Some(ref it) = _i.qself { + _visitor.visit_qself(it) + }; + _visitor.visit_path(&_i.path); +} +#[cfg(feature = "full")] +pub fn visit_pat_range<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRange) { + _visitor.visit_expr(&*_i.lo); + _visitor.visit_range_limits(&_i.limits); + _visitor.visit_expr(&*_i.hi); +} +#[cfg(feature = "full")] +pub fn visit_pat_ref<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatRef) { + tokens_helper(_visitor, &_i.and_token.spans); + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_pat(&*_i.pat); +} +#[cfg(feature = "full")] +pub fn visit_pat_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatSlice) { + tokens_helper(_visitor, &_i.bracket_token.span); + for el in Punctuated::pairs(&_i.front) { + let it = el.value(); + _visitor.visit_pat(it) + } + if let Some(ref it) = _i.middle { + _visitor.visit_pat(&**it) + }; + if let Some(ref it) = _i.dot2_token { + tokens_helper(_visitor, &it.spans) + }; + if let Some(ref it) = _i.comma_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.back) { + let it = el.value(); + _visitor.visit_pat(it) + } +} +#[cfg(feature = "full")] +pub fn visit_pat_struct<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatStruct) { + _visitor.visit_path(&_i.path); + tokens_helper(_visitor, &_i.brace_token.span); + for el in Punctuated::pairs(&_i.fields) { + let it = el.value(); + _visitor.visit_field_pat(it) + } + if let Some(ref it) = _i.dot2_token { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_pat_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatTuple) { + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.front) { + let it = el.value(); + _visitor.visit_pat(it) + } + if let Some(ref it) = _i.dot2_token { + tokens_helper(_visitor, &it.spans) + }; + if let Some(ref it) = _i.comma_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.back) { + let it = el.value(); + _visitor.visit_pat(it) + } +} +#[cfg(feature = "full")] +pub fn visit_pat_tuple_struct<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast PatTupleStruct, +) { + _visitor.visit_path(&_i.path); + _visitor.visit_pat_tuple(&_i.pat); +} +#[cfg(feature = "full")] +pub fn visit_pat_verbatim<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatVerbatim) { + skip!(_i.tts); +} +#[cfg(feature = "full")] +pub fn visit_pat_wild<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PatWild) { + tokens_helper(_visitor, &_i.underscore_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Path) { + if let Some(ref it) = _i.leading_colon { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.segments) { + let it = el.value(); + _visitor.visit_path_segment(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_path_arguments<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast PathArguments, +) { + match *_i { + PathArguments::None => {} + PathArguments::AngleBracketed(ref _binding_0) => { + _visitor.visit_angle_bracketed_generic_arguments(_binding_0); + } + PathArguments::Parenthesized(ref _binding_0) => { + _visitor.visit_parenthesized_generic_arguments(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_path_segment<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PathSegment) { + _visitor.visit_ident(&_i.ident); + _visitor.visit_path_arguments(&_i.arguments); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_predicate_eq<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast PredicateEq) { + _visitor.visit_type(&_i.lhs_ty); + tokens_helper(_visitor, &_i.eq_token.spans); + _visitor.visit_type(&_i.rhs_ty); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_predicate_lifetime<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast PredicateLifetime, +) { + _visitor.visit_lifetime(&_i.lifetime); + tokens_helper(_visitor, &_i.colon_token.spans); + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_lifetime(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_predicate_type<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast PredicateType, +) { + if let Some(ref it) = _i.lifetimes { + _visitor.visit_bound_lifetimes(it) + }; + _visitor.visit_type(&_i.bounded_ty); + tokens_helper(_visitor, &_i.colon_token.spans); + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_qself<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast QSelf) { + tokens_helper(_visitor, &_i.lt_token.spans); + _visitor.visit_type(&*_i.ty); + skip!(_i.position); + if let Some(ref it) = _i.as_token { + tokens_helper(_visitor, &it.span) + }; + tokens_helper(_visitor, &_i.gt_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_range_limits<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast RangeLimits) { + match *_i { + RangeLimits::HalfOpen(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + RangeLimits::Closed(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_return_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast ReturnType) { + match *_i { + ReturnType::Default => {} + ReturnType::Type(ref _binding_0, ref _binding_1) => { + tokens_helper(_visitor, &_binding_0.spans); + _visitor.visit_type(&**_binding_1); + } + } +} +#[cfg(feature = "full")] +pub fn visit_stmt<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Stmt) { + match *_i { + Stmt::Local(ref _binding_0) => { + _visitor.visit_local(_binding_0); + } + Stmt::Item(ref _binding_0) => { + _visitor.visit_item(_binding_0); + } + Stmt::Expr(ref _binding_0) => { + _visitor.visit_expr(_binding_0); + } + Stmt::Semi(ref _binding_0, ref _binding_1) => { + _visitor.visit_expr(_binding_0); + tokens_helper(_visitor, &_binding_1.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_trait_bound<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitBound) { + if let Some(ref it) = _i.paren_token { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_trait_bound_modifier(&_i.modifier); + if let Some(ref it) = _i.lifetimes { + _visitor.visit_bound_lifetimes(it) + }; + _visitor.visit_path(&_i.path); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_trait_bound_modifier<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TraitBoundModifier, +) { + match *_i { + TraitBoundModifier::None => {} + TraitBoundModifier::Maybe(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + } +} +#[cfg(feature = "full")] +pub fn visit_trait_item<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TraitItem) { + match *_i { + TraitItem::Const(ref _binding_0) => { + _visitor.visit_trait_item_const(_binding_0); + } + TraitItem::Method(ref _binding_0) => { + _visitor.visit_trait_item_method(_binding_0); + } + TraitItem::Type(ref _binding_0) => { + _visitor.visit_trait_item_type(_binding_0); + } + TraitItem::Macro(ref _binding_0) => { + _visitor.visit_trait_item_macro(_binding_0); + } + TraitItem::Verbatim(ref _binding_0) => { + _visitor.visit_trait_item_verbatim(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_trait_item_const<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TraitItemConst, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.const_token.span); + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.colon_token.spans); + _visitor.visit_type(&_i.ty); + if let Some(ref it) = _i.default { + tokens_helper(_visitor, &(it).0.spans); + _visitor.visit_expr(&(it).1); + }; + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_trait_item_macro<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TraitItemMacro, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_macro(&_i.mac); + if let Some(ref it) = _i.semi_token { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_trait_item_method<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TraitItemMethod, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_method_sig(&_i.sig); + if let Some(ref it) = _i.default { + _visitor.visit_block(it) + }; + if let Some(ref it) = _i.semi_token { + tokens_helper(_visitor, &it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_trait_item_type<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TraitItemType, +) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + tokens_helper(_visitor, &_i.type_token.span); + _visitor.visit_ident(&_i.ident); + _visitor.visit_generics(&_i.generics); + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } + if let Some(ref it) = _i.default { + tokens_helper(_visitor, &(it).0.spans); + _visitor.visit_type(&(it).1); + }; + tokens_helper(_visitor, &_i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_trait_item_verbatim<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TraitItemVerbatim, +) { + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Type) { + match *_i { + Type::Slice(ref _binding_0) => { + _visitor.visit_type_slice(_binding_0); + } + Type::Array(ref _binding_0) => { + _visitor.visit_type_array(_binding_0); + } + Type::Ptr(ref _binding_0) => { + _visitor.visit_type_ptr(_binding_0); + } + Type::Reference(ref _binding_0) => { + _visitor.visit_type_reference(_binding_0); + } + Type::BareFn(ref _binding_0) => { + _visitor.visit_type_bare_fn(_binding_0); + } + Type::Never(ref _binding_0) => { + _visitor.visit_type_never(_binding_0); + } + Type::Tuple(ref _binding_0) => { + _visitor.visit_type_tuple(_binding_0); + } + Type::Path(ref _binding_0) => { + _visitor.visit_type_path(_binding_0); + } + Type::TraitObject(ref _binding_0) => { + _visitor.visit_type_trait_object(_binding_0); + } + Type::ImplTrait(ref _binding_0) => { + _visitor.visit_type_impl_trait(_binding_0); + } + Type::Paren(ref _binding_0) => { + _visitor.visit_type_paren(_binding_0); + } + Type::Group(ref _binding_0) => { + _visitor.visit_type_group(_binding_0); + } + Type::Infer(ref _binding_0) => { + _visitor.visit_type_infer(_binding_0); + } + Type::Macro(ref _binding_0) => { + _visitor.visit_type_macro(_binding_0); + } + Type::Verbatim(ref _binding_0) => { + _visitor.visit_type_verbatim(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_array<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeArray) { + tokens_helper(_visitor, &_i.bracket_token.span); + _visitor.visit_type(&*_i.elem); + tokens_helper(_visitor, &_i.semi_token.spans); + _visitor.visit_expr(&_i.len); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_bare_fn<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeBareFn) { + if let Some(ref it) = _i.lifetimes { + _visitor.visit_bound_lifetimes(it) + }; + if let Some(ref it) = _i.unsafety { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.abi { + _visitor.visit_abi(it) + }; + tokens_helper(_visitor, &_i.fn_token.span); + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.inputs) { + let it = el.value(); + _visitor.visit_bare_fn_arg(it) + } + if let Some(ref it) = _i.variadic { + tokens_helper(_visitor, &it.spans) + }; + _visitor.visit_return_type(&_i.output); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeGroup) { + tokens_helper(_visitor, &_i.group_token.span); + _visitor.visit_type(&*_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_impl_trait<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TypeImplTrait, +) { + tokens_helper(_visitor, &_i.impl_token.span); + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_infer<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeInfer) { + tokens_helper(_visitor, &_i.underscore_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_macro<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeMacro) { + _visitor.visit_macro(&_i.mac); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_never<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeNever) { + tokens_helper(_visitor, &_i.bang_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_param<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeParam) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_ident(&_i.ident); + if let Some(ref it) = _i.colon_token { + tokens_helper(_visitor, &it.spans) + }; + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } + if let Some(ref it) = _i.eq_token { + tokens_helper(_visitor, &it.spans) + }; + if let Some(ref it) = _i.default { + _visitor.visit_type(it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_param_bound<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TypeParamBound, +) { + match *_i { + TypeParamBound::Trait(ref _binding_0) => { + _visitor.visit_trait_bound(_binding_0); + } + TypeParamBound::Lifetime(ref _binding_0) => { + _visitor.visit_lifetime(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_paren<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeParen) { + tokens_helper(_visitor, &_i.paren_token.span); + _visitor.visit_type(&*_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypePath) { + if let Some(ref it) = _i.qself { + _visitor.visit_qself(it) + }; + _visitor.visit_path(&_i.path); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_ptr<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypePtr) { + tokens_helper(_visitor, &_i.star_token.spans); + if let Some(ref it) = _i.const_token { + tokens_helper(_visitor, &it.span) + }; + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_type(&*_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_reference<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TypeReference, +) { + tokens_helper(_visitor, &_i.and_token.spans); + if let Some(ref it) = _i.lifetime { + _visitor.visit_lifetime(it) + }; + if let Some(ref it) = _i.mutability { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_type(&*_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_slice<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeSlice) { + tokens_helper(_visitor, &_i.bracket_token.span); + _visitor.visit_type(&*_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_trait_object<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TypeTraitObject, +) { + if let Some(ref it) = _i.dyn_token { + tokens_helper(_visitor, &it.span) + }; + for el in Punctuated::pairs(&_i.bounds) { + let it = el.value(); + _visitor.visit_type_param_bound(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_tuple<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast TypeTuple) { + tokens_helper(_visitor, &_i.paren_token.span); + for el in Punctuated::pairs(&_i.elems) { + let it = el.value(); + _visitor.visit_type(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_verbatim<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast TypeVerbatim, +) { + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_un_op<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UnOp) { + match *_i { + UnOp::Deref(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + UnOp::Not(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + UnOp::Neg(ref _binding_0) => { + tokens_helper(_visitor, &_binding_0.spans); + } + } +} +#[cfg(feature = "full")] +pub fn visit_use_glob<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseGlob) { + tokens_helper(_visitor, &_i.star_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_use_group<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseGroup) { + tokens_helper(_visitor, &_i.brace_token.span); + for el in Punctuated::pairs(&_i.items) { + let it = el.value(); + _visitor.visit_use_tree(it) + } +} +#[cfg(feature = "full")] +pub fn visit_use_name<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseName) { + _visitor.visit_ident(&_i.ident); +} +#[cfg(feature = "full")] +pub fn visit_use_path<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UsePath) { + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.colon2_token.spans); + _visitor.visit_use_tree(&*_i.tree); +} +#[cfg(feature = "full")] +pub fn visit_use_rename<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseRename) { + _visitor.visit_ident(&_i.ident); + tokens_helper(_visitor, &_i.as_token.span); + _visitor.visit_ident(&_i.rename); +} +#[cfg(feature = "full")] +pub fn visit_use_tree<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast UseTree) { + match *_i { + UseTree::Path(ref _binding_0) => { + _visitor.visit_use_path(_binding_0); + } + UseTree::Name(ref _binding_0) => { + _visitor.visit_use_name(_binding_0); + } + UseTree::Rename(ref _binding_0) => { + _visitor.visit_use_rename(_binding_0); + } + UseTree::Glob(ref _binding_0) => { + _visitor.visit_use_glob(_binding_0); + } + UseTree::Group(ref _binding_0) => { + _visitor.visit_use_group(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_variant<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Variant) { + for it in &_i.attrs { + _visitor.visit_attribute(it) + } + _visitor.visit_ident(&_i.ident); + _visitor.visit_fields(&_i.fields); + if let Some(ref it) = _i.discriminant { + tokens_helper(_visitor, &(it).0.spans); + _visitor.visit_expr(&(it).1); + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_vis_crate<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisCrate) { + tokens_helper(_visitor, &_i.crate_token.span); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_vis_public<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast VisPublic) { + tokens_helper(_visitor, &_i.pub_token.span); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_vis_restricted<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast VisRestricted, +) { + tokens_helper(_visitor, &_i.pub_token.span); + tokens_helper(_visitor, &_i.paren_token.span); + if let Some(ref it) = _i.in_token { + tokens_helper(_visitor, &it.span) + }; + _visitor.visit_path(&*_i.path); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_visibility<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Visibility) { + match *_i { + Visibility::Public(ref _binding_0) => { + _visitor.visit_vis_public(_binding_0); + } + Visibility::Crate(ref _binding_0) => { + _visitor.visit_vis_crate(_binding_0); + } + Visibility::Restricted(ref _binding_0) => { + _visitor.visit_vis_restricted(_binding_0); + } + Visibility::Inherited => {} + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_where_clause<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast WhereClause) { + tokens_helper(_visitor, &_i.where_token.span); + for el in Punctuated::pairs(&_i.predicates) { + let it = el.value(); + _visitor.visit_where_predicate(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_where_predicate<'ast, V: Visit<'ast> + ?Sized>( + _visitor: &mut V, + _i: &'ast WherePredicate, +) { + match *_i { + WherePredicate::Type(ref _binding_0) => { + _visitor.visit_predicate_type(_binding_0); + } + WherePredicate::Lifetime(ref _binding_0) => { + _visitor.visit_predicate_lifetime(_binding_0); + } + WherePredicate::Eq(ref _binding_0) => { + _visitor.visit_predicate_eq(_binding_0); + } + } +} +pub fn visit_span<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Span) {} +pub fn visit_ident<'ast, V: Visit<'ast> + ?Sized>(_visitor: &mut V, _i: &'ast Ident) {} diff --git a/rust/vendor/syn-0.15.44/src/gen/visit_mut.rs b/rust/vendor/syn-0.15.44/src/gen/visit_mut.rs new file mode 100644 index 0000000..d12071a --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/gen/visit_mut.rs @@ -0,0 +1,3279 @@ +// This file is @generated by syn-internal-codegen. +// It is not intended for manual editing. + +#[cfg(any(feature = "full", feature = "derive"))] +use gen::helper::visit_mut::*; +use proc_macro2::Span; +#[cfg(any(feature = "full", feature = "derive"))] +use punctuated::Punctuated; +use *; +#[cfg(feature = "full")] +macro_rules! full { + ($e:expr) => { + $e + }; +} +#[cfg(all(feature = "derive", not(feature = "full")))] +macro_rules! full { + ($e:expr) => { + unreachable!() + }; +} +#[cfg(any(feature = "full", feature = "derive"))] +macro_rules! skip { + ($($tt:tt)*) => {}; +} +/// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in +/// place. +/// +/// See the [module documentation] for details. +/// +/// [module documentation]: self +/// +/// *This trait is available if Syn is built with the `"visit-mut"` feature.* +pub trait VisitMut { + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_abi_mut(&mut self, i: &mut Abi) { + visit_abi_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_angle_bracketed_generic_arguments_mut( + &mut self, + i: &mut AngleBracketedGenericArguments, + ) { + visit_angle_bracketed_generic_arguments_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_arg_captured_mut(&mut self, i: &mut ArgCaptured) { + visit_arg_captured_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_arg_self_mut(&mut self, i: &mut ArgSelf) { + visit_arg_self_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_arg_self_ref_mut(&mut self, i: &mut ArgSelfRef) { + visit_arg_self_ref_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_arm_mut(&mut self, i: &mut Arm) { + visit_arm_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_attr_style_mut(&mut self, i: &mut AttrStyle) { + visit_attr_style_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_attribute_mut(&mut self, i: &mut Attribute) { + visit_attribute_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_bare_fn_arg_mut(&mut self, i: &mut BareFnArg) { + visit_bare_fn_arg_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_bare_fn_arg_name_mut(&mut self, i: &mut BareFnArgName) { + visit_bare_fn_arg_name_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_bin_op_mut(&mut self, i: &mut BinOp) { + visit_bin_op_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_binding_mut(&mut self, i: &mut Binding) { + visit_binding_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_block_mut(&mut self, i: &mut Block) { + visit_block_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_bound_lifetimes_mut(&mut self, i: &mut BoundLifetimes) { + visit_bound_lifetimes_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_const_param_mut(&mut self, i: &mut ConstParam) { + visit_const_param_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_constraint_mut(&mut self, i: &mut Constraint) { + visit_constraint_mut(self, i) + } + #[cfg(feature = "derive")] + fn visit_data_mut(&mut self, i: &mut Data) { + visit_data_mut(self, i) + } + #[cfg(feature = "derive")] + fn visit_data_enum_mut(&mut self, i: &mut DataEnum) { + visit_data_enum_mut(self, i) + } + #[cfg(feature = "derive")] + fn visit_data_struct_mut(&mut self, i: &mut DataStruct) { + visit_data_struct_mut(self, i) + } + #[cfg(feature = "derive")] + fn visit_data_union_mut(&mut self, i: &mut DataUnion) { + visit_data_union_mut(self, i) + } + #[cfg(feature = "derive")] + fn visit_derive_input_mut(&mut self, i: &mut DeriveInput) { + visit_derive_input_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_mut(&mut self, i: &mut Expr) { + visit_expr_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_array_mut(&mut self, i: &mut ExprArray) { + visit_expr_array_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_assign_mut(&mut self, i: &mut ExprAssign) { + visit_expr_assign_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_assign_op_mut(&mut self, i: &mut ExprAssignOp) { + visit_expr_assign_op_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_async_mut(&mut self, i: &mut ExprAsync) { + visit_expr_async_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_binary_mut(&mut self, i: &mut ExprBinary) { + visit_expr_binary_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_block_mut(&mut self, i: &mut ExprBlock) { + visit_expr_block_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_box_mut(&mut self, i: &mut ExprBox) { + visit_expr_box_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_break_mut(&mut self, i: &mut ExprBreak) { + visit_expr_break_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_call_mut(&mut self, i: &mut ExprCall) { + visit_expr_call_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_cast_mut(&mut self, i: &mut ExprCast) { + visit_expr_cast_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_closure_mut(&mut self, i: &mut ExprClosure) { + visit_expr_closure_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_continue_mut(&mut self, i: &mut ExprContinue) { + visit_expr_continue_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_field_mut(&mut self, i: &mut ExprField) { + visit_expr_field_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_for_loop_mut(&mut self, i: &mut ExprForLoop) { + visit_expr_for_loop_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_group_mut(&mut self, i: &mut ExprGroup) { + visit_expr_group_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_if_mut(&mut self, i: &mut ExprIf) { + visit_expr_if_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_in_place_mut(&mut self, i: &mut ExprInPlace) { + visit_expr_in_place_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_index_mut(&mut self, i: &mut ExprIndex) { + visit_expr_index_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_let_mut(&mut self, i: &mut ExprLet) { + visit_expr_let_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_lit_mut(&mut self, i: &mut ExprLit) { + visit_expr_lit_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_loop_mut(&mut self, i: &mut ExprLoop) { + visit_expr_loop_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_macro_mut(&mut self, i: &mut ExprMacro) { + visit_expr_macro_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_match_mut(&mut self, i: &mut ExprMatch) { + visit_expr_match_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_method_call_mut(&mut self, i: &mut ExprMethodCall) { + visit_expr_method_call_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_paren_mut(&mut self, i: &mut ExprParen) { + visit_expr_paren_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_path_mut(&mut self, i: &mut ExprPath) { + visit_expr_path_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_range_mut(&mut self, i: &mut ExprRange) { + visit_expr_range_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_reference_mut(&mut self, i: &mut ExprReference) { + visit_expr_reference_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_repeat_mut(&mut self, i: &mut ExprRepeat) { + visit_expr_repeat_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_return_mut(&mut self, i: &mut ExprReturn) { + visit_expr_return_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_struct_mut(&mut self, i: &mut ExprStruct) { + visit_expr_struct_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_try_mut(&mut self, i: &mut ExprTry) { + visit_expr_try_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_try_block_mut(&mut self, i: &mut ExprTryBlock) { + visit_expr_try_block_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_tuple_mut(&mut self, i: &mut ExprTuple) { + visit_expr_tuple_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_type_mut(&mut self, i: &mut ExprType) { + visit_expr_type_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_unary_mut(&mut self, i: &mut ExprUnary) { + visit_expr_unary_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_unsafe_mut(&mut self, i: &mut ExprUnsafe) { + visit_expr_unsafe_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_expr_verbatim_mut(&mut self, i: &mut ExprVerbatim) { + visit_expr_verbatim_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_while_mut(&mut self, i: &mut ExprWhile) { + visit_expr_while_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_expr_yield_mut(&mut self, i: &mut ExprYield) { + visit_expr_yield_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_field_mut(&mut self, i: &mut Field) { + visit_field_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_field_pat_mut(&mut self, i: &mut FieldPat) { + visit_field_pat_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_field_value_mut(&mut self, i: &mut FieldValue) { + visit_field_value_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_fields_mut(&mut self, i: &mut Fields) { + visit_fields_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_fields_named_mut(&mut self, i: &mut FieldsNamed) { + visit_fields_named_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_fields_unnamed_mut(&mut self, i: &mut FieldsUnnamed) { + visit_fields_unnamed_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_file_mut(&mut self, i: &mut File) { + visit_file_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_fn_arg_mut(&mut self, i: &mut FnArg) { + visit_fn_arg_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_fn_decl_mut(&mut self, i: &mut FnDecl) { + visit_fn_decl_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_mut(&mut self, i: &mut ForeignItem) { + visit_foreign_item_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_fn_mut(&mut self, i: &mut ForeignItemFn) { + visit_foreign_item_fn_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_macro_mut(&mut self, i: &mut ForeignItemMacro) { + visit_foreign_item_macro_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_static_mut(&mut self, i: &mut ForeignItemStatic) { + visit_foreign_item_static_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_type_mut(&mut self, i: &mut ForeignItemType) { + visit_foreign_item_type_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_foreign_item_verbatim_mut(&mut self, i: &mut ForeignItemVerbatim) { + visit_foreign_item_verbatim_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_generic_argument_mut(&mut self, i: &mut GenericArgument) { + visit_generic_argument_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_generic_method_argument_mut(&mut self, i: &mut GenericMethodArgument) { + visit_generic_method_argument_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_generic_param_mut(&mut self, i: &mut GenericParam) { + visit_generic_param_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_generics_mut(&mut self, i: &mut Generics) { + visit_generics_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_mut(&mut self, i: &mut ImplItem) { + visit_impl_item_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_const_mut(&mut self, i: &mut ImplItemConst) { + visit_impl_item_const_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_existential_mut(&mut self, i: &mut ImplItemExistential) { + visit_impl_item_existential_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_macro_mut(&mut self, i: &mut ImplItemMacro) { + visit_impl_item_macro_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_method_mut(&mut self, i: &mut ImplItemMethod) { + visit_impl_item_method_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_type_mut(&mut self, i: &mut ImplItemType) { + visit_impl_item_type_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_impl_item_verbatim_mut(&mut self, i: &mut ImplItemVerbatim) { + visit_impl_item_verbatim_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_index_mut(&mut self, i: &mut Index) { + visit_index_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_mut(&mut self, i: &mut Item) { + visit_item_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_const_mut(&mut self, i: &mut ItemConst) { + visit_item_const_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_enum_mut(&mut self, i: &mut ItemEnum) { + visit_item_enum_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_existential_mut(&mut self, i: &mut ItemExistential) { + visit_item_existential_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_extern_crate_mut(&mut self, i: &mut ItemExternCrate) { + visit_item_extern_crate_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_fn_mut(&mut self, i: &mut ItemFn) { + visit_item_fn_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_foreign_mod_mut(&mut self, i: &mut ItemForeignMod) { + visit_item_foreign_mod_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_impl_mut(&mut self, i: &mut ItemImpl) { + visit_item_impl_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_macro_mut(&mut self, i: &mut ItemMacro) { + visit_item_macro_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_macro2_mut(&mut self, i: &mut ItemMacro2) { + visit_item_macro2_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_mod_mut(&mut self, i: &mut ItemMod) { + visit_item_mod_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_static_mut(&mut self, i: &mut ItemStatic) { + visit_item_static_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_struct_mut(&mut self, i: &mut ItemStruct) { + visit_item_struct_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_trait_mut(&mut self, i: &mut ItemTrait) { + visit_item_trait_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_trait_alias_mut(&mut self, i: &mut ItemTraitAlias) { + visit_item_trait_alias_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_type_mut(&mut self, i: &mut ItemType) { + visit_item_type_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_union_mut(&mut self, i: &mut ItemUnion) { + visit_item_union_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_use_mut(&mut self, i: &mut ItemUse) { + visit_item_use_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_item_verbatim_mut(&mut self, i: &mut ItemVerbatim) { + visit_item_verbatim_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_label_mut(&mut self, i: &mut Label) { + visit_label_mut(self, i) + } + fn visit_lifetime_mut(&mut self, i: &mut Lifetime) { + visit_lifetime_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lifetime_def_mut(&mut self, i: &mut LifetimeDef) { + visit_lifetime_def_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_mut(&mut self, i: &mut Lit) { + visit_lit_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_bool_mut(&mut self, i: &mut LitBool) { + visit_lit_bool_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_byte_mut(&mut self, i: &mut LitByte) { + visit_lit_byte_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_byte_str_mut(&mut self, i: &mut LitByteStr) { + visit_lit_byte_str_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_char_mut(&mut self, i: &mut LitChar) { + visit_lit_char_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_float_mut(&mut self, i: &mut LitFloat) { + visit_lit_float_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_int_mut(&mut self, i: &mut LitInt) { + visit_lit_int_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_str_mut(&mut self, i: &mut LitStr) { + visit_lit_str_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_lit_verbatim_mut(&mut self, i: &mut LitVerbatim) { + visit_lit_verbatim_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_local_mut(&mut self, i: &mut Local) { + visit_local_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_macro_mut(&mut self, i: &mut Macro) { + visit_macro_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_macro_delimiter_mut(&mut self, i: &mut MacroDelimiter) { + visit_macro_delimiter_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_member_mut(&mut self, i: &mut Member) { + visit_member_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_meta_mut(&mut self, i: &mut Meta) { + visit_meta_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_meta_list_mut(&mut self, i: &mut MetaList) { + visit_meta_list_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_meta_name_value_mut(&mut self, i: &mut MetaNameValue) { + visit_meta_name_value_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_method_sig_mut(&mut self, i: &mut MethodSig) { + visit_method_sig_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_method_turbofish_mut(&mut self, i: &mut MethodTurbofish) { + visit_method_turbofish_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_nested_meta_mut(&mut self, i: &mut NestedMeta) { + visit_nested_meta_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_parenthesized_generic_arguments_mut(&mut self, i: &mut ParenthesizedGenericArguments) { + visit_parenthesized_generic_arguments_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_mut(&mut self, i: &mut Pat) { + visit_pat_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_box_mut(&mut self, i: &mut PatBox) { + visit_pat_box_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_ident_mut(&mut self, i: &mut PatIdent) { + visit_pat_ident_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_lit_mut(&mut self, i: &mut PatLit) { + visit_pat_lit_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_macro_mut(&mut self, i: &mut PatMacro) { + visit_pat_macro_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_path_mut(&mut self, i: &mut PatPath) { + visit_pat_path_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_range_mut(&mut self, i: &mut PatRange) { + visit_pat_range_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_ref_mut(&mut self, i: &mut PatRef) { + visit_pat_ref_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_slice_mut(&mut self, i: &mut PatSlice) { + visit_pat_slice_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_struct_mut(&mut self, i: &mut PatStruct) { + visit_pat_struct_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_tuple_mut(&mut self, i: &mut PatTuple) { + visit_pat_tuple_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_tuple_struct_mut(&mut self, i: &mut PatTupleStruct) { + visit_pat_tuple_struct_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_verbatim_mut(&mut self, i: &mut PatVerbatim) { + visit_pat_verbatim_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_pat_wild_mut(&mut self, i: &mut PatWild) { + visit_pat_wild_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_path_mut(&mut self, i: &mut Path) { + visit_path_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_path_arguments_mut(&mut self, i: &mut PathArguments) { + visit_path_arguments_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_path_segment_mut(&mut self, i: &mut PathSegment) { + visit_path_segment_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_predicate_eq_mut(&mut self, i: &mut PredicateEq) { + visit_predicate_eq_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_predicate_lifetime_mut(&mut self, i: &mut PredicateLifetime) { + visit_predicate_lifetime_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_predicate_type_mut(&mut self, i: &mut PredicateType) { + visit_predicate_type_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_qself_mut(&mut self, i: &mut QSelf) { + visit_qself_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_range_limits_mut(&mut self, i: &mut RangeLimits) { + visit_range_limits_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_return_type_mut(&mut self, i: &mut ReturnType) { + visit_return_type_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_stmt_mut(&mut self, i: &mut Stmt) { + visit_stmt_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_trait_bound_mut(&mut self, i: &mut TraitBound) { + visit_trait_bound_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_trait_bound_modifier_mut(&mut self, i: &mut TraitBoundModifier) { + visit_trait_bound_modifier_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_mut(&mut self, i: &mut TraitItem) { + visit_trait_item_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_const_mut(&mut self, i: &mut TraitItemConst) { + visit_trait_item_const_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_macro_mut(&mut self, i: &mut TraitItemMacro) { + visit_trait_item_macro_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_method_mut(&mut self, i: &mut TraitItemMethod) { + visit_trait_item_method_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_type_mut(&mut self, i: &mut TraitItemType) { + visit_trait_item_type_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_trait_item_verbatim_mut(&mut self, i: &mut TraitItemVerbatim) { + visit_trait_item_verbatim_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_mut(&mut self, i: &mut Type) { + visit_type_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_array_mut(&mut self, i: &mut TypeArray) { + visit_type_array_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_bare_fn_mut(&mut self, i: &mut TypeBareFn) { + visit_type_bare_fn_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_group_mut(&mut self, i: &mut TypeGroup) { + visit_type_group_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_impl_trait_mut(&mut self, i: &mut TypeImplTrait) { + visit_type_impl_trait_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_infer_mut(&mut self, i: &mut TypeInfer) { + visit_type_infer_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_macro_mut(&mut self, i: &mut TypeMacro) { + visit_type_macro_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_never_mut(&mut self, i: &mut TypeNever) { + visit_type_never_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_param_mut(&mut self, i: &mut TypeParam) { + visit_type_param_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_param_bound_mut(&mut self, i: &mut TypeParamBound) { + visit_type_param_bound_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_paren_mut(&mut self, i: &mut TypeParen) { + visit_type_paren_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_path_mut(&mut self, i: &mut TypePath) { + visit_type_path_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_ptr_mut(&mut self, i: &mut TypePtr) { + visit_type_ptr_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_reference_mut(&mut self, i: &mut TypeReference) { + visit_type_reference_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_slice_mut(&mut self, i: &mut TypeSlice) { + visit_type_slice_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_trait_object_mut(&mut self, i: &mut TypeTraitObject) { + visit_type_trait_object_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_tuple_mut(&mut self, i: &mut TypeTuple) { + visit_type_tuple_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_type_verbatim_mut(&mut self, i: &mut TypeVerbatim) { + visit_type_verbatim_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_un_op_mut(&mut self, i: &mut UnOp) { + visit_un_op_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_use_glob_mut(&mut self, i: &mut UseGlob) { + visit_use_glob_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_use_group_mut(&mut self, i: &mut UseGroup) { + visit_use_group_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_use_name_mut(&mut self, i: &mut UseName) { + visit_use_name_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_use_path_mut(&mut self, i: &mut UsePath) { + visit_use_path_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_use_rename_mut(&mut self, i: &mut UseRename) { + visit_use_rename_mut(self, i) + } + #[cfg(feature = "full")] + fn visit_use_tree_mut(&mut self, i: &mut UseTree) { + visit_use_tree_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_variant_mut(&mut self, i: &mut Variant) { + visit_variant_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_vis_crate_mut(&mut self, i: &mut VisCrate) { + visit_vis_crate_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_vis_public_mut(&mut self, i: &mut VisPublic) { + visit_vis_public_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_vis_restricted_mut(&mut self, i: &mut VisRestricted) { + visit_vis_restricted_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_visibility_mut(&mut self, i: &mut Visibility) { + visit_visibility_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_where_clause_mut(&mut self, i: &mut WhereClause) { + visit_where_clause_mut(self, i) + } + #[cfg(any(feature = "derive", feature = "full"))] + fn visit_where_predicate_mut(&mut self, i: &mut WherePredicate) { + visit_where_predicate_mut(self, i) + } + fn visit_span_mut(&mut self, i: &mut Span) { + visit_span_mut(self, i) + } + fn visit_ident_mut(&mut self, i: &mut Ident) { + visit_ident_mut(self, i) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_abi_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Abi) { + tokens_helper(_visitor, &mut _i.extern_token.span); + if let Some(ref mut it) = _i.name { + _visitor.visit_lit_str_mut(it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_angle_bracketed_generic_arguments_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut AngleBracketedGenericArguments, +) { + if let Some(ref mut it) = _i.colon2_token { + tokens_helper(_visitor, &mut it.spans) + }; + tokens_helper(_visitor, &mut _i.lt_token.spans); + for mut el in Punctuated::pairs_mut(&mut _i.args) { + let it = el.value_mut(); + _visitor.visit_generic_argument_mut(it) + } + tokens_helper(_visitor, &mut _i.gt_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_arg_captured_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgCaptured) { + _visitor.visit_pat_mut(&mut _i.pat); + tokens_helper(_visitor, &mut _i.colon_token.spans); + _visitor.visit_type_mut(&mut _i.ty); +} +#[cfg(feature = "full")] +pub fn visit_arg_self_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelf) { + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + tokens_helper(_visitor, &mut _i.self_token.span); +} +#[cfg(feature = "full")] +pub fn visit_arg_self_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ArgSelfRef) { + tokens_helper(_visitor, &mut _i.and_token.spans); + if let Some(ref mut it) = _i.lifetime { + _visitor.visit_lifetime_mut(it) + }; + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + tokens_helper(_visitor, &mut _i.self_token.span); +} +#[cfg(feature = "full")] +pub fn visit_arm_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Arm) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.leading_vert { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.pats) { + let it = el.value_mut(); + _visitor.visit_pat_mut(it) + } + if let Some(ref mut it) = _i.guard { + tokens_helper(_visitor, &mut (it).0.span); + _visitor.visit_expr_mut(&mut *(it).1); + }; + tokens_helper(_visitor, &mut _i.fat_arrow_token.spans); + _visitor.visit_expr_mut(&mut *_i.body); + if let Some(ref mut it) = _i.comma { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_attr_style_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut AttrStyle) { + match *_i { + AttrStyle::Outer => {} + AttrStyle::Inner(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_attribute_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Attribute) { + tokens_helper(_visitor, &mut _i.pound_token.spans); + _visitor.visit_attr_style_mut(&mut _i.style); + tokens_helper(_visitor, &mut _i.bracket_token.span); + _visitor.visit_path_mut(&mut _i.path); + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_bare_fn_arg_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArg) { + if let Some(ref mut it) = _i.name { + _visitor.visit_bare_fn_arg_name_mut(&mut (it).0); + tokens_helper(_visitor, &mut (it).1.spans); + }; + _visitor.visit_type_mut(&mut _i.ty); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_bare_fn_arg_name_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BareFnArgName) { + match *_i { + BareFnArgName::Named(ref mut _binding_0) => { + _visitor.visit_ident_mut(_binding_0); + } + BareFnArgName::Wild(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_bin_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BinOp) { + match *_i { + BinOp::Add(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Sub(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Mul(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Div(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Rem(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::And(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Or(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::BitXor(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::BitAnd(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::BitOr(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Shl(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Shr(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Eq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Lt(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Le(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Ne(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Ge(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::Gt(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::AddEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::SubEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::MulEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::DivEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::RemEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::BitXorEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::BitAndEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::BitOrEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::ShlEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + BinOp::ShrEq(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_binding_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Binding) { + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_type_mut(&mut _i.ty); +} +#[cfg(feature = "full")] +pub fn visit_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Block) { + tokens_helper(_visitor, &mut _i.brace_token.span); + for it in &mut _i.stmts { + _visitor.visit_stmt_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_bound_lifetimes_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut BoundLifetimes) { + tokens_helper(_visitor, &mut _i.for_token.span); + tokens_helper(_visitor, &mut _i.lt_token.spans); + for mut el in Punctuated::pairs_mut(&mut _i.lifetimes) { + let it = el.value_mut(); + _visitor.visit_lifetime_def_mut(it) + } + tokens_helper(_visitor, &mut _i.gt_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_const_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ConstParam) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.const_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.colon_token.spans); + _visitor.visit_type_mut(&mut _i.ty); + if let Some(ref mut it) = _i.eq_token { + tokens_helper(_visitor, &mut it.spans) + }; + if let Some(ref mut it) = _i.default { + _visitor.visit_expr_mut(it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_constraint_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Constraint) { + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.colon_token.spans); + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } +} +#[cfg(feature = "derive")] +pub fn visit_data_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Data) { + match *_i { + Data::Struct(ref mut _binding_0) => { + _visitor.visit_data_struct_mut(_binding_0); + } + Data::Enum(ref mut _binding_0) => { + _visitor.visit_data_enum_mut(_binding_0); + } + Data::Union(ref mut _binding_0) => { + _visitor.visit_data_union_mut(_binding_0); + } + } +} +#[cfg(feature = "derive")] +pub fn visit_data_enum_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataEnum) { + tokens_helper(_visitor, &mut _i.enum_token.span); + tokens_helper(_visitor, &mut _i.brace_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.variants) { + let it = el.value_mut(); + _visitor.visit_variant_mut(it) + } +} +#[cfg(feature = "derive")] +pub fn visit_data_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataStruct) { + tokens_helper(_visitor, &mut _i.struct_token.span); + _visitor.visit_fields_mut(&mut _i.fields); + if let Some(ref mut it) = _i.semi_token { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "derive")] +pub fn visit_data_union_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DataUnion) { + tokens_helper(_visitor, &mut _i.union_token.span); + _visitor.visit_fields_named_mut(&mut _i.fields); +} +#[cfg(feature = "derive")] +pub fn visit_derive_input_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut DeriveInput) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + _visitor.visit_data_mut(&mut _i.data); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Expr) { + match *_i { + Expr::Box(ref mut _binding_0) => { + full!(_visitor.visit_expr_box_mut(_binding_0)); + } + Expr::InPlace(ref mut _binding_0) => { + full!(_visitor.visit_expr_in_place_mut(_binding_0)); + } + Expr::Array(ref mut _binding_0) => { + full!(_visitor.visit_expr_array_mut(_binding_0)); + } + Expr::Call(ref mut _binding_0) => { + _visitor.visit_expr_call_mut(_binding_0); + } + Expr::MethodCall(ref mut _binding_0) => { + full!(_visitor.visit_expr_method_call_mut(_binding_0)); + } + Expr::Tuple(ref mut _binding_0) => { + full!(_visitor.visit_expr_tuple_mut(_binding_0)); + } + Expr::Binary(ref mut _binding_0) => { + _visitor.visit_expr_binary_mut(_binding_0); + } + Expr::Unary(ref mut _binding_0) => { + _visitor.visit_expr_unary_mut(_binding_0); + } + Expr::Lit(ref mut _binding_0) => { + _visitor.visit_expr_lit_mut(_binding_0); + } + Expr::Cast(ref mut _binding_0) => { + _visitor.visit_expr_cast_mut(_binding_0); + } + Expr::Type(ref mut _binding_0) => { + full!(_visitor.visit_expr_type_mut(_binding_0)); + } + Expr::Let(ref mut _binding_0) => { + full!(_visitor.visit_expr_let_mut(_binding_0)); + } + Expr::If(ref mut _binding_0) => { + full!(_visitor.visit_expr_if_mut(_binding_0)); + } + Expr::While(ref mut _binding_0) => { + full!(_visitor.visit_expr_while_mut(_binding_0)); + } + Expr::ForLoop(ref mut _binding_0) => { + full!(_visitor.visit_expr_for_loop_mut(_binding_0)); + } + Expr::Loop(ref mut _binding_0) => { + full!(_visitor.visit_expr_loop_mut(_binding_0)); + } + Expr::Match(ref mut _binding_0) => { + full!(_visitor.visit_expr_match_mut(_binding_0)); + } + Expr::Closure(ref mut _binding_0) => { + full!(_visitor.visit_expr_closure_mut(_binding_0)); + } + Expr::Unsafe(ref mut _binding_0) => { + full!(_visitor.visit_expr_unsafe_mut(_binding_0)); + } + Expr::Block(ref mut _binding_0) => { + full!(_visitor.visit_expr_block_mut(_binding_0)); + } + Expr::Assign(ref mut _binding_0) => { + full!(_visitor.visit_expr_assign_mut(_binding_0)); + } + Expr::AssignOp(ref mut _binding_0) => { + full!(_visitor.visit_expr_assign_op_mut(_binding_0)); + } + Expr::Field(ref mut _binding_0) => { + _visitor.visit_expr_field_mut(_binding_0); + } + Expr::Index(ref mut _binding_0) => { + _visitor.visit_expr_index_mut(_binding_0); + } + Expr::Range(ref mut _binding_0) => { + full!(_visitor.visit_expr_range_mut(_binding_0)); + } + Expr::Path(ref mut _binding_0) => { + _visitor.visit_expr_path_mut(_binding_0); + } + Expr::Reference(ref mut _binding_0) => { + full!(_visitor.visit_expr_reference_mut(_binding_0)); + } + Expr::Break(ref mut _binding_0) => { + full!(_visitor.visit_expr_break_mut(_binding_0)); + } + Expr::Continue(ref mut _binding_0) => { + full!(_visitor.visit_expr_continue_mut(_binding_0)); + } + Expr::Return(ref mut _binding_0) => { + full!(_visitor.visit_expr_return_mut(_binding_0)); + } + Expr::Macro(ref mut _binding_0) => { + full!(_visitor.visit_expr_macro_mut(_binding_0)); + } + Expr::Struct(ref mut _binding_0) => { + full!(_visitor.visit_expr_struct_mut(_binding_0)); + } + Expr::Repeat(ref mut _binding_0) => { + full!(_visitor.visit_expr_repeat_mut(_binding_0)); + } + Expr::Paren(ref mut _binding_0) => { + _visitor.visit_expr_paren_mut(_binding_0); + } + Expr::Group(ref mut _binding_0) => { + full!(_visitor.visit_expr_group_mut(_binding_0)); + } + Expr::Try(ref mut _binding_0) => { + full!(_visitor.visit_expr_try_mut(_binding_0)); + } + Expr::Async(ref mut _binding_0) => { + full!(_visitor.visit_expr_async_mut(_binding_0)); + } + Expr::TryBlock(ref mut _binding_0) => { + full!(_visitor.visit_expr_try_block_mut(_binding_0)); + } + Expr::Yield(ref mut _binding_0) => { + full!(_visitor.visit_expr_yield_mut(_binding_0)); + } + Expr::Verbatim(ref mut _binding_0) => { + _visitor.visit_expr_verbatim_mut(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_expr_array_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprArray) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.bracket_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.elems) { + let it = el.value_mut(); + _visitor.visit_expr_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_expr_assign_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssign) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.left); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_expr_mut(&mut *_i.right); +} +#[cfg(feature = "full")] +pub fn visit_expr_assign_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAssignOp) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.left); + _visitor.visit_bin_op_mut(&mut _i.op); + _visitor.visit_expr_mut(&mut *_i.right); +} +#[cfg(feature = "full")] +pub fn visit_expr_async_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprAsync) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.async_token.span); + if let Some(ref mut it) = _i.capture { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_block_mut(&mut _i.block); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_binary_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBinary) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.left); + _visitor.visit_bin_op_mut(&mut _i.op); + _visitor.visit_expr_mut(&mut *_i.right); +} +#[cfg(feature = "full")] +pub fn visit_expr_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBlock) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.label { + _visitor.visit_label_mut(it) + }; + _visitor.visit_block_mut(&mut _i.block); +} +#[cfg(feature = "full")] +pub fn visit_expr_box_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBox) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.box_token.span); + _visitor.visit_expr_mut(&mut *_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_expr_break_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprBreak) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.break_token.span); + if let Some(ref mut it) = _i.label { + _visitor.visit_lifetime_mut(it) + }; + if let Some(ref mut it) = _i.expr { + _visitor.visit_expr_mut(&mut **it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_call_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCall) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.func); + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.args) { + let it = el.value_mut(); + _visitor.visit_expr_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_cast_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprCast) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.expr); + tokens_helper(_visitor, &mut _i.as_token.span); + _visitor.visit_type_mut(&mut *_i.ty); +} +#[cfg(feature = "full")] +pub fn visit_expr_closure_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprClosure) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.asyncness { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.movability { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.capture { + tokens_helper(_visitor, &mut it.span) + }; + tokens_helper(_visitor, &mut _i.or1_token.spans); + for mut el in Punctuated::pairs_mut(&mut _i.inputs) { + let it = el.value_mut(); + _visitor.visit_fn_arg_mut(it) + } + tokens_helper(_visitor, &mut _i.or2_token.spans); + _visitor.visit_return_type_mut(&mut _i.output); + _visitor.visit_expr_mut(&mut *_i.body); +} +#[cfg(feature = "full")] +pub fn visit_expr_continue_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprContinue) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.continue_token.span); + if let Some(ref mut it) = _i.label { + _visitor.visit_lifetime_mut(it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_field_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprField) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.base); + tokens_helper(_visitor, &mut _i.dot_token.spans); + _visitor.visit_member_mut(&mut _i.member); +} +#[cfg(feature = "full")] +pub fn visit_expr_for_loop_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprForLoop) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.label { + _visitor.visit_label_mut(it) + }; + tokens_helper(_visitor, &mut _i.for_token.span); + _visitor.visit_pat_mut(&mut *_i.pat); + tokens_helper(_visitor, &mut _i.in_token.span); + _visitor.visit_expr_mut(&mut *_i.expr); + _visitor.visit_block_mut(&mut _i.body); +} +#[cfg(feature = "full")] +pub fn visit_expr_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprGroup) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.group_token.span); + _visitor.visit_expr_mut(&mut *_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_expr_if_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIf) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.if_token.span); + _visitor.visit_expr_mut(&mut *_i.cond); + _visitor.visit_block_mut(&mut _i.then_branch); + if let Some(ref mut it) = _i.else_branch { + tokens_helper(_visitor, &mut (it).0.span); + _visitor.visit_expr_mut(&mut *(it).1); + }; +} +#[cfg(feature = "full")] +pub fn visit_expr_in_place_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprInPlace) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.place); + tokens_helper(_visitor, &mut _i.arrow_token.spans); + _visitor.visit_expr_mut(&mut *_i.value); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_index_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprIndex) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.expr); + tokens_helper(_visitor, &mut _i.bracket_token.span); + _visitor.visit_expr_mut(&mut *_i.index); +} +#[cfg(feature = "full")] +pub fn visit_expr_let_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLet) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.let_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.pats) { + let it = el.value_mut(); + _visitor.visit_pat_mut(it) + } + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_expr_mut(&mut *_i.expr); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLit) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_lit_mut(&mut _i.lit); +} +#[cfg(feature = "full")] +pub fn visit_expr_loop_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprLoop) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.label { + _visitor.visit_label_mut(it) + }; + tokens_helper(_visitor, &mut _i.loop_token.span); + _visitor.visit_block_mut(&mut _i.body); +} +#[cfg(feature = "full")] +pub fn visit_expr_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMacro) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_macro_mut(&mut _i.mac); +} +#[cfg(feature = "full")] +pub fn visit_expr_match_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMatch) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.match_token.span); + _visitor.visit_expr_mut(&mut *_i.expr); + tokens_helper(_visitor, &mut _i.brace_token.span); + for it in &mut _i.arms { + _visitor.visit_arm_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_expr_method_call_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprMethodCall) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.receiver); + tokens_helper(_visitor, &mut _i.dot_token.spans); + _visitor.visit_ident_mut(&mut _i.method); + if let Some(ref mut it) = _i.turbofish { + _visitor.visit_method_turbofish_mut(it) + }; + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.args) { + let it = el.value_mut(); + _visitor.visit_expr_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_paren_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprParen) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.paren_token.span); + _visitor.visit_expr_mut(&mut *_i.expr); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprPath) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.qself { + _visitor.visit_qself_mut(it) + }; + _visitor.visit_path_mut(&mut _i.path); +} +#[cfg(feature = "full")] +pub fn visit_expr_range_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRange) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.from { + _visitor.visit_expr_mut(&mut **it) + }; + _visitor.visit_range_limits_mut(&mut _i.limits); + if let Some(ref mut it) = _i.to { + _visitor.visit_expr_mut(&mut **it) + }; +} +#[cfg(feature = "full")] +pub fn visit_expr_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprReference) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.and_token.spans); + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_expr_mut(&mut *_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_expr_repeat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprRepeat) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.bracket_token.span); + _visitor.visit_expr_mut(&mut *_i.expr); + tokens_helper(_visitor, &mut _i.semi_token.spans); + _visitor.visit_expr_mut(&mut *_i.len); +} +#[cfg(feature = "full")] +pub fn visit_expr_return_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprReturn) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.return_token.span); + if let Some(ref mut it) = _i.expr { + _visitor.visit_expr_mut(&mut **it) + }; +} +#[cfg(feature = "full")] +pub fn visit_expr_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprStruct) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_path_mut(&mut _i.path); + tokens_helper(_visitor, &mut _i.brace_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.fields) { + let it = el.value_mut(); + _visitor.visit_field_value_mut(it) + } + if let Some(ref mut it) = _i.dot2_token { + tokens_helper(_visitor, &mut it.spans) + }; + if let Some(ref mut it) = _i.rest { + _visitor.visit_expr_mut(&mut **it) + }; +} +#[cfg(feature = "full")] +pub fn visit_expr_try_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTry) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.expr); + tokens_helper(_visitor, &mut _i.question_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_expr_try_block_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTryBlock) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.try_token.span); + _visitor.visit_block_mut(&mut _i.block); +} +#[cfg(feature = "full")] +pub fn visit_expr_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprTuple) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.elems) { + let it = el.value_mut(); + _visitor.visit_expr_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_expr_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprType) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_expr_mut(&mut *_i.expr); + tokens_helper(_visitor, &mut _i.colon_token.spans); + _visitor.visit_type_mut(&mut *_i.ty); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_unary_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnary) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_un_op_mut(&mut _i.op); + _visitor.visit_expr_mut(&mut *_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_expr_unsafe_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprUnsafe) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.unsafe_token.span); + _visitor.visit_block_mut(&mut _i.block); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_expr_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprVerbatim) { + skip!(_i.tts); +} +#[cfg(feature = "full")] +pub fn visit_expr_while_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprWhile) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.label { + _visitor.visit_label_mut(it) + }; + tokens_helper(_visitor, &mut _i.while_token.span); + _visitor.visit_expr_mut(&mut *_i.cond); + _visitor.visit_block_mut(&mut _i.body); +} +#[cfg(feature = "full")] +pub fn visit_expr_yield_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ExprYield) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.yield_token.span); + if let Some(ref mut it) = _i.expr { + _visitor.visit_expr_mut(&mut **it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_field_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Field) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + if let Some(ref mut it) = _i.ident { + _visitor.visit_ident_mut(it) + }; + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + _visitor.visit_type_mut(&mut _i.ty); +} +#[cfg(feature = "full")] +pub fn visit_field_pat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldPat) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_member_mut(&mut _i.member); + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + _visitor.visit_pat_mut(&mut *_i.pat); +} +#[cfg(feature = "full")] +pub fn visit_field_value_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldValue) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_member_mut(&mut _i.member); + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + _visitor.visit_expr_mut(&mut _i.expr); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_fields_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Fields) { + match *_i { + Fields::Named(ref mut _binding_0) => { + _visitor.visit_fields_named_mut(_binding_0); + } + Fields::Unnamed(ref mut _binding_0) => { + _visitor.visit_fields_unnamed_mut(_binding_0); + } + Fields::Unit => {} + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_fields_named_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsNamed) { + tokens_helper(_visitor, &mut _i.brace_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.named) { + let it = el.value_mut(); + _visitor.visit_field_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_fields_unnamed_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FieldsUnnamed) { + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.unnamed) { + let it = el.value_mut(); + _visitor.visit_field_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_file_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut File) { + skip!(_i.shebang); + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + for it in &mut _i.items { + _visitor.visit_item_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_fn_arg_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FnArg) { + match *_i { + FnArg::SelfRef(ref mut _binding_0) => { + _visitor.visit_arg_self_ref_mut(_binding_0); + } + FnArg::SelfValue(ref mut _binding_0) => { + _visitor.visit_arg_self_mut(_binding_0); + } + FnArg::Captured(ref mut _binding_0) => { + _visitor.visit_arg_captured_mut(_binding_0); + } + FnArg::Inferred(ref mut _binding_0) => { + _visitor.visit_pat_mut(_binding_0); + } + FnArg::Ignored(ref mut _binding_0) => { + _visitor.visit_type_mut(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_fn_decl_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut FnDecl) { + tokens_helper(_visitor, &mut _i.fn_token.span); + _visitor.visit_generics_mut(&mut _i.generics); + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.inputs) { + let it = el.value_mut(); + _visitor.visit_fn_arg_mut(it) + } + if let Some(ref mut it) = _i.variadic { + tokens_helper(_visitor, &mut it.spans) + }; + _visitor.visit_return_type_mut(&mut _i.output); +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItem) { + match *_i { + ForeignItem::Fn(ref mut _binding_0) => { + _visitor.visit_foreign_item_fn_mut(_binding_0); + } + ForeignItem::Static(ref mut _binding_0) => { + _visitor.visit_foreign_item_static_mut(_binding_0); + } + ForeignItem::Type(ref mut _binding_0) => { + _visitor.visit_foreign_item_type_mut(_binding_0); + } + ForeignItem::Macro(ref mut _binding_0) => { + _visitor.visit_foreign_item_macro_mut(_binding_0); + } + ForeignItem::Verbatim(ref mut _binding_0) => { + _visitor.visit_foreign_item_verbatim_mut(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_fn_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ForeignItemFn) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_fn_decl_mut(&mut *_i.decl); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_macro_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ForeignItemMacro, +) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_macro_mut(&mut _i.mac); + if let Some(ref mut it) = _i.semi_token { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_static_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ForeignItemStatic, +) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.static_token.span); + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.colon_token.spans); + _visitor.visit_type_mut(&mut *_i.ty); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_type_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ForeignItemType, +) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.type_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_foreign_item_verbatim_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ForeignItemVerbatim, +) { + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_generic_argument_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut GenericArgument, +) { + match *_i { + GenericArgument::Lifetime(ref mut _binding_0) => { + _visitor.visit_lifetime_mut(_binding_0); + } + GenericArgument::Type(ref mut _binding_0) => { + _visitor.visit_type_mut(_binding_0); + } + GenericArgument::Binding(ref mut _binding_0) => { + _visitor.visit_binding_mut(_binding_0); + } + GenericArgument::Constraint(ref mut _binding_0) => { + _visitor.visit_constraint_mut(_binding_0); + } + GenericArgument::Const(ref mut _binding_0) => { + _visitor.visit_expr_mut(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_generic_method_argument_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut GenericMethodArgument, +) { + match *_i { + GenericMethodArgument::Type(ref mut _binding_0) => { + _visitor.visit_type_mut(_binding_0); + } + GenericMethodArgument::Const(ref mut _binding_0) => { + _visitor.visit_expr_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_generic_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut GenericParam) { + match *_i { + GenericParam::Type(ref mut _binding_0) => { + _visitor.visit_type_param_mut(_binding_0); + } + GenericParam::Lifetime(ref mut _binding_0) => { + _visitor.visit_lifetime_def_mut(_binding_0); + } + GenericParam::Const(ref mut _binding_0) => { + _visitor.visit_const_param_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_generics_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Generics) { + if let Some(ref mut it) = _i.lt_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.params) { + let it = el.value_mut(); + _visitor.visit_generic_param_mut(it) + } + if let Some(ref mut it) = _i.gt_token { + tokens_helper(_visitor, &mut it.spans) + }; + if let Some(ref mut it) = _i.where_clause { + _visitor.visit_where_clause_mut(it) + }; +} +#[cfg(feature = "full")] +pub fn visit_impl_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItem) { + match *_i { + ImplItem::Const(ref mut _binding_0) => { + _visitor.visit_impl_item_const_mut(_binding_0); + } + ImplItem::Method(ref mut _binding_0) => { + _visitor.visit_impl_item_method_mut(_binding_0); + } + ImplItem::Type(ref mut _binding_0) => { + _visitor.visit_impl_item_type_mut(_binding_0); + } + ImplItem::Existential(ref mut _binding_0) => { + _visitor.visit_impl_item_existential_mut(_binding_0); + } + ImplItem::Macro(ref mut _binding_0) => { + _visitor.visit_impl_item_macro_mut(_binding_0); + } + ImplItem::Verbatim(ref mut _binding_0) => { + _visitor.visit_impl_item_verbatim_mut(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_impl_item_const_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemConst) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + if let Some(ref mut it) = _i.defaultness { + tokens_helper(_visitor, &mut it.span) + }; + tokens_helper(_visitor, &mut _i.const_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.colon_token.spans); + _visitor.visit_type_mut(&mut _i.ty); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_expr_mut(&mut _i.expr); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_impl_item_existential_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ImplItemExistential, +) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.existential_token.span); + tokens_helper(_visitor, &mut _i.type_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_impl_item_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemMacro) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_macro_mut(&mut _i.mac); + if let Some(ref mut it) = _i.semi_token { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_impl_item_method_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemMethod) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + if let Some(ref mut it) = _i.defaultness { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_method_sig_mut(&mut _i.sig); + _visitor.visit_block_mut(&mut _i.block); +} +#[cfg(feature = "full")] +pub fn visit_impl_item_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ImplItemType) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + if let Some(ref mut it) = _i.defaultness { + tokens_helper(_visitor, &mut it.span) + }; + tokens_helper(_visitor, &mut _i.type_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_type_mut(&mut _i.ty); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_impl_item_verbatim_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ImplItemVerbatim, +) { + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_index_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Index) { + skip!(_i.index); + _visitor.visit_span_mut(&mut _i.span); +} +#[cfg(feature = "full")] +pub fn visit_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Item) { + match *_i { + Item::ExternCrate(ref mut _binding_0) => { + _visitor.visit_item_extern_crate_mut(_binding_0); + } + Item::Use(ref mut _binding_0) => { + _visitor.visit_item_use_mut(_binding_0); + } + Item::Static(ref mut _binding_0) => { + _visitor.visit_item_static_mut(_binding_0); + } + Item::Const(ref mut _binding_0) => { + _visitor.visit_item_const_mut(_binding_0); + } + Item::Fn(ref mut _binding_0) => { + _visitor.visit_item_fn_mut(_binding_0); + } + Item::Mod(ref mut _binding_0) => { + _visitor.visit_item_mod_mut(_binding_0); + } + Item::ForeignMod(ref mut _binding_0) => { + _visitor.visit_item_foreign_mod_mut(_binding_0); + } + Item::Type(ref mut _binding_0) => { + _visitor.visit_item_type_mut(_binding_0); + } + Item::Existential(ref mut _binding_0) => { + _visitor.visit_item_existential_mut(_binding_0); + } + Item::Struct(ref mut _binding_0) => { + _visitor.visit_item_struct_mut(_binding_0); + } + Item::Enum(ref mut _binding_0) => { + _visitor.visit_item_enum_mut(_binding_0); + } + Item::Union(ref mut _binding_0) => { + _visitor.visit_item_union_mut(_binding_0); + } + Item::Trait(ref mut _binding_0) => { + _visitor.visit_item_trait_mut(_binding_0); + } + Item::TraitAlias(ref mut _binding_0) => { + _visitor.visit_item_trait_alias_mut(_binding_0); + } + Item::Impl(ref mut _binding_0) => { + _visitor.visit_item_impl_mut(_binding_0); + } + Item::Macro(ref mut _binding_0) => { + _visitor.visit_item_macro_mut(_binding_0); + } + Item::Macro2(ref mut _binding_0) => { + _visitor.visit_item_macro2_mut(_binding_0); + } + Item::Verbatim(ref mut _binding_0) => { + _visitor.visit_item_verbatim_mut(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_item_const_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemConst) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.const_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.colon_token.spans); + _visitor.visit_type_mut(&mut *_i.ty); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_expr_mut(&mut *_i.expr); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_enum_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemEnum) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.enum_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + tokens_helper(_visitor, &mut _i.brace_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.variants) { + let it = el.value_mut(); + _visitor.visit_variant_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_item_existential_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ItemExistential, +) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.existential_token.span); + tokens_helper(_visitor, &mut _i.type_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_extern_crate_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ItemExternCrate, +) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.extern_token.span); + tokens_helper(_visitor, &mut _i.crate_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + if let Some(ref mut it) = _i.rename { + tokens_helper(_visitor, &mut (it).0.span); + _visitor.visit_ident_mut(&mut (it).1); + }; + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_fn_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemFn) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + if let Some(ref mut it) = _i.constness { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.asyncness { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.unsafety { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.abi { + _visitor.visit_abi_mut(it) + }; + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_fn_decl_mut(&mut *_i.decl); + _visitor.visit_block_mut(&mut *_i.block); +} +#[cfg(feature = "full")] +pub fn visit_item_foreign_mod_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemForeignMod) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_abi_mut(&mut _i.abi); + tokens_helper(_visitor, &mut _i.brace_token.span); + for it in &mut _i.items { + _visitor.visit_foreign_item_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_item_impl_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemImpl) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.defaultness { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.unsafety { + tokens_helper(_visitor, &mut it.span) + }; + tokens_helper(_visitor, &mut _i.impl_token.span); + _visitor.visit_generics_mut(&mut _i.generics); + if let Some(ref mut it) = _i.trait_ { + if let Some(ref mut it) = (it).0 { + tokens_helper(_visitor, &mut it.spans) + }; + _visitor.visit_path_mut(&mut (it).1); + tokens_helper(_visitor, &mut (it).2.span); + }; + _visitor.visit_type_mut(&mut *_i.self_ty); + tokens_helper(_visitor, &mut _i.brace_token.span); + for it in &mut _i.items { + _visitor.visit_impl_item_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_item_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemMacro) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + if let Some(ref mut it) = _i.ident { + _visitor.visit_ident_mut(it) + }; + _visitor.visit_macro_mut(&mut _i.mac); + if let Some(ref mut it) = _i.semi_token { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_item_macro2_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemMacro2) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.macro_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.paren_token.span); + skip!(_i.args); + tokens_helper(_visitor, &mut _i.brace_token.span); + skip!(_i.body); +} +#[cfg(feature = "full")] +pub fn visit_item_mod_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemMod) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.mod_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + if let Some(ref mut it) = _i.content { + tokens_helper(_visitor, &mut (it).0.span); + for it in &mut (it).1 { + _visitor.visit_item_mut(it) + } + }; + if let Some(ref mut it) = _i.semi { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_item_static_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemStatic) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.static_token.span); + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.colon_token.spans); + _visitor.visit_type_mut(&mut *_i.ty); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_expr_mut(&mut *_i.expr); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemStruct) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.struct_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + _visitor.visit_fields_mut(&mut _i.fields); + if let Some(ref mut it) = _i.semi_token { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_item_trait_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemTrait) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + if let Some(ref mut it) = _i.unsafety { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.auto_token { + tokens_helper(_visitor, &mut it.span) + }; + tokens_helper(_visitor, &mut _i.trait_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.supertraits) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } + tokens_helper(_visitor, &mut _i.brace_token.span); + for it in &mut _i.items { + _visitor.visit_trait_item_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_item_trait_alias_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemTraitAlias) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.trait_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + tokens_helper(_visitor, &mut _i.eq_token.spans); + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemType) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.type_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_type_mut(&mut *_i.ty); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_union_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemUnion) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.union_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + _visitor.visit_fields_named_mut(&mut _i.fields); +} +#[cfg(feature = "full")] +pub fn visit_item_use_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemUse) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_visibility_mut(&mut _i.vis); + tokens_helper(_visitor, &mut _i.use_token.span); + if let Some(ref mut it) = _i.leading_colon { + tokens_helper(_visitor, &mut it.spans) + }; + _visitor.visit_use_tree_mut(&mut _i.tree); + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_item_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ItemVerbatim) { + skip!(_i.tts); +} +#[cfg(feature = "full")] +pub fn visit_label_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Label) { + _visitor.visit_lifetime_mut(&mut _i.name); + tokens_helper(_visitor, &mut _i.colon_token.spans); +} +pub fn visit_lifetime_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Lifetime) { + _visitor.visit_span_mut(&mut _i.apostrophe); + _visitor.visit_ident_mut(&mut _i.ident); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lifetime_def_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LifetimeDef) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_lifetime_mut(&mut _i.lifetime); + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_lifetime_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Lit) { + match *_i { + Lit::Str(ref mut _binding_0) => { + _visitor.visit_lit_str_mut(_binding_0); + } + Lit::ByteStr(ref mut _binding_0) => { + _visitor.visit_lit_byte_str_mut(_binding_0); + } + Lit::Byte(ref mut _binding_0) => { + _visitor.visit_lit_byte_mut(_binding_0); + } + Lit::Char(ref mut _binding_0) => { + _visitor.visit_lit_char_mut(_binding_0); + } + Lit::Int(ref mut _binding_0) => { + _visitor.visit_lit_int_mut(_binding_0); + } + Lit::Float(ref mut _binding_0) => { + _visitor.visit_lit_float_mut(_binding_0); + } + Lit::Bool(ref mut _binding_0) => { + _visitor.visit_lit_bool_mut(_binding_0); + } + Lit::Verbatim(ref mut _binding_0) => { + _visitor.visit_lit_verbatim_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_bool_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitBool) { + skip!(_i.value); + _visitor.visit_span_mut(&mut _i.span); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_byte_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitByte) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_byte_str_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitByteStr) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_char_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitChar) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_float_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitFloat) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_int_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitInt) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_str_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitStr) {} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_lit_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut LitVerbatim) { + skip!(_i.token); +} +#[cfg(feature = "full")] +pub fn visit_local_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Local) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.let_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.pats) { + let it = el.value_mut(); + _visitor.visit_pat_mut(it) + } + if let Some(ref mut it) = _i.ty { + tokens_helper(_visitor, &mut (it).0.spans); + _visitor.visit_type_mut(&mut *(it).1); + }; + if let Some(ref mut it) = _i.init { + tokens_helper(_visitor, &mut (it).0.spans); + _visitor.visit_expr_mut(&mut *(it).1); + }; + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Macro) { + _visitor.visit_path_mut(&mut _i.path); + tokens_helper(_visitor, &mut _i.bang_token.spans); + _visitor.visit_macro_delimiter_mut(&mut _i.delimiter); + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_macro_delimiter_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MacroDelimiter) { + match *_i { + MacroDelimiter::Paren(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.span); + } + MacroDelimiter::Brace(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.span); + } + MacroDelimiter::Bracket(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.span); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_member_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Member) { + match *_i { + Member::Named(ref mut _binding_0) => { + _visitor.visit_ident_mut(_binding_0); + } + Member::Unnamed(ref mut _binding_0) => { + _visitor.visit_index_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Meta) { + match *_i { + Meta::Word(ref mut _binding_0) => { + _visitor.visit_ident_mut(_binding_0); + } + Meta::List(ref mut _binding_0) => { + _visitor.visit_meta_list_mut(_binding_0); + } + Meta::NameValue(ref mut _binding_0) => { + _visitor.visit_meta_name_value_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_meta_list_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaList) { + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.nested) { + let it = el.value_mut(); + _visitor.visit_nested_meta_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_meta_name_value_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MetaNameValue) { + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_lit_mut(&mut _i.lit); +} +#[cfg(feature = "full")] +pub fn visit_method_sig_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut MethodSig) { + if let Some(ref mut it) = _i.constness { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.asyncness { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.unsafety { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.abi { + _visitor.visit_abi_mut(it) + }; + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_fn_decl_mut(&mut _i.decl); +} +#[cfg(feature = "full")] +pub fn visit_method_turbofish_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut MethodTurbofish, +) { + tokens_helper(_visitor, &mut _i.colon2_token.spans); + tokens_helper(_visitor, &mut _i.lt_token.spans); + for mut el in Punctuated::pairs_mut(&mut _i.args) { + let it = el.value_mut(); + _visitor.visit_generic_method_argument_mut(it) + } + tokens_helper(_visitor, &mut _i.gt_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_nested_meta_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut NestedMeta) { + match *_i { + NestedMeta::Meta(ref mut _binding_0) => { + _visitor.visit_meta_mut(_binding_0); + } + NestedMeta::Literal(ref mut _binding_0) => { + _visitor.visit_lit_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_parenthesized_generic_arguments_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut ParenthesizedGenericArguments, +) { + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.inputs) { + let it = el.value_mut(); + _visitor.visit_type_mut(it) + } + _visitor.visit_return_type_mut(&mut _i.output); +} +#[cfg(feature = "full")] +pub fn visit_pat_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Pat) { + match *_i { + Pat::Wild(ref mut _binding_0) => { + _visitor.visit_pat_wild_mut(_binding_0); + } + Pat::Ident(ref mut _binding_0) => { + _visitor.visit_pat_ident_mut(_binding_0); + } + Pat::Struct(ref mut _binding_0) => { + _visitor.visit_pat_struct_mut(_binding_0); + } + Pat::TupleStruct(ref mut _binding_0) => { + _visitor.visit_pat_tuple_struct_mut(_binding_0); + } + Pat::Path(ref mut _binding_0) => { + _visitor.visit_pat_path_mut(_binding_0); + } + Pat::Tuple(ref mut _binding_0) => { + _visitor.visit_pat_tuple_mut(_binding_0); + } + Pat::Box(ref mut _binding_0) => { + _visitor.visit_pat_box_mut(_binding_0); + } + Pat::Ref(ref mut _binding_0) => { + _visitor.visit_pat_ref_mut(_binding_0); + } + Pat::Lit(ref mut _binding_0) => { + _visitor.visit_pat_lit_mut(_binding_0); + } + Pat::Range(ref mut _binding_0) => { + _visitor.visit_pat_range_mut(_binding_0); + } + Pat::Slice(ref mut _binding_0) => { + _visitor.visit_pat_slice_mut(_binding_0); + } + Pat::Macro(ref mut _binding_0) => { + _visitor.visit_pat_macro_mut(_binding_0); + } + Pat::Verbatim(ref mut _binding_0) => { + _visitor.visit_pat_verbatim_mut(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_pat_box_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatBox) { + tokens_helper(_visitor, &mut _i.box_token.span); + _visitor.visit_pat_mut(&mut *_i.pat); +} +#[cfg(feature = "full")] +pub fn visit_pat_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatIdent) { + if let Some(ref mut it) = _i.by_ref { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_ident_mut(&mut _i.ident); + if let Some(ref mut it) = _i.subpat { + tokens_helper(_visitor, &mut (it).0.spans); + _visitor.visit_pat_mut(&mut *(it).1); + }; +} +#[cfg(feature = "full")] +pub fn visit_pat_lit_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatLit) { + _visitor.visit_expr_mut(&mut *_i.expr); +} +#[cfg(feature = "full")] +pub fn visit_pat_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatMacro) { + _visitor.visit_macro_mut(&mut _i.mac); +} +#[cfg(feature = "full")] +pub fn visit_pat_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatPath) { + if let Some(ref mut it) = _i.qself { + _visitor.visit_qself_mut(it) + }; + _visitor.visit_path_mut(&mut _i.path); +} +#[cfg(feature = "full")] +pub fn visit_pat_range_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRange) { + _visitor.visit_expr_mut(&mut *_i.lo); + _visitor.visit_range_limits_mut(&mut _i.limits); + _visitor.visit_expr_mut(&mut *_i.hi); +} +#[cfg(feature = "full")] +pub fn visit_pat_ref_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatRef) { + tokens_helper(_visitor, &mut _i.and_token.spans); + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_pat_mut(&mut *_i.pat); +} +#[cfg(feature = "full")] +pub fn visit_pat_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatSlice) { + tokens_helper(_visitor, &mut _i.bracket_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.front) { + let it = el.value_mut(); + _visitor.visit_pat_mut(it) + } + if let Some(ref mut it) = _i.middle { + _visitor.visit_pat_mut(&mut **it) + }; + if let Some(ref mut it) = _i.dot2_token { + tokens_helper(_visitor, &mut it.spans) + }; + if let Some(ref mut it) = _i.comma_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.back) { + let it = el.value_mut(); + _visitor.visit_pat_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_pat_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatStruct) { + _visitor.visit_path_mut(&mut _i.path); + tokens_helper(_visitor, &mut _i.brace_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.fields) { + let it = el.value_mut(); + _visitor.visit_field_pat_mut(it) + } + if let Some(ref mut it) = _i.dot2_token { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_pat_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatTuple) { + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.front) { + let it = el.value_mut(); + _visitor.visit_pat_mut(it) + } + if let Some(ref mut it) = _i.dot2_token { + tokens_helper(_visitor, &mut it.spans) + }; + if let Some(ref mut it) = _i.comma_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.back) { + let it = el.value_mut(); + _visitor.visit_pat_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_pat_tuple_struct_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatTupleStruct) { + _visitor.visit_path_mut(&mut _i.path); + _visitor.visit_pat_tuple_mut(&mut _i.pat); +} +#[cfg(feature = "full")] +pub fn visit_pat_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatVerbatim) { + skip!(_i.tts); +} +#[cfg(feature = "full")] +pub fn visit_pat_wild_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PatWild) { + tokens_helper(_visitor, &mut _i.underscore_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Path) { + if let Some(ref mut it) = _i.leading_colon { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.segments) { + let it = el.value_mut(); + _visitor.visit_path_segment_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_path_arguments_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PathArguments) { + match *_i { + PathArguments::None => {} + PathArguments::AngleBracketed(ref mut _binding_0) => { + _visitor.visit_angle_bracketed_generic_arguments_mut(_binding_0); + } + PathArguments::Parenthesized(ref mut _binding_0) => { + _visitor.visit_parenthesized_generic_arguments_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_path_segment_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PathSegment) { + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_path_arguments_mut(&mut _i.arguments); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_predicate_eq_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PredicateEq) { + _visitor.visit_type_mut(&mut _i.lhs_ty); + tokens_helper(_visitor, &mut _i.eq_token.spans); + _visitor.visit_type_mut(&mut _i.rhs_ty); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_predicate_lifetime_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut PredicateLifetime, +) { + _visitor.visit_lifetime_mut(&mut _i.lifetime); + tokens_helper(_visitor, &mut _i.colon_token.spans); + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_lifetime_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_predicate_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut PredicateType) { + if let Some(ref mut it) = _i.lifetimes { + _visitor.visit_bound_lifetimes_mut(it) + }; + _visitor.visit_type_mut(&mut _i.bounded_ty); + tokens_helper(_visitor, &mut _i.colon_token.spans); + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_qself_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut QSelf) { + tokens_helper(_visitor, &mut _i.lt_token.spans); + _visitor.visit_type_mut(&mut *_i.ty); + skip!(_i.position); + if let Some(ref mut it) = _i.as_token { + tokens_helper(_visitor, &mut it.span) + }; + tokens_helper(_visitor, &mut _i.gt_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_range_limits_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut RangeLimits) { + match *_i { + RangeLimits::HalfOpen(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + RangeLimits::Closed(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_return_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut ReturnType) { + match *_i { + ReturnType::Default => {} + ReturnType::Type(ref mut _binding_0, ref mut _binding_1) => { + tokens_helper(_visitor, &mut _binding_0.spans); + _visitor.visit_type_mut(&mut **_binding_1); + } + } +} +#[cfg(feature = "full")] +pub fn visit_stmt_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Stmt) { + match *_i { + Stmt::Local(ref mut _binding_0) => { + _visitor.visit_local_mut(_binding_0); + } + Stmt::Item(ref mut _binding_0) => { + _visitor.visit_item_mut(_binding_0); + } + Stmt::Expr(ref mut _binding_0) => { + _visitor.visit_expr_mut(_binding_0); + } + Stmt::Semi(ref mut _binding_0, ref mut _binding_1) => { + _visitor.visit_expr_mut(_binding_0); + tokens_helper(_visitor, &mut _binding_1.spans); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_trait_bound_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitBound) { + if let Some(ref mut it) = _i.paren_token { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_trait_bound_modifier_mut(&mut _i.modifier); + if let Some(ref mut it) = _i.lifetimes { + _visitor.visit_bound_lifetimes_mut(it) + }; + _visitor.visit_path_mut(&mut _i.path); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_trait_bound_modifier_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut TraitBoundModifier, +) { + match *_i { + TraitBoundModifier::None => {} + TraitBoundModifier::Maybe(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + } +} +#[cfg(feature = "full")] +pub fn visit_trait_item_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItem) { + match *_i { + TraitItem::Const(ref mut _binding_0) => { + _visitor.visit_trait_item_const_mut(_binding_0); + } + TraitItem::Method(ref mut _binding_0) => { + _visitor.visit_trait_item_method_mut(_binding_0); + } + TraitItem::Type(ref mut _binding_0) => { + _visitor.visit_trait_item_type_mut(_binding_0); + } + TraitItem::Macro(ref mut _binding_0) => { + _visitor.visit_trait_item_macro_mut(_binding_0); + } + TraitItem::Verbatim(ref mut _binding_0) => { + _visitor.visit_trait_item_verbatim_mut(_binding_0); + } + } +} +#[cfg(feature = "full")] +pub fn visit_trait_item_const_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemConst) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.const_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.colon_token.spans); + _visitor.visit_type_mut(&mut _i.ty); + if let Some(ref mut it) = _i.default { + tokens_helper(_visitor, &mut (it).0.spans); + _visitor.visit_expr_mut(&mut (it).1); + }; + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_trait_item_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemMacro) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_macro_mut(&mut _i.mac); + if let Some(ref mut it) = _i.semi_token { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_trait_item_method_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut TraitItemMethod, +) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_method_sig_mut(&mut _i.sig); + if let Some(ref mut it) = _i.default { + _visitor.visit_block_mut(it) + }; + if let Some(ref mut it) = _i.semi_token { + tokens_helper(_visitor, &mut it.spans) + }; +} +#[cfg(feature = "full")] +pub fn visit_trait_item_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TraitItemType) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + tokens_helper(_visitor, &mut _i.type_token.span); + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_generics_mut(&mut _i.generics); + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } + if let Some(ref mut it) = _i.default { + tokens_helper(_visitor, &mut (it).0.spans); + _visitor.visit_type_mut(&mut (it).1); + }; + tokens_helper(_visitor, &mut _i.semi_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_trait_item_verbatim_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut TraitItemVerbatim, +) { + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Type) { + match *_i { + Type::Slice(ref mut _binding_0) => { + _visitor.visit_type_slice_mut(_binding_0); + } + Type::Array(ref mut _binding_0) => { + _visitor.visit_type_array_mut(_binding_0); + } + Type::Ptr(ref mut _binding_0) => { + _visitor.visit_type_ptr_mut(_binding_0); + } + Type::Reference(ref mut _binding_0) => { + _visitor.visit_type_reference_mut(_binding_0); + } + Type::BareFn(ref mut _binding_0) => { + _visitor.visit_type_bare_fn_mut(_binding_0); + } + Type::Never(ref mut _binding_0) => { + _visitor.visit_type_never_mut(_binding_0); + } + Type::Tuple(ref mut _binding_0) => { + _visitor.visit_type_tuple_mut(_binding_0); + } + Type::Path(ref mut _binding_0) => { + _visitor.visit_type_path_mut(_binding_0); + } + Type::TraitObject(ref mut _binding_0) => { + _visitor.visit_type_trait_object_mut(_binding_0); + } + Type::ImplTrait(ref mut _binding_0) => { + _visitor.visit_type_impl_trait_mut(_binding_0); + } + Type::Paren(ref mut _binding_0) => { + _visitor.visit_type_paren_mut(_binding_0); + } + Type::Group(ref mut _binding_0) => { + _visitor.visit_type_group_mut(_binding_0); + } + Type::Infer(ref mut _binding_0) => { + _visitor.visit_type_infer_mut(_binding_0); + } + Type::Macro(ref mut _binding_0) => { + _visitor.visit_type_macro_mut(_binding_0); + } + Type::Verbatim(ref mut _binding_0) => { + _visitor.visit_type_verbatim_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_array_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeArray) { + tokens_helper(_visitor, &mut _i.bracket_token.span); + _visitor.visit_type_mut(&mut *_i.elem); + tokens_helper(_visitor, &mut _i.semi_token.spans); + _visitor.visit_expr_mut(&mut _i.len); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_bare_fn_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeBareFn) { + if let Some(ref mut it) = _i.lifetimes { + _visitor.visit_bound_lifetimes_mut(it) + }; + if let Some(ref mut it) = _i.unsafety { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.abi { + _visitor.visit_abi_mut(it) + }; + tokens_helper(_visitor, &mut _i.fn_token.span); + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.inputs) { + let it = el.value_mut(); + _visitor.visit_bare_fn_arg_mut(it) + } + if let Some(ref mut it) = _i.variadic { + tokens_helper(_visitor, &mut it.spans) + }; + _visitor.visit_return_type_mut(&mut _i.output); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeGroup) { + tokens_helper(_visitor, &mut _i.group_token.span); + _visitor.visit_type_mut(&mut *_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_impl_trait_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeImplTrait) { + tokens_helper(_visitor, &mut _i.impl_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_infer_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeInfer) { + tokens_helper(_visitor, &mut _i.underscore_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_macro_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeMacro) { + _visitor.visit_macro_mut(&mut _i.mac); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_never_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeNever) { + tokens_helper(_visitor, &mut _i.bang_token.spans); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_param_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParam) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_ident_mut(&mut _i.ident); + if let Some(ref mut it) = _i.colon_token { + tokens_helper(_visitor, &mut it.spans) + }; + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } + if let Some(ref mut it) = _i.eq_token { + tokens_helper(_visitor, &mut it.spans) + }; + if let Some(ref mut it) = _i.default { + _visitor.visit_type_mut(it) + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_param_bound_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParamBound) { + match *_i { + TypeParamBound::Trait(ref mut _binding_0) => { + _visitor.visit_trait_bound_mut(_binding_0); + } + TypeParamBound::Lifetime(ref mut _binding_0) => { + _visitor.visit_lifetime_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_paren_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeParen) { + tokens_helper(_visitor, &mut _i.paren_token.span); + _visitor.visit_type_mut(&mut *_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypePath) { + if let Some(ref mut it) = _i.qself { + _visitor.visit_qself_mut(it) + }; + _visitor.visit_path_mut(&mut _i.path); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_ptr_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypePtr) { + tokens_helper(_visitor, &mut _i.star_token.spans); + if let Some(ref mut it) = _i.const_token { + tokens_helper(_visitor, &mut it.span) + }; + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_type_mut(&mut *_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_reference_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeReference) { + tokens_helper(_visitor, &mut _i.and_token.spans); + if let Some(ref mut it) = _i.lifetime { + _visitor.visit_lifetime_mut(it) + }; + if let Some(ref mut it) = _i.mutability { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_type_mut(&mut *_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_slice_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeSlice) { + tokens_helper(_visitor, &mut _i.bracket_token.span); + _visitor.visit_type_mut(&mut *_i.elem); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_trait_object_mut<V: VisitMut + ?Sized>( + _visitor: &mut V, + _i: &mut TypeTraitObject, +) { + if let Some(ref mut it) = _i.dyn_token { + tokens_helper(_visitor, &mut it.span) + }; + for mut el in Punctuated::pairs_mut(&mut _i.bounds) { + let it = el.value_mut(); + _visitor.visit_type_param_bound_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_tuple_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeTuple) { + tokens_helper(_visitor, &mut _i.paren_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.elems) { + let it = el.value_mut(); + _visitor.visit_type_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_type_verbatim_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut TypeVerbatim) { + skip!(_i.tts); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_un_op_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UnOp) { + match *_i { + UnOp::Deref(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + UnOp::Not(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + UnOp::Neg(ref mut _binding_0) => { + tokens_helper(_visitor, &mut _binding_0.spans); + } + } +} +#[cfg(feature = "full")] +pub fn visit_use_glob_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseGlob) { + tokens_helper(_visitor, &mut _i.star_token.spans); +} +#[cfg(feature = "full")] +pub fn visit_use_group_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseGroup) { + tokens_helper(_visitor, &mut _i.brace_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.items) { + let it = el.value_mut(); + _visitor.visit_use_tree_mut(it) + } +} +#[cfg(feature = "full")] +pub fn visit_use_name_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseName) { + _visitor.visit_ident_mut(&mut _i.ident); +} +#[cfg(feature = "full")] +pub fn visit_use_path_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UsePath) { + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.colon2_token.spans); + _visitor.visit_use_tree_mut(&mut *_i.tree); +} +#[cfg(feature = "full")] +pub fn visit_use_rename_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseRename) { + _visitor.visit_ident_mut(&mut _i.ident); + tokens_helper(_visitor, &mut _i.as_token.span); + _visitor.visit_ident_mut(&mut _i.rename); +} +#[cfg(feature = "full")] +pub fn visit_use_tree_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut UseTree) { + match *_i { + UseTree::Path(ref mut _binding_0) => { + _visitor.visit_use_path_mut(_binding_0); + } + UseTree::Name(ref mut _binding_0) => { + _visitor.visit_use_name_mut(_binding_0); + } + UseTree::Rename(ref mut _binding_0) => { + _visitor.visit_use_rename_mut(_binding_0); + } + UseTree::Glob(ref mut _binding_0) => { + _visitor.visit_use_glob_mut(_binding_0); + } + UseTree::Group(ref mut _binding_0) => { + _visitor.visit_use_group_mut(_binding_0); + } + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_variant_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Variant) { + for it in &mut _i.attrs { + _visitor.visit_attribute_mut(it) + } + _visitor.visit_ident_mut(&mut _i.ident); + _visitor.visit_fields_mut(&mut _i.fields); + if let Some(ref mut it) = _i.discriminant { + tokens_helper(_visitor, &mut (it).0.spans); + _visitor.visit_expr_mut(&mut (it).1); + }; +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_vis_crate_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisCrate) { + tokens_helper(_visitor, &mut _i.crate_token.span); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_vis_public_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisPublic) { + tokens_helper(_visitor, &mut _i.pub_token.span); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_vis_restricted_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut VisRestricted) { + tokens_helper(_visitor, &mut _i.pub_token.span); + tokens_helper(_visitor, &mut _i.paren_token.span); + if let Some(ref mut it) = _i.in_token { + tokens_helper(_visitor, &mut it.span) + }; + _visitor.visit_path_mut(&mut *_i.path); +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_visibility_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Visibility) { + match *_i { + Visibility::Public(ref mut _binding_0) => { + _visitor.visit_vis_public_mut(_binding_0); + } + Visibility::Crate(ref mut _binding_0) => { + _visitor.visit_vis_crate_mut(_binding_0); + } + Visibility::Restricted(ref mut _binding_0) => { + _visitor.visit_vis_restricted_mut(_binding_0); + } + Visibility::Inherited => {} + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_where_clause_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut WhereClause) { + tokens_helper(_visitor, &mut _i.where_token.span); + for mut el in Punctuated::pairs_mut(&mut _i.predicates) { + let it = el.value_mut(); + _visitor.visit_where_predicate_mut(it) + } +} +#[cfg(any(feature = "derive", feature = "full"))] +pub fn visit_where_predicate_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut WherePredicate) { + match *_i { + WherePredicate::Type(ref mut _binding_0) => { + _visitor.visit_predicate_type_mut(_binding_0); + } + WherePredicate::Lifetime(ref mut _binding_0) => { + _visitor.visit_predicate_lifetime_mut(_binding_0); + } + WherePredicate::Eq(ref mut _binding_0) => { + _visitor.visit_predicate_eq_mut(_binding_0); + } + } +} +pub fn visit_span_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Span) {} +pub fn visit_ident_mut<V: VisitMut + ?Sized>(_visitor: &mut V, _i: &mut Ident) {} diff --git a/rust/vendor/syn-0.15.44/src/gen_helper.rs b/rust/vendor/syn-0.15.44/src/gen_helper.rs new file mode 100644 index 0000000..b15b42b --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/gen_helper.rs @@ -0,0 +1,154 @@ +#[cfg(feature = "fold")] +pub mod fold { + use fold::Fold; + use proc_macro2::Span; + use punctuated::{Pair, Punctuated}; + + pub trait FoldHelper { + type Item; + fn lift<F>(self, f: F) -> Self + where + F: FnMut(Self::Item) -> Self::Item; + } + + impl<T> FoldHelper for Vec<T> { + type Item = T; + fn lift<F>(self, f: F) -> Self + where + F: FnMut(Self::Item) -> Self::Item, + { + self.into_iter().map(f).collect() + } + } + + impl<T, U> FoldHelper for Punctuated<T, U> { + type Item = T; + fn lift<F>(self, mut f: F) -> Self + where + F: FnMut(Self::Item) -> Self::Item, + { + self.into_pairs() + .map(Pair::into_tuple) + .map(|(t, u)| Pair::new(f(t), u)) + .collect() + } + } + + pub fn tokens_helper<F: Fold + ?Sized, S: Spans>(folder: &mut F, spans: &S) -> S { + spans.fold(folder) + } + + pub trait Spans { + fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self; + } + + impl Spans for Span { + fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self { + folder.fold_span(*self) + } + } + + impl Spans for [Span; 1] { + fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self { + [folder.fold_span(self[0])] + } + } + + impl Spans for [Span; 2] { + fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self { + [folder.fold_span(self[0]), folder.fold_span(self[1])] + } + } + + impl Spans for [Span; 3] { + fn fold<F: Fold + ?Sized>(&self, folder: &mut F) -> Self { + [ + folder.fold_span(self[0]), + folder.fold_span(self[1]), + folder.fold_span(self[2]), + ] + } + } +} + +#[cfg(feature = "visit")] +pub mod visit { + use proc_macro2::Span; + use visit::Visit; + + pub fn tokens_helper<'ast, V: Visit<'ast> + ?Sized, S: Spans>(visitor: &mut V, spans: &'ast S) { + spans.visit(visitor); + } + + pub trait Spans { + fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V); + } + + impl Spans for Span { + fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) { + visitor.visit_span(self); + } + } + + impl Spans for [Span; 1] { + fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) { + visitor.visit_span(&self[0]); + } + } + + impl Spans for [Span; 2] { + fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) { + visitor.visit_span(&self[0]); + visitor.visit_span(&self[1]); + } + } + + impl Spans for [Span; 3] { + fn visit<'ast, V: Visit<'ast> + ?Sized>(&'ast self, visitor: &mut V) { + visitor.visit_span(&self[0]); + visitor.visit_span(&self[1]); + visitor.visit_span(&self[2]); + } + } +} + +#[cfg(feature = "visit-mut")] +pub mod visit_mut { + use proc_macro2::Span; + use visit_mut::VisitMut; + + pub fn tokens_helper<V: VisitMut + ?Sized, S: Spans>(visitor: &mut V, spans: &mut S) { + spans.visit_mut(visitor); + } + + pub trait Spans { + fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V); + } + + impl Spans for Span { + fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) { + visitor.visit_span_mut(self); + } + } + + impl Spans for [Span; 1] { + fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) { + visitor.visit_span_mut(&mut self[0]); + } + } + + impl Spans for [Span; 2] { + fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) { + visitor.visit_span_mut(&mut self[0]); + visitor.visit_span_mut(&mut self[1]); + } + } + + impl Spans for [Span; 3] { + fn visit_mut<V: VisitMut + ?Sized>(&mut self, visitor: &mut V) { + visitor.visit_span_mut(&mut self[0]); + visitor.visit_span_mut(&mut self[1]); + visitor.visit_span_mut(&mut self[2]); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/generics.rs b/rust/vendor/syn-0.15.44/src/generics.rs new file mode 100644 index 0000000..d9d652d --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/generics.rs @@ -0,0 +1,1132 @@ +use super::*; +use punctuated::{Iter, IterMut, Punctuated}; + +ast_struct! { + /// Lifetimes and type parameters attached to a declaration of a function, + /// enum, trait, etc. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + #[derive(Default)] + pub struct Generics { + pub lt_token: Option<Token![<]>, + pub params: Punctuated<GenericParam, Token![,]>, + pub gt_token: Option<Token![>]>, + pub where_clause: Option<WhereClause>, + } +} + +ast_enum_of_structs! { + /// A generic type parameter, lifetime, or const generic: `T: Into<String>`, + /// `'a: 'b`, `const LEN: usize`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum GenericParam { + /// A generic type parameter: `T: Into<String>`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Type(TypeParam { + pub attrs: Vec<Attribute>, + pub ident: Ident, + pub colon_token: Option<Token![:]>, + pub bounds: Punctuated<TypeParamBound, Token![+]>, + pub eq_token: Option<Token![=]>, + pub default: Option<Type>, + }), + + /// A lifetime definition: `'a: 'b + 'c + 'd`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Lifetime(LifetimeDef { + pub attrs: Vec<Attribute>, + pub lifetime: Lifetime, + pub colon_token: Option<Token![:]>, + pub bounds: Punctuated<Lifetime, Token![+]>, + }), + + /// A const generic parameter: `const LENGTH: usize`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Const(ConstParam { + pub attrs: Vec<Attribute>, + pub const_token: Token![const], + pub ident: Ident, + pub colon_token: Token![:], + pub ty: Type, + pub eq_token: Option<Token![=]>, + pub default: Option<Expr>, + }), + } +} + +impl Generics { + /// Returns an + /// <code + /// style="padding-right:0;">Iterator<Item = &</code><a + /// href="struct.TypeParam.html"><code + /// style="padding-left:0;padding-right:0;">TypeParam</code></a><code + /// style="padding-left:0;">></code> + /// over the type parameters in `self.params`. + pub fn type_params(&self) -> TypeParams { + TypeParams(self.params.iter()) + } + + /// Returns an + /// <code + /// style="padding-right:0;">Iterator<Item = &mut </code><a + /// href="struct.TypeParam.html"><code + /// style="padding-left:0;padding-right:0;">TypeParam</code></a><code + /// style="padding-left:0;">></code> + /// over the type parameters in `self.params`. + pub fn type_params_mut(&mut self) -> TypeParamsMut { + TypeParamsMut(self.params.iter_mut()) + } + + /// Returns an + /// <code + /// style="padding-right:0;">Iterator<Item = &</code><a + /// href="struct.LifetimeDef.html"><code + /// style="padding-left:0;padding-right:0;">LifetimeDef</code></a><code + /// style="padding-left:0;">></code> + /// over the lifetime parameters in `self.params`. + pub fn lifetimes(&self) -> Lifetimes { + Lifetimes(self.params.iter()) + } + + /// Returns an + /// <code + /// style="padding-right:0;">Iterator<Item = &mut </code><a + /// href="struct.LifetimeDef.html"><code + /// style="padding-left:0;padding-right:0;">LifetimeDef</code></a><code + /// style="padding-left:0;">></code> + /// over the lifetime parameters in `self.params`. + pub fn lifetimes_mut(&mut self) -> LifetimesMut { + LifetimesMut(self.params.iter_mut()) + } + + /// Returns an + /// <code + /// style="padding-right:0;">Iterator<Item = &</code><a + /// href="struct.ConstParam.html"><code + /// style="padding-left:0;padding-right:0;">ConstParam</code></a><code + /// style="padding-left:0;">></code> + /// over the constant parameters in `self.params`. + pub fn const_params(&self) -> ConstParams { + ConstParams(self.params.iter()) + } + + /// Returns an + /// <code + /// style="padding-right:0;">Iterator<Item = &mut </code><a + /// href="struct.ConstParam.html"><code + /// style="padding-left:0;padding-right:0;">ConstParam</code></a><code + /// style="padding-left:0;">></code> + /// over the constant parameters in `self.params`. + pub fn const_params_mut(&mut self) -> ConstParamsMut { + ConstParamsMut(self.params.iter_mut()) + } + + /// Initializes an empty `where`-clause if there is not one present already. + pub fn make_where_clause(&mut self) -> &mut WhereClause { + // This is Option::get_or_insert_with in Rust 1.20. + if self.where_clause.is_none() { + self.where_clause = Some(WhereClause { + where_token: <Token![where]>::default(), + predicates: Punctuated::new(), + }); + } + match self.where_clause { + Some(ref mut where_clause) => where_clause, + None => unreachable!(), + } + } +} + +pub struct TypeParams<'a>(Iter<'a, GenericParam>); + +impl<'a> Iterator for TypeParams<'a> { + type Item = &'a TypeParam; + + fn next(&mut self) -> Option<Self::Item> { + let next = match self.0.next() { + Some(item) => item, + None => return None, + }; + if let GenericParam::Type(ref type_param) = *next { + Some(type_param) + } else { + self.next() + } + } +} + +pub struct TypeParamsMut<'a>(IterMut<'a, GenericParam>); + +impl<'a> Iterator for TypeParamsMut<'a> { + type Item = &'a mut TypeParam; + + fn next(&mut self) -> Option<Self::Item> { + let next = match self.0.next() { + Some(item) => item, + None => return None, + }; + if let GenericParam::Type(ref mut type_param) = *next { + Some(type_param) + } else { + self.next() + } + } +} + +pub struct Lifetimes<'a>(Iter<'a, GenericParam>); + +impl<'a> Iterator for Lifetimes<'a> { + type Item = &'a LifetimeDef; + + fn next(&mut self) -> Option<Self::Item> { + let next = match self.0.next() { + Some(item) => item, + None => return None, + }; + if let GenericParam::Lifetime(ref lifetime) = *next { + Some(lifetime) + } else { + self.next() + } + } +} + +pub struct LifetimesMut<'a>(IterMut<'a, GenericParam>); + +impl<'a> Iterator for LifetimesMut<'a> { + type Item = &'a mut LifetimeDef; + + fn next(&mut self) -> Option<Self::Item> { + let next = match self.0.next() { + Some(item) => item, + None => return None, + }; + if let GenericParam::Lifetime(ref mut lifetime) = *next { + Some(lifetime) + } else { + self.next() + } + } +} + +pub struct ConstParams<'a>(Iter<'a, GenericParam>); + +impl<'a> Iterator for ConstParams<'a> { + type Item = &'a ConstParam; + + fn next(&mut self) -> Option<Self::Item> { + let next = match self.0.next() { + Some(item) => item, + None => return None, + }; + if let GenericParam::Const(ref const_param) = *next { + Some(const_param) + } else { + self.next() + } + } +} + +pub struct ConstParamsMut<'a>(IterMut<'a, GenericParam>); + +impl<'a> Iterator for ConstParamsMut<'a> { + type Item = &'a mut ConstParam; + + fn next(&mut self) -> Option<Self::Item> { + let next = match self.0.next() { + Some(item) => item, + None => return None, + }; + if let GenericParam::Const(ref mut const_param) = *next { + Some(const_param) + } else { + self.next() + } + } +} + +/// Returned by `Generics::split_for_impl`. +/// +/// *This type is available if Syn is built with the `"derive"` or `"full"` +/// feature and the `"printing"` feature.* +#[cfg(feature = "printing")] +#[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))] +#[cfg_attr(feature = "clone-impls", derive(Clone))] +pub struct ImplGenerics<'a>(&'a Generics); + +/// Returned by `Generics::split_for_impl`. +/// +/// *This type is available if Syn is built with the `"derive"` or `"full"` +/// feature and the `"printing"` feature.* +#[cfg(feature = "printing")] +#[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))] +#[cfg_attr(feature = "clone-impls", derive(Clone))] +pub struct TypeGenerics<'a>(&'a Generics); + +/// Returned by `TypeGenerics::as_turbofish`. +/// +/// *This type is available if Syn is built with the `"derive"` or `"full"` +/// feature and the `"printing"` feature.* +#[cfg(feature = "printing")] +#[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))] +#[cfg_attr(feature = "clone-impls", derive(Clone))] +pub struct Turbofish<'a>(&'a Generics); + +#[cfg(feature = "printing")] +impl Generics { + /// Split a type's generics into the pieces required for impl'ing a trait + /// for that type. + /// + /// ```edition2018 + /// # use proc_macro2::{Span, Ident}; + /// # use quote::quote; + /// # + /// # fn main() { + /// # let generics: syn::Generics = Default::default(); + /// # let name = Ident::new("MyType", Span::call_site()); + /// # + /// let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); + /// quote! { + /// impl #impl_generics MyTrait for #name #ty_generics #where_clause { + /// // ... + /// } + /// } + /// # ; + /// # } + /// ``` + /// + /// *This method is available if Syn is built with the `"derive"` or + /// `"full"` feature and the `"printing"` feature.* + pub fn split_for_impl(&self) -> (ImplGenerics, TypeGenerics, Option<&WhereClause>) { + ( + ImplGenerics(self), + TypeGenerics(self), + self.where_clause.as_ref(), + ) + } +} + +#[cfg(feature = "printing")] +impl<'a> TypeGenerics<'a> { + /// Turn a type's generics like `<X, Y>` into a turbofish like `::<X, Y>`. + /// + /// *This method is available if Syn is built with the `"derive"` or + /// `"full"` feature and the `"printing"` feature.* + pub fn as_turbofish(&self) -> Turbofish { + Turbofish(self.0) + } +} + +ast_struct! { + /// A set of bound lifetimes: `for<'a, 'b, 'c>`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + #[derive(Default)] + pub struct BoundLifetimes { + pub for_token: Token![for], + pub lt_token: Token![<], + pub lifetimes: Punctuated<LifetimeDef, Token![,]>, + pub gt_token: Token![>], + } +} + +impl LifetimeDef { + pub fn new(lifetime: Lifetime) -> Self { + LifetimeDef { + attrs: Vec::new(), + lifetime: lifetime, + colon_token: None, + bounds: Punctuated::new(), + } + } +} + +impl From<Ident> for TypeParam { + fn from(ident: Ident) -> Self { + TypeParam { + attrs: vec![], + ident: ident, + colon_token: None, + bounds: Punctuated::new(), + eq_token: None, + default: None, + } + } +} + +ast_enum_of_structs! { + /// A trait or lifetime used as a bound on a type parameter. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum TypeParamBound { + pub Trait(TraitBound), + pub Lifetime(Lifetime), + } +} + +ast_struct! { + /// A trait used as a bound on a type parameter. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct TraitBound { + pub paren_token: Option<token::Paren>, + pub modifier: TraitBoundModifier, + /// The `for<'a>` in `for<'a> Foo<&'a T>` + pub lifetimes: Option<BoundLifetimes>, + /// The `Foo<&'a T>` in `for<'a> Foo<&'a T>` + pub path: Path, + } +} + +ast_enum! { + /// A modifier on a trait bound, currently only used for the `?` in + /// `?Sized`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + #[cfg_attr(feature = "clone-impls", derive(Copy))] + pub enum TraitBoundModifier { + None, + Maybe(Token![?]), + } +} + +ast_struct! { + /// A `where` clause in a definition: `where T: Deserialize<'de>, D: + /// 'static`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct WhereClause { + pub where_token: Token![where], + pub predicates: Punctuated<WherePredicate, Token![,]>, + } +} + +ast_enum_of_structs! { + /// A single predicate in a `where` clause: `T: Deserialize<'de>`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum WherePredicate { + /// A type predicate in a `where` clause: `for<'c> Foo<'c>: Trait<'c>`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Type(PredicateType { + /// Any lifetimes from a `for` binding + pub lifetimes: Option<BoundLifetimes>, + /// The type being bounded + pub bounded_ty: Type, + pub colon_token: Token![:], + /// Trait and lifetime bounds (`Clone+Send+'static`) + pub bounds: Punctuated<TypeParamBound, Token![+]>, + }), + + /// A lifetime predicate in a `where` clause: `'a: 'b + 'c`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Lifetime(PredicateLifetime { + pub lifetime: Lifetime, + pub colon_token: Token![:], + pub bounds: Punctuated<Lifetime, Token![+]>, + }), + + /// An equality predicate in a `where` clause (unsupported). + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Eq(PredicateEq { + pub lhs_ty: Type, + pub eq_token: Token![=], + pub rhs_ty: Type, + }), + } +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use parse::{Parse, ParseStream, Result}; + + impl Parse for Generics { + fn parse(input: ParseStream) -> Result<Self> { + if !input.peek(Token![<]) { + return Ok(Generics::default()); + } + + let lt_token: Token![<] = input.parse()?; + + let mut params = Punctuated::new(); + let mut allow_lifetime_param = true; + let mut allow_type_param = true; + loop { + if input.peek(Token![>]) { + break; + } + + let attrs = input.call(Attribute::parse_outer)?; + let lookahead = input.lookahead1(); + if allow_lifetime_param && lookahead.peek(Lifetime) { + params.push_value(GenericParam::Lifetime(LifetimeDef { + attrs: attrs, + ..input.parse()? + })); + } else if allow_type_param && lookahead.peek(Ident) { + allow_lifetime_param = false; + params.push_value(GenericParam::Type(TypeParam { + attrs: attrs, + ..input.parse()? + })); + } else if lookahead.peek(Token![const]) { + allow_lifetime_param = false; + allow_type_param = false; + params.push_value(GenericParam::Const(ConstParam { + attrs: attrs, + ..input.parse()? + })); + } else { + return Err(lookahead.error()); + } + + if input.peek(Token![>]) { + break; + } + let punct = input.parse()?; + params.push_punct(punct); + } + + let gt_token: Token![>] = input.parse()?; + + Ok(Generics { + lt_token: Some(lt_token), + params: params, + gt_token: Some(gt_token), + where_clause: None, + }) + } + } + + impl Parse for GenericParam { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + + let lookahead = input.lookahead1(); + if lookahead.peek(Ident) { + Ok(GenericParam::Type(TypeParam { + attrs: attrs, + ..input.parse()? + })) + } else if lookahead.peek(Lifetime) { + Ok(GenericParam::Lifetime(LifetimeDef { + attrs: attrs, + ..input.parse()? + })) + } else if lookahead.peek(Token![const]) { + Ok(GenericParam::Const(ConstParam { + attrs: attrs, + ..input.parse()? + })) + } else { + Err(lookahead.error()) + } + } + } + + impl Parse for LifetimeDef { + fn parse(input: ParseStream) -> Result<Self> { + let has_colon; + Ok(LifetimeDef { + attrs: input.call(Attribute::parse_outer)?, + lifetime: input.parse()?, + colon_token: { + if input.peek(Token![:]) { + has_colon = true; + Some(input.parse()?) + } else { + has_colon = false; + None + } + }, + bounds: { + let mut bounds = Punctuated::new(); + if has_colon { + loop { + if input.peek(Token![,]) || input.peek(Token![>]) { + break; + } + let value = input.parse()?; + bounds.push_value(value); + if !input.peek(Token![+]) { + break; + } + let punct = input.parse()?; + bounds.push_punct(punct); + } + } + bounds + }, + }) + } + } + + impl Parse for BoundLifetimes { + fn parse(input: ParseStream) -> Result<Self> { + Ok(BoundLifetimes { + for_token: input.parse()?, + lt_token: input.parse()?, + lifetimes: { + let mut lifetimes = Punctuated::new(); + while !input.peek(Token![>]) { + lifetimes.push_value(input.parse()?); + if input.peek(Token![>]) { + break; + } + lifetimes.push_punct(input.parse()?); + } + lifetimes + }, + gt_token: input.parse()?, + }) + } + } + + impl Parse for Option<BoundLifetimes> { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Token![for]) { + input.parse().map(Some) + } else { + Ok(None) + } + } + } + + impl Parse for TypeParam { + fn parse(input: ParseStream) -> Result<Self> { + let has_colon; + let has_default; + Ok(TypeParam { + attrs: input.call(Attribute::parse_outer)?, + ident: input.parse()?, + colon_token: { + if input.peek(Token![:]) { + has_colon = true; + Some(input.parse()?) + } else { + has_colon = false; + None + } + }, + bounds: { + let mut bounds = Punctuated::new(); + if has_colon { + loop { + if input.peek(Token![,]) + || input.peek(Token![>]) + || input.peek(Token![=]) + { + break; + } + let value = input.parse()?; + bounds.push_value(value); + if !input.peek(Token![+]) { + break; + } + let punct = input.parse()?; + bounds.push_punct(punct); + } + } + bounds + }, + eq_token: { + if input.peek(Token![=]) { + has_default = true; + Some(input.parse()?) + } else { + has_default = false; + None + } + }, + default: { + if has_default { + Some(input.parse()?) + } else { + None + } + }, + }) + } + } + + impl Parse for TypeParamBound { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Lifetime) { + return input.parse().map(TypeParamBound::Lifetime); + } + + if input.peek(token::Paren) { + let content; + let paren_token = parenthesized!(content in input); + let mut bound: TraitBound = content.parse()?; + bound.paren_token = Some(paren_token); + return Ok(TypeParamBound::Trait(bound)); + } + + input.parse().map(TypeParamBound::Trait) + } + } + + impl Parse for TraitBound { + fn parse(input: ParseStream) -> Result<Self> { + let modifier: TraitBoundModifier = input.parse()?; + let lifetimes: Option<BoundLifetimes> = input.parse()?; + + let mut path: Path = input.parse()?; + if path.segments.last().unwrap().value().arguments.is_empty() + && input.peek(token::Paren) + { + let parenthesized = PathArguments::Parenthesized(input.parse()?); + path.segments.last_mut().unwrap().value_mut().arguments = parenthesized; + } + + Ok(TraitBound { + paren_token: None, + modifier: modifier, + lifetimes: lifetimes, + path: path, + }) + } + } + + impl Parse for TraitBoundModifier { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Token![?]) { + input.parse().map(TraitBoundModifier::Maybe) + } else { + Ok(TraitBoundModifier::None) + } + } + } + + impl Parse for ConstParam { + fn parse(input: ParseStream) -> Result<Self> { + let mut default = None; + Ok(ConstParam { + attrs: input.call(Attribute::parse_outer)?, + const_token: input.parse()?, + ident: input.parse()?, + colon_token: input.parse()?, + ty: input.parse()?, + eq_token: { + if input.peek(Token![=]) { + let eq_token = input.parse()?; + default = Some(input.parse::<Expr>()?); + Some(eq_token) + } else { + None + } + }, + default: default, + }) + } + } + + impl Parse for WhereClause { + fn parse(input: ParseStream) -> Result<Self> { + Ok(WhereClause { + where_token: input.parse()?, + predicates: { + let mut predicates = Punctuated::new(); + loop { + if input.is_empty() + || input.peek(token::Brace) + || input.peek(Token![,]) + || input.peek(Token![;]) + || input.peek(Token![:]) && !input.peek(Token![::]) + || input.peek(Token![=]) + { + break; + } + let value = input.parse()?; + predicates.push_value(value); + if !input.peek(Token![,]) { + break; + } + let punct = input.parse()?; + predicates.push_punct(punct); + } + predicates + }, + }) + } + } + + impl Parse for Option<WhereClause> { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Token![where]) { + input.parse().map(Some) + } else { + Ok(None) + } + } + } + + impl Parse for WherePredicate { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Lifetime) && input.peek2(Token![:]) { + Ok(WherePredicate::Lifetime(PredicateLifetime { + lifetime: input.parse()?, + colon_token: input.parse()?, + bounds: { + let mut bounds = Punctuated::new(); + loop { + if input.is_empty() + || input.peek(token::Brace) + || input.peek(Token![,]) + || input.peek(Token![;]) + || input.peek(Token![:]) + || input.peek(Token![=]) + { + break; + } + let value = input.parse()?; + bounds.push_value(value); + if !input.peek(Token![+]) { + break; + } + let punct = input.parse()?; + bounds.push_punct(punct); + } + bounds + }, + })) + } else { + Ok(WherePredicate::Type(PredicateType { + lifetimes: input.parse()?, + bounded_ty: input.parse()?, + colon_token: input.parse()?, + bounds: { + let mut bounds = Punctuated::new(); + loop { + if input.is_empty() + || input.peek(token::Brace) + || input.peek(Token![,]) + || input.peek(Token![;]) + || input.peek(Token![:]) && !input.peek(Token![::]) + || input.peek(Token![=]) + { + break; + } + let value = input.parse()?; + bounds.push_value(value); + if !input.peek(Token![+]) { + break; + } + let punct = input.parse()?; + bounds.push_punct(punct); + } + bounds + }, + })) + } + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + + use proc_macro2::TokenStream; + use quote::{ToTokens, TokenStreamExt}; + + use attr::FilterAttrs; + use print::TokensOrDefault; + + impl ToTokens for Generics { + fn to_tokens(&self, tokens: &mut TokenStream) { + if self.params.is_empty() { + return; + } + + TokensOrDefault(&self.lt_token).to_tokens(tokens); + + // Print lifetimes before types and consts, regardless of their + // order in self.params. + // + // TODO: ordering rules for const parameters vs type parameters have + // not been settled yet. https://github.com/rust-lang/rust/issues/44580 + let mut trailing_or_empty = true; + for param in self.params.pairs() { + if let GenericParam::Lifetime(_) = **param.value() { + param.to_tokens(tokens); + trailing_or_empty = param.punct().is_some(); + } + } + for param in self.params.pairs() { + match **param.value() { + GenericParam::Type(_) | GenericParam::Const(_) => { + if !trailing_or_empty { + <Token![,]>::default().to_tokens(tokens); + trailing_or_empty = true; + } + param.to_tokens(tokens); + } + GenericParam::Lifetime(_) => {} + } + } + + TokensOrDefault(&self.gt_token).to_tokens(tokens); + } + } + + impl<'a> ToTokens for ImplGenerics<'a> { + fn to_tokens(&self, tokens: &mut TokenStream) { + if self.0.params.is_empty() { + return; + } + + TokensOrDefault(&self.0.lt_token).to_tokens(tokens); + + // Print lifetimes before types and consts, regardless of their + // order in self.params. + // + // TODO: ordering rules for const parameters vs type parameters have + // not been settled yet. https://github.com/rust-lang/rust/issues/44580 + let mut trailing_or_empty = true; + for param in self.0.params.pairs() { + if let GenericParam::Lifetime(_) = **param.value() { + param.to_tokens(tokens); + trailing_or_empty = param.punct().is_some(); + } + } + for param in self.0.params.pairs() { + if let GenericParam::Lifetime(_) = **param.value() { + continue; + } + if !trailing_or_empty { + <Token![,]>::default().to_tokens(tokens); + trailing_or_empty = true; + } + match **param.value() { + GenericParam::Lifetime(_) => unreachable!(), + GenericParam::Type(ref param) => { + // Leave off the type parameter defaults + tokens.append_all(param.attrs.outer()); + param.ident.to_tokens(tokens); + if !param.bounds.is_empty() { + TokensOrDefault(¶m.colon_token).to_tokens(tokens); + param.bounds.to_tokens(tokens); + } + } + GenericParam::Const(ref param) => { + // Leave off the const parameter defaults + tokens.append_all(param.attrs.outer()); + param.const_token.to_tokens(tokens); + param.ident.to_tokens(tokens); + param.colon_token.to_tokens(tokens); + param.ty.to_tokens(tokens); + } + } + param.punct().to_tokens(tokens); + } + + TokensOrDefault(&self.0.gt_token).to_tokens(tokens); + } + } + + impl<'a> ToTokens for TypeGenerics<'a> { + fn to_tokens(&self, tokens: &mut TokenStream) { + if self.0.params.is_empty() { + return; + } + + TokensOrDefault(&self.0.lt_token).to_tokens(tokens); + + // Print lifetimes before types and consts, regardless of their + // order in self.params. + // + // TODO: ordering rules for const parameters vs type parameters have + // not been settled yet. https://github.com/rust-lang/rust/issues/44580 + let mut trailing_or_empty = true; + for param in self.0.params.pairs() { + if let GenericParam::Lifetime(ref def) = **param.value() { + // Leave off the lifetime bounds and attributes + def.lifetime.to_tokens(tokens); + param.punct().to_tokens(tokens); + trailing_or_empty = param.punct().is_some(); + } + } + for param in self.0.params.pairs() { + if let GenericParam::Lifetime(_) = **param.value() { + continue; + } + if !trailing_or_empty { + <Token![,]>::default().to_tokens(tokens); + trailing_or_empty = true; + } + match **param.value() { + GenericParam::Lifetime(_) => unreachable!(), + GenericParam::Type(ref param) => { + // Leave off the type parameter defaults + param.ident.to_tokens(tokens); + } + GenericParam::Const(ref param) => { + // Leave off the const parameter defaults + param.ident.to_tokens(tokens); + } + } + param.punct().to_tokens(tokens); + } + + TokensOrDefault(&self.0.gt_token).to_tokens(tokens); + } + } + + impl<'a> ToTokens for Turbofish<'a> { + fn to_tokens(&self, tokens: &mut TokenStream) { + if !self.0.params.is_empty() { + <Token![::]>::default().to_tokens(tokens); + TypeGenerics(self.0).to_tokens(tokens); + } + } + } + + impl ToTokens for BoundLifetimes { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.for_token.to_tokens(tokens); + self.lt_token.to_tokens(tokens); + self.lifetimes.to_tokens(tokens); + self.gt_token.to_tokens(tokens); + } + } + + impl ToTokens for LifetimeDef { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.lifetime.to_tokens(tokens); + if !self.bounds.is_empty() { + TokensOrDefault(&self.colon_token).to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + } + } + + impl ToTokens for TypeParam { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.ident.to_tokens(tokens); + if !self.bounds.is_empty() { + TokensOrDefault(&self.colon_token).to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + if self.default.is_some() { + TokensOrDefault(&self.eq_token).to_tokens(tokens); + self.default.to_tokens(tokens); + } + } + } + + impl ToTokens for TraitBound { + fn to_tokens(&self, tokens: &mut TokenStream) { + let to_tokens = |tokens: &mut TokenStream| { + self.modifier.to_tokens(tokens); + self.lifetimes.to_tokens(tokens); + self.path.to_tokens(tokens); + }; + match self.paren_token { + Some(ref paren) => paren.surround(tokens, to_tokens), + None => to_tokens(tokens), + } + } + } + + impl ToTokens for TraitBoundModifier { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + TraitBoundModifier::None => {} + TraitBoundModifier::Maybe(ref t) => t.to_tokens(tokens), + } + } + } + + impl ToTokens for ConstParam { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.const_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + if self.default.is_some() { + TokensOrDefault(&self.eq_token).to_tokens(tokens); + self.default.to_tokens(tokens); + } + } + } + + impl ToTokens for WhereClause { + fn to_tokens(&self, tokens: &mut TokenStream) { + if !self.predicates.is_empty() { + self.where_token.to_tokens(tokens); + self.predicates.to_tokens(tokens); + } + } + } + + impl ToTokens for PredicateType { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.lifetimes.to_tokens(tokens); + self.bounded_ty.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + } + + impl ToTokens for PredicateLifetime { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.lifetime.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + } + + impl ToTokens for PredicateEq { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.lhs_ty.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.rhs_ty.to_tokens(tokens); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/group.rs b/rust/vendor/syn-0.15.44/src/group.rs new file mode 100644 index 0000000..f0ad7b4 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/group.rs @@ -0,0 +1,286 @@ +use proc_macro2::{Delimiter, Span}; + +use error::Result; +use parse::ParseBuffer; +use private; +use token; + +// Not public API. +#[doc(hidden)] +pub struct Parens<'a> { + pub token: token::Paren, + pub content: ParseBuffer<'a>, +} + +// Not public API. +#[doc(hidden)] +pub struct Braces<'a> { + pub token: token::Brace, + pub content: ParseBuffer<'a>, +} + +// Not public API. +#[doc(hidden)] +pub struct Brackets<'a> { + pub token: token::Bracket, + pub content: ParseBuffer<'a>, +} + +// Not public API. +#[cfg(any(feature = "full", feature = "derive"))] +#[doc(hidden)] +pub struct Group<'a> { + pub token: token::Group, + pub content: ParseBuffer<'a>, +} + +// Not public API. +#[doc(hidden)] +pub fn parse_parens<'a>(input: &ParseBuffer<'a>) -> Result<Parens<'a>> { + parse_delimited(input, Delimiter::Parenthesis).map(|(span, content)| Parens { + token: token::Paren(span), + content: content, + }) +} + +// Not public API. +#[doc(hidden)] +pub fn parse_braces<'a>(input: &ParseBuffer<'a>) -> Result<Braces<'a>> { + parse_delimited(input, Delimiter::Brace).map(|(span, content)| Braces { + token: token::Brace(span), + content: content, + }) +} + +// Not public API. +#[doc(hidden)] +pub fn parse_brackets<'a>(input: &ParseBuffer<'a>) -> Result<Brackets<'a>> { + parse_delimited(input, Delimiter::Bracket).map(|(span, content)| Brackets { + token: token::Bracket(span), + content: content, + }) +} + +#[cfg(any(feature = "full", feature = "derive"))] +impl private { + pub fn parse_group<'a>(input: &ParseBuffer<'a>) -> Result<Group<'a>> { + parse_delimited(input, Delimiter::None).map(|(span, content)| Group { + token: token::Group(span), + content: content, + }) + } +} + +fn parse_delimited<'a>( + input: &ParseBuffer<'a>, + delimiter: Delimiter, +) -> Result<(Span, ParseBuffer<'a>)> { + input.step(|cursor| { + if let Some((content, span, rest)) = cursor.group(delimiter) { + #[cfg(procmacro2_semver_exempt)] + let scope = private::close_span_of_group(*cursor); + #[cfg(not(procmacro2_semver_exempt))] + let scope = span; + let nested = private::advance_step_cursor(cursor, content); + let unexpected = private::get_unexpected(input); + let content = private::new_parse_buffer(scope, nested, unexpected); + Ok(((span, content), rest)) + } else { + let message = match delimiter { + Delimiter::Parenthesis => "expected parentheses", + Delimiter::Brace => "expected curly braces", + Delimiter::Bracket => "expected square brackets", + Delimiter::None => "expected invisible group", + }; + Err(cursor.error(message)) + } + }) +} + +/// Parse a set of parentheses and expose their content to subsequent parsers. +/// +/// # Example +/// +/// ```edition2018 +/// # use quote::quote; +/// # +/// use syn::{parenthesized, token, Ident, Result, Token, Type}; +/// use syn::parse::{Parse, ParseStream}; +/// use syn::punctuated::Punctuated; +/// +/// // Parse a simplified tuple struct syntax like: +/// // +/// // struct S(A, B); +/// struct TupleStruct { +/// struct_token: Token![struct], +/// ident: Ident, +/// paren_token: token::Paren, +/// fields: Punctuated<Type, Token![,]>, +/// semi_token: Token![;], +/// } +/// +/// impl Parse for TupleStruct { +/// fn parse(input: ParseStream) -> Result<Self> { +/// let content; +/// Ok(TupleStruct { +/// struct_token: input.parse()?, +/// ident: input.parse()?, +/// paren_token: parenthesized!(content in input), +/// fields: content.parse_terminated(Type::parse)?, +/// semi_token: input.parse()?, +/// }) +/// } +/// } +/// # +/// # fn main() { +/// # let input = quote! { +/// # struct S(A, B); +/// # }; +/// # syn::parse2::<TupleStruct>(input).unwrap(); +/// # } +/// ``` +#[macro_export] +macro_rules! parenthesized { + ($content:ident in $cursor:expr) => { + match $crate::group::parse_parens(&$cursor) { + $crate::export::Ok(parens) => { + $content = parens.content; + parens.token + } + $crate::export::Err(error) => { + return $crate::export::Err(error); + } + } + }; +} + +/// Parse a set of curly braces and expose their content to subsequent parsers. +/// +/// # Example +/// +/// ```edition2018 +/// # use quote::quote; +/// # +/// use syn::{braced, token, Ident, Result, Token, Type}; +/// use syn::parse::{Parse, ParseStream}; +/// use syn::punctuated::Punctuated; +/// +/// // Parse a simplified struct syntax like: +/// // +/// // struct S { +/// // a: A, +/// // b: B, +/// // } +/// struct Struct { +/// struct_token: Token![struct], +/// ident: Ident, +/// brace_token: token::Brace, +/// fields: Punctuated<Field, Token![,]>, +/// } +/// +/// struct Field { +/// name: Ident, +/// colon_token: Token![:], +/// ty: Type, +/// } +/// +/// impl Parse for Struct { +/// fn parse(input: ParseStream) -> Result<Self> { +/// let content; +/// Ok(Struct { +/// struct_token: input.parse()?, +/// ident: input.parse()?, +/// brace_token: braced!(content in input), +/// fields: content.parse_terminated(Field::parse)?, +/// }) +/// } +/// } +/// +/// impl Parse for Field { +/// fn parse(input: ParseStream) -> Result<Self> { +/// Ok(Field { +/// name: input.parse()?, +/// colon_token: input.parse()?, +/// ty: input.parse()?, +/// }) +/// } +/// } +/// # +/// # fn main() { +/// # let input = quote! { +/// # struct S { +/// # a: A, +/// # b: B, +/// # } +/// # }; +/// # syn::parse2::<Struct>(input).unwrap(); +/// # } +/// ``` +#[macro_export] +macro_rules! braced { + ($content:ident in $cursor:expr) => { + match $crate::group::parse_braces(&$cursor) { + $crate::export::Ok(braces) => { + $content = braces.content; + braces.token + } + $crate::export::Err(error) => { + return $crate::export::Err(error); + } + } + }; +} + +/// Parse a set of square brackets and expose their content to subsequent +/// parsers. +/// +/// # Example +/// +/// ```edition2018 +/// # use quote::quote; +/// # +/// use proc_macro2::TokenStream; +/// use syn::{bracketed, token, Result, Token}; +/// use syn::parse::{Parse, ParseStream}; +/// +/// // Parse an outer attribute like: +/// // +/// // #[repr(C, packed)] +/// struct OuterAttribute { +/// pound_token: Token![#], +/// bracket_token: token::Bracket, +/// content: TokenStream, +/// } +/// +/// impl Parse for OuterAttribute { +/// fn parse(input: ParseStream) -> Result<Self> { +/// let content; +/// Ok(OuterAttribute { +/// pound_token: input.parse()?, +/// bracket_token: bracketed!(content in input), +/// content: content.parse()?, +/// }) +/// } +/// } +/// # +/// # fn main() { +/// # let input = quote! { +/// # #[repr(C, packed)] +/// # }; +/// # syn::parse2::<OuterAttribute>(input).unwrap(); +/// # } +/// ``` +#[macro_export] +macro_rules! bracketed { + ($content:ident in $cursor:expr) => { + match $crate::group::parse_brackets(&$cursor) { + $crate::export::Ok(brackets) => { + $content = brackets.content; + brackets.token + } + $crate::export::Err(error) => { + return $crate::export::Err(error); + } + } + }; +} diff --git a/rust/vendor/syn-0.15.44/src/ident.rs b/rust/vendor/syn-0.15.44/src/ident.rs new file mode 100644 index 0000000..41279ae --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/ident.rs @@ -0,0 +1,100 @@ +#[cfg(feature = "parsing")] +use buffer::Cursor; +#[cfg(feature = "parsing")] +use parse::{Parse, ParseStream, Result}; +#[cfg(feature = "parsing")] +use token::Token; +#[cfg(feature = "parsing")] +use {lookahead, private}; + +pub use proc_macro2::Ident; + +#[cfg(feature = "parsing")] +#[doc(hidden)] +#[allow(non_snake_case)] +pub fn Ident(marker: lookahead::TokenMarker) -> Ident { + match marker {} +} + +#[cfg(feature = "parsing")] +fn accept_as_ident(ident: &Ident) -> bool { + match ident.to_string().as_str() { + "_" | + // Based on https://doc.rust-lang.org/grammar.html#keywords + // and https://github.com/rust-lang/rfcs/blob/master/text/2421-unreservations-2018.md + // and https://github.com/rust-lang/rfcs/blob/master/text/2420-unreserve-proc.md + "abstract" | "as" | "become" | "box" | "break" | "const" | "continue" | + "crate" | "do" | "else" | "enum" | "extern" | "false" | "final" | "fn" | + "for" | "if" | "impl" | "in" | "let" | "loop" | "macro" | "match" | + "mod" | "move" | "mut" | "override" | "priv" | "pub" | "ref" | + "return" | "Self" | "self" | "static" | "struct" | "super" | "trait" | + "true" | "type" | "typeof" | "unsafe" | "unsized" | "use" | "virtual" | + "where" | "while" | "yield" => false, + _ => true, + } +} + +#[cfg(feature = "parsing")] +impl Parse for Ident { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| { + if let Some((ident, rest)) = cursor.ident() { + if accept_as_ident(&ident) { + return Ok((ident, rest)); + } + } + Err(cursor.error("expected identifier")) + }) + } +} + +#[cfg(feature = "parsing")] +impl Token for Ident { + fn peek(cursor: Cursor) -> bool { + if let Some((ident, _rest)) = cursor.ident() { + accept_as_ident(&ident) + } else { + false + } + } + + fn display() -> &'static str { + "identifier" + } +} + +macro_rules! ident_from_token { + ($token:ident) => { + impl From<Token![$token]> for Ident { + fn from(token: Token![$token]) -> Ident { + Ident::new(stringify!($token), token.span) + } + } + }; +} + +ident_from_token!(self); +ident_from_token!(Self); +ident_from_token!(super); +ident_from_token!(crate); +ident_from_token!(extern); + +impl From<Token![_]> for Ident { + fn from(token: Token![_]) -> Ident { + Ident::new("_", token.span) + } +} + +#[cfg(feature = "parsing")] +impl private { + #[cfg(syn_can_use_associated_constants)] + pub fn peek_any_ident(input: ParseStream) -> bool { + use ext::IdentExt; + input.peek(Ident::peek_any) + } + + #[cfg(not(syn_can_use_associated_constants))] + pub fn peek_any_ident(input: ParseStream) -> bool { + input.cursor().ident().is_some() + } +} diff --git a/rust/vendor/syn-0.15.44/src/item.rs b/rust/vendor/syn-0.15.44/src/item.rs new file mode 100644 index 0000000..0634657 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/item.rs @@ -0,0 +1,2771 @@ +use super::*; +use derive::{Data, DeriveInput}; +use proc_macro2::TokenStream; +use punctuated::Punctuated; +use token::{Brace, Paren}; + +#[cfg(feature = "extra-traits")] +use std::hash::{Hash, Hasher}; +#[cfg(feature = "extra-traits")] +use tt::TokenStreamHelper; + +ast_enum_of_structs! { + /// Things that can appear directly inside of a module or scope. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum Item { + /// An `extern crate` item: `extern crate serde`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub ExternCrate(ItemExternCrate { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub extern_token: Token![extern], + pub crate_token: Token![crate], + pub ident: Ident, + pub rename: Option<(Token![as], Ident)>, + pub semi_token: Token![;], + }), + + /// A use declaration: `use std::collections::HashMap`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Use(ItemUse { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub use_token: Token![use], + pub leading_colon: Option<Token![::]>, + pub tree: UseTree, + pub semi_token: Token![;], + }), + + /// A static item: `static BIKE: Shed = Shed(42)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Static(ItemStatic { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub static_token: Token![static], + pub mutability: Option<Token![mut]>, + pub ident: Ident, + pub colon_token: Token![:], + pub ty: Box<Type>, + pub eq_token: Token![=], + pub expr: Box<Expr>, + pub semi_token: Token![;], + }), + + /// A constant item: `const MAX: u16 = 65535`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Const(ItemConst { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub const_token: Token![const], + pub ident: Ident, + pub colon_token: Token![:], + pub ty: Box<Type>, + pub eq_token: Token![=], + pub expr: Box<Expr>, + pub semi_token: Token![;], + }), + + /// A free-standing function: `fn process(n: usize) -> Result<()> { ... + /// }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Fn(ItemFn { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub constness: Option<Token![const]>, + pub asyncness: Option<Token![async]>, + pub unsafety: Option<Token![unsafe]>, + pub abi: Option<Abi>, + pub ident: Ident, + pub decl: Box<FnDecl>, + pub block: Box<Block>, + }), + + /// A module or module declaration: `mod m` or `mod m { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Mod(ItemMod { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub mod_token: Token![mod], + pub ident: Ident, + pub content: Option<(token::Brace, Vec<Item>)>, + pub semi: Option<Token![;]>, + }), + + /// A block of foreign items: `extern "C" { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub ForeignMod(ItemForeignMod { + pub attrs: Vec<Attribute>, + pub abi: Abi, + pub brace_token: token::Brace, + pub items: Vec<ForeignItem>, + }), + + /// A type alias: `type Result<T> = std::result::Result<T, MyError>`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Type(ItemType { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub type_token: Token![type], + pub ident: Ident, + pub generics: Generics, + pub eq_token: Token![=], + pub ty: Box<Type>, + pub semi_token: Token![;], + }), + + /// An existential type: `existential type Iter: Iterator<Item = u8>`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Existential(ItemExistential { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub existential_token: Token![existential], + pub type_token: Token![type], + pub ident: Ident, + pub generics: Generics, + pub colon_token: Option<Token![:]>, + pub bounds: Punctuated<TypeParamBound, Token![+]>, + pub semi_token: Token![;], + }), + + /// A struct definition: `struct Foo<A> { x: A }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Struct(ItemStruct { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub struct_token: Token![struct], + pub ident: Ident, + pub generics: Generics, + pub fields: Fields, + pub semi_token: Option<Token![;]>, + }), + + /// An enum definition: `enum Foo<A, B> { C<A>, D<B> }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Enum(ItemEnum { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub enum_token: Token![enum], + pub ident: Ident, + pub generics: Generics, + pub brace_token: token::Brace, + pub variants: Punctuated<Variant, Token![,]>, + }), + + /// A union definition: `union Foo<A, B> { x: A, y: B }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Union(ItemUnion { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub union_token: Token![union], + pub ident: Ident, + pub generics: Generics, + pub fields: FieldsNamed, + }), + + /// A trait definition: `pub trait Iterator { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Trait(ItemTrait { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub unsafety: Option<Token![unsafe]>, + pub auto_token: Option<Token![auto]>, + pub trait_token: Token![trait], + pub ident: Ident, + pub generics: Generics, + pub colon_token: Option<Token![:]>, + pub supertraits: Punctuated<TypeParamBound, Token![+]>, + pub brace_token: token::Brace, + pub items: Vec<TraitItem>, + }), + + /// A trait alias: `pub trait SharableIterator = Iterator + Sync`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub TraitAlias(ItemTraitAlias { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub trait_token: Token![trait], + pub ident: Ident, + pub generics: Generics, + pub eq_token: Token![=], + pub bounds: Punctuated<TypeParamBound, Token![+]>, + pub semi_token: Token![;], + }), + + /// An impl block providing trait or associated items: `impl<A> Trait + /// for Data<A> { ... }`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Impl(ItemImpl { + pub attrs: Vec<Attribute>, + pub defaultness: Option<Token![default]>, + pub unsafety: Option<Token![unsafe]>, + pub impl_token: Token![impl], + pub generics: Generics, + /// Trait this impl implements. + pub trait_: Option<(Option<Token![!]>, Path, Token![for])>, + /// The Self type of the impl. + pub self_ty: Box<Type>, + pub brace_token: token::Brace, + pub items: Vec<ImplItem>, + }), + + /// A macro invocation, which includes `macro_rules!` definitions. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Macro(ItemMacro { + pub attrs: Vec<Attribute>, + /// The `example` in `macro_rules! example { ... }`. + pub ident: Option<Ident>, + pub mac: Macro, + pub semi_token: Option<Token![;]>, + }), + + /// A 2.0-style declarative macro introduced by the `macro` keyword. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Macro2(ItemMacro2 #manual_extra_traits { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub macro_token: Token![macro], + pub ident: Ident, + pub paren_token: Paren, + pub args: TokenStream, + pub brace_token: Brace, + pub body: TokenStream, + }), + + /// Tokens forming an item not interpreted by Syn. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Verbatim(ItemVerbatim #manual_extra_traits { + pub tts: TokenStream, + }), + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for ItemMacro2 {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for ItemMacro2 { + fn eq(&self, other: &Self) -> bool { + self.attrs == other.attrs + && self.vis == other.vis + && self.macro_token == other.macro_token + && self.ident == other.ident + && self.paren_token == other.paren_token + && TokenStreamHelper(&self.args) == TokenStreamHelper(&other.args) + && self.brace_token == other.brace_token + && TokenStreamHelper(&self.body) == TokenStreamHelper(&other.body) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for ItemMacro2 { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + self.attrs.hash(state); + self.vis.hash(state); + self.macro_token.hash(state); + self.ident.hash(state); + self.paren_token.hash(state); + TokenStreamHelper(&self.args).hash(state); + self.brace_token.hash(state); + TokenStreamHelper(&self.body).hash(state); + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for ItemVerbatim {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for ItemVerbatim { + fn eq(&self, other: &Self) -> bool { + TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for ItemVerbatim { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + TokenStreamHelper(&self.tts).hash(state); + } +} + +impl From<DeriveInput> for Item { + fn from(input: DeriveInput) -> Item { + match input.data { + Data::Struct(data) => Item::Struct(ItemStruct { + attrs: input.attrs, + vis: input.vis, + struct_token: data.struct_token, + ident: input.ident, + generics: input.generics, + fields: data.fields, + semi_token: data.semi_token, + }), + Data::Enum(data) => Item::Enum(ItemEnum { + attrs: input.attrs, + vis: input.vis, + enum_token: data.enum_token, + ident: input.ident, + generics: input.generics, + brace_token: data.brace_token, + variants: data.variants, + }), + Data::Union(data) => Item::Union(ItemUnion { + attrs: input.attrs, + vis: input.vis, + union_token: data.union_token, + ident: input.ident, + generics: input.generics, + fields: data.fields, + }), + } + } +} + +ast_enum_of_structs! { + /// A suffix of an import tree in a `use` item: `Type as Renamed` or `*`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum UseTree { + /// A path prefix of imports in a `use` item: `std::...`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Path(UsePath { + pub ident: Ident, + pub colon2_token: Token![::], + pub tree: Box<UseTree>, + }), + + /// An identifier imported by a `use` item: `HashMap`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Name(UseName { + pub ident: Ident, + }), + + /// An renamed identifier imported by a `use` item: `HashMap as Map`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Rename(UseRename { + pub ident: Ident, + pub as_token: Token![as], + pub rename: Ident, + }), + + /// A glob import in a `use` item: `*`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Glob(UseGlob { + pub star_token: Token![*], + }), + + /// A braced group of imports in a `use` item: `{A, B, C}`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Group(UseGroup { + pub brace_token: token::Brace, + pub items: Punctuated<UseTree, Token![,]>, + }), + } +} + +ast_enum_of_structs! { + /// An item within an `extern` block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum ForeignItem { + /// A foreign function in an `extern` block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Fn(ForeignItemFn { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub ident: Ident, + pub decl: Box<FnDecl>, + pub semi_token: Token![;], + }), + + /// A foreign static item in an `extern` block: `static ext: u8`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Static(ForeignItemStatic { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub static_token: Token![static], + pub mutability: Option<Token![mut]>, + pub ident: Ident, + pub colon_token: Token![:], + pub ty: Box<Type>, + pub semi_token: Token![;], + }), + + /// A foreign type in an `extern` block: `type void`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Type(ForeignItemType { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub type_token: Token![type], + pub ident: Ident, + pub semi_token: Token![;], + }), + + /// A macro invocation within an extern block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Macro(ForeignItemMacro { + pub attrs: Vec<Attribute>, + pub mac: Macro, + pub semi_token: Option<Token![;]>, + }), + + /// Tokens in an `extern` block not interpreted by Syn. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Verbatim(ForeignItemVerbatim #manual_extra_traits { + pub tts: TokenStream, + }), + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for ForeignItemVerbatim {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for ForeignItemVerbatim { + fn eq(&self, other: &Self) -> bool { + TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for ForeignItemVerbatim { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + TokenStreamHelper(&self.tts).hash(state); + } +} + +ast_enum_of_structs! { + /// An item declaration within the definition of a trait. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum TraitItem { + /// An associated constant within the definition of a trait. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Const(TraitItemConst { + pub attrs: Vec<Attribute>, + pub const_token: Token![const], + pub ident: Ident, + pub colon_token: Token![:], + pub ty: Type, + pub default: Option<(Token![=], Expr)>, + pub semi_token: Token![;], + }), + + /// A trait method within the definition of a trait. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Method(TraitItemMethod { + pub attrs: Vec<Attribute>, + pub sig: MethodSig, + pub default: Option<Block>, + pub semi_token: Option<Token![;]>, + }), + + /// An associated type within the definition of a trait. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Type(TraitItemType { + pub attrs: Vec<Attribute>, + pub type_token: Token![type], + pub ident: Ident, + pub generics: Generics, + pub colon_token: Option<Token![:]>, + pub bounds: Punctuated<TypeParamBound, Token![+]>, + pub default: Option<(Token![=], Type)>, + pub semi_token: Token![;], + }), + + /// A macro invocation within the definition of a trait. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Macro(TraitItemMacro { + pub attrs: Vec<Attribute>, + pub mac: Macro, + pub semi_token: Option<Token![;]>, + }), + + /// Tokens within the definition of a trait not interpreted by Syn. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Verbatim(TraitItemVerbatim #manual_extra_traits { + pub tts: TokenStream, + }), + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for TraitItemVerbatim {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for TraitItemVerbatim { + fn eq(&self, other: &Self) -> bool { + TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for TraitItemVerbatim { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + TokenStreamHelper(&self.tts).hash(state); + } +} + +ast_enum_of_structs! { + /// An item within an impl block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum ImplItem { + /// An associated constant within an impl block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Const(ImplItemConst { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub defaultness: Option<Token![default]>, + pub const_token: Token![const], + pub ident: Ident, + pub colon_token: Token![:], + pub ty: Type, + pub eq_token: Token![=], + pub expr: Expr, + pub semi_token: Token![;], + }), + + /// A method within an impl block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Method(ImplItemMethod { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub defaultness: Option<Token![default]>, + pub sig: MethodSig, + pub block: Block, + }), + + /// An associated type within an impl block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Type(ImplItemType { + pub attrs: Vec<Attribute>, + pub vis: Visibility, + pub defaultness: Option<Token![default]>, + pub type_token: Token![type], + pub ident: Ident, + pub generics: Generics, + pub eq_token: Token![=], + pub ty: Type, + pub semi_token: Token![;], + }), + + /// An existential type within an impl block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Existential(ImplItemExistential { + pub attrs: Vec<Attribute>, + pub existential_token: Token![existential], + pub type_token: Token![type], + pub ident: Ident, + pub generics: Generics, + pub colon_token: Option<Token![:]>, + pub bounds: Punctuated<TypeParamBound, Token![+]>, + pub semi_token: Token![;], + }), + + /// A macro invocation within an impl block. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Macro(ImplItemMacro { + pub attrs: Vec<Attribute>, + pub mac: Macro, + pub semi_token: Option<Token![;]>, + }), + + /// Tokens within an impl block not interpreted by Syn. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Verbatim(ImplItemVerbatim #manual_extra_traits { + pub tts: TokenStream, + }), + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for ImplItemVerbatim {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for ImplItemVerbatim { + fn eq(&self, other: &Self) -> bool { + TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for ImplItemVerbatim { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + TokenStreamHelper(&self.tts).hash(state); + } +} + +ast_struct! { + /// A method's signature in a trait or implementation: `unsafe fn + /// initialize(&self)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct MethodSig { + pub constness: Option<Token![const]>, + pub asyncness: Option<Token![async]>, + pub unsafety: Option<Token![unsafe]>, + pub abi: Option<Abi>, + pub ident: Ident, + pub decl: FnDecl, + } +} + +ast_struct! { + /// Header of a function declaration, without including the body. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub struct FnDecl { + pub fn_token: Token![fn], + pub generics: Generics, + pub paren_token: token::Paren, + pub inputs: Punctuated<FnArg, Token![,]>, + pub variadic: Option<Token![...]>, + pub output: ReturnType, + } +} + +ast_enum_of_structs! { + /// An argument in a function signature: the `n: usize` in `fn f(n: usize)`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum FnArg { + /// Self captured by reference in a function signature: `&self` or `&mut + /// self`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub SelfRef(ArgSelfRef { + pub and_token: Token![&], + pub lifetime: Option<Lifetime>, + pub mutability: Option<Token![mut]>, + pub self_token: Token![self], + }), + + /// Self captured by value in a function signature: `self` or `mut + /// self`. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub SelfValue(ArgSelf { + pub mutability: Option<Token![mut]>, + pub self_token: Token![self], + }), + + /// An explicitly typed pattern captured by a function signature. + /// + /// *This type is available if Syn is built with the `"full"` feature.* + pub Captured(ArgCaptured { + pub pat: Pat, + pub colon_token: Token![:], + pub ty: Type, + }), + + /// A pattern whose type is inferred captured by a function signature. + pub Inferred(Pat), + /// A type not bound to any pattern in a function signature. + pub Ignored(Type), + } +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use ext::IdentExt; + use parse::{Parse, ParseStream, Result}; + use proc_macro2::{Punct, Spacing, TokenTree}; + use std::iter::FromIterator; + + impl Parse for Item { + fn parse(input: ParseStream) -> Result<Self> { + let mut attrs = input.call(Attribute::parse_outer)?; + let ahead = input.fork(); + let vis: Visibility = ahead.parse()?; + + let lookahead = ahead.lookahead1(); + let mut item = if lookahead.peek(Token![extern]) { + ahead.parse::<Token![extern]>()?; + let lookahead = ahead.lookahead1(); + if lookahead.peek(Token![crate]) { + input.parse().map(Item::ExternCrate) + } else if lookahead.peek(Token![fn]) { + input.parse().map(Item::Fn) + } else if lookahead.peek(token::Brace) { + input.parse().map(Item::ForeignMod) + } else if lookahead.peek(LitStr) { + ahead.parse::<LitStr>()?; + let lookahead = ahead.lookahead1(); + if lookahead.peek(token::Brace) { + input.parse().map(Item::ForeignMod) + } else if lookahead.peek(Token![fn]) { + input.parse().map(Item::Fn) + } else { + Err(lookahead.error()) + } + } else { + Err(lookahead.error()) + } + } else if lookahead.peek(Token![use]) { + input.parse().map(Item::Use) + } else if lookahead.peek(Token![static]) { + input.parse().map(Item::Static) + } else if lookahead.peek(Token![const]) { + ahead.parse::<Token![const]>()?; + let lookahead = ahead.lookahead1(); + if lookahead.peek(Ident) || lookahead.peek(Token![_]) { + input.parse().map(Item::Const) + } else if lookahead.peek(Token![unsafe]) + || lookahead.peek(Token![async]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![fn]) + { + input.parse().map(Item::Fn) + } else { + Err(lookahead.error()) + } + } else if lookahead.peek(Token![unsafe]) { + ahead.parse::<Token![unsafe]>()?; + let lookahead = ahead.lookahead1(); + if lookahead.peek(Token![trait]) + || lookahead.peek(Token![auto]) && ahead.peek2(Token![trait]) + { + input.parse().map(Item::Trait) + } else if lookahead.peek(Token![impl]) { + input.parse().map(Item::Impl) + } else if lookahead.peek(Token![async]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![fn]) + { + input.parse().map(Item::Fn) + } else { + Err(lookahead.error()) + } + } else if lookahead.peek(Token![async]) || lookahead.peek(Token![fn]) { + input.parse().map(Item::Fn) + } else if lookahead.peek(Token![mod]) { + input.parse().map(Item::Mod) + } else if lookahead.peek(Token![type]) { + input.parse().map(Item::Type) + } else if lookahead.peek(Token![existential]) { + input.parse().map(Item::Existential) + } else if lookahead.peek(Token![struct]) { + input.parse().map(Item::Struct) + } else if lookahead.peek(Token![enum]) { + input.parse().map(Item::Enum) + } else if lookahead.peek(Token![union]) && ahead.peek2(Ident) { + input.parse().map(Item::Union) + } else if lookahead.peek(Token![trait]) { + input.call(parse_trait_or_trait_alias) + } else if lookahead.peek(Token![auto]) && ahead.peek2(Token![trait]) { + input.parse().map(Item::Trait) + } else if lookahead.peek(Token![impl]) + || lookahead.peek(Token![default]) && !ahead.peek2(Token![!]) + { + input.parse().map(Item::Impl) + } else if lookahead.peek(Token![macro]) { + input.parse().map(Item::Macro2) + } else if vis.is_inherited() + && (lookahead.peek(Ident) + || lookahead.peek(Token![self]) + || lookahead.peek(Token![super]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![crate]) + || lookahead.peek(Token![::])) + { + input.parse().map(Item::Macro) + } else { + Err(lookahead.error()) + }?; + + { + let item_attrs = match item { + Item::ExternCrate(ref mut item) => &mut item.attrs, + Item::Use(ref mut item) => &mut item.attrs, + Item::Static(ref mut item) => &mut item.attrs, + Item::Const(ref mut item) => &mut item.attrs, + Item::Fn(ref mut item) => &mut item.attrs, + Item::Mod(ref mut item) => &mut item.attrs, + Item::ForeignMod(ref mut item) => &mut item.attrs, + Item::Type(ref mut item) => &mut item.attrs, + Item::Existential(ref mut item) => &mut item.attrs, + Item::Struct(ref mut item) => &mut item.attrs, + Item::Enum(ref mut item) => &mut item.attrs, + Item::Union(ref mut item) => &mut item.attrs, + Item::Trait(ref mut item) => &mut item.attrs, + Item::TraitAlias(ref mut item) => &mut item.attrs, + Item::Impl(ref mut item) => &mut item.attrs, + Item::Macro(ref mut item) => &mut item.attrs, + Item::Macro2(ref mut item) => &mut item.attrs, + Item::Verbatim(_) => unreachable!(), + }; + attrs.extend(item_attrs.drain(..)); + *item_attrs = attrs; + } + + Ok(item) + } + } + + impl Parse for ItemMacro { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let path = input.call(Path::parse_mod_style)?; + let bang_token: Token![!] = input.parse()?; + let ident: Option<Ident> = input.parse()?; + let (delimiter, tts) = input.call(mac::parse_delimiter)?; + let semi_token: Option<Token![;]> = if !delimiter.is_brace() { + Some(input.parse()?) + } else { + None + }; + Ok(ItemMacro { + attrs: attrs, + ident: ident, + mac: Macro { + path: path, + bang_token: bang_token, + delimiter: delimiter, + tts: tts, + }, + semi_token: semi_token, + }) + } + } + + // TODO: figure out the actual grammar; is body required to be braced? + impl Parse for ItemMacro2 { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let vis: Visibility = input.parse()?; + let macro_token: Token![macro] = input.parse()?; + let ident: Ident = input.parse()?; + + let paren_token; + let args; + let brace_token; + let body; + let lookahead = input.lookahead1(); + if lookahead.peek(token::Paren) { + let paren_content; + paren_token = parenthesized!(paren_content in input); + args = paren_content.parse()?; + + let brace_content; + brace_token = braced!(brace_content in input); + body = brace_content.parse()?; + } else if lookahead.peek(token::Brace) { + // Hack: the ItemMacro2 syntax tree will need to change so that + // we can store None for the args. + // + // https://github.com/dtolnay/syn/issues/548 + // + // For now, store some sentinel tokens that are otherwise + // illegal. + paren_token = token::Paren::default(); + args = TokenStream::from_iter(vec![ + TokenTree::Punct(Punct::new('$', Spacing::Alone)), + TokenTree::Punct(Punct::new('$', Spacing::Alone)), + ]); + + let brace_content; + brace_token = braced!(brace_content in input); + body = brace_content.parse()?; + } else { + return Err(lookahead.error()); + } + + Ok(ItemMacro2 { + attrs: attrs, + vis: vis, + macro_token: macro_token, + ident: ident, + paren_token: paren_token, + args: args, + brace_token: brace_token, + body: body, + }) + } + } + + impl Parse for ItemExternCrate { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ItemExternCrate { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + extern_token: input.parse()?, + crate_token: input.parse()?, + ident: { + if input.peek(Token![self]) { + input.call(Ident::parse_any)? + } else { + input.parse()? + } + }, + rename: { + if input.peek(Token![as]) { + let as_token: Token![as] = input.parse()?; + let rename: Ident = input.parse()?; + Some((as_token, rename)) + } else { + None + } + }, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ItemUse { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ItemUse { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + use_token: input.parse()?, + leading_colon: input.parse()?, + tree: input.parse()?, + semi_token: input.parse()?, + }) + } + } + + impl Parse for UseTree { + fn parse(input: ParseStream) -> Result<UseTree> { + let lookahead = input.lookahead1(); + if lookahead.peek(Ident) + || lookahead.peek(Token![self]) + || lookahead.peek(Token![super]) + || lookahead.peek(Token![crate]) + || lookahead.peek(Token![extern]) + { + let ident = input.call(Ident::parse_any)?; + if input.peek(Token![::]) { + Ok(UseTree::Path(UsePath { + ident: ident, + colon2_token: input.parse()?, + tree: Box::new(input.parse()?), + })) + } else if input.peek(Token![as]) { + Ok(UseTree::Rename(UseRename { + ident: ident, + as_token: input.parse()?, + rename: { + if input.peek(Ident) { + input.parse()? + } else if input.peek(Token![_]) { + Ident::from(input.parse::<Token![_]>()?) + } else { + return Err(input.error("expected identifier or underscore")); + } + }, + })) + } else { + Ok(UseTree::Name(UseName { ident: ident })) + } + } else if lookahead.peek(Token![*]) { + Ok(UseTree::Glob(UseGlob { + star_token: input.parse()?, + })) + } else if lookahead.peek(token::Brace) { + let content; + Ok(UseTree::Group(UseGroup { + brace_token: braced!(content in input), + items: content.parse_terminated(UseTree::parse)?, + })) + } else { + Err(lookahead.error()) + } + } + } + + impl Parse for ItemStatic { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ItemStatic { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + static_token: input.parse()?, + mutability: input.parse()?, + ident: input.parse()?, + colon_token: input.parse()?, + ty: input.parse()?, + eq_token: input.parse()?, + expr: input.parse()?, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ItemConst { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ItemConst { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + const_token: input.parse()?, + ident: { + let lookahead = input.lookahead1(); + if lookahead.peek(Ident) || lookahead.peek(Token![_]) { + input.call(Ident::parse_any)? + } else { + return Err(lookahead.error()); + } + }, + colon_token: input.parse()?, + ty: input.parse()?, + eq_token: input.parse()?, + expr: input.parse()?, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ItemFn { + fn parse(input: ParseStream) -> Result<Self> { + let outer_attrs = input.call(Attribute::parse_outer)?; + let vis: Visibility = input.parse()?; + let constness: Option<Token![const]> = input.parse()?; + let asyncness: Option<Token![async]> = input.parse()?; + let unsafety: Option<Token![unsafe]> = input.parse()?; + let abi: Option<Abi> = input.parse()?; + let fn_token: Token![fn] = input.parse()?; + let ident: Ident = input.parse()?; + let generics: Generics = input.parse()?; + + let content; + let paren_token = parenthesized!(content in input); + let inputs = content.parse_terminated(FnArg::parse)?; + let variadic: Option<Token![...]> = match inputs.last() { + Some(punctuated::Pair::End(&FnArg::Captured(ArgCaptured { + ty: Type::Verbatim(TypeVerbatim { ref tts }), + .. + }))) => parse2(tts.clone()).ok(), + _ => None, + }; + + let output: ReturnType = input.parse()?; + let where_clause: Option<WhereClause> = input.parse()?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let stmts = content.call(Block::parse_within)?; + + Ok(ItemFn { + attrs: private::attrs(outer_attrs, inner_attrs), + vis: vis, + constness: constness, + asyncness: asyncness, + unsafety: unsafety, + abi: abi, + ident: ident, + decl: Box::new(FnDecl { + fn_token: fn_token, + paren_token: paren_token, + inputs: inputs, + output: output, + variadic: variadic, + generics: Generics { + where_clause: where_clause, + ..generics + }, + }), + block: Box::new(Block { + brace_token: brace_token, + stmts: stmts, + }), + }) + } + } + + impl Parse for FnArg { + fn parse(input: ParseStream) -> Result<Self> { + // TODO: optimize using advance_to + + if input.peek(Token![&]) { + let ahead = input.fork(); + if ahead.call(arg_self_ref).is_ok() && !ahead.peek(Token![:]) { + return input.call(arg_self_ref).map(FnArg::SelfRef); + } + } + + if input.peek(Token![mut]) || input.peek(Token![self]) { + let ahead = input.fork(); + if ahead.call(arg_self).is_ok() && !ahead.peek(Token![:]) { + return input.call(arg_self).map(FnArg::SelfValue); + } + } + + let ahead = input.fork(); + let err = match ahead.call(arg_captured) { + Ok(_) => return input.call(arg_captured).map(FnArg::Captured), + Err(err) => err, + }; + + let ahead = input.fork(); + if ahead.parse::<Type>().is_ok() { + return input.parse().map(FnArg::Ignored); + } + + Err(err) + } + } + + fn arg_self_ref(input: ParseStream) -> Result<ArgSelfRef> { + Ok(ArgSelfRef { + and_token: input.parse()?, + lifetime: input.parse()?, + mutability: input.parse()?, + self_token: input.parse()?, + }) + } + + fn arg_self(input: ParseStream) -> Result<ArgSelf> { + Ok(ArgSelf { + mutability: input.parse()?, + self_token: input.parse()?, + }) + } + + fn arg_captured(input: ParseStream) -> Result<ArgCaptured> { + Ok(ArgCaptured { + pat: input.parse()?, + colon_token: input.parse()?, + ty: match input.parse::<Token![...]>() { + Ok(dot3) => { + let args = vec![ + TokenTree::Punct(Punct::new('.', Spacing::Joint)), + TokenTree::Punct(Punct::new('.', Spacing::Joint)), + TokenTree::Punct(Punct::new('.', Spacing::Alone)), + ]; + let tokens = TokenStream::from_iter(args.into_iter().zip(&dot3.spans).map( + |(mut arg, span)| { + arg.set_span(*span); + arg + }, + )); + Type::Verbatim(TypeVerbatim { tts: tokens }) + } + Err(_) => input.parse()?, + }, + }) + } + + impl Parse for ItemMod { + fn parse(input: ParseStream) -> Result<Self> { + let outer_attrs = input.call(Attribute::parse_outer)?; + let vis: Visibility = input.parse()?; + let mod_token: Token![mod] = input.parse()?; + let ident: Ident = input.parse()?; + + let lookahead = input.lookahead1(); + if lookahead.peek(Token![;]) { + Ok(ItemMod { + attrs: outer_attrs, + vis: vis, + mod_token: mod_token, + ident: ident, + content: None, + semi: Some(input.parse()?), + }) + } else if lookahead.peek(token::Brace) { + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + + let mut items = Vec::new(); + while !content.is_empty() { + items.push(content.parse()?); + } + + Ok(ItemMod { + attrs: private::attrs(outer_attrs, inner_attrs), + vis: vis, + mod_token: mod_token, + ident: ident, + content: Some((brace_token, items)), + semi: None, + }) + } else { + Err(lookahead.error()) + } + } + } + + impl Parse for ItemForeignMod { + fn parse(input: ParseStream) -> Result<Self> { + let outer_attrs = input.call(Attribute::parse_outer)?; + let abi: Abi = input.parse()?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let mut items = Vec::new(); + while !content.is_empty() { + items.push(content.parse()?); + } + + Ok(ItemForeignMod { + attrs: private::attrs(outer_attrs, inner_attrs), + abi: abi, + brace_token: brace_token, + items: items, + }) + } + } + + impl Parse for ForeignItem { + fn parse(input: ParseStream) -> Result<Self> { + let mut attrs = input.call(Attribute::parse_outer)?; + let ahead = input.fork(); + let vis: Visibility = ahead.parse()?; + + let lookahead = ahead.lookahead1(); + let mut item = if lookahead.peek(Token![fn]) { + input.parse().map(ForeignItem::Fn) + } else if lookahead.peek(Token![static]) { + input.parse().map(ForeignItem::Static) + } else if lookahead.peek(Token![type]) { + input.parse().map(ForeignItem::Type) + } else if vis.is_inherited() + && (lookahead.peek(Ident) + || lookahead.peek(Token![self]) + || lookahead.peek(Token![super]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![crate]) + || lookahead.peek(Token![::])) + { + input.parse().map(ForeignItem::Macro) + } else { + Err(lookahead.error()) + }?; + + { + let item_attrs = match item { + ForeignItem::Fn(ref mut item) => &mut item.attrs, + ForeignItem::Static(ref mut item) => &mut item.attrs, + ForeignItem::Type(ref mut item) => &mut item.attrs, + ForeignItem::Macro(ref mut item) => &mut item.attrs, + ForeignItem::Verbatim(_) => unreachable!(), + }; + attrs.extend(item_attrs.drain(..)); + *item_attrs = attrs; + } + + Ok(item) + } + } + + impl Parse for ForeignItemFn { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let vis: Visibility = input.parse()?; + let fn_token: Token![fn] = input.parse()?; + let ident: Ident = input.parse()?; + let generics: Generics = input.parse()?; + + let content; + let paren_token = parenthesized!(content in input); + let mut inputs = Punctuated::new(); + while !content.is_empty() && !content.peek(Token![...]) { + inputs.push_value(content.parse()?); + if content.is_empty() { + break; + } + inputs.push_punct(content.parse()?); + } + let variadic: Option<Token![...]> = if inputs.empty_or_trailing() { + content.parse()? + } else { + None + }; + + let output: ReturnType = input.parse()?; + let where_clause: Option<WhereClause> = input.parse()?; + let semi_token: Token![;] = input.parse()?; + + Ok(ForeignItemFn { + attrs: attrs, + vis: vis, + ident: ident, + decl: Box::new(FnDecl { + fn_token: fn_token, + paren_token: paren_token, + inputs: inputs, + output: output, + variadic: variadic, + generics: Generics { + where_clause: where_clause, + ..generics + }, + }), + semi_token: semi_token, + }) + } + } + + impl Parse for ForeignItemStatic { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ForeignItemStatic { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + static_token: input.parse()?, + mutability: input.parse()?, + ident: input.parse()?, + colon_token: input.parse()?, + ty: input.parse()?, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ForeignItemType { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ForeignItemType { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + type_token: input.parse()?, + ident: input.parse()?, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ForeignItemMacro { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let mac: Macro = input.parse()?; + let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { + None + } else { + Some(input.parse()?) + }; + Ok(ForeignItemMacro { + attrs: attrs, + mac: mac, + semi_token: semi_token, + }) + } + } + + impl Parse for ItemType { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ItemType { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + type_token: input.parse()?, + ident: input.parse()?, + generics: { + let mut generics: Generics = input.parse()?; + generics.where_clause = input.parse()?; + generics + }, + eq_token: input.parse()?, + ty: input.parse()?, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ItemExistential { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ItemExistential { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + existential_token: input.parse()?, + type_token: input.parse()?, + ident: input.parse()?, + generics: { + let mut generics: Generics = input.parse()?; + generics.where_clause = input.parse()?; + generics + }, + colon_token: Some(input.parse()?), + bounds: { + let mut bounds = Punctuated::new(); + while !input.peek(Token![;]) { + if !bounds.is_empty() { + bounds.push_punct(input.parse()?); + } + bounds.push_value(input.parse()?); + } + bounds + }, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ItemStruct { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let vis = input.parse::<Visibility>()?; + let struct_token = input.parse::<Token![struct]>()?; + let ident = input.parse::<Ident>()?; + let generics = input.parse::<Generics>()?; + let (where_clause, fields, semi_token) = derive::parsing::data_struct(input)?; + Ok(ItemStruct { + attrs: attrs, + vis: vis, + struct_token: struct_token, + ident: ident, + generics: Generics { + where_clause: where_clause, + ..generics + }, + fields: fields, + semi_token: semi_token, + }) + } + } + + impl Parse for ItemEnum { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let vis = input.parse::<Visibility>()?; + let enum_token = input.parse::<Token![enum]>()?; + let ident = input.parse::<Ident>()?; + let generics = input.parse::<Generics>()?; + let (where_clause, brace_token, variants) = derive::parsing::data_enum(input)?; + Ok(ItemEnum { + attrs: attrs, + vis: vis, + enum_token: enum_token, + ident: ident, + generics: Generics { + where_clause: where_clause, + ..generics + }, + brace_token: brace_token, + variants: variants, + }) + } + } + + impl Parse for ItemUnion { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let vis = input.parse::<Visibility>()?; + let union_token = input.parse::<Token![union]>()?; + let ident = input.parse::<Ident>()?; + let generics = input.parse::<Generics>()?; + let (where_clause, fields) = derive::parsing::data_union(input)?; + Ok(ItemUnion { + attrs: attrs, + vis: vis, + union_token: union_token, + ident: ident, + generics: Generics { + where_clause: where_clause, + ..generics + }, + fields: fields, + }) + } + } + + fn parse_trait_or_trait_alias(input: ParseStream) -> Result<Item> { + let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?; + let lookahead = input.lookahead1(); + if lookahead.peek(token::Brace) + || lookahead.peek(Token![:]) + || lookahead.peek(Token![where]) + { + let unsafety = None; + let auto_token = None; + parse_rest_of_trait( + input, + attrs, + vis, + unsafety, + auto_token, + trait_token, + ident, + generics, + ) + .map(Item::Trait) + } else if lookahead.peek(Token![=]) { + parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics) + .map(Item::TraitAlias) + } else { + Err(lookahead.error()) + } + } + + impl Parse for ItemTrait { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let vis: Visibility = input.parse()?; + let unsafety: Option<Token![unsafe]> = input.parse()?; + let auto_token: Option<Token![auto]> = input.parse()?; + let trait_token: Token![trait] = input.parse()?; + let ident: Ident = input.parse()?; + let generics: Generics = input.parse()?; + parse_rest_of_trait( + input, + attrs, + vis, + unsafety, + auto_token, + trait_token, + ident, + generics, + ) + } + } + + fn parse_rest_of_trait( + input: ParseStream, + attrs: Vec<Attribute>, + vis: Visibility, + unsafety: Option<Token![unsafe]>, + auto_token: Option<Token![auto]>, + trait_token: Token![trait], + ident: Ident, + mut generics: Generics, + ) -> Result<ItemTrait> { + let colon_token: Option<Token![:]> = input.parse()?; + + let mut supertraits = Punctuated::new(); + if colon_token.is_some() { + loop { + supertraits.push_value(input.parse()?); + if input.peek(Token![where]) || input.peek(token::Brace) { + break; + } + supertraits.push_punct(input.parse()?); + if input.peek(Token![where]) || input.peek(token::Brace) { + break; + } + } + } + + generics.where_clause = input.parse()?; + + let content; + let brace_token = braced!(content in input); + let mut items = Vec::new(); + while !content.is_empty() { + items.push(content.parse()?); + } + + Ok(ItemTrait { + attrs: attrs, + vis: vis, + unsafety: unsafety, + auto_token: auto_token, + trait_token: trait_token, + ident: ident, + generics: generics, + colon_token: colon_token, + supertraits: supertraits, + brace_token: brace_token, + items: items, + }) + } + + impl Parse for ItemTraitAlias { + fn parse(input: ParseStream) -> Result<Self> { + let (attrs, vis, trait_token, ident, generics) = parse_start_of_trait_alias(input)?; + parse_rest_of_trait_alias(input, attrs, vis, trait_token, ident, generics) + } + } + + fn parse_start_of_trait_alias( + input: ParseStream, + ) -> Result<(Vec<Attribute>, Visibility, Token![trait], Ident, Generics)> { + let attrs = input.call(Attribute::parse_outer)?; + let vis: Visibility = input.parse()?; + let trait_token: Token![trait] = input.parse()?; + let ident: Ident = input.parse()?; + let generics: Generics = input.parse()?; + Ok((attrs, vis, trait_token, ident, generics)) + } + + fn parse_rest_of_trait_alias( + input: ParseStream, + attrs: Vec<Attribute>, + vis: Visibility, + trait_token: Token![trait], + ident: Ident, + mut generics: Generics, + ) -> Result<ItemTraitAlias> { + let eq_token: Token![=] = input.parse()?; + + let mut bounds = Punctuated::new(); + loop { + if input.peek(Token![where]) || input.peek(Token![;]) { + break; + } + bounds.push_value(input.parse()?); + if input.peek(Token![where]) || input.peek(Token![;]) { + break; + } + bounds.push_punct(input.parse()?); + } + + generics.where_clause = input.parse()?; + let semi_token: Token![;] = input.parse()?; + + Ok(ItemTraitAlias { + attrs: attrs, + vis: vis, + trait_token: trait_token, + ident: ident, + generics: generics, + eq_token: eq_token, + bounds: bounds, + semi_token: semi_token, + }) + } + + impl Parse for TraitItem { + fn parse(input: ParseStream) -> Result<Self> { + let mut attrs = input.call(Attribute::parse_outer)?; + let ahead = input.fork(); + + let lookahead = ahead.lookahead1(); + let mut item = if lookahead.peek(Token![const]) { + ahead.parse::<Token![const]>()?; + let lookahead = ahead.lookahead1(); + if lookahead.peek(Ident) { + input.parse().map(TraitItem::Const) + } else if lookahead.peek(Token![async]) + || lookahead.peek(Token![unsafe]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![fn]) + { + input.parse().map(TraitItem::Method) + } else { + Err(lookahead.error()) + } + } else if lookahead.peek(Token![async]) + || lookahead.peek(Token![unsafe]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![fn]) + { + input.parse().map(TraitItem::Method) + } else if lookahead.peek(Token![type]) { + input.parse().map(TraitItem::Type) + } else if lookahead.peek(Ident) + || lookahead.peek(Token![self]) + || lookahead.peek(Token![super]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![crate]) + || lookahead.peek(Token![::]) + { + input.parse().map(TraitItem::Macro) + } else { + Err(lookahead.error()) + }?; + + { + let item_attrs = match item { + TraitItem::Const(ref mut item) => &mut item.attrs, + TraitItem::Method(ref mut item) => &mut item.attrs, + TraitItem::Type(ref mut item) => &mut item.attrs, + TraitItem::Macro(ref mut item) => &mut item.attrs, + TraitItem::Verbatim(_) => unreachable!(), + }; + attrs.extend(item_attrs.drain(..)); + *item_attrs = attrs; + } + + Ok(item) + } + } + + impl Parse for TraitItemConst { + fn parse(input: ParseStream) -> Result<Self> { + Ok(TraitItemConst { + attrs: input.call(Attribute::parse_outer)?, + const_token: input.parse()?, + ident: input.parse()?, + colon_token: input.parse()?, + ty: input.parse()?, + default: { + if input.peek(Token![=]) { + let eq_token: Token![=] = input.parse()?; + let default: Expr = input.parse()?; + Some((eq_token, default)) + } else { + None + } + }, + semi_token: input.parse()?, + }) + } + } + + impl Parse for TraitItemMethod { + fn parse(input: ParseStream) -> Result<Self> { + let outer_attrs = input.call(Attribute::parse_outer)?; + let constness: Option<Token![const]> = input.parse()?; + let asyncness: Option<Token![async]> = input.parse()?; + let unsafety: Option<Token![unsafe]> = input.parse()?; + let abi: Option<Abi> = input.parse()?; + let fn_token: Token![fn] = input.parse()?; + let ident: Ident = input.parse()?; + let generics: Generics = input.parse()?; + + let content; + let paren_token = parenthesized!(content in input); + let inputs = content.parse_terminated(FnArg::parse)?; + + let output: ReturnType = input.parse()?; + let where_clause: Option<WhereClause> = input.parse()?; + + let lookahead = input.lookahead1(); + let (brace_token, inner_attrs, stmts, semi_token) = if lookahead.peek(token::Brace) { + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let stmts = content.call(Block::parse_within)?; + (Some(brace_token), inner_attrs, stmts, None) + } else if lookahead.peek(Token![;]) { + let semi_token: Token![;] = input.parse()?; + (None, Vec::new(), Vec::new(), Some(semi_token)) + } else { + return Err(lookahead.error()); + }; + + Ok(TraitItemMethod { + attrs: private::attrs(outer_attrs, inner_attrs), + sig: MethodSig { + constness: constness, + asyncness: asyncness, + unsafety: unsafety, + abi: abi, + ident: ident, + decl: FnDecl { + fn_token: fn_token, + paren_token: paren_token, + inputs: inputs, + output: output, + variadic: None, + generics: Generics { + where_clause: where_clause, + ..generics + }, + }, + }, + default: brace_token.map(|brace_token| Block { + brace_token: brace_token, + stmts: stmts, + }), + semi_token: semi_token, + }) + } + } + + impl Parse for TraitItemType { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let type_token: Token![type] = input.parse()?; + let ident: Ident = input.parse()?; + let mut generics: Generics = input.parse()?; + let colon_token: Option<Token![:]> = input.parse()?; + + let mut bounds = Punctuated::new(); + if colon_token.is_some() { + while !input.peek(Token![where]) && !input.peek(Token![=]) && !input.peek(Token![;]) + { + if !bounds.is_empty() { + bounds.push_punct(input.parse()?); + } + bounds.push_value(input.parse()?); + } + } + + generics.where_clause = input.parse()?; + let default = if input.peek(Token![=]) { + let eq_token: Token![=] = input.parse()?; + let default: Type = input.parse()?; + Some((eq_token, default)) + } else { + None + }; + let semi_token: Token![;] = input.parse()?; + + Ok(TraitItemType { + attrs: attrs, + type_token: type_token, + ident: ident, + generics: generics, + colon_token: colon_token, + bounds: bounds, + default: default, + semi_token: semi_token, + }) + } + } + + impl Parse for TraitItemMacro { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let mac: Macro = input.parse()?; + let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { + None + } else { + Some(input.parse()?) + }; + Ok(TraitItemMacro { + attrs: attrs, + mac: mac, + semi_token: semi_token, + }) + } + } + + impl Parse for ItemImpl { + fn parse(input: ParseStream) -> Result<Self> { + let outer_attrs = input.call(Attribute::parse_outer)?; + let defaultness: Option<Token![default]> = input.parse()?; + let unsafety: Option<Token![unsafe]> = input.parse()?; + let impl_token: Token![impl] = input.parse()?; + + let has_generics = input.peek(Token![<]) + && (input.peek2(Token![>]) + || input.peek2(Token![#]) + || (input.peek2(Ident) || input.peek2(Lifetime)) + && (input.peek3(Token![:]) + || input.peek3(Token![,]) + || input.peek3(Token![>]))); + let generics: Generics = if has_generics { + input.parse()? + } else { + Generics::default() + }; + + let trait_ = { + // TODO: optimize using advance_to + let ahead = input.fork(); + if ahead.parse::<Option<Token![!]>>().is_ok() + && ahead.parse::<Path>().is_ok() + && ahead.parse::<Token![for]>().is_ok() + { + let polarity: Option<Token![!]> = input.parse()?; + let path: Path = input.parse()?; + let for_token: Token![for] = input.parse()?; + Some((polarity, path, for_token)) + } else { + None + } + }; + let self_ty: Type = input.parse()?; + let where_clause: Option<WhereClause> = input.parse()?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + + let mut items = Vec::new(); + while !content.is_empty() { + items.push(content.parse()?); + } + + Ok(ItemImpl { + attrs: private::attrs(outer_attrs, inner_attrs), + defaultness: defaultness, + unsafety: unsafety, + impl_token: impl_token, + generics: Generics { + where_clause: where_clause, + ..generics + }, + trait_: trait_, + self_ty: Box::new(self_ty), + brace_token: brace_token, + items: items, + }) + } + } + + impl Parse for ImplItem { + fn parse(input: ParseStream) -> Result<Self> { + let mut attrs = input.call(Attribute::parse_outer)?; + let ahead = input.fork(); + let vis: Visibility = ahead.parse()?; + + let mut lookahead = ahead.lookahead1(); + let defaultness = if lookahead.peek(Token![default]) && !ahead.peek2(Token![!]) { + let defaultness: Token![default] = ahead.parse()?; + lookahead = ahead.lookahead1(); + Some(defaultness) + } else { + None + }; + + let mut item = if lookahead.peek(Token![const]) { + ahead.parse::<Token![const]>()?; + let lookahead = ahead.lookahead1(); + if lookahead.peek(Ident) { + input.parse().map(ImplItem::Const) + } else if lookahead.peek(Token![unsafe]) + || lookahead.peek(Token![async]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![fn]) + { + input.parse().map(ImplItem::Method) + } else { + Err(lookahead.error()) + } + } else if lookahead.peek(Token![unsafe]) + || lookahead.peek(Token![async]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![fn]) + { + input.parse().map(ImplItem::Method) + } else if lookahead.peek(Token![type]) { + input.parse().map(ImplItem::Type) + } else if vis.is_inherited() + && defaultness.is_none() + && lookahead.peek(Token![existential]) + { + input.parse().map(ImplItem::Existential) + } else if vis.is_inherited() + && defaultness.is_none() + && (lookahead.peek(Ident) + || lookahead.peek(Token![self]) + || lookahead.peek(Token![super]) + || lookahead.peek(Token![extern]) + || lookahead.peek(Token![crate]) + || lookahead.peek(Token![::])) + { + input.parse().map(ImplItem::Macro) + } else { + Err(lookahead.error()) + }?; + + { + let item_attrs = match item { + ImplItem::Const(ref mut item) => &mut item.attrs, + ImplItem::Method(ref mut item) => &mut item.attrs, + ImplItem::Type(ref mut item) => &mut item.attrs, + ImplItem::Existential(ref mut item) => &mut item.attrs, + ImplItem::Macro(ref mut item) => &mut item.attrs, + ImplItem::Verbatim(_) => unreachable!(), + }; + attrs.extend(item_attrs.drain(..)); + *item_attrs = attrs; + } + + Ok(item) + } + } + + impl Parse for ImplItemConst { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ImplItemConst { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + defaultness: input.parse()?, + const_token: input.parse()?, + ident: input.parse()?, + colon_token: input.parse()?, + ty: input.parse()?, + eq_token: input.parse()?, + expr: input.parse()?, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ImplItemMethod { + fn parse(input: ParseStream) -> Result<Self> { + let outer_attrs = input.call(Attribute::parse_outer)?; + let vis: Visibility = input.parse()?; + let defaultness: Option<Token![default]> = input.parse()?; + let constness: Option<Token![const]> = input.parse()?; + let asyncness: Option<Token![async]> = input.parse()?; + let unsafety: Option<Token![unsafe]> = input.parse()?; + let abi: Option<Abi> = input.parse()?; + let fn_token: Token![fn] = input.parse()?; + let ident: Ident = input.parse()?; + let generics: Generics = input.parse()?; + + let content; + let paren_token = parenthesized!(content in input); + let inputs = content.parse_terminated(FnArg::parse)?; + + let output: ReturnType = input.parse()?; + let where_clause: Option<WhereClause> = input.parse()?; + + let content; + let brace_token = braced!(content in input); + let inner_attrs = content.call(Attribute::parse_inner)?; + let stmts = content.call(Block::parse_within)?; + + Ok(ImplItemMethod { + attrs: private::attrs(outer_attrs, inner_attrs), + vis: vis, + defaultness: defaultness, + sig: MethodSig { + constness: constness, + asyncness: asyncness, + unsafety: unsafety, + abi: abi, + ident: ident, + decl: FnDecl { + fn_token: fn_token, + paren_token: paren_token, + inputs: inputs, + output: output, + variadic: None, + generics: Generics { + where_clause: where_clause, + ..generics + }, + }, + }, + block: Block { + brace_token: brace_token, + stmts: stmts, + }, + }) + } + } + + impl Parse for ImplItemType { + fn parse(input: ParseStream) -> Result<Self> { + Ok(ImplItemType { + attrs: input.call(Attribute::parse_outer)?, + vis: input.parse()?, + defaultness: input.parse()?, + type_token: input.parse()?, + ident: input.parse()?, + generics: { + let mut generics: Generics = input.parse()?; + generics.where_clause = input.parse()?; + generics + }, + eq_token: input.parse()?, + ty: input.parse()?, + semi_token: input.parse()?, + }) + } + } + + impl Parse for ImplItemExistential { + fn parse(input: ParseStream) -> Result<Self> { + let ety: ItemExistential = input.parse()?; + Ok(ImplItemExistential { + attrs: ety.attrs, + existential_token: ety.existential_token, + type_token: ety.type_token, + ident: ety.ident, + generics: ety.generics, + colon_token: ety.colon_token, + bounds: ety.bounds, + semi_token: ety.semi_token, + }) + } + } + + impl Parse for ImplItemMacro { + fn parse(input: ParseStream) -> Result<Self> { + let attrs = input.call(Attribute::parse_outer)?; + let mac: Macro = input.parse()?; + let semi_token: Option<Token![;]> = if mac.delimiter.is_brace() { + None + } else { + Some(input.parse()?) + }; + Ok(ImplItemMacro { + attrs: attrs, + mac: mac, + semi_token: semi_token, + }) + } + } + + impl Visibility { + fn is_inherited(&self) -> bool { + match *self { + Visibility::Inherited => true, + _ => false, + } + } + } + + impl MacroDelimiter { + fn is_brace(&self) -> bool { + match *self { + MacroDelimiter::Brace(_) => true, + MacroDelimiter::Paren(_) | MacroDelimiter::Bracket(_) => false, + } + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + + use proc_macro2::TokenStream; + use quote::{ToTokens, TokenStreamExt}; + + use attr::FilterAttrs; + use print::TokensOrDefault; + + impl ToTokens for ItemExternCrate { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.extern_token.to_tokens(tokens); + self.crate_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + if let Some((ref as_token, ref rename)) = self.rename { + as_token.to_tokens(tokens); + rename.to_tokens(tokens); + } + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ItemUse { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.use_token.to_tokens(tokens); + self.leading_colon.to_tokens(tokens); + self.tree.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ItemStatic { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.static_token.to_tokens(tokens); + self.mutability.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.expr.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ItemConst { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.const_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.expr.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ItemFn { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.constness.to_tokens(tokens); + self.asyncness.to_tokens(tokens); + self.unsafety.to_tokens(tokens); + self.abi.to_tokens(tokens); + NamedDecl(&self.decl, &self.ident).to_tokens(tokens); + self.block.brace_token.surround(tokens, |tokens| { + tokens.append_all(self.attrs.inner()); + tokens.append_all(&self.block.stmts); + }); + } + } + + impl ToTokens for ItemMod { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.mod_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + if let Some((ref brace, ref items)) = self.content { + brace.surround(tokens, |tokens| { + tokens.append_all(self.attrs.inner()); + tokens.append_all(items); + }); + } else { + TokensOrDefault(&self.semi).to_tokens(tokens); + } + } + } + + impl ToTokens for ItemForeignMod { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.abi.to_tokens(tokens); + self.brace_token.surround(tokens, |tokens| { + tokens.append_all(self.attrs.inner()); + tokens.append_all(&self.items); + }); + } + } + + impl ToTokens for ItemType { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.type_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ItemExistential { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.existential_token.to_tokens(tokens); + self.type_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + if !self.bounds.is_empty() { + TokensOrDefault(&self.colon_token).to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ItemEnum { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.enum_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + self.brace_token.surround(tokens, |tokens| { + self.variants.to_tokens(tokens); + }); + } + } + + impl ToTokens for ItemStruct { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.struct_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + match self.fields { + Fields::Named(ref fields) => { + self.generics.where_clause.to_tokens(tokens); + fields.to_tokens(tokens); + } + Fields::Unnamed(ref fields) => { + fields.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + TokensOrDefault(&self.semi_token).to_tokens(tokens); + } + Fields::Unit => { + self.generics.where_clause.to_tokens(tokens); + TokensOrDefault(&self.semi_token).to_tokens(tokens); + } + } + } + } + + impl ToTokens for ItemUnion { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.union_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + self.fields.to_tokens(tokens); + } + } + + impl ToTokens for ItemTrait { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.unsafety.to_tokens(tokens); + self.auto_token.to_tokens(tokens); + self.trait_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + if !self.supertraits.is_empty() { + TokensOrDefault(&self.colon_token).to_tokens(tokens); + self.supertraits.to_tokens(tokens); + } + self.generics.where_clause.to_tokens(tokens); + self.brace_token.surround(tokens, |tokens| { + tokens.append_all(&self.items); + }); + } + } + + impl ToTokens for ItemTraitAlias { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.trait_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.bounds.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ItemImpl { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.defaultness.to_tokens(tokens); + self.unsafety.to_tokens(tokens); + self.impl_token.to_tokens(tokens); + self.generics.to_tokens(tokens); + if let Some((ref polarity, ref path, ref for_token)) = self.trait_ { + polarity.to_tokens(tokens); + path.to_tokens(tokens); + for_token.to_tokens(tokens); + } + self.self_ty.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + self.brace_token.surround(tokens, |tokens| { + tokens.append_all(self.attrs.inner()); + tokens.append_all(&self.items); + }); + } + } + + impl ToTokens for ItemMacro { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.mac.path.to_tokens(tokens); + self.mac.bang_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + match self.mac.delimiter { + MacroDelimiter::Paren(ref paren) => { + paren.surround(tokens, |tokens| self.mac.tts.to_tokens(tokens)); + } + MacroDelimiter::Brace(ref brace) => { + brace.surround(tokens, |tokens| self.mac.tts.to_tokens(tokens)); + } + MacroDelimiter::Bracket(ref bracket) => { + bracket.surround(tokens, |tokens| self.mac.tts.to_tokens(tokens)); + } + } + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ItemMacro2 { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.macro_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + + // Hack: see comment in impl Parse for ItemMacro2. + if self.args.to_string() != "$ $" { + self.paren_token.surround(tokens, |tokens| { + self.args.to_tokens(tokens); + }); + } + + self.brace_token.surround(tokens, |tokens| { + self.body.to_tokens(tokens); + }); + } + } + + impl ToTokens for ItemVerbatim { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.tts.to_tokens(tokens); + } + } + + impl ToTokens for UsePath { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.ident.to_tokens(tokens); + self.colon2_token.to_tokens(tokens); + self.tree.to_tokens(tokens); + } + } + + impl ToTokens for UseName { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.ident.to_tokens(tokens); + } + } + + impl ToTokens for UseRename { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.ident.to_tokens(tokens); + self.as_token.to_tokens(tokens); + self.rename.to_tokens(tokens); + } + } + + impl ToTokens for UseGlob { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.star_token.to_tokens(tokens); + } + } + + impl ToTokens for UseGroup { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.brace_token.surround(tokens, |tokens| { + self.items.to_tokens(tokens); + }); + } + } + + impl ToTokens for TraitItemConst { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.const_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + if let Some((ref eq_token, ref default)) = self.default { + eq_token.to_tokens(tokens); + default.to_tokens(tokens); + } + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for TraitItemMethod { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.sig.to_tokens(tokens); + match self.default { + Some(ref block) => { + block.brace_token.surround(tokens, |tokens| { + tokens.append_all(self.attrs.inner()); + tokens.append_all(&block.stmts); + }); + } + None => { + TokensOrDefault(&self.semi_token).to_tokens(tokens); + } + } + } + } + + impl ToTokens for TraitItemType { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.type_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + if !self.bounds.is_empty() { + TokensOrDefault(&self.colon_token).to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + self.generics.where_clause.to_tokens(tokens); + if let Some((ref eq_token, ref default)) = self.default { + eq_token.to_tokens(tokens); + default.to_tokens(tokens); + } + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for TraitItemMacro { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.mac.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for TraitItemVerbatim { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.tts.to_tokens(tokens); + } + } + + impl ToTokens for ImplItemConst { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.defaultness.to_tokens(tokens); + self.const_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.expr.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ImplItemMethod { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.defaultness.to_tokens(tokens); + self.sig.to_tokens(tokens); + self.block.brace_token.surround(tokens, |tokens| { + tokens.append_all(self.attrs.inner()); + tokens.append_all(&self.block.stmts); + }); + } + } + + impl ToTokens for ImplItemType { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.defaultness.to_tokens(tokens); + self.type_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ImplItemExistential { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.existential_token.to_tokens(tokens); + self.type_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.generics.to_tokens(tokens); + self.generics.where_clause.to_tokens(tokens); + if !self.bounds.is_empty() { + TokensOrDefault(&self.colon_token).to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ImplItemMacro { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.mac.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ImplItemVerbatim { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.tts.to_tokens(tokens); + } + } + + impl ToTokens for ForeignItemFn { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + NamedDecl(&self.decl, &self.ident).to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ForeignItemStatic { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.static_token.to_tokens(tokens); + self.mutability.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ForeignItemType { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.vis.to_tokens(tokens); + self.type_token.to_tokens(tokens); + self.ident.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ForeignItemMacro { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.attrs.outer()); + self.mac.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + } + } + + impl ToTokens for ForeignItemVerbatim { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.tts.to_tokens(tokens); + } + } + + impl ToTokens for MethodSig { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.constness.to_tokens(tokens); + self.asyncness.to_tokens(tokens); + self.unsafety.to_tokens(tokens); + self.abi.to_tokens(tokens); + NamedDecl(&self.decl, &self.ident).to_tokens(tokens); + } + } + + struct NamedDecl<'a>(&'a FnDecl, &'a Ident); + + impl<'a> ToTokens for NamedDecl<'a> { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.0.fn_token.to_tokens(tokens); + self.1.to_tokens(tokens); + self.0.generics.to_tokens(tokens); + self.0.paren_token.surround(tokens, |tokens| { + self.0.inputs.to_tokens(tokens); + if self.0.variadic.is_some() && !self.0.inputs.empty_or_trailing() { + <Token![,]>::default().to_tokens(tokens); + } + self.0.variadic.to_tokens(tokens); + }); + self.0.output.to_tokens(tokens); + self.0.generics.where_clause.to_tokens(tokens); + } + } + + impl ToTokens for ArgSelfRef { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.and_token.to_tokens(tokens); + self.lifetime.to_tokens(tokens); + self.mutability.to_tokens(tokens); + self.self_token.to_tokens(tokens); + } + } + + impl ToTokens for ArgSelf { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.mutability.to_tokens(tokens); + self.self_token.to_tokens(tokens); + } + } + + impl ToTokens for ArgCaptured { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.pat.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/keyword.rs b/rust/vendor/syn-0.15.44/src/keyword.rs new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/keyword.rs diff --git a/rust/vendor/syn-0.15.44/src/lib.rs b/rust/vendor/syn-0.15.44/src/lib.rs new file mode 100644 index 0000000..2c792b2 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/lib.rs @@ -0,0 +1,740 @@ +//! Syn is a parsing library for parsing a stream of Rust tokens into a syntax +//! tree of Rust source code. +//! +//! Currently this library is geared toward use in Rust procedural macros, but +//! contains some APIs that may be useful more generally. +//! +//! - **Data structures** — Syn provides a complete syntax tree that can +//! represent any valid Rust source code. The syntax tree is rooted at +//! [`syn::File`] which represents a full source file, but there are other +//! entry points that may be useful to procedural macros including +//! [`syn::Item`], [`syn::Expr`] and [`syn::Type`]. +//! +//! - **Custom derives** — Of particular interest to custom derives is +//! [`syn::DeriveInput`] which is any of the three legal input items to a +//! derive macro. An example below shows using this type in a library that can +//! derive implementations of a trait of your own. +//! +//! - **Parsing** — Parsing in Syn is built around [parser functions] with the +//! signature `fn(ParseStream) -> Result<T>`. Every syntax tree node defined +//! by Syn is individually parsable and may be used as a building block for +//! custom syntaxes, or you may dream up your own brand new syntax without +//! involving any of our syntax tree types. +//! +//! - **Location information** — Every token parsed by Syn is associated with a +//! `Span` that tracks line and column information back to the source of that +//! token. These spans allow a procedural macro to display detailed error +//! messages pointing to all the right places in the user's code. There is an +//! example of this below. +//! +//! - **Feature flags** — Functionality is aggressively feature gated so your +//! procedural macros enable only what they need, and do not pay in compile +//! time for all the rest. +//! +//! [`syn::File`]: struct.File.html +//! [`syn::Item`]: enum.Item.html +//! [`syn::Expr`]: enum.Expr.html +//! [`syn::Type`]: enum.Type.html +//! [`syn::DeriveInput`]: struct.DeriveInput.html +//! [parser functions]: parse/index.html +//! +//! *Version requirement: Syn supports any compiler version back to Rust's very +//! first support for procedural macros in Rust 1.15.0. Some features especially +//! around error reporting are only available in newer compilers or on the +//! nightly channel.* +//! +//! ## Example of a custom derive +//! +//! The canonical custom derive using Syn looks like this. We write an ordinary +//! Rust function tagged with a `proc_macro_derive` attribute and the name of +//! the trait we are deriving. Any time that derive appears in the user's code, +//! the Rust compiler passes their data structure as tokens into our macro. We +//! get to execute arbitrary Rust code to figure out what to do with those +//! tokens, then hand some tokens back to the compiler to compile into the +//! user's crate. +//! +//! [`TokenStream`]: https://doc.rust-lang.org/proc_macro/struct.TokenStream.html +//! +//! ```toml +//! [dependencies] +//! syn = "0.15" +//! quote = "0.6" +//! +//! [lib] +//! proc-macro = true +//! ``` +//! +//! ```edition2018 +//! extern crate proc_macro; +//! +//! use proc_macro::TokenStream; +//! use quote::quote; +//! use syn::{parse_macro_input, DeriveInput}; +//! +//! # const IGNORE_TOKENS: &str = stringify! { +//! #[proc_macro_derive(MyMacro)] +//! # }; +//! pub fn my_macro(input: TokenStream) -> TokenStream { +//! // Parse the input tokens into a syntax tree +//! let input = parse_macro_input!(input as DeriveInput); +//! +//! // Build the output, possibly using quasi-quotation +//! let expanded = quote! { +//! // ... +//! }; +//! +//! // Hand the output tokens back to the compiler +//! TokenStream::from(expanded) +//! } +//! ``` +//! +//! The [`heapsize`] example directory shows a complete working Macros 1.1 +//! implementation of a custom derive. It works on any Rust compiler 1.15+. +//! The example derives a `HeapSize` trait which computes an estimate of the +//! amount of heap memory owned by a value. +//! +//! [`heapsize`]: https://github.com/dtolnay/syn/tree/master/examples/heapsize +//! +//! ```edition2018 +//! pub trait HeapSize { +//! /// Total number of bytes of heap memory owned by `self`. +//! fn heap_size_of_children(&self) -> usize; +//! } +//! ``` +//! +//! The custom derive allows users to write `#[derive(HeapSize)]` on data +//! structures in their program. +//! +//! ```edition2018 +//! # const IGNORE_TOKENS: &str = stringify! { +//! #[derive(HeapSize)] +//! # }; +//! struct Demo<'a, T: ?Sized> { +//! a: Box<T>, +//! b: u8, +//! c: &'a str, +//! d: String, +//! } +//! ``` +//! +//! ## Spans and error reporting +//! +//! The token-based procedural macro API provides great control over where the +//! compiler's error messages are displayed in user code. Consider the error the +//! user sees if one of their field types does not implement `HeapSize`. +//! +//! ```edition2018 +//! # const IGNORE_TOKENS: &str = stringify! { +//! #[derive(HeapSize)] +//! # }; +//! struct Broken { +//! ok: String, +//! bad: std::thread::Thread, +//! } +//! ``` +//! +//! By tracking span information all the way through the expansion of a +//! procedural macro as shown in the `heapsize` example, token-based macros in +//! Syn are able to trigger errors that directly pinpoint the source of the +//! problem. +//! +//! ```text +//! error[E0277]: the trait bound `std::thread::Thread: HeapSize` is not satisfied +//! --> src/main.rs:7:5 +//! | +//! 7 | bad: std::thread::Thread, +//! | ^^^^^^^^^^^^^^^^^^^^^^^^ the trait `HeapSize` is not implemented for `Thread` +//! ``` +//! +//! ## Parsing a custom syntax +//! +//! The [`lazy-static`] example directory shows the implementation of a +//! `functionlike!(...)` procedural macro in which the input tokens are parsed +//! using Syn's parsing API. +//! +//! [`lazy-static`]: https://github.com/dtolnay/syn/tree/master/examples/lazy-static +//! +//! The example reimplements the popular `lazy_static` crate from crates.io as a +//! procedural macro. +//! +//! ```edition2018 +//! # macro_rules! lazy_static { +//! # ($($tt:tt)*) => {} +//! # } +//! # +//! lazy_static! { +//! static ref USERNAME: Regex = Regex::new("^[a-z0-9_-]{3,16}$").unwrap(); +//! } +//! ``` +//! +//! The implementation shows how to trigger custom warnings and error messages +//! on the macro input. +//! +//! ```text +//! warning: come on, pick a more creative name +//! --> src/main.rs:10:16 +//! | +//! 10 | static ref FOO: String = "lazy_static".to_owned(); +//! | ^^^ +//! ``` +//! +//! ## Testing +//! +//! When testing macros, we often care not just that the macro can be used +//! successfully but also that when the macro is provided with invalid input it +//! produces maximally helpful error messages. Consider using the [`trybuild`] +//! crate to write tests for errors that are emitted by your macro or errors +//! detected by the Rust compiler in the expanded code following misuse of the +//! macro. Such tests help avoid regressions from later refactors that +//! mistakenly make an error no longer trigger or be less helpful than it used +//! to be. +//! +//! [`trybuild`]: https://github.com/dtolnay/trybuild +//! +//! ## Debugging +//! +//! When developing a procedural macro it can be helpful to look at what the +//! generated code looks like. Use `cargo rustc -- -Zunstable-options +//! --pretty=expanded` or the [`cargo expand`] subcommand. +//! +//! [`cargo expand`]: https://github.com/dtolnay/cargo-expand +//! +//! To show the expanded code for some crate that uses your procedural macro, +//! run `cargo expand` from that crate. To show the expanded code for one of +//! your own test cases, run `cargo expand --test the_test_case` where the last +//! argument is the name of the test file without the `.rs` extension. +//! +//! This write-up by Brandon W Maister discusses debugging in more detail: +//! [Debugging Rust's new Custom Derive system][debugging]. +//! +//! [debugging]: https://quodlibetor.github.io/posts/debugging-rusts-new-custom-derive-system/ +//! +//! ## Optional features +//! +//! Syn puts a lot of functionality behind optional features in order to +//! optimize compile time for the most common use cases. The following features +//! are available. +//! +//! - **`derive`** *(enabled by default)* — Data structures for representing the +//! possible input to a custom derive, including structs and enums and types. +//! - **`full`** — Data structures for representing the syntax tree of all valid +//! Rust source code, including items and expressions. +//! - **`parsing`** *(enabled by default)* — Ability to parse input tokens into +//! a syntax tree node of a chosen type. +//! - **`printing`** *(enabled by default)* — Ability to print a syntax tree +//! node as tokens of Rust source code. +//! - **`visit`** — Trait for traversing a syntax tree. +//! - **`visit-mut`** — Trait for traversing and mutating in place a syntax +//! tree. +//! - **`fold`** — Trait for transforming an owned syntax tree. +//! - **`clone-impls`** *(enabled by default)* — Clone impls for all syntax tree +//! types. +//! - **`extra-traits`** — Debug, Eq, PartialEq, Hash impls for all syntax tree +//! types. +//! - **`proc-macro`** *(enabled by default)* — Runtime dependency on the +//! dynamic library libproc_macro from rustc toolchain. + +// Syn types in rustdoc of other crates get linked to here. +#![doc(html_root_url = "https://docs.rs/syn/0.15.44")] +#![allow(unknown_lints, bare_trait_objects, ellipsis_inclusive_range_patterns)] +#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))] +#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))] +// Ignored clippy lints. +#![cfg_attr( + feature = "cargo-clippy", + allow( + block_in_if_condition_stmt, + cognitive_complexity, + deprecated_cfg_attr, + doc_markdown, + eval_order_dependence, + large_enum_variant, + needless_pass_by_value, + never_loop, + redundant_field_names, + redundant_static_lifetimes, + too_many_arguments, + ) +)] +// Ignored clippy_pedantic lints. +#![cfg_attr( + feature = "cargo-clippy", + allow( + cast_possible_truncation, + cast_possible_wrap, + empty_enum, + if_not_else, + items_after_statements, + module_name_repetitions, + shadow_unrelated, + similar_names, + single_match_else, + unseparated_literal_suffix, + use_self, + used_underscore_binding, + ) +)] + +#[cfg(all( + not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))), + feature = "proc-macro" +))] +extern crate proc_macro; +extern crate proc_macro2; +extern crate unicode_xid; + +#[cfg(feature = "printing")] +extern crate quote; + +#[macro_use] +mod macros; + +// Not public API. +#[cfg(feature = "parsing")] +#[doc(hidden)] +#[macro_use] +pub mod group; + +#[macro_use] +pub mod token; + +mod ident; +pub use ident::Ident; + +#[cfg(any(feature = "full", feature = "derive"))] +mod attr; +#[cfg(any(feature = "full", feature = "derive"))] +pub use attr::{AttrStyle, Attribute, AttributeArgs, Meta, MetaList, MetaNameValue, NestedMeta}; + +#[cfg(any(feature = "full", feature = "derive"))] +mod data; +#[cfg(any(feature = "full", feature = "derive"))] +pub use data::{ + Field, Fields, FieldsNamed, FieldsUnnamed, Variant, VisCrate, VisPublic, VisRestricted, + Visibility, +}; + +#[cfg(any(feature = "full", feature = "derive"))] +mod expr; +#[cfg(any(feature = "full", feature = "derive"))] +pub use expr::{ + Expr, ExprArray, ExprAssign, ExprAssignOp, ExprAsync, ExprBinary, ExprBlock, ExprBox, + ExprBreak, ExprCall, ExprCast, ExprClosure, ExprContinue, ExprField, ExprForLoop, ExprGroup, + ExprIf, ExprInPlace, ExprIndex, ExprLet, ExprLit, ExprLoop, ExprMacro, ExprMatch, + ExprMethodCall, ExprParen, ExprPath, ExprRange, ExprReference, ExprRepeat, ExprReturn, + ExprStruct, ExprTry, ExprTryBlock, ExprTuple, ExprType, ExprUnary, ExprUnsafe, ExprVerbatim, + ExprWhile, ExprYield, Index, Member, +}; + +#[cfg(feature = "full")] +pub use expr::{ + Arm, Block, FieldPat, FieldValue, GenericMethodArgument, Label, Local, MethodTurbofish, Pat, + PatBox, PatIdent, PatLit, PatMacro, PatPath, PatRange, PatRef, PatSlice, PatStruct, PatTuple, + PatTupleStruct, PatVerbatim, PatWild, RangeLimits, Stmt, +}; + +#[cfg(any(feature = "full", feature = "derive"))] +mod generics; +#[cfg(any(feature = "full", feature = "derive"))] +pub use generics::{ + BoundLifetimes, ConstParam, GenericParam, Generics, LifetimeDef, PredicateEq, + PredicateLifetime, PredicateType, TraitBound, TraitBoundModifier, TypeParam, TypeParamBound, + WhereClause, WherePredicate, +}; +#[cfg(all(any(feature = "full", feature = "derive"), feature = "printing"))] +pub use generics::{ImplGenerics, Turbofish, TypeGenerics}; + +#[cfg(feature = "full")] +mod item; +#[cfg(feature = "full")] +pub use item::{ + ArgCaptured, ArgSelf, ArgSelfRef, FnArg, FnDecl, ForeignItem, ForeignItemFn, ForeignItemMacro, + ForeignItemStatic, ForeignItemType, ForeignItemVerbatim, ImplItem, ImplItemConst, + ImplItemExistential, ImplItemMacro, ImplItemMethod, ImplItemType, ImplItemVerbatim, Item, + ItemConst, ItemEnum, ItemExistential, ItemExternCrate, ItemFn, ItemForeignMod, ItemImpl, + ItemMacro, ItemMacro2, ItemMod, ItemStatic, ItemStruct, ItemTrait, ItemTraitAlias, ItemType, + ItemUnion, ItemUse, ItemVerbatim, MethodSig, TraitItem, TraitItemConst, TraitItemMacro, + TraitItemMethod, TraitItemType, TraitItemVerbatim, UseGlob, UseGroup, UseName, UsePath, + UseRename, UseTree, +}; + +#[cfg(feature = "full")] +mod file; +#[cfg(feature = "full")] +pub use file::File; + +mod lifetime; +pub use lifetime::Lifetime; + +#[cfg(any(feature = "full", feature = "derive"))] +mod lit; +#[cfg(any(feature = "full", feature = "derive"))] +pub use lit::{ + FloatSuffix, IntSuffix, Lit, LitBool, LitByte, LitByteStr, LitChar, LitFloat, LitInt, LitStr, + LitVerbatim, StrStyle, +}; + +#[cfg(any(feature = "full", feature = "derive"))] +mod mac; +#[cfg(any(feature = "full", feature = "derive"))] +pub use mac::{Macro, MacroDelimiter}; + +#[cfg(any(feature = "full", feature = "derive"))] +mod derive; +#[cfg(feature = "derive")] +pub use derive::{Data, DataEnum, DataStruct, DataUnion, DeriveInput}; + +#[cfg(any(feature = "full", feature = "derive"))] +mod op; +#[cfg(any(feature = "full", feature = "derive"))] +pub use op::{BinOp, UnOp}; + +#[cfg(any(feature = "full", feature = "derive"))] +mod ty; +#[cfg(any(feature = "full", feature = "derive"))] +pub use ty::{ + Abi, BareFnArg, BareFnArgName, ReturnType, Type, TypeArray, TypeBareFn, TypeGroup, + TypeImplTrait, TypeInfer, TypeMacro, TypeNever, TypeParen, TypePath, TypePtr, TypeReference, + TypeSlice, TypeTraitObject, TypeTuple, TypeVerbatim, +}; + +#[cfg(any(feature = "full", feature = "derive"))] +mod path; +#[cfg(any(feature = "full", feature = "derive"))] +pub use path::{ + AngleBracketedGenericArguments, Binding, Constraint, GenericArgument, + ParenthesizedGenericArguments, Path, PathArguments, PathSegment, QSelf, +}; + +#[cfg(feature = "parsing")] +pub mod buffer; +#[cfg(feature = "parsing")] +pub mod ext; +pub mod punctuated; +#[cfg(all(any(feature = "full", feature = "derive"), feature = "extra-traits"))] +mod tt; + +// Not public API except the `parse_quote!` macro. +#[cfg(feature = "parsing")] +#[doc(hidden)] +pub mod parse_quote; + +// Not public API except the `parse_macro_input!` macro. +#[cfg(all( + not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))), + feature = "parsing", + feature = "proc-macro" +))] +#[doc(hidden)] +pub mod parse_macro_input; + +#[cfg(all(feature = "parsing", feature = "printing"))] +pub mod spanned; + +mod gen { + /// Syntax tree traversal to walk a shared borrow of a syntax tree. + /// + /// Each method of the [`Visit`] trait is a hook that can be overridden to + /// customize the behavior when visiting the corresponding type of node. By + /// default, every method recursively visits the substructure of the input + /// by invoking the right visitor method of each of its fields. + /// + /// [`Visit`]: visit::Visit + /// + /// ```edition2018 + /// # use syn::{Attribute, BinOp, Expr, ExprBinary}; + /// # + /// pub trait Visit<'ast> { + /// /* ... */ + /// + /// fn visit_expr_binary(&mut self, node: &'ast ExprBinary) { + /// for attr in &node.attrs { + /// self.visit_attribute(attr); + /// } + /// self.visit_expr(&*node.left); + /// self.visit_bin_op(&node.op); + /// self.visit_expr(&*node.right); + /// } + /// + /// /* ... */ + /// # fn visit_attribute(&mut self, node: &'ast Attribute); + /// # fn visit_expr(&mut self, node: &'ast Expr); + /// # fn visit_bin_op(&mut self, node: &'ast BinOp); + /// } + /// ``` + /// + /// *This module is available if Syn is built with the `"visit"` feature.* + #[cfg(feature = "visit")] + pub mod visit; + + /// Syntax tree traversal to mutate an exclusive borrow of a syntax tree in + /// place. + /// + /// Each method of the [`VisitMut`] trait is a hook that can be overridden + /// to customize the behavior when mutating the corresponding type of node. + /// By default, every method recursively visits the substructure of the + /// input by invoking the right visitor method of each of its fields. + /// + /// [`VisitMut`]: visit_mut::VisitMut + /// + /// ```edition2018 + /// # use syn::{Attribute, BinOp, Expr, ExprBinary}; + /// # + /// pub trait VisitMut { + /// /* ... */ + /// + /// fn visit_expr_binary_mut(&mut self, node: &mut ExprBinary) { + /// for attr in &mut node.attrs { + /// self.visit_attribute_mut(attr); + /// } + /// self.visit_expr_mut(&mut *node.left); + /// self.visit_bin_op_mut(&mut node.op); + /// self.visit_expr_mut(&mut *node.right); + /// } + /// + /// /* ... */ + /// # fn visit_attribute_mut(&mut self, node: &mut Attribute); + /// # fn visit_expr_mut(&mut self, node: &mut Expr); + /// # fn visit_bin_op_mut(&mut self, node: &mut BinOp); + /// } + /// ``` + /// + /// *This module is available if Syn is built with the `"visit-mut"` + /// feature.* + #[cfg(feature = "visit-mut")] + pub mod visit_mut; + + /// Syntax tree traversal to transform the nodes of an owned syntax tree. + /// + /// Each method of the [`Fold`] trait is a hook that can be overridden to + /// customize the behavior when transforming the corresponding type of node. + /// By default, every method recursively visits the substructure of the + /// input by invoking the right visitor method of each of its fields. + /// + /// [`Fold`]: fold::Fold + /// + /// ```edition2018 + /// # use syn::{Attribute, BinOp, Expr, ExprBinary}; + /// # + /// pub trait Fold { + /// /* ... */ + /// + /// fn fold_expr_binary(&mut self, node: ExprBinary) -> ExprBinary { + /// ExprBinary { + /// attrs: node.attrs + /// .into_iter() + /// .map(|attr| self.fold_attribute(attr)) + /// .collect(), + /// left: Box::new(self.fold_expr(*node.left)), + /// op: self.fold_bin_op(node.op), + /// right: Box::new(self.fold_expr(*node.right)), + /// } + /// } + /// + /// /* ... */ + /// # fn fold_attribute(&mut self, node: Attribute) -> Attribute; + /// # fn fold_expr(&mut self, node: Expr) -> Expr; + /// # fn fold_bin_op(&mut self, node: BinOp) -> BinOp; + /// } + /// ``` + /// + /// *This module is available if Syn is built with the `"fold"` feature.* + #[cfg(feature = "fold")] + pub mod fold; + + #[cfg(any(feature = "full", feature = "derive"))] + #[path = "../gen_helper.rs"] + mod helper; +} +pub use gen::*; + +// Not public API. +#[doc(hidden)] +pub mod export; + +mod custom_keyword; +mod custom_punctuation; +mod sealed; + +#[cfg(feature = "parsing")] +mod lookahead; + +#[cfg(feature = "parsing")] +pub mod parse; + +mod span; + +#[cfg(all(any(feature = "full", feature = "derive"), feature = "printing"))] +mod print; + +mod thread; + +//////////////////////////////////////////////////////////////////////////////// + +#[cfg(any(feature = "parsing", feature = "full", feature = "derive"))] +#[allow(non_camel_case_types)] +struct private; + +//////////////////////////////////////////////////////////////////////////////// + +mod error; +pub use error::{Error, Result}; + +/// Parse tokens of source code into the chosen syntax tree node. +/// +/// This is preferred over parsing a string because tokens are able to preserve +/// information about where in the user's code they were originally written (the +/// "span" of the token), possibly allowing the compiler to produce better error +/// messages. +/// +/// This function parses a `proc_macro::TokenStream` which is the type used for +/// interop with the compiler in a procedural macro. To parse a +/// `proc_macro2::TokenStream`, use [`syn::parse2`] instead. +/// +/// [`syn::parse2`]: parse2 +/// +/// *This function is available if Syn is built with both the `"parsing"` and +/// `"proc-macro"` features.* +/// +/// # Examples +/// +/// ```edition2018 +/// extern crate proc_macro; +/// +/// use proc_macro::TokenStream; +/// use quote::quote; +/// use syn::DeriveInput; +/// +/// # const IGNORE_TOKENS: &str = stringify! { +/// #[proc_macro_derive(MyMacro)] +/// # }; +/// pub fn my_macro(input: TokenStream) -> TokenStream { +/// // Parse the tokens into a syntax tree +/// let ast: DeriveInput = syn::parse(input).unwrap(); +/// +/// // Build the output, possibly using quasi-quotation +/// let expanded = quote! { +/// /* ... */ +/// }; +/// +/// // Convert into a token stream and return it +/// expanded.into() +/// } +/// ``` +#[cfg(all( + not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))), + feature = "parsing", + feature = "proc-macro" +))] +pub fn parse<T: parse::Parse>(tokens: proc_macro::TokenStream) -> Result<T> { + parse::Parser::parse(T::parse, tokens) +} + +/// Parse a proc-macro2 token stream into the chosen syntax tree node. +/// +/// This function parses a `proc_macro2::TokenStream` which is commonly useful +/// when the input comes from a node of the Syn syntax tree, for example the tts +/// of a [`Macro`] node. When in a procedural macro parsing the +/// `proc_macro::TokenStream` provided by the compiler, use [`syn::parse`] +/// instead. +/// +/// [`syn::parse`]: parse() +/// +/// *This function is available if Syn is built with the `"parsing"` feature.* +#[cfg(feature = "parsing")] +pub fn parse2<T: parse::Parse>(tokens: proc_macro2::TokenStream) -> Result<T> { + parse::Parser::parse2(T::parse, tokens) +} + +/// Parse a string of Rust code into the chosen syntax tree node. +/// +/// *This function is available if Syn is built with the `"parsing"` feature.* +/// +/// # Hygiene +/// +/// Every span in the resulting syntax tree will be set to resolve at the macro +/// call site. +/// +/// # Examples +/// +/// ```edition2018 +/// use syn::{Expr, Result}; +/// +/// fn run() -> Result<()> { +/// let code = "assert_eq!(u8::max_value(), 255)"; +/// let expr = syn::parse_str::<Expr>(code)?; +/// println!("{:#?}", expr); +/// Ok(()) +/// } +/// # +/// # fn main() { +/// # run().unwrap(); +/// # } +/// ``` +#[cfg(feature = "parsing")] +pub fn parse_str<T: parse::Parse>(s: &str) -> Result<T> { + parse::Parser::parse_str(T::parse, s) +} + +// FIXME the name parse_file makes it sound like you might pass in a path to a +// file, rather than the content. +/// Parse the content of a file of Rust code. +/// +/// This is different from `syn::parse_str::<File>(content)` in two ways: +/// +/// - It discards a leading byte order mark `\u{FEFF}` if the file has one. +/// - It preserves the shebang line of the file, such as `#!/usr/bin/env rustx`. +/// +/// If present, either of these would be an error using `from_str`. +/// +/// *This function is available if Syn is built with the `"parsing"` and +/// `"full"` features.* +/// +/// # Examples +/// +/// ```edition2018,no_run +/// use std::error::Error; +/// use std::fs::File; +/// use std::io::Read; +/// +/// fn run() -> Result<(), Box<Error>> { +/// let mut file = File::open("path/to/code.rs")?; +/// let mut content = String::new(); +/// file.read_to_string(&mut content)?; +/// +/// let ast = syn::parse_file(&content)?; +/// if let Some(shebang) = ast.shebang { +/// println!("{}", shebang); +/// } +/// println!("{} items", ast.items.len()); +/// +/// Ok(()) +/// } +/// # +/// # fn main() { +/// # run().unwrap(); +/// # } +/// ``` +#[cfg(all(feature = "parsing", feature = "full"))] +pub fn parse_file(mut content: &str) -> Result<File> { + // Strip the BOM if it is present + const BOM: &'static str = "\u{feff}"; + if content.starts_with(BOM) { + content = &content[BOM.len()..]; + } + + let mut shebang = None; + if content.starts_with("#!") && !content.starts_with("#![") { + if let Some(idx) = content.find('\n') { + shebang = Some(content[..idx].to_string()); + content = &content[idx..]; + } else { + shebang = Some(content.to_string()); + content = ""; + } + } + + let mut file: File = parse_str(content)?; + file.shebang = shebang; + Ok(file) +} diff --git a/rust/vendor/syn-0.15.44/src/lifetime.rs b/rust/vendor/syn-0.15.44/src/lifetime.rs new file mode 100644 index 0000000..461560c --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/lifetime.rs @@ -0,0 +1,155 @@ +use std::cmp::Ordering; +use std::fmt::{self, Display}; +use std::hash::{Hash, Hasher}; + +use proc_macro2::{Ident, Span}; +use unicode_xid::UnicodeXID; + +#[cfg(feature = "parsing")] +use lookahead; + +/// A Rust lifetime: `'a`. +/// +/// Lifetime names must conform to the following rules: +/// +/// - Must start with an apostrophe. +/// - Must not consist of just an apostrophe: `'`. +/// - Character after the apostrophe must be `_` or a Unicode code point with +/// the XID_Start property. +/// - All following characters must be Unicode code points with the XID_Continue +/// property. +/// +/// *This type is available if Syn is built with the `"derive"` or `"full"` +/// feature.* +#[cfg_attr(feature = "extra-traits", derive(Debug))] +#[derive(Clone)] +pub struct Lifetime { + pub apostrophe: Span, + pub ident: Ident, +} + +impl Lifetime { + /// # Panics + /// + /// Panics if the lifetime does not conform to the bulleted rules above. + /// + /// # Invocation + /// + /// ```edition2018 + /// # use proc_macro2::Span; + /// # use syn::Lifetime; + /// # + /// # fn f() -> Lifetime { + /// Lifetime::new("'a", Span::call_site()) + /// # } + /// ``` + pub fn new(symbol: &str, span: Span) -> Self { + if !symbol.starts_with('\'') { + panic!( + "lifetime name must start with apostrophe as in \"'a\", got {:?}", + symbol + ); + } + + if symbol == "'" { + panic!("lifetime name must not be empty"); + } + + fn xid_ok(symbol: &str) -> bool { + let mut chars = symbol.chars(); + let first = chars.next().unwrap(); + if !(UnicodeXID::is_xid_start(first) || first == '_') { + return false; + } + for ch in chars { + if !UnicodeXID::is_xid_continue(ch) { + return false; + } + } + true + } + + if !xid_ok(&symbol[1..]) { + panic!("{:?} is not a valid lifetime name", symbol); + } + + Lifetime { + apostrophe: span, + ident: Ident::new(&symbol[1..], span), + } + } +} + +impl Display for Lifetime { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + "'".fmt(formatter)?; + self.ident.fmt(formatter) + } +} + +impl PartialEq for Lifetime { + fn eq(&self, other: &Lifetime) -> bool { + self.ident.eq(&other.ident) + } +} + +impl Eq for Lifetime {} + +impl PartialOrd for Lifetime { + fn partial_cmp(&self, other: &Lifetime) -> Option<Ordering> { + Some(self.cmp(other)) + } +} + +impl Ord for Lifetime { + fn cmp(&self, other: &Lifetime) -> Ordering { + self.ident.cmp(&other.ident) + } +} + +impl Hash for Lifetime { + fn hash<H: Hasher>(&self, h: &mut H) { + self.ident.hash(h) + } +} + +#[cfg(feature = "parsing")] +#[doc(hidden)] +#[allow(non_snake_case)] +pub fn Lifetime(marker: lookahead::TokenMarker) -> Lifetime { + match marker {} +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use parse::{Parse, ParseStream, Result}; + + impl Parse for Lifetime { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| { + cursor + .lifetime() + .ok_or_else(|| cursor.error("expected lifetime")) + }) + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + + use proc_macro2::{Punct, Spacing, TokenStream}; + use quote::{ToTokens, TokenStreamExt}; + + impl ToTokens for Lifetime { + fn to_tokens(&self, tokens: &mut TokenStream) { + let mut apostrophe = Punct::new('\'', Spacing::Joint); + apostrophe.set_span(self.apostrophe); + tokens.append(apostrophe); + self.ident.to_tokens(tokens); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/lit.rs b/rust/vendor/syn-0.15.44/src/lit.rs new file mode 100644 index 0000000..aa6a654 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/lit.rs @@ -0,0 +1,1106 @@ +use proc_macro2::{Literal, Span}; +use std::str; + +#[cfg(feature = "printing")] +use proc_macro2::Ident; + +#[cfg(feature = "parsing")] +use proc_macro2::TokenStream; + +use proc_macro2::TokenTree; + +#[cfg(feature = "extra-traits")] +use std::hash::{Hash, Hasher}; + +#[cfg(feature = "parsing")] +use lookahead; +#[cfg(feature = "parsing")] +use parse::{Parse, Parser, Result}; + +ast_enum_of_structs! { + /// A Rust literal such as a string or integer or boolean. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum Lit { + /// A UTF-8 string literal: `"foo"`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Str(LitStr #manual_extra_traits { + token: Literal, + }), + + /// A byte string literal: `b"foo"`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub ByteStr(LitByteStr #manual_extra_traits { + token: Literal, + }), + + /// A byte literal: `b'f'`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Byte(LitByte #manual_extra_traits { + token: Literal, + }), + + /// A character literal: `'a'`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Char(LitChar #manual_extra_traits { + token: Literal, + }), + + /// An integer literal: `1` or `1u16`. + /// + /// Holds up to 64 bits of data. Use `LitVerbatim` for any larger + /// integer literal. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Int(LitInt #manual_extra_traits { + token: Literal, + }), + + /// A floating point literal: `1f64` or `1.0e10f64`. + /// + /// Must be finite. May not be infinte or NaN. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Float(LitFloat #manual_extra_traits { + token: Literal, + }), + + /// A boolean literal: `true` or `false`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Bool(LitBool #manual_extra_traits { + pub value: bool, + pub span: Span, + }), + + /// A raw token literal not interpreted by Syn, possibly because it + /// represents an integer larger than 64 bits. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Verbatim(LitVerbatim #manual_extra_traits { + pub token: Literal, + }), + } +} + +impl LitStr { + pub fn new(value: &str, span: Span) -> Self { + let mut lit = Literal::string(value); + lit.set_span(span); + LitStr { token: lit } + } + + pub fn value(&self) -> String { + value::parse_lit_str(&self.token.to_string()) + } + + /// Parse a syntax tree node from the content of this string literal. + /// + /// All spans in the syntax tree will point to the span of this `LitStr`. + /// + /// # Example + /// + /// ```edition2018 + /// use proc_macro2::Span; + /// use syn::{Attribute, Error, Ident, Lit, Meta, MetaNameValue, Path, Result}; + /// + /// // Parses the path from an attribute that looks like: + /// // + /// // #[path = "a::b::c"] + /// // + /// // or returns `None` if the input is some other attribute. + /// fn get_path(attr: &Attribute) -> Result<Option<Path>> { + /// if !attr.path.is_ident("path") { + /// return Ok(None); + /// } + /// + /// match attr.parse_meta()? { + /// Meta::NameValue(MetaNameValue { lit: Lit::Str(lit_str), .. }) => { + /// lit_str.parse().map(Some) + /// } + /// _ => { + /// let message = "expected #[path = \"...\"]"; + /// Err(Error::new_spanned(attr, message)) + /// } + /// } + /// } + /// ``` + #[cfg(feature = "parsing")] + pub fn parse<T: Parse>(&self) -> Result<T> { + self.parse_with(T::parse) + } + + /// Invoke parser on the content of this string literal. + /// + /// All spans in the syntax tree will point to the span of this `LitStr`. + /// + /// # Example + /// + /// ```edition2018 + /// # use proc_macro2::Span; + /// # use syn::{LitStr, Result}; + /// # + /// # fn main() -> Result<()> { + /// # let lit_str = LitStr::new("a::b::c", Span::call_site()); + /// # + /// # const IGNORE: &str = stringify! { + /// let lit_str: LitStr = /* ... */; + /// # }; + /// + /// // Parse a string literal like "a::b::c" into a Path, not allowing + /// // generic arguments on any of the path segments. + /// let basic_path = lit_str.parse_with(syn::Path::parse_mod_style)?; + /// # + /// # Ok(()) + /// # } + /// ``` + #[cfg(feature = "parsing")] + pub fn parse_with<F: Parser>(&self, parser: F) -> Result<F::Output> { + use proc_macro2::Group; + + // Token stream with every span replaced by the given one. + fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream { + stream + .into_iter() + .map(|token| respan_token_tree(token, span)) + .collect() + } + + // Token tree with every span replaced by the given one. + fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree { + match token { + TokenTree::Group(ref mut g) => { + let stream = respan_token_stream(g.stream().clone(), span); + *g = Group::new(g.delimiter(), stream); + g.set_span(span); + } + ref mut other => other.set_span(span), + } + token + } + + // Parse string literal into a token stream with every span equal to the + // original literal's span. + let mut tokens = ::parse_str(&self.value())?; + tokens = respan_token_stream(tokens, self.span()); + + parser.parse2(tokens) + } + + pub fn span(&self) -> Span { + self.token.span() + } + + pub fn set_span(&mut self, span: Span) { + self.token.set_span(span) + } +} + +impl LitByteStr { + pub fn new(value: &[u8], span: Span) -> Self { + let mut token = Literal::byte_string(value); + token.set_span(span); + LitByteStr { token: token } + } + + pub fn value(&self) -> Vec<u8> { + value::parse_lit_byte_str(&self.token.to_string()) + } + + pub fn span(&self) -> Span { + self.token.span() + } + + pub fn set_span(&mut self, span: Span) { + self.token.set_span(span) + } +} + +impl LitByte { + pub fn new(value: u8, span: Span) -> Self { + let mut token = Literal::u8_suffixed(value); + token.set_span(span); + LitByte { token: token } + } + + pub fn value(&self) -> u8 { + value::parse_lit_byte(&self.token.to_string()) + } + + pub fn span(&self) -> Span { + self.token.span() + } + + pub fn set_span(&mut self, span: Span) { + self.token.set_span(span) + } +} + +impl LitChar { + pub fn new(value: char, span: Span) -> Self { + let mut token = Literal::character(value); + token.set_span(span); + LitChar { token: token } + } + + pub fn value(&self) -> char { + value::parse_lit_char(&self.token.to_string()) + } + + pub fn span(&self) -> Span { + self.token.span() + } + + pub fn set_span(&mut self, span: Span) { + self.token.set_span(span) + } +} + +impl LitInt { + pub fn new(value: u64, suffix: IntSuffix, span: Span) -> Self { + let mut token = match suffix { + IntSuffix::Isize => Literal::isize_suffixed(value as isize), + IntSuffix::I8 => Literal::i8_suffixed(value as i8), + IntSuffix::I16 => Literal::i16_suffixed(value as i16), + IntSuffix::I32 => Literal::i32_suffixed(value as i32), + IntSuffix::I64 => Literal::i64_suffixed(value as i64), + IntSuffix::I128 => value::to_literal(&format!("{}i128", value)), + IntSuffix::Usize => Literal::usize_suffixed(value as usize), + IntSuffix::U8 => Literal::u8_suffixed(value as u8), + IntSuffix::U16 => Literal::u16_suffixed(value as u16), + IntSuffix::U32 => Literal::u32_suffixed(value as u32), + IntSuffix::U64 => Literal::u64_suffixed(value), + IntSuffix::U128 => value::to_literal(&format!("{}u128", value)), + IntSuffix::None => Literal::u64_unsuffixed(value), + }; + token.set_span(span); + LitInt { token: token } + } + + pub fn value(&self) -> u64 { + value::parse_lit_int(&self.token.to_string()).unwrap() + } + + pub fn suffix(&self) -> IntSuffix { + let value = self.token.to_string(); + for (s, suffix) in vec![ + ("i8", IntSuffix::I8), + ("i16", IntSuffix::I16), + ("i32", IntSuffix::I32), + ("i64", IntSuffix::I64), + ("i128", IntSuffix::I128), + ("isize", IntSuffix::Isize), + ("u8", IntSuffix::U8), + ("u16", IntSuffix::U16), + ("u32", IntSuffix::U32), + ("u64", IntSuffix::U64), + ("u128", IntSuffix::U128), + ("usize", IntSuffix::Usize), + ] { + if value.ends_with(s) { + return suffix; + } + } + IntSuffix::None + } + + pub fn span(&self) -> Span { + self.token.span() + } + + pub fn set_span(&mut self, span: Span) { + self.token.set_span(span) + } +} + +impl LitFloat { + pub fn new(value: f64, suffix: FloatSuffix, span: Span) -> Self { + let mut token = match suffix { + FloatSuffix::F32 => Literal::f32_suffixed(value as f32), + FloatSuffix::F64 => Literal::f64_suffixed(value), + FloatSuffix::None => Literal::f64_unsuffixed(value), + }; + token.set_span(span); + LitFloat { token: token } + } + + pub fn value(&self) -> f64 { + value::parse_lit_float(&self.token.to_string()) + } + + pub fn suffix(&self) -> FloatSuffix { + let value = self.token.to_string(); + for (s, suffix) in vec![("f32", FloatSuffix::F32), ("f64", FloatSuffix::F64)] { + if value.ends_with(s) { + return suffix; + } + } + FloatSuffix::None + } + + pub fn span(&self) -> Span { + self.token.span() + } + + pub fn set_span(&mut self, span: Span) { + self.token.set_span(span) + } +} + +macro_rules! lit_extra_traits { + ($ty:ident, $field:ident) => { + #[cfg(feature = "extra-traits")] + impl Eq for $ty {} + + #[cfg(feature = "extra-traits")] + impl PartialEq for $ty { + fn eq(&self, other: &Self) -> bool { + self.$field.to_string() == other.$field.to_string() + } + } + + #[cfg(feature = "extra-traits")] + impl Hash for $ty { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + self.$field.to_string().hash(state); + } + } + + #[cfg(feature = "parsing")] + #[doc(hidden)] + #[allow(non_snake_case)] + pub fn $ty(marker: lookahead::TokenMarker) -> $ty { + match marker {} + } + }; +} + +impl LitVerbatim { + pub fn span(&self) -> Span { + self.token.span() + } + + pub fn set_span(&mut self, span: Span) { + self.token.set_span(span) + } +} + +lit_extra_traits!(LitStr, token); +lit_extra_traits!(LitByteStr, token); +lit_extra_traits!(LitByte, token); +lit_extra_traits!(LitChar, token); +lit_extra_traits!(LitInt, token); +lit_extra_traits!(LitFloat, token); +lit_extra_traits!(LitBool, value); +lit_extra_traits!(LitVerbatim, token); + +ast_enum! { + /// The style of a string literal, either plain quoted or a raw string like + /// `r##"data"##`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum StrStyle #no_visit { + /// An ordinary string like `"data"`. + Cooked, + /// A raw string like `r##"data"##`. + /// + /// The unsigned integer is the number of `#` symbols used. + Raw(usize), + } +} + +ast_enum! { + /// The suffix on an integer literal if any, like the `u8` in `127u8`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum IntSuffix #no_visit { + I8, + I16, + I32, + I64, + I128, + Isize, + U8, + U16, + U32, + U64, + U128, + Usize, + None, + } +} + +ast_enum! { + /// The suffix on a floating point literal if any, like the `f32` in + /// `1.0f32`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum FloatSuffix #no_visit { + F32, + F64, + None, + } +} + +#[cfg(feature = "parsing")] +#[doc(hidden)] +#[allow(non_snake_case)] +pub fn Lit(marker: lookahead::TokenMarker) -> Lit { + match marker {} +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + use parse::{Parse, ParseStream, Result}; + + impl Parse for Lit { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| { + if let Some((lit, rest)) = cursor.literal() { + return Ok((Lit::new(lit), rest)); + } + while let Some((ident, rest)) = cursor.ident() { + let value = if ident == "true" { + true + } else if ident == "false" { + false + } else { + break; + }; + let lit_bool = LitBool { + value: value, + span: ident.span(), + }; + return Ok((Lit::Bool(lit_bool), rest)); + } + Err(cursor.error("expected literal")) + }) + } + } + + impl Parse for LitStr { + fn parse(input: ParseStream) -> Result<Self> { + let head = input.fork(); + match input.parse()? { + Lit::Str(lit) => Ok(lit), + _ => Err(head.error("expected string literal")), + } + } + } + + impl Parse for LitByteStr { + fn parse(input: ParseStream) -> Result<Self> { + let head = input.fork(); + match input.parse()? { + Lit::ByteStr(lit) => Ok(lit), + _ => Err(head.error("expected byte string literal")), + } + } + } + + impl Parse for LitByte { + fn parse(input: ParseStream) -> Result<Self> { + let head = input.fork(); + match input.parse()? { + Lit::Byte(lit) => Ok(lit), + _ => Err(head.error("expected byte literal")), + } + } + } + + impl Parse for LitChar { + fn parse(input: ParseStream) -> Result<Self> { + let head = input.fork(); + match input.parse()? { + Lit::Char(lit) => Ok(lit), + _ => Err(head.error("expected character literal")), + } + } + } + + impl Parse for LitInt { + fn parse(input: ParseStream) -> Result<Self> { + let head = input.fork(); + match input.parse()? { + Lit::Int(lit) => Ok(lit), + _ => Err(head.error("expected integer literal")), + } + } + } + + impl Parse for LitFloat { + fn parse(input: ParseStream) -> Result<Self> { + let head = input.fork(); + match input.parse()? { + Lit::Float(lit) => Ok(lit), + _ => Err(head.error("expected floating point literal")), + } + } + } + + impl Parse for LitBool { + fn parse(input: ParseStream) -> Result<Self> { + let head = input.fork(); + match input.parse()? { + Lit::Bool(lit) => Ok(lit), + _ => Err(head.error("expected boolean literal")), + } + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + use proc_macro2::TokenStream; + use quote::{ToTokens, TokenStreamExt}; + + impl ToTokens for LitStr { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.token.to_tokens(tokens); + } + } + + impl ToTokens for LitByteStr { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.token.to_tokens(tokens); + } + } + + impl ToTokens for LitByte { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.token.to_tokens(tokens); + } + } + + impl ToTokens for LitChar { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.token.to_tokens(tokens); + } + } + + impl ToTokens for LitInt { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.token.to_tokens(tokens); + } + } + + impl ToTokens for LitFloat { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.token.to_tokens(tokens); + } + } + + impl ToTokens for LitBool { + fn to_tokens(&self, tokens: &mut TokenStream) { + let s = if self.value { "true" } else { "false" }; + tokens.append(Ident::new(s, self.span)); + } + } + + impl ToTokens for LitVerbatim { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.token.to_tokens(tokens); + } + } +} + +mod value { + use super::*; + use proc_macro2::TokenStream; + use std::char; + use std::ops::{Index, RangeFrom}; + + impl Lit { + /// Interpret a Syn literal from a proc-macro2 literal. + /// + /// Not all proc-macro2 literals are valid Syn literals. In particular, + /// doc comments are considered by proc-macro2 to be literals but in Syn + /// they are [`Attribute`]. + /// + /// [`Attribute`]: crate::Attribute + /// + /// # Panics + /// + /// Panics if the input is a doc comment literal. + pub fn new(token: Literal) -> Self { + let value = token.to_string(); + + match value::byte(&value, 0) { + b'"' | b'r' => return Lit::Str(LitStr { token: token }), + b'b' => match value::byte(&value, 1) { + b'"' | b'r' => return Lit::ByteStr(LitByteStr { token: token }), + b'\'' => return Lit::Byte(LitByte { token: token }), + _ => {} + }, + b'\'' => return Lit::Char(LitChar { token: token }), + b'0'...b'9' => { + if number_is_int(&value) { + return Lit::Int(LitInt { token: token }); + } else if number_is_float(&value) { + return Lit::Float(LitFloat { token: token }); + } else { + // number overflow + return Lit::Verbatim(LitVerbatim { token: token }); + } + } + _ => { + if value == "true" || value == "false" { + return Lit::Bool(LitBool { + value: value == "true", + span: token.span(), + }); + } + } + } + + panic!("Unrecognized literal: {}", value); + } + } + + fn number_is_int(value: &str) -> bool { + if number_is_float(value) { + false + } else { + value::parse_lit_int(value).is_some() + } + } + + fn number_is_float(value: &str) -> bool { + if value.contains('.') { + true + } else if value.starts_with("0x") || value.ends_with("size") { + false + } else { + value.contains('e') || value.contains('E') + } + } + + /// Get the byte at offset idx, or a default of `b'\0'` if we're looking + /// past the end of the input buffer. + pub fn byte<S: AsRef<[u8]> + ?Sized>(s: &S, idx: usize) -> u8 { + let s = s.as_ref(); + if idx < s.len() { + s[idx] + } else { + 0 + } + } + + fn next_chr(s: &str) -> char { + s.chars().next().unwrap_or('\0') + } + + pub fn parse_lit_str(s: &str) -> String { + match byte(s, 0) { + b'"' => parse_lit_str_cooked(s), + b'r' => parse_lit_str_raw(s), + _ => unreachable!(), + } + } + + // Clippy false positive + // https://github.com/rust-lang-nursery/rust-clippy/issues/2329 + #[cfg_attr(feature = "cargo-clippy", allow(needless_continue))] + fn parse_lit_str_cooked(mut s: &str) -> String { + assert_eq!(byte(s, 0), b'"'); + s = &s[1..]; + + let mut out = String::new(); + 'outer: loop { + let ch = match byte(s, 0) { + b'"' => break, + b'\\' => { + let b = byte(s, 1); + s = &s[2..]; + match b { + b'x' => { + let (byte, rest) = backslash_x(s); + s = rest; + assert!(byte <= 0x80, "Invalid \\x byte in string literal"); + char::from_u32(u32::from(byte)).unwrap() + } + b'u' => { + let (chr, rest) = backslash_u(s); + s = rest; + chr + } + b'n' => '\n', + b'r' => '\r', + b't' => '\t', + b'\\' => '\\', + b'0' => '\0', + b'\'' => '\'', + b'"' => '"', + b'\r' | b'\n' => loop { + let ch = next_chr(s); + if ch.is_whitespace() { + s = &s[ch.len_utf8()..]; + } else { + continue 'outer; + } + }, + b => panic!("unexpected byte {:?} after \\ character in byte literal", b), + } + } + b'\r' => { + assert_eq!(byte(s, 1), b'\n', "Bare CR not allowed in string"); + s = &s[2..]; + '\n' + } + _ => { + let ch = next_chr(s); + s = &s[ch.len_utf8()..]; + ch + } + }; + out.push(ch); + } + + assert_eq!(s, "\""); + out + } + + fn parse_lit_str_raw(mut s: &str) -> String { + assert_eq!(byte(s, 0), b'r'); + s = &s[1..]; + + let mut pounds = 0; + while byte(s, pounds) == b'#' { + pounds += 1; + } + assert_eq!(byte(s, pounds), b'"'); + assert_eq!(byte(s, s.len() - pounds - 1), b'"'); + for end in s[s.len() - pounds..].bytes() { + assert_eq!(end, b'#'); + } + + s[pounds + 1..s.len() - pounds - 1].to_owned() + } + + pub fn parse_lit_byte_str(s: &str) -> Vec<u8> { + assert_eq!(byte(s, 0), b'b'); + match byte(s, 1) { + b'"' => parse_lit_byte_str_cooked(s), + b'r' => parse_lit_byte_str_raw(s), + _ => unreachable!(), + } + } + + // Clippy false positive + // https://github.com/rust-lang-nursery/rust-clippy/issues/2329 + #[cfg_attr(feature = "cargo-clippy", allow(needless_continue))] + fn parse_lit_byte_str_cooked(mut s: &str) -> Vec<u8> { + assert_eq!(byte(s, 0), b'b'); + assert_eq!(byte(s, 1), b'"'); + s = &s[2..]; + + // We're going to want to have slices which don't respect codepoint boundaries. + let mut s = s.as_bytes(); + + let mut out = Vec::new(); + 'outer: loop { + let byte = match byte(s, 0) { + b'"' => break, + b'\\' => { + let b = byte(s, 1); + s = &s[2..]; + match b { + b'x' => { + let (b, rest) = backslash_x(s); + s = rest; + b + } + b'n' => b'\n', + b'r' => b'\r', + b't' => b'\t', + b'\\' => b'\\', + b'0' => b'\0', + b'\'' => b'\'', + b'"' => b'"', + b'\r' | b'\n' => loop { + let byte = byte(s, 0); + let ch = char::from_u32(u32::from(byte)).unwrap(); + if ch.is_whitespace() { + s = &s[1..]; + } else { + continue 'outer; + } + }, + b => panic!("unexpected byte {:?} after \\ character in byte literal", b), + } + } + b'\r' => { + assert_eq!(byte(s, 1), b'\n', "Bare CR not allowed in string"); + s = &s[2..]; + b'\n' + } + b => { + s = &s[1..]; + b + } + }; + out.push(byte); + } + + assert_eq!(s, b"\""); + out + } + + fn parse_lit_byte_str_raw(s: &str) -> Vec<u8> { + assert_eq!(byte(s, 0), b'b'); + parse_lit_str_raw(&s[1..]).into_bytes() + } + + pub fn parse_lit_byte(s: &str) -> u8 { + assert_eq!(byte(s, 0), b'b'); + assert_eq!(byte(s, 1), b'\''); + + // We're going to want to have slices which don't respect codepoint boundaries. + let mut s = s[2..].as_bytes(); + + let b = match byte(s, 0) { + b'\\' => { + let b = byte(s, 1); + s = &s[2..]; + match b { + b'x' => { + let (b, rest) = backslash_x(s); + s = rest; + b + } + b'n' => b'\n', + b'r' => b'\r', + b't' => b'\t', + b'\\' => b'\\', + b'0' => b'\0', + b'\'' => b'\'', + b'"' => b'"', + b => panic!("unexpected byte {:?} after \\ character in byte literal", b), + } + } + b => { + s = &s[1..]; + b + } + }; + + assert_eq!(byte(s, 0), b'\''); + b + } + + pub fn parse_lit_char(mut s: &str) -> char { + assert_eq!(byte(s, 0), b'\''); + s = &s[1..]; + + let ch = match byte(s, 0) { + b'\\' => { + let b = byte(s, 1); + s = &s[2..]; + match b { + b'x' => { + let (byte, rest) = backslash_x(s); + s = rest; + assert!(byte <= 0x80, "Invalid \\x byte in string literal"); + char::from_u32(u32::from(byte)).unwrap() + } + b'u' => { + let (chr, rest) = backslash_u(s); + s = rest; + chr + } + b'n' => '\n', + b'r' => '\r', + b't' => '\t', + b'\\' => '\\', + b'0' => '\0', + b'\'' => '\'', + b'"' => '"', + b => panic!("unexpected byte {:?} after \\ character in byte literal", b), + } + } + _ => { + let ch = next_chr(s); + s = &s[ch.len_utf8()..]; + ch + } + }; + assert_eq!(s, "\'", "Expected end of char literal"); + ch + } + + fn backslash_x<S>(s: &S) -> (u8, &S) + where + S: Index<RangeFrom<usize>, Output = S> + AsRef<[u8]> + ?Sized, + { + let mut ch = 0; + let b0 = byte(s, 0); + let b1 = byte(s, 1); + ch += 0x10 + * match b0 { + b'0'...b'9' => b0 - b'0', + b'a'...b'f' => 10 + (b0 - b'a'), + b'A'...b'F' => 10 + (b0 - b'A'), + _ => panic!("unexpected non-hex character after \\x"), + }; + ch += match b1 { + b'0'...b'9' => b1 - b'0', + b'a'...b'f' => 10 + (b1 - b'a'), + b'A'...b'F' => 10 + (b1 - b'A'), + _ => panic!("unexpected non-hex character after \\x"), + }; + (ch, &s[2..]) + } + + fn backslash_u(mut s: &str) -> (char, &str) { + if byte(s, 0) != b'{' { + panic!("expected {{ after \\u"); + } + s = &s[1..]; + + let mut ch = 0; + for _ in 0..6 { + let b = byte(s, 0); + match b { + b'0'...b'9' => { + ch *= 0x10; + ch += u32::from(b - b'0'); + s = &s[1..]; + } + b'a'...b'f' => { + ch *= 0x10; + ch += u32::from(10 + b - b'a'); + s = &s[1..]; + } + b'A'...b'F' => { + ch *= 0x10; + ch += u32::from(10 + b - b'A'); + s = &s[1..]; + } + b'}' => break, + _ => panic!("unexpected non-hex character after \\u"), + } + } + assert!(byte(s, 0) == b'}'); + s = &s[1..]; + + if let Some(ch) = char::from_u32(ch) { + (ch, s) + } else { + panic!("character code {:x} is not a valid unicode character", ch); + } + } + + pub fn parse_lit_int(mut s: &str) -> Option<u64> { + let base = match (byte(s, 0), byte(s, 1)) { + (b'0', b'x') => { + s = &s[2..]; + 16 + } + (b'0', b'o') => { + s = &s[2..]; + 8 + } + (b'0', b'b') => { + s = &s[2..]; + 2 + } + (b'0'...b'9', _) => 10, + _ => unreachable!(), + }; + + let mut value = 0u64; + loop { + let b = byte(s, 0); + let digit = match b { + b'0'...b'9' => u64::from(b - b'0'), + b'a'...b'f' if base > 10 => 10 + u64::from(b - b'a'), + b'A'...b'F' if base > 10 => 10 + u64::from(b - b'A'), + b'_' => { + s = &s[1..]; + continue; + } + // NOTE: Looking at a floating point literal, we don't want to + // consider these integers. + b'.' if base == 10 => return None, + b'e' | b'E' if base == 10 => return None, + _ => break, + }; + + if digit >= base { + panic!("Unexpected digit {:x} out of base range", digit); + } + + value = match value.checked_mul(base) { + Some(value) => value, + None => return None, + }; + value = match value.checked_add(digit) { + Some(value) => value, + None => return None, + }; + s = &s[1..]; + } + + Some(value) + } + + pub fn parse_lit_float(input: &str) -> f64 { + // Rust's floating point literals are very similar to the ones parsed by + // the standard library, except that rust's literals can contain + // ignorable underscores. Let's remove those underscores. + let mut bytes = input.to_owned().into_bytes(); + let mut write = 0; + for read in 0..bytes.len() { + if bytes[read] == b'_' { + continue; // Don't increase write + } + if write != read { + let x = bytes[read]; + bytes[write] = x; + } + write += 1; + } + bytes.truncate(write); + let input = String::from_utf8(bytes).unwrap(); + let end = input.find('f').unwrap_or_else(|| input.len()); + input[..end].parse().unwrap() + } + + pub fn to_literal(s: &str) -> Literal { + let stream = s.parse::<TokenStream>().unwrap(); + match stream.into_iter().next().unwrap() { + TokenTree::Literal(l) => l, + _ => unreachable!(), + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/lookahead.rs b/rust/vendor/syn-0.15.44/src/lookahead.rs new file mode 100644 index 0000000..d1b0cff --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/lookahead.rs @@ -0,0 +1,168 @@ +use std::cell::RefCell; + +use proc_macro2::{Delimiter, Span}; + +use buffer::Cursor; +use error::{self, Error}; +use sealed::lookahead::Sealed; +use span::IntoSpans; +use token::Token; + +/// Support for checking the next token in a stream to decide how to parse. +/// +/// An important advantage over [`ParseStream::peek`] is that here we +/// automatically construct an appropriate error message based on the token +/// alternatives that get peeked. If you are producing your own error message, +/// go ahead and use `ParseStream::peek` instead. +/// +/// Use [`ParseStream::lookahead1`] to construct this object. +/// +/// [`ParseStream::peek`]: crate::parse::ParseBuffer::peek +/// [`ParseStream::lookahead1`]: crate::parse::ParseBuffer::lookahead1 +/// +/// # Example +/// +/// ```edition2018 +/// use syn::{ConstParam, Ident, Lifetime, LifetimeDef, Result, Token, TypeParam}; +/// use syn::parse::{Parse, ParseStream}; +/// +/// // A generic parameter, a single one of the comma-separated elements inside +/// // angle brackets in: +/// // +/// // fn f<T: Clone, 'a, 'b: 'a, const N: usize>() { ... } +/// // +/// // On invalid input, lookahead gives us a reasonable error message. +/// // +/// // error: expected one of: identifier, lifetime, `const` +/// // | +/// // 5 | fn f<!Sized>() {} +/// // | ^ +/// enum GenericParam { +/// Type(TypeParam), +/// Lifetime(LifetimeDef), +/// Const(ConstParam), +/// } +/// +/// impl Parse for GenericParam { +/// fn parse(input: ParseStream) -> Result<Self> { +/// let lookahead = input.lookahead1(); +/// if lookahead.peek(Ident) { +/// input.parse().map(GenericParam::Type) +/// } else if lookahead.peek(Lifetime) { +/// input.parse().map(GenericParam::Lifetime) +/// } else if lookahead.peek(Token![const]) { +/// input.parse().map(GenericParam::Const) +/// } else { +/// Err(lookahead.error()) +/// } +/// } +/// } +/// ``` +pub struct Lookahead1<'a> { + scope: Span, + cursor: Cursor<'a>, + comparisons: RefCell<Vec<&'static str>>, +} + +pub fn new(scope: Span, cursor: Cursor) -> Lookahead1 { + Lookahead1 { + scope: scope, + cursor: cursor, + comparisons: RefCell::new(Vec::new()), + } +} + +fn peek_impl( + lookahead: &Lookahead1, + peek: fn(Cursor) -> bool, + display: fn() -> &'static str, +) -> bool { + if peek(lookahead.cursor) { + return true; + } + lookahead.comparisons.borrow_mut().push(display()); + false +} + +impl<'a> Lookahead1<'a> { + /// Looks at the next token in the parse stream to determine whether it + /// matches the requested type of token. + /// + /// # Syntax + /// + /// Note that this method does not use turbofish syntax. Pass the peek type + /// inside of parentheses. + /// + /// - `input.peek(Token![struct])` + /// - `input.peek(Token![==])` + /// - `input.peek(Ident)` *(does not accept keywords)* + /// - `input.peek(Ident::peek_any)` + /// - `input.peek(Lifetime)` + /// - `input.peek(token::Brace)` + pub fn peek<T: Peek>(&self, token: T) -> bool { + let _ = token; + peek_impl(self, T::Token::peek, T::Token::display) + } + + /// Triggers an error at the current position of the parse stream. + /// + /// The error message will identify all of the expected token types that + /// have been peeked against this lookahead instance. + pub fn error(self) -> Error { + let comparisons = self.comparisons.borrow(); + match comparisons.len() { + 0 => { + if self.cursor.eof() { + Error::new(self.scope, "unexpected end of input") + } else { + Error::new(self.cursor.span(), "unexpected token") + } + } + 1 => { + let message = format!("expected {}", comparisons[0]); + error::new_at(self.scope, self.cursor, message) + } + 2 => { + let message = format!("expected {} or {}", comparisons[0], comparisons[1]); + error::new_at(self.scope, self.cursor, message) + } + _ => { + let join = comparisons.join(", "); + let message = format!("expected one of: {}", join); + error::new_at(self.scope, self.cursor, message) + } + } + } +} + +/// Types that can be parsed by looking at just one token. +/// +/// Use [`ParseStream::peek`] to peek one of these types in a parse stream +/// without consuming it from the stream. +/// +/// This trait is sealed and cannot be implemented for types outside of Syn. +/// +/// [`ParseStream::peek`]: crate::parse::ParseBuffer::peek +pub trait Peek: Sealed { + // Not public API. + #[doc(hidden)] + type Token: Token; +} + +impl<F: Copy + FnOnce(TokenMarker) -> T, T: Token> Peek for F { + type Token = T; +} + +pub enum TokenMarker {} + +impl<S> IntoSpans<S> for TokenMarker { + fn into_spans(self) -> S { + match self {} + } +} + +pub fn is_delimiter(cursor: Cursor, delimiter: Delimiter) -> bool { + cursor.group(delimiter).is_some() +} + +impl<F: Copy + FnOnce(TokenMarker) -> T, T: Token> Sealed for F {} diff --git a/rust/vendor/syn-0.15.44/src/mac.rs b/rust/vendor/syn-0.15.44/src/mac.rs new file mode 100644 index 0000000..c4b16ba --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/mac.rs @@ -0,0 +1,239 @@ +use super::*; +use proc_macro2::TokenStream; +#[cfg(feature = "parsing")] +use proc_macro2::{Delimiter, Span, TokenTree}; +use token::{Brace, Bracket, Paren}; + +#[cfg(feature = "parsing")] +use parse::{Parse, ParseStream, Parser, Result}; +#[cfg(feature = "extra-traits")] +use std::hash::{Hash, Hasher}; +#[cfg(feature = "extra-traits")] +use tt::TokenStreamHelper; + +ast_struct! { + /// A macro invocation: `println!("{}", mac)`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct Macro #manual_extra_traits { + pub path: Path, + pub bang_token: Token![!], + pub delimiter: MacroDelimiter, + pub tts: TokenStream, + } +} + +ast_enum! { + /// A grouping token that surrounds a macro body: `m!(...)` or `m!{...}` or `m![...]`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum MacroDelimiter { + Paren(Paren), + Brace(Brace), + Bracket(Bracket), + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for Macro {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for Macro { + fn eq(&self, other: &Self) -> bool { + self.path == other.path + && self.bang_token == other.bang_token + && self.delimiter == other.delimiter + && TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for Macro { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + self.path.hash(state); + self.bang_token.hash(state); + self.delimiter.hash(state); + TokenStreamHelper(&self.tts).hash(state); + } +} + +#[cfg(feature = "parsing")] +fn delimiter_span(delimiter: &MacroDelimiter) -> Span { + match *delimiter { + MacroDelimiter::Paren(ref token) => token.span, + MacroDelimiter::Brace(ref token) => token.span, + MacroDelimiter::Bracket(ref token) => token.span, + } +} + +impl Macro { + /// Parse the tokens within the macro invocation's delimiters into a syntax + /// tree. + /// + /// This is equivalent to `syn::parse2::<T>(mac.tts)` except that it + /// produces a more useful span when `tts` is empty. + /// + /// # Example + /// + /// ```edition2018 + /// use syn::{parse_quote, Expr, ExprLit, Ident, Lit, LitStr, Macro, Token}; + /// use syn::ext::IdentExt; + /// use syn::parse::{Error, Parse, ParseStream, Result}; + /// use syn::punctuated::Punctuated; + /// + /// // The arguments expected by libcore's format_args macro, and as a + /// // result most other formatting and printing macros like println. + /// // + /// // println!("{} is {number:.prec$}", "x", prec=5, number=0.01) + /// struct FormatArgs { + /// format_string: Expr, + /// positional_args: Vec<Expr>, + /// named_args: Vec<(Ident, Expr)>, + /// } + /// + /// impl Parse for FormatArgs { + /// fn parse(input: ParseStream) -> Result<Self> { + /// let format_string: Expr; + /// let mut positional_args = Vec::new(); + /// let mut named_args = Vec::new(); + /// + /// format_string = input.parse()?; + /// while !input.is_empty() { + /// input.parse::<Token![,]>()?; + /// if input.is_empty() { + /// break; + /// } + /// if input.peek(Ident::peek_any) && input.peek2(Token![=]) { + /// while !input.is_empty() { + /// let name: Ident = input.call(Ident::parse_any)?; + /// input.parse::<Token![=]>()?; + /// let value: Expr = input.parse()?; + /// named_args.push((name, value)); + /// if input.is_empty() { + /// break; + /// } + /// input.parse::<Token![,]>()?; + /// } + /// break; + /// } + /// positional_args.push(input.parse()?); + /// } + /// + /// Ok(FormatArgs { + /// format_string, + /// positional_args, + /// named_args, + /// }) + /// } + /// } + /// + /// // Extract the first argument, the format string literal, from an + /// // invocation of a formatting or printing macro. + /// fn get_format_string(m: &Macro) -> Result<LitStr> { + /// let args: FormatArgs = m.parse_body()?; + /// match args.format_string { + /// Expr::Lit(ExprLit { lit: Lit::Str(lit), .. }) => Ok(lit), + /// other => { + /// // First argument was not a string literal expression. + /// // Maybe something like: println!(concat!(...), ...) + /// Err(Error::new_spanned(other, "format string must be a string literal")) + /// } + /// } + /// } + /// + /// fn main() { + /// let invocation = parse_quote! { + /// println!("{:?}", Instant::now()) + /// }; + /// let lit = get_format_string(&invocation).unwrap(); + /// assert_eq!(lit.value(), "{:?}"); + /// } + /// ``` + #[cfg(feature = "parsing")] + pub fn parse_body<T: Parse>(&self) -> Result<T> { + self.parse_body_with(T::parse) + } + + /// Parse the tokens within the macro invocation's delimiters using the + /// given parser. + #[cfg(feature = "parsing")] + pub fn parse_body_with<F: Parser>(&self, parser: F) -> Result<F::Output> { + // TODO: see if we can get a group.span_close() span in here as the + // scope, rather than the span of the whole group. + let scope = delimiter_span(&self.delimiter); + private::parse_scoped(parser, scope, self.tts.clone()) + } +} + +#[cfg(feature = "parsing")] +pub fn parse_delimiter(input: ParseStream) -> Result<(MacroDelimiter, TokenStream)> { + input.step(|cursor| { + if let Some((TokenTree::Group(g), rest)) = cursor.token_tree() { + let span = g.span(); + let delimiter = match g.delimiter() { + Delimiter::Parenthesis => MacroDelimiter::Paren(Paren(span)), + Delimiter::Brace => MacroDelimiter::Brace(Brace(span)), + Delimiter::Bracket => MacroDelimiter::Bracket(Bracket(span)), + Delimiter::None => { + return Err(cursor.error("expected delimiter")); + } + }; + Ok(((delimiter, g.stream().clone()), rest)) + } else { + Err(cursor.error("expected delimiter")) + } + }) +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use parse::{Parse, ParseStream, Result}; + + impl Parse for Macro { + fn parse(input: ParseStream) -> Result<Self> { + let tts; + Ok(Macro { + path: input.call(Path::parse_mod_style)?, + bang_token: input.parse()?, + delimiter: { + let (delimiter, content) = parse_delimiter(input)?; + tts = content; + delimiter + }, + tts: tts, + }) + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + use proc_macro2::TokenStream; + use quote::ToTokens; + + impl ToTokens for Macro { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.path.to_tokens(tokens); + self.bang_token.to_tokens(tokens); + match self.delimiter { + MacroDelimiter::Paren(ref paren) => { + paren.surround(tokens, |tokens| self.tts.to_tokens(tokens)); + } + MacroDelimiter::Brace(ref brace) => { + brace.surround(tokens, |tokens| self.tts.to_tokens(tokens)); + } + MacroDelimiter::Bracket(ref bracket) => { + bracket.surround(tokens, |tokens| self.tts.to_tokens(tokens)); + } + } + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/macros.rs b/rust/vendor/syn-0.15.44/src/macros.rs new file mode 100644 index 0000000..bb59063 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/macros.rs @@ -0,0 +1,165 @@ +#[cfg(any(feature = "full", feature = "derive"))] +macro_rules! ast_struct { + ( + $(#[$attr:meta])* + pub struct $name:ident #full $($rest:tt)* + ) => { + #[cfg(feature = "full")] + $(#[$attr])* + #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))] + #[cfg_attr(feature = "clone-impls", derive(Clone))] + pub struct $name $($rest)* + + #[cfg(not(feature = "full"))] + $(#[$attr])* + #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))] + #[cfg_attr(feature = "clone-impls", derive(Clone))] + pub struct $name { + _noconstruct: (), + } + }; + + ( + $(#[$attr:meta])* + pub struct $name:ident #manual_extra_traits $($rest:tt)* + ) => { + $(#[$attr])* + #[cfg_attr(feature = "extra-traits", derive(Debug))] + #[cfg_attr(feature = "clone-impls", derive(Clone))] + pub struct $name $($rest)* + }; + + ( + $(#[$attr:meta])* + pub struct $name:ident $($rest:tt)* + ) => { + $(#[$attr])* + #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))] + #[cfg_attr(feature = "clone-impls", derive(Clone))] + pub struct $name $($rest)* + }; +} + +#[cfg(any(feature = "full", feature = "derive"))] +macro_rules! ast_enum { + ( + $(#[$enum_attr:meta])* + pub enum $name:ident $(# $tags:ident)* { $($variants:tt)* } + ) => ( + $(#[$enum_attr])* + #[cfg_attr(feature = "extra-traits", derive(Debug, Eq, PartialEq, Hash))] + #[cfg_attr(feature = "clone-impls", derive(Clone))] + pub enum $name { + $($variants)* + } + ) +} + +#[cfg(any(feature = "full", feature = "derive"))] +macro_rules! ast_enum_of_structs { + ( + $(#[$enum_attr:meta])* + pub enum $name:ident { + $( + $(#[$variant_attr:meta])* + pub $variant:ident $( ($member:ident $($rest:tt)*) )*, + )* + } + + $($remaining:tt)* + ) => ( + ast_enum! { + $(#[$enum_attr])* + pub enum $name { + $( + $(#[$variant_attr])* + $variant $( ($member) )*, + )* + } + } + + $( + maybe_ast_struct! { + $(#[$variant_attr])* + $( + pub struct $member $($rest)* + )* + } + + $( + impl From<$member> for $name { + fn from(e: $member) -> $name { + $name::$variant(e) + } + } + )* + )* + + #[cfg(feature = "printing")] + generate_to_tokens! { + $($remaining)* + () + tokens + $name { $($variant $( [$($rest)*] )*,)* } + } + ) +} + +#[cfg(all(feature = "printing", any(feature = "full", feature = "derive")))] +macro_rules! generate_to_tokens { + (do_not_generate_to_tokens $($foo:tt)*) => (); + + (($($arms:tt)*) $tokens:ident $name:ident { $variant:ident, $($next:tt)*}) => { + generate_to_tokens!( + ($($arms)* $name::$variant => {}) + $tokens $name { $($next)* } + ); + }; + + (($($arms:tt)*) $tokens:ident $name:ident { $variant:ident [$($rest:tt)*], $($next:tt)*}) => { + generate_to_tokens!( + ($($arms)* $name::$variant(ref _e) => to_tokens_call!(_e, $tokens, $($rest)*),) + $tokens $name { $($next)* } + ); + }; + + (($($arms:tt)*) $tokens:ident $name:ident {}) => { + impl ::quote::ToTokens for $name { + fn to_tokens(&self, $tokens: &mut ::proc_macro2::TokenStream) { + match *self { + $($arms)* + } + } + } + }; +} + +#[cfg(all(feature = "printing", feature = "full"))] +macro_rules! to_tokens_call { + ($e:ident, $tokens:ident, $($rest:tt)*) => { + $e.to_tokens($tokens) + }; +} + +#[cfg(all(feature = "printing", feature = "derive", not(feature = "full")))] +macro_rules! to_tokens_call { + // If the variant is marked as #full, don't auto-generate to-tokens for it. + ($e:ident, $tokens:ident, #full $($rest:tt)*) => { + unreachable!() + }; + ($e:ident, $tokens:ident, $($rest:tt)*) => { + $e.to_tokens($tokens) + }; +} + +#[cfg(any(feature = "full", feature = "derive"))] +macro_rules! maybe_ast_struct { + ( + $(#[$attr:meta])* + $( + pub struct $name:ident + )* + ) => (); + + ($($rest:tt)*) => (ast_struct! { $($rest)* }); +} diff --git a/rust/vendor/syn-0.15.44/src/op.rs b/rust/vendor/syn-0.15.44/src/op.rs new file mode 100644 index 0000000..96d8c99 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/op.rs @@ -0,0 +1,231 @@ +ast_enum! { + /// A binary operator: `+`, `+=`, `&`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + #[cfg_attr(feature = "clone-impls", derive(Copy))] + pub enum BinOp { + /// The `+` operator (addition) + Add(Token![+]), + /// The `-` operator (subtraction) + Sub(Token![-]), + /// The `*` operator (multiplication) + Mul(Token![*]), + /// The `/` operator (division) + Div(Token![/]), + /// The `%` operator (modulus) + Rem(Token![%]), + /// The `&&` operator (logical and) + And(Token![&&]), + /// The `||` operator (logical or) + Or(Token![||]), + /// The `^` operator (bitwise xor) + BitXor(Token![^]), + /// The `&` operator (bitwise and) + BitAnd(Token![&]), + /// The `|` operator (bitwise or) + BitOr(Token![|]), + /// The `<<` operator (shift left) + Shl(Token![<<]), + /// The `>>` operator (shift right) + Shr(Token![>>]), + /// The `==` operator (equality) + Eq(Token![==]), + /// The `<` operator (less than) + Lt(Token![<]), + /// The `<=` operator (less than or equal to) + Le(Token![<=]), + /// The `!=` operator (not equal to) + Ne(Token![!=]), + /// The `>=` operator (greater than or equal to) + Ge(Token![>=]), + /// The `>` operator (greater than) + Gt(Token![>]), + /// The `+=` operator + AddEq(Token![+=]), + /// The `-=` operator + SubEq(Token![-=]), + /// The `*=` operator + MulEq(Token![*=]), + /// The `/=` operator + DivEq(Token![/=]), + /// The `%=` operator + RemEq(Token![%=]), + /// The `^=` operator + BitXorEq(Token![^=]), + /// The `&=` operator + BitAndEq(Token![&=]), + /// The `|=` operator + BitOrEq(Token![|=]), + /// The `<<=` operator + ShlEq(Token![<<=]), + /// The `>>=` operator + ShrEq(Token![>>=]), + } +} + +ast_enum! { + /// A unary operator: `*`, `!`, `-`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + #[cfg_attr(feature = "clone-impls", derive(Copy))] + pub enum UnOp { + /// The `*` operator for dereferencing + Deref(Token![*]), + /// The `!` operator for logical inversion + Not(Token![!]), + /// The `-` operator for negation + Neg(Token![-]), + } +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use parse::{Parse, ParseStream, Result}; + + fn parse_binop(input: ParseStream) -> Result<BinOp> { + if input.peek(Token![&&]) { + input.parse().map(BinOp::And) + } else if input.peek(Token![||]) { + input.parse().map(BinOp::Or) + } else if input.peek(Token![<<]) { + input.parse().map(BinOp::Shl) + } else if input.peek(Token![>>]) { + input.parse().map(BinOp::Shr) + } else if input.peek(Token![==]) { + input.parse().map(BinOp::Eq) + } else if input.peek(Token![<=]) { + input.parse().map(BinOp::Le) + } else if input.peek(Token![!=]) { + input.parse().map(BinOp::Ne) + } else if input.peek(Token![>=]) { + input.parse().map(BinOp::Ge) + } else if input.peek(Token![+]) { + input.parse().map(BinOp::Add) + } else if input.peek(Token![-]) { + input.parse().map(BinOp::Sub) + } else if input.peek(Token![*]) { + input.parse().map(BinOp::Mul) + } else if input.peek(Token![/]) { + input.parse().map(BinOp::Div) + } else if input.peek(Token![%]) { + input.parse().map(BinOp::Rem) + } else if input.peek(Token![^]) { + input.parse().map(BinOp::BitXor) + } else if input.peek(Token![&]) { + input.parse().map(BinOp::BitAnd) + } else if input.peek(Token![|]) { + input.parse().map(BinOp::BitOr) + } else if input.peek(Token![<]) { + input.parse().map(BinOp::Lt) + } else if input.peek(Token![>]) { + input.parse().map(BinOp::Gt) + } else { + Err(input.error("expected binary operator")) + } + } + + impl Parse for BinOp { + #[cfg(not(feature = "full"))] + fn parse(input: ParseStream) -> Result<Self> { + parse_binop(input) + } + + #[cfg(feature = "full")] + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Token![+=]) { + input.parse().map(BinOp::AddEq) + } else if input.peek(Token![-=]) { + input.parse().map(BinOp::SubEq) + } else if input.peek(Token![*=]) { + input.parse().map(BinOp::MulEq) + } else if input.peek(Token![/=]) { + input.parse().map(BinOp::DivEq) + } else if input.peek(Token![%=]) { + input.parse().map(BinOp::RemEq) + } else if input.peek(Token![^=]) { + input.parse().map(BinOp::BitXorEq) + } else if input.peek(Token![&=]) { + input.parse().map(BinOp::BitAndEq) + } else if input.peek(Token![|=]) { + input.parse().map(BinOp::BitOrEq) + } else if input.peek(Token![<<=]) { + input.parse().map(BinOp::ShlEq) + } else if input.peek(Token![>>=]) { + input.parse().map(BinOp::ShrEq) + } else { + parse_binop(input) + } + } + } + + impl Parse for UnOp { + fn parse(input: ParseStream) -> Result<Self> { + let lookahead = input.lookahead1(); + if lookahead.peek(Token![*]) { + input.parse().map(UnOp::Deref) + } else if lookahead.peek(Token![!]) { + input.parse().map(UnOp::Not) + } else if lookahead.peek(Token![-]) { + input.parse().map(UnOp::Neg) + } else { + Err(lookahead.error()) + } + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + use proc_macro2::TokenStream; + use quote::ToTokens; + + impl ToTokens for BinOp { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + BinOp::Add(ref t) => t.to_tokens(tokens), + BinOp::Sub(ref t) => t.to_tokens(tokens), + BinOp::Mul(ref t) => t.to_tokens(tokens), + BinOp::Div(ref t) => t.to_tokens(tokens), + BinOp::Rem(ref t) => t.to_tokens(tokens), + BinOp::And(ref t) => t.to_tokens(tokens), + BinOp::Or(ref t) => t.to_tokens(tokens), + BinOp::BitXor(ref t) => t.to_tokens(tokens), + BinOp::BitAnd(ref t) => t.to_tokens(tokens), + BinOp::BitOr(ref t) => t.to_tokens(tokens), + BinOp::Shl(ref t) => t.to_tokens(tokens), + BinOp::Shr(ref t) => t.to_tokens(tokens), + BinOp::Eq(ref t) => t.to_tokens(tokens), + BinOp::Lt(ref t) => t.to_tokens(tokens), + BinOp::Le(ref t) => t.to_tokens(tokens), + BinOp::Ne(ref t) => t.to_tokens(tokens), + BinOp::Ge(ref t) => t.to_tokens(tokens), + BinOp::Gt(ref t) => t.to_tokens(tokens), + BinOp::AddEq(ref t) => t.to_tokens(tokens), + BinOp::SubEq(ref t) => t.to_tokens(tokens), + BinOp::MulEq(ref t) => t.to_tokens(tokens), + BinOp::DivEq(ref t) => t.to_tokens(tokens), + BinOp::RemEq(ref t) => t.to_tokens(tokens), + BinOp::BitXorEq(ref t) => t.to_tokens(tokens), + BinOp::BitAndEq(ref t) => t.to_tokens(tokens), + BinOp::BitOrEq(ref t) => t.to_tokens(tokens), + BinOp::ShlEq(ref t) => t.to_tokens(tokens), + BinOp::ShrEq(ref t) => t.to_tokens(tokens), + } + } + } + + impl ToTokens for UnOp { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + UnOp::Deref(ref t) => t.to_tokens(tokens), + UnOp::Not(ref t) => t.to_tokens(tokens), + UnOp::Neg(ref t) => t.to_tokens(tokens), + } + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/parse.rs b/rust/vendor/syn-0.15.44/src/parse.rs new file mode 100644 index 0000000..1457db6 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/parse.rs @@ -0,0 +1,1147 @@ +//! Parsing interface for parsing a token stream into a syntax tree node. +//! +//! Parsing in Syn is built on parser functions that take in a [`ParseStream`] +//! and produce a [`Result<T>`] where `T` is some syntax tree node. Underlying +//! these parser functions is a lower level mechanism built around the +//! [`Cursor`] type. `Cursor` is a cheaply copyable cursor over a range of +//! tokens in a token stream. +//! +//! [`ParseStream`]: type.ParseStream.html +//! [`Result<T>`]: type.Result.html +//! [`Cursor`]: ../buffer/index.html +//! +//! # Example +//! +//! Here is a snippet of parsing code to get a feel for the style of the +//! library. We define data structures for a subset of Rust syntax including +//! enums (not shown) and structs, then provide implementations of the [`Parse`] +//! trait to parse these syntax tree data structures from a token stream. +//! +//! Once `Parse` impls have been defined, they can be called conveniently from a +//! procedural macro through [`parse_macro_input!`] as shown at the bottom of +//! the snippet. If the caller provides syntactically invalid input to the +//! procedural macro, they will receive a helpful compiler error message +//! pointing out the exact token that triggered the failure to parse. +//! +//! [`parse_macro_input!`]: ../macro.parse_macro_input.html +//! +//! ```edition2018 +//! extern crate proc_macro; +//! +//! use proc_macro::TokenStream; +//! use syn::{braced, parse_macro_input, token, Field, Ident, Result, Token}; +//! use syn::parse::{Parse, ParseStream}; +//! use syn::punctuated::Punctuated; +//! +//! enum Item { +//! Struct(ItemStruct), +//! Enum(ItemEnum), +//! } +//! +//! struct ItemStruct { +//! struct_token: Token![struct], +//! ident: Ident, +//! brace_token: token::Brace, +//! fields: Punctuated<Field, Token![,]>, +//! } +//! # +//! # enum ItemEnum {} +//! +//! impl Parse for Item { +//! fn parse(input: ParseStream) -> Result<Self> { +//! let lookahead = input.lookahead1(); +//! if lookahead.peek(Token![struct]) { +//! input.parse().map(Item::Struct) +//! } else if lookahead.peek(Token![enum]) { +//! input.parse().map(Item::Enum) +//! } else { +//! Err(lookahead.error()) +//! } +//! } +//! } +//! +//! impl Parse for ItemStruct { +//! fn parse(input: ParseStream) -> Result<Self> { +//! let content; +//! Ok(ItemStruct { +//! struct_token: input.parse()?, +//! ident: input.parse()?, +//! brace_token: braced!(content in input), +//! fields: content.parse_terminated(Field::parse_named)?, +//! }) +//! } +//! } +//! # +//! # impl Parse for ItemEnum { +//! # fn parse(input: ParseStream) -> Result<Self> { +//! # unimplemented!() +//! # } +//! # } +//! +//! # const IGNORE: &str = stringify! { +//! #[proc_macro] +//! # }; +//! pub fn my_macro(tokens: TokenStream) -> TokenStream { +//! let input = parse_macro_input!(tokens as Item); +//! +//! /* ... */ +//! # "".parse().unwrap() +//! } +//! ``` +//! +//! # The `syn::parse*` functions +//! +//! The [`syn::parse`], [`syn::parse2`], and [`syn::parse_str`] functions serve +//! as an entry point for parsing syntax tree nodes that can be parsed in an +//! obvious default way. These functions can return any syntax tree node that +//! implements the [`Parse`] trait, which includes most types in Syn. +//! +//! [`syn::parse`]: ../fn.parse.html +//! [`syn::parse2`]: ../fn.parse2.html +//! [`syn::parse_str`]: ../fn.parse_str.html +//! [`Parse`]: trait.Parse.html +//! +//! ```edition2018 +//! use syn::Type; +//! +//! # fn run_parser() -> syn::Result<()> { +//! let t: Type = syn::parse_str("std::collections::HashMap<String, Value>")?; +//! # Ok(()) +//! # } +//! # +//! # fn main() { +//! # run_parser().unwrap(); +//! # } +//! ``` +//! +//! The [`parse_quote!`] macro also uses this approach. +//! +//! [`parse_quote!`]: ../macro.parse_quote.html +//! +//! # The `Parser` trait +//! +//! Some types can be parsed in several ways depending on context. For example +//! an [`Attribute`] can be either "outer" like `#[...]` or "inner" like +//! `#![...]` and parsing the wrong one would be a bug. Similarly [`Punctuated`] +//! may or may not allow trailing punctuation, and parsing it the wrong way +//! would either reject valid input or accept invalid input. +//! +//! [`Attribute`]: ../struct.Attribute.html +//! [`Punctuated`]: ../punctuated/index.html +//! +//! The `Parse` trait is not implemented in these cases because there is no good +//! behavior to consider the default. +//! +//! ```edition2018,compile_fail +//! # extern crate proc_macro; +//! # +//! # use syn::punctuated::Punctuated; +//! # use syn::{PathSegment, Result, Token}; +//! # +//! # fn f(tokens: proc_macro::TokenStream) -> Result<()> { +//! # +//! // Can't parse `Punctuated` without knowing whether trailing punctuation +//! // should be allowed in this context. +//! let path: Punctuated<PathSegment, Token![::]> = syn::parse(tokens)?; +//! # +//! # Ok(()) +//! # } +//! ``` +//! +//! In these cases the types provide a choice of parser functions rather than a +//! single `Parse` implementation, and those parser functions can be invoked +//! through the [`Parser`] trait. +//! +//! [`Parser`]: trait.Parser.html +//! +//! ```edition2018 +//! extern crate proc_macro; +//! +//! use proc_macro::TokenStream; +//! use syn::parse::Parser; +//! use syn::punctuated::Punctuated; +//! use syn::{Attribute, Expr, PathSegment, Result, Token}; +//! +//! fn call_some_parser_methods(input: TokenStream) -> Result<()> { +//! // Parse a nonempty sequence of path segments separated by `::` punctuation +//! // with no trailing punctuation. +//! let tokens = input.clone(); +//! let parser = Punctuated::<PathSegment, Token![::]>::parse_separated_nonempty; +//! let _path = parser.parse(tokens)?; +//! +//! // Parse a possibly empty sequence of expressions terminated by commas with +//! // an optional trailing punctuation. +//! let tokens = input.clone(); +//! let parser = Punctuated::<Expr, Token![,]>::parse_terminated; +//! let _args = parser.parse(tokens)?; +//! +//! // Parse zero or more outer attributes but not inner attributes. +//! let tokens = input.clone(); +//! let parser = Attribute::parse_outer; +//! let _attrs = parser.parse(tokens)?; +//! +//! Ok(()) +//! } +//! ``` +//! +//! --- +//! +//! *This module is available if Syn is built with the `"parsing"` feature.* + +#[path = "discouraged.rs"] +pub mod discouraged; + +use std::cell::Cell; +use std::fmt::{self, Debug, Display}; +use std::marker::PhantomData; +use std::mem; +use std::ops::Deref; +use std::rc::Rc; +use std::str::FromStr; + +#[cfg(all( + not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))), + feature = "proc-macro" +))] +use proc_macro; +use proc_macro2::{self, Delimiter, Group, Literal, Punct, Span, TokenStream, TokenTree}; + +use buffer::{Cursor, TokenBuffer}; +use error; +use lookahead; +use private; +use punctuated::Punctuated; +use token::Token; + +pub use error::{Error, Result}; +pub use lookahead::{Lookahead1, Peek}; + +/// Parsing interface implemented by all types that can be parsed in a default +/// way from a token stream. +pub trait Parse: Sized { + fn parse(input: ParseStream) -> Result<Self>; +} + +/// Input to a Syn parser function. +/// +/// See the methods of this type under the documentation of [`ParseBuffer`]. For +/// an overview of parsing in Syn, refer to the [module documentation]. +/// +/// [module documentation]: self +pub type ParseStream<'a> = &'a ParseBuffer<'a>; + +/// Cursor position within a buffered token stream. +/// +/// This type is more commonly used through the type alias [`ParseStream`] which +/// is an alias for `&ParseBuffer`. +/// +/// `ParseStream` is the input type for all parser functions in Syn. They have +/// the signature `fn(ParseStream) -> Result<T>`. +/// +/// ## Calling a parser function +/// +/// There is no public way to construct a `ParseBuffer`. Instead, if you are +/// looking to invoke a parser function that requires `ParseStream` as input, +/// you will need to go through one of the public parsing entry points. +/// +/// - The [`parse_macro_input!`] macro if parsing input of a procedural macro; +/// - One of [the `syn::parse*` functions][syn-parse]; or +/// - A method of the [`Parser`] trait. +/// +/// [syn-parse]: index.html#the-synparse-functions +pub struct ParseBuffer<'a> { + scope: Span, + // Instead of Cell<Cursor<'a>> so that ParseBuffer<'a> is covariant in 'a. + // The rest of the code in this module needs to be careful that only a + // cursor derived from this `cell` is ever assigned to this `cell`. + // + // Cell<Cursor<'a>> cannot be covariant in 'a because then we could take a + // ParseBuffer<'a>, upcast to ParseBuffer<'short> for some lifetime shorter + // than 'a, and then assign a Cursor<'short> into the Cell. + // + // By extension, it would not be safe to expose an API that accepts a + // Cursor<'a> and trusts that it lives as long as the cursor currently in + // the cell. + cell: Cell<Cursor<'static>>, + marker: PhantomData<Cursor<'a>>, + unexpected: Rc<Cell<Option<Span>>>, +} + +impl<'a> Drop for ParseBuffer<'a> { + fn drop(&mut self) { + if !self.is_empty() && self.unexpected.get().is_none() { + self.unexpected.set(Some(self.cursor().span())); + } + } +} + +impl<'a> Display for ParseBuffer<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + Display::fmt(&self.cursor().token_stream(), f) + } +} + +impl<'a> Debug for ParseBuffer<'a> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + Debug::fmt(&self.cursor().token_stream(), f) + } +} + +/// Cursor state associated with speculative parsing. +/// +/// This type is the input of the closure provided to [`ParseStream::step`]. +/// +/// [`ParseStream::step`]: ParseBuffer::step +/// +/// # Example +/// +/// ```edition2018 +/// use proc_macro2::TokenTree; +/// use syn::Result; +/// use syn::parse::ParseStream; +/// +/// // This function advances the stream past the next occurrence of `@`. If +/// // no `@` is present in the stream, the stream position is unchanged and +/// // an error is returned. +/// fn skip_past_next_at(input: ParseStream) -> Result<()> { +/// input.step(|cursor| { +/// let mut rest = *cursor; +/// while let Some((tt, next)) = rest.token_tree() { +/// match &tt { +/// TokenTree::Punct(punct) if punct.as_char() == '@' => { +/// return Ok(((), next)); +/// } +/// _ => rest = next, +/// } +/// } +/// Err(cursor.error("no `@` was found after this point")) +/// }) +/// } +/// # +/// # fn remainder_after_skipping_past_next_at( +/// # input: ParseStream, +/// # ) -> Result<proc_macro2::TokenStream> { +/// # skip_past_next_at(input)?; +/// # input.parse() +/// # } +/// # +/// # fn main() { +/// # use syn::parse::Parser; +/// # let remainder = remainder_after_skipping_past_next_at +/// # .parse_str("a @ b c") +/// # .unwrap(); +/// # assert_eq!(remainder.to_string(), "b c"); +/// # } +/// ``` +#[derive(Copy, Clone)] +pub struct StepCursor<'c, 'a> { + scope: Span, + // This field is covariant in 'c. + cursor: Cursor<'c>, + // This field is contravariant in 'c. Together these make StepCursor + // invariant in 'c. Also covariant in 'a. The user cannot cast 'c to a + // different lifetime but can upcast into a StepCursor with a shorter + // lifetime 'a. + // + // As long as we only ever construct a StepCursor for which 'c outlives 'a, + // this means if ever a StepCursor<'c, 'a> exists we are guaranteed that 'c + // outlives 'a. + marker: PhantomData<fn(Cursor<'c>) -> Cursor<'a>>, +} + +impl<'c, 'a> Deref for StepCursor<'c, 'a> { + type Target = Cursor<'c>; + + fn deref(&self) -> &Self::Target { + &self.cursor + } +} + +impl<'c, 'a> StepCursor<'c, 'a> { + /// Triggers an error at the current position of the parse stream. + /// + /// The `ParseStream::step` invocation will return this same error without + /// advancing the stream state. + pub fn error<T: Display>(self, message: T) -> Error { + error::new_at(self.scope, self.cursor, message) + } +} + +impl private { + pub fn advance_step_cursor<'c, 'a>(proof: StepCursor<'c, 'a>, to: Cursor<'c>) -> Cursor<'a> { + // Refer to the comments within the StepCursor definition. We use the + // fact that a StepCursor<'c, 'a> exists as proof that 'c outlives 'a. + // Cursor is covariant in its lifetime parameter so we can cast a + // Cursor<'c> to one with the shorter lifetime Cursor<'a>. + let _ = proof; + unsafe { mem::transmute::<Cursor<'c>, Cursor<'a>>(to) } + } +} + +fn skip(input: ParseStream) -> bool { + input + .step(|cursor| { + if let Some((_lifetime, rest)) = cursor.lifetime() { + Ok((true, rest)) + } else if let Some((_token, rest)) = cursor.token_tree() { + Ok((true, rest)) + } else { + Ok((false, *cursor)) + } + }) + .unwrap() +} + +impl private { + pub fn new_parse_buffer( + scope: Span, + cursor: Cursor, + unexpected: Rc<Cell<Option<Span>>>, + ) -> ParseBuffer { + ParseBuffer { + scope: scope, + // See comment on `cell` in the struct definition. + cell: Cell::new(unsafe { mem::transmute::<Cursor, Cursor<'static>>(cursor) }), + marker: PhantomData, + unexpected: unexpected, + } + } + + pub fn get_unexpected(buffer: &ParseBuffer) -> Rc<Cell<Option<Span>>> { + buffer.unexpected.clone() + } +} + +impl<'a> ParseBuffer<'a> { + /// Parses a syntax tree node of type `T`, advancing the position of our + /// parse stream past it. + pub fn parse<T: Parse>(&self) -> Result<T> { + T::parse(self) + } + + /// Calls the given parser function to parse a syntax tree node of type `T` + /// from this stream. + /// + /// # Example + /// + /// The parser below invokes [`Attribute::parse_outer`] to parse a vector of + /// zero or more outer attributes. + /// + /// [`Attribute::parse_outer`]: crate::Attribute::parse_outer + /// + /// ```edition2018 + /// use syn::{Attribute, Ident, Result, Token}; + /// use syn::parse::{Parse, ParseStream}; + /// + /// // Parses a unit struct with attributes. + /// // + /// // #[path = "s.tmpl"] + /// // struct S; + /// struct UnitStruct { + /// attrs: Vec<Attribute>, + /// struct_token: Token![struct], + /// name: Ident, + /// semi_token: Token![;], + /// } + /// + /// impl Parse for UnitStruct { + /// fn parse(input: ParseStream) -> Result<Self> { + /// Ok(UnitStruct { + /// attrs: input.call(Attribute::parse_outer)?, + /// struct_token: input.parse()?, + /// name: input.parse()?, + /// semi_token: input.parse()?, + /// }) + /// } + /// } + /// ``` + pub fn call<T>(&self, function: fn(ParseStream) -> Result<T>) -> Result<T> { + function(self) + } + + /// Looks at the next token in the parse stream to determine whether it + /// matches the requested type of token. + /// + /// Does not advance the position of the parse stream. + /// + /// # Syntax + /// + /// Note that this method does not use turbofish syntax. Pass the peek type + /// inside of parentheses. + /// + /// - `input.peek(Token![struct])` + /// - `input.peek(Token![==])` + /// - `input.peek(Ident)` *(does not accept keywords)* + /// - `input.peek(Ident::peek_any)` + /// - `input.peek(Lifetime)` + /// - `input.peek(token::Brace)` + /// + /// # Example + /// + /// In this example we finish parsing the list of supertraits when the next + /// token in the input is either `where` or an opening curly brace. + /// + /// ```edition2018 + /// use syn::{braced, token, Generics, Ident, Result, Token, TypeParamBound}; + /// use syn::parse::{Parse, ParseStream}; + /// use syn::punctuated::Punctuated; + /// + /// // Parses a trait definition containing no associated items. + /// // + /// // trait Marker<'de, T>: A + B<'de> where Box<T>: Clone {} + /// struct MarkerTrait { + /// trait_token: Token![trait], + /// ident: Ident, + /// generics: Generics, + /// colon_token: Option<Token![:]>, + /// supertraits: Punctuated<TypeParamBound, Token![+]>, + /// brace_token: token::Brace, + /// } + /// + /// impl Parse for MarkerTrait { + /// fn parse(input: ParseStream) -> Result<Self> { + /// let trait_token: Token![trait] = input.parse()?; + /// let ident: Ident = input.parse()?; + /// let mut generics: Generics = input.parse()?; + /// let colon_token: Option<Token![:]> = input.parse()?; + /// + /// let mut supertraits = Punctuated::new(); + /// if colon_token.is_some() { + /// loop { + /// supertraits.push_value(input.parse()?); + /// if input.peek(Token![where]) || input.peek(token::Brace) { + /// break; + /// } + /// supertraits.push_punct(input.parse()?); + /// } + /// } + /// + /// generics.where_clause = input.parse()?; + /// let content; + /// let empty_brace_token = braced!(content in input); + /// + /// Ok(MarkerTrait { + /// trait_token: trait_token, + /// ident: ident, + /// generics: generics, + /// colon_token: colon_token, + /// supertraits: supertraits, + /// brace_token: empty_brace_token, + /// }) + /// } + /// } + /// ``` + pub fn peek<T: Peek>(&self, token: T) -> bool { + let _ = token; + T::Token::peek(self.cursor()) + } + + /// Looks at the second-next token in the parse stream. + /// + /// This is commonly useful as a way to implement contextual keywords. + /// + /// # Example + /// + /// This example needs to use `peek2` because the symbol `union` is not a + /// keyword in Rust. We can't use just `peek` and decide to parse a union if + /// the very next token is `union`, because someone is free to write a `mod + /// union` and a macro invocation that looks like `union::some_macro! { ... + /// }`. In other words `union` is a contextual keyword. + /// + /// ```edition2018 + /// use syn::{Ident, ItemUnion, Macro, Result, Token}; + /// use syn::parse::{Parse, ParseStream}; + /// + /// // Parses either a union or a macro invocation. + /// enum UnionOrMacro { + /// // union MaybeUninit<T> { uninit: (), value: T } + /// Union(ItemUnion), + /// // lazy_static! { ... } + /// Macro(Macro), + /// } + /// + /// impl Parse for UnionOrMacro { + /// fn parse(input: ParseStream) -> Result<Self> { + /// if input.peek(Token![union]) && input.peek2(Ident) { + /// input.parse().map(UnionOrMacro::Union) + /// } else { + /// input.parse().map(UnionOrMacro::Macro) + /// } + /// } + /// } + /// ``` + pub fn peek2<T: Peek>(&self, token: T) -> bool { + let ahead = self.fork(); + skip(&ahead) && ahead.peek(token) + } + + /// Looks at the third-next token in the parse stream. + pub fn peek3<T: Peek>(&self, token: T) -> bool { + let ahead = self.fork(); + skip(&ahead) && skip(&ahead) && ahead.peek(token) + } + + /// Parses zero or more occurrences of `T` separated by punctuation of type + /// `P`, with optional trailing punctuation. + /// + /// Parsing continues until the end of this parse stream. The entire content + /// of this parse stream must consist of `T` and `P`. + /// + /// # Example + /// + /// ```edition2018 + /// # use quote::quote; + /// # + /// use syn::{parenthesized, token, Ident, Result, Token, Type}; + /// use syn::parse::{Parse, ParseStream}; + /// use syn::punctuated::Punctuated; + /// + /// // Parse a simplified tuple struct syntax like: + /// // + /// // struct S(A, B); + /// struct TupleStruct { + /// struct_token: Token![struct], + /// ident: Ident, + /// paren_token: token::Paren, + /// fields: Punctuated<Type, Token![,]>, + /// semi_token: Token![;], + /// } + /// + /// impl Parse for TupleStruct { + /// fn parse(input: ParseStream) -> Result<Self> { + /// let content; + /// Ok(TupleStruct { + /// struct_token: input.parse()?, + /// ident: input.parse()?, + /// paren_token: parenthesized!(content in input), + /// fields: content.parse_terminated(Type::parse)?, + /// semi_token: input.parse()?, + /// }) + /// } + /// } + /// # + /// # fn main() { + /// # let input = quote! { + /// # struct S(A, B); + /// # }; + /// # syn::parse2::<TupleStruct>(input).unwrap(); + /// # } + /// ``` + pub fn parse_terminated<T, P: Parse>( + &self, + parser: fn(ParseStream) -> Result<T>, + ) -> Result<Punctuated<T, P>> { + Punctuated::parse_terminated_with(self, parser) + } + + /// Returns whether there are tokens remaining in this stream. + /// + /// This method returns true at the end of the content of a set of + /// delimiters, as well as at the very end of the complete macro input. + /// + /// # Example + /// + /// ```edition2018 + /// use syn::{braced, token, Ident, Item, Result, Token}; + /// use syn::parse::{Parse, ParseStream}; + /// + /// // Parses a Rust `mod m { ... }` containing zero or more items. + /// struct Mod { + /// mod_token: Token![mod], + /// name: Ident, + /// brace_token: token::Brace, + /// items: Vec<Item>, + /// } + /// + /// impl Parse for Mod { + /// fn parse(input: ParseStream) -> Result<Self> { + /// let content; + /// Ok(Mod { + /// mod_token: input.parse()?, + /// name: input.parse()?, + /// brace_token: braced!(content in input), + /// items: { + /// let mut items = Vec::new(); + /// while !content.is_empty() { + /// items.push(content.parse()?); + /// } + /// items + /// }, + /// }) + /// } + /// } + /// ``` + pub fn is_empty(&self) -> bool { + self.cursor().eof() + } + + /// Constructs a helper for peeking at the next token in this stream and + /// building an error message if it is not one of a set of expected tokens. + /// + /// # Example + /// + /// ```edition2018 + /// use syn::{ConstParam, Ident, Lifetime, LifetimeDef, Result, Token, TypeParam}; + /// use syn::parse::{Parse, ParseStream}; + /// + /// // A generic parameter, a single one of the comma-separated elements inside + /// // angle brackets in: + /// // + /// // fn f<T: Clone, 'a, 'b: 'a, const N: usize>() { ... } + /// // + /// // On invalid input, lookahead gives us a reasonable error message. + /// // + /// // error: expected one of: identifier, lifetime, `const` + /// // | + /// // 5 | fn f<!Sized>() {} + /// // | ^ + /// enum GenericParam { + /// Type(TypeParam), + /// Lifetime(LifetimeDef), + /// Const(ConstParam), + /// } + /// + /// impl Parse for GenericParam { + /// fn parse(input: ParseStream) -> Result<Self> { + /// let lookahead = input.lookahead1(); + /// if lookahead.peek(Ident) { + /// input.parse().map(GenericParam::Type) + /// } else if lookahead.peek(Lifetime) { + /// input.parse().map(GenericParam::Lifetime) + /// } else if lookahead.peek(Token![const]) { + /// input.parse().map(GenericParam::Const) + /// } else { + /// Err(lookahead.error()) + /// } + /// } + /// } + /// ``` + pub fn lookahead1(&self) -> Lookahead1<'a> { + lookahead::new(self.scope, self.cursor()) + } + + /// Forks a parse stream so that parsing tokens out of either the original + /// or the fork does not advance the position of the other. + /// + /// # Performance + /// + /// Forking a parse stream is a cheap fixed amount of work and does not + /// involve copying token buffers. Where you might hit performance problems + /// is if your macro ends up parsing a large amount of content more than + /// once. + /// + /// ```edition2018 + /// # use syn::{Expr, Result}; + /// # use syn::parse::ParseStream; + /// # + /// # fn bad(input: ParseStream) -> Result<Expr> { + /// // Do not do this. + /// if input.fork().parse::<Expr>().is_ok() { + /// return input.parse::<Expr>(); + /// } + /// # unimplemented!() + /// # } + /// ``` + /// + /// As a rule, avoid parsing an unbounded amount of tokens out of a forked + /// parse stream. Only use a fork when the amount of work performed against + /// the fork is small and bounded. + /// + /// When complex speculative parsing against the forked stream is + /// unavoidable, use [`parse::discouraged::Speculative`] to advance the + /// original stream once the fork's parse is determined to have been + /// successful. + /// + /// For a lower level way to perform speculative parsing at the token level, + /// consider using [`ParseStream::step`] instead. + /// + /// [`parse::discouraged::Speculative`]: discouraged::Speculative + /// [`ParseStream::step`]: ParseBuffer::step + /// + /// # Example + /// + /// The parse implementation shown here parses possibly restricted `pub` + /// visibilities. + /// + /// - `pub` + /// - `pub(crate)` + /// - `pub(self)` + /// - `pub(super)` + /// - `pub(in some::path)` + /// + /// To handle the case of visibilities inside of tuple structs, the parser + /// needs to distinguish parentheses that specify visibility restrictions + /// from parentheses that form part of a tuple type. + /// + /// ```edition2018 + /// # struct A; + /// # struct B; + /// # struct C; + /// # + /// struct S(pub(crate) A, pub (B, C)); + /// ``` + /// + /// In this example input the first tuple struct element of `S` has + /// `pub(crate)` visibility while the second tuple struct element has `pub` + /// visibility; the parentheses around `(B, C)` are part of the type rather + /// than part of a visibility restriction. + /// + /// The parser uses a forked parse stream to check the first token inside of + /// parentheses after the `pub` keyword. This is a small bounded amount of + /// work performed against the forked parse stream. + /// + /// ```edition2018 + /// use syn::{parenthesized, token, Ident, Path, Result, Token}; + /// use syn::ext::IdentExt; + /// use syn::parse::{Parse, ParseStream}; + /// + /// struct PubVisibility { + /// pub_token: Token![pub], + /// restricted: Option<Restricted>, + /// } + /// + /// struct Restricted { + /// paren_token: token::Paren, + /// in_token: Option<Token![in]>, + /// path: Path, + /// } + /// + /// impl Parse for PubVisibility { + /// fn parse(input: ParseStream) -> Result<Self> { + /// let pub_token: Token![pub] = input.parse()?; + /// + /// if input.peek(token::Paren) { + /// let ahead = input.fork(); + /// let mut content; + /// parenthesized!(content in ahead); + /// + /// if content.peek(Token![crate]) + /// || content.peek(Token![self]) + /// || content.peek(Token![super]) + /// { + /// return Ok(PubVisibility { + /// pub_token: pub_token, + /// restricted: Some(Restricted { + /// paren_token: parenthesized!(content in input), + /// in_token: None, + /// path: Path::from(content.call(Ident::parse_any)?), + /// }), + /// }); + /// } else if content.peek(Token![in]) { + /// return Ok(PubVisibility { + /// pub_token: pub_token, + /// restricted: Some(Restricted { + /// paren_token: parenthesized!(content in input), + /// in_token: Some(content.parse()?), + /// path: content.call(Path::parse_mod_style)?, + /// }), + /// }); + /// } + /// } + /// + /// Ok(PubVisibility { + /// pub_token: pub_token, + /// restricted: None, + /// }) + /// } + /// } + /// ``` + pub fn fork(&self) -> Self { + ParseBuffer { + scope: self.scope, + cell: self.cell.clone(), + marker: PhantomData, + // Not the parent's unexpected. Nothing cares whether the clone + // parses all the way. + unexpected: Rc::new(Cell::new(None)), + } + } + + /// Triggers an error at the current position of the parse stream. + /// + /// # Example + /// + /// ```edition2018 + /// use syn::{Expr, Result, Token}; + /// use syn::parse::{Parse, ParseStream}; + /// + /// // Some kind of loop: `while` or `for` or `loop`. + /// struct Loop { + /// expr: Expr, + /// } + /// + /// impl Parse for Loop { + /// fn parse(input: ParseStream) -> Result<Self> { + /// if input.peek(Token![while]) + /// || input.peek(Token![for]) + /// || input.peek(Token![loop]) + /// { + /// Ok(Loop { + /// expr: input.parse()?, + /// }) + /// } else { + /// Err(input.error("expected some kind of loop")) + /// } + /// } + /// } + /// ``` + pub fn error<T: Display>(&self, message: T) -> Error { + error::new_at(self.scope, self.cursor(), message) + } + + /// Speculatively parses tokens from this parse stream, advancing the + /// position of this stream only if parsing succeeds. + /// + /// This is a powerful low-level API used for defining the `Parse` impls of + /// the basic built-in token types. It is not something that will be used + /// widely outside of the Syn codebase. + /// + /// # Example + /// + /// ```edition2018 + /// use proc_macro2::TokenTree; + /// use syn::Result; + /// use syn::parse::ParseStream; + /// + /// // This function advances the stream past the next occurrence of `@`. If + /// // no `@` is present in the stream, the stream position is unchanged and + /// // an error is returned. + /// fn skip_past_next_at(input: ParseStream) -> Result<()> { + /// input.step(|cursor| { + /// let mut rest = *cursor; + /// while let Some((tt, next)) = rest.token_tree() { + /// match &tt { + /// TokenTree::Punct(punct) if punct.as_char() == '@' => { + /// return Ok(((), next)); + /// } + /// _ => rest = next, + /// } + /// } + /// Err(cursor.error("no `@` was found after this point")) + /// }) + /// } + /// # + /// # fn remainder_after_skipping_past_next_at( + /// # input: ParseStream, + /// # ) -> Result<proc_macro2::TokenStream> { + /// # skip_past_next_at(input)?; + /// # input.parse() + /// # } + /// # + /// # fn main() { + /// # use syn::parse::Parser; + /// # let remainder = remainder_after_skipping_past_next_at + /// # .parse_str("a @ b c") + /// # .unwrap(); + /// # assert_eq!(remainder.to_string(), "b c"); + /// # } + /// ``` + pub fn step<F, R>(&self, function: F) -> Result<R> + where + F: for<'c> FnOnce(StepCursor<'c, 'a>) -> Result<(R, Cursor<'c>)>, + { + // Since the user's function is required to work for any 'c, we know + // that the Cursor<'c> they return is either derived from the input + // StepCursor<'c, 'a> or from a Cursor<'static>. + // + // It would not be legal to write this function without the invariant + // lifetime 'c in StepCursor<'c, 'a>. If this function were written only + // in terms of 'a, the user could take our ParseBuffer<'a>, upcast it to + // a ParseBuffer<'short> which some shorter lifetime than 'a, invoke + // `step` on their ParseBuffer<'short> with a closure that returns + // Cursor<'short>, and we would wrongly write that Cursor<'short> into + // the Cell intended to hold Cursor<'a>. + // + // In some cases it may be necessary for R to contain a Cursor<'a>. + // Within Syn we solve this using `private::advance_step_cursor` which + // uses the existence of a StepCursor<'c, 'a> as proof that it is safe + // to cast from Cursor<'c> to Cursor<'a>. If needed outside of Syn, it + // would be safe to expose that API as a method on StepCursor. + let (node, rest) = function(StepCursor { + scope: self.scope, + cursor: self.cell.get(), + marker: PhantomData, + })?; + self.cell.set(rest); + Ok(node) + } + + /// Provides low-level access to the token representation underlying this + /// parse stream. + /// + /// Cursors are immutable so no operations you perform against the cursor + /// will affect the state of this parse stream. + pub fn cursor(&self) -> Cursor<'a> { + self.cell.get() + } + + fn check_unexpected(&self) -> Result<()> { + match self.unexpected.get() { + Some(span) => Err(Error::new(span, "unexpected token")), + None => Ok(()), + } + } +} + +impl<T: Parse> Parse for Box<T> { + fn parse(input: ParseStream) -> Result<Self> { + input.parse().map(Box::new) + } +} + +impl<T: Parse + Token> Parse for Option<T> { + fn parse(input: ParseStream) -> Result<Self> { + if T::peek(input.cursor()) { + Ok(Some(input.parse()?)) + } else { + Ok(None) + } + } +} + +impl Parse for TokenStream { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| Ok((cursor.token_stream(), Cursor::empty()))) + } +} + +impl Parse for TokenTree { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| match cursor.token_tree() { + Some((tt, rest)) => Ok((tt, rest)), + None => Err(cursor.error("expected token tree")), + }) + } +} + +impl Parse for Group { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| { + for delim in &[Delimiter::Parenthesis, Delimiter::Brace, Delimiter::Bracket] { + if let Some((inside, span, rest)) = cursor.group(*delim) { + let mut group = Group::new(*delim, inside.token_stream()); + group.set_span(span); + return Ok((group, rest)); + } + } + Err(cursor.error("expected group token")) + }) + } +} + +impl Parse for Punct { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| match cursor.punct() { + Some((punct, rest)) => Ok((punct, rest)), + None => Err(cursor.error("expected punctuation token")), + }) + } +} + +impl Parse for Literal { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| match cursor.literal() { + Some((literal, rest)) => Ok((literal, rest)), + None => Err(cursor.error("expected literal token")), + }) + } +} + +/// Parser that can parse Rust tokens into a particular syntax tree node. +/// +/// Refer to the [module documentation] for details about parsing in Syn. +/// +/// [module documentation]: self +/// +/// *This trait is available if Syn is built with the `"parsing"` feature.* +pub trait Parser: Sized { + type Output; + + /// Parse a proc-macro2 token stream into the chosen syntax tree node. + /// + /// This function will check that the input is fully parsed. If there are + /// any unparsed tokens at the end of the stream, an error is returned. + fn parse2(self, tokens: TokenStream) -> Result<Self::Output>; + + /// Parse tokens of source code into the chosen syntax tree node. + /// + /// This function will check that the input is fully parsed. If there are + /// any unparsed tokens at the end of the stream, an error is returned. + /// + /// *This method is available if Syn is built with both the `"parsing"` and + /// `"proc-macro"` features.* + #[cfg(all( + not(all(target_arch = "wasm32", any(target_os = "unknown", target_os = "wasi"))), + feature = "proc-macro" + ))] + fn parse(self, tokens: proc_macro::TokenStream) -> Result<Self::Output> { + self.parse2(proc_macro2::TokenStream::from(tokens)) + } + + /// Parse a string of Rust code into the chosen syntax tree node. + /// + /// This function will check that the input is fully parsed. If there are + /// any unparsed tokens at the end of the string, an error is returned. + /// + /// # Hygiene + /// + /// Every span in the resulting syntax tree will be set to resolve at the + /// macro call site. + fn parse_str(self, s: &str) -> Result<Self::Output> { + self.parse2(proc_macro2::TokenStream::from_str(s)?) + } + + // Not public API. + #[doc(hidden)] + fn __parse_scoped(self, scope: Span, tokens: TokenStream) -> Result<Self::Output> { + let _ = scope; + self.parse2(tokens) + } +} + +fn tokens_to_parse_buffer(tokens: &TokenBuffer) -> ParseBuffer { + let scope = Span::call_site(); + let cursor = tokens.begin(); + let unexpected = Rc::new(Cell::new(None)); + private::new_parse_buffer(scope, cursor, unexpected) +} + +impl<F, T> Parser for F +where + F: FnOnce(ParseStream) -> Result<T>, +{ + type Output = T; + + fn parse2(self, tokens: TokenStream) -> Result<T> { + let buf = TokenBuffer::new2(tokens); + let state = tokens_to_parse_buffer(&buf); + let node = self(&state)?; + state.check_unexpected()?; + if state.is_empty() { + Ok(node) + } else { + Err(state.error("unexpected token")) + } + } + + #[doc(hidden)] + fn __parse_scoped(self, scope: Span, tokens: TokenStream) -> Result<Self::Output> { + let buf = TokenBuffer::new2(tokens); + let cursor = buf.begin(); + let unexpected = Rc::new(Cell::new(None)); + let state = private::new_parse_buffer(scope, cursor, unexpected); + let node = self(&state)?; + state.check_unexpected()?; + if state.is_empty() { + Ok(node) + } else { + Err(state.error("unexpected token")) + } + } +} + +impl private { + pub fn parse_scoped<F: Parser>(f: F, scope: Span, tokens: TokenStream) -> Result<F::Output> { + f.__parse_scoped(scope, tokens) + } +} diff --git a/rust/vendor/syn-0.15.44/src/parse_macro_input.rs b/rust/vendor/syn-0.15.44/src/parse_macro_input.rs new file mode 100644 index 0000000..c70cb00 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/parse_macro_input.rs @@ -0,0 +1,106 @@ +/// Parse the input TokenStream of a macro, triggering a compile error if the +/// tokens fail to parse. +/// +/// Refer to the [`parse` module] documentation for more details about parsing +/// in Syn. +/// +/// [`parse` module]: parse/index.html +/// +/// # Intended usage +/// +/// ```edition2018 +/// extern crate proc_macro; +/// +/// use proc_macro::TokenStream; +/// use syn::{parse_macro_input, Result}; +/// use syn::parse::{Parse, ParseStream}; +/// +/// struct MyMacroInput { +/// /* ... */ +/// } +/// +/// impl Parse for MyMacroInput { +/// fn parse(input: ParseStream) -> Result<Self> { +/// /* ... */ +/// # Ok(MyMacroInput {}) +/// } +/// } +/// +/// # const IGNORE: &str = stringify! { +/// #[proc_macro] +/// # }; +/// pub fn my_macro(tokens: TokenStream) -> TokenStream { +/// let input = parse_macro_input!(tokens as MyMacroInput); +/// +/// /* ... */ +/// # "".parse().unwrap() +/// } +/// ``` +// +// TODO: change the parse module link to an intra rustdoc link, currently +// blocked on https://github.com/rust-lang/rust/issues/62830 +#[macro_export(local_inner_macros)] +macro_rules! parse_macro_input { + ($tokenstream:ident as $ty:ty) => { + match $crate::parse_macro_input::parse::<$ty>($tokenstream) { + $crate::export::Ok(data) => data, + $crate::export::Err(err) => { + return $crate::export::TokenStream::from(err.to_compile_error()); + } + } + }; + ($tokenstream:ident) => { + parse_macro_input!($tokenstream as _) + }; +} + +//////////////////////////////////////////////////////////////////////////////// +// Can parse any type that implements Parse. + +use parse::{Parse, ParseStream, Parser, Result}; +use proc_macro::TokenStream; + +// Not public API. +#[doc(hidden)] +pub fn parse<T: ParseMacroInput>(token_stream: TokenStream) -> Result<T> { + T::parse.parse(token_stream) +} + +// Not public API. +#[doc(hidden)] +pub trait ParseMacroInput: Sized { + fn parse(input: ParseStream) -> Result<Self>; +} + +impl<T: Parse> ParseMacroInput for T { + fn parse(input: ParseStream) -> Result<Self> { + <T as Parse>::parse(input) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Any other types that we want `parse_macro_input!` to be able to parse. + +#[cfg(any(feature = "full", feature = "derive"))] +use AttributeArgs; + +#[cfg(any(feature = "full", feature = "derive"))] +impl ParseMacroInput for AttributeArgs { + fn parse(input: ParseStream) -> Result<Self> { + let mut metas = Vec::new(); + + loop { + if input.is_empty() { + break; + } + let value = input.parse()?; + metas.push(value); + if input.is_empty() { + break; + } + input.parse::<Token![,]>()?; + } + + Ok(metas) + } +} diff --git a/rust/vendor/syn-0.15.44/src/parse_quote.rs b/rust/vendor/syn-0.15.44/src/parse_quote.rs new file mode 100644 index 0000000..ed5cf7d --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/parse_quote.rs @@ -0,0 +1,146 @@ +/// Quasi-quotation macro that accepts input like the [`quote!`] macro but uses +/// type inference to figure out a return type for those tokens. +/// +/// [`quote!`]: https://docs.rs/quote/0.6/quote/index.html +/// +/// The return type can be any syntax tree node that implements the [`Parse`] +/// trait. +/// +/// [`Parse`]: parse::Parse +/// +/// ```edition2018 +/// use quote::quote; +/// use syn::{parse_quote, Stmt}; +/// +/// fn main() { +/// let name = quote!(v); +/// let ty = quote!(u8); +/// +/// let stmt: Stmt = parse_quote! { +/// let #name: #ty = Default::default(); +/// }; +/// +/// println!("{:#?}", stmt); +/// } +/// ``` +/// +/// *This macro is available if Syn is built with the `"parsing"` feature, +/// although interpolation of syntax tree nodes into the quoted tokens is only +/// supported if Syn is built with the `"printing"` feature as well.* +/// +/// # Example +/// +/// The following helper function adds a bound `T: HeapSize` to every type +/// parameter `T` in the input generics. +/// +/// ```edition2018 +/// use syn::{parse_quote, Generics, GenericParam}; +/// +/// // Add a bound `T: HeapSize` to every type parameter T. +/// fn add_trait_bounds(mut generics: Generics) -> Generics { +/// for param in &mut generics.params { +/// if let GenericParam::Type(type_param) = param { +/// type_param.bounds.push(parse_quote!(HeapSize)); +/// } +/// } +/// generics +/// } +/// ``` +/// +/// # Special cases +/// +/// This macro can parse the following additional types as a special case even +/// though they do not implement the `Parse` trait. +/// +/// - [`Attribute`] — parses one attribute, allowing either outer like `#[...]` +/// or inner like `#![...]` +/// - [`Punctuated<T, P>`] — parses zero or more `T` separated by punctuation +/// `P` with optional trailing punctuation +/// +/// [`Punctuated<T, P>`]: punctuated::Punctuated +/// +/// # Panics +/// +/// Panics if the tokens fail to parse as the expected syntax tree type. The +/// caller is responsible for ensuring that the input tokens are syntactically +/// valid. +// +// TODO: allow Punctuated to be inferred as intra doc link, currently blocked on +// https://github.com/rust-lang/rust/issues/62834 +#[macro_export(local_inner_macros)] +macro_rules! parse_quote { + ($($tt:tt)*) => { + $crate::parse_quote::parse($crate::export::From::from(quote_impl!($($tt)*))) + }; +} + +#[cfg(not(syn_can_call_macro_by_path))] +#[doc(hidden)] +#[macro_export] +macro_rules! quote_impl { + ($($tt:tt)*) => { + // Require caller to have their own `#[macro_use] extern crate quote`. + quote!($($tt)*) + }; +} + +#[cfg(syn_can_call_macro_by_path)] +#[doc(hidden)] +#[macro_export] +macro_rules! quote_impl { + ($($tt:tt)*) => { + $crate::export::quote::quote!($($tt)*) + }; +} + +//////////////////////////////////////////////////////////////////////////////// +// Can parse any type that implements Parse. + +use parse::{Parse, ParseStream, Parser, Result}; +use proc_macro2::TokenStream; + +// Not public API. +#[doc(hidden)] +pub fn parse<T: ParseQuote>(token_stream: TokenStream) -> T { + let parser = T::parse; + match parser.parse2(token_stream) { + Ok(t) => t, + Err(err) => panic!("{}", err), + } +} + +// Not public API. +#[doc(hidden)] +pub trait ParseQuote: Sized { + fn parse(input: ParseStream) -> Result<Self>; +} + +impl<T: Parse> ParseQuote for T { + fn parse(input: ParseStream) -> Result<Self> { + <T as Parse>::parse(input) + } +} + +//////////////////////////////////////////////////////////////////////////////// +// Any other types that we want `parse_quote!` to be able to parse. + +use punctuated::Punctuated; +#[cfg(any(feature = "full", feature = "derive"))] +use {attr, Attribute}; + +#[cfg(any(feature = "full", feature = "derive"))] +impl ParseQuote for Attribute { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Token![#]) && input.peek2(Token![!]) { + attr::parsing::single_parse_inner(input) + } else { + attr::parsing::single_parse_outer(input) + } + } +} + +impl<T: Parse, P: Parse> ParseQuote for Punctuated<T, P> { + fn parse(input: ParseStream) -> Result<Self> { + Self::parse_terminated(input) + } +} diff --git a/rust/vendor/syn-0.15.44/src/path.rs b/rust/vendor/syn-0.15.44/src/path.rs new file mode 100644 index 0000000..6e891b9 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/path.rs @@ -0,0 +1,704 @@ +use super::*; +use punctuated::Punctuated; + +ast_struct! { + /// A path at which a named item is exported: `std::collections::HashMap`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + 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 + } +} + +ast_struct! { + /// A segment of a path together with any path arguments on that segment. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + 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. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// ## Angle bracketed + /// + /// The `<'a, T>` in `std::slice::iter<'a, T>`. + /// + /// ## Parenthesized + /// + /// The `(A, B) -> C` in `Fn(A, B) -> C`. + 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(ref bracketed) => bracketed.args.is_empty(), + PathArguments::Parenthesized(_) => false, + } + } + + #[cfg(feature = "parsing")] + 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`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum GenericArgument { + /// A lifetime argument. + Lifetime(Lifetime), + /// A type argument. + Type(Type), + /// A binding (equality constraint) on an associated type: the `Item = + /// u8` in `Iterator<Item = u8>`. + Binding(Binding), + /// An associated type bound: `Iterator<Item: Display>`. + Constraint(Constraint), + /// A const expression. Must be inside of a block. + /// + /// NOTE: Identity expressions are represented as Type arguments, as + /// they are indistinguishable syntactically. + Const(Expr), + } +} + +ast_struct! { + /// Angle bracketed arguments of a path segment: the `<K, V>` in `HashMap<K, + /// V>`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + 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: `Item = u8`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct Binding { + pub ident: Ident, + pub eq_token: Token![=], + pub ty: Type, + } +} + +ast_struct! { + /// An associated type bound: `Iterator<Item: Display>`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct Constraint { + pub ident: Ident, + 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`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + 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 + /// ``` + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + 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 mod parsing { + use super::*; + + #[cfg(feature = "full")] + use expr; + use ext::IdentExt; + use parse::{Parse, ParseStream, Result}; + + impl Parse for Path { + fn parse(input: ParseStream) -> Result<Self> { + Self::parse_helper(input, false) + } + } + + 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(Ident) && input.peek2(Token![=]) { + return Ok(GenericArgument::Binding(input.parse()?)); + } + + #[cfg(feature = "full")] + { + if input.peek(Ident) && input.peek2(Token![:]) && !input.peek2(Token![::]) { + return Ok(GenericArgument::Constraint(input.parse()?)); + } + + if input.peek(Lit) { + let lit = input.parse()?; + return Ok(GenericArgument::Const(Expr::Lit(lit))); + } + + if input.peek(token::Brace) { + let block = input.call(expr::parsing::expr_block)?; + return Ok(GenericArgument::Const(Expr::Block(block))); + } + } + + input.parse().map(GenericArgument::Type) + } + } + + impl Parse for AngleBracketedGenericArguments { + fn parse(input: ParseStream) -> Result<Self> { + Ok(AngleBracketedGenericArguments { + colon2_token: input.parse()?, + lt_token: input.parse()?, + args: { + let mut args = Punctuated::new(); + loop { + if input.peek(Token![>]) { + break; + } + let value = input.parse()?; + args.push_value(value); + if input.peek(Token![>]) { + break; + } + let punct = input.parse()?; + args.push_punct(punct); + } + args + }, + gt_token: input.parse()?, + }) + } + } + + 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)?, + output: input.call(ReturnType::without_plus)?, + }) + } + } + + 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]) + || input.peek(Token![extern]) + { + 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: ident, + arguments: PathArguments::AngleBracketed(input.parse()?), + }) + } else { + Ok(PathSegment::from(ident)) + } + } + } + + impl Parse for Binding { + fn parse(input: ParseStream) -> Result<Self> { + Ok(Binding { + ident: input.parse()?, + eq_token: input.parse()?, + ty: input.parse()?, + }) + } + } + + #[cfg(feature = "full")] + impl Parse for Constraint { + fn parse(input: ParseStream) -> Result<Self> { + Ok(Constraint { + ident: input.parse()?, + colon_token: input.parse()?, + bounds: { + let mut bounds = Punctuated::new(); + loop { + if input.peek(Token![,]) || input.peek(Token![>]) { + break; + } + let value = input.parse()?; + bounds.push_value(value); + if !input.peek(Token![+]) { + break; + } + let punct = input.parse()?; + bounds.push_punct(punct); + } + bounds + }, + }) + } + } + + impl Path { + /// Parse a `Path` containing no path arguments on any of its segments. + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + /// + /// # Example + /// + /// ```edition2018 + /// 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)?, + /// }) + /// } + /// } + /// ``` + 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]) + && !input.peek(Token![extern]) + { + 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.error("expected path")); + } else if segments.trailing_punct() { + return Err(input.error("expected path segment")); + } + segments + }, + }) + } + + /// 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. + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + pub fn is_ident<I>(&self, ident: I) -> bool + where + Ident: PartialEq<I>, + { + self.leading_colon.is_none() + && self.segments.len() == 1 + && self.segments[0].arguments.is_none() + && self.segments[0].ident == ident + } + + fn parse_helper(input: ParseStream, expr_style: bool) -> Result<Self> { + Ok(Path { + leading_colon: input.parse()?, + segments: { + let mut segments = Punctuated::new(); + let value = PathSegment::parse_helper(input, expr_style)?; + segments.push_value(value); + while input.peek(Token![::]) { + let punct: Token![::] = input.parse()?; + segments.push_punct(punct); + let value = PathSegment::parse_helper(input, expr_style)?; + segments.push_value(value); + } + segments + }, + }) + } + } + + pub 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: lt_token, + ty: Box::new(this), + position: position, + as_token: as_token, + gt_token: gt_token, + }; + Ok((Some(qself), path)) + } else { + let path = Path::parse_helper(input, expr_style)?; + Ok((None, path)) + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + + use proc_macro2::TokenStream; + use quote::ToTokens; + + use print::TokensOrDefault; + + impl ToTokens for Path { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.leading_colon.to_tokens(tokens); + self.segments.to_tokens(tokens); + } + } + + impl ToTokens for PathSegment { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.ident.to_tokens(tokens); + self.arguments.to_tokens(tokens); + } + } + + impl ToTokens for PathArguments { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + PathArguments::None => {} + PathArguments::AngleBracketed(ref arguments) => { + arguments.to_tokens(tokens); + } + PathArguments::Parenthesized(ref arguments) => { + arguments.to_tokens(tokens); + } + } + } + } + + impl ToTokens for GenericArgument { + #[cfg_attr(feature = "cargo-clippy", allow(match_same_arms))] + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + GenericArgument::Lifetime(ref lt) => lt.to_tokens(tokens), + GenericArgument::Type(ref ty) => ty.to_tokens(tokens), + GenericArgument::Binding(ref tb) => tb.to_tokens(tokens), + GenericArgument::Constraint(ref tc) => tc.to_tokens(tokens), + GenericArgument::Const(ref e) => match *e { + Expr::Lit(_) => e.to_tokens(tokens), + + // NOTE: We should probably support parsing blocks with only + // expressions in them without the full feature for const + // generics. + #[cfg(feature = "full")] + Expr::Block(_) => e.to_tokens(tokens), + + // ERROR CORRECTION: Add braces to make sure that the + // generated code is valid. + _ => token::Brace::default().surround(tokens, |tokens| { + e.to_tokens(tokens); + }), + }, + } + } + } + + 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 and consts, all before bindings, + // regardless of their order in self.args. + // + // TODO: ordering rules for const arguments vs type arguments have + // not been settled yet. https://github.com/rust-lang/rust/issues/44580 + 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::Binding(_) + | GenericArgument::Constraint(_) + | GenericArgument::Const(_) => {} + } + } + for param in self.args.pairs() { + match **param.value() { + GenericArgument::Type(_) | GenericArgument::Const(_) => { + if !trailing_or_empty { + <Token![,]>::default().to_tokens(tokens); + } + param.to_tokens(tokens); + trailing_or_empty = param.punct().is_some(); + } + GenericArgument::Lifetime(_) + | GenericArgument::Binding(_) + | GenericArgument::Constraint(_) => {} + } + } + for param in self.args.pairs() { + match **param.value() { + GenericArgument::Binding(_) | GenericArgument::Constraint(_) => { + if !trailing_or_empty { + <Token![,]>::default().to_tokens(tokens); + trailing_or_empty = true; + } + param.to_tokens(tokens); + } + GenericArgument::Lifetime(_) + | GenericArgument::Type(_) + | GenericArgument::Const(_) => {} + } + } + + self.gt_token.to_tokens(tokens); + } + } + + impl ToTokens for Binding { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.ident.to_tokens(tokens); + self.eq_token.to_tokens(tokens); + self.ty.to_tokens(tokens); + } + } + + impl ToTokens for Constraint { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.ident.to_tokens(tokens); + self.colon_token.to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + } + + 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); + } + } + + impl private { + pub fn print_path(tokens: &mut TokenStream, qself: &Option<QSelf>, path: &Path) { + let qself = match *qself { + Some(ref qself) => qself, + None => { + path.to_tokens(tokens); + return; + } + }; + qself.lt_token.to_tokens(tokens); + qself.ty.to_tokens(tokens); + + let pos = if qself.position > 0 && qself.position >= path.segments.len() { + path.segments.len() - 1 + } else { + qself.position + }; + 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); + } + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/print.rs b/rust/vendor/syn-0.15.44/src/print.rs new file mode 100644 index 0000000..90570a0 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/print.rs @@ -0,0 +1,16 @@ +use proc_macro2::TokenStream; +use quote::ToTokens; + +pub struct TokensOrDefault<'a, T: 'a>(pub &'a Option<T>); + +impl<'a, T> ToTokens for TokensOrDefault<'a, T> +where + T: ToTokens + Default, +{ + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self.0 { + Some(ref t) => t.to_tokens(tokens), + None => T::default().to_tokens(tokens), + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/punctuated.rs b/rust/vendor/syn-0.15.44/src/punctuated.rs new file mode 100644 index 0000000..50f22af --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/punctuated.rs @@ -0,0 +1,836 @@ +//! A punctuated sequence of syntax tree nodes separated by punctuation. +//! +//! Lots of things in Rust are punctuated sequences. +//! +//! - The fields of a struct are `Punctuated<Field, Token![,]>`. +//! - The segments of a path are `Punctuated<PathSegment, Token![::]>`. +//! - The bounds on a generic parameter are `Punctuated<TypeParamBound, +//! Token![+]>`. +//! - The arguments to a function call are `Punctuated<Expr, Token![,]>`. +//! +//! This module provides a common representation for these punctuated sequences +//! in the form of the [`Punctuated<T, P>`] type. We store a vector of pairs of +//! syntax tree node + punctuation, where every node in the sequence is followed +//! by punctuation except for possibly the final one. +//! +//! [`Punctuated<T, P>`]: struct.Punctuated.html +//! +//! ```text +//! a_function_call(arg1, arg2, arg3); +//! ^^^^^ ~~~~~ ^^^^ +//! ``` + +#[cfg(feature = "extra-traits")] +use std::fmt::{self, Debug}; +#[cfg(any(feature = "full", feature = "derive"))] +use std::iter; +use std::iter::FromIterator; +use std::marker::PhantomData; +use std::ops::{Index, IndexMut}; +use std::option; +use std::slice; +use std::vec; + +#[cfg(feature = "parsing")] +use parse::{Parse, ParseStream, Result}; +#[cfg(any(feature = "full", feature = "derive"))] +use private; +#[cfg(feature = "parsing")] +use token::Token; + +/// A punctuated sequence of syntax tree nodes of type `T` separated by +/// punctuation of type `P`. +/// +/// Refer to the [module documentation] for details about punctuated sequences. +/// +/// [module documentation]: self +#[cfg_attr(feature = "extra-traits", derive(Eq, PartialEq, Hash))] +#[cfg_attr(feature = "clone-impls", derive(Clone))] +pub struct Punctuated<T, P> { + inner: Vec<(T, P)>, + last: Option<Box<T>>, +} + +impl<T, P> Punctuated<T, P> { + /// Creates an empty punctuated sequence. + pub fn new() -> Punctuated<T, P> { + Punctuated { + inner: Vec::new(), + last: None, + } + } + + /// Determines whether this punctuated sequence is empty, meaning it + /// contains no syntax tree nodes or punctuation. + pub fn is_empty(&self) -> bool { + self.inner.len() == 0 && self.last.is_none() + } + + /// Returns the number of syntax tree nodes in this punctuated sequence. + /// + /// This is the number of nodes of type `T`, not counting the punctuation of + /// type `P`. + pub fn len(&self) -> usize { + self.inner.len() + if self.last.is_some() { 1 } else { 0 } + } + + /// Borrows the first punctuated pair in this sequence. + pub fn first(&self) -> Option<Pair<&T, &P>> { + self.pairs().next() + } + + /// Borrows the last punctuated pair in this sequence. + pub fn last(&self) -> Option<Pair<&T, &P>> { + if self.last.is_some() { + self.last.as_ref().map(|t| Pair::End(t.as_ref())) + } else { + self.inner + .last() + .map(|&(ref t, ref d)| Pair::Punctuated(t, d)) + } + } + + /// Mutably borrows the last punctuated pair in this sequence. + pub fn last_mut(&mut self) -> Option<Pair<&mut T, &mut P>> { + if self.last.is_some() { + self.last.as_mut().map(|t| Pair::End(t.as_mut())) + } else { + self.inner + .last_mut() + .map(|&mut (ref mut t, ref mut d)| Pair::Punctuated(t, d)) + } + } + + /// Returns an iterator over borrowed syntax tree nodes of type `&T`. + pub fn iter(&self) -> Iter<T> { + Iter { + inner: Box::new(PrivateIter { + inner: self.inner.iter(), + last: self.last.as_ref().map(Box::as_ref).into_iter(), + }), + } + } + + /// Returns an iterator over mutably borrowed syntax tree nodes of type + /// `&mut T`. + pub fn iter_mut(&mut self) -> IterMut<T> { + IterMut { + inner: Box::new(PrivateIterMut { + inner: self.inner.iter_mut(), + last: self.last.as_mut().map(Box::as_mut).into_iter(), + }), + } + } + + /// Returns an iterator over the contents of this sequence as borrowed + /// punctuated pairs. + pub fn pairs(&self) -> Pairs<T, P> { + Pairs { + inner: self.inner.iter(), + last: self.last.as_ref().map(Box::as_ref).into_iter(), + } + } + + /// Returns an iterator over the contents of this sequence as mutably + /// borrowed punctuated pairs. + pub fn pairs_mut(&mut self) -> PairsMut<T, P> { + PairsMut { + inner: self.inner.iter_mut(), + last: self.last.as_mut().map(Box::as_mut).into_iter(), + } + } + + /// Returns an iterator over the contents of this sequence as owned + /// punctuated pairs. + pub fn into_pairs(self) -> IntoPairs<T, P> { + IntoPairs { + inner: self.inner.into_iter(), + last: self.last.map(|t| *t).into_iter(), + } + } + + /// Appends a syntax tree node onto the end of this punctuated sequence. The + /// sequence must previously have a trailing punctuation. + /// + /// Use [`push`] instead if the punctuated sequence may or may not already + /// have trailing punctuation. + /// + /// [`push`]: Punctuated::push + /// + /// # Panics + /// + /// Panics if the sequence does not already have a trailing punctuation when + /// this method is called. + pub fn push_value(&mut self, value: T) { + assert!(self.empty_or_trailing()); + self.last = Some(Box::new(value)); + } + + /// Appends a trailing punctuation onto the end of this punctuated sequence. + /// The sequence must be non-empty and must not already have trailing + /// punctuation. + /// + /// # Panics + /// + /// Panics if the sequence is empty or already has a trailing punctuation. + pub fn push_punct(&mut self, punctuation: P) { + assert!(self.last.is_some()); + let last = self.last.take().unwrap(); + self.inner.push((*last, punctuation)); + } + + /// Removes the last punctuated pair from this sequence, or `None` if the + /// sequence is empty. + pub fn pop(&mut self) -> Option<Pair<T, P>> { + if self.last.is_some() { + self.last.take().map(|t| Pair::End(*t)) + } else { + self.inner.pop().map(|(t, d)| Pair::Punctuated(t, d)) + } + } + + /// Determines whether this punctuated sequence ends with a trailing + /// punctuation. + pub fn trailing_punct(&self) -> bool { + self.last.is_none() && !self.is_empty() + } + + /// Returns true if either this `Punctuated` is empty, or it has a trailing + /// punctuation. + /// + /// Equivalent to `punctuated.is_empty() || punctuated.trailing_punct()`. + pub fn empty_or_trailing(&self) -> bool { + self.last.is_none() + } + + /// Appends a syntax tree node onto the end of this punctuated sequence. + /// + /// If there is not a trailing punctuation in this sequence when this method + /// is called, the default value of punctuation type `P` is inserted before + /// the given value of type `T`. + pub fn push(&mut self, value: T) + where + P: Default, + { + if !self.empty_or_trailing() { + self.push_punct(Default::default()); + } + self.push_value(value); + } + + /// Inserts an element at position `index`. + /// + /// # Panics + /// + /// Panics if `index` is greater than the number of elements previously in + /// this punctuated sequence. + pub fn insert(&mut self, index: usize, value: T) + where + P: Default, + { + assert!(index <= self.len()); + + if index == self.len() { + self.push(value); + } else { + self.inner.insert(index, (value, Default::default())); + } + } + + /// Parses zero or more occurrences of `T` separated by punctuation of type + /// `P`, with optional trailing punctuation. + /// + /// Parsing continues until the end of this parse stream. The entire content + /// of this parse stream must consist of `T` and `P`. + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + #[cfg(feature = "parsing")] + pub fn parse_terminated(input: ParseStream) -> Result<Self> + where + T: Parse, + P: Parse, + { + Self::parse_terminated_with(input, T::parse) + } + + /// Parses zero or more occurrences of `T` using the given parse function, + /// separated by punctuation of type `P`, with optional trailing + /// punctuation. + /// + /// Like [`parse_terminated`], the entire content of this stream is expected + /// to be parsed. + /// + /// [`parse_terminated`]: Punctuated::parse_terminated + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + #[cfg(feature = "parsing")] + pub fn parse_terminated_with( + input: ParseStream, + parser: fn(ParseStream) -> Result<T>, + ) -> Result<Self> + where + P: Parse, + { + let mut punctuated = Punctuated::new(); + + loop { + if input.is_empty() { + break; + } + let value = parser(input)?; + punctuated.push_value(value); + if input.is_empty() { + break; + } + let punct = input.parse()?; + punctuated.push_punct(punct); + } + + Ok(punctuated) + } + + /// Parses one or more occurrences of `T` separated by punctuation of type + /// `P`, not accepting trailing punctuation. + /// + /// Parsing continues as long as punctuation `P` is present at the head of + /// the stream. This method returns upon parsing a `T` and observing that it + /// is not followed by a `P`, even if there are remaining tokens in the + /// stream. + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + #[cfg(feature = "parsing")] + pub fn parse_separated_nonempty(input: ParseStream) -> Result<Self> + where + T: Parse, + P: Token + Parse, + { + Self::parse_separated_nonempty_with(input, T::parse) + } + + /// Parses one or more occurrences of `T` using the given parse function, + /// separated by punctuation of type `P`, not accepting trailing + /// punctuation. + /// + /// Like [`parse_separated_nonempty`], may complete early without parsing + /// the entire content of this stream. + /// + /// [`parse_separated_nonempty`]: Punctuated::parse_separated_nonempty + /// + /// *This function is available if Syn is built with the `"parsing"` + /// feature.* + #[cfg(feature = "parsing")] + pub fn parse_separated_nonempty_with( + input: ParseStream, + parser: fn(ParseStream) -> Result<T>, + ) -> Result<Self> + where + P: Token + Parse, + { + let mut punctuated = Punctuated::new(); + + loop { + let value = parser(input)?; + punctuated.push_value(value); + if !P::peek(input.cursor()) { + break; + } + let punct = input.parse()?; + punctuated.push_punct(punct); + } + + Ok(punctuated) + } +} + +#[cfg(feature = "extra-traits")] +impl<T: Debug, P: Debug> Debug for Punctuated<T, P> { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + let mut list = f.debug_list(); + for &(ref t, ref p) in &self.inner { + list.entry(t); + list.entry(p); + } + if let Some(ref last) = self.last { + list.entry(last); + } + list.finish() + } +} + +impl<T, P> FromIterator<T> for Punctuated<T, P> +where + P: Default, +{ + fn from_iter<I: IntoIterator<Item = T>>(i: I) -> Self { + let mut ret = Punctuated::new(); + ret.extend(i); + ret + } +} + +impl<T, P> Extend<T> for Punctuated<T, P> +where + P: Default, +{ + fn extend<I: IntoIterator<Item = T>>(&mut self, i: I) { + for value in i { + self.push(value); + } + } +} + +impl<T, P> FromIterator<Pair<T, P>> for Punctuated<T, P> { + fn from_iter<I: IntoIterator<Item = Pair<T, P>>>(i: I) -> Self { + let mut ret = Punctuated::new(); + ret.extend(i); + ret + } +} + +impl<T, P> Extend<Pair<T, P>> for Punctuated<T, P> { + fn extend<I: IntoIterator<Item = Pair<T, P>>>(&mut self, i: I) { + assert!(self.empty_or_trailing()); + let mut nomore = false; + for pair in i { + if nomore { + panic!("Punctuated extended with items after a Pair::End"); + } + match pair { + Pair::Punctuated(a, b) => self.inner.push((a, b)), + Pair::End(a) => { + self.last = Some(Box::new(a)); + nomore = true; + } + } + } + } +} + +impl<T, P> IntoIterator for Punctuated<T, P> { + type Item = T; + type IntoIter = IntoIter<T, P>; + + fn into_iter(self) -> Self::IntoIter { + let mut elements = Vec::with_capacity(self.len()); + elements.extend(self.inner.into_iter().map(|pair| pair.0)); + elements.extend(self.last.map(|t| *t)); + + IntoIter { + inner: elements.into_iter(), + marker: PhantomData, + } + } +} + +impl<'a, T, P> IntoIterator for &'a Punctuated<T, P> { + type Item = &'a T; + type IntoIter = Iter<'a, T>; + + fn into_iter(self) -> Self::IntoIter { + Punctuated::iter(self) + } +} + +impl<'a, T, P> IntoIterator for &'a mut Punctuated<T, P> { + type Item = &'a mut T; + type IntoIter = IterMut<'a, T>; + + fn into_iter(self) -> Self::IntoIter { + Punctuated::iter_mut(self) + } +} + +impl<T, P> Default for Punctuated<T, P> { + fn default() -> Self { + Punctuated::new() + } +} + +/// An iterator over borrowed pairs of type `Pair<&T, &P>`. +/// +/// Refer to the [module documentation] for details about punctuated sequences. +/// +/// [module documentation]: self +pub struct Pairs<'a, T: 'a, P: 'a> { + inner: slice::Iter<'a, (T, P)>, + last: option::IntoIter<&'a T>, +} + +impl<'a, T, P> Iterator for Pairs<'a, T, P> { + type Item = Pair<&'a T, &'a P>; + + fn next(&mut self) -> Option<Self::Item> { + self.inner + .next() + .map(|&(ref t, ref p)| Pair::Punctuated(t, p)) + .or_else(|| self.last.next().map(Pair::End)) + } +} + +impl<'a, T, P> ExactSizeIterator for Pairs<'a, T, P> { + fn len(&self) -> usize { + self.inner.len() + self.last.len() + } +} + +// No Clone bound on T or P. +impl<'a, T, P> Clone for Pairs<'a, T, P> { + fn clone(&self) -> Self { + Pairs { + inner: self.inner.clone(), + last: self.last.clone(), + } + } +} + +/// An iterator over mutably borrowed pairs of type `Pair<&mut T, &mut P>`. +/// +/// Refer to the [module documentation] for details about punctuated sequences. +/// +/// [module documentation]: self +pub struct PairsMut<'a, T: 'a, P: 'a> { + inner: slice::IterMut<'a, (T, P)>, + last: option::IntoIter<&'a mut T>, +} + +impl<'a, T, P> Iterator for PairsMut<'a, T, P> { + type Item = Pair<&'a mut T, &'a mut P>; + + fn next(&mut self) -> Option<Self::Item> { + self.inner + .next() + .map(|&mut (ref mut t, ref mut p)| Pair::Punctuated(t, p)) + .or_else(|| self.last.next().map(Pair::End)) + } +} + +impl<'a, T, P> ExactSizeIterator for PairsMut<'a, T, P> { + fn len(&self) -> usize { + self.inner.len() + self.last.len() + } +} + +/// An iterator over owned pairs of type `Pair<T, P>`. +/// +/// Refer to the [module documentation] for details about punctuated sequences. +/// +/// [module documentation]: self +#[derive(Clone)] +pub struct IntoPairs<T, P> { + inner: vec::IntoIter<(T, P)>, + last: option::IntoIter<T>, +} + +impl<T, P> Iterator for IntoPairs<T, P> { + type Item = Pair<T, P>; + + fn next(&mut self) -> Option<Self::Item> { + self.inner + .next() + .map(|(t, p)| Pair::Punctuated(t, p)) + .or_else(|| self.last.next().map(Pair::End)) + } +} + +impl<T, P> ExactSizeIterator for IntoPairs<T, P> { + fn len(&self) -> usize { + self.inner.len() + self.last.len() + } +} + +/// An iterator over owned values of type `T`. +/// +/// Refer to the [module documentation] for details about punctuated sequences. +/// +/// [module documentation]: self +#[derive(Clone)] +pub struct IntoIter<T, P> { + inner: vec::IntoIter<T>, + + // TODO: remove P type parameter in the next breaking change + marker: PhantomData<P>, +} + +impl<T, P> Iterator for IntoIter<T, P> { + type Item = T; + + fn next(&mut self) -> Option<Self::Item> { + self.inner.next() + } +} + +impl<T, P> ExactSizeIterator for IntoIter<T, P> { + fn len(&self) -> usize { + self.inner.len() + } +} + +/// An iterator over borrowed values of type `&T`. +/// +/// Refer to the [module documentation] for details about punctuated sequences. +/// +/// [module documentation]: self +pub struct Iter<'a, T: 'a> { + // The `Item = &'a T` needs to be specified to support rustc 1.31 and older. + // On modern compilers we would be able to write just IterTrait<'a, T> where + // Item can be inferred unambiguously from the supertrait. + inner: Box<IterTrait<'a, T, Item = &'a T> + 'a>, +} + +trait IterTrait<'a, T: 'a>: ExactSizeIterator<Item = &'a T> { + fn clone_box(&self) -> Box<IterTrait<'a, T, Item = &'a T> + 'a>; +} + +struct PrivateIter<'a, T: 'a, P: 'a> { + inner: slice::Iter<'a, (T, P)>, + last: option::IntoIter<&'a T>, +} + +#[cfg(any(feature = "full", feature = "derive"))] +impl private { + pub fn empty_punctuated_iter<'a, T>() -> Iter<'a, T> { + Iter { + inner: Box::new(iter::empty()), + } + } +} + +// No Clone bound on T. +impl<'a, T> Clone for Iter<'a, T> { + fn clone(&self) -> Self { + Iter { + inner: self.inner.clone_box(), + } + } +} + +impl<'a, T> Iterator for Iter<'a, T> { + type Item = &'a T; + + fn next(&mut self) -> Option<Self::Item> { + self.inner.next() + } +} + +impl<'a, T> ExactSizeIterator for Iter<'a, T> { + fn len(&self) -> usize { + self.inner.len() + } +} + +impl<'a, T, P> Iterator for PrivateIter<'a, T, P> { + type Item = &'a T; + + fn next(&mut self) -> Option<Self::Item> { + self.inner + .next() + .map(|pair| &pair.0) + .or_else(|| self.last.next()) + } +} + +impl<'a, T, P> ExactSizeIterator for PrivateIter<'a, T, P> { + fn len(&self) -> usize { + self.inner.len() + self.last.len() + } +} + +// No Clone bound on T or P. +impl<'a, T, P> Clone for PrivateIter<'a, T, P> { + fn clone(&self) -> Self { + PrivateIter { + inner: self.inner.clone(), + last: self.last.clone(), + } + } +} + +impl<'a, T: 'a, I: 'a> IterTrait<'a, T> for I +where + I: ExactSizeIterator<Item = &'a T> + Clone, +{ + fn clone_box(&self) -> Box<IterTrait<'a, T, Item = &'a T> + 'a> { + Box::new(self.clone()) + } +} + +/// An iterator over mutably borrowed values of type `&mut T`. +/// +/// Refer to the [module documentation] for details about punctuated sequences. +/// +/// [module documentation]: self +pub struct IterMut<'a, T: 'a> { + inner: Box<ExactSizeIterator<Item = &'a mut T> + 'a>, +} + +struct PrivateIterMut<'a, T: 'a, P: 'a> { + inner: slice::IterMut<'a, (T, P)>, + last: option::IntoIter<&'a mut T>, +} + +#[cfg(any(feature = "full", feature = "derive"))] +impl private { + pub fn empty_punctuated_iter_mut<'a, T>() -> IterMut<'a, T> { + IterMut { + inner: Box::new(iter::empty()), + } + } +} + +impl<'a, T> Iterator for IterMut<'a, T> { + type Item = &'a mut T; + + fn next(&mut self) -> Option<Self::Item> { + self.inner.next() + } +} + +impl<'a, T> ExactSizeIterator for IterMut<'a, T> { + fn len(&self) -> usize { + self.inner.len() + } +} + +impl<'a, T, P> Iterator for PrivateIterMut<'a, T, P> { + type Item = &'a mut T; + + fn next(&mut self) -> Option<Self::Item> { + self.inner + .next() + .map(|pair| &mut pair.0) + .or_else(|| self.last.next()) + } +} + +impl<'a, T, P> ExactSizeIterator for PrivateIterMut<'a, T, P> { + fn len(&self) -> usize { + self.inner.len() + self.last.len() + } +} + +/// A single syntax tree node of type `T` followed by its trailing punctuation +/// of type `P` if any. +/// +/// Refer to the [module documentation] for details about punctuated sequences. +/// +/// [module documentation]: self +#[cfg_attr(feature = "clone-impls", derive(Clone))] +pub enum Pair<T, P> { + Punctuated(T, P), + End(T), +} + +impl<T, P> Pair<T, P> { + /// Extracts the syntax tree node from this punctuated pair, discarding the + /// following punctuation. + pub fn into_value(self) -> T { + match self { + Pair::Punctuated(t, _) | Pair::End(t) => t, + } + } + + /// Borrows the syntax tree node from this punctuated pair. + pub fn value(&self) -> &T { + match *self { + Pair::Punctuated(ref t, _) | Pair::End(ref t) => t, + } + } + + /// Mutably borrows the syntax tree node from this punctuated pair. + pub fn value_mut(&mut self) -> &mut T { + match *self { + Pair::Punctuated(ref mut t, _) | Pair::End(ref mut t) => t, + } + } + + /// Borrows the punctuation from this punctuated pair, unless this pair is + /// the final one and there is no trailing punctuation. + pub fn punct(&self) -> Option<&P> { + match *self { + Pair::Punctuated(_, ref d) => Some(d), + Pair::End(_) => None, + } + } + + /// Creates a punctuated pair out of a syntax tree node and an optional + /// following punctuation. + pub fn new(t: T, d: Option<P>) -> Self { + match d { + Some(d) => Pair::Punctuated(t, d), + None => Pair::End(t), + } + } + + /// Produces this punctuated pair as a tuple of syntax tree node and + /// optional following punctuation. + pub fn into_tuple(self) -> (T, Option<P>) { + match self { + Pair::Punctuated(t, d) => (t, Some(d)), + Pair::End(t) => (t, None), + } + } +} + +impl<T, P> Index<usize> for Punctuated<T, P> { + type Output = T; + + fn index(&self, index: usize) -> &Self::Output { + if index == self.len() - 1 { + match self.last { + Some(ref t) => t, + None => &self.inner[index].0, + } + } else { + &self.inner[index].0 + } + } +} + +impl<T, P> IndexMut<usize> for Punctuated<T, P> { + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + if index == self.len() - 1 { + match self.last { + Some(ref mut t) => t, + None => &mut self.inner[index].0, + } + } else { + &mut self.inner[index].0 + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + use proc_macro2::TokenStream; + use quote::{ToTokens, TokenStreamExt}; + + impl<T, P> ToTokens for Punctuated<T, P> + where + T: ToTokens, + P: ToTokens, + { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append_all(self.pairs()) + } + } + + impl<T, P> ToTokens for Pair<T, P> + where + T: ToTokens, + P: ToTokens, + { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + Pair::Punctuated(ref a, ref b) => { + a.to_tokens(tokens); + b.to_tokens(tokens); + } + Pair::End(ref a) => a.to_tokens(tokens), + } + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/sealed.rs b/rust/vendor/syn-0.15.44/src/sealed.rs new file mode 100644 index 0000000..0b11bc9 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/sealed.rs @@ -0,0 +1,4 @@ +#[cfg(feature = "parsing")] +pub mod lookahead { + pub trait Sealed: Copy {} +} diff --git a/rust/vendor/syn-0.15.44/src/span.rs b/rust/vendor/syn-0.15.44/src/span.rs new file mode 100644 index 0000000..27a7fe8 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/span.rs @@ -0,0 +1,67 @@ +use proc_macro2::Span; + +pub trait IntoSpans<S> { + fn into_spans(self) -> S; +} + +impl IntoSpans<[Span; 1]> for Span { + fn into_spans(self) -> [Span; 1] { + [self] + } +} + +impl IntoSpans<[Span; 2]> for Span { + fn into_spans(self) -> [Span; 2] { + [self, self] + } +} + +impl IntoSpans<[Span; 3]> for Span { + fn into_spans(self) -> [Span; 3] { + [self, self, self] + } +} + +impl IntoSpans<[Span; 1]> for [Span; 1] { + fn into_spans(self) -> [Span; 1] { + self + } +} + +impl IntoSpans<[Span; 2]> for [Span; 2] { + fn into_spans(self) -> [Span; 2] { + self + } +} + +impl IntoSpans<[Span; 3]> for [Span; 3] { + fn into_spans(self) -> [Span; 3] { + self + } +} + +#[cfg(feature = "parsing")] +pub trait FromSpans: Sized { + fn from_spans(spans: &[Span]) -> Self; +} + +#[cfg(feature = "parsing")] +impl FromSpans for [Span; 1] { + fn from_spans(spans: &[Span]) -> Self { + [spans[0]] + } +} + +#[cfg(feature = "parsing")] +impl FromSpans for [Span; 2] { + fn from_spans(spans: &[Span]) -> Self { + [spans[0], spans[1]] + } +} + +#[cfg(feature = "parsing")] +impl FromSpans for [Span; 3] { + fn from_spans(spans: &[Span]) -> Self { + [spans[0], spans[1], spans[2]] + } +} diff --git a/rust/vendor/syn-0.15.44/src/spanned.rs b/rust/vendor/syn-0.15.44/src/spanned.rs new file mode 100644 index 0000000..e0dd834 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/spanned.rs @@ -0,0 +1,144 @@ +//! A trait that can provide the `Span` of the complete contents of a syntax +//! tree node. +//! +//! *This module is available if Syn is built with both the `"parsing"` and +//! `"printing"` features.* +//! +//! # Example +//! +//! Suppose in a procedural macro we have a [`Type`] that we want to assert +//! implements the [`Sync`] trait. Maybe this is the type of one of the fields +//! of a struct for which we are deriving a trait implementation, and we need to +//! be able to pass a reference to one of those fields across threads. +//! +//! [`Type`]: ../enum.Type.html +//! [`Sync`]: https://doc.rust-lang.org/std/marker/trait.Sync.html +//! +//! If the field type does *not* implement `Sync` as required, we want the +//! compiler to report an error pointing out exactly which type it was. +//! +//! The following macro code takes a variable `ty` of type `Type` and produces a +//! static assertion that `Sync` is implemented for that type. +//! +//! ```edition2018 +//! # extern crate proc_macro; +//! # +//! use proc_macro::TokenStream; +//! use proc_macro2::Span; +//! use quote::quote_spanned; +//! use syn::Type; +//! use syn::spanned::Spanned; +//! +//! # const IGNORE_TOKENS: &str = stringify! { +//! #[proc_macro_derive(MyMacro)] +//! # }; +//! pub fn my_macro(input: TokenStream) -> TokenStream { +//! # let ty = get_a_type(); +//! /* ... */ +//! +//! let assert_sync = quote_spanned! {ty.span()=> +//! struct _AssertSync where #ty: Sync; +//! }; +//! +//! /* ... */ +//! # input +//! } +//! # +//! # fn get_a_type() -> Type { +//! # unimplemented!() +//! # } +//! ``` +//! +//! By inserting this `assert_sync` fragment into the output code generated by +//! our macro, the user's code will fail to compile if `ty` does not implement +//! `Sync`. The errors they would see look like the following. +//! +//! ```text +//! error[E0277]: the trait bound `*const i32: std::marker::Sync` is not satisfied +//! --> src/main.rs:10:21 +//! | +//! 10 | bad_field: *const i32, +//! | ^^^^^^^^^^ `*const i32` cannot be shared between threads safely +//! ``` +//! +//! In this technique, using the `Type`'s span for the error message makes the +//! error appear in the correct place underlining the right type. + +use proc_macro2::{Span, TokenStream}; +use quote::ToTokens; + +/// A trait that can provide the `Span` of the complete contents of a syntax +/// tree node. +/// +/// This trait is automatically implemented for all types that implement +/// [`ToTokens`] from the `quote` crate. It is sealed and cannot be implemented +/// outside of the Syn crate other than by implementing `ToTokens`. +/// +/// [`ToTokens`]: quote::ToTokens +/// +/// See the [module documentation] for an example. +/// +/// [module documentation]: self +/// +/// *This trait is available if Syn is built with both the `"parsing"` and +/// `"printing"` features.* +pub trait Spanned: private::Sealed { + /// Returns a `Span` covering the complete contents of this syntax tree + /// node, or [`Span::call_site()`] if this node is empty. + /// + /// [`Span::call_site()`]: proc_macro2::Span::call_site + fn span(&self) -> Span; +} + +mod private { + use quote::ToTokens; + pub trait Sealed {} + impl<T: ToTokens> Sealed for T {} +} + +impl<T> Spanned for T +where + T: ToTokens, +{ + fn span(&self) -> Span { + join_spans(self.into_token_stream()) + } +} + +fn join_spans(tokens: TokenStream) -> Span { + let mut iter = tokens.into_iter().filter_map(|tt| { + // FIXME: This shouldn't be required, since optimally spans should + // never be invalid. This filter_map can probably be removed when + // https://github.com/rust-lang/rust/issues/43081 is resolved. + let span = tt.span(); + let debug = format!("{:?}", span); + if debug.ends_with("bytes(0..0)") { + None + } else { + Some(span) + } + }); + + let mut joined = match iter.next() { + Some(span) => span, + None => return Span::call_site(), + }; + + #[cfg(procmacro2_semver_exempt)] + { + for next in iter { + if let Some(span) = joined.join(next) { + joined = span; + } + } + } + + #[cfg(not(procmacro2_semver_exempt))] + { + // We can't join spans without procmacro2_semver_exempt so just grab the + // first one. + joined = joined; + } + + joined +} diff --git a/rust/vendor/syn-0.15.44/src/thread.rs b/rust/vendor/syn-0.15.44/src/thread.rs new file mode 100644 index 0000000..ff47e4a --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/thread.rs @@ -0,0 +1,83 @@ +use std::fmt::{self, Debug}; + +use self::thread_id::ThreadId; + +/// ThreadBound is a Sync-maker and Send-maker that allows accessing a value +/// of type T only from the original thread on which the ThreadBound was +/// constructed. +pub struct ThreadBound<T> { + value: T, + thread_id: ThreadId, +} + +unsafe impl<T> Sync for ThreadBound<T> {} + +// Send bound requires Copy, as otherwise Drop could run in the wrong place. +unsafe impl<T: Copy> Send for ThreadBound<T> {} + +impl<T> ThreadBound<T> { + pub fn new(value: T) -> Self { + ThreadBound { + value: value, + thread_id: thread_id::current(), + } + } + + pub fn get(&self) -> Option<&T> { + if thread_id::current() == self.thread_id { + Some(&self.value) + } else { + None + } + } +} + +impl<T: Debug> Debug for ThreadBound<T> { + fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { + match self.get() { + Some(value) => Debug::fmt(value, formatter), + None => formatter.write_str("unknown"), + } + } +} + +#[cfg(syn_can_use_thread_id)] +mod thread_id { + use std::thread; + + pub use std::thread::ThreadId; + + pub fn current() -> ThreadId { + thread::current().id() + } +} + +#[cfg(not(syn_can_use_thread_id))] +mod thread_id { + #[allow(deprecated)] + use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT}; + + thread_local! { + static THREAD_ID: usize = { + #[allow(deprecated)] + static NEXT_THREAD_ID: AtomicUsize = ATOMIC_USIZE_INIT; + + // Ordering::Relaxed because our only requirement for the ids is + // that they are unique. It is okay for the compiler to rearrange + // other memory reads around this fetch. It's still an atomic + // fetch_add, so no two threads will be able to read the same value + // from it. + // + // The main thing which these orderings affect is other memory reads + // around the atomic read, which for our case are irrelevant as this + // atomic guards nothing. + NEXT_THREAD_ID.fetch_add(1, Ordering::Relaxed) + }; + } + + pub type ThreadId = usize; + + pub fn current() -> ThreadId { + THREAD_ID.with(|id| *id) + } +} diff --git a/rust/vendor/syn-0.15.44/src/token.rs b/rust/vendor/syn-0.15.44/src/token.rs new file mode 100644 index 0000000..e1d1c8d --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/token.rs @@ -0,0 +1,961 @@ +//! Tokens representing Rust punctuation, keywords, and delimiters. +//! +//! The type names in this module can be difficult to keep straight, so we +//! prefer to use the [`Token!`] macro instead. This is a type-macro that +//! expands to the token type of the given token. +//! +//! [`Token!`]: ../macro.Token.html +//! +//! # Example +//! +//! The [`ItemStatic`] syntax tree node is defined like this. +//! +//! [`ItemStatic`]: ../struct.ItemStatic.html +//! +//! ```edition2018 +//! # use syn::{Attribute, Expr, Ident, Token, Type, Visibility}; +//! # +//! pub struct ItemStatic { +//! pub attrs: Vec<Attribute>, +//! pub vis: Visibility, +//! pub static_token: Token![static], +//! pub mutability: Option<Token![mut]>, +//! pub ident: Ident, +//! pub colon_token: Token![:], +//! pub ty: Box<Type>, +//! pub eq_token: Token![=], +//! pub expr: Box<Expr>, +//! pub semi_token: Token![;], +//! } +//! ``` +//! +//! # Parsing +//! +//! Keywords and punctuation can be parsed through the [`ParseStream::parse`] +//! method. Delimiter tokens are parsed using the [`parenthesized!`], +//! [`bracketed!`] and [`braced!`] macros. +//! +//! [`ParseStream::parse`]: ../parse/struct.ParseBuffer.html#method.parse +//! [`parenthesized!`]: ../macro.parenthesized.html +//! [`bracketed!`]: ../macro.bracketed.html +//! [`braced!`]: ../macro.braced.html +//! +//! ```edition2018 +//! use syn::{Attribute, Result}; +//! use syn::parse::{Parse, ParseStream}; +//! # +//! # enum ItemStatic {} +//! +//! // Parse the ItemStatic struct shown above. +//! impl Parse for ItemStatic { +//! fn parse(input: ParseStream) -> Result<Self> { +//! # use syn::ItemStatic; +//! # fn parse(input: ParseStream) -> Result<ItemStatic> { +//! Ok(ItemStatic { +//! attrs: input.call(Attribute::parse_outer)?, +//! vis: input.parse()?, +//! static_token: input.parse()?, +//! mutability: input.parse()?, +//! ident: input.parse()?, +//! colon_token: input.parse()?, +//! ty: input.parse()?, +//! eq_token: input.parse()?, +//! expr: input.parse()?, +//! semi_token: input.parse()?, +//! }) +//! # } +//! # unimplemented!() +//! } +//! } +//! ``` +//! +//! # Other operations +//! +//! Every keyword and punctuation token supports the following operations. +//! +//! - [Peeking] — `input.peek(Token![...])` +//! +//! - [Parsing] — `input.parse::<Token![...]>()?` +//! +//! - [Printing] — `quote!( ... #the_token ... )` +//! +//! - Construction from a [`Span`] — `let the_token = Token` +//! +//! - Field access to its span — `let sp = the_token.span` +//! +//! [Peeking]: ../parse/struct.ParseBuffer.html#method.peek +//! [Parsing]: ../parse/struct.ParseBuffer.html#method.parse +//! [Printing]: https://docs.rs/quote/0.6/quote/trait.ToTokens.html +//! [`Span`]: https://docs.rs/proc-macro2/0.4/proc_macro2/struct.Span.html + +use std; +#[cfg(feature = "extra-traits")] +use std::cmp; +#[cfg(feature = "extra-traits")] +use std::fmt::{self, Debug}; +#[cfg(feature = "extra-traits")] +use std::hash::{Hash, Hasher}; +use std::ops::{Deref, DerefMut}; + +#[cfg(feature = "parsing")] +use proc_macro2::Delimiter; +#[cfg(any(feature = "parsing", feature = "printing"))] +use proc_macro2::Ident; +use proc_macro2::Span; +#[cfg(feature = "printing")] +use proc_macro2::TokenStream; +#[cfg(feature = "printing")] +use quote::{ToTokens, TokenStreamExt}; + +use self::private::WithSpan; +#[cfg(feature = "parsing")] +use buffer::Cursor; +#[cfg(feature = "parsing")] +use error::Result; +#[cfg(any(feature = "full", feature = "derive"))] +#[cfg(feature = "parsing")] +use lifetime::Lifetime; +#[cfg(any(feature = "full", feature = "derive"))] +#[cfg(feature = "parsing")] +use lit::{Lit, LitBool, LitByte, LitByteStr, LitChar, LitFloat, LitInt, LitStr}; +#[cfg(feature = "parsing")] +use lookahead; +#[cfg(feature = "parsing")] +use parse::{Parse, ParseStream}; +use span::IntoSpans; + +/// Marker trait for types that represent single tokens. +/// +/// This trait is sealed and cannot be implemented for types outside of Syn. +#[cfg(feature = "parsing")] +pub trait Token: private::Sealed { + // Not public API. + #[doc(hidden)] + fn peek(cursor: Cursor) -> bool; + + // Not public API. + #[doc(hidden)] + fn display() -> &'static str; +} + +mod private { + use proc_macro2::Span; + + #[cfg(feature = "parsing")] + pub trait Sealed {} + + /// Support writing `token.span` rather than `token.spans[0]` on tokens that + /// hold a single span. + #[repr(C)] + pub struct WithSpan { + pub span: Span, + } +} + +#[cfg(feature = "parsing")] +impl private::Sealed for Ident {} + +#[cfg(any(feature = "full", feature = "derive"))] +#[cfg(feature = "parsing")] +fn peek_impl(cursor: Cursor, peek: fn(ParseStream) -> bool) -> bool { + use std::cell::Cell; + use std::rc::Rc; + + let scope = Span::call_site(); + let unexpected = Rc::new(Cell::new(None)); + let buffer = ::private::new_parse_buffer(scope, cursor, unexpected); + peek(&buffer) +} + +#[cfg(any(feature = "full", feature = "derive"))] +macro_rules! impl_token { + ($name:ident $display:expr) => { + #[cfg(feature = "parsing")] + impl Token for $name { + fn peek(cursor: Cursor) -> bool { + fn peek(input: ParseStream) -> bool { + <$name as Parse>::parse(input).is_ok() + } + peek_impl(cursor, peek) + } + + fn display() -> &'static str { + $display + } + } + + #[cfg(feature = "parsing")] + impl private::Sealed for $name {} + }; +} + +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(Lifetime "lifetime"); +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(Lit "literal"); +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(LitStr "string literal"); +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(LitByteStr "byte string literal"); +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(LitByte "byte literal"); +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(LitChar "character literal"); +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(LitInt "integer literal"); +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(LitFloat "floating point literal"); +#[cfg(any(feature = "full", feature = "derive"))] +impl_token!(LitBool "boolean literal"); + +// Not public API. +#[doc(hidden)] +#[cfg(feature = "parsing")] +pub trait CustomToken { + fn peek(cursor: Cursor) -> bool; + fn display() -> &'static str; +} + +#[cfg(feature = "parsing")] +impl<T: CustomToken> private::Sealed for T {} + +#[cfg(feature = "parsing")] +impl<T: CustomToken> Token for T { + fn peek(cursor: Cursor) -> bool { + <Self as CustomToken>::peek(cursor) + } + + fn display() -> &'static str { + <Self as CustomToken>::display() + } +} + +macro_rules! define_keywords { + ($($token:tt pub struct $name:ident #[$doc:meta])*) => { + $( + #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))] + #[$doc] + /// + /// Don't try to remember the name of this type -- use the [`Token!`] + /// macro instead. + /// + /// [`Token!`]: crate::token + pub struct $name { + pub span: Span, + } + + #[doc(hidden)] + #[allow(non_snake_case)] + pub fn $name<S: IntoSpans<[Span; 1]>>(span: S) -> $name { + $name { + span: span.into_spans()[0], + } + } + + impl std::default::Default for $name { + fn default() -> Self { + $name { + span: Span::call_site(), + } + } + } + + #[cfg(feature = "extra-traits")] + impl Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(stringify!($name)) + } + } + + #[cfg(feature = "extra-traits")] + impl cmp::Eq for $name {} + + #[cfg(feature = "extra-traits")] + impl PartialEq for $name { + fn eq(&self, _other: &$name) -> bool { + true + } + } + + #[cfg(feature = "extra-traits")] + impl Hash for $name { + fn hash<H: Hasher>(&self, _state: &mut H) {} + } + + #[cfg(feature = "printing")] + impl ToTokens for $name { + fn to_tokens(&self, tokens: &mut TokenStream) { + printing::keyword($token, self.span, tokens); + } + } + + #[cfg(feature = "parsing")] + impl Parse for $name { + fn parse(input: ParseStream) -> Result<Self> { + Ok($name { + span: parsing::keyword(input, $token)?, + }) + } + } + + #[cfg(feature = "parsing")] + impl Token for $name { + fn peek(cursor: Cursor) -> bool { + parsing::peek_keyword(cursor, $token) + } + + fn display() -> &'static str { + concat!("`", $token, "`") + } + } + + #[cfg(feature = "parsing")] + impl private::Sealed for $name {} + )* + }; +} + +macro_rules! impl_deref_if_len_is_1 { + ($name:ident/1) => { + impl Deref for $name { + type Target = WithSpan; + + fn deref(&self) -> &Self::Target { + unsafe { &*(self as *const Self as *const WithSpan) } + } + } + + impl DerefMut for $name { + fn deref_mut(&mut self) -> &mut Self::Target { + unsafe { &mut *(self as *mut Self as *mut WithSpan) } + } + } + }; + + ($name:ident/$len:tt) => {}; +} + +macro_rules! define_punctuation_structs { + ($($token:tt pub struct $name:ident/$len:tt #[$doc:meta])*) => { + $( + #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))] + #[repr(C)] + #[$doc] + /// + /// Don't try to remember the name of this type -- use the [`Token!`] + /// macro instead. + /// + /// [`Token!`]: crate::token + pub struct $name { + pub spans: [Span; $len], + } + + #[doc(hidden)] + #[allow(non_snake_case)] + pub fn $name<S: IntoSpans<[Span; $len]>>(spans: S) -> $name { + $name { + spans: spans.into_spans(), + } + } + + impl std::default::Default for $name { + fn default() -> Self { + $name { + spans: [Span::call_site(); $len], + } + } + } + + #[cfg(feature = "extra-traits")] + impl Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(stringify!($name)) + } + } + + #[cfg(feature = "extra-traits")] + impl cmp::Eq for $name {} + + #[cfg(feature = "extra-traits")] + impl PartialEq for $name { + fn eq(&self, _other: &$name) -> bool { + true + } + } + + #[cfg(feature = "extra-traits")] + impl Hash for $name { + fn hash<H: Hasher>(&self, _state: &mut H) {} + } + + impl_deref_if_len_is_1!($name/$len); + )* + }; +} + +macro_rules! define_punctuation { + ($($token:tt pub struct $name:ident/$len:tt #[$doc:meta])*) => { + $( + define_punctuation_structs! { + $token pub struct $name/$len #[$doc] + } + + #[cfg(feature = "printing")] + impl ToTokens for $name { + fn to_tokens(&self, tokens: &mut TokenStream) { + printing::punct($token, &self.spans, tokens); + } + } + + #[cfg(feature = "parsing")] + impl Parse for $name { + fn parse(input: ParseStream) -> Result<Self> { + Ok($name { + spans: parsing::punct(input, $token)?, + }) + } + } + + #[cfg(feature = "parsing")] + impl Token for $name { + fn peek(cursor: Cursor) -> bool { + parsing::peek_punct(cursor, $token) + } + + fn display() -> &'static str { + concat!("`", $token, "`") + } + } + + #[cfg(feature = "parsing")] + impl private::Sealed for $name {} + )* + }; +} + +macro_rules! define_delimiters { + ($($token:tt pub struct $name:ident #[$doc:meta])*) => { + $( + #[cfg_attr(feature = "clone-impls", derive(Copy, Clone))] + #[$doc] + pub struct $name { + pub span: Span, + } + + #[doc(hidden)] + #[allow(non_snake_case)] + pub fn $name<S: IntoSpans<[Span; 1]>>(span: S) -> $name { + $name { + span: span.into_spans()[0], + } + } + + impl std::default::Default for $name { + fn default() -> Self { + $name { + span: Span::call_site(), + } + } + } + + #[cfg(feature = "extra-traits")] + impl Debug for $name { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + f.write_str(stringify!($name)) + } + } + + #[cfg(feature = "extra-traits")] + impl cmp::Eq for $name {} + + #[cfg(feature = "extra-traits")] + impl PartialEq for $name { + fn eq(&self, _other: &$name) -> bool { + true + } + } + + #[cfg(feature = "extra-traits")] + impl Hash for $name { + fn hash<H: Hasher>(&self, _state: &mut H) {} + } + + impl $name { + #[cfg(feature = "printing")] + pub fn surround<F>(&self, tokens: &mut TokenStream, f: F) + where + F: FnOnce(&mut TokenStream), + { + printing::delim($token, self.span, tokens, f); + } + } + + #[cfg(feature = "parsing")] + impl private::Sealed for $name {} + )* + }; +} + +define_punctuation_structs! { + "_" pub struct Underscore/1 /// `_` +} + +#[cfg(feature = "printing")] +impl ToTokens for Underscore { + fn to_tokens(&self, tokens: &mut TokenStream) { + tokens.append(Ident::new("_", self.span)); + } +} + +#[cfg(feature = "parsing")] +impl Parse for Underscore { + fn parse(input: ParseStream) -> Result<Self> { + input.step(|cursor| { + if let Some((ident, rest)) = cursor.ident() { + if ident == "_" { + return Ok((Underscore(ident.span()), rest)); + } + } + if let Some((punct, rest)) = cursor.punct() { + if punct.as_char() == '_' { + return Ok((Underscore(punct.span()), rest)); + } + } + Err(cursor.error("expected `_`")) + }) + } +} + +#[cfg(feature = "parsing")] +impl Token for Underscore { + fn peek(cursor: Cursor) -> bool { + if let Some((ident, _rest)) = cursor.ident() { + return ident == "_"; + } + if let Some((punct, _rest)) = cursor.punct() { + return punct.as_char() == '_'; + } + false + } + + fn display() -> &'static str { + "`_`" + } +} + +#[cfg(feature = "parsing")] +impl private::Sealed for Underscore {} + +#[cfg(feature = "parsing")] +impl Token for Paren { + fn peek(cursor: Cursor) -> bool { + lookahead::is_delimiter(cursor, Delimiter::Parenthesis) + } + + fn display() -> &'static str { + "parentheses" + } +} + +#[cfg(feature = "parsing")] +impl Token for Brace { + fn peek(cursor: Cursor) -> bool { + lookahead::is_delimiter(cursor, Delimiter::Brace) + } + + fn display() -> &'static str { + "curly braces" + } +} + +#[cfg(feature = "parsing")] +impl Token for Bracket { + fn peek(cursor: Cursor) -> bool { + lookahead::is_delimiter(cursor, Delimiter::Bracket) + } + + fn display() -> &'static str { + "square brackets" + } +} + +#[cfg(feature = "parsing")] +impl Token for Group { + fn peek(cursor: Cursor) -> bool { + lookahead::is_delimiter(cursor, Delimiter::None) + } + + fn display() -> &'static str { + "invisible group" + } +} + +define_keywords! { + "abstract" pub struct Abstract /// `abstract` + "as" pub struct As /// `as` + "async" pub struct Async /// `async` + "auto" pub struct Auto /// `auto` + "become" pub struct Become /// `become` + "box" pub struct Box /// `box` + "break" pub struct Break /// `break` + "const" pub struct Const /// `const` + "continue" pub struct Continue /// `continue` + "crate" pub struct Crate /// `crate` + "default" pub struct Default /// `default` + "do" pub struct Do /// `do` + "dyn" pub struct Dyn /// `dyn` + "else" pub struct Else /// `else` + "enum" pub struct Enum /// `enum` + "existential" pub struct Existential /// `existential` + "extern" pub struct Extern /// `extern` + "final" pub struct Final /// `final` + "fn" pub struct Fn /// `fn` + "for" pub struct For /// `for` + "if" pub struct If /// `if` + "impl" pub struct Impl /// `impl` + "in" pub struct In /// `in` + "let" pub struct Let /// `let` + "loop" pub struct Loop /// `loop` + "macro" pub struct Macro /// `macro` + "match" pub struct Match /// `match` + "mod" pub struct Mod /// `mod` + "move" pub struct Move /// `move` + "mut" pub struct Mut /// `mut` + "override" pub struct Override /// `override` + "priv" pub struct Priv /// `priv` + "pub" pub struct Pub /// `pub` + "ref" pub struct Ref /// `ref` + "return" pub struct Return /// `return` + "Self" pub struct SelfType /// `Self` + "self" pub struct SelfValue /// `self` + "static" pub struct Static /// `static` + "struct" pub struct Struct /// `struct` + "super" pub struct Super /// `super` + "trait" pub struct Trait /// `trait` + "try" pub struct Try /// `try` + "type" pub struct Type /// `type` + "typeof" pub struct Typeof /// `typeof` + "union" pub struct Union /// `union` + "unsafe" pub struct Unsafe /// `unsafe` + "unsized" pub struct Unsized /// `unsized` + "use" pub struct Use /// `use` + "virtual" pub struct Virtual /// `virtual` + "where" pub struct Where /// `where` + "while" pub struct While /// `while` + "yield" pub struct Yield /// `yield` +} + +define_punctuation! { + "+" pub struct Add/1 /// `+` + "+=" pub struct AddEq/2 /// `+=` + "&" pub struct And/1 /// `&` + "&&" pub struct AndAnd/2 /// `&&` + "&=" pub struct AndEq/2 /// `&=` + "@" pub struct At/1 /// `@` + "!" pub struct Bang/1 /// `!` + "^" pub struct Caret/1 /// `^` + "^=" pub struct CaretEq/2 /// `^=` + ":" pub struct Colon/1 /// `:` + "::" pub struct Colon2/2 /// `::` + "," pub struct Comma/1 /// `,` + "/" pub struct Div/1 /// `/` + "/=" pub struct DivEq/2 /// `/=` + "$" pub struct Dollar/1 /// `$` + "." pub struct Dot/1 /// `.` + ".." pub struct Dot2/2 /// `..` + "..." pub struct Dot3/3 /// `...` + "..=" pub struct DotDotEq/3 /// `..=` + "=" pub struct Eq/1 /// `=` + "==" pub struct EqEq/2 /// `==` + ">=" pub struct Ge/2 /// `>=` + ">" pub struct Gt/1 /// `>` + "<=" pub struct Le/2 /// `<=` + "<" pub struct Lt/1 /// `<` + "*=" pub struct MulEq/2 /// `*=` + "!=" pub struct Ne/2 /// `!=` + "|" pub struct Or/1 /// `|` + "|=" pub struct OrEq/2 /// `|=` + "||" pub struct OrOr/2 /// `||` + "#" pub struct Pound/1 /// `#` + "?" pub struct Question/1 /// `?` + "->" pub struct RArrow/2 /// `->` + "<-" pub struct LArrow/2 /// `<-` + "%" pub struct Rem/1 /// `%` + "%=" pub struct RemEq/2 /// `%=` + "=>" pub struct FatArrow/2 /// `=>` + ";" pub struct Semi/1 /// `;` + "<<" pub struct Shl/2 /// `<<` + "<<=" pub struct ShlEq/3 /// `<<=` + ">>" pub struct Shr/2 /// `>>` + ">>=" pub struct ShrEq/3 /// `>>=` + "*" pub struct Star/1 /// `*` + "-" pub struct Sub/1 /// `-` + "-=" pub struct SubEq/2 /// `-=` + "~" pub struct Tilde/1 /// `~` +} + +define_delimiters! { + "{" pub struct Brace /// `{...}` + "[" pub struct Bracket /// `[...]` + "(" pub struct Paren /// `(...)` + " " pub struct Group /// None-delimited group +} + +macro_rules! export_token_macro { + ($($dollar:tt)*) => { + /// A type-macro that expands to the name of the Rust type representation of a + /// given token. + /// + /// See the [token module] documentation for details and examples. + /// + /// [token module]: crate::token + // Unfortunate duplication due to a rustdoc bug. + // https://github.com/rust-lang/rust/issues/45939 + #[macro_export] + macro_rules! Token { + (abstract) => { $crate::token::Abstract }; + (as) => { $crate::token::As }; + (async) => { $crate::token::Async }; + (auto) => { $crate::token::Auto }; + (become) => { $crate::token::Become }; + (box) => { $crate::token::Box }; + (break) => { $crate::token::Break }; + (const) => { $crate::token::Const }; + (continue) => { $crate::token::Continue }; + (crate) => { $crate::token::Crate }; + (default) => { $crate::token::Default }; + (do) => { $crate::token::Do }; + (dyn) => { $crate::token::Dyn }; + (else) => { $crate::token::Else }; + (enum) => { $crate::token::Enum }; + (existential) => { $crate::token::Existential }; + (extern) => { $crate::token::Extern }; + (final) => { $crate::token::Final }; + (fn) => { $crate::token::Fn }; + (for) => { $crate::token::For }; + (if) => { $crate::token::If }; + (impl) => { $crate::token::Impl }; + (in) => { $crate::token::In }; + (let) => { $crate::token::Let }; + (loop) => { $crate::token::Loop }; + (macro) => { $crate::token::Macro }; + (match) => { $crate::token::Match }; + (mod) => { $crate::token::Mod }; + (move) => { $crate::token::Move }; + (mut) => { $crate::token::Mut }; + (override) => { $crate::token::Override }; + (priv) => { $crate::token::Priv }; + (pub) => { $crate::token::Pub }; + (ref) => { $crate::token::Ref }; + (return) => { $crate::token::Return }; + (Self) => { $crate::token::SelfType }; + (self) => { $crate::token::SelfValue }; + (static) => { $crate::token::Static }; + (struct) => { $crate::token::Struct }; + (super) => { $crate::token::Super }; + (trait) => { $crate::token::Trait }; + (try) => { $crate::token::Try }; + (type) => { $crate::token::Type }; + (typeof) => { $crate::token::Typeof }; + (union) => { $crate::token::Union }; + (unsafe) => { $crate::token::Unsafe }; + (unsized) => { $crate::token::Unsized }; + (use) => { $crate::token::Use }; + (virtual) => { $crate::token::Virtual }; + (where) => { $crate::token::Where }; + (while) => { $crate::token::While }; + (yield) => { $crate::token::Yield }; + (+) => { $crate::token::Add }; + (+=) => { $crate::token::AddEq }; + (&) => { $crate::token::And }; + (&&) => { $crate::token::AndAnd }; + (&=) => { $crate::token::AndEq }; + (@) => { $crate::token::At }; + (!) => { $crate::token::Bang }; + (^) => { $crate::token::Caret }; + (^=) => { $crate::token::CaretEq }; + (:) => { $crate::token::Colon }; + (::) => { $crate::token::Colon2 }; + (,) => { $crate::token::Comma }; + (/) => { $crate::token::Div }; + (/=) => { $crate::token::DivEq }; + (.) => { $crate::token::Dot }; + (..) => { $crate::token::Dot2 }; + (...) => { $crate::token::Dot3 }; + (..=) => { $crate::token::DotDotEq }; + (=) => { $crate::token::Eq }; + (==) => { $crate::token::EqEq }; + (>=) => { $crate::token::Ge }; + (>) => { $crate::token::Gt }; + (<=) => { $crate::token::Le }; + (<) => { $crate::token::Lt }; + (*=) => { $crate::token::MulEq }; + (!=) => { $crate::token::Ne }; + (|) => { $crate::token::Or }; + (|=) => { $crate::token::OrEq }; + (||) => { $crate::token::OrOr }; + (#) => { $crate::token::Pound }; + (?) => { $crate::token::Question }; + (->) => { $crate::token::RArrow }; + (<-) => { $crate::token::LArrow }; + (%) => { $crate::token::Rem }; + (%=) => { $crate::token::RemEq }; + (=>) => { $crate::token::FatArrow }; + (;) => { $crate::token::Semi }; + (<<) => { $crate::token::Shl }; + (<<=) => { $crate::token::ShlEq }; + (>>) => { $crate::token::Shr }; + (>>=) => { $crate::token::ShrEq }; + (*) => { $crate::token::Star }; + (-) => { $crate::token::Sub }; + (-=) => { $crate::token::SubEq }; + (~) => { $crate::token::Tilde }; + (_) => { $crate::token::Underscore }; + $($dollar => { $crate::token::Dollar };)* + } + }; +} + +#[cfg(syn_can_match_trailing_dollar)] +export_token_macro![($)]; + +// Old rustc does not support ($) => {...} as a macro rule. +#[cfg(not(syn_can_match_trailing_dollar))] +export_token_macro![]; + +// Old names. TODO: remove these re-exports in a breaking change. +// https://github.com/dtolnay/syn/issues/486 +#[doc(hidden)] +pub use self::SelfType as CapSelf; +#[doc(hidden)] +pub use self::SelfValue as Self_; + +// Not public API. +#[doc(hidden)] +#[cfg(feature = "parsing")] +pub mod parsing { + use proc_macro2::{Spacing, Span}; + + use buffer::Cursor; + use error::{Error, Result}; + use parse::ParseStream; + use span::FromSpans; + + pub fn keyword(input: ParseStream, token: &str) -> Result<Span> { + input.step(|cursor| { + if let Some((ident, rest)) = cursor.ident() { + if ident == token { + return Ok((ident.span(), rest)); + } + } + Err(cursor.error(format!("expected `{}`", token))) + }) + } + + pub fn peek_keyword(cursor: Cursor, token: &str) -> bool { + if let Some((ident, _rest)) = cursor.ident() { + ident == token + } else { + false + } + } + + pub fn punct<S: FromSpans>(input: ParseStream, token: &str) -> Result<S> { + let mut spans = [input.cursor().span(); 3]; + punct_helper(input, token, &mut spans)?; + Ok(S::from_spans(&spans)) + } + + fn punct_helper(input: ParseStream, token: &str, spans: &mut [Span; 3]) -> Result<()> { + input.step(|cursor| { + let mut cursor = *cursor; + assert!(token.len() <= spans.len()); + + for (i, ch) in token.chars().enumerate() { + match cursor.punct() { + Some((punct, rest)) => { + spans[i] = punct.span(); + if punct.as_char() != ch { + break; + } else if i == token.len() - 1 { + return Ok(((), rest)); + } else if punct.spacing() != Spacing::Joint { + break; + } + cursor = rest; + } + None => break, + } + } + + Err(Error::new(spans[0], format!("expected `{}`", token))) + }) + } + + pub fn peek_punct(mut cursor: Cursor, token: &str) -> bool { + for (i, ch) in token.chars().enumerate() { + match cursor.punct() { + Some((punct, rest)) => { + if punct.as_char() != ch { + break; + } else if i == token.len() - 1 { + return true; + } else if punct.spacing() != Spacing::Joint { + break; + } + cursor = rest; + } + None => break, + } + } + false + } +} + +// Not public API. +#[doc(hidden)] +#[cfg(feature = "printing")] +pub mod printing { + use proc_macro2::{Delimiter, Group, Ident, Punct, Spacing, Span, TokenStream}; + use quote::TokenStreamExt; + + pub fn punct(s: &str, spans: &[Span], tokens: &mut TokenStream) { + assert_eq!(s.len(), spans.len()); + + let mut chars = s.chars(); + let mut spans = spans.iter(); + let ch = chars.next_back().unwrap(); + let span = spans.next_back().unwrap(); + for (ch, span) in chars.zip(spans) { + let mut op = Punct::new(ch, Spacing::Joint); + op.set_span(*span); + tokens.append(op); + } + + let mut op = Punct::new(ch, Spacing::Alone); + op.set_span(*span); + tokens.append(op); + } + + pub fn keyword(s: &str, span: Span, tokens: &mut TokenStream) { + tokens.append(Ident::new(s, span)); + } + + pub fn delim<F>(s: &str, span: Span, tokens: &mut TokenStream, f: F) + where + F: FnOnce(&mut TokenStream), + { + let delim = match s { + "(" => Delimiter::Parenthesis, + "[" => Delimiter::Bracket, + "{" => Delimiter::Brace, + " " => Delimiter::None, + _ => panic!("unknown delimiter: {}", s), + }; + let mut inner = TokenStream::new(); + f(&mut inner); + let mut g = Group::new(delim, inner); + g.set_span(span); + tokens.append(g); + } +} diff --git a/rust/vendor/syn-0.15.44/src/tt.rs b/rust/vendor/syn-0.15.44/src/tt.rs new file mode 100644 index 0000000..72bc3c1 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/tt.rs @@ -0,0 +1,110 @@ +use std::hash::{Hash, Hasher}; + +use proc_macro2::{Delimiter, TokenStream, TokenTree}; + +pub struct TokenTreeHelper<'a>(pub &'a TokenTree); + +impl<'a> PartialEq for TokenTreeHelper<'a> { + fn eq(&self, other: &Self) -> bool { + use proc_macro2::Spacing; + + match (self.0, other.0) { + (&TokenTree::Group(ref g1), &TokenTree::Group(ref g2)) => { + match (g1.delimiter(), g2.delimiter()) { + (Delimiter::Parenthesis, Delimiter::Parenthesis) + | (Delimiter::Brace, Delimiter::Brace) + | (Delimiter::Bracket, Delimiter::Bracket) + | (Delimiter::None, Delimiter::None) => {} + _ => return false, + } + + let s1 = g1.stream().clone().into_iter(); + let mut s2 = g2.stream().clone().into_iter(); + + for item1 in s1 { + let item2 = match s2.next() { + Some(item) => item, + None => return false, + }; + if TokenTreeHelper(&item1) != TokenTreeHelper(&item2) { + return false; + } + } + s2.next().is_none() + } + (&TokenTree::Punct(ref o1), &TokenTree::Punct(ref o2)) => { + o1.as_char() == o2.as_char() + && match (o1.spacing(), o2.spacing()) { + (Spacing::Alone, Spacing::Alone) | (Spacing::Joint, Spacing::Joint) => true, + _ => false, + } + } + (&TokenTree::Literal(ref l1), &TokenTree::Literal(ref l2)) => { + l1.to_string() == l2.to_string() + } + (&TokenTree::Ident(ref s1), &TokenTree::Ident(ref s2)) => s1 == s2, + _ => false, + } + } +} + +impl<'a> Hash for TokenTreeHelper<'a> { + fn hash<H: Hasher>(&self, h: &mut H) { + use proc_macro2::Spacing; + + match *self.0 { + TokenTree::Group(ref g) => { + 0u8.hash(h); + match g.delimiter() { + Delimiter::Parenthesis => 0u8.hash(h), + Delimiter::Brace => 1u8.hash(h), + Delimiter::Bracket => 2u8.hash(h), + Delimiter::None => 3u8.hash(h), + } + + for item in g.stream().clone() { + TokenTreeHelper(&item).hash(h); + } + 0xffu8.hash(h); // terminator w/ a variant we don't normally hash + } + TokenTree::Punct(ref op) => { + 1u8.hash(h); + op.as_char().hash(h); + match op.spacing() { + Spacing::Alone => 0u8.hash(h), + Spacing::Joint => 1u8.hash(h), + } + } + TokenTree::Literal(ref lit) => (2u8, lit.to_string()).hash(h), + TokenTree::Ident(ref word) => (3u8, word).hash(h), + } + } +} + +pub struct TokenStreamHelper<'a>(pub &'a TokenStream); + +impl<'a> PartialEq for TokenStreamHelper<'a> { + fn eq(&self, other: &Self) -> bool { + let left = self.0.clone().into_iter().collect::<Vec<_>>(); + let right = other.0.clone().into_iter().collect::<Vec<_>>(); + if left.len() != right.len() { + return false; + } + for (a, b) in left.into_iter().zip(right) { + if TokenTreeHelper(&a) != TokenTreeHelper(&b) { + return false; + } + } + true + } +} + +impl<'a> Hash for TokenStreamHelper<'a> { + fn hash<H: Hasher>(&self, state: &mut H) { + let tts = self.0.clone().into_iter().collect::<Vec<_>>(); + tts.len().hash(state); + for tt in tts { + TokenTreeHelper(&tt).hash(state); + } + } +} diff --git a/rust/vendor/syn-0.15.44/src/ty.rs b/rust/vendor/syn-0.15.44/src/ty.rs new file mode 100644 index 0000000..9e6e3f3 --- /dev/null +++ b/rust/vendor/syn-0.15.44/src/ty.rs @@ -0,0 +1,997 @@ +use super::*; +use proc_macro2::TokenStream; +use punctuated::Punctuated; +#[cfg(feature = "extra-traits")] +use std::hash::{Hash, Hasher}; +#[cfg(feature = "extra-traits")] +use tt::TokenStreamHelper; + +ast_enum_of_structs! { + /// The possible types that a Rust value could have. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + /// + /// # Syntax tree enum + /// + /// This type is a [syntax tree enum]. + /// + /// [syntax tree enum]: enum.Expr.html#syntax-tree-enums + // + // TODO: change syntax-tree-enum link to an intra rustdoc link, currently + // blocked on https://github.com/rust-lang/rust/issues/62833 + pub enum Type { + /// A dynamically sized slice type: `[T]`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Slice(TypeSlice { + pub bracket_token: token::Bracket, + pub elem: Box<Type>, + }), + + /// A fixed size array type: `[T; n]`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Array(TypeArray { + pub bracket_token: token::Bracket, + pub elem: Box<Type>, + pub semi_token: Token![;], + pub len: Expr, + }), + + /// A raw pointer type: `*const T` or `*mut T`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Ptr(TypePtr { + pub star_token: Token![*], + pub const_token: Option<Token![const]>, + pub mutability: Option<Token![mut]>, + pub elem: Box<Type>, + }), + + /// A reference type: `&'a T` or `&'a mut T`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Reference(TypeReference { + pub and_token: Token![&], + pub lifetime: Option<Lifetime>, + pub mutability: Option<Token![mut]>, + pub elem: Box<Type>, + }), + + /// A bare function type: `fn(usize) -> bool`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub BareFn(TypeBareFn { + pub lifetimes: Option<BoundLifetimes>, + pub unsafety: Option<Token![unsafe]>, + pub abi: Option<Abi>, + pub fn_token: Token![fn], + pub paren_token: token::Paren, + pub inputs: Punctuated<BareFnArg, Token![,]>, + pub variadic: Option<Token![...]>, + pub output: ReturnType, + }), + + /// The never type: `!`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Never(TypeNever { + pub bang_token: Token![!], + }), + + /// A tuple type: `(A, B, C, String)`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Tuple(TypeTuple { + pub paren_token: token::Paren, + pub elems: Punctuated<Type, Token![,]>, + }), + + /// A path like `std::slice::Iter`, optionally qualified with a + /// self-type as in `<Vec<T> as SomeTrait>::Associated`. + /// + /// Type arguments are stored in the Path itself. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Path(TypePath { + pub qself: Option<QSelf>, + pub path: Path, + }), + + /// A trait object type `Bound1 + Bound2 + Bound3` where `Bound` is a + /// trait or a lifetime. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub TraitObject(TypeTraitObject { + pub dyn_token: Option<Token![dyn]>, + pub bounds: Punctuated<TypeParamBound, Token![+]>, + }), + + /// An `impl Bound1 + Bound2 + Bound3` type where `Bound` is a trait or + /// a lifetime. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub ImplTrait(TypeImplTrait { + pub impl_token: Token![impl], + pub bounds: Punctuated<TypeParamBound, Token![+]>, + }), + + /// A parenthesized type equivalent to the inner type. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Paren(TypeParen { + pub paren_token: token::Paren, + pub elem: Box<Type>, + }), + + /// A type contained within invisible delimiters. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Group(TypeGroup { + pub group_token: token::Group, + pub elem: Box<Type>, + }), + + /// Indication that a type should be inferred by the compiler: `_`. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Infer(TypeInfer { + pub underscore_token: Token![_], + }), + + /// A macro in the type position. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Macro(TypeMacro { + pub mac: Macro, + }), + + /// Tokens in type position not interpreted by Syn. + /// + /// *This type is available if Syn is built with the `"derive"` or + /// `"full"` feature.* + pub Verbatim(TypeVerbatim #manual_extra_traits { + pub tts: TokenStream, + }), + } +} + +#[cfg(feature = "extra-traits")] +impl Eq for TypeVerbatim {} + +#[cfg(feature = "extra-traits")] +impl PartialEq for TypeVerbatim { + fn eq(&self, other: &Self) -> bool { + TokenStreamHelper(&self.tts) == TokenStreamHelper(&other.tts) + } +} + +#[cfg(feature = "extra-traits")] +impl Hash for TypeVerbatim { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + TokenStreamHelper(&self.tts).hash(state); + } +} + +ast_struct! { + /// The binary interface of a function: `extern "C"`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct Abi { + pub extern_token: Token![extern], + pub name: Option<LitStr>, + } +} + +ast_struct! { + /// An argument in a function type: the `usize` in `fn(usize) -> bool`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub struct BareFnArg { + pub name: Option<(BareFnArgName, Token![:])>, + pub ty: Type, + } +} + +ast_enum! { + /// Name of an argument in a function type: the `n` in `fn(n: usize)`. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum BareFnArgName { + /// Argument given a name. + Named(Ident), + /// Argument not given a name, matched with `_`. + Wild(Token![_]), + } +} + +ast_enum! { + /// Return type of a function signature. + /// + /// *This type is available if Syn is built with the `"derive"` or `"full"` + /// feature.* + pub enum ReturnType { + /// Return type is not specified. + /// + /// Functions default to `()` and closures default to type inference. + Default, + /// A particular type is returned. + Type(Token![->], Box<Type>), + } +} + +#[cfg(feature = "parsing")] +pub mod parsing { + use super::*; + + use parse::{Parse, ParseStream, Result}; + use path; + + impl Parse for Type { + fn parse(input: ParseStream) -> Result<Self> { + ambig_ty(input, true) + } + } + + impl Type { + /// In some positions, types may not contain the `+` character, to + /// disambiguate them. For example in the expression `1 as T`, T may not + /// contain a `+` character. + /// + /// This parser does not allow a `+`, while the default parser does. + pub fn without_plus(input: ParseStream) -> Result<Self> { + ambig_ty(input, false) + } + } + + fn ambig_ty(input: ParseStream, allow_plus: bool) -> Result<Type> { + if input.peek(token::Group) { + return input.parse().map(Type::Group); + } + + let mut lifetimes = None::<BoundLifetimes>; + let mut lookahead = input.lookahead1(); + if lookahead.peek(Token![for]) { + lifetimes = input.parse()?; + lookahead = input.lookahead1(); + if !lookahead.peek(Ident) + && !lookahead.peek(Token![fn]) + && !lookahead.peek(Token![unsafe]) + && !lookahead.peek(Token![extern]) + && !lookahead.peek(Token![super]) + && !lookahead.peek(Token![self]) + && !lookahead.peek(Token![Self]) + && !lookahead.peek(Token![crate]) + { + return Err(lookahead.error()); + } + } + + if lookahead.peek(token::Paren) { + let content; + let paren_token = parenthesized!(content in input); + if content.is_empty() { + return Ok(Type::Tuple(TypeTuple { + paren_token: paren_token, + elems: Punctuated::new(), + })); + } + if content.peek(Lifetime) { + return Ok(Type::Paren(TypeParen { + paren_token: paren_token, + elem: Box::new(Type::TraitObject(content.parse()?)), + })); + } + if content.peek(Token![?]) { + return Ok(Type::TraitObject(TypeTraitObject { + dyn_token: None, + bounds: { + let mut bounds = Punctuated::new(); + bounds.push_value(TypeParamBound::Trait(TraitBound { + paren_token: Some(paren_token), + ..content.parse()? + })); + while let Some(plus) = input.parse()? { + bounds.push_punct(plus); + bounds.push_value(input.parse()?); + } + bounds + }, + })); + } + let first: Type = content.parse()?; + if content.peek(Token![,]) { + return Ok(Type::Tuple(TypeTuple { + paren_token: paren_token, + elems: { + let mut elems = Punctuated::new(); + elems.push_value(first); + elems.push_punct(content.parse()?); + let rest: Punctuated<Type, Token![,]> = + content.parse_terminated(Parse::parse)?; + elems.extend(rest); + elems + }, + })); + } + if allow_plus && input.peek(Token![+]) { + loop { + let first = match first { + Type::Path(TypePath { qself: None, path }) => { + TypeParamBound::Trait(TraitBound { + paren_token: Some(paren_token), + modifier: TraitBoundModifier::None, + lifetimes: None, + path: path, + }) + } + Type::TraitObject(TypeTraitObject { + dyn_token: None, + ref bounds, + }) => { + if bounds.len() > 1 || bounds.trailing_punct() { + break; + } + match first { + Type::TraitObject(TypeTraitObject { bounds, .. }) => { + match bounds.into_iter().next().unwrap() { + TypeParamBound::Trait(trait_bound) => { + TypeParamBound::Trait(TraitBound { + paren_token: Some(paren_token), + ..trait_bound + }) + } + other => other, + } + } + _ => unreachable!(), + } + } + _ => break, + }; + return Ok(Type::TraitObject(TypeTraitObject { + dyn_token: None, + bounds: { + let mut bounds = Punctuated::new(); + bounds.push_value(first); + while let Some(plus) = input.parse()? { + bounds.push_punct(plus); + bounds.push_value(input.parse()?); + } + bounds + }, + })); + } + } + Ok(Type::Paren(TypeParen { + paren_token: paren_token, + elem: Box::new(first), + })) + } else if lookahead.peek(Token![fn]) + || lookahead.peek(Token![unsafe]) + || lookahead.peek(Token![extern]) && !input.peek2(Token![::]) + { + let mut bare_fn: TypeBareFn = input.parse()?; + bare_fn.lifetimes = lifetimes; + Ok(Type::BareFn(bare_fn)) + } else if lookahead.peek(Ident) + || input.peek(Token![super]) + || input.peek(Token![self]) + || input.peek(Token![Self]) + || input.peek(Token![crate]) + || input.peek(Token![extern]) + || lookahead.peek(Token![::]) + || lookahead.peek(Token![<]) + { + if input.peek(Token![dyn]) { + let mut trait_object: TypeTraitObject = input.parse()?; + if lifetimes.is_some() { + match *trait_object.bounds.iter_mut().next().unwrap() { + TypeParamBound::Trait(ref mut trait_bound) => { + trait_bound.lifetimes = lifetimes; + } + TypeParamBound::Lifetime(_) => unreachable!(), + } + } + return Ok(Type::TraitObject(trait_object)); + } + + let ty: TypePath = input.parse()?; + if ty.qself.is_some() { + return Ok(Type::Path(ty)); + } + + if input.peek(Token![!]) && !input.peek(Token![!=]) { + let mut contains_arguments = false; + for segment in &ty.path.segments { + match segment.arguments { + PathArguments::None => {} + PathArguments::AngleBracketed(_) | PathArguments::Parenthesized(_) => { + contains_arguments = true; + } + } + } + + if !contains_arguments { + let bang_token: Token![!] = input.parse()?; + let (delimiter, tts) = mac::parse_delimiter(input)?; + return Ok(Type::Macro(TypeMacro { + mac: Macro { + path: ty.path, + bang_token: bang_token, + delimiter: delimiter, + tts: tts, + }, + })); + } + } + + if lifetimes.is_some() || allow_plus && input.peek(Token![+]) { + let mut bounds = Punctuated::new(); + bounds.push_value(TypeParamBound::Trait(TraitBound { + paren_token: None, + modifier: TraitBoundModifier::None, + lifetimes: lifetimes, + path: ty.path, + })); + if allow_plus { + while input.peek(Token![+]) { + bounds.push_punct(input.parse()?); + if input.peek(Token![>]) { + break; + } + bounds.push_value(input.parse()?); + } + } + return Ok(Type::TraitObject(TypeTraitObject { + dyn_token: None, + bounds: bounds, + })); + } + + Ok(Type::Path(ty)) + } else if lookahead.peek(token::Bracket) { + let content; + let bracket_token = bracketed!(content in input); + let elem: Type = content.parse()?; + if content.peek(Token![;]) { + Ok(Type::Array(TypeArray { + bracket_token: bracket_token, + elem: Box::new(elem), + semi_token: content.parse()?, + len: content.parse()?, + })) + } else { + Ok(Type::Slice(TypeSlice { + bracket_token: bracket_token, + elem: Box::new(elem), + })) + } + } else if lookahead.peek(Token![*]) { + input.parse().map(Type::Ptr) + } else if lookahead.peek(Token![&]) { + input.parse().map(Type::Reference) + } else if lookahead.peek(Token![!]) && !input.peek(Token![=]) { + input.parse().map(Type::Never) + } else if lookahead.peek(Token![impl]) { + input.parse().map(Type::ImplTrait) + } else if lookahead.peek(Token![_]) { + input.parse().map(Type::Infer) + } else if lookahead.peek(Lifetime) { + input.parse().map(Type::TraitObject) + } else { + Err(lookahead.error()) + } + } + + impl Parse for TypeSlice { + fn parse(input: ParseStream) -> Result<Self> { + let content; + Ok(TypeSlice { + bracket_token: bracketed!(content in input), + elem: content.parse()?, + }) + } + } + + impl Parse for TypeArray { + fn parse(input: ParseStream) -> Result<Self> { + let content; + Ok(TypeArray { + bracket_token: bracketed!(content in input), + elem: content.parse()?, + semi_token: content.parse()?, + len: content.parse()?, + }) + } + } + + impl Parse for TypePtr { + fn parse(input: ParseStream) -> Result<Self> { + let star_token: Token![*] = input.parse()?; + + let lookahead = input.lookahead1(); + let (const_token, mutability) = if lookahead.peek(Token![const]) { + (Some(input.parse()?), None) + } else if lookahead.peek(Token![mut]) { + (None, Some(input.parse()?)) + } else { + return Err(lookahead.error()); + }; + + Ok(TypePtr { + star_token: star_token, + const_token: const_token, + mutability: mutability, + elem: Box::new(input.call(Type::without_plus)?), + }) + } + } + + impl Parse for TypeReference { + fn parse(input: ParseStream) -> Result<Self> { + Ok(TypeReference { + and_token: input.parse()?, + lifetime: input.parse()?, + mutability: input.parse()?, + // & binds tighter than +, so we don't allow + here. + elem: Box::new(input.call(Type::without_plus)?), + }) + } + } + + impl Parse for TypeBareFn { + fn parse(input: ParseStream) -> Result<Self> { + let args; + let allow_variadic; + Ok(TypeBareFn { + lifetimes: input.parse()?, + unsafety: input.parse()?, + abi: input.parse()?, + fn_token: input.parse()?, + paren_token: parenthesized!(args in input), + inputs: { + let mut inputs = Punctuated::new(); + while !args.is_empty() && !args.peek(Token![...]) { + inputs.push_value(args.parse()?); + if args.is_empty() { + break; + } + inputs.push_punct(args.parse()?); + } + allow_variadic = inputs.empty_or_trailing(); + inputs + }, + variadic: { + if allow_variadic && args.peek(Token![...]) { + Some(args.parse()?) + } else { + None + } + }, + output: input.call(ReturnType::without_plus)?, + }) + } + } + + impl Parse for TypeNever { + fn parse(input: ParseStream) -> Result<Self> { + Ok(TypeNever { + bang_token: input.parse()?, + }) + } + } + + impl Parse for TypeInfer { + fn parse(input: ParseStream) -> Result<Self> { + Ok(TypeInfer { + underscore_token: input.parse()?, + }) + } + } + + impl Parse for TypeTuple { + fn parse(input: ParseStream) -> Result<Self> { + let content; + Ok(TypeTuple { + paren_token: parenthesized!(content in input), + elems: content.parse_terminated(Type::parse)?, + }) + } + } + + impl Parse for TypeMacro { + fn parse(input: ParseStream) -> Result<Self> { + Ok(TypeMacro { + mac: input.parse()?, + }) + } + } + + impl Parse for TypePath { + fn parse(input: ParseStream) -> Result<Self> { + let (qself, mut path) = path::parsing::qpath(input, false)?; + + if path.segments.last().unwrap().value().arguments.is_empty() + && input.peek(token::Paren) + { + let args: ParenthesizedGenericArguments = input.parse()?; + let parenthesized = PathArguments::Parenthesized(args); + path.segments.last_mut().unwrap().value_mut().arguments = parenthesized; + } + + Ok(TypePath { + qself: qself, + path: path, + }) + } + } + + impl ReturnType { + pub fn without_plus(input: ParseStream) -> Result<Self> { + Self::parse(input, false) + } + + pub fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> { + if input.peek(Token![->]) { + let arrow = input.parse()?; + let ty = ambig_ty(input, allow_plus)?; + Ok(ReturnType::Type(arrow, Box::new(ty))) + } else { + Ok(ReturnType::Default) + } + } + } + + impl Parse for ReturnType { + fn parse(input: ParseStream) -> Result<Self> { + Self::parse(input, true) + } + } + + impl Parse for TypeTraitObject { + fn parse(input: ParseStream) -> Result<Self> { + Self::parse(input, true) + } + } + + fn at_least_one_type(bounds: &Punctuated<TypeParamBound, Token![+]>) -> bool { + for bound in bounds { + if let TypeParamBound::Trait(_) = *bound { + return true; + } + } + false + } + + impl TypeTraitObject { + pub fn without_plus(input: ParseStream) -> Result<Self> { + Self::parse(input, false) + } + + // Only allow multiple trait references if allow_plus is true. + pub fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> { + Ok(TypeTraitObject { + dyn_token: input.parse()?, + bounds: { + let mut bounds = Punctuated::new(); + if allow_plus { + loop { + bounds.push_value(input.parse()?); + if !input.peek(Token![+]) { + break; + } + bounds.push_punct(input.parse()?); + if input.peek(Token![>]) { + break; + } + } + } else { + bounds.push_value(input.parse()?); + } + // Just lifetimes like `'a + 'b` is not a TraitObject. + if !at_least_one_type(&bounds) { + return Err(input.error("expected at least one type")); + } + bounds + }, + }) + } + } + + impl Parse for TypeImplTrait { + fn parse(input: ParseStream) -> Result<Self> { + Ok(TypeImplTrait { + impl_token: input.parse()?, + // NOTE: rust-lang/rust#34511 includes discussion about whether + // or not + should be allowed in ImplTrait directly without (). + bounds: { + let mut bounds = Punctuated::new(); + loop { + bounds.push_value(input.parse()?); + if !input.peek(Token![+]) { + break; + } + bounds.push_punct(input.parse()?); + } + bounds + }, + }) + } + } + + impl Parse for TypeGroup { + fn parse(input: ParseStream) -> Result<Self> { + let group = private::parse_group(input)?; + Ok(TypeGroup { + group_token: group.token, + elem: group.content.parse()?, + }) + } + } + + impl Parse for TypeParen { + fn parse(input: ParseStream) -> Result<Self> { + Self::parse(input, false) + } + } + + impl TypeParen { + fn parse(input: ParseStream, allow_plus: bool) -> Result<Self> { + let content; + Ok(TypeParen { + paren_token: parenthesized!(content in input), + elem: Box::new(ambig_ty(&content, allow_plus)?), + }) + } + } + + impl Parse for BareFnArg { + fn parse(input: ParseStream) -> Result<Self> { + Ok(BareFnArg { + name: { + if (input.peek(Ident) || input.peek(Token![_])) + && !input.peek2(Token![::]) + && input.peek2(Token![:]) + { + let name: BareFnArgName = input.parse()?; + let colon: Token![:] = input.parse()?; + Some((name, colon)) + } else { + None + } + }, + ty: input.parse()?, + }) + } + } + + impl Parse for BareFnArgName { + fn parse(input: ParseStream) -> Result<Self> { + let lookahead = input.lookahead1(); + if lookahead.peek(Ident) { + input.parse().map(BareFnArgName::Named) + } else if lookahead.peek(Token![_]) { + input.parse().map(BareFnArgName::Wild) + } else { + Err(lookahead.error()) + } + } + } + + impl Parse for Abi { + fn parse(input: ParseStream) -> Result<Self> { + Ok(Abi { + extern_token: input.parse()?, + name: input.parse()?, + }) + } + } + + impl Parse for Option<Abi> { + fn parse(input: ParseStream) -> Result<Self> { + if input.peek(Token![extern]) { + input.parse().map(Some) + } else { + Ok(None) + } + } + } +} + +#[cfg(feature = "printing")] +mod printing { + use super::*; + + use proc_macro2::TokenStream; + use quote::ToTokens; + + use print::TokensOrDefault; + + impl ToTokens for TypeSlice { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.bracket_token.surround(tokens, |tokens| { + self.elem.to_tokens(tokens); + }); + } + } + + impl ToTokens for TypeArray { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.bracket_token.surround(tokens, |tokens| { + self.elem.to_tokens(tokens); + self.semi_token.to_tokens(tokens); + self.len.to_tokens(tokens); + }); + } + } + + impl ToTokens for TypePtr { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.star_token.to_tokens(tokens); + match self.mutability { + Some(ref tok) => tok.to_tokens(tokens), + None => { + TokensOrDefault(&self.const_token).to_tokens(tokens); + } + } + self.elem.to_tokens(tokens); + } + } + + impl ToTokens for TypeReference { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.and_token.to_tokens(tokens); + self.lifetime.to_tokens(tokens); + self.mutability.to_tokens(tokens); + self.elem.to_tokens(tokens); + } + } + + impl ToTokens for TypeBareFn { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.lifetimes.to_tokens(tokens); + self.unsafety.to_tokens(tokens); + self.abi.to_tokens(tokens); + self.fn_token.to_tokens(tokens); + self.paren_token.surround(tokens, |tokens| { + self.inputs.to_tokens(tokens); + if let Some(ref variadic) = self.variadic { + if !self.inputs.empty_or_trailing() { + let span = variadic.spans[0]; + Token.to_tokens(tokens); + } + variadic.to_tokens(tokens); + } + }); + self.output.to_tokens(tokens); + } + } + + impl ToTokens for TypeNever { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.bang_token.to_tokens(tokens); + } + } + + impl ToTokens for TypeTuple { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.paren_token.surround(tokens, |tokens| { + self.elems.to_tokens(tokens); + }); + } + } + + impl ToTokens for TypePath { + fn to_tokens(&self, tokens: &mut TokenStream) { + private::print_path(tokens, &self.qself, &self.path); + } + } + + impl ToTokens for TypeTraitObject { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.dyn_token.to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + } + + impl ToTokens for TypeImplTrait { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.impl_token.to_tokens(tokens); + self.bounds.to_tokens(tokens); + } + } + + impl ToTokens for TypeGroup { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.group_token.surround(tokens, |tokens| { + self.elem.to_tokens(tokens); + }); + } + } + + impl ToTokens for TypeParen { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.paren_token.surround(tokens, |tokens| { + self.elem.to_tokens(tokens); + }); + } + } + + impl ToTokens for TypeInfer { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.underscore_token.to_tokens(tokens); + } + } + + impl ToTokens for TypeMacro { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.mac.to_tokens(tokens); + } + } + + impl ToTokens for TypeVerbatim { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.tts.to_tokens(tokens); + } + } + + impl ToTokens for ReturnType { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + ReturnType::Default => {} + ReturnType::Type(ref arrow, ref ty) => { + arrow.to_tokens(tokens); + ty.to_tokens(tokens); + } + } + } + } + + impl ToTokens for BareFnArg { + fn to_tokens(&self, tokens: &mut TokenStream) { + if let Some((ref name, ref colon)) = self.name { + name.to_tokens(tokens); + colon.to_tokens(tokens); + } + self.ty.to_tokens(tokens); + } + } + + impl ToTokens for BareFnArgName { + fn to_tokens(&self, tokens: &mut TokenStream) { + match *self { + BareFnArgName::Named(ref t) => t.to_tokens(tokens), + BareFnArgName::Wild(ref t) => t.to_tokens(tokens), + } + } + } + + impl ToTokens for Abi { + fn to_tokens(&self, tokens: &mut TokenStream) { + self.extern_token.to_tokens(tokens); + self.name.to_tokens(tokens); + } + } +} |