1use crate::attr::Attribute;
2use crate::expr::Expr;
3use crate::item::Item;
4use crate::mac::Macro;
5use crate::pat::Pat;
6use crate::token;
7
8ast_struct! {
9 /// A braced block containing Rust statements.
10 #[cfg_attr(docsrs, doc(cfg(feature = "full")))]
11 pub struct Block {
12 pub brace_token: token::Brace,
13 /// Statements in a block
14 pub stmts: Vec<Stmt>,
15 }
16}
17
18ast_enum! {
19 /// A statement, usually ending in a semicolon.
20 #[cfg_attr(docsrs, doc(cfg(feature = "full")))]
21 pub enum Stmt {
22 /// A local (let) binding.
23 Local(Local),
24
25 /// An item definition.
26 Item(Item),
27
28 /// Expression, with or without trailing semicolon.
29 Expr(Expr, Option<Token![;]>),
30
31 /// A macro invocation in statement position.
32 ///
33 /// Syntactically it's ambiguous which other kind of statement this
34 /// macro would expand to. It can be any of local variable (`let`),
35 /// item, or expression.
36 Macro(StmtMacro),
37 }
38}
39
40ast_struct! {
41 /// A local `let` binding: `let x: u64 = s.parse()?`.
42 #[cfg_attr(docsrs, doc(cfg(feature = "full")))]
43 pub struct Local {
44 pub attrs: Vec<Attribute>,
45 pub let_token: Token![let],
46 pub pat: Pat,
47 pub init: Option<LocalInit>,
48 pub semi_token: Token![;],
49 }
50}
51
52ast_struct! {
53 /// The expression assigned in a local `let` binding, including optional
54 /// diverging `else` block.
55 ///
56 /// `LocalInit` represents `= s.parse()?` in `let x: u64 = s.parse()?` and
57 /// `= r else { return }` in `let Ok(x) = r else { return }`.
58 #[cfg_attr(docsrs, doc(cfg(feature = "full")))]
59 pub struct LocalInit {
60 pub eq_token: Token![=],
61 pub expr: Box<Expr>,
62 pub diverge: Option<(Token![else], Box<Expr>)>,
63 }
64}
65
66ast_struct! {
67 /// A macro invocation in statement position.
68 ///
69 /// Syntactically it's ambiguous which other kind of statement this macro
70 /// would expand to. It can be any of local variable (`let`), item, or
71 /// expression.
72 #[cfg_attr(docsrs, doc(cfg(feature = "full")))]
73 pub struct StmtMacro {
74 pub attrs: Vec<Attribute>,
75 pub mac: Macro,
76 pub semi_token: Option<Token![;]>,
77 }
78}
79
80#[cfg(feature = "parsing")]
81pub(crate) mod parsing {
82 use crate::attr::Attribute;
83 use crate::classify;
84 use crate::error::Result;
85 use crate::expr::{Expr, ExprBlock, ExprMacro};
86 use crate::ident::Ident;
87 use crate::item;
88 use crate::mac::{self, Macro};
89 use crate::parse::discouraged::Speculative as _;
90 use crate::parse::{Parse, ParseStream};
91 use crate::pat::{Pat, PatType};
92 use crate::path::Path;
93 use crate::stmt::{Block, Local, LocalInit, Stmt, StmtMacro};
94 use crate::token;
95 use crate::ty::Type;
96 use proc_macro2::TokenStream;
97
98 struct AllowNoSemi(bool);
99
100 impl Block {
101 /// Parse the body of a block as zero or more statements, possibly
102 /// including one trailing expression.
103 ///
104 /// # Example
105 ///
106 /// ```
107 /// use syn::{braced, token, Attribute, Block, Ident, Result, Stmt, Token};
108 /// use syn::parse::{Parse, ParseStream};
109 ///
110 /// // Parse a function with no generics or parameter list.
111 /// //
112 /// // fn playground {
113 /// // let mut x = 1;
114 /// // x += 1;
115 /// // println!("{}", x);
116 /// // }
117 /// struct MiniFunction {
118 /// attrs: Vec<Attribute>,
119 /// fn_token: Token![fn],
120 /// name: Ident,
121 /// brace_token: token::Brace,
122 /// stmts: Vec<Stmt>,
123 /// }
124 ///
125 /// impl Parse for MiniFunction {
126 /// fn parse(input: ParseStream) -> Result<Self> {
127 /// let outer_attrs = input.call(Attribute::parse_outer)?;
128 /// let fn_token: Token![fn] = input.parse()?;
129 /// let name: Ident = input.parse()?;
130 ///
131 /// let content;
132 /// let brace_token = braced!(content in input);
133 /// let inner_attrs = content.call(Attribute::parse_inner)?;
134 /// let stmts = content.call(Block::parse_within)?;
135 ///
136 /// Ok(MiniFunction {
137 /// attrs: {
138 /// let mut attrs = outer_attrs;
139 /// attrs.extend(inner_attrs);
140 /// attrs
141 /// },
142 /// fn_token,
143 /// name,
144 /// brace_token,
145 /// stmts,
146 /// })
147 /// }
148 /// }
149 /// ```
150 #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
151 pub fn parse_within(input: ParseStream) -> Result<Vec<Stmt>> {
152 let mut stmts = Vec::new();
153 loop {
154 while let semi @ Some(_) = input.parse()? {
155 stmts.push(Stmt::Expr(Expr::Verbatim(TokenStream::new()), semi));
156 }
157 if input.is_empty() {
158 break;
159 }
160 let stmt = parse_stmt(input, AllowNoSemi(true))?;
161 let requires_semicolon = match &stmt {
162 Stmt::Expr(stmt, None) => classify::requires_semi_to_be_stmt(stmt),
163 Stmt::Macro(stmt) => {
164 stmt.semi_token.is_none() && !stmt.mac.delimiter.is_brace()
165 }
166 Stmt::Local(_) | Stmt::Item(_) | Stmt::Expr(_, Some(_)) => false,
167 };
168 stmts.push(stmt);
169 if input.is_empty() {
170 break;
171 } else if requires_semicolon {
172 return Err(input.error("unexpected token, expected `;`"));
173 }
174 }
175 Ok(stmts)
176 }
177 }
178
179 #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
180 impl Parse for Block {
181 fn parse(input: ParseStream) -> Result<Self> {
182 let content;
183 Ok(Block {
184 brace_token: braced!(content in input),
185 stmts: content.call(Block::parse_within)?,
186 })
187 }
188 }
189
190 #[cfg_attr(docsrs, doc(cfg(feature = "parsing")))]
191 impl Parse for Stmt {
192 fn parse(input: ParseStream) -> Result<Self> {
193 let allow_nosemi = AllowNoSemi(false);
194 parse_stmt(input, allow_nosemi)
195 }
196 }
197
198 fn parse_stmt(input: ParseStream, allow_nosemi: AllowNoSemi) -> Result<Stmt> {
199 let begin = input.fork();
200 let attrs = input.call(Attribute::parse_outer)?;
201
202 // brace-style macros; paren and bracket macros get parsed as
203 // expression statements.
204 let ahead = input.fork();
205 let mut is_item_macro = false;
206 if let Ok(path) = ahead.call(Path::parse_mod_style) {
207 if ahead.peek(Token![!]) {
208 if ahead.peek2(Ident) || ahead.peek2(Token![try]) {
209 is_item_macro = true;
210 } else if ahead.peek2(token::Brace)
211 && !(ahead.peek3(Token![.]) && !ahead.peek3(Token![..])
212 || ahead.peek3(Token![?]))
213 {
214 input.advance_to(&ahead);
215 return stmt_mac(input, attrs, path).map(Stmt::Macro);
216 }
217 }
218 }
219
220 if input.peek(Token![let]) && !input.peek(token::Group) {
221 stmt_local(input, attrs).map(Stmt::Local)
222 } else if input.peek(Token![pub])
223 || input.peek(Token![crate]) && !input.peek2(Token![::])
224 || input.peek(Token![extern])
225 || input.peek(Token![use])
226 || input.peek(Token![static])
227 && (input.peek2(Token![mut])
228 || input.peek2(Ident)
229 && !(input.peek2(Token![async])
230 && (input.peek3(Token![move]) || input.peek3(Token![|]))))
231 || input.peek(Token![const])
232 && !(input.peek2(token::Brace)
233 || input.peek2(Token![static])
234 || input.peek2(Token![async])
235 && !(input.peek3(Token![unsafe])
236 || input.peek3(Token![extern])
237 || input.peek3(Token![fn]))
238 || input.peek2(Token![move])
239 || input.peek2(Token![|]))
240 || input.peek(Token![unsafe]) && !input.peek2(token::Brace)
241 || input.peek(Token![async])
242 && (input.peek2(Token![unsafe])
243 || input.peek2(Token![extern])
244 || input.peek2(Token![fn]))
245 || input.peek(Token![fn])
246 || input.peek(Token![mod])
247 || input.peek(Token![type])
248 || input.peek(Token![struct])
249 || input.peek(Token![enum])
250 || input.peek(Token![union]) && input.peek2(Ident)
251 || input.peek(Token![auto]) && input.peek2(Token![trait])
252 || input.peek(Token![trait])
253 || input.peek(Token![default])
254 && (input.peek2(Token![unsafe]) || input.peek2(Token![impl]))
255 || input.peek(Token![impl])
256 || input.peek(Token![macro])
257 || is_item_macro
258 {
259 let item = item::parsing::parse_rest_of_item(begin, attrs, input)?;
260 Ok(Stmt::Item(item))
261 } else {
262 stmt_expr(input, allow_nosemi, attrs)
263 }
264 }
265
266 fn stmt_mac(input: ParseStream, attrs: Vec<Attribute>, path: Path) -> Result<StmtMacro> {
267 let bang_token: Token![!] = input.parse()?;
268 let (delimiter, tokens) = mac::parse_delimiter(input)?;
269 let semi_token: Option<Token![;]> = input.parse()?;
270
271 Ok(StmtMacro {
272 attrs,
273 mac: Macro {
274 path,
275 bang_token,
276 delimiter,
277 tokens,
278 },
279 semi_token,
280 })
281 }
282
283 fn stmt_local(input: ParseStream, attrs: Vec<Attribute>) -> Result<Local> {
284 let let_token: Token![let] = input.parse()?;
285
286 let mut pat = Pat::parse_single(input)?;
287 if input.peek(Token![:]) {
288 let colon_token: Token![:] = input.parse()?;
289 let ty: Type = input.parse()?;
290 pat = Pat::Type(PatType {
291 attrs: Vec::new(),
292 pat: Box::new(pat),
293 colon_token,
294 ty: Box::new(ty),
295 });
296 }
297
298 let init = if let Some(eq_token) = input.parse()? {
299 let eq_token: Token![=] = eq_token;
300 let expr: Expr = input.parse()?;
301
302 let diverge = if !classify::expr_trailing_brace(&expr) && input.peek(Token![else]) {
303 let else_token: Token![else] = input.parse()?;
304 let diverge = ExprBlock {
305 attrs: Vec::new(),
306 label: None,
307 block: input.parse()?,
308 };
309 Some((else_token, Box::new(Expr::Block(diverge))))
310 } else {
311 None
312 };
313
314 Some(LocalInit {
315 eq_token,
316 expr: Box::new(expr),
317 diverge,
318 })
319 } else {
320 None
321 };
322
323 let semi_token: Token![;] = input.parse()?;
324
325 Ok(Local {
326 attrs,
327 let_token,
328 pat,
329 init,
330 semi_token,
331 })
332 }
333
334 fn stmt_expr(
335 input: ParseStream,
336 allow_nosemi: AllowNoSemi,
337 mut attrs: Vec<Attribute>,
338 ) -> Result<Stmt> {
339 let mut e = Expr::parse_with_earlier_boundary_rule(input)?;
340
341 let mut attr_target = &mut e;
342 loop {
343 attr_target = match attr_target {
344 Expr::Assign(e) => &mut e.left,
345 Expr::Binary(e) => &mut e.left,
346 Expr::Cast(e) => &mut e.expr,
347 Expr::Array(_)
348 | Expr::Async(_)
349 | Expr::Await(_)
350 | Expr::Block(_)
351 | Expr::Break(_)
352 | Expr::Call(_)
353 | Expr::Closure(_)
354 | Expr::Const(_)
355 | Expr::Continue(_)
356 | Expr::Field(_)
357 | Expr::ForLoop(_)
358 | Expr::Group(_)
359 | Expr::If(_)
360 | Expr::Index(_)
361 | Expr::Infer(_)
362 | Expr::Let(_)
363 | Expr::Lit(_)
364 | Expr::Loop(_)
365 | Expr::Macro(_)
366 | Expr::Match(_)
367 | Expr::MethodCall(_)
368 | Expr::Paren(_)
369 | Expr::Path(_)
370 | Expr::Range(_)
371 | Expr::RawAddr(_)
372 | Expr::Reference(_)
373 | Expr::Repeat(_)
374 | Expr::Return(_)
375 | Expr::Struct(_)
376 | Expr::Try(_)
377 | Expr::TryBlock(_)
378 | Expr::Tuple(_)
379 | Expr::Unary(_)
380 | Expr::Unsafe(_)
381 | Expr::While(_)
382 | Expr::Yield(_)
383 | Expr::Verbatim(_) => break,
384 };
385 }
386 attrs.extend(attr_target.replace_attrs(Vec::new()));
387 attr_target.replace_attrs(attrs);
388
389 let semi_token: Option<Token![;]> = input.parse()?;
390
391 match e {
392 Expr::Macro(ExprMacro { attrs, mac })
393 if semi_token.is_some() || mac.delimiter.is_brace() =>
394 {
395 return Ok(Stmt::Macro(StmtMacro {
396 attrs,
397 mac,
398 semi_token,
399 }));
400 }
401 _ => {}
402 }
403
404 if semi_token.is_some() {
405 Ok(Stmt::Expr(e, semi_token))
406 } else if allow_nosemi.0 || !classify::requires_semi_to_be_stmt(&e) {
407 Ok(Stmt::Expr(e, None))
408 } else {
409 Err(input.error("expected semicolon"))
410 }
411 }
412}
413
414#[cfg(feature = "printing")]
415pub(crate) mod printing {
416 use crate::classify;
417 use crate::expr::{self, Expr};
418 use crate::fixup::FixupContext;
419 use crate::stmt::{Block, Local, Stmt, StmtMacro};
420 use crate::token;
421 use proc_macro2::TokenStream;
422 use quote::{ToTokens, TokenStreamExt};
423
424 #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
425 impl ToTokens for Block {
426 fn to_tokens(&self, tokens: &mut TokenStream) {
427 self.brace_token.surround(tokens, |tokens| {
428 tokens.append_all(&self.stmts);
429 });
430 }
431 }
432
433 #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
434 impl ToTokens for Stmt {
435 fn to_tokens(&self, tokens: &mut TokenStream) {
436 match self {
437 Stmt::Local(local) => local.to_tokens(tokens),
438 Stmt::Item(item) => item.to_tokens(tokens),
439 Stmt::Expr(expr, semi) => {
440 expr::printing::print_expr(expr, tokens, FixupContext::new_stmt());
441 semi.to_tokens(tokens);
442 }
443 Stmt::Macro(mac) => mac.to_tokens(tokens),
444 }
445 }
446 }
447
448 #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
449 impl ToTokens for Local {
450 fn to_tokens(&self, tokens: &mut TokenStream) {
451 expr::printing::outer_attrs_to_tokens(&self.attrs, tokens);
452 self.let_token.to_tokens(tokens);
453 self.pat.to_tokens(tokens);
454 if let Some(init) = &self.init {
455 init.eq_token.to_tokens(tokens);
456 expr::printing::print_subexpression(
457 &init.expr,
458 init.diverge.is_some() && classify::expr_trailing_brace(&init.expr),
459 tokens,
460 FixupContext::NONE,
461 );
462 if let Some((else_token, diverge)) = &init.diverge {
463 else_token.to_tokens(tokens);
464 match &**diverge {
465 Expr::Block(diverge) => diverge.to_tokens(tokens),
466 _ => token::Brace::default().surround(tokens, |tokens| {
467 expr::printing::print_expr(diverge, tokens, FixupContext::new_stmt());
468 }),
469 }
470 }
471 }
472 self.semi_token.to_tokens(tokens);
473 }
474 }
475
476 #[cfg_attr(docsrs, doc(cfg(feature = "printing")))]
477 impl ToTokens for StmtMacro {
478 fn to_tokens(&self, tokens: &mut TokenStream) {
479 expr::printing::outer_attrs_to_tokens(&self.attrs, tokens);
480 self.mac.to_tokens(tokens);
481 self.semi_token.to_tokens(tokens);
482 }
483 }
484}
485

Provided by KDAB

Privacy Policy