| 1 |
/// Define a type that supports parsing and printing a multi-character symbol |
| 2 |
/// as if it were a punctuation token. |
| 3 |
/// |
| 4 |
/// # Usage |
| 5 |
/// |
| 6 |
/// ``` |
| 7 |
/// syn::custom_punctuation!(LeftRightArrow, <=>); |
| 8 |
/// ``` |
| 9 |
/// |
| 10 |
/// The generated syntax tree node supports the following operations just like |
| 11 |
/// any built-in punctuation token. |
| 12 |
/// |
| 13 |
/// - [Peeking] — `input.peek(LeftRightArrow)` |
| 14 |
/// |
| 15 |
/// - [Parsing] — `input.parse::<LeftRightArrow>()?` |
| 16 |
/// |
| 17 |
/// - [Printing] — `quote!( ... #lrarrow ... )` |
| 18 |
/// |
| 19 |
/// - Construction from a [`Span`] — `let lrarrow = LeftRightArrow(sp)` |
| 20 |
/// |
| 21 |
/// - Construction from multiple [`Span`] — `let lrarrow = LeftRightArrow([sp, sp, sp])` |
| 22 |
/// |
| 23 |
/// - Field access to its spans — `let spans = lrarrow.spans` |
| 24 |
/// |
| 25 |
/// [Peeking]: crate::parse::ParseBuffer::peek |
| 26 |
/// [Parsing]: crate::parse::ParseBuffer::parse |
| 27 |
/// [Printing]: quote::ToTokens |
| 28 |
/// [`Span`]: proc_macro2::Span |
| 29 |
/// |
| 30 |
/// # Example |
| 31 |
/// |
| 32 |
/// ``` |
| 33 |
/// use proc_macro2::{TokenStream, TokenTree}; |
| 34 |
/// use syn::parse::{Parse, ParseStream, Peek, Result}; |
| 35 |
/// use syn::punctuated::Punctuated; |
| 36 |
/// use syn::Expr; |
| 37 |
/// |
| 38 |
/// syn::custom_punctuation!(PathSeparator, </>); |
| 39 |
/// |
| 40 |
/// // expr </> expr </> expr ... |
| 41 |
/// struct PathSegments { |
| 42 |
/// segments: Punctuated<Expr, PathSeparator>, |
| 43 |
/// } |
| 44 |
/// |
| 45 |
/// impl Parse for PathSegments { |
| 46 |
/// fn parse(input: ParseStream) -> Result<Self> { |
| 47 |
/// let mut segments = Punctuated::new(); |
| 48 |
/// |
| 49 |
/// let first = parse_until(input, PathSeparator)?; |
| 50 |
/// segments.push_value(syn::parse2(first)?); |
| 51 |
/// |
| 52 |
/// while input.peek(PathSeparator) { |
| 53 |
/// segments.push_punct(input.parse()?); |
| 54 |
/// |
| 55 |
/// let next = parse_until(input, PathSeparator)?; |
| 56 |
/// segments.push_value(syn::parse2(next)?); |
| 57 |
/// } |
| 58 |
/// |
| 59 |
/// Ok(PathSegments { segments }) |
| 60 |
/// } |
| 61 |
/// } |
| 62 |
/// |
| 63 |
/// fn parse_until<E: Peek>(input: ParseStream, end: E) -> Result<TokenStream> { |
| 64 |
/// let mut tokens = TokenStream::new(); |
| 65 |
/// while !input.is_empty() && !input.peek(end) { |
| 66 |
/// let next: TokenTree = input.parse()?; |
| 67 |
/// tokens.extend(Some(next)); |
| 68 |
/// } |
| 69 |
/// Ok(tokens) |
| 70 |
/// } |
| 71 |
/// |
| 72 |
/// fn main() { |
| 73 |
/// let input = r#" a::b </> c::d::e "#; |
| 74 |
/// let _: PathSegments = syn::parse_str(input).unwrap(); |
| 75 |
/// } |
| 76 |
/// ``` |
| 77 |
#[macro_export] |
| 78 |
macro_rules! custom_punctuation { |
| 79 |
($ident:ident, $($tt:tt)+) => { |
| 80 |
pub struct $ident { |
| 81 |
pub spans: $crate::custom_punctuation_repr!($($tt)+), |
| 82 |
} |
| 83 |
|
| 84 |
#[doc(hidden)] |
| 85 |
#[allow(dead_code, non_snake_case)] |
| 86 |
pub fn $ident<__S: $crate::__private::IntoSpans<$crate::custom_punctuation_repr!($($tt)+)>>( |
| 87 |
spans: __S, |
| 88 |
) -> $ident { |
| 89 |
let _validate_len = 0 $(+ $crate::custom_punctuation_len!(strict, $tt))*; |
| 90 |
$ident { |
| 91 |
spans: $crate::__private::IntoSpans::into_spans(spans) |
| 92 |
} |
| 93 |
} |
| 94 |
|
| 95 |
impl $crate::__private::Default for $ident { |
| 96 |
fn default() -> Self { |
| 97 |
$ident($crate::__private::Span::call_site()) |
| 98 |
} |
| 99 |
} |
| 100 |
|
| 101 |
$crate::impl_parse_for_custom_punctuation!($ident, $($tt)+); |
| 102 |
$crate::impl_to_tokens_for_custom_punctuation!($ident, $($tt)+); |
| 103 |
$crate::impl_clone_for_custom_punctuation!($ident, $($tt)+); |
| 104 |
$crate::impl_extra_traits_for_custom_punctuation!($ident, $($tt)+); |
| 105 |
}; |
| 106 |
} |
| 107 |
|
| 108 |
// Not public API. |
| 109 |
#[cfg(feature = "parsing")] |
| 110 |
#[doc(hidden)] |
| 111 |
#[macro_export] |
| 112 |
macro_rules! impl_parse_for_custom_punctuation { |
| 113 |
($ident:ident, $($tt:tt)+) => { |
| 114 |
impl $crate::token::CustomToken for $ident { |
| 115 |
fn peek(cursor: $crate::buffer::Cursor) -> bool { |
| 116 |
$crate::token::parsing::peek_punct(cursor, $crate::stringify_punct!($($tt)+)) |
| 117 |
} |
| 118 |
|
| 119 |
fn display() -> &'static $crate::__private::str { |
| 120 |
concat!("`", $crate::stringify_punct!($($tt)+), "`") |
| 121 |
} |
| 122 |
} |
| 123 |
|
| 124 |
impl $crate::parse::Parse for $ident { |
| 125 |
fn parse(input: $crate::parse::ParseStream) -> $crate::parse::Result<$ident> { |
| 126 |
let spans: $crate::custom_punctuation_repr!($($tt)+) = |
| 127 |
$crate::token::parsing::punct(input, $crate::stringify_punct!($($tt)+))?; |
| 128 |
Ok($ident(spans)) |
| 129 |
} |
| 130 |
} |
| 131 |
}; |
| 132 |
} |
| 133 |
|
| 134 |
// Not public API. |
| 135 |
#[cfg(not(feature = "parsing"))] |
| 136 |
#[doc(hidden)] |
| 137 |
#[macro_export] |
| 138 |
macro_rules! impl_parse_for_custom_punctuation { |
| 139 |
($ident:ident, $($tt:tt)+) => {}; |
| 140 |
} |
| 141 |
|
| 142 |
// Not public API. |
| 143 |
#[cfg(feature = "printing")] |
| 144 |
#[doc(hidden)] |
| 145 |
#[macro_export] |
| 146 |
macro_rules! impl_to_tokens_for_custom_punctuation { |
| 147 |
($ident:ident, $($tt:tt)+) => { |
| 148 |
impl $crate::__private::ToTokens for $ident { |
| 149 |
fn to_tokens(&self, tokens: &mut $crate::__private::TokenStream2) { |
| 150 |
$crate::token::printing::punct($crate::stringify_punct!($($tt)+), &self.spans, tokens) |
| 151 |
} |
| 152 |
} |
| 153 |
}; |
| 154 |
} |
| 155 |
|
| 156 |
// Not public API. |
| 157 |
#[cfg(not(feature = "printing"))] |
| 158 |
#[doc(hidden)] |
| 159 |
#[macro_export] |
| 160 |
macro_rules! impl_to_tokens_for_custom_punctuation { |
| 161 |
($ident:ident, $($tt:tt)+) => {}; |
| 162 |
} |
| 163 |
|
| 164 |
// Not public API. |
| 165 |
#[cfg(feature = "clone-impls")] |
| 166 |
#[doc(hidden)] |
| 167 |
#[macro_export] |
| 168 |
macro_rules! impl_clone_for_custom_punctuation { |
| 169 |
($ident:ident, $($tt:tt)+) => { |
| 170 |
impl $crate::__private::Copy for $ident {} |
| 171 |
|
| 172 |
#[allow(clippy::expl_impl_clone_on_copy)] |
| 173 |
impl $crate::__private::Clone for $ident { |
| 174 |
fn clone(&self) -> Self { |
| 175 |
*self |
| 176 |
} |
| 177 |
} |
| 178 |
}; |
| 179 |
} |
| 180 |
|
| 181 |
// Not public API. |
| 182 |
#[cfg(not(feature = "clone-impls"))] |
| 183 |
#[doc(hidden)] |
| 184 |
#[macro_export] |
| 185 |
macro_rules! impl_clone_for_custom_punctuation { |
| 186 |
($ident:ident, $($tt:tt)+) => {}; |
| 187 |
} |
| 188 |
|
| 189 |
// Not public API. |
| 190 |
#[cfg(feature = "extra-traits")] |
| 191 |
#[doc(hidden)] |
| 192 |
#[macro_export] |
| 193 |
macro_rules! impl_extra_traits_for_custom_punctuation { |
| 194 |
($ident:ident, $($tt:tt)+) => { |
| 195 |
impl $crate::__private::Debug for $ident { |
| 196 |
fn fmt(&self, f: &mut $crate::__private::Formatter) -> $crate::__private::fmt::Result { |
| 197 |
$crate::__private::Formatter::write_str(f, stringify!($ident)) |
| 198 |
} |
| 199 |
} |
| 200 |
|
| 201 |
impl $crate::__private::Eq for $ident {} |
| 202 |
|
| 203 |
impl $crate::__private::PartialEq for $ident { |
| 204 |
fn eq(&self, _other: &Self) -> $crate::__private::bool { |
| 205 |
true |
| 206 |
} |
| 207 |
} |
| 208 |
|
| 209 |
impl $crate::__private::Hash for $ident { |
| 210 |
fn hash<__H: $crate::__private::Hasher>(&self, _state: &mut __H) {} |
| 211 |
} |
| 212 |
}; |
| 213 |
} |
| 214 |
|
| 215 |
// Not public API. |
| 216 |
#[cfg(not(feature = "extra-traits"))] |
| 217 |
#[doc(hidden)] |
| 218 |
#[macro_export] |
| 219 |
macro_rules! impl_extra_traits_for_custom_punctuation { |
| 220 |
($ident:ident, $($tt:tt)+) => {}; |
| 221 |
} |
| 222 |
|
| 223 |
// Not public API. |
| 224 |
#[doc(hidden)] |
| 225 |
#[macro_export] |
| 226 |
macro_rules! custom_punctuation_repr { |
| 227 |
($($tt:tt)+) => { |
| 228 |
[$crate::__private::Span; 0 $(+ $crate::custom_punctuation_len!(lenient, $tt))+] |
| 229 |
}; |
| 230 |
} |
| 231 |
|
| 232 |
// Not public API. |
| 233 |
#[doc(hidden)] |
| 234 |
#[macro_export] |
| 235 |
#[rustfmt::skip] |
| 236 |
macro_rules! custom_punctuation_len { |
| 237 |
($mode:ident, +) => { 1 }; |
| 238 |
($mode:ident, +=) => { 2 }; |
| 239 |
($mode:ident, &) => { 1 }; |
| 240 |
($mode:ident, &&) => { 2 }; |
| 241 |
($mode:ident, &=) => { 2 }; |
| 242 |
($mode:ident, @) => { 1 }; |
| 243 |
($mode:ident, !) => { 1 }; |
| 244 |
($mode:ident, ^) => { 1 }; |
| 245 |
($mode:ident, ^=) => { 2 }; |
| 246 |
($mode:ident, :) => { 1 }; |
| 247 |
($mode:ident, ::) => { 2 }; |
| 248 |
($mode:ident, ,) => { 1 }; |
| 249 |
($mode:ident, /) => { 1 }; |
| 250 |
($mode:ident, /=) => { 2 }; |
| 251 |
($mode:ident, .) => { 1 }; |
| 252 |
($mode:ident, ..) => { 2 }; |
| 253 |
($mode:ident, ...) => { 3 }; |
| 254 |
($mode:ident, ..=) => { 3 }; |
| 255 |
($mode:ident, =) => { 1 }; |
| 256 |
($mode:ident, ==) => { 2 }; |
| 257 |
($mode:ident, >=) => { 2 }; |
| 258 |
($mode:ident, >) => { 1 }; |
| 259 |
($mode:ident, <=) => { 2 }; |
| 260 |
($mode:ident, <) => { 1 }; |
| 261 |
($mode:ident, *=) => { 2 }; |
| 262 |
($mode:ident, !=) => { 2 }; |
| 263 |
($mode:ident, |) => { 1 }; |
| 264 |
($mode:ident, |=) => { 2 }; |
| 265 |
($mode:ident, ||) => { 2 }; |
| 266 |
($mode:ident, #) => { 1 }; |
| 267 |
($mode:ident, ?) => { 1 }; |
| 268 |
($mode:ident, ->) => { 2 }; |
| 269 |
($mode:ident, <-) => { 2 }; |
| 270 |
($mode:ident, %) => { 1 }; |
| 271 |
($mode:ident, %=) => { 2 }; |
| 272 |
($mode:ident, =>) => { 2 }; |
| 273 |
($mode:ident, ;) => { 1 }; |
| 274 |
($mode:ident, <<) => { 2 }; |
| 275 |
($mode:ident, <<=) => { 3 }; |
| 276 |
($mode:ident, >>) => { 2 }; |
| 277 |
($mode:ident, >>=) => { 3 }; |
| 278 |
($mode:ident, *) => { 1 }; |
| 279 |
($mode:ident, -) => { 1 }; |
| 280 |
($mode:ident, -=) => { 2 }; |
| 281 |
($mode:ident, ~) => { 1 }; |
| 282 |
(lenient, $tt:tt) => { 0 }; |
| 283 |
(strict, $tt:tt) => {{ $crate::custom_punctuation_unexpected!($tt); 0 }}; |
| 284 |
} |
| 285 |
|
| 286 |
// Not public API. |
| 287 |
#[doc(hidden)] |
| 288 |
#[macro_export] |
| 289 |
macro_rules! custom_punctuation_unexpected { |
| 290 |
() => {}; |
| 291 |
} |
| 292 |
|
| 293 |
// Not public API. |
| 294 |
#[doc(hidden)] |
| 295 |
#[macro_export] |
| 296 |
macro_rules! stringify_punct { |
| 297 |
($($tt:tt)+) => { |
| 298 |
concat!($(stringify!($tt)),+) |
| 299 |
}; |
| 300 |
} |