David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 1 | use proc_macro2::{Delimiter, Span}; |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 2 | |
David Tolnay | ad4b247 | 2018-08-25 08:25:24 -0400 | [diff] [blame] | 3 | use error::Result; |
David Tolnay | d658dab | 2018-09-01 02:47:42 -0700 | [diff] [blame] | 4 | use parse::{ParseBuffer, ParseStream}; |
David Tolnay | 94f0663 | 2018-08-31 10:17:17 -0700 | [diff] [blame] | 5 | use private; |
David Tolnay | 776f8e0 | 2018-08-24 22:32:10 -0400 | [diff] [blame] | 6 | use token; |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 7 | |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 8 | // Not public API. |
| 9 | #[doc(hidden)] |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 10 | pub struct Parens<'a> { |
| 11 | pub token: token::Paren, |
| 12 | pub content: ParseBuffer<'a>, |
| 13 | } |
| 14 | |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 15 | // Not public API. |
| 16 | #[doc(hidden)] |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 17 | pub struct Braces<'a> { |
| 18 | pub token: token::Brace, |
| 19 | pub content: ParseBuffer<'a>, |
| 20 | } |
| 21 | |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 22 | // Not public API. |
| 23 | #[doc(hidden)] |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 24 | pub struct Brackets<'a> { |
| 25 | pub token: token::Bracket, |
| 26 | pub content: ParseBuffer<'a>, |
| 27 | } |
| 28 | |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 29 | // Not public API. |
David Tolnay | aa77a85 | 2018-08-31 11:15:10 -0700 | [diff] [blame] | 30 | #[cfg(any(feature = "full", feature = "derive"))] |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 31 | #[doc(hidden)] |
David Tolnay | a7d69fc | 2018-08-26 13:30:24 -0400 | [diff] [blame] | 32 | pub struct Group<'a> { |
| 33 | pub token: token::Group, |
| 34 | pub content: ParseBuffer<'a>, |
| 35 | } |
| 36 | |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 37 | // Not public API. |
| 38 | #[doc(hidden)] |
| 39 | pub fn parse_parens(input: ParseStream) -> Result<Parens> { |
David Tolnay | 70f30e9 | 2018-09-01 02:04:17 -0700 | [diff] [blame] | 40 | parse_delimited(input, Delimiter::Parenthesis).map(|(span, content)| Parens { |
| 41 | token: token::Paren(span), |
| 42 | content: content, |
| 43 | }) |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 44 | } |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 45 | |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 46 | // Not public API. |
| 47 | #[doc(hidden)] |
| 48 | pub fn parse_braces(input: ParseStream) -> Result<Braces> { |
David Tolnay | 70f30e9 | 2018-09-01 02:04:17 -0700 | [diff] [blame] | 49 | parse_delimited(input, Delimiter::Brace).map(|(span, content)| Braces { |
| 50 | token: token::Brace(span), |
| 51 | content: content, |
| 52 | }) |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 53 | } |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 54 | |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 55 | // Not public API. |
| 56 | #[doc(hidden)] |
| 57 | pub fn parse_brackets(input: ParseStream) -> Result<Brackets> { |
David Tolnay | 70f30e9 | 2018-09-01 02:04:17 -0700 | [diff] [blame] | 58 | parse_delimited(input, Delimiter::Bracket).map(|(span, content)| Brackets { |
| 59 | token: token::Bracket(span), |
| 60 | content: content, |
| 61 | }) |
David Tolnay | f57f76f | 2018-08-31 10:23:17 -0700 | [diff] [blame] | 62 | } |
David Tolnay | a7d69fc | 2018-08-26 13:30:24 -0400 | [diff] [blame] | 63 | |
David Tolnay | aa77a85 | 2018-08-31 11:15:10 -0700 | [diff] [blame] | 64 | #[cfg(any(feature = "full", feature = "derive"))] |
David Tolnay | 10951d5 | 2018-08-31 10:27:39 -0700 | [diff] [blame] | 65 | impl private { |
David Tolnay | f57f76f | 2018-08-31 10:23:17 -0700 | [diff] [blame] | 66 | pub fn parse_group(input: ParseStream) -> Result<Group> { |
David Tolnay | 70f30e9 | 2018-09-01 02:04:17 -0700 | [diff] [blame] | 67 | parse_delimited(input, Delimiter::None).map(|(span, content)| Group { |
| 68 | token: token::Group(span), |
| 69 | content: content, |
| 70 | }) |
David Tolnay | a7d69fc | 2018-08-26 13:30:24 -0400 | [diff] [blame] | 71 | } |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 72 | } |
| 73 | |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 74 | fn parse_delimited(input: ParseStream, delimiter: Delimiter) -> Result<(Span, ParseBuffer)> { |
| 75 | input.step(|cursor| { |
| 76 | if let Some((content, span, rest)) = cursor.group(delimiter) { |
David Tolnay | fe89fcc | 2018-09-08 17:56:31 -0700 | [diff] [blame] | 77 | #[cfg(procmacro2_semver_exempt)] |
| 78 | let scope = private::close_span_of_group(*cursor); |
| 79 | #[cfg(not(procmacro2_semver_exempt))] |
| 80 | let scope = span; |
David Tolnay | 6ea3fdc | 2018-09-01 13:30:53 -0700 | [diff] [blame] | 81 | let nested = private::advance_step_cursor(cursor, content); |
David Tolnay | fe89fcc | 2018-09-08 17:56:31 -0700 | [diff] [blame] | 82 | let unexpected = private::get_unexpected(input); |
| 83 | let content = private::new_parse_buffer(scope, nested, unexpected); |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 84 | Ok(((span, content), rest)) |
| 85 | } else { |
| 86 | let message = match delimiter { |
| 87 | Delimiter::Parenthesis => "expected parentheses", |
| 88 | Delimiter::Brace => "expected curly braces", |
| 89 | Delimiter::Bracket => "expected square brackets", |
| 90 | Delimiter::None => "expected invisible group", |
| 91 | }; |
| 92 | Err(cursor.error(message)) |
| 93 | } |
| 94 | }) |
| 95 | } |
| 96 | |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 97 | /// Parse a set of parentheses and expose their content to subsequent parsers. |
David Tolnay | 8bb9cca | 2018-09-01 01:50:19 -0700 | [diff] [blame] | 98 | /// |
David Tolnay | 0e5a4cb | 2018-09-01 01:58:02 -0700 | [diff] [blame] | 99 | /// # Example |
| 100 | /// |
David Tolnay | 95989db | 2019-01-01 15:05:57 -0500 | [diff] [blame] | 101 | /// ```edition2018 |
David Tolnay | fd5b117 | 2018-12-31 17:54:36 -0500 | [diff] [blame] | 102 | /// # use quote::quote; |
David Tolnay | 8bb9cca | 2018-09-01 01:50:19 -0700 | [diff] [blame] | 103 | /// # |
David Tolnay | fd5b117 | 2018-12-31 17:54:36 -0500 | [diff] [blame] | 104 | /// use syn::{parenthesized, token, Ident, Result, Token, Type}; |
David Tolnay | 67fea04 | 2018-11-24 14:50:20 -0800 | [diff] [blame] | 105 | /// use syn::parse::{Parse, ParseStream}; |
David Tolnay | 8bb9cca | 2018-09-01 01:50:19 -0700 | [diff] [blame] | 106 | /// use syn::punctuated::Punctuated; |
| 107 | /// |
| 108 | /// // Parse a simplified tuple struct syntax like: |
| 109 | /// // |
| 110 | /// // struct S(A, B); |
| 111 | /// struct TupleStruct { |
| 112 | /// struct_token: Token![struct], |
| 113 | /// ident: Ident, |
| 114 | /// paren_token: token::Paren, |
| 115 | /// fields: Punctuated<Type, Token![,]>, |
| 116 | /// semi_token: Token![;], |
| 117 | /// } |
| 118 | /// |
| 119 | /// impl Parse for TupleStruct { |
| 120 | /// fn parse(input: ParseStream) -> Result<Self> { |
| 121 | /// let content; |
| 122 | /// Ok(TupleStruct { |
| 123 | /// struct_token: input.parse()?, |
| 124 | /// ident: input.parse()?, |
| 125 | /// paren_token: parenthesized!(content in input), |
| 126 | /// fields: content.parse_terminated(Type::parse)?, |
| 127 | /// semi_token: input.parse()?, |
| 128 | /// }) |
| 129 | /// } |
| 130 | /// } |
| 131 | /// # |
| 132 | /// # fn main() { |
| 133 | /// # let input = quote! { |
| 134 | /// # struct S(A, B); |
| 135 | /// # }; |
| 136 | /// # syn::parse2::<TupleStruct>(input).unwrap(); |
| 137 | /// # } |
| 138 | /// ``` |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 139 | #[macro_export] |
| 140 | macro_rules! parenthesized { |
| 141 | ($content:ident in $cursor:expr) => { |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 142 | match $crate::group::parse_parens(&$cursor) { |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 143 | $crate::export::Ok(parens) => { |
| 144 | $content = parens.content; |
| 145 | parens.token |
| 146 | } |
| 147 | $crate::export::Err(error) => { |
| 148 | return $crate::export::Err(error); |
| 149 | } |
| 150 | } |
| 151 | }; |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 152 | } |
| 153 | |
| 154 | /// Parse a set of curly braces and expose their content to subsequent parsers. |
| 155 | /// |
David Tolnay | 0e5a4cb | 2018-09-01 01:58:02 -0700 | [diff] [blame] | 156 | /// # Example |
| 157 | /// |
David Tolnay | 95989db | 2019-01-01 15:05:57 -0500 | [diff] [blame] | 158 | /// ```edition2018 |
David Tolnay | fd5b117 | 2018-12-31 17:54:36 -0500 | [diff] [blame] | 159 | /// # use quote::quote; |
David Tolnay | 9b00f65 | 2018-09-01 10:31:02 -0700 | [diff] [blame] | 160 | /// # |
David Tolnay | fd5b117 | 2018-12-31 17:54:36 -0500 | [diff] [blame] | 161 | /// use syn::{braced, token, Ident, Result, Token, Type}; |
David Tolnay | 67fea04 | 2018-11-24 14:50:20 -0800 | [diff] [blame] | 162 | /// use syn::parse::{Parse, ParseStream}; |
David Tolnay | e763533 | 2018-08-26 08:16:18 -0400 | [diff] [blame] | 163 | /// use syn::punctuated::Punctuated; |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 164 | /// |
| 165 | /// // Parse a simplified struct syntax like: |
| 166 | /// // |
| 167 | /// // struct S { |
| 168 | /// // a: A, |
| 169 | /// // b: B, |
| 170 | /// // } |
| 171 | /// struct Struct { |
David Tolnay | 4496221 | 2018-09-01 01:41:44 -0700 | [diff] [blame] | 172 | /// struct_token: Token![struct], |
| 173 | /// ident: Ident, |
| 174 | /// brace_token: token::Brace, |
| 175 | /// fields: Punctuated<Field, Token![,]>, |
| 176 | /// } |
| 177 | /// |
| 178 | /// struct Field { |
| 179 | /// name: Ident, |
| 180 | /// colon_token: Token![:], |
| 181 | /// ty: Type, |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 182 | /// } |
| 183 | /// |
| 184 | /// impl Parse for Struct { |
| 185 | /// fn parse(input: ParseStream) -> Result<Self> { |
| 186 | /// let content; |
| 187 | /// Ok(Struct { |
| 188 | /// struct_token: input.parse()?, |
| 189 | /// ident: input.parse()?, |
| 190 | /// brace_token: braced!(content in input), |
David Tolnay | e763533 | 2018-08-26 08:16:18 -0400 | [diff] [blame] | 191 | /// fields: content.parse_terminated(Field::parse)?, |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 192 | /// }) |
| 193 | /// } |
| 194 | /// } |
David Tolnay | 4496221 | 2018-09-01 01:41:44 -0700 | [diff] [blame] | 195 | /// |
| 196 | /// impl Parse for Field { |
| 197 | /// fn parse(input: ParseStream) -> Result<Self> { |
| 198 | /// Ok(Field { |
| 199 | /// name: input.parse()?, |
| 200 | /// colon_token: input.parse()?, |
| 201 | /// ty: input.parse()?, |
| 202 | /// }) |
| 203 | /// } |
| 204 | /// } |
| 205 | /// # |
| 206 | /// # fn main() { |
| 207 | /// # let input = quote! { |
| 208 | /// # struct S { |
| 209 | /// # a: A, |
| 210 | /// # b: B, |
| 211 | /// # } |
| 212 | /// # }; |
| 213 | /// # syn::parse2::<Struct>(input).unwrap(); |
| 214 | /// # } |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 215 | /// ``` |
| 216 | #[macro_export] |
| 217 | macro_rules! braced { |
| 218 | ($content:ident in $cursor:expr) => { |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 219 | match $crate::group::parse_braces(&$cursor) { |
David Tolnay | 456c982 | 2018-08-25 08:09:46 -0400 | [diff] [blame] | 220 | $crate::export::Ok(braces) => { |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 221 | $content = braces.content; |
| 222 | braces.token |
| 223 | } |
David Tolnay | 456c982 | 2018-08-25 08:09:46 -0400 | [diff] [blame] | 224 | $crate::export::Err(error) => { |
| 225 | return $crate::export::Err(error); |
David Tolnay | 18c754c | 2018-08-21 23:26:58 -0400 | [diff] [blame] | 226 | } |
| 227 | } |
| 228 | }; |
| 229 | } |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 230 | |
| 231 | /// Parse a set of square brackets and expose their content to subsequent |
| 232 | /// parsers. |
David Tolnay | 1d2960c | 2018-09-01 01:57:19 -0700 | [diff] [blame] | 233 | /// |
David Tolnay | 0e5a4cb | 2018-09-01 01:58:02 -0700 | [diff] [blame] | 234 | /// # Example |
| 235 | /// |
David Tolnay | 95989db | 2019-01-01 15:05:57 -0500 | [diff] [blame] | 236 | /// ```edition2018 |
David Tolnay | fd5b117 | 2018-12-31 17:54:36 -0500 | [diff] [blame] | 237 | /// # use quote::quote; |
| 238 | /// # |
David Tolnay | 1d2960c | 2018-09-01 01:57:19 -0700 | [diff] [blame] | 239 | /// use proc_macro2::TokenStream; |
David Tolnay | fd5b117 | 2018-12-31 17:54:36 -0500 | [diff] [blame] | 240 | /// use syn::{bracketed, token, Result, Token}; |
David Tolnay | 67fea04 | 2018-11-24 14:50:20 -0800 | [diff] [blame] | 241 | /// use syn::parse::{Parse, ParseStream}; |
David Tolnay | 1d2960c | 2018-09-01 01:57:19 -0700 | [diff] [blame] | 242 | /// |
| 243 | /// // Parse an outer attribute like: |
| 244 | /// // |
| 245 | /// // #[repr(C, packed)] |
| 246 | /// struct OuterAttribute { |
| 247 | /// pound_token: Token![#], |
| 248 | /// bracket_token: token::Bracket, |
| 249 | /// content: TokenStream, |
| 250 | /// } |
| 251 | /// |
| 252 | /// impl Parse for OuterAttribute { |
| 253 | /// fn parse(input: ParseStream) -> Result<Self> { |
| 254 | /// let content; |
| 255 | /// Ok(OuterAttribute { |
| 256 | /// pound_token: input.parse()?, |
| 257 | /// bracket_token: bracketed!(content in input), |
| 258 | /// content: content.parse()?, |
| 259 | /// }) |
| 260 | /// } |
| 261 | /// } |
| 262 | /// # |
| 263 | /// # fn main() { |
| 264 | /// # let input = quote! { |
| 265 | /// # #[repr(C, packed)] |
| 266 | /// # }; |
| 267 | /// # syn::parse2::<OuterAttribute>(input).unwrap(); |
| 268 | /// # } |
| 269 | /// ``` |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 270 | #[macro_export] |
| 271 | macro_rules! bracketed { |
| 272 | ($content:ident in $cursor:expr) => { |
David Tolnay | 734079e | 2018-09-01 02:03:37 -0700 | [diff] [blame] | 273 | match $crate::group::parse_brackets(&$cursor) { |
David Tolnay | 42342c8 | 2018-08-25 08:36:35 -0400 | [diff] [blame] | 274 | $crate::export::Ok(brackets) => { |
| 275 | $content = brackets.content; |
| 276 | brackets.token |
| 277 | } |
| 278 | $crate::export::Err(error) => { |
| 279 | return $crate::export::Err(error); |
| 280 | } |
| 281 | } |
| 282 | }; |
| 283 | } |