Something went wrong. Try again.
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
Something went wrong. Try again.
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457// SPDX-License-Identifier: Apache-2.0 OR MIT
//! [![github]](https://github.com/dtolnay/quote) [![crates-io]](https://crates.io/crates/quote) [![docs-rs]](https://docs.rs/quote)//!//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs//!//! <br>//!//! This crate provides the [`quote!`] macro for turning Rust syntax tree data//! structures into tokens of source code.//!//! Procedural macros in Rust receive a stream of tokens as input, execute//! arbitrary Rust code to determine how to manipulate those tokens, and produce//! a stream of tokens to hand back to the compiler to compile into the caller's//! crate. Quasi-quoting is a solution to one piece of that — producing//! tokens to return to the compiler.//!//! The idea of quasi-quoting is that we write *code* that we treat as *data*.//! Within the `quote!` macro, we can write what looks like code to our text//! editor or IDE. We get all the benefits of the editor's brace matching,//! syntax highlighting, indentation, and maybe autocompletion. But rather than//! compiling that as code into the current crate, we can treat it as data, pass//! it around, mutate it, and eventually hand it back to the compiler as tokens//! to compile into the macro caller's crate.//!//! This crate is motivated by the procedural macro use case, but is a//! general-purpose Rust quasi-quoting library and is not specific to procedural//! macros.//!//! ```toml//! [dependencies]//! quote = "1.0"//! ```//!//! <br>//!//! # Example//!//! The following quasi-quoted block of code is something you might find in [a]//! procedural macro having to do with data structure serialization. The `#var`//! syntax performs interpolation of runtime variables into the quoted tokens.//! Check out the documentation of the [`quote!`] macro for more detail about//! the syntax. See also the [`quote_spanned!`] macro which is important for//! implementing hygienic procedural macros.//!//! [a]: https://serde.rs///!//! ```//! # use quote::quote;//! #//! # let generics = "";//! # let where_clause = "";//! # let field_ty = "";//! # let item_ty = "";//! # let path = "";//! # let value = "";//! #//! let tokens = quote! {//! struct SerializeWith #generics #where_clause {//! value: &'a #field_ty,//! phantom: core::marker::PhantomData<#item_ty>,//! }//!//! impl #generics serde::Serialize for SerializeWith #generics #where_clause {//! fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>//! where//! S: serde::Serializer,//! {//! #path(self.value, serializer)//! }//! }//!//! SerializeWith {//! value: #value,//! phantom: core::marker::PhantomData::<#item_ty>,//! }//! };//! ```//!//! <br>//!//! # Non-macro code generators//!//! When using `quote` in a build.rs or main.rs and writing the output out to a//! file, consider having the code generator pass the tokens through//! [prettyplease] before writing. This way if an error occurs in the generated//! code it is convenient for a human to read and debug.//!//! [prettyplease]: https://github.com/dtolnay/prettyplease
// Quote types in rustdoc of other crates get linked to here.#![doc(html_root_url = "https://docs.rs/quote/1.0.40")]#![allow( clippy::doc_markdown, clippy::elidable_lifetime_names, clippy::missing_errors_doc, clippy::missing_panics_doc, clippy::module_name_repetitions, clippy::needless_lifetimes, // false positive https://github.com/rust-lang/rust-clippy/issues/6983 clippy::wrong_self_convention,)]
extern crate alloc;
#[cfg(feature = "proc-macro")]extern crate proc_macro;
mod ext;mod format;mod ident_fragment;mod to_tokens;
// Not public API.#[doc(hidden)]#[path = "runtime.rs"]pub mod __private;
pub use crate::ext::TokenStreamExt;pub use crate::ident_fragment::IdentFragment;pub use crate::to_tokens::ToTokens;
// Not public API.#[doc(hidden)]pub mod spanned;
macro_rules! __quote { ($quote:item) => { /// The whole point. /// /// Performs variable interpolation against the input and produces it as /// [`proc_macro2::TokenStream`]. /// /// Note: for returning tokens to the compiler in a procedural macro, use /// `.into()` on the result to convert to [`proc_macro::TokenStream`]. /// /// <br> /// /// # Interpolation /// /// Variable interpolation is done with `#var` (similar to `$var` in /// `macro_rules!` macros). This grabs the `var` variable that is currently in /// scope and inserts it in that location in the output tokens. Any type /// implementing the [`ToTokens`] trait can be interpolated. This includes most /// Rust primitive types as well as most of the syntax tree types from the [Syn] /// crate. /// /// [Syn]: https://github.com/dtolnay/syn /// /// Repetition is done using `#(...)*` or `#(...),*` again similar to /// `macro_rules!`. This iterates through the elements of any variable /// interpolated within the repetition and inserts a copy of the repetition body /// for each one. The variables in an interpolation may be a `Vec`, slice, /// `BTreeSet`, or any `Iterator`. /// /// - `#(#var)*` — no separators /// - `#(#var),*` — the character before the asterisk is used as a separator /// - `#( struct #var; )*` — the repetition can contain other tokens /// - `#( #k => println!("{}", #v), )*` — even multiple interpolations /// /// <br> /// /// # Hygiene /// /// Any interpolated tokens preserve the `Span` information provided by their /// `ToTokens` implementation. Tokens that originate within the `quote!` /// invocation are spanned with [`Span::call_site()`]. /// /// [`Span::call_site()`]: proc_macro2::Span::call_site /// /// A different span can be provided through the [`quote_spanned!`] macro. /// /// <br> /// /// # Return type /// /// The macro evaluates to an expression of type `proc_macro2::TokenStream`. /// Meanwhile Rust procedural macros are expected to return the type /// `proc_macro::TokenStream`. /// /// The difference between the two types is that `proc_macro` types are entirely /// specific to procedural macros and cannot ever exist in code outside of a /// procedural macro, while `proc_macro2` types may exist anywhere including /// tests and non-macro code like main.rs and build.rs. This is why even the /// procedural macro ecosystem is largely built around `proc_macro2`, because /// that ensures the libraries are unit testable and accessible in non-macro /// contexts. /// /// There is a [`From`]-conversion in both directions so returning the output of /// `quote!` from a procedural macro usually looks like `tokens.into()` or /// `proc_macro::TokenStream::from(tokens)`. /// /// <br> /// /// # Examples /// /// ### Procedural macro /// /// The structure of a basic procedural macro is as follows. Refer to the [Syn] /// crate for further useful guidance on using `quote!` as part of a procedural /// macro. /// /// [Syn]: https://github.com/dtolnay/syn /// /// ``` /// # #[cfg(any())] /// extern crate proc_macro; /// # extern crate proc_macro2; /// /// # #[cfg(any())] /// use proc_macro::TokenStream; /// # use proc_macro2::TokenStream; /// use quote::quote; /// /// # const IGNORE_TOKENS: &'static str = stringify! { /// #[proc_macro_derive(HeapSize)] /// # }; /// pub fn derive_heap_size(input: TokenStream) -> TokenStream { /// // Parse the input and figure out what implementation to generate... /// # const IGNORE_TOKENS: &'static str = stringify! { /// let name = /* ... */; /// let expr = /* ... */; /// # }; /// # /// # let name = 0; /// # let expr = 0; /// /// let expanded = quote! { /// // The generated impl. /// impl heapsize::HeapSize for #name { /// fn heap_size_of_children(&self) -> usize { /// #expr /// } /// } /// }; /// /// // Hand the output tokens back to the compiler. /// TokenStream::from(expanded) /// } /// ``` /// /// <p><br></p> /// /// ### Combining quoted fragments /// /// Usually you don't end up constructing an entire final `TokenStream` in one /// piece. Different parts may come from different helper functions. The tokens /// produced by `quote!` themselves implement `ToTokens` and so can be /// interpolated into later `quote!` invocations to build up a final result. /// /// ``` /// # use quote::quote; /// # /// let type_definition = quote! {...}; /// let methods = quote! {...}; /// /// let tokens = quote! { /// #type_definition /// #methods /// }; /// ``` /// /// <p><br></p> /// /// ### Constructing identifiers /// /// Suppose we have an identifier `ident` which came from somewhere in a macro /// input and we need to modify it in some way for the macro output. Let's /// consider prepending the identifier with an underscore. /// /// Simply interpolating the identifier next to an underscore will not have the /// behavior of concatenating them. The underscore and the identifier will /// continue to be two separate tokens as if you had written `_ x`. /// /// ``` /// # use proc_macro2::{self as syn, Span}; /// # use quote::quote; /// # /// # let ident = syn::Ident::new("i", Span::call_site()); /// # /// // incorrect /// quote! { /// let mut _#ident = 0; /// } /// # ; /// ``` /// /// The solution is to build a new identifier token with the correct value. As /// this is such a common case, the [`format_ident!`] macro provides a /// convenient utility for doing so correctly. /// /// ``` /// # use proc_macro2::{Ident, Span}; /// # use quote::{format_ident, quote}; /// # /// # let ident = Ident::new("i", Span::call_site()); /// # /// let varname = format_ident!("_{}", ident); /// quote! { /// let mut #varname = 0; /// } /// # ; /// ``` /// /// Alternatively, the APIs provided by Syn and proc-macro2 can be used to /// directly build the identifier. This is roughly equivalent to the above, but /// will not handle `ident` being a raw identifier. /// /// ``` /// # use proc_macro2::{self as syn, Span}; /// # use quote::quote; /// # /// # let ident = syn::Ident::new("i", Span::call_site()); /// # /// let concatenated = format!("_{}", ident); /// let varname = syn::Ident::new(&concatenated, ident.span()); /// quote! { /// let mut #varname = 0; /// } /// # ; /// ``` /// /// <p><br></p> /// /// ### Making method calls /// /// Let's say our macro requires some type specified in the macro input to have /// a constructor called `new`. We have the type in a variable called /// `field_type` of type `syn::Type` and want to invoke the constructor. /// /// ``` /// # use quote::quote; /// # /// # let field_type = quote!(...); /// # /// // incorrect /// quote! { /// let value = #field_type::new(); /// } /// # ; /// ``` /// /// This works only sometimes. If `field_type` is `String`, the expanded code /// contains `String::new()` which is fine. But if `field_type` is something /// like `Vec<i32>` then the expanded code is `Vec<i32>::new()` which is invalid /// syntax. Ordinarily in handwritten Rust we would write `Vec::<i32>::new()` /// but for macros often the following is more convenient. /// /// ``` /// # use quote::quote; /// # /// # let field_type = quote!(...); /// # /// quote! { /// let value = <#field_type>::new(); /// } /// # ; /// ``` /// /// This expands to `<Vec<i32>>::new()` which behaves correctly. /// /// A similar pattern is appropriate for trait methods. /// /// ``` /// # use quote::quote; /// # /// # let field_type = quote!(...); /// # /// quote! { /// let value = <#field_type as core::default::Default>::default(); /// } /// # ; /// ``` /// /// <p><br></p> /// /// ### Interpolating text inside of doc comments /// /// Neither doc comments nor string literals get interpolation behavior in /// quote: /// /// ```compile_fail /// quote! { /// /// try to interpolate: #ident /// /// /// /// ... /// } /// ``` /// /// ```compile_fail /// quote! { /// #[doc = "try to interpolate: #ident"] /// } /// ``` /// /// Instead the best way to build doc comments that involve variables is by /// formatting the doc string literal outside of quote. /// /// ```rust /// # use proc_macro2::{Ident, Span}; /// # use quote::quote; /// # /// # const IGNORE: &str = stringify! { /// let msg = format!(...); /// # }; /// # /// # let ident = Ident::new("var", Span::call_site()); /// # let msg = format!("try to interpolate: {}", ident); /// quote! { /// #[doc = #msg] /// /// /// /// ... /// } /// # ; /// ``` /// /// <p><br></p> /// /// ### Indexing into a tuple struct /// /// When interpolating indices of a tuple or tuple struct, we need them not to /// appears suffixed as integer literals by interpolating them as [`syn::Index`] /// instead. /// /// [`syn::Index`]: https://docs.rs/syn/2.0/syn/struct.Index.html /// /// ```compile_fail /// let i = 0usize..self.fields.len(); /// /// // expands to 0 + self.0usize.heap_size() + self.1usize.heap_size() + ... /// // which is not valid syntax /// quote! { /// 0 #( + self.#i.heap_size() )* /// } /// ``` /// /// ``` /// # use proc_macro2::{Ident, TokenStream}; /// # use quote::quote; /// # /// # mod syn { /// # use proc_macro2::{Literal, TokenStream}; /// # use quote::{ToTokens, TokenStreamExt}; /// # /// # pub struct Index(usize); /// # /// # impl From<usize> for Index { /// # fn from(i: usize) -> Self { /// # Index(i) /// # } /// # } /// # /// # impl ToTokens for Index { /// # fn to_tokens(&self, tokens: &mut TokenStream) { /// # tokens.append(Literal::usize_unsuffixed(self.0)); /// # } /// # } /// # } /// # /// # struct Struct { /// # fields: Vec<Ident>, /// # } /// # /// # impl Struct { /// # fn example(&self) -> TokenStream { /// let i = (0..self.fields.len()).map(syn::Index::from); /// /// // expands to 0 + self.0.heap_size() + self.1.heap_size() + ... /// quote! { /// 0 #( + self.#i.heap_size() )* /// } /// # } /// # } /// ``` $quote };}
#[cfg(doc)]__quote![ #[macro_export] macro_rules! quote { ($($tt:tt)*) => { ... }; }];
#[cfg(not(doc))]__quote![ #[macro_export] macro_rules! quote { () => { $crate::__private::TokenStream::new() };
// Special case rule for a single tt, for performance. ($tt:tt) => {{ let mut _s = $crate::__private::TokenStream::new(); $crate::quote_token!{$tt _s} _s }};
// Special case rules for two tts, for performance. (# $var:ident) => {{ let mut _s = $crate::__private::TokenStream::new(); $crate::ToTokens::to_tokens(&$var, &mut _s); _s }}; ($tt1:tt $tt2:tt) => {{ let mut _s = $crate::__private::TokenStream::new(); $crate::quote_token!{$tt1 _s} $crate::quote_token!{$tt2 _s} _s }};
// Rule for any other number of tokens. ($($tt:tt)*) => {{ let mut _s = $crate::__private::TokenStream::new(); $crate::quote_each_token!{_s $($tt)*} _s }}; }];
macro_rules! __quote_spanned { ($quote_spanned:item) => { /// Same as `quote!`, but applies a given span to all tokens originating within /// the macro invocation. /// /// <br> /// /// # Syntax /// /// A span expression of type [`Span`], followed by `=>`, followed by the tokens /// to quote. The span expression should be brief — use a variable for /// anything more than a few characters. There should be no space before the /// `=>` token. /// /// [`Span`]: proc_macro2::Span /// /// ``` /// # use proc_macro2::Span; /// # use quote::quote_spanned; /// # /// # const IGNORE_TOKENS: &'static str = stringify! { /// let span = /* ... */; /// # }; /// # let span = Span::call_site(); /// # let init = 0; /// /// // On one line, use parentheses. /// let tokens = quote_spanned!(span=> Box::into_raw(Box::new(#init))); /// /// // On multiple lines, place the span at the top and use braces. /// let tokens = quote_spanned! {span=> /// Box::into_raw(Box::new(#init)) /// }; /// ``` /// /// The lack of space before the `=>` should look jarring to Rust programmers /// and this is intentional. The formatting is designed to be visibly /// off-balance and draw the eye a particular way, due to the span expression /// being evaluated in the context of the procedural macro and the remaining /// tokens being evaluated in the generated code. /// /// <br> /// /// # Hygiene /// /// Any interpolated tokens preserve the `Span` information provided by their /// `ToTokens` implementation. Tokens that originate within the `quote_spanned!` /// invocation are spanned with the given span argument. /// /// <br> /// /// # Example /// /// The following procedural macro code uses `quote_spanned!` to assert that a /// particular Rust type implements the [`Sync`] trait so that references can be /// safely shared between threads. /// /// ``` /// # use quote::{quote_spanned, TokenStreamExt, ToTokens}; /// # use proc_macro2::{Span, TokenStream}; /// # /// # struct Type; /// # /// # impl Type { /// # fn span(&self) -> Span { /// # Span::call_site() /// # } /// # } /// # /// # impl ToTokens for Type { /// # fn to_tokens(&self, _tokens: &mut TokenStream) {} /// # } /// # /// # let ty = Type; /// # let call_site = Span::call_site(); /// # /// let ty_span = ty.span(); /// let assert_sync = quote_spanned! {ty_span=> /// struct _AssertSync where #ty: Sync; /// }; /// ``` /// /// If the assertion fails, the user will see an error like the following. The /// input span of their type is highlighted in the error. /// /// ```text /// error[E0277]: the trait bound `*const (): std::marker::Sync` is not satisfied /// --> src/main.rs:10:21 /// | /// 10 | static ref PTR: *const () = &(); /// | ^^^^^^^^^ `*const ()` cannot be shared between threads safely /// ``` /// /// In this example it is important for the where-clause to be spanned with the /// line/column information of the user's input type so that error messages are /// placed appropriately by the compiler. $quote_spanned };}
#[cfg(doc)]__quote_spanned![ #[macro_export] macro_rules! quote_spanned { ($span:expr=> $($tt:tt)*) => { ... }; }];
#[cfg(not(doc))]__quote_spanned![ #[macro_export] macro_rules! quote_spanned { ($span:expr=>) => {{ let _: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); $crate::__private::TokenStream::new() }};
// Special case rule for a single tt, for performance. ($span:expr=> $tt:tt) => {{ let mut _s = $crate::__private::TokenStream::new(); let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); $crate::quote_token_spanned!{$tt _s _span} _s }};
// Special case rules for two tts, for performance. ($span:expr=> # $var:ident) => {{ let mut _s = $crate::__private::TokenStream::new(); let _: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); $crate::ToTokens::to_tokens(&$var, &mut _s); _s }}; ($span:expr=> $tt1:tt $tt2:tt) => {{ let mut _s = $crate::__private::TokenStream::new(); let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); $crate::quote_token_spanned!{$tt1 _s _span} $crate::quote_token_spanned!{$tt2 _s _span} _s }};
// Rule for any other number of tokens. ($span:expr=> $($tt:tt)*) => {{ let mut _s = $crate::__private::TokenStream::new(); let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span(); $crate::quote_each_token_spanned!{_s _span $($tt)*} _s }}; }];
// Extract the names of all #metavariables and pass them to the $call macro.//// in: pounded_var_names!(then!(...) a #b c #( #d )* #e)// out: then!(... b);// then!(... d);// then!(... e);#[macro_export]#[doc(hidden)]macro_rules! pounded_var_names { ($call:ident! $extra:tt $($tts:tt)*) => { $crate::pounded_var_names_with_context!{$call! $extra (@ $($tts)*) ($($tts)* @) } };}
#[macro_export]#[doc(hidden)]macro_rules! pounded_var_names_with_context { ($call:ident! $extra:tt ($($b1:tt)*) ($($curr:tt)*)) => { $( $crate::pounded_var_with_context!{$call! $extra $b1 $curr} )* };}
#[macro_export]#[doc(hidden)]macro_rules! pounded_var_with_context { ($call:ident! $extra:tt $b1:tt ( $($inner:tt)* )) => { $crate::pounded_var_names!{$call! $extra $($inner)*} };
($call:ident! $extra:tt $b1:tt [ $($inner:tt)* ]) => { $crate::pounded_var_names!{$call! $extra $($inner)*} };
($call:ident! $extra:tt $b1:tt { $($inner:tt)* }) => { $crate::pounded_var_names!{$call! $extra $($inner)*} };
($call:ident!($($extra:tt)*) # $var:ident) => { $crate::$call!($($extra)* $var); };
($call:ident! $extra:tt $b1:tt $curr:tt) => {};}
#[macro_export]#[doc(hidden)]macro_rules! quote_bind_into_iter { ($has_iter:ident $var:ident) => { // `mut` may be unused if $var occurs multiple times in the list. #[allow(unused_mut)] let (mut $var, i) = $var.quote_into_iter(); let $has_iter = $has_iter | i; };}
#[macro_export]#[doc(hidden)]macro_rules! quote_bind_next_or_break { ($var:ident) => { let $var = match $var.next() { Some(_x) => $crate::__private::RepInterp(_x), None => break, }; };}
// The obvious way to write this macro is as a tt muncher. This implementation// does something more complex for two reasons.//// - With a tt muncher it's easy to hit Rust's built-in recursion_limit, which// this implementation avoids because it isn't tail recursive.//// - Compile times for a tt muncher are quadratic relative to the length of// the input. This implementation is linear, so it will be faster// (potentially much faster) for big inputs. However, the constant factors// of this implementation are higher than that of a tt muncher, so it is// somewhat slower than a tt muncher if there are many invocations with// short inputs.//// An invocation like this://// quote_each_token!(_s a b c d e f g h i j);//// expands to this://// quote_tokens_with_context!(_s// (@ @ @ @ @ @ a b c d e f g h i j)// (@ @ @ @ @ a b c d e f g h i j @)// (@ @ @ @ a b c d e f g h i j @ @)// (@ @ @ (a) (b) (c) (d) (e) (f) (g) (h) (i) (j) @ @ @)// (@ @ a b c d e f g h i j @ @ @ @)// (@ a b c d e f g h i j @ @ @ @ @)// (a b c d e f g h i j @ @ @ @ @ @)// );//// which gets transposed and expanded to this://// quote_token_with_context!(_s @ @ @ @ @ @ a);// quote_token_with_context!(_s @ @ @ @ @ a b);// quote_token_with_context!(_s @ @ @ @ a b c);// quote_token_with_context!(_s @ @ @ (a) b c d);// quote_token_with_context!(_s @ @ a (b) c d e);// quote_token_with_context!(_s @ a b (c) d e f);// quote_token_with_context!(_s a b c (d) e f g);// quote_token_with_context!(_s b c d (e) f g h);// quote_token_with_context!(_s c d e (f) g h i);// quote_token_with_context!(_s d e f (g) h i j);// quote_token_with_context!(_s e f g (h) i j @);// quote_token_with_context!(_s f g h (i) j @ @);// quote_token_with_context!(_s g h i (j) @ @ @);// quote_token_with_context!(_s h i j @ @ @ @);// quote_token_with_context!(_s i j @ @ @ @ @);// quote_token_with_context!(_s j @ @ @ @ @ @);//// Without having used muncher-style recursion, we get one invocation of// quote_token_with_context for each original tt, with three tts of context on// either side. This is enough for the longest possible interpolation form (a// repetition with separator, as in `# (#var) , *`) to be fully represented with// the first or last tt in the middle.//// The middle tt (surrounded by parentheses) is the tt being processed.//// - When it is a `#`, quote_token_with_context can do an interpolation. The// interpolation kind will depend on the three subsequent tts.//// - When it is within a later part of an interpolation, it can be ignored// because the interpolation has already been done.//// - When it is not part of an interpolation it can be pushed as a single// token into the output.//// - When the middle token is an unparenthesized `@`, that call is one of the// first 3 or last 3 calls of quote_token_with_context and does not// correspond to one of the original input tokens, so turns into nothing.#[macro_export]#[doc(hidden)]macro_rules! quote_each_token { ($tokens:ident $($tts:tt)*) => { $crate::quote_tokens_with_context!{$tokens (@ @ @ @ @ @ $($tts)*) (@ @ @ @ @ $($tts)* @) (@ @ @ @ $($tts)* @ @) (@ @ @ $(($tts))* @ @ @) (@ @ $($tts)* @ @ @ @) (@ $($tts)* @ @ @ @ @) ($($tts)* @ @ @ @ @ @) } };}
// See the explanation on quote_each_token.#[macro_export]#[doc(hidden)]macro_rules! quote_each_token_spanned { ($tokens:ident $span:ident $($tts:tt)*) => { $crate::quote_tokens_with_context_spanned!{$tokens $span (@ @ @ @ @ @ $($tts)*) (@ @ @ @ @ $($tts)* @) (@ @ @ @ $($tts)* @ @) (@ @ @ $(($tts))* @ @ @) (@ @ $($tts)* @ @ @ @) (@ $($tts)* @ @ @ @ @) ($($tts)* @ @ @ @ @ @) } };}
// See the explanation on quote_each_token.#[macro_export]#[doc(hidden)]macro_rules! quote_tokens_with_context { ($tokens:ident ($($b3:tt)*) ($($b2:tt)*) ($($b1:tt)*) ($($curr:tt)*) ($($a1:tt)*) ($($a2:tt)*) ($($a3:tt)*) ) => { $( $crate::quote_token_with_context!{$tokens $b3 $b2 $b1 $curr $a1 $a2 $a3} )* };}
// See the explanation on quote_each_token.#[macro_export]#[doc(hidden)]macro_rules! quote_tokens_with_context_spanned { ($tokens:ident $span:ident ($($b3:tt)*) ($($b2:tt)*) ($($b1:tt)*) ($($curr:tt)*) ($($a1:tt)*) ($($a2:tt)*) ($($a3:tt)*) ) => { $( $crate::quote_token_with_context_spanned!{$tokens $span $b3 $b2 $b1 $curr $a1 $a2 $a3} )* };}
// See the explanation on quote_each_token.#[macro_export]#[doc(hidden)]macro_rules! quote_token_with_context { // Unparenthesized `@` indicates this call does not correspond to one of the // original input tokens. Ignore it. ($tokens:ident $b3:tt $b2:tt $b1:tt @ $a1:tt $a2:tt $a3:tt) => {};
// A repetition with no separator. ($tokens:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) * $a3:tt) => {{ use $crate::__private::ext::*; let has_iter = $crate::__private::ThereIsNoIteratorInRepetition; $crate::pounded_var_names!{quote_bind_into_iter!(has_iter) () $($inner)*} let _: $crate::__private::HasIterator = has_iter; // This is `while true` instead of `loop` because if there are no // iterators used inside of this repetition then the body would not // contain any `break`, so the compiler would emit unreachable code // warnings on anything below the loop. We use has_iter to detect and // fail to compile when there are no iterators, so here we just work // around the unneeded extra warning. while true { $crate::pounded_var_names!{quote_bind_next_or_break!() () $($inner)*} $crate::quote_each_token!{$tokens $($inner)*} } }}; // ... and one step later. ($tokens:ident $b3:tt $b2:tt # (( $($inner:tt)* )) * $a2:tt $a3:tt) => {}; // ... and one step later. ($tokens:ident $b3:tt # ( $($inner:tt)* ) (*) $a1:tt $a2:tt $a3:tt) => {};
// A repetition with separator. ($tokens:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) $sep:tt *) => {{ use $crate::__private::ext::*; let mut _i = 0usize; let has_iter = $crate::__private::ThereIsNoIteratorInRepetition; $crate::pounded_var_names!{quote_bind_into_iter!(has_iter) () $($inner)*} let _: $crate::__private::HasIterator = has_iter; while true { $crate::pounded_var_names!{quote_bind_next_or_break!() () $($inner)*} if _i > 0 { $crate::quote_token!{$sep $tokens} } _i += 1; $crate::quote_each_token!{$tokens $($inner)*} } }}; // ... and one step later. ($tokens:ident $b3:tt $b2:tt # (( $($inner:tt)* )) $sep:tt * $a3:tt) => {}; // ... and one step later. ($tokens:ident $b3:tt # ( $($inner:tt)* ) ($sep:tt) * $a2:tt $a3:tt) => {}; // (A special case for `#(var)**`, where the first `*` is treated as the // repetition symbol and the second `*` is treated as an ordinary token.) ($tokens:ident # ( $($inner:tt)* ) * (*) $a1:tt $a2:tt $a3:tt) => { // https://github.com/dtolnay/quote/issues/130 $crate::quote_token!{* $tokens} }; // ... and one step later. ($tokens:ident # ( $($inner:tt)* ) $sep:tt (*) $a1:tt $a2:tt $a3:tt) => {};
// A non-repetition interpolation. ($tokens:ident $b3:tt $b2:tt $b1:tt (#) $var:ident $a2:tt $a3:tt) => { $crate::ToTokens::to_tokens(&$var, &mut $tokens); }; // ... and one step later. ($tokens:ident $b3:tt $b2:tt # ($var:ident) $a1:tt $a2:tt $a3:tt) => {};
// An ordinary token, not part of any interpolation. ($tokens:ident $b3:tt $b2:tt $b1:tt ($curr:tt) $a1:tt $a2:tt $a3:tt) => { $crate::quote_token!{$curr $tokens} };}
// See the explanation on quote_each_token, and on the individual rules of// quote_token_with_context.#[macro_export]#[doc(hidden)]macro_rules! quote_token_with_context_spanned { ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt @ $a1:tt $a2:tt $a3:tt) => {};
($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) * $a3:tt) => {{ use $crate::__private::ext::*; let has_iter = $crate::__private::ThereIsNoIteratorInRepetition; $crate::pounded_var_names!{quote_bind_into_iter!(has_iter) () $($inner)*} let _: $crate::__private::HasIterator = has_iter; while true { $crate::pounded_var_names!{quote_bind_next_or_break!() () $($inner)*} $crate::quote_each_token_spanned!{$tokens $span $($inner)*} } }}; ($tokens:ident $span:ident $b3:tt $b2:tt # (( $($inner:tt)* )) * $a2:tt $a3:tt) => {}; ($tokens:ident $span:ident $b3:tt # ( $($inner:tt)* ) (*) $a1:tt $a2:tt $a3:tt) => {};
($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) $sep:tt *) => {{ use $crate::__private::ext::*; let mut _i = 0usize; let has_iter = $crate::__private::ThereIsNoIteratorInRepetition; $crate::pounded_var_names!{quote_bind_into_iter!(has_iter) () $($inner)*} let _: $crate::__private::HasIterator = has_iter; while true { $crate::pounded_var_names!{quote_bind_next_or_break!() () $($inner)*} if _i > 0 { $crate::quote_token_spanned!{$sep $tokens $span} } _i += 1; $crate::quote_each_token_spanned!{$tokens $span $($inner)*} } }}; ($tokens:ident $span:ident $b3:tt $b2:tt # (( $($inner:tt)* )) $sep:tt * $a3:tt) => {}; ($tokens:ident $span:ident $b3:tt # ( $($inner:tt)* ) ($sep:tt) * $a2:tt $a3:tt) => {}; ($tokens:ident $span:ident # ( $($inner:tt)* ) * (*) $a1:tt $a2:tt $a3:tt) => { // https://github.com/dtolnay/quote/issues/130 $crate::quote_token_spanned!{* $tokens $span} }; ($tokens:ident $span:ident # ( $($inner:tt)* ) $sep:tt (*) $a1:tt $a2:tt $a3:tt) => {};
($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) $var:ident $a2:tt $a3:tt) => { $crate::ToTokens::to_tokens(&$var, &mut $tokens); }; ($tokens:ident $span:ident $b3:tt $b2:tt # ($var:ident) $a1:tt $a2:tt $a3:tt) => {};
($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt ($curr:tt) $a1:tt $a2:tt $a3:tt) => { $crate::quote_token_spanned!{$curr $tokens $span} };}
// These rules are ordered by approximate token frequency, at least for the// first 10 or so, to improve compile times. Having `ident` first is by far the// most important because it's typically 2-3x more common than the next most// common token.//// Separately, we put the token being matched in the very front so that failing// rules may fail to match as quickly as possible.#[macro_export]#[doc(hidden)]macro_rules! quote_token { ($ident:ident $tokens:ident) => { $crate::__private::push_ident(&mut $tokens, stringify!($ident)); };
(:: $tokens:ident) => { $crate::__private::push_colon2(&mut $tokens); };
(( $($inner:tt)* ) $tokens:ident) => { $crate::__private::push_group( &mut $tokens, $crate::__private::Delimiter::Parenthesis, $crate::quote!($($inner)*), ); };
([ $($inner:tt)* ] $tokens:ident) => { $crate::__private::push_group( &mut $tokens, $crate::__private::Delimiter::Bracket, $crate::quote!($($inner)*), ); };
({ $($inner:tt)* } $tokens:ident) => { $crate::__private::push_group( &mut $tokens, $crate::__private::Delimiter::Brace, $crate::quote!($($inner)*), ); };
(# $tokens:ident) => { $crate::__private::push_pound(&mut $tokens); };
(, $tokens:ident) => { $crate::__private::push_comma(&mut $tokens); };
(. $tokens:ident) => { $crate::__private::push_dot(&mut $tokens); };
(; $tokens:ident) => { $crate::__private::push_semi(&mut $tokens); };
(: $tokens:ident) => { $crate::__private::push_colon(&mut $tokens); };
(+ $tokens:ident) => { $crate::__private::push_add(&mut $tokens); };
(+= $tokens:ident) => { $crate::__private::push_add_eq(&mut $tokens); };
(& $tokens:ident) => { $crate::__private::push_and(&mut $tokens); };
(&& $tokens:ident) => { $crate::__private::push_and_and(&mut $tokens); };
(&= $tokens:ident) => { $crate::__private::push_and_eq(&mut $tokens); };
(@ $tokens:ident) => { $crate::__private::push_at(&mut $tokens); };
(! $tokens:ident) => { $crate::__private::push_bang(&mut $tokens); };
(^ $tokens:ident) => { $crate::__private::push_caret(&mut $tokens); };
(^= $tokens:ident) => { $crate::__private::push_caret_eq(&mut $tokens); };
(/ $tokens:ident) => { $crate::__private::push_div(&mut $tokens); };
(/= $tokens:ident) => { $crate::__private::push_div_eq(&mut $tokens); };
(.. $tokens:ident) => { $crate::__private::push_dot2(&mut $tokens); };
(... $tokens:ident) => { $crate::__private::push_dot3(&mut $tokens); };
(..= $tokens:ident) => { $crate::__private::push_dot_dot_eq(&mut $tokens); };
(= $tokens:ident) => { $crate::__private::push_eq(&mut $tokens); };
(== $tokens:ident) => { $crate::__private::push_eq_eq(&mut $tokens); };
(>= $tokens:ident) => { $crate::__private::push_ge(&mut $tokens); };
(> $tokens:ident) => { $crate::__private::push_gt(&mut $tokens); };
(<= $tokens:ident) => { $crate::__private::push_le(&mut $tokens); };
(< $tokens:ident) => { $crate::__private::push_lt(&mut $tokens); };
(*= $tokens:ident) => { $crate::__private::push_mul_eq(&mut $tokens); };
(!= $tokens:ident) => { $crate::__private::push_ne(&mut $tokens); };
(| $tokens:ident) => { $crate::__private::push_or(&mut $tokens); };
(|= $tokens:ident) => { $crate::__private::push_or_eq(&mut $tokens); };
(|| $tokens:ident) => { $crate::__private::push_or_or(&mut $tokens); };
(? $tokens:ident) => { $crate::__private::push_question(&mut $tokens); };
(-> $tokens:ident) => { $crate::__private::push_rarrow(&mut $tokens); };
(<- $tokens:ident) => { $crate::__private::push_larrow(&mut $tokens); };
(% $tokens:ident) => { $crate::__private::push_rem(&mut $tokens); };
(%= $tokens:ident) => { $crate::__private::push_rem_eq(&mut $tokens); };
(=> $tokens:ident) => { $crate::__private::push_fat_arrow(&mut $tokens); };
(<< $tokens:ident) => { $crate::__private::push_shl(&mut $tokens); };
(<<= $tokens:ident) => { $crate::__private::push_shl_eq(&mut $tokens); };
(>> $tokens:ident) => { $crate::__private::push_shr(&mut $tokens); };
(>>= $tokens:ident) => { $crate::__private::push_shr_eq(&mut $tokens); };
(* $tokens:ident) => { $crate::__private::push_star(&mut $tokens); };
(- $tokens:ident) => { $crate::__private::push_sub(&mut $tokens); };
(-= $tokens:ident) => { $crate::__private::push_sub_eq(&mut $tokens); };
($lifetime:lifetime $tokens:ident) => { $crate::__private::push_lifetime(&mut $tokens, stringify!($lifetime)); };
(_ $tokens:ident) => { $crate::__private::push_underscore(&mut $tokens); };
($other:tt $tokens:ident) => { $crate::__private::parse(&mut $tokens, stringify!($other)); };}
// See the comment above `quote_token!` about the rule ordering.#[macro_export]#[doc(hidden)]macro_rules! quote_token_spanned { ($ident:ident $tokens:ident $span:ident) => { $crate::__private::push_ident_spanned(&mut $tokens, $span, stringify!($ident)); };
(:: $tokens:ident $span:ident) => { $crate::__private::push_colon2_spanned(&mut $tokens, $span); };
(( $($inner:tt)* ) $tokens:ident $span:ident) => { $crate::__private::push_group_spanned( &mut $tokens, $span, $crate::__private::Delimiter::Parenthesis, $crate::quote_spanned!($span=> $($inner)*), ); };
([ $($inner:tt)* ] $tokens:ident $span:ident) => { $crate::__private::push_group_spanned( &mut $tokens, $span, $crate::__private::Delimiter::Bracket, $crate::quote_spanned!($span=> $($inner)*), ); };
({ $($inner:tt)* } $tokens:ident $span:ident) => { $crate::__private::push_group_spanned( &mut $tokens, $span, $crate::__private::Delimiter::Brace, $crate::quote_spanned!($span=> $($inner)*), ); };
(# $tokens:ident $span:ident) => { $crate::__private::push_pound_spanned(&mut $tokens, $span); };
(, $tokens:ident $span:ident) => { $crate::__private::push_comma_spanned(&mut $tokens, $span); };
(. $tokens:ident $span:ident) => { $crate::__private::push_dot_spanned(&mut $tokens, $span); };
(; $tokens:ident $span:ident) => { $crate::__private::push_semi_spanned(&mut $tokens, $span); };
(: $tokens:ident $span:ident) => { $crate::__private::push_colon_spanned(&mut $tokens, $span); };
(+ $tokens:ident $span:ident) => { $crate::__private::push_add_spanned(&mut $tokens, $span); };
(+= $tokens:ident $span:ident) => { $crate::__private::push_add_eq_spanned(&mut $tokens, $span); };
(& $tokens:ident $span:ident) => { $crate::__private::push_and_spanned(&mut $tokens, $span); };
(&& $tokens:ident $span:ident) => { $crate::__private::push_and_and_spanned(&mut $tokens, $span); };
(&= $tokens:ident $span:ident) => { $crate::__private::push_and_eq_spanned(&mut $tokens, $span); };
(@ $tokens:ident $span:ident) => { $crate::__private::push_at_spanned(&mut $tokens, $span); };
(! $tokens:ident $span:ident) => { $crate::__private::push_bang_spanned(&mut $tokens, $span); };
(^ $tokens:ident $span:ident) => { $crate::__private::push_caret_spanned(&mut $tokens, $span); };
(^= $tokens:ident $span:ident) => { $crate::__private::push_caret_eq_spanned(&mut $tokens, $span); };
(/ $tokens:ident $span:ident) => { $crate::__private::push_div_spanned(&mut $tokens, $span); };
(/= $tokens:ident $span:ident) => { $crate::__private::push_div_eq_spanned(&mut $tokens, $span); };
(.. $tokens:ident $span:ident) => { $crate::__private::push_dot2_spanned(&mut $tokens, $span); };
(... $tokens:ident $span:ident) => { $crate::__private::push_dot3_spanned(&mut $tokens, $span); };
(..= $tokens:ident $span:ident) => { $crate::__private::push_dot_dot_eq_spanned(&mut $tokens, $span); };
(= $tokens:ident $span:ident) => { $crate::__private::push_eq_spanned(&mut $tokens, $span); };
(== $tokens:ident $span:ident) => { $crate::__private::push_eq_eq_spanned(&mut $tokens, $span); };
(>= $tokens:ident $span:ident) => { $crate::__private::push_ge_spanned(&mut $tokens, $span); };
(> $tokens:ident $span:ident) => { $crate::__private::push_gt_spanned(&mut $tokens, $span); };
(<= $tokens:ident $span:ident) => { $crate::__private::push_le_spanned(&mut $tokens, $span); };
(< $tokens:ident $span:ident) => { $crate::__private::push_lt_spanned(&mut $tokens, $span); };
(*= $tokens:ident $span:ident) => { $crate::__private::push_mul_eq_spanned(&mut $tokens, $span); };
(!= $tokens:ident $span:ident) => { $crate::__private::push_ne_spanned(&mut $tokens, $span); };
(| $tokens:ident $span:ident) => { $crate::__private::push_or_spanned(&mut $tokens, $span); };
(|= $tokens:ident $span:ident) => { $crate::__private::push_or_eq_spanned(&mut $tokens, $span); };
(|| $tokens:ident $span:ident) => { $crate::__private::push_or_or_spanned(&mut $tokens, $span); };
(? $tokens:ident $span:ident) => { $crate::__private::push_question_spanned(&mut $tokens, $span); };
(-> $tokens:ident $span:ident) => { $crate::__private::push_rarrow_spanned(&mut $tokens, $span); };
(<- $tokens:ident $span:ident) => { $crate::__private::push_larrow_spanned(&mut $tokens, $span); };
(% $tokens:ident $span:ident) => { $crate::__private::push_rem_spanned(&mut $tokens, $span); };
(%= $tokens:ident $span:ident) => { $crate::__private::push_rem_eq_spanned(&mut $tokens, $span); };
(=> $tokens:ident $span:ident) => { $crate::__private::push_fat_arrow_spanned(&mut $tokens, $span); };
(<< $tokens:ident $span:ident) => { $crate::__private::push_shl_spanned(&mut $tokens, $span); };
(<<= $tokens:ident $span:ident) => { $crate::__private::push_shl_eq_spanned(&mut $tokens, $span); };
(>> $tokens:ident $span:ident) => { $crate::__private::push_shr_spanned(&mut $tokens, $span); };
(>>= $tokens:ident $span:ident) => { $crate::__private::push_shr_eq_spanned(&mut $tokens, $span); };
(* $tokens:ident $span:ident) => { $crate::__private::push_star_spanned(&mut $tokens, $span); };
(- $tokens:ident $span:ident) => { $crate::__private::push_sub_spanned(&mut $tokens, $span); };
(-= $tokens:ident $span:ident) => { $crate::__private::push_sub_eq_spanned(&mut $tokens, $span); };
($lifetime:lifetime $tokens:ident $span:ident) => { $crate::__private::push_lifetime_spanned(&mut $tokens, $span, stringify!($lifetime)); };
(_ $tokens:ident $span:ident) => { $crate::__private::push_underscore_spanned(&mut $tokens, $span); };
($other:tt $tokens:ident $span:ident) => { $crate::__private::parse_spanned(&mut $tokens, $span, stringify!($other)); };}