projects/linux·blob master · refs

1456 lines · 47.5 KiB

1// SPDX-License-Identifier: Apache-2.0 OR MIT
2
3//! [![github]](https://github.com/dtolnay/quote) [![crates-io]](https://crates.io/crates/quote) [![docs-rs]](https://docs.rs/quote)
4//!
5//! [github]: https://img.shields.io/badge/github-8da0cb?style=for-the-badge&labelColor=555555&logo=github
6//! [crates-io]: https://img.shields.io/badge/crates.io-fc8d62?style=for-the-badge&labelColor=555555&logo=rust
7//! [docs-rs]: https://img.shields.io/badge/docs.rs-66c2a5?style=for-the-badge&labelColor=555555&logo=docs.rs
8//!
9//! <br>
10//!
11//! This crate provides the [`quote!`] macro for turning Rust syntax tree data
12//! structures into tokens of source code.
13//!
14//! Procedural macros in Rust receive a stream of tokens as input, execute
15//! arbitrary Rust code to determine how to manipulate those tokens, and produce
16//! a stream of tokens to hand back to the compiler to compile into the caller's
17//! crate. Quasi-quoting is a solution to one piece of that &mdash; producing
18//! tokens to return to the compiler.
19//!
20//! The idea of quasi-quoting is that we write *code* that we treat as *data*.
21//! Within the `quote!` macro, we can write what looks like code to our text
22//! editor or IDE. We get all the benefits of the editor's brace matching,
23//! syntax highlighting, indentation, and maybe autocompletion. But rather than
24//! compiling that as code into the current crate, we can treat it as data, pass
25//! it around, mutate it, and eventually hand it back to the compiler as tokens
26//! to compile into the macro caller's crate.
27//!
28//! This crate is motivated by the procedural macro use case, but is a
29//! general-purpose Rust quasi-quoting library and is not specific to procedural
30//! macros.
31//!
32//! ```toml
33//! [dependencies]
34//! quote = "1.0"
35//! ```
36//!
37//! <br>
38//!
39//! # Example
40//!
41//! The following quasi-quoted block of code is something you might find in [a]
42//! procedural macro having to do with data structure serialization. The `#var`
43//! syntax performs interpolation of runtime variables into the quoted tokens.
44//! Check out the documentation of the [`quote!`] macro for more detail about
45//! the syntax. See also the [`quote_spanned!`] macro which is important for
46//! implementing hygienic procedural macros.
47//!
48//! [a]: https://serde.rs/
49//!
50//! ```
51//! # use quote::quote;
52//! #
53//! # let generics = "";
54//! # let where_clause = "";
55//! # let field_ty = "";
56//! # let item_ty = "";
57//! # let path = "";
58//! # let value = "";
59//! #
60//! let tokens = quote! {
61//! struct SerializeWith #generics #where_clause {
62//! value: &'a #field_ty,
63//! phantom: core::marker::PhantomData<#item_ty>,
64//! }
65//!
66//! impl #generics serde::Serialize for SerializeWith #generics #where_clause {
67//! fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
68//! where
69//! S: serde::Serializer,
70//! {
71//! #path(self.value, serializer)
72//! }
73//! }
74//!
75//! SerializeWith {
76//! value: #value,
77//! phantom: core::marker::PhantomData::<#item_ty>,
78//! }
79//! };
80//! ```
81//!
82//! <br>
83//!
84//! # Non-macro code generators
85//!
86//! When using `quote` in a build.rs or main.rs and writing the output out to a
87//! file, consider having the code generator pass the tokens through
88//! [prettyplease] before writing. This way if an error occurs in the generated
89//! code it is convenient for a human to read and debug.
90//!
91//! [prettyplease]: https://github.com/dtolnay/prettyplease
92
93// Quote types in rustdoc of other crates get linked to here.
94#![doc(html_root_url = "https://docs.rs/quote/1.0.40")]
95#![allow(
96 clippy::doc_markdown,
97 clippy::elidable_lifetime_names,
98 clippy::missing_errors_doc,
99 clippy::missing_panics_doc,
100 clippy::module_name_repetitions,
101 clippy::needless_lifetimes,
102 // false positive https://github.com/rust-lang/rust-clippy/issues/6983
103 clippy::wrong_self_convention,
104)]
105
106extern crate alloc;
107
108#[cfg(feature = "proc-macro")]
109extern crate proc_macro;
110
111mod ext;
112mod format;
113mod ident_fragment;
114mod to_tokens;
115
116// Not public API.
117#[doc(hidden)]
118#[path = "runtime.rs"]
119pub mod __private;
120
121pub use crate::ext::TokenStreamExt;
122pub use crate::ident_fragment::IdentFragment;
123pub use crate::to_tokens::ToTokens;
124
125// Not public API.
126#[doc(hidden)]
127pub mod spanned;
128
129macro_rules! __quote {
130 ($quote:item) => {
131 /// The whole point.
132 ///
133 /// Performs variable interpolation against the input and produces it as
134 /// [`proc_macro2::TokenStream`].
135 ///
136 /// Note: for returning tokens to the compiler in a procedural macro, use
137 /// `.into()` on the result to convert to [`proc_macro::TokenStream`].
138 ///
139 /// <br>
140 ///
141 /// # Interpolation
142 ///
143 /// Variable interpolation is done with `#var` (similar to `$var` in
144 /// `macro_rules!` macros). This grabs the `var` variable that is currently in
145 /// scope and inserts it in that location in the output tokens. Any type
146 /// implementing the [`ToTokens`] trait can be interpolated. This includes most
147 /// Rust primitive types as well as most of the syntax tree types from the [Syn]
148 /// crate.
149 ///
150 /// [Syn]: https://github.com/dtolnay/syn
151 ///
152 /// Repetition is done using `#(...)*` or `#(...),*` again similar to
153 /// `macro_rules!`. This iterates through the elements of any variable
154 /// interpolated within the repetition and inserts a copy of the repetition body
155 /// for each one. The variables in an interpolation may be a `Vec`, slice,
156 /// `BTreeSet`, or any `Iterator`.
157 ///
158 /// - `#(#var)*` — no separators
159 /// - `#(#var),*` — the character before the asterisk is used as a separator
160 /// - `#( struct #var; )*` — the repetition can contain other tokens
161 /// - `#( #k => println!("{}", #v), )*` — even multiple interpolations
162 ///
163 /// <br>
164 ///
165 /// # Hygiene
166 ///
167 /// Any interpolated tokens preserve the `Span` information provided by their
168 /// `ToTokens` implementation. Tokens that originate within the `quote!`
169 /// invocation are spanned with [`Span::call_site()`].
170 ///
171 /// [`Span::call_site()`]: proc_macro2::Span::call_site
172 ///
173 /// A different span can be provided through the [`quote_spanned!`] macro.
174 ///
175 /// <br>
176 ///
177 /// # Return type
178 ///
179 /// The macro evaluates to an expression of type `proc_macro2::TokenStream`.
180 /// Meanwhile Rust procedural macros are expected to return the type
181 /// `proc_macro::TokenStream`.
182 ///
183 /// The difference between the two types is that `proc_macro` types are entirely
184 /// specific to procedural macros and cannot ever exist in code outside of a
185 /// procedural macro, while `proc_macro2` types may exist anywhere including
186 /// tests and non-macro code like main.rs and build.rs. This is why even the
187 /// procedural macro ecosystem is largely built around `proc_macro2`, because
188 /// that ensures the libraries are unit testable and accessible in non-macro
189 /// contexts.
190 ///
191 /// There is a [`From`]-conversion in both directions so returning the output of
192 /// `quote!` from a procedural macro usually looks like `tokens.into()` or
193 /// `proc_macro::TokenStream::from(tokens)`.
194 ///
195 /// <br>
196 ///
197 /// # Examples
198 ///
199 /// ### Procedural macro
200 ///
201 /// The structure of a basic procedural macro is as follows. Refer to the [Syn]
202 /// crate for further useful guidance on using `quote!` as part of a procedural
203 /// macro.
204 ///
205 /// [Syn]: https://github.com/dtolnay/syn
206 ///
207 /// ```
208 /// # #[cfg(any())]
209 /// extern crate proc_macro;
210 /// # extern crate proc_macro2;
211 ///
212 /// # #[cfg(any())]
213 /// use proc_macro::TokenStream;
214 /// # use proc_macro2::TokenStream;
215 /// use quote::quote;
216 ///
217 /// # const IGNORE_TOKENS: &'static str = stringify! {
218 /// #[proc_macro_derive(HeapSize)]
219 /// # };
220 /// pub fn derive_heap_size(input: TokenStream) -> TokenStream {
221 /// // Parse the input and figure out what implementation to generate...
222 /// # const IGNORE_TOKENS: &'static str = stringify! {
223 /// let name = /* ... */;
224 /// let expr = /* ... */;
225 /// # };
226 /// #
227 /// # let name = 0;
228 /// # let expr = 0;
229 ///
230 /// let expanded = quote! {
231 /// // The generated impl.
232 /// impl heapsize::HeapSize for #name {
233 /// fn heap_size_of_children(&self) -> usize {
234 /// #expr
235 /// }
236 /// }
237 /// };
238 ///
239 /// // Hand the output tokens back to the compiler.
240 /// TokenStream::from(expanded)
241 /// }
242 /// ```
243 ///
244 /// <p><br></p>
245 ///
246 /// ### Combining quoted fragments
247 ///
248 /// Usually you don't end up constructing an entire final `TokenStream` in one
249 /// piece. Different parts may come from different helper functions. The tokens
250 /// produced by `quote!` themselves implement `ToTokens` and so can be
251 /// interpolated into later `quote!` invocations to build up a final result.
252 ///
253 /// ```
254 /// # use quote::quote;
255 /// #
256 /// let type_definition = quote! {...};
257 /// let methods = quote! {...};
258 ///
259 /// let tokens = quote! {
260 /// #type_definition
261 /// #methods
262 /// };
263 /// ```
264 ///
265 /// <p><br></p>
266 ///
267 /// ### Constructing identifiers
268 ///
269 /// Suppose we have an identifier `ident` which came from somewhere in a macro
270 /// input and we need to modify it in some way for the macro output. Let's
271 /// consider prepending the identifier with an underscore.
272 ///
273 /// Simply interpolating the identifier next to an underscore will not have the
274 /// behavior of concatenating them. The underscore and the identifier will
275 /// continue to be two separate tokens as if you had written `_ x`.
276 ///
277 /// ```
278 /// # use proc_macro2::{self as syn, Span};
279 /// # use quote::quote;
280 /// #
281 /// # let ident = syn::Ident::new("i", Span::call_site());
282 /// #
283 /// // incorrect
284 /// quote! {
285 /// let mut _#ident = 0;
286 /// }
287 /// # ;
288 /// ```
289 ///
290 /// The solution is to build a new identifier token with the correct value. As
291 /// this is such a common case, the [`format_ident!`] macro provides a
292 /// convenient utility for doing so correctly.
293 ///
294 /// ```
295 /// # use proc_macro2::{Ident, Span};
296 /// # use quote::{format_ident, quote};
297 /// #
298 /// # let ident = Ident::new("i", Span::call_site());
299 /// #
300 /// let varname = format_ident!("_{}", ident);
301 /// quote! {
302 /// let mut #varname = 0;
303 /// }
304 /// # ;
305 /// ```
306 ///
307 /// Alternatively, the APIs provided by Syn and proc-macro2 can be used to
308 /// directly build the identifier. This is roughly equivalent to the above, but
309 /// will not handle `ident` being a raw identifier.
310 ///
311 /// ```
312 /// # use proc_macro2::{self as syn, Span};
313 /// # use quote::quote;
314 /// #
315 /// # let ident = syn::Ident::new("i", Span::call_site());
316 /// #
317 /// let concatenated = format!("_{}", ident);
318 /// let varname = syn::Ident::new(&concatenated, ident.span());
319 /// quote! {
320 /// let mut #varname = 0;
321 /// }
322 /// # ;
323 /// ```
324 ///
325 /// <p><br></p>
326 ///
327 /// ### Making method calls
328 ///
329 /// Let's say our macro requires some type specified in the macro input to have
330 /// a constructor called `new`. We have the type in a variable called
331 /// `field_type` of type `syn::Type` and want to invoke the constructor.
332 ///
333 /// ```
334 /// # use quote::quote;
335 /// #
336 /// # let field_type = quote!(...);
337 /// #
338 /// // incorrect
339 /// quote! {
340 /// let value = #field_type::new();
341 /// }
342 /// # ;
343 /// ```
344 ///
345 /// This works only sometimes. If `field_type` is `String`, the expanded code
346 /// contains `String::new()` which is fine. But if `field_type` is something
347 /// like `Vec<i32>` then the expanded code is `Vec<i32>::new()` which is invalid
348 /// syntax. Ordinarily in handwritten Rust we would write `Vec::<i32>::new()`
349 /// but for macros often the following is more convenient.
350 ///
351 /// ```
352 /// # use quote::quote;
353 /// #
354 /// # let field_type = quote!(...);
355 /// #
356 /// quote! {
357 /// let value = <#field_type>::new();
358 /// }
359 /// # ;
360 /// ```
361 ///
362 /// This expands to `<Vec<i32>>::new()` which behaves correctly.
363 ///
364 /// A similar pattern is appropriate for trait methods.
365 ///
366 /// ```
367 /// # use quote::quote;
368 /// #
369 /// # let field_type = quote!(...);
370 /// #
371 /// quote! {
372 /// let value = <#field_type as core::default::Default>::default();
373 /// }
374 /// # ;
375 /// ```
376 ///
377 /// <p><br></p>
378 ///
379 /// ### Interpolating text inside of doc comments
380 ///
381 /// Neither doc comments nor string literals get interpolation behavior in
382 /// quote:
383 ///
384 /// ```compile_fail
385 /// quote! {
386 /// /// try to interpolate: #ident
387 /// ///
388 /// /// ...
389 /// }
390 /// ```
391 ///
392 /// ```compile_fail
393 /// quote! {
394 /// #[doc = "try to interpolate: #ident"]
395 /// }
396 /// ```
397 ///
398 /// Instead the best way to build doc comments that involve variables is by
399 /// formatting the doc string literal outside of quote.
400 ///
401 /// ```rust
402 /// # use proc_macro2::{Ident, Span};
403 /// # use quote::quote;
404 /// #
405 /// # const IGNORE: &str = stringify! {
406 /// let msg = format!(...);
407 /// # };
408 /// #
409 /// # let ident = Ident::new("var", Span::call_site());
410 /// # let msg = format!("try to interpolate: {}", ident);
411 /// quote! {
412 /// #[doc = #msg]
413 /// ///
414 /// /// ...
415 /// }
416 /// # ;
417 /// ```
418 ///
419 /// <p><br></p>
420 ///
421 /// ### Indexing into a tuple struct
422 ///
423 /// When interpolating indices of a tuple or tuple struct, we need them not to
424 /// appears suffixed as integer literals by interpolating them as [`syn::Index`]
425 /// instead.
426 ///
427 /// [`syn::Index`]: https://docs.rs/syn/2.0/syn/struct.Index.html
428 ///
429 /// ```compile_fail
430 /// let i = 0usize..self.fields.len();
431 ///
432 /// // expands to 0 + self.0usize.heap_size() + self.1usize.heap_size() + ...
433 /// // which is not valid syntax
434 /// quote! {
435 /// 0 #( + self.#i.heap_size() )*
436 /// }
437 /// ```
438 ///
439 /// ```
440 /// # use proc_macro2::{Ident, TokenStream};
441 /// # use quote::quote;
442 /// #
443 /// # mod syn {
444 /// # use proc_macro2::{Literal, TokenStream};
445 /// # use quote::{ToTokens, TokenStreamExt};
446 /// #
447 /// # pub struct Index(usize);
448 /// #
449 /// # impl From<usize> for Index {
450 /// # fn from(i: usize) -> Self {
451 /// # Index(i)
452 /// # }
453 /// # }
454 /// #
455 /// # impl ToTokens for Index {
456 /// # fn to_tokens(&self, tokens: &mut TokenStream) {
457 /// # tokens.append(Literal::usize_unsuffixed(self.0));
458 /// # }
459 /// # }
460 /// # }
461 /// #
462 /// # struct Struct {
463 /// # fields: Vec<Ident>,
464 /// # }
465 /// #
466 /// # impl Struct {
467 /// # fn example(&self) -> TokenStream {
468 /// let i = (0..self.fields.len()).map(syn::Index::from);
469 ///
470 /// // expands to 0 + self.0.heap_size() + self.1.heap_size() + ...
471 /// quote! {
472 /// 0 #( + self.#i.heap_size() )*
473 /// }
474 /// # }
475 /// # }
476 /// ```
477 $quote
478 };
479}
480
481#[cfg(doc)]
482__quote![
483 #[macro_export]
484 macro_rules! quote {
485 ($($tt:tt)*) => {
486 ...
487 };
488 }
489];
490
491#[cfg(not(doc))]
492__quote![
493 #[macro_export]
494 macro_rules! quote {
495 () => {
496 $crate::__private::TokenStream::new()
497 };
498
499 // Special case rule for a single tt, for performance.
500 ($tt:tt) => {{
501 let mut _s = $crate::__private::TokenStream::new();
502 $crate::quote_token!{$tt _s}
503 _s
504 }};
505
506 // Special case rules for two tts, for performance.
507 (# $var:ident) => {{
508 let mut _s = $crate::__private::TokenStream::new();
509 $crate::ToTokens::to_tokens(&$var, &mut _s);
510 _s
511 }};
512 ($tt1:tt $tt2:tt) => {{
513 let mut _s = $crate::__private::TokenStream::new();
514 $crate::quote_token!{$tt1 _s}
515 $crate::quote_token!{$tt2 _s}
516 _s
517 }};
518
519 // Rule for any other number of tokens.
520 ($($tt:tt)*) => {{
521 let mut _s = $crate::__private::TokenStream::new();
522 $crate::quote_each_token!{_s $($tt)*}
523 _s
524 }};
525 }
526];
527
528macro_rules! __quote_spanned {
529 ($quote_spanned:item) => {
530 /// Same as `quote!`, but applies a given span to all tokens originating within
531 /// the macro invocation.
532 ///
533 /// <br>
534 ///
535 /// # Syntax
536 ///
537 /// A span expression of type [`Span`], followed by `=>`, followed by the tokens
538 /// to quote. The span expression should be brief &mdash; use a variable for
539 /// anything more than a few characters. There should be no space before the
540 /// `=>` token.
541 ///
542 /// [`Span`]: proc_macro2::Span
543 ///
544 /// ```
545 /// # use proc_macro2::Span;
546 /// # use quote::quote_spanned;
547 /// #
548 /// # const IGNORE_TOKENS: &'static str = stringify! {
549 /// let span = /* ... */;
550 /// # };
551 /// # let span = Span::call_site();
552 /// # let init = 0;
553 ///
554 /// // On one line, use parentheses.
555 /// let tokens = quote_spanned!(span=> Box::into_raw(Box::new(#init)));
556 ///
557 /// // On multiple lines, place the span at the top and use braces.
558 /// let tokens = quote_spanned! {span=>
559 /// Box::into_raw(Box::new(#init))
560 /// };
561 /// ```
562 ///
563 /// The lack of space before the `=>` should look jarring to Rust programmers
564 /// and this is intentional. The formatting is designed to be visibly
565 /// off-balance and draw the eye a particular way, due to the span expression
566 /// being evaluated in the context of the procedural macro and the remaining
567 /// tokens being evaluated in the generated code.
568 ///
569 /// <br>
570 ///
571 /// # Hygiene
572 ///
573 /// Any interpolated tokens preserve the `Span` information provided by their
574 /// `ToTokens` implementation. Tokens that originate within the `quote_spanned!`
575 /// invocation are spanned with the given span argument.
576 ///
577 /// <br>
578 ///
579 /// # Example
580 ///
581 /// The following procedural macro code uses `quote_spanned!` to assert that a
582 /// particular Rust type implements the [`Sync`] trait so that references can be
583 /// safely shared between threads.
584 ///
585 /// ```
586 /// # use quote::{quote_spanned, TokenStreamExt, ToTokens};
587 /// # use proc_macro2::{Span, TokenStream};
588 /// #
589 /// # struct Type;
590 /// #
591 /// # impl Type {
592 /// # fn span(&self) -> Span {
593 /// # Span::call_site()
594 /// # }
595 /// # }
596 /// #
597 /// # impl ToTokens for Type {
598 /// # fn to_tokens(&self, _tokens: &mut TokenStream) {}
599 /// # }
600 /// #
601 /// # let ty = Type;
602 /// # let call_site = Span::call_site();
603 /// #
604 /// let ty_span = ty.span();
605 /// let assert_sync = quote_spanned! {ty_span=>
606 /// struct _AssertSync where #ty: Sync;
607 /// };
608 /// ```
609 ///
610 /// If the assertion fails, the user will see an error like the following. The
611 /// input span of their type is highlighted in the error.
612 ///
613 /// ```text
614 /// error[E0277]: the trait bound `*const (): std::marker::Sync` is not satisfied
615 /// --> src/main.rs:10:21
616 /// |
617 /// 10 | static ref PTR: *const () = &();
618 /// | ^^^^^^^^^ `*const ()` cannot be shared between threads safely
619 /// ```
620 ///
621 /// In this example it is important for the where-clause to be spanned with the
622 /// line/column information of the user's input type so that error messages are
623 /// placed appropriately by the compiler.
624 $quote_spanned
625 };
626}
627
628#[cfg(doc)]
629__quote_spanned![
630 #[macro_export]
631 macro_rules! quote_spanned {
632 ($span:expr=> $($tt:tt)*) => {
633 ...
634 };
635 }
636];
637
638#[cfg(not(doc))]
639__quote_spanned![
640 #[macro_export]
641 macro_rules! quote_spanned {
642 ($span:expr=>) => {{
643 let _: $crate::__private::Span = $crate::__private::get_span($span).__into_span();
644 $crate::__private::TokenStream::new()
645 }};
646
647 // Special case rule for a single tt, for performance.
648 ($span:expr=> $tt:tt) => {{
649 let mut _s = $crate::__private::TokenStream::new();
650 let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span();
651 $crate::quote_token_spanned!{$tt _s _span}
652 _s
653 }};
654
655 // Special case rules for two tts, for performance.
656 ($span:expr=> # $var:ident) => {{
657 let mut _s = $crate::__private::TokenStream::new();
658 let _: $crate::__private::Span = $crate::__private::get_span($span).__into_span();
659 $crate::ToTokens::to_tokens(&$var, &mut _s);
660 _s
661 }};
662 ($span:expr=> $tt1:tt $tt2:tt) => {{
663 let mut _s = $crate::__private::TokenStream::new();
664 let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span();
665 $crate::quote_token_spanned!{$tt1 _s _span}
666 $crate::quote_token_spanned!{$tt2 _s _span}
667 _s
668 }};
669
670 // Rule for any other number of tokens.
671 ($span:expr=> $($tt:tt)*) => {{
672 let mut _s = $crate::__private::TokenStream::new();
673 let _span: $crate::__private::Span = $crate::__private::get_span($span).__into_span();
674 $crate::quote_each_token_spanned!{_s _span $($tt)*}
675 _s
676 }};
677 }
678];
679
680// Extract the names of all #metavariables and pass them to the $call macro.
681//
682// in: pounded_var_names!(then!(...) a #b c #( #d )* #e)
683// out: then!(... b);
684// then!(... d);
685// then!(... e);
686#[macro_export]
687#[doc(hidden)]
688macro_rules! pounded_var_names {
689 ($call:ident! $extra:tt $($tts:tt)*) => {
690 $crate::pounded_var_names_with_context!{$call! $extra
691 (@ $($tts)*)
692 ($($tts)* @)
693 }
694 };
695}
696
697#[macro_export]
698#[doc(hidden)]
699macro_rules! pounded_var_names_with_context {
700 ($call:ident! $extra:tt ($($b1:tt)*) ($($curr:tt)*)) => {
701 $(
702 $crate::pounded_var_with_context!{$call! $extra $b1 $curr}
703 )*
704 };
705}
706
707#[macro_export]
708#[doc(hidden)]
709macro_rules! pounded_var_with_context {
710 ($call:ident! $extra:tt $b1:tt ( $($inner:tt)* )) => {
711 $crate::pounded_var_names!{$call! $extra $($inner)*}
712 };
713
714 ($call:ident! $extra:tt $b1:tt [ $($inner:tt)* ]) => {
715 $crate::pounded_var_names!{$call! $extra $($inner)*}
716 };
717
718 ($call:ident! $extra:tt $b1:tt { $($inner:tt)* }) => {
719 $crate::pounded_var_names!{$call! $extra $($inner)*}
720 };
721
722 ($call:ident!($($extra:tt)*) # $var:ident) => {
723 $crate::$call!($($extra)* $var);
724 };
725
726 ($call:ident! $extra:tt $b1:tt $curr:tt) => {};
727}
728
729#[macro_export]
730#[doc(hidden)]
731macro_rules! quote_bind_into_iter {
732 ($has_iter:ident $var:ident) => {
733 // `mut` may be unused if $var occurs multiple times in the list.
734 #[allow(unused_mut)]
735 let (mut $var, i) = $var.quote_into_iter();
736 let $has_iter = $has_iter | i;
737 };
738}
739
740#[macro_export]
741#[doc(hidden)]
742macro_rules! quote_bind_next_or_break {
743 ($var:ident) => {
744 let $var = match $var.next() {
745 Some(_x) => $crate::__private::RepInterp(_x),
746 None => break,
747 };
748 };
749}
750
751// The obvious way to write this macro is as a tt muncher. This implementation
752// does something more complex for two reasons.
753//
754// - With a tt muncher it's easy to hit Rust's built-in recursion_limit, which
755// this implementation avoids because it isn't tail recursive.
756//
757// - Compile times for a tt muncher are quadratic relative to the length of
758// the input. This implementation is linear, so it will be faster
759// (potentially much faster) for big inputs. However, the constant factors
760// of this implementation are higher than that of a tt muncher, so it is
761// somewhat slower than a tt muncher if there are many invocations with
762// short inputs.
763//
764// An invocation like this:
765//
766// quote_each_token!(_s a b c d e f g h i j);
767//
768// expands to this:
769//
770// quote_tokens_with_context!(_s
771// (@ @ @ @ @ @ a b c d e f g h i j)
772// (@ @ @ @ @ a b c d e f g h i j @)
773// (@ @ @ @ a b c d e f g h i j @ @)
774// (@ @ @ (a) (b) (c) (d) (e) (f) (g) (h) (i) (j) @ @ @)
775// (@ @ a b c d e f g h i j @ @ @ @)
776// (@ a b c d e f g h i j @ @ @ @ @)
777// (a b c d e f g h i j @ @ @ @ @ @)
778// );
779//
780// which gets transposed and expanded to this:
781//
782// quote_token_with_context!(_s @ @ @ @ @ @ a);
783// quote_token_with_context!(_s @ @ @ @ @ a b);
784// quote_token_with_context!(_s @ @ @ @ a b c);
785// quote_token_with_context!(_s @ @ @ (a) b c d);
786// quote_token_with_context!(_s @ @ a (b) c d e);
787// quote_token_with_context!(_s @ a b (c) d e f);
788// quote_token_with_context!(_s a b c (d) e f g);
789// quote_token_with_context!(_s b c d (e) f g h);
790// quote_token_with_context!(_s c d e (f) g h i);
791// quote_token_with_context!(_s d e f (g) h i j);
792// quote_token_with_context!(_s e f g (h) i j @);
793// quote_token_with_context!(_s f g h (i) j @ @);
794// quote_token_with_context!(_s g h i (j) @ @ @);
795// quote_token_with_context!(_s h i j @ @ @ @);
796// quote_token_with_context!(_s i j @ @ @ @ @);
797// quote_token_with_context!(_s j @ @ @ @ @ @);
798//
799// Without having used muncher-style recursion, we get one invocation of
800// quote_token_with_context for each original tt, with three tts of context on
801// either side. This is enough for the longest possible interpolation form (a
802// repetition with separator, as in `# (#var) , *`) to be fully represented with
803// the first or last tt in the middle.
804//
805// The middle tt (surrounded by parentheses) is the tt being processed.
806//
807// - When it is a `#`, quote_token_with_context can do an interpolation. The
808// interpolation kind will depend on the three subsequent tts.
809//
810// - When it is within a later part of an interpolation, it can be ignored
811// because the interpolation has already been done.
812//
813// - When it is not part of an interpolation it can be pushed as a single
814// token into the output.
815//
816// - When the middle token is an unparenthesized `@`, that call is one of the
817// first 3 or last 3 calls of quote_token_with_context and does not
818// correspond to one of the original input tokens, so turns into nothing.
819#[macro_export]
820#[doc(hidden)]
821macro_rules! quote_each_token {
822 ($tokens:ident $($tts:tt)*) => {
823 $crate::quote_tokens_with_context!{$tokens
824 (@ @ @ @ @ @ $($tts)*)
825 (@ @ @ @ @ $($tts)* @)
826 (@ @ @ @ $($tts)* @ @)
827 (@ @ @ $(($tts))* @ @ @)
828 (@ @ $($tts)* @ @ @ @)
829 (@ $($tts)* @ @ @ @ @)
830 ($($tts)* @ @ @ @ @ @)
831 }
832 };
833}
834
835// See the explanation on quote_each_token.
836#[macro_export]
837#[doc(hidden)]
838macro_rules! quote_each_token_spanned {
839 ($tokens:ident $span:ident $($tts:tt)*) => {
840 $crate::quote_tokens_with_context_spanned!{$tokens $span
841 (@ @ @ @ @ @ $($tts)*)
842 (@ @ @ @ @ $($tts)* @)
843 (@ @ @ @ $($tts)* @ @)
844 (@ @ @ $(($tts))* @ @ @)
845 (@ @ $($tts)* @ @ @ @)
846 (@ $($tts)* @ @ @ @ @)
847 ($($tts)* @ @ @ @ @ @)
848 }
849 };
850}
851
852// See the explanation on quote_each_token.
853#[macro_export]
854#[doc(hidden)]
855macro_rules! quote_tokens_with_context {
856 ($tokens:ident
857 ($($b3:tt)*) ($($b2:tt)*) ($($b1:tt)*)
858 ($($curr:tt)*)
859 ($($a1:tt)*) ($($a2:tt)*) ($($a3:tt)*)
860 ) => {
861 $(
862 $crate::quote_token_with_context!{$tokens $b3 $b2 $b1 $curr $a1 $a2 $a3}
863 )*
864 };
865}
866
867// See the explanation on quote_each_token.
868#[macro_export]
869#[doc(hidden)]
870macro_rules! quote_tokens_with_context_spanned {
871 ($tokens:ident $span:ident
872 ($($b3:tt)*) ($($b2:tt)*) ($($b1:tt)*)
873 ($($curr:tt)*)
874 ($($a1:tt)*) ($($a2:tt)*) ($($a3:tt)*)
875 ) => {
876 $(
877 $crate::quote_token_with_context_spanned!{$tokens $span $b3 $b2 $b1 $curr $a1 $a2 $a3}
878 )*
879 };
880}
881
882// See the explanation on quote_each_token.
883#[macro_export]
884#[doc(hidden)]
885macro_rules! quote_token_with_context {
886 // Unparenthesized `@` indicates this call does not correspond to one of the
887 // original input tokens. Ignore it.
888 ($tokens:ident $b3:tt $b2:tt $b1:tt @ $a1:tt $a2:tt $a3:tt) => {};
889
890 // A repetition with no separator.
891 ($tokens:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) * $a3:tt) => {{
892 use $crate::__private::ext::*;
893 let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
894 $crate::pounded_var_names!{quote_bind_into_iter!(has_iter) () $($inner)*}
895 let _: $crate::__private::HasIterator = has_iter;
896 // This is `while true` instead of `loop` because if there are no
897 // iterators used inside of this repetition then the body would not
898 // contain any `break`, so the compiler would emit unreachable code
899 // warnings on anything below the loop. We use has_iter to detect and
900 // fail to compile when there are no iterators, so here we just work
901 // around the unneeded extra warning.
902 while true {
903 $crate::pounded_var_names!{quote_bind_next_or_break!() () $($inner)*}
904 $crate::quote_each_token!{$tokens $($inner)*}
905 }
906 }};
907 // ... and one step later.
908 ($tokens:ident $b3:tt $b2:tt # (( $($inner:tt)* )) * $a2:tt $a3:tt) => {};
909 // ... and one step later.
910 ($tokens:ident $b3:tt # ( $($inner:tt)* ) (*) $a1:tt $a2:tt $a3:tt) => {};
911
912 // A repetition with separator.
913 ($tokens:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) $sep:tt *) => {{
914 use $crate::__private::ext::*;
915 let mut _i = 0usize;
916 let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
917 $crate::pounded_var_names!{quote_bind_into_iter!(has_iter) () $($inner)*}
918 let _: $crate::__private::HasIterator = has_iter;
919 while true {
920 $crate::pounded_var_names!{quote_bind_next_or_break!() () $($inner)*}
921 if _i > 0 {
922 $crate::quote_token!{$sep $tokens}
923 }
924 _i += 1;
925 $crate::quote_each_token!{$tokens $($inner)*}
926 }
927 }};
928 // ... and one step later.
929 ($tokens:ident $b3:tt $b2:tt # (( $($inner:tt)* )) $sep:tt * $a3:tt) => {};
930 // ... and one step later.
931 ($tokens:ident $b3:tt # ( $($inner:tt)* ) ($sep:tt) * $a2:tt $a3:tt) => {};
932 // (A special case for `#(var)**`, where the first `*` is treated as the
933 // repetition symbol and the second `*` is treated as an ordinary token.)
934 ($tokens:ident # ( $($inner:tt)* ) * (*) $a1:tt $a2:tt $a3:tt) => {
935 // https://github.com/dtolnay/quote/issues/130
936 $crate::quote_token!{* $tokens}
937 };
938 // ... and one step later.
939 ($tokens:ident # ( $($inner:tt)* ) $sep:tt (*) $a1:tt $a2:tt $a3:tt) => {};
940
941 // A non-repetition interpolation.
942 ($tokens:ident $b3:tt $b2:tt $b1:tt (#) $var:ident $a2:tt $a3:tt) => {
943 $crate::ToTokens::to_tokens(&$var, &mut $tokens);
944 };
945 // ... and one step later.
946 ($tokens:ident $b3:tt $b2:tt # ($var:ident) $a1:tt $a2:tt $a3:tt) => {};
947
948 // An ordinary token, not part of any interpolation.
949 ($tokens:ident $b3:tt $b2:tt $b1:tt ($curr:tt) $a1:tt $a2:tt $a3:tt) => {
950 $crate::quote_token!{$curr $tokens}
951 };
952}
953
954// See the explanation on quote_each_token, and on the individual rules of
955// quote_token_with_context.
956#[macro_export]
957#[doc(hidden)]
958macro_rules! quote_token_with_context_spanned {
959 ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt @ $a1:tt $a2:tt $a3:tt) => {};
960
961 ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) * $a3:tt) => {{
962 use $crate::__private::ext::*;
963 let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
964 $crate::pounded_var_names!{quote_bind_into_iter!(has_iter) () $($inner)*}
965 let _: $crate::__private::HasIterator = has_iter;
966 while true {
967 $crate::pounded_var_names!{quote_bind_next_or_break!() () $($inner)*}
968 $crate::quote_each_token_spanned!{$tokens $span $($inner)*}
969 }
970 }};
971 ($tokens:ident $span:ident $b3:tt $b2:tt # (( $($inner:tt)* )) * $a2:tt $a3:tt) => {};
972 ($tokens:ident $span:ident $b3:tt # ( $($inner:tt)* ) (*) $a1:tt $a2:tt $a3:tt) => {};
973
974 ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) ( $($inner:tt)* ) $sep:tt *) => {{
975 use $crate::__private::ext::*;
976 let mut _i = 0usize;
977 let has_iter = $crate::__private::ThereIsNoIteratorInRepetition;
978 $crate::pounded_var_names!{quote_bind_into_iter!(has_iter) () $($inner)*}
979 let _: $crate::__private::HasIterator = has_iter;
980 while true {
981 $crate::pounded_var_names!{quote_bind_next_or_break!() () $($inner)*}
982 if _i > 0 {
983 $crate::quote_token_spanned!{$sep $tokens $span}
984 }
985 _i += 1;
986 $crate::quote_each_token_spanned!{$tokens $span $($inner)*}
987 }
988 }};
989 ($tokens:ident $span:ident $b3:tt $b2:tt # (( $($inner:tt)* )) $sep:tt * $a3:tt) => {};
990 ($tokens:ident $span:ident $b3:tt # ( $($inner:tt)* ) ($sep:tt) * $a2:tt $a3:tt) => {};
991 ($tokens:ident $span:ident # ( $($inner:tt)* ) * (*) $a1:tt $a2:tt $a3:tt) => {
992 // https://github.com/dtolnay/quote/issues/130
993 $crate::quote_token_spanned!{* $tokens $span}
994 };
995 ($tokens:ident $span:ident # ( $($inner:tt)* ) $sep:tt (*) $a1:tt $a2:tt $a3:tt) => {};
996
997 ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt (#) $var:ident $a2:tt $a3:tt) => {
998 $crate::ToTokens::to_tokens(&$var, &mut $tokens);
999 };
1000 ($tokens:ident $span:ident $b3:tt $b2:tt # ($var:ident) $a1:tt $a2:tt $a3:tt) => {};
1001
1002 ($tokens:ident $span:ident $b3:tt $b2:tt $b1:tt ($curr:tt) $a1:tt $a2:tt $a3:tt) => {
1003 $crate::quote_token_spanned!{$curr $tokens $span}
1004 };
1005}
1006
1007// These rules are ordered by approximate token frequency, at least for the
1008// first 10 or so, to improve compile times. Having `ident` first is by far the
1009// most important because it's typically 2-3x more common than the next most
1010// common token.
1011//
1012// Separately, we put the token being matched in the very front so that failing
1013// rules may fail to match as quickly as possible.
1014#[macro_export]
1015#[doc(hidden)]
1016macro_rules! quote_token {
1017 ($ident:ident $tokens:ident) => {
1018 $crate::__private::push_ident(&mut $tokens, stringify!($ident));
1019 };
1020
1021 (:: $tokens:ident) => {
1022 $crate::__private::push_colon2(&mut $tokens);
1023 };
1024
1025 (( $($inner:tt)* ) $tokens:ident) => {
1026 $crate::__private::push_group(
1027 &mut $tokens,
1028 $crate::__private::Delimiter::Parenthesis,
1029 $crate::quote!($($inner)*),
1030 );
1031 };
1032
1033 ([ $($inner:tt)* ] $tokens:ident) => {
1034 $crate::__private::push_group(
1035 &mut $tokens,
1036 $crate::__private::Delimiter::Bracket,
1037 $crate::quote!($($inner)*),
1038 );
1039 };
1040
1041 ({ $($inner:tt)* } $tokens:ident) => {
1042 $crate::__private::push_group(
1043 &mut $tokens,
1044 $crate::__private::Delimiter::Brace,
1045 $crate::quote!($($inner)*),
1046 );
1047 };
1048
1049 (# $tokens:ident) => {
1050 $crate::__private::push_pound(&mut $tokens);
1051 };
1052
1053 (, $tokens:ident) => {
1054 $crate::__private::push_comma(&mut $tokens);
1055 };
1056
1057 (. $tokens:ident) => {
1058 $crate::__private::push_dot(&mut $tokens);
1059 };
1060
1061 (; $tokens:ident) => {
1062 $crate::__private::push_semi(&mut $tokens);
1063 };
1064
1065 (: $tokens:ident) => {
1066 $crate::__private::push_colon(&mut $tokens);
1067 };
1068
1069 (+ $tokens:ident) => {
1070 $crate::__private::push_add(&mut $tokens);
1071 };
1072
1073 (+= $tokens:ident) => {
1074 $crate::__private::push_add_eq(&mut $tokens);
1075 };
1076
1077 (& $tokens:ident) => {
1078 $crate::__private::push_and(&mut $tokens);
1079 };
1080
1081 (&& $tokens:ident) => {
1082 $crate::__private::push_and_and(&mut $tokens);
1083 };
1084
1085 (&= $tokens:ident) => {
1086 $crate::__private::push_and_eq(&mut $tokens);
1087 };
1088
1089 (@ $tokens:ident) => {
1090 $crate::__private::push_at(&mut $tokens);
1091 };
1092
1093 (! $tokens:ident) => {
1094 $crate::__private::push_bang(&mut $tokens);
1095 };
1096
1097 (^ $tokens:ident) => {
1098 $crate::__private::push_caret(&mut $tokens);
1099 };
1100
1101 (^= $tokens:ident) => {
1102 $crate::__private::push_caret_eq(&mut $tokens);
1103 };
1104
1105 (/ $tokens:ident) => {
1106 $crate::__private::push_div(&mut $tokens);
1107 };
1108
1109 (/= $tokens:ident) => {
1110 $crate::__private::push_div_eq(&mut $tokens);
1111 };
1112
1113 (.. $tokens:ident) => {
1114 $crate::__private::push_dot2(&mut $tokens);
1115 };
1116
1117 (... $tokens:ident) => {
1118 $crate::__private::push_dot3(&mut $tokens);
1119 };
1120
1121 (..= $tokens:ident) => {
1122 $crate::__private::push_dot_dot_eq(&mut $tokens);
1123 };
1124
1125 (= $tokens:ident) => {
1126 $crate::__private::push_eq(&mut $tokens);
1127 };
1128
1129 (== $tokens:ident) => {
1130 $crate::__private::push_eq_eq(&mut $tokens);
1131 };
1132
1133 (>= $tokens:ident) => {
1134 $crate::__private::push_ge(&mut $tokens);
1135 };
1136
1137 (> $tokens:ident) => {
1138 $crate::__private::push_gt(&mut $tokens);
1139 };
1140
1141 (<= $tokens:ident) => {
1142 $crate::__private::push_le(&mut $tokens);
1143 };
1144
1145 (< $tokens:ident) => {
1146 $crate::__private::push_lt(&mut $tokens);
1147 };
1148
1149 (*= $tokens:ident) => {
1150 $crate::__private::push_mul_eq(&mut $tokens);
1151 };
1152
1153 (!= $tokens:ident) => {
1154 $crate::__private::push_ne(&mut $tokens);
1155 };
1156
1157 (| $tokens:ident) => {
1158 $crate::__private::push_or(&mut $tokens);
1159 };
1160
1161 (|= $tokens:ident) => {
1162 $crate::__private::push_or_eq(&mut $tokens);
1163 };
1164
1165 (|| $tokens:ident) => {
1166 $crate::__private::push_or_or(&mut $tokens);
1167 };
1168
1169 (? $tokens:ident) => {
1170 $crate::__private::push_question(&mut $tokens);
1171 };
1172
1173 (-> $tokens:ident) => {
1174 $crate::__private::push_rarrow(&mut $tokens);
1175 };
1176
1177 (<- $tokens:ident) => {
1178 $crate::__private::push_larrow(&mut $tokens);
1179 };
1180
1181 (% $tokens:ident) => {
1182 $crate::__private::push_rem(&mut $tokens);
1183 };
1184
1185 (%= $tokens:ident) => {
1186 $crate::__private::push_rem_eq(&mut $tokens);
1187 };
1188
1189 (=> $tokens:ident) => {
1190 $crate::__private::push_fat_arrow(&mut $tokens);
1191 };
1192
1193 (<< $tokens:ident) => {
1194 $crate::__private::push_shl(&mut $tokens);
1195 };
1196
1197 (<<= $tokens:ident) => {
1198 $crate::__private::push_shl_eq(&mut $tokens);
1199 };
1200
1201 (>> $tokens:ident) => {
1202 $crate::__private::push_shr(&mut $tokens);
1203 };
1204
1205 (>>= $tokens:ident) => {
1206 $crate::__private::push_shr_eq(&mut $tokens);
1207 };
1208
1209 (* $tokens:ident) => {
1210 $crate::__private::push_star(&mut $tokens);
1211 };
1212
1213 (- $tokens:ident) => {
1214 $crate::__private::push_sub(&mut $tokens);
1215 };
1216
1217 (-= $tokens:ident) => {
1218 $crate::__private::push_sub_eq(&mut $tokens);
1219 };
1220
1221 ($lifetime:lifetime $tokens:ident) => {
1222 $crate::__private::push_lifetime(&mut $tokens, stringify!($lifetime));
1223 };
1224
1225 (_ $tokens:ident) => {
1226 $crate::__private::push_underscore(&mut $tokens);
1227 };
1228
1229 ($other:tt $tokens:ident) => {
1230 $crate::__private::parse(&mut $tokens, stringify!($other));
1231 };
1232}
1233
1234// See the comment above `quote_token!` about the rule ordering.
1235#[macro_export]
1236#[doc(hidden)]
1237macro_rules! quote_token_spanned {
1238 ($ident:ident $tokens:ident $span:ident) => {
1239 $crate::__private::push_ident_spanned(&mut $tokens, $span, stringify!($ident));
1240 };
1241
1242 (:: $tokens:ident $span:ident) => {
1243 $crate::__private::push_colon2_spanned(&mut $tokens, $span);
1244 };
1245
1246 (( $($inner:tt)* ) $tokens:ident $span:ident) => {
1247 $crate::__private::push_group_spanned(
1248 &mut $tokens,
1249 $span,
1250 $crate::__private::Delimiter::Parenthesis,
1251 $crate::quote_spanned!($span=> $($inner)*),
1252 );
1253 };
1254
1255 ([ $($inner:tt)* ] $tokens:ident $span:ident) => {
1256 $crate::__private::push_group_spanned(
1257 &mut $tokens,
1258 $span,
1259 $crate::__private::Delimiter::Bracket,
1260 $crate::quote_spanned!($span=> $($inner)*),
1261 );
1262 };
1263
1264 ({ $($inner:tt)* } $tokens:ident $span:ident) => {
1265 $crate::__private::push_group_spanned(
1266 &mut $tokens,
1267 $span,
1268 $crate::__private::Delimiter::Brace,
1269 $crate::quote_spanned!($span=> $($inner)*),
1270 );
1271 };
1272
1273 (# $tokens:ident $span:ident) => {
1274 $crate::__private::push_pound_spanned(&mut $tokens, $span);
1275 };
1276
1277 (, $tokens:ident $span:ident) => {
1278 $crate::__private::push_comma_spanned(&mut $tokens, $span);
1279 };
1280
1281 (. $tokens:ident $span:ident) => {
1282 $crate::__private::push_dot_spanned(&mut $tokens, $span);
1283 };
1284
1285 (; $tokens:ident $span:ident) => {
1286 $crate::__private::push_semi_spanned(&mut $tokens, $span);
1287 };
1288
1289 (: $tokens:ident $span:ident) => {
1290 $crate::__private::push_colon_spanned(&mut $tokens, $span);
1291 };
1292
1293 (+ $tokens:ident $span:ident) => {
1294 $crate::__private::push_add_spanned(&mut $tokens, $span);
1295 };
1296
1297 (+= $tokens:ident $span:ident) => {
1298 $crate::__private::push_add_eq_spanned(&mut $tokens, $span);
1299 };
1300
1301 (& $tokens:ident $span:ident) => {
1302 $crate::__private::push_and_spanned(&mut $tokens, $span);
1303 };
1304
1305 (&& $tokens:ident $span:ident) => {
1306 $crate::__private::push_and_and_spanned(&mut $tokens, $span);
1307 };
1308
1309 (&= $tokens:ident $span:ident) => {
1310 $crate::__private::push_and_eq_spanned(&mut $tokens, $span);
1311 };
1312
1313 (@ $tokens:ident $span:ident) => {
1314 $crate::__private::push_at_spanned(&mut $tokens, $span);
1315 };
1316
1317 (! $tokens:ident $span:ident) => {
1318 $crate::__private::push_bang_spanned(&mut $tokens, $span);
1319 };
1320
1321 (^ $tokens:ident $span:ident) => {
1322 $crate::__private::push_caret_spanned(&mut $tokens, $span);
1323 };
1324
1325 (^= $tokens:ident $span:ident) => {
1326 $crate::__private::push_caret_eq_spanned(&mut $tokens, $span);
1327 };
1328
1329 (/ $tokens:ident $span:ident) => {
1330 $crate::__private::push_div_spanned(&mut $tokens, $span);
1331 };
1332
1333 (/= $tokens:ident $span:ident) => {
1334 $crate::__private::push_div_eq_spanned(&mut $tokens, $span);
1335 };
1336
1337 (.. $tokens:ident $span:ident) => {
1338 $crate::__private::push_dot2_spanned(&mut $tokens, $span);
1339 };
1340
1341 (... $tokens:ident $span:ident) => {
1342 $crate::__private::push_dot3_spanned(&mut $tokens, $span);
1343 };
1344
1345 (..= $tokens:ident $span:ident) => {
1346 $crate::__private::push_dot_dot_eq_spanned(&mut $tokens, $span);
1347 };
1348
1349 (= $tokens:ident $span:ident) => {
1350 $crate::__private::push_eq_spanned(&mut $tokens, $span);
1351 };
1352
1353 (== $tokens:ident $span:ident) => {
1354 $crate::__private::push_eq_eq_spanned(&mut $tokens, $span);
1355 };
1356
1357 (>= $tokens:ident $span:ident) => {
1358 $crate::__private::push_ge_spanned(&mut $tokens, $span);
1359 };
1360
1361 (> $tokens:ident $span:ident) => {
1362 $crate::__private::push_gt_spanned(&mut $tokens, $span);
1363 };
1364
1365 (<= $tokens:ident $span:ident) => {
1366 $crate::__private::push_le_spanned(&mut $tokens, $span);
1367 };
1368
1369 (< $tokens:ident $span:ident) => {
1370 $crate::__private::push_lt_spanned(&mut $tokens, $span);
1371 };
1372
1373 (*= $tokens:ident $span:ident) => {
1374 $crate::__private::push_mul_eq_spanned(&mut $tokens, $span);
1375 };
1376
1377 (!= $tokens:ident $span:ident) => {
1378 $crate::__private::push_ne_spanned(&mut $tokens, $span);
1379 };
1380
1381 (| $tokens:ident $span:ident) => {
1382 $crate::__private::push_or_spanned(&mut $tokens, $span);
1383 };
1384
1385 (|= $tokens:ident $span:ident) => {
1386 $crate::__private::push_or_eq_spanned(&mut $tokens, $span);
1387 };
1388
1389 (|| $tokens:ident $span:ident) => {
1390 $crate::__private::push_or_or_spanned(&mut $tokens, $span);
1391 };
1392
1393 (? $tokens:ident $span:ident) => {
1394 $crate::__private::push_question_spanned(&mut $tokens, $span);
1395 };
1396
1397 (-> $tokens:ident $span:ident) => {
1398 $crate::__private::push_rarrow_spanned(&mut $tokens, $span);
1399 };
1400
1401 (<- $tokens:ident $span:ident) => {
1402 $crate::__private::push_larrow_spanned(&mut $tokens, $span);
1403 };
1404
1405 (% $tokens:ident $span:ident) => {
1406 $crate::__private::push_rem_spanned(&mut $tokens, $span);
1407 };
1408
1409 (%= $tokens:ident $span:ident) => {
1410 $crate::__private::push_rem_eq_spanned(&mut $tokens, $span);
1411 };
1412
1413 (=> $tokens:ident $span:ident) => {
1414 $crate::__private::push_fat_arrow_spanned(&mut $tokens, $span);
1415 };
1416
1417 (<< $tokens:ident $span:ident) => {
1418 $crate::__private::push_shl_spanned(&mut $tokens, $span);
1419 };
1420
1421 (<<= $tokens:ident $span:ident) => {
1422 $crate::__private::push_shl_eq_spanned(&mut $tokens, $span);
1423 };
1424
1425 (>> $tokens:ident $span:ident) => {
1426 $crate::__private::push_shr_spanned(&mut $tokens, $span);
1427 };
1428
1429 (>>= $tokens:ident $span:ident) => {
1430 $crate::__private::push_shr_eq_spanned(&mut $tokens, $span);
1431 };
1432
1433 (* $tokens:ident $span:ident) => {
1434 $crate::__private::push_star_spanned(&mut $tokens, $span);
1435 };
1436
1437 (- $tokens:ident $span:ident) => {
1438 $crate::__private::push_sub_spanned(&mut $tokens, $span);
1439 };
1440
1441 (-= $tokens:ident $span:ident) => {
1442 $crate::__private::push_sub_eq_spanned(&mut $tokens, $span);
1443 };
1444
1445 ($lifetime:lifetime $tokens:ident $span:ident) => {
1446 $crate::__private::push_lifetime_spanned(&mut $tokens, $span, stringify!($lifetime));
1447 };
1448
1449 (_ $tokens:ident $span:ident) => {
1450 $crate::__private::push_underscore_spanned(&mut $tokens, $span);
1451 };
1452
1453 ($other:tt $tokens:ident $span:ident) => {
1454 $crate::__private::parse_spanned(&mut $tokens, $span, stringify!($other));
1455 };
1456}