rust: quote: import crate (a4851eee) · Commits · git / linux-net

rust/quote/ext.rs

0 → 100644

+110 −0

Original line number	Diff line number	Diff line
		use super::ToTokens;
		use core::iter;
		use proc_macro2::{TokenStream, TokenTree};

		/// TokenStream extension trait with methods for appending tokens.
		///
		/// This trait is sealed and cannot be implemented outside of the `quote` crate.
		pub trait TokenStreamExt: private::Sealed {
		/// For use by `ToTokens` implementations.
		///
		/// Appends the token specified to this list of tokens.
		fn append<U>(&mut self, token: U)
		where
		U: Into<TokenTree>;

		/// For use by `ToTokens` implementations.
		///
		/// ```
		/// # use quote::{quote, TokenStreamExt, ToTokens};
		/// # use proc_macro2::TokenStream;
		/// #
		/// struct X;
		///
		/// impl ToTokens for X {
		/// fn to_tokens(&self, tokens: &mut TokenStream) {
		/// tokens.append_all(&[true, false]);
		/// }
		/// }
		///
		/// let tokens = quote!(#X);
		/// assert_eq!(tokens.to_string(), "true false");
		/// ```
		fn append_all<I>(&mut self, iter: I)
		where
		I: IntoIterator,
		I::Item: ToTokens;

		/// For use by `ToTokens` implementations.
		///
		/// Appends all of the items in the iterator `I`, separated by the tokens
		/// `U`.
		fn append_separated<I, U>(&mut self, iter: I, op: U)
		where
		I: IntoIterator,
		I::Item: ToTokens,
		U: ToTokens;

		/// For use by `ToTokens` implementations.
		///
		/// Appends all tokens in the iterator `I`, appending `U` after each
		/// element, including after the last element of the iterator.
		fn append_terminated<I, U>(&mut self, iter: I, term: U)
		where
		I: IntoIterator,
		I::Item: ToTokens,
		U: ToTokens;
		}

		impl TokenStreamExt for TokenStream {
		fn append<U>(&mut self, token: U)
		where
		U: Into<TokenTree>,
		{
		self.extend(iter::once(token.into()));
		}

		fn append_all<I>(&mut self, iter: I)
		where
		I: IntoIterator,
		I::Item: ToTokens,
		{
		for token in iter {
		token.to_tokens(self);
		}
		}

		fn append_separated<I, U>(&mut self, iter: I, op: U)
		where
		I: IntoIterator,
		I::Item: ToTokens,
		U: ToTokens,
		{
		for (i, token) in iter.into_iter().enumerate() {
		if i > 0 {
		op.to_tokens(self);
		}
		token.to_tokens(self);
		}
		}

		fn append_terminated<I, U>(&mut self, iter: I, term: U)
		where
		I: IntoIterator,
		I::Item: ToTokens,
		U: ToTokens,
		{
		for token in iter {
		token.to_tokens(self);
		term.to_tokens(self);
		}
		}
		}

		mod private {
		use proc_macro2::TokenStream;

		pub trait Sealed {}

		impl Sealed for TokenStream {}
		}

rust/quote/format.rs

0 → 100644

+168 −0

