4 /// A braced block containing Rust statements.
6 /// *This type is available only if Syn is built with the `"full"` feature.*
7 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
9 pub brace_token
: token
::Brace
,
10 /// Statements in a block
16 /// A statement, usually ending in a semicolon.
18 /// *This type is available only if Syn is built with the `"full"` feature.*
19 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
21 /// A local (let) binding.
24 /// An item definition.
27 /// Expr without trailing semicolon.
30 /// Expression with trailing semicolon.
31 Semi(Expr
, Token
![;]),
36 /// A local `let` binding: `let x: u64 = s.parse()?`.
38 /// *This type is available only if Syn is built with the `"full"` feature.*
39 #[cfg_attr(doc_cfg, doc(cfg(feature = "full")))]
41 pub attrs
: Vec
<Attribute
>,
42 pub let_token
: Token
![let],
44 pub init
: Option
<(Token
![=], Box
<Expr
>)>,
45 pub semi_token
: Token
![;],
49 #[cfg(feature = "parsing")]
52 use crate::parse
::discouraged
::Speculative
;
53 use crate::parse
::{Parse, ParseStream, Result}
;
54 use proc_macro2
::TokenStream
;
57 /// Parse the body of a block as zero or more statements, possibly
58 /// including one trailing expression.
60 /// *This function is available only if Syn is built with the `"parsing"`
66 /// use syn::{braced, token, Attribute, Block, Ident, Result, Stmt, Token};
67 /// use syn::parse::{Parse, ParseStream};
69 /// // Parse a function with no generics or parameter list.
71 /// // fn playground {
74 /// // println!("{}", x);
76 /// struct MiniFunction {
77 /// attrs: Vec<Attribute>,
78 /// fn_token: Token![fn],
80 /// brace_token: token::Brace,
84 /// impl Parse for MiniFunction {
85 /// fn parse(input: ParseStream) -> Result<Self> {
86 /// let outer_attrs = input.call(Attribute::parse_outer)?;
87 /// let fn_token: Token![fn] = input.parse()?;
88 /// let name: Ident = input.parse()?;
91 /// let brace_token = braced!(content in input);
92 /// let inner_attrs = content.call(Attribute::parse_inner)?;
93 /// let stmts = content.call(Block::parse_within)?;
97 /// let mut attrs = outer_attrs;
98 /// attrs.extend(inner_attrs);
109 #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
110 pub fn parse_within(input
: ParseStream
) -> Result
<Vec
<Stmt
>> {
111 let mut stmts
= Vec
::new();
113 while let Some(semi
) = input
.parse
::<Option
<Token
![;]>>()?
{
114 stmts
.push(Stmt
::Semi(Expr
::Verbatim(TokenStream
::new()), semi
));
116 if input
.is_empty() {
119 let s
= parse_stmt(input
, true)?
;
120 let requires_semicolon
= if let Stmt
::Expr(s
) = &s
{
121 expr
::requires_terminator(s
)
126 if input
.is_empty() {
128 } else if requires_semicolon
{
129 return Err(input
.error("unexpected token"));
136 #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
137 impl Parse
for Block
{
138 fn parse(input
: ParseStream
) -> Result
<Self> {
141 brace_token
: braced
!(content
in input
),
142 stmts
: content
.call(Block
::parse_within
)?
,
147 #[cfg_attr(doc_cfg, doc(cfg(feature = "parsing")))]
148 impl Parse
for Stmt
{
149 fn parse(input
: ParseStream
) -> Result
<Self> {
150 parse_stmt(input
, false)
154 fn parse_stmt(input
: ParseStream
, allow_nosemi
: bool
) -> Result
<Stmt
> {
155 let mut attrs
= input
.call(Attribute
::parse_outer
)?
;
157 // brace-style macros; paren and bracket macros get parsed as
158 // expression statements.
159 let ahead
= input
.fork();
160 if let Ok(path
) = ahead
.call(Path
::parse_mod_style
) {
161 if ahead
.peek(Token
![!]) && (ahead
.peek2(token
::Brace
) || ahead
.peek2(Ident
)) {
162 input
.advance_to(&ahead
);
163 return stmt_mac(input
, attrs
, path
);
167 if input
.peek(Token
![let]) {
168 stmt_local(input
, attrs
).map(Stmt
::Local
)
169 } else if input
.peek(Token
![pub])
170 || input
.peek(Token
![crate]) && !input
.peek2(Token
![::])
171 || input
.peek(Token
![extern])
172 || input
.peek(Token
![use])
173 || input
.peek(Token
![static]) && (input
.peek2(Token
![mut]) || input
.peek2(Ident
))
174 || input
.peek(Token
![const]) && !input
.peek2(token
::Brace
)
175 || input
.peek(Token
![unsafe]) && !input
.peek2(token
::Brace
)
176 || input
.peek(Token
![async
])
177 && (input
.peek2(Token
![unsafe])
178 || input
.peek2(Token
![extern])
179 || input
.peek2(Token
![fn]))
180 || input
.peek(Token
![fn])
181 || input
.peek(Token
![mod])
182 || input
.peek(Token
![type])
183 || input
.peek(item
::parsing
::existential
) && input
.peek2(Token
![type])
184 || input
.peek(Token
![struct])
185 || input
.peek(Token
![enum])
186 || input
.peek(Token
![union]) && input
.peek2(Ident
)
187 || input
.peek(Token
![auto]) && input
.peek2(Token
![trait])
188 || input
.peek(Token
![trait])
189 || input
.peek(Token
![default])
190 && (input
.peek2(Token
![unsafe]) || input
.peek2(Token
![impl]))
191 || input
.peek(Token
![impl])
192 || input
.peek(Token
![macro])
194 let mut item
: Item
= input
.parse()?
;
195 attrs
.extend(item
.replace_attrs(Vec
::new()));
196 item
.replace_attrs(attrs
);
199 stmt_expr(input
, allow_nosemi
, attrs
)
203 fn stmt_mac(input
: ParseStream
, attrs
: Vec
<Attribute
>, path
: Path
) -> Result
<Stmt
> {
204 let bang_token
: Token
![!] = input
.parse()?
;
205 let ident
: Option
<Ident
> = input
.parse()?
;
206 let (delimiter
, tokens
) = mac
::parse_delimiter(input
)?
;
207 let semi_token
: Option
<Token
![;]> = input
.parse()?
;
209 Ok(Stmt
::Item(Item
::Macro(ItemMacro
{
222 fn stmt_local(input
: ParseStream
, attrs
: Vec
<Attribute
>) -> Result
<Local
> {
225 let_token
: input
.parse()?
,
227 let mut pat
: Pat
= pat
::parsing
::multi_pat_with_leading_vert(input
)?
;
228 if input
.peek(Token
![:]) {
229 let colon_token
: Token
![:] = input
.parse()?
;
230 let ty
: Type
= input
.parse()?
;
231 pat
= Pat
::Type(PatType
{
241 if input
.peek(Token
![=]) {
242 let eq_token
: Token
![=] = input
.parse()?
;
243 let init
: Expr
= input
.parse()?
;
244 Some((eq_token
, Box
::new(init
)))
249 semi_token
: input
.parse()?
,
256 mut attrs
: Vec
<Attribute
>,
258 let mut e
= expr
::parsing
::expr_early(input
)?
;
260 let mut attr_target
= &mut e
;
261 while let Expr
::Binary(e
) = attr_target
{
262 attr_target
= &mut e
.left
;
264 attrs
.extend(attr_target
.replace_attrs(Vec
::new()));
265 attr_target
.replace_attrs(attrs
);
267 if input
.peek(Token
![;]) {
268 return Ok(Stmt
::Semi(e
, input
.parse()?
));
271 if allow_nosemi
|| !expr
::requires_terminator(&e
) {
274 Err(input
.error("expected semicolon"))
279 #[cfg(feature = "printing")]
282 use proc_macro2
::TokenStream
;
283 use quote
::{ToTokens, TokenStreamExt}
;
285 #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
286 impl ToTokens
for Block
{
287 fn to_tokens(&self, tokens
: &mut TokenStream
) {
288 self.brace_token
.surround(tokens
, |tokens
| {
289 tokens
.append_all(&self.stmts
);
294 #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
295 impl ToTokens
for Stmt
{
296 fn to_tokens(&self, tokens
: &mut TokenStream
) {
298 Stmt
::Local(local
) => local
.to_tokens(tokens
),
299 Stmt
::Item(item
) => item
.to_tokens(tokens
),
300 Stmt
::Expr(expr
) => expr
.to_tokens(tokens
),
301 Stmt
::Semi(expr
, semi
) => {
302 expr
.to_tokens(tokens
);
303 semi
.to_tokens(tokens
);
309 #[cfg_attr(doc_cfg, doc(cfg(feature = "printing")))]
310 impl ToTokens
for Local
{
311 fn to_tokens(&self, tokens
: &mut TokenStream
) {
312 expr
::printing
::outer_attrs_to_tokens(&self.attrs
, tokens
);
313 self.let_token
.to_tokens(tokens
);
314 self.pat
.to_tokens(tokens
);
315 if let Some((eq_token
, init
)) = &self.init
{
316 eq_token
.to_tokens(tokens
);
317 init
.to_tokens(tokens
);
319 self.semi_token
.to_tokens(tokens
);