diff options
Diffstat (limited to 'vendor/quote/src/runtime.rs')
| -rw-r--r-- | vendor/quote/src/runtime.rs | 530 |
1 files changed, 0 insertions, 530 deletions
diff --git a/vendor/quote/src/runtime.rs b/vendor/quote/src/runtime.rs deleted file mode 100644 index eff044a..0000000 --- a/vendor/quote/src/runtime.rs +++ /dev/null @@ -1,530 +0,0 @@ -use self::get_span::{GetSpan, GetSpanBase, GetSpanInner}; -use crate::{IdentFragment, ToTokens, TokenStreamExt}; -use core::fmt; -use core::iter; -use core::ops::BitOr; -use proc_macro2::{Group, Ident, Punct, Spacing, TokenTree}; - -#[doc(hidden)] -pub use alloc::format; -#[doc(hidden)] -pub use core::option::Option; - -#[doc(hidden)] -pub type Delimiter = proc_macro2::Delimiter; -#[doc(hidden)] -pub type Span = proc_macro2::Span; -#[doc(hidden)] -pub type TokenStream = proc_macro2::TokenStream; - -#[doc(hidden)] -pub struct HasIterator; // True -#[doc(hidden)] -pub struct ThereIsNoIteratorInRepetition; // False - -impl BitOr<ThereIsNoIteratorInRepetition> for ThereIsNoIteratorInRepetition { - type Output = ThereIsNoIteratorInRepetition; - fn bitor(self, _rhs: ThereIsNoIteratorInRepetition) -> ThereIsNoIteratorInRepetition { - ThereIsNoIteratorInRepetition - } -} - -impl BitOr<ThereIsNoIteratorInRepetition> for HasIterator { - type Output = HasIterator; - fn bitor(self, _rhs: ThereIsNoIteratorInRepetition) -> HasIterator { - HasIterator - } -} - -impl BitOr<HasIterator> for ThereIsNoIteratorInRepetition { - type Output = HasIterator; - fn bitor(self, _rhs: HasIterator) -> HasIterator { - HasIterator - } -} - -impl BitOr<HasIterator> for HasIterator { - type Output = HasIterator; - fn bitor(self, _rhs: HasIterator) -> HasIterator { - HasIterator - } -} - -/// Extension traits used by the implementation of `quote!`. These are defined -/// in separate traits, rather than as a single trait due to ambiguity issues. -/// -/// These traits expose a `quote_into_iter` method which should allow calling -/// whichever impl happens to be applicable. Calling that method repeatedly on -/// the returned value should be idempotent. -#[doc(hidden)] -pub mod ext { - use super::RepInterp; - use super::{HasIterator as HasIter, ThereIsNoIteratorInRepetition as DoesNotHaveIter}; - use crate::ToTokens; - use alloc::collections::btree_set::{self, BTreeSet}; - use core::slice; - - /// Extension trait providing the `quote_into_iter` method on iterators. - #[doc(hidden)] - pub trait RepIteratorExt: Iterator + Sized { - fn quote_into_iter(self) -> (Self, HasIter) { - (self, HasIter) - } - } - - impl<T: Iterator> RepIteratorExt for T {} - - /// Extension trait providing the `quote_into_iter` method for - /// non-iterable types. These types interpolate the same value in each - /// iteration of the repetition. - #[doc(hidden)] - pub trait RepToTokensExt { - /// Pretend to be an iterator for the purposes of `quote_into_iter`. - /// This allows repeated calls to `quote_into_iter` to continue - /// correctly returning DoesNotHaveIter. - fn next(&self) -> Option<&Self> { - Some(self) - } - - fn quote_into_iter(&self) -> (&Self, DoesNotHaveIter) { - (self, DoesNotHaveIter) - } - } - - impl<T: ToTokens + ?Sized> RepToTokensExt for T {} - - /// Extension trait providing the `quote_into_iter` method for types that - /// can be referenced as an iterator. - #[doc(hidden)] - pub trait RepAsIteratorExt<'q> { - type Iter: Iterator; - - fn quote_into_iter(&'q self) -> (Self::Iter, HasIter); - } - - impl<'q, 'a, T: RepAsIteratorExt<'q> + ?Sized> RepAsIteratorExt<'q> for &'a T { - type Iter = T::Iter; - - fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) { - <T as RepAsIteratorExt>::quote_into_iter(*self) - } - } - - impl<'q, 'a, T: RepAsIteratorExt<'q> + ?Sized> RepAsIteratorExt<'q> for &'a mut T { - type Iter = T::Iter; - - fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) { - <T as RepAsIteratorExt>::quote_into_iter(*self) - } - } - - impl<'q, T: 'q> RepAsIteratorExt<'q> for [T] { - type Iter = slice::Iter<'q, T>; - - fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) { - (self.iter(), HasIter) - } - } - - impl<'q, T: 'q> RepAsIteratorExt<'q> for Vec<T> { - type Iter = slice::Iter<'q, T>; - - fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) { - (self.iter(), HasIter) - } - } - - impl<'q, T: 'q> RepAsIteratorExt<'q> for BTreeSet<T> { - type Iter = btree_set::Iter<'q, T>; - - fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) { - (self.iter(), HasIter) - } - } - - impl<'q, T: RepAsIteratorExt<'q>> RepAsIteratorExt<'q> for RepInterp<T> { - type Iter = T::Iter; - - fn quote_into_iter(&'q self) -> (Self::Iter, HasIter) { - self.0.quote_into_iter() - } - } -} - -// Helper type used within interpolations to allow for repeated binding names. -// Implements the relevant traits, and exports a dummy `next()` method. -#[derive(Copy, Clone)] -#[doc(hidden)] -pub struct RepInterp<T>(pub T); - -impl<T> RepInterp<T> { - // This method is intended to look like `Iterator::next`, and is called when - // a name is bound multiple times, as the previous binding will shadow the - // original `Iterator` object. This allows us to avoid advancing the - // iterator multiple times per iteration. - pub fn next(self) -> Option<T> { - Some(self.0) - } -} - -impl<T: Iterator> Iterator for RepInterp<T> { - type Item = T::Item; - - fn next(&mut self) -> Option<Self::Item> { - self.0.next() - } -} - -impl<T: ToTokens> ToTokens for RepInterp<T> { - fn to_tokens(&self, tokens: &mut TokenStream) { - self.0.to_tokens(tokens); - } -} - -#[doc(hidden)] -#[inline] -pub fn get_span<T>(span: T) -> GetSpan<T> { - GetSpan(GetSpanInner(GetSpanBase(span))) -} - -mod get_span { - use core::ops::Deref; - use proc_macro2::extra::DelimSpan; - use proc_macro2::Span; - - pub struct GetSpan<T>(pub(crate) GetSpanInner<T>); - - pub struct GetSpanInner<T>(pub(crate) GetSpanBase<T>); - - pub struct GetSpanBase<T>(pub(crate) T); - - impl GetSpan<Span> { - #[inline] - pub fn __into_span(self) -> Span { - ((self.0).0).0 - } - } - - impl GetSpanInner<DelimSpan> { - #[inline] - pub fn __into_span(&self) -> Span { - (self.0).0.join() - } - } - - impl<T> GetSpanBase<T> { - #[allow(clippy::unused_self)] - pub fn __into_span(&self) -> T { - unreachable!() - } - } - - impl<T> Deref for GetSpan<T> { - type Target = GetSpanInner<T>; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } - } - - impl<T> Deref for GetSpanInner<T> { - type Target = GetSpanBase<T>; - - #[inline] - fn deref(&self) -> &Self::Target { - &self.0 - } - } -} - -#[doc(hidden)] -pub fn push_group(tokens: &mut TokenStream, delimiter: Delimiter, inner: TokenStream) { - tokens.append(Group::new(delimiter, inner)); -} - -#[doc(hidden)] -pub fn push_group_spanned( - tokens: &mut TokenStream, - span: Span, - delimiter: Delimiter, - inner: TokenStream, -) { - let mut g = Group::new(delimiter, inner); - g.set_span(span); - tokens.append(g); -} - -#[doc(hidden)] -pub fn parse(tokens: &mut TokenStream, s: &str) { - let s: TokenStream = s.parse().expect("invalid token stream"); - tokens.extend(iter::once(s)); -} - -#[doc(hidden)] -pub fn parse_spanned(tokens: &mut TokenStream, span: Span, s: &str) { - let s: TokenStream = s.parse().expect("invalid token stream"); - tokens.extend(s.into_iter().map(|t| respan_token_tree(t, span))); -} - -// Token tree with every span replaced by the given one. -fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree { - match &mut token { - TokenTree::Group(g) => { - let stream = g - .stream() - .into_iter() - .map(|token| respan_token_tree(token, span)) - .collect(); - *g = Group::new(g.delimiter(), stream); - g.set_span(span); - } - other => other.set_span(span), - } - token -} - -#[doc(hidden)] -pub fn push_ident(tokens: &mut TokenStream, s: &str) { - let span = Span::call_site(); - push_ident_spanned(tokens, span, s); -} - -#[doc(hidden)] -pub fn push_ident_spanned(tokens: &mut TokenStream, span: Span, s: &str) { - tokens.append(ident_maybe_raw(s, span)); -} - -#[doc(hidden)] -pub fn push_lifetime(tokens: &mut TokenStream, lifetime: &str) { - struct Lifetime<'a> { - name: &'a str, - state: u8, - } - - impl<'a> Iterator for Lifetime<'a> { - type Item = TokenTree; - - fn next(&mut self) -> Option<Self::Item> { - match self.state { - 0 => { - self.state = 1; - Some(TokenTree::Punct(Punct::new('\'', Spacing::Joint))) - } - 1 => { - self.state = 2; - Some(TokenTree::Ident(Ident::new(self.name, Span::call_site()))) - } - _ => None, - } - } - } - - tokens.extend(Lifetime { - name: &lifetime[1..], - state: 0, - }); -} - -#[doc(hidden)] -pub fn push_lifetime_spanned(tokens: &mut TokenStream, span: Span, lifetime: &str) { - struct Lifetime<'a> { - name: &'a str, - span: Span, - state: u8, - } - - impl<'a> Iterator for Lifetime<'a> { - type Item = TokenTree; - - fn next(&mut self) -> Option<Self::Item> { - match self.state { - 0 => { - self.state = 1; - let mut apostrophe = Punct::new('\'', Spacing::Joint); - apostrophe.set_span(self.span); - Some(TokenTree::Punct(apostrophe)) - } - 1 => { - self.state = 2; - Some(TokenTree::Ident(Ident::new(self.name, self.span))) - } - _ => None, - } - } - } - - tokens.extend(Lifetime { - name: &lifetime[1..], - span, - state: 0, - }); -} - -macro_rules! push_punct { - ($name:ident $spanned:ident $char1:tt) => { - #[doc(hidden)] - pub fn $name(tokens: &mut TokenStream) { - tokens.append(Punct::new($char1, Spacing::Alone)); - } - #[doc(hidden)] - pub fn $spanned(tokens: &mut TokenStream, span: Span) { - let mut punct = Punct::new($char1, Spacing::Alone); - punct.set_span(span); - tokens.append(punct); - } - }; - ($name:ident $spanned:ident $char1:tt $char2:tt) => { - #[doc(hidden)] - pub fn $name(tokens: &mut TokenStream) { - tokens.append(Punct::new($char1, Spacing::Joint)); - tokens.append(Punct::new($char2, Spacing::Alone)); - } - #[doc(hidden)] - pub fn $spanned(tokens: &mut TokenStream, span: Span) { - let mut punct = Punct::new($char1, Spacing::Joint); - punct.set_span(span); - tokens.append(punct); - let mut punct = Punct::new($char2, Spacing::Alone); - punct.set_span(span); - tokens.append(punct); - } - }; - ($name:ident $spanned:ident $char1:tt $char2:tt $char3:tt) => { - #[doc(hidden)] - pub fn $name(tokens: &mut TokenStream) { - tokens.append(Punct::new($char1, Spacing::Joint)); - tokens.append(Punct::new($char2, Spacing::Joint)); - tokens.append(Punct::new($char3, Spacing::Alone)); - } - #[doc(hidden)] - pub fn $spanned(tokens: &mut TokenStream, span: Span) { - let mut punct = Punct::new($char1, Spacing::Joint); - punct.set_span(span); - tokens.append(punct); - let mut punct = Punct::new($char2, Spacing::Joint); - punct.set_span(span); - tokens.append(punct); - let mut punct = Punct::new($char3, Spacing::Alone); - punct.set_span(span); - tokens.append(punct); - } - }; -} - -push_punct!(push_add push_add_spanned '+'); -push_punct!(push_add_eq push_add_eq_spanned '+' '='); -push_punct!(push_and push_and_spanned '&'); -push_punct!(push_and_and push_and_and_spanned '&' '&'); -push_punct!(push_and_eq push_and_eq_spanned '&' '='); -push_punct!(push_at push_at_spanned '@'); -push_punct!(push_bang push_bang_spanned '!'); -push_punct!(push_caret push_caret_spanned '^'); -push_punct!(push_caret_eq push_caret_eq_spanned '^' '='); -push_punct!(push_colon push_colon_spanned ':'); -push_punct!(push_colon2 push_colon2_spanned ':' ':'); -push_punct!(push_comma push_comma_spanned ','); -push_punct!(push_div push_div_spanned '/'); -push_punct!(push_div_eq push_div_eq_spanned '/' '='); -push_punct!(push_dot push_dot_spanned '.'); -push_punct!(push_dot2 push_dot2_spanned '.' '.'); -push_punct!(push_dot3 push_dot3_spanned '.' '.' '.'); -push_punct!(push_dot_dot_eq push_dot_dot_eq_spanned '.' '.' '='); -push_punct!(push_eq push_eq_spanned '='); -push_punct!(push_eq_eq push_eq_eq_spanned '=' '='); -push_punct!(push_ge push_ge_spanned '>' '='); -push_punct!(push_gt push_gt_spanned '>'); -push_punct!(push_le push_le_spanned '<' '='); -push_punct!(push_lt push_lt_spanned '<'); -push_punct!(push_mul_eq push_mul_eq_spanned '*' '='); -push_punct!(push_ne push_ne_spanned '!' '='); -push_punct!(push_or push_or_spanned '|'); -push_punct!(push_or_eq push_or_eq_spanned '|' '='); -push_punct!(push_or_or push_or_or_spanned '|' '|'); -push_punct!(push_pound push_pound_spanned '#'); -push_punct!(push_question push_question_spanned '?'); -push_punct!(push_rarrow push_rarrow_spanned '-' '>'); -push_punct!(push_larrow push_larrow_spanned '<' '-'); -push_punct!(push_rem push_rem_spanned '%'); -push_punct!(push_rem_eq push_rem_eq_spanned '%' '='); -push_punct!(push_fat_arrow push_fat_arrow_spanned '=' '>'); -push_punct!(push_semi push_semi_spanned ';'); -push_punct!(push_shl push_shl_spanned '<' '<'); -push_punct!(push_shl_eq push_shl_eq_spanned '<' '<' '='); -push_punct!(push_shr push_shr_spanned '>' '>'); -push_punct!(push_shr_eq push_shr_eq_spanned '>' '>' '='); -push_punct!(push_star push_star_spanned '*'); -push_punct!(push_sub push_sub_spanned '-'); -push_punct!(push_sub_eq push_sub_eq_spanned '-' '='); - -#[doc(hidden)] -pub fn push_underscore(tokens: &mut TokenStream) { - push_underscore_spanned(tokens, Span::call_site()); -} - -#[doc(hidden)] -pub fn push_underscore_spanned(tokens: &mut TokenStream, span: Span) { - tokens.append(Ident::new("_", span)); -} - -// Helper method for constructing identifiers from the `format_ident!` macro, -// handling `r#` prefixes. -#[doc(hidden)] -pub fn mk_ident(id: &str, span: Option<Span>) -> Ident { - let span = span.unwrap_or_else(Span::call_site); - ident_maybe_raw(id, span) -} - -fn ident_maybe_raw(id: &str, span: Span) -> Ident { - if let Some(id) = id.strip_prefix("r#") { - Ident::new_raw(id, span) - } else { - Ident::new(id, span) - } -} - -// Adapts from `IdentFragment` to `fmt::Display` for use by the `format_ident!` -// macro, and exposes span information from these fragments. -// -// This struct also has forwarding implementations of the formatting traits -// `Octal`, `LowerHex`, `UpperHex`, and `Binary` to allow for their use within -// `format_ident!`. -#[derive(Copy, Clone)] -#[doc(hidden)] -pub struct IdentFragmentAdapter<T: IdentFragment>(pub T); - -impl<T: IdentFragment> IdentFragmentAdapter<T> { - pub fn span(&self) -> Option<Span> { - self.0.span() - } -} - -impl<T: IdentFragment> fmt::Display for IdentFragmentAdapter<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - IdentFragment::fmt(&self.0, f) - } -} - -impl<T: IdentFragment + fmt::Octal> fmt::Octal for IdentFragmentAdapter<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Octal::fmt(&self.0, f) - } -} - -impl<T: IdentFragment + fmt::LowerHex> fmt::LowerHex for IdentFragmentAdapter<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::LowerHex::fmt(&self.0, f) - } -} - -impl<T: IdentFragment + fmt::UpperHex> fmt::UpperHex for IdentFragmentAdapter<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::UpperHex::fmt(&self.0, f) - } -} - -impl<T: IdentFragment + fmt::Binary> fmt::Binary for IdentFragmentAdapter<T> { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Binary::fmt(&self.0, f) - } -} |