Original line number	Diff line number	Diff line
		/// Formatting macro for constructing `Ident`s.
		///
		/// <br>
		///
		/// # Syntax
		///
		/// Syntax is copied from the [`format!`] macro, supporting both positional and
		/// named arguments.
		///
		/// Only a limited set of formatting traits are supported. The current mapping
		/// of format types to traits is:
		///
		/// * `{}` ⇒ [`IdentFragment`]
		/// * `{:o}` ⇒ [`Octal`](std::fmt::Octal)
		/// * `{:x}` ⇒ [`LowerHex`](std::fmt::LowerHex)
		/// * `{:X}` ⇒ [`UpperHex`](std::fmt::UpperHex)
		/// * `{:b}` ⇒ [`Binary`](std::fmt::Binary)
		///
		/// See [`std::fmt`] for more information.
		///
		/// <br>
		///
		/// # IdentFragment
		///
		/// Unlike `format!`, this macro uses the [`IdentFragment`] formatting trait by
		/// default. This trait is like `Display`, with a few differences:
		///
		/// * `IdentFragment` is only implemented for a limited set of types, such as
		/// unsigned integers and strings.
		/// * [`Ident`] arguments will have their `r#` prefixes stripped, if present.
		///
		/// [`IdentFragment`]: crate::IdentFragment
		/// [`Ident`]: proc_macro2::Ident
		///
		/// <br>
		///
		/// # Hygiene
		///
		/// The [`Span`] of the first `Ident` argument is used as the span of the final
		/// identifier, falling back to [`Span::call_site`] when no identifiers are
		/// provided.
		///
		/// ```
		/// # use quote::format_ident;
		/// # let ident = format_ident!("Ident");
		/// // If `ident` is an Ident, the span of `my_ident` will be inherited from it.
		/// let my_ident = format_ident!("My{}{}", ident, "IsCool");
		/// assert_eq!(my_ident, "MyIdentIsCool");
		/// ```
		///
		/// Alternatively, the span can be overridden by passing the `span` named
		/// argument.
		///
		/// ```
		/// # use quote::format_ident;
		/// # const IGNORE_TOKENS: &'static str = stringify! {
		/// let my_span = /* ... */;
		/// # };
		/// # let my_span = proc_macro2::Span::call_site();
		/// format_ident!("MyIdent", span = my_span);
		/// ```
		///
		/// [`Span`]: proc_macro2::Span
		/// [`Span::call_site`]: proc_macro2::Span::call_site
		///
		/// <p><br></p>
		///
		/// # Panics
		///
		/// This method will panic if the resulting formatted string is not a valid
		/// identifier.
		///
		/// <br>
		///
		/// # Examples
		///
		/// Composing raw and non-raw identifiers:
		/// ```
		/// # use quote::format_ident;
		/// let my_ident = format_ident!("My{}", "Ident");
		/// assert_eq!(my_ident, "MyIdent");
		///
		/// let raw = format_ident!("r#Raw");
		/// assert_eq!(raw, "r#Raw");
		///
		/// let my_ident_raw = format_ident!("{}Is{}", my_ident, raw);
		/// assert_eq!(my_ident_raw, "MyIdentIsRaw");
		/// ```
		///
		/// Integer formatting options:
		/// ```
		/// # use quote::format_ident;
		/// let num: u32 = 10;
		///
		/// let decimal = format_ident!("Id_{}", num);
		/// assert_eq!(decimal, "Id_10");
		///
		/// let octal = format_ident!("Id_{:o}", num);
		/// assert_eq!(octal, "Id_12");
		///
		/// let binary = format_ident!("Id_{:b}", num);
		/// assert_eq!(binary, "Id_1010");
		///
		/// let lower_hex = format_ident!("Id_{:x}", num);
		/// assert_eq!(lower_hex, "Id_a");
		///
		/// let upper_hex = format_ident!("Id_{:X}", num);
		/// assert_eq!(upper_hex, "Id_A");
		/// ```
		#[macro_export]
		macro_rules! format_ident {
		($fmt:expr) => {
		$crate::format_ident_impl!([
		$crate::__private::Option::None,
		$fmt
		])
		};

		($fmt:expr, $($rest:tt)*) => {
		$crate::format_ident_impl!([
		$crate::__private::Option::None,
		$fmt
		] $($rest)*)
		};
		}

		#[macro_export]
		#[doc(hidden)]
		macro_rules! format_ident_impl {
		// Final state
		([$span:expr, $($fmt:tt)*]) => {
		$crate::__private::mk_ident(
		&$crate::__private::format!($($fmt)*),
		$span,
		)
		};

		// Span argument
		([$old:expr, $($fmt:tt)*] span = $span:expr) => {
		$crate::format_ident_impl!([$old, $($fmt)*] span = $span,)
		};
		([$old:expr, $($fmt:tt)] span = $span:expr, $($rest:tt)) => {
		$crate::format_ident_impl!([
		$crate::__private::Option::Some::<$crate::__private::Span>($span),
		$($fmt)*
		] $($rest)*)
		};

		// Named argument
		([$span:expr, $($fmt:tt)*] $name:ident = $arg:expr) => {
		$crate::format_ident_impl!([$span, $($fmt)*] $name = $arg,)
		};
		([$span:expr, $($fmt:tt)] $name:ident = $arg:expr, $($rest:tt)) => {
		match $crate::__private::IdentFragmentAdapter(&$arg) {
		arg => $crate::format_ident_impl!([$span.or(arg.span()), $($fmt), $name = arg] $($rest)),
		}
		};

		// Positional argument
		([$span:expr, $($fmt:tt)*] $arg:expr) => {
		$crate::format_ident_impl!([$span, $($fmt)*] $arg,)
		};
		([$span:expr, $($fmt:tt)] $arg:expr, $($rest:tt)) => {
		match $crate::__private::IdentFragmentAdapter(&$arg) {
		arg => $crate::format_ident_impl!([$span.or(arg.span()), $($fmt), arg] $($rest)),
		}
		};
		}

rust/quote/ident_fragment.rs

0 → 100644

+88 −0

Original line number	Diff line number	Diff line
		use alloc::borrow::Cow;
		use core::fmt;
		use proc_macro2::{Ident, Span};

		/// Specialized formatting trait used by `format_ident!`.
		///
		/// [`Ident`] arguments formatted using this trait will have their `r#` prefix
		/// stripped, if present.
		///
		/// See [`format_ident!`] for more information.
		///
		/// [`format_ident!`]: crate::format_ident
		pub trait IdentFragment {
		/// Format this value as an identifier fragment.
		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result;

		/// Span associated with this `IdentFragment`.
		///
		/// If non-`None`, may be inherited by formatted identifiers.
		fn span(&self) -> Option<Span> {
		None
		}
		}

		impl<T: IdentFragment + ?Sized> IdentFragment for &T {
		fn span(&self) -> Option<Span> {
		<T as IdentFragment>::span(*self)
		}

		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		IdentFragment::fmt(*self, f)
		}
		}

		impl<T: IdentFragment + ?Sized> IdentFragment for &mut T {
		fn span(&self) -> Option<Span> {
		<T as IdentFragment>::span(*self)
		}

		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		IdentFragment::fmt(*self, f)
		}
		}

		impl IdentFragment for Ident {
		fn span(&self) -> Option<Span> {
		Some(self.span())
		}

		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		let id = self.to_string();
		if let Some(id) = id.strip_prefix("r#") {
		fmt::Display::fmt(id, f)
		} else {
		fmt::Display::fmt(&id[..], f)
		}
		}
		}

		impl<T> IdentFragment for Cow<'_, T>
		where
		T: IdentFragment + ToOwned + ?Sized,
		{
		fn span(&self) -> Option<Span> {
		T::span(self)
		}

		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		T::fmt(self, f)
		}
		}

		// Limited set of types which this is implemented for, as we want to avoid types
		// which will often include non-identifier characters in their `Display` impl.
		macro_rules! ident_fragment_display {
		($($T:ty),*) => {
		$(
		impl IdentFragment for $T {
		fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
		fmt::Display::fmt(self, f)
		}
		}
		)*
		};
		}

		ident_fragment_display!(bool, str, String, char);
		ident_fragment_display!(u8, u16, u32, u64, u128, usize);

rust/quote/lib.rs

0 → 100644

+1454 −0

File added.

Preview size limit exceeded, changes collapsed.

rust/quote/runtime.rs

0 → 100644

+492 −0

File added.

Preview size limit exceeded, changes collapsed.