1use crate::algorithm::{BreakToken, Printer};
2use crate::attr;
3use crate::classify;
4use crate::fixup::FixupContext;
5use crate::iter::IterDelimited;
6use crate::path::PathKind;
7use crate::precedence::Precedence;
8use crate::stmt;
9use crate::INDENT;
10use proc_macro2::TokenStream;
11use syn::punctuated::Punctuated;
12use syn::{
13 token, Arm, Attribute, BinOp, Block, Expr, ExprArray, ExprAssign, ExprAsync, ExprAwait,
14 ExprBinary, ExprBlock, ExprBreak, ExprCall, ExprCast, ExprClosure, ExprConst, ExprContinue,
15 ExprField, ExprForLoop, ExprGroup, ExprIf, ExprIndex, ExprInfer, ExprLet, ExprLit, ExprLoop,
16 ExprMacro, ExprMatch, ExprMethodCall, ExprParen, ExprPath, ExprRange, ExprRawAddr,
17 ExprReference, ExprRepeat, ExprReturn, ExprStruct, ExprTry, ExprTryBlock, ExprTuple, ExprUnary,
18 ExprUnsafe, ExprWhile, ExprYield, FieldValue, Index, Label, Lit, Member, PointerMutability,
19 RangeLimits, ReturnType, Stmt, Token, UnOp,
20};
21
22impl Printer {
23 pub fn expr(&mut self, expr: &Expr, mut fixup: FixupContext) {
24 let needs_paren = fixup.parenthesize(expr);
25 if needs_paren {
26 self.word("(");
27 fixup = FixupContext::NONE;
28 }
29
30 let beginning_of_line = false;
31
32 match expr {
33 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
34 Expr::Array(expr) => self.expr_array(expr),
35 Expr::Assign(expr) => self.expr_assign(expr, fixup),
36 Expr::Async(expr) => self.expr_async(expr),
37 Expr::Await(expr) => self.expr_await(expr, beginning_of_line, fixup),
38 Expr::Binary(expr) => self.expr_binary(expr, fixup),
39 Expr::Block(expr) => self.expr_block(expr),
40 Expr::Break(expr) => self.expr_break(expr, fixup),
41 Expr::Call(expr) => self.expr_call(expr, beginning_of_line, fixup),
42 Expr::Cast(expr) => self.expr_cast(expr, fixup),
43 Expr::Closure(expr) => self.expr_closure(expr, fixup),
44 Expr::Const(expr) => self.expr_const(expr),
45 Expr::Continue(expr) => self.expr_continue(expr),
46 Expr::Field(expr) => self.expr_field(expr, beginning_of_line, fixup),
47 Expr::ForLoop(expr) => self.expr_for_loop(expr),
48 Expr::Group(expr) => self.expr_group(expr, fixup),
49 Expr::If(expr) => self.expr_if(expr),
50 Expr::Index(expr) => self.expr_index(expr, beginning_of_line, fixup),
51 Expr::Infer(expr) => self.expr_infer(expr),
52 Expr::Let(expr) => self.expr_let(expr, fixup),
53 Expr::Lit(expr) => self.expr_lit(expr),
54 Expr::Loop(expr) => self.expr_loop(expr),
55 Expr::Macro(expr) => self.expr_macro(expr),
56 Expr::Match(expr) => self.expr_match(expr),
57 Expr::MethodCall(expr) => self.expr_method_call(expr, beginning_of_line, fixup),
58 Expr::Paren(expr) => self.expr_paren(expr),
59 Expr::Path(expr) => self.expr_path(expr),
60 Expr::Range(expr) => self.expr_range(expr, fixup),
61 Expr::RawAddr(expr) => self.expr_raw_addr(expr, fixup),
62 Expr::Reference(expr) => self.expr_reference(expr, fixup),
63 Expr::Repeat(expr) => self.expr_repeat(expr),
64 Expr::Return(expr) => self.expr_return(expr, fixup),
65 Expr::Struct(expr) => self.expr_struct(expr),
66 Expr::Try(expr) => self.expr_try(expr, beginning_of_line, fixup),
67 Expr::TryBlock(expr) => self.expr_try_block(expr),
68 Expr::Tuple(expr) => self.expr_tuple(expr),
69 Expr::Unary(expr) => self.expr_unary(expr, fixup),
70 Expr::Unsafe(expr) => self.expr_unsafe(expr),
71 Expr::Verbatim(expr) => self.expr_verbatim(expr, fixup),
72 Expr::While(expr) => self.expr_while(expr),
73 Expr::Yield(expr) => self.expr_yield(expr, fixup),
74 _ => unimplemented!("unknown Expr"),
75 }
76
77 if needs_paren {
78 self.word(")");
79 }
80 }
81
82 pub fn expr_beginning_of_line(
83 &mut self,
84 expr: &Expr,
85 mut needs_paren: bool,
86 beginning_of_line: bool,
87 mut fixup: FixupContext,
88 ) {
89 needs_paren |= fixup.parenthesize(expr);
90 if needs_paren {
91 self.word("(");
92 fixup = FixupContext::NONE;
93 }
94
95 match expr {
96 Expr::Await(expr) => self.expr_await(expr, beginning_of_line, fixup),
97 Expr::Field(expr) => self.expr_field(expr, beginning_of_line, fixup),
98 Expr::Index(expr) => self.expr_index(expr, beginning_of_line, fixup),
99 Expr::MethodCall(expr) => self.expr_method_call(expr, beginning_of_line, fixup),
100 Expr::Try(expr) => self.expr_try(expr, beginning_of_line, fixup),
101 _ => self.expr(expr, fixup),
102 }
103
104 if needs_paren {
105 self.word(")");
106 }
107 }
108
109 fn prefix_subexpr(
110 &mut self,
111 expr: &Expr,
112 mut needs_paren: bool,
113 beginning_of_line: bool,
114 mut fixup: FixupContext,
115 ) {
116 needs_paren |= fixup.parenthesize(expr);
117 if needs_paren {
118 self.word("(");
119 fixup = FixupContext::NONE;
120 }
121
122 match expr {
123 Expr::Await(expr) => self.prefix_subexpr_await(expr, beginning_of_line, fixup),
124 Expr::Call(expr) => self.prefix_subexpr_call(expr, fixup),
125 Expr::Field(expr) => self.prefix_subexpr_field(expr, beginning_of_line, fixup),
126 Expr::Index(expr) => self.prefix_subexpr_index(expr, beginning_of_line, fixup),
127 Expr::MethodCall(expr) => {
128 let unindent_call_args = false;
129 self.prefix_subexpr_method_call(expr, beginning_of_line, unindent_call_args, fixup);
130 }
131 Expr::Try(expr) => self.prefix_subexpr_try(expr, beginning_of_line, fixup),
132 _ => {
133 self.cbox(-INDENT);
134 self.expr(expr, fixup);
135 self.end();
136 }
137 }
138
139 if needs_paren {
140 self.word(")");
141 }
142 }
143
144 fn expr_condition(&mut self, expr: &Expr) {
145 self.cbox(0);
146 self.expr(expr, FixupContext::new_condition());
147 if needs_newline_if_wrap(expr) {
148 self.space();
149 } else {
150 self.nbsp();
151 }
152 self.end();
153 }
154
155 pub fn subexpr(&mut self, expr: &Expr, needs_paren: bool, mut fixup: FixupContext) {
156 if needs_paren {
157 self.word("(");
158 fixup = FixupContext::NONE;
159 }
160
161 self.expr(expr, fixup);
162
163 if needs_paren {
164 self.word(")");
165 }
166 }
167
168 fn expr_array(&mut self, expr: &ExprArray) {
169 self.outer_attrs(&expr.attrs);
170 if expr.elems.is_empty() {
171 self.word("[]");
172 } else if simple_array(&expr.elems) {
173 self.cbox(INDENT);
174 self.word("[");
175 self.zerobreak();
176 self.ibox(0);
177 for elem in expr.elems.iter().delimited() {
178 self.expr(&elem, FixupContext::NONE);
179 if !elem.is_last {
180 self.word(",");
181 self.space();
182 }
183 }
184 self.end();
185 self.trailing_comma(true);
186 self.offset(-INDENT);
187 self.word("]");
188 self.end();
189 } else {
190 self.word("[");
191 self.cbox(INDENT);
192 self.zerobreak();
193 for elem in expr.elems.iter().delimited() {
194 self.expr(&elem, FixupContext::NONE);
195 self.trailing_comma(elem.is_last);
196 }
197 self.offset(-INDENT);
198 self.end();
199 self.word("]");
200 }
201 }
202
203 fn expr_assign(&mut self, expr: &ExprAssign, fixup: FixupContext) {
204 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_operator(
205 &expr.left,
206 false,
207 false,
208 Precedence::Assign,
209 );
210 let right_fixup = fixup.rightmost_subexpression_fixup(false, false, Precedence::Assign);
211
212 self.outer_attrs(&expr.attrs);
213 self.ibox(0);
214 self.subexpr(&expr.left, left_prec <= Precedence::Range, left_fixup);
215 self.word(" = ");
216 self.neverbreak();
217 self.expr(&expr.right, right_fixup);
218 self.end();
219 }
220
221 fn expr_async(&mut self, expr: &ExprAsync) {
222 self.outer_attrs(&expr.attrs);
223 self.word("async ");
224 if expr.capture.is_some() {
225 self.word("move ");
226 }
227 self.cbox(INDENT);
228 self.small_block(&expr.block, &expr.attrs);
229 self.end();
230 }
231
232 fn expr_await(&mut self, expr: &ExprAwait, beginning_of_line: bool, fixup: FixupContext) {
233 self.outer_attrs(&expr.attrs);
234 self.cbox(INDENT);
235 self.prefix_subexpr_await(expr, beginning_of_line, fixup);
236 self.end();
237 }
238
239 fn prefix_subexpr_await(
240 &mut self,
241 expr: &ExprAwait,
242 beginning_of_line: bool,
243 fixup: FixupContext,
244 ) {
245 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_dot(&expr.base);
246
247 self.prefix_subexpr(
248 &expr.base,
249 left_prec < Precedence::Unambiguous,
250 beginning_of_line,
251 left_fixup,
252 );
253 if !(beginning_of_line && is_short_ident(&expr.base)) {
254 self.scan_break(BreakToken {
255 no_break: self.ends_with('.').then_some(' '),
256 ..BreakToken::default()
257 });
258 }
259 self.word(".await");
260 }
261
262 fn expr_binary(&mut self, expr: &ExprBinary, fixup: FixupContext) {
263 let binop_prec = Precedence::of_binop(&expr.op);
264 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_operator(
265 &expr.left,
266 match &expr.op {
267 BinOp::Sub(_)
268 | BinOp::Mul(_)
269 | BinOp::And(_)
270 | BinOp::Or(_)
271 | BinOp::BitAnd(_)
272 | BinOp::BitOr(_)
273 | BinOp::Shl(_)
274 | BinOp::Lt(_) => true,
275 _ => false,
276 },
277 match &expr.op {
278 BinOp::Shl(_) | BinOp::Lt(_) => true,
279 _ => false,
280 },
281 binop_prec,
282 );
283 let left_needs_group = match binop_prec {
284 Precedence::Assign => left_prec <= Precedence::Range,
285 Precedence::Compare => left_prec <= binop_prec,
286 _ => left_prec < binop_prec,
287 };
288 let right_fixup = fixup.rightmost_subexpression_fixup(false, false, binop_prec);
289 let right_needs_group = binop_prec != Precedence::Assign
290 && right_fixup.rightmost_subexpression_precedence(&expr.right) <= binop_prec;
291
292 self.outer_attrs(&expr.attrs);
293 self.ibox(INDENT);
294 self.ibox(-INDENT);
295 self.subexpr(&expr.left, left_needs_group, left_fixup);
296 self.end();
297 self.space();
298 self.binary_operator(&expr.op);
299 self.nbsp();
300 self.subexpr(&expr.right, right_needs_group, right_fixup);
301 self.end();
302 }
303
304 pub fn expr_block(&mut self, expr: &ExprBlock) {
305 self.outer_attrs(&expr.attrs);
306 if let Some(label) = &expr.label {
307 self.label(label);
308 }
309 self.cbox(INDENT);
310 self.small_block(&expr.block, &expr.attrs);
311 self.end();
312 }
313
314 fn expr_break(&mut self, expr: &ExprBreak, fixup: FixupContext) {
315 self.outer_attrs(&expr.attrs);
316 self.word("break");
317 if let Some(lifetime) = &expr.label {
318 self.nbsp();
319 self.lifetime(lifetime);
320 }
321 if let Some(value) = &expr.expr {
322 self.nbsp();
323 self.subexpr(
324 value,
325 expr.label.is_none() && classify::expr_leading_label(value),
326 fixup.rightmost_subexpression_fixup(true, true, Precedence::Jump),
327 );
328 }
329 }
330
331 fn expr_call(&mut self, expr: &ExprCall, beginning_of_line: bool, fixup: FixupContext) {
332 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_operator(
333 &expr.func,
334 true,
335 false,
336 Precedence::Unambiguous,
337 );
338 let needs_paren = if let Expr::Field(func) = &*expr.func {
339 matches!(func.member, Member::Named(_))
340 } else {
341 left_prec < Precedence::Unambiguous
342 };
343
344 self.outer_attrs(&expr.attrs);
345 self.expr_beginning_of_line(&expr.func, needs_paren, beginning_of_line, left_fixup);
346 self.word("(");
347 self.call_args(&expr.args);
348 self.word(")");
349 }
350
351 fn prefix_subexpr_call(&mut self, expr: &ExprCall, fixup: FixupContext) {
352 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_operator(
353 &expr.func,
354 true,
355 false,
356 Precedence::Unambiguous,
357 );
358 let needs_paren = if let Expr::Field(func) = &*expr.func {
359 matches!(func.member, Member::Named(_))
360 } else {
361 left_prec < Precedence::Unambiguous
362 };
363
364 let beginning_of_line = false;
365 self.prefix_subexpr(&expr.func, needs_paren, beginning_of_line, left_fixup);
366 self.word("(");
367 self.call_args(&expr.args);
368 self.word(")");
369 }
370
371 fn expr_cast(&mut self, expr: &ExprCast, fixup: FixupContext) {
372 let (left_prec, left_fixup) =
373 fixup.leftmost_subexpression_with_operator(&expr.expr, false, false, Precedence::Cast);
374
375 self.outer_attrs(&expr.attrs);
376 self.ibox(INDENT);
377 self.ibox(-INDENT);
378 self.subexpr(&expr.expr, left_prec < Precedence::Cast, left_fixup);
379 self.end();
380 self.space();
381 self.word("as ");
382 self.ty(&expr.ty);
383 self.end();
384 }
385
386 fn expr_closure(&mut self, expr: &ExprClosure, fixup: FixupContext) {
387 self.outer_attrs(&expr.attrs);
388 self.ibox(0);
389 if let Some(bound_lifetimes) = &expr.lifetimes {
390 self.bound_lifetimes(bound_lifetimes);
391 }
392 if expr.constness.is_some() {
393 self.word("const ");
394 }
395 if expr.movability.is_some() {
396 self.word("static ");
397 }
398 if expr.asyncness.is_some() {
399 self.word("async ");
400 }
401 if expr.capture.is_some() {
402 self.word("move ");
403 }
404 self.cbox(INDENT);
405 self.word("|");
406 for pat in expr.inputs.iter().delimited() {
407 if pat.is_first {
408 self.zerobreak();
409 }
410 self.pat(&pat);
411 if !pat.is_last {
412 self.word(",");
413 self.space();
414 }
415 }
416 match &expr.output {
417 ReturnType::Default => {
418 self.word("|");
419 self.space();
420 self.offset(-INDENT);
421 self.end();
422 self.neverbreak();
423 let wrap_in_brace = match &*expr.body {
424 Expr::Match(ExprMatch { attrs, .. }) | Expr::Call(ExprCall { attrs, .. }) => {
425 attr::has_outer(attrs)
426 }
427 body => !is_blocklike(body),
428 };
429 if wrap_in_brace {
430 self.cbox(INDENT);
431 let okay_to_brace = parseable_as_stmt(&expr.body);
432 self.scan_break(BreakToken {
433 pre_break: Some(if okay_to_brace { '{' } else { '(' }),
434 ..BreakToken::default()
435 });
436 self.expr(
437 &expr.body,
438 fixup.rightmost_subexpression_fixup(false, false, Precedence::Jump),
439 );
440 self.scan_break(BreakToken {
441 offset: -INDENT,
442 pre_break: (okay_to_brace && stmt::add_semi(&expr.body)).then_some(';'),
443 post_break: if okay_to_brace { "}" } else { ")" },
444 ..BreakToken::default()
445 });
446 self.end();
447 } else {
448 self.expr(
449 &expr.body,
450 fixup.rightmost_subexpression_fixup(false, false, Precedence::Jump),
451 );
452 }
453 }
454 ReturnType::Type(_arrow, ty) => {
455 if !expr.inputs.is_empty() {
456 self.trailing_comma(true);
457 self.offset(-INDENT);
458 }
459 self.word("|");
460 self.end();
461 self.word(" -> ");
462 self.ty(ty);
463 self.nbsp();
464 self.neverbreak();
465 if matches!(&*expr.body, Expr::Block(body) if body.attrs.is_empty() && body.label.is_none())
466 {
467 self.expr(
468 &expr.body,
469 fixup.rightmost_subexpression_fixup(false, false, Precedence::Jump),
470 );
471 } else {
472 self.cbox(INDENT);
473 self.expr_as_small_block(&expr.body, 0);
474 self.end();
475 }
476 }
477 }
478 self.end();
479 }
480
481 pub fn expr_const(&mut self, expr: &ExprConst) {
482 self.outer_attrs(&expr.attrs);
483 self.word("const ");
484 self.cbox(INDENT);
485 self.small_block(&expr.block, &expr.attrs);
486 self.end();
487 }
488
489 fn expr_continue(&mut self, expr: &ExprContinue) {
490 self.outer_attrs(&expr.attrs);
491 self.word("continue");
492 if let Some(lifetime) = &expr.label {
493 self.nbsp();
494 self.lifetime(lifetime);
495 }
496 }
497
498 fn expr_field(&mut self, expr: &ExprField, beginning_of_line: bool, fixup: FixupContext) {
499 self.outer_attrs(&expr.attrs);
500 self.cbox(INDENT);
501 self.prefix_subexpr_field(expr, beginning_of_line, fixup);
502 self.end();
503 }
504
505 fn prefix_subexpr_field(
506 &mut self,
507 expr: &ExprField,
508 beginning_of_line: bool,
509 fixup: FixupContext,
510 ) {
511 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_dot(&expr.base);
512
513 self.prefix_subexpr(
514 &expr.base,
515 left_prec < Precedence::Unambiguous,
516 beginning_of_line,
517 left_fixup,
518 );
519 if !(beginning_of_line && is_short_ident(&expr.base)) {
520 self.scan_break(BreakToken {
521 no_break: self.ends_with('.').then_some(' '),
522 ..BreakToken::default()
523 });
524 }
525 self.word(".");
526 self.member(&expr.member);
527 }
528
529 fn expr_for_loop(&mut self, expr: &ExprForLoop) {
530 self.outer_attrs(&expr.attrs);
531 self.ibox(0);
532 if let Some(label) = &expr.label {
533 self.label(label);
534 }
535 self.word("for ");
536 self.pat(&expr.pat);
537 self.word(" in ");
538 self.neverbreak();
539 self.expr_condition(&expr.expr);
540 self.word("{");
541 self.neverbreak();
542 self.cbox(INDENT);
543 self.hardbreak_if_nonempty();
544 self.inner_attrs(&expr.attrs);
545 for stmt in expr.body.stmts.iter().delimited() {
546 self.stmt(&stmt, stmt.is_last);
547 }
548 self.offset(-INDENT);
549 self.end();
550 self.word("}");
551 self.end();
552 }
553
554 fn expr_group(&mut self, expr: &ExprGroup, fixup: FixupContext) {
555 self.outer_attrs(&expr.attrs);
556 self.expr(&expr.expr, fixup);
557 }
558
559 fn expr_if(&mut self, expr: &ExprIf) {
560 self.outer_attrs(&expr.attrs);
561 self.cbox(INDENT);
562 self.word("if ");
563 self.cbox(-INDENT);
564 self.expr_condition(&expr.cond);
565 self.end();
566 if let Some((_else_token, else_branch)) = &expr.else_branch {
567 let mut else_branch = &**else_branch;
568 self.small_block(&expr.then_branch, &[]);
569 loop {
570 self.word(" else ");
571 match else_branch {
572 Expr::If(expr) => {
573 self.word("if ");
574 self.cbox(-INDENT);
575 self.expr_condition(&expr.cond);
576 self.end();
577 self.small_block(&expr.then_branch, &[]);
578 if let Some((_else_token, next)) = &expr.else_branch {
579 else_branch = next;
580 continue;
581 }
582 }
583 Expr::Block(expr) => {
584 self.small_block(&expr.block, &[]);
585 }
586 // If not one of the valid expressions to exist in an else
587 // clause, wrap in a block.
588 other => self.expr_as_small_block(other, INDENT),
589 }
590 break;
591 }
592 } else if expr.then_branch.stmts.is_empty() {
593 self.word("{}");
594 } else {
595 self.word("{");
596 self.hardbreak();
597 for stmt in expr.then_branch.stmts.iter().delimited() {
598 self.stmt(&stmt, stmt.is_last);
599 }
600 self.offset(-INDENT);
601 self.word("}");
602 }
603 self.end();
604 }
605
606 fn expr_index(&mut self, expr: &ExprIndex, beginning_of_line: bool, fixup: FixupContext) {
607 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_operator(
608 &expr.expr,
609 true,
610 false,
611 Precedence::Unambiguous,
612 );
613
614 self.outer_attrs(&expr.attrs);
615 self.expr_beginning_of_line(
616 &expr.expr,
617 left_prec < Precedence::Unambiguous,
618 beginning_of_line,
619 left_fixup,
620 );
621 self.word("[");
622 self.expr(&expr.index, FixupContext::NONE);
623 self.word("]");
624 }
625
626 fn prefix_subexpr_index(
627 &mut self,
628 expr: &ExprIndex,
629 beginning_of_line: bool,
630 fixup: FixupContext,
631 ) {
632 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_operator(
633 &expr.expr,
634 true,
635 false,
636 Precedence::Unambiguous,
637 );
638
639 self.prefix_subexpr(
640 &expr.expr,
641 left_prec < Precedence::Unambiguous,
642 beginning_of_line,
643 left_fixup,
644 );
645 self.word("[");
646 self.expr(&expr.index, FixupContext::NONE);
647 self.word("]");
648 }
649
650 fn expr_infer(&mut self, expr: &ExprInfer) {
651 self.outer_attrs(&expr.attrs);
652 self.word("_");
653 }
654
655 fn expr_let(&mut self, expr: &ExprLet, fixup: FixupContext) {
656 let (right_prec, right_fixup) = fixup.rightmost_subexpression(&expr.expr, Precedence::Let);
657
658 self.outer_attrs(&expr.attrs);
659 self.ibox(0);
660 self.word("let ");
661 self.ibox(0);
662 self.pat(&expr.pat);
663 self.end();
664 self.word(" = ");
665 self.neverbreak();
666 self.ibox(0);
667 self.subexpr(&expr.expr, right_prec < Precedence::Let, right_fixup);
668 self.end();
669 self.end();
670 }
671
672 pub fn expr_lit(&mut self, expr: &ExprLit) {
673 self.outer_attrs(&expr.attrs);
674 self.lit(&expr.lit);
675 }
676
677 fn expr_loop(&mut self, expr: &ExprLoop) {
678 self.outer_attrs(&expr.attrs);
679 if let Some(label) = &expr.label {
680 self.label(label);
681 }
682 self.word("loop {");
683 self.cbox(INDENT);
684 self.hardbreak_if_nonempty();
685 self.inner_attrs(&expr.attrs);
686 for stmt in expr.body.stmts.iter().delimited() {
687 self.stmt(&stmt, stmt.is_last);
688 }
689 self.offset(-INDENT);
690 self.end();
691 self.word("}");
692 }
693
694 pub fn expr_macro(&mut self, expr: &ExprMacro) {
695 self.outer_attrs(&expr.attrs);
696 let semicolon = false;
697 self.mac(&expr.mac, None, semicolon);
698 }
699
700 fn expr_match(&mut self, expr: &ExprMatch) {
701 self.outer_attrs(&expr.attrs);
702 self.ibox(0);
703 self.word("match ");
704 self.expr_condition(&expr.expr);
705 self.word("{");
706 self.neverbreak();
707 self.cbox(INDENT);
708 self.hardbreak_if_nonempty();
709 self.inner_attrs(&expr.attrs);
710 for arm in &expr.arms {
711 self.arm(arm);
712 self.hardbreak();
713 }
714 self.offset(-INDENT);
715 self.end();
716 self.word("}");
717 self.end();
718 }
719
720 fn expr_method_call(
721 &mut self,
722 expr: &ExprMethodCall,
723 beginning_of_line: bool,
724 fixup: FixupContext,
725 ) {
726 self.outer_attrs(&expr.attrs);
727 self.cbox(INDENT);
728 let unindent_call_args = beginning_of_line && is_short_ident(&expr.receiver);
729 self.prefix_subexpr_method_call(expr, beginning_of_line, unindent_call_args, fixup);
730 self.end();
731 }
732
733 fn prefix_subexpr_method_call(
734 &mut self,
735 expr: &ExprMethodCall,
736 beginning_of_line: bool,
737 unindent_call_args: bool,
738 fixup: FixupContext,
739 ) {
740 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_dot(&expr.receiver);
741
742 self.prefix_subexpr(
743 &expr.receiver,
744 left_prec < Precedence::Unambiguous,
745 beginning_of_line,
746 left_fixup,
747 );
748 if !(beginning_of_line && is_short_ident(&expr.receiver)) {
749 self.scan_break(BreakToken {
750 no_break: self.ends_with('.').then_some(' '),
751 ..BreakToken::default()
752 });
753 }
754 self.word(".");
755 self.ident(&expr.method);
756 if let Some(turbofish) = &expr.turbofish {
757 self.angle_bracketed_generic_arguments(turbofish, PathKind::Expr);
758 }
759 self.cbox(if unindent_call_args { -INDENT } else { 0 });
760 self.word("(");
761 self.call_args(&expr.args);
762 self.word(")");
763 self.end();
764 }
765
766 fn expr_paren(&mut self, expr: &ExprParen) {
767 self.outer_attrs(&expr.attrs);
768 self.word("(");
769 self.expr(&expr.expr, FixupContext::NONE);
770 self.word(")");
771 }
772
773 pub fn expr_path(&mut self, expr: &ExprPath) {
774 self.outer_attrs(&expr.attrs);
775 self.qpath(&expr.qself, &expr.path, PathKind::Expr);
776 }
777
778 pub fn expr_range(&mut self, expr: &ExprRange, fixup: FixupContext) {
779 self.outer_attrs(&expr.attrs);
780 if let Some(start) = &expr.start {
781 let (left_prec, left_fixup) =
782 fixup.leftmost_subexpression_with_operator(start, true, false, Precedence::Range);
783 self.subexpr(start, left_prec <= Precedence::Range, left_fixup);
784 } else if self.ends_with('.') {
785 self.nbsp();
786 }
787 self.word(match expr.limits {
788 RangeLimits::HalfOpen(_) => "..",
789 RangeLimits::Closed(_) => "..=",
790 });
791 if let Some(end) = &expr.end {
792 let right_fixup = fixup.rightmost_subexpression_fixup(false, true, Precedence::Range);
793 let right_prec = right_fixup.rightmost_subexpression_precedence(end);
794 self.subexpr(end, right_prec <= Precedence::Range, right_fixup);
795 }
796 }
797
798 fn expr_raw_addr(&mut self, expr: &ExprRawAddr, fixup: FixupContext) {
799 let (right_prec, right_fixup) =
800 fixup.rightmost_subexpression(&expr.expr, Precedence::Prefix);
801
802 self.outer_attrs(&expr.attrs);
803 self.word("&raw ");
804 self.pointer_mutability(&expr.mutability);
805 self.nbsp();
806 self.subexpr(&expr.expr, right_prec < Precedence::Prefix, right_fixup);
807 }
808
809 fn expr_reference(&mut self, expr: &ExprReference, fixup: FixupContext) {
810 let (right_prec, right_fixup) =
811 fixup.rightmost_subexpression(&expr.expr, Precedence::Prefix);
812
813 self.outer_attrs(&expr.attrs);
814 self.word("&");
815 if expr.mutability.is_some() {
816 self.word("mut ");
817 }
818 self.subexpr(&expr.expr, right_prec < Precedence::Prefix, right_fixup);
819 }
820
821 fn expr_repeat(&mut self, expr: &ExprRepeat) {
822 self.outer_attrs(&expr.attrs);
823 self.word("[");
824 self.expr(&expr.expr, FixupContext::NONE);
825 self.word("; ");
826 self.expr(&expr.len, FixupContext::NONE);
827 self.word("]");
828 }
829
830 fn expr_return(&mut self, expr: &ExprReturn, fixup: FixupContext) {
831 self.outer_attrs(&expr.attrs);
832 self.word("return");
833 if let Some(value) = &expr.expr {
834 self.nbsp();
835 self.expr(
836 value,
837 fixup.rightmost_subexpression_fixup(true, false, Precedence::Jump),
838 );
839 }
840 }
841
842 fn expr_struct(&mut self, expr: &ExprStruct) {
843 self.outer_attrs(&expr.attrs);
844 self.cbox(INDENT);
845 self.ibox(-INDENT);
846 self.qpath(&expr.qself, &expr.path, PathKind::Expr);
847 self.end();
848 self.word(" {");
849 self.space_if_nonempty();
850 for field_value in expr.fields.iter().delimited() {
851 self.field_value(&field_value);
852 self.trailing_comma_or_space(field_value.is_last && expr.rest.is_none());
853 }
854 if let Some(rest) = &expr.rest {
855 self.word("..");
856 self.expr(rest, FixupContext::NONE);
857 self.space();
858 }
859 self.offset(-INDENT);
860 self.end_with_max_width(34);
861 self.word("}");
862 }
863
864 fn expr_try(&mut self, expr: &ExprTry, beginning_of_line: bool, fixup: FixupContext) {
865 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_dot(&expr.expr);
866
867 self.outer_attrs(&expr.attrs);
868 self.expr_beginning_of_line(
869 &expr.expr,
870 left_prec < Precedence::Unambiguous,
871 beginning_of_line,
872 left_fixup,
873 );
874 self.word("?");
875 }
876
877 fn prefix_subexpr_try(&mut self, expr: &ExprTry, beginning_of_line: bool, fixup: FixupContext) {
878 let (left_prec, left_fixup) = fixup.leftmost_subexpression_with_dot(&expr.expr);
879
880 self.prefix_subexpr(
881 &expr.expr,
882 left_prec < Precedence::Unambiguous,
883 beginning_of_line,
884 left_fixup,
885 );
886 self.word("?");
887 }
888
889 fn expr_try_block(&mut self, expr: &ExprTryBlock) {
890 self.outer_attrs(&expr.attrs);
891 self.word("try ");
892 self.cbox(INDENT);
893 self.small_block(&expr.block, &expr.attrs);
894 self.end();
895 }
896
897 fn expr_tuple(&mut self, expr: &ExprTuple) {
898 self.outer_attrs(&expr.attrs);
899 self.word("(");
900 self.cbox(INDENT);
901 self.zerobreak();
902 for elem in expr.elems.iter().delimited() {
903 self.expr(&elem, FixupContext::NONE);
904 if expr.elems.len() == 1 {
905 self.word(",");
906 self.zerobreak();
907 } else {
908 self.trailing_comma(elem.is_last);
909 }
910 }
911 self.offset(-INDENT);
912 self.end();
913 self.word(")");
914 }
915
916 fn expr_unary(&mut self, expr: &ExprUnary, fixup: FixupContext) {
917 let (right_prec, right_fixup) =
918 fixup.rightmost_subexpression(&expr.expr, Precedence::Prefix);
919
920 self.outer_attrs(&expr.attrs);
921 self.unary_operator(&expr.op);
922 self.subexpr(&expr.expr, right_prec < Precedence::Prefix, right_fixup);
923 }
924
925 fn expr_unsafe(&mut self, expr: &ExprUnsafe) {
926 self.outer_attrs(&expr.attrs);
927 self.word("unsafe ");
928 self.cbox(INDENT);
929 self.small_block(&expr.block, &expr.attrs);
930 self.end();
931 }
932
933 #[cfg(not(feature = "verbatim"))]
934 fn expr_verbatim(&mut self, expr: &TokenStream, _fixup: FixupContext) {
935 if !expr.is_empty() {
936 unimplemented!("Expr::Verbatim `{}`", expr);
937 }
938 }
939
940 #[cfg(feature = "verbatim")]
941 fn expr_verbatim(&mut self, tokens: &TokenStream, fixup: FixupContext) {
942 use syn::parse::discouraged::Speculative;
943 use syn::parse::{Parse, ParseStream, Result};
944 use syn::{parenthesized, Ident};
945
946 enum ExprVerbatim {
947 Empty,
948 Ellipsis,
949 Become(Become),
950 Builtin(Builtin),
951 }
952
953 struct Become {
954 attrs: Vec<Attribute>,
955 tail_call: Expr,
956 }
957
958 struct Builtin {
959 attrs: Vec<Attribute>,
960 name: Ident,
961 args: TokenStream,
962 }
963
964 mod kw {
965 syn::custom_keyword!(builtin);
966 syn::custom_keyword!(raw);
967 }
968
969 impl Parse for ExprVerbatim {
970 fn parse(input: ParseStream) -> Result<Self> {
971 let ahead = input.fork();
972 let attrs = ahead.call(Attribute::parse_outer)?;
973 let lookahead = ahead.lookahead1();
974 if input.is_empty() {
975 Ok(ExprVerbatim::Empty)
976 } else if lookahead.peek(Token![become]) {
977 input.advance_to(&ahead);
978 input.parse::<Token![become]>()?;
979 let tail_call: Expr = input.parse()?;
980 Ok(ExprVerbatim::Become(Become { attrs, tail_call }))
981 } else if lookahead.peek(kw::builtin) {
982 input.advance_to(&ahead);
983 input.parse::<kw::builtin>()?;
984 input.parse::<Token![#]>()?;
985 let name: Ident = input.parse()?;
986 let args;
987 parenthesized!(args in input);
988 let args: TokenStream = args.parse()?;
989 Ok(ExprVerbatim::Builtin(Builtin { attrs, name, args }))
990 } else if lookahead.peek(Token![...]) {
991 input.parse::<Token![...]>()?;
992 Ok(ExprVerbatim::Ellipsis)
993 } else {
994 Err(lookahead.error())
995 }
996 }
997 }
998
999 let expr: ExprVerbatim = match syn::parse2(tokens.clone()) {
1000 Ok(expr) => expr,
1001 Err(_) => unimplemented!("Expr::Verbatim `{}`", tokens),
1002 };
1003
1004 match expr {
1005 ExprVerbatim::Empty => {}
1006 ExprVerbatim::Ellipsis => {
1007 self.word("...");
1008 }
1009 ExprVerbatim::Become(expr) => {
1010 self.outer_attrs(&expr.attrs);
1011 self.word("become");
1012 self.nbsp();
1013 self.expr(
1014 &expr.tail_call,
1015 fixup.rightmost_subexpression_fixup(true, false, Precedence::Jump),
1016 );
1017 }
1018 ExprVerbatim::Builtin(expr) => {
1019 self.outer_attrs(&expr.attrs);
1020 self.word("builtin # ");
1021 self.ident(&expr.name);
1022 self.word("(");
1023 if !expr.args.is_empty() {
1024 self.cbox(INDENT);
1025 self.zerobreak();
1026 self.ibox(0);
1027 self.macro_rules_tokens(expr.args, false);
1028 self.end();
1029 self.zerobreak();
1030 self.offset(-INDENT);
1031 self.end();
1032 }
1033 self.word(")");
1034 }
1035 }
1036 }
1037
1038 fn expr_while(&mut self, expr: &ExprWhile) {
1039 self.outer_attrs(&expr.attrs);
1040 if let Some(label) = &expr.label {
1041 self.label(label);
1042 }
1043 self.word("while ");
1044 self.expr_condition(&expr.cond);
1045 self.word("{");
1046 self.neverbreak();
1047 self.cbox(INDENT);
1048 self.hardbreak_if_nonempty();
1049 self.inner_attrs(&expr.attrs);
1050 for stmt in expr.body.stmts.iter().delimited() {
1051 self.stmt(&stmt, stmt.is_last);
1052 }
1053 self.offset(-INDENT);
1054 self.end();
1055 self.word("}");
1056 }
1057
1058 fn expr_yield(&mut self, expr: &ExprYield, fixup: FixupContext) {
1059 self.outer_attrs(&expr.attrs);
1060 self.word("yield");
1061 if let Some(value) = &expr.expr {
1062 self.nbsp();
1063 self.expr(
1064 value,
1065 fixup.rightmost_subexpression_fixup(true, false, Precedence::Jump),
1066 );
1067 }
1068 }
1069
1070 fn label(&mut self, label: &Label) {
1071 self.lifetime(&label.name);
1072 self.word(": ");
1073 }
1074
1075 fn field_value(&mut self, field_value: &FieldValue) {
1076 self.outer_attrs(&field_value.attrs);
1077 self.member(&field_value.member);
1078 if field_value.colon_token.is_some() {
1079 self.word(": ");
1080 self.ibox(0);
1081 self.expr(&field_value.expr, FixupContext::NONE);
1082 self.end();
1083 }
1084 }
1085
1086 fn arm(&mut self, arm: &Arm) {
1087 self.outer_attrs(&arm.attrs);
1088 self.ibox(0);
1089 self.pat(&arm.pat);
1090 if let Some((_if_token, guard)) = &arm.guard {
1091 self.word(" if ");
1092 self.expr(guard, FixupContext::NONE);
1093 }
1094 self.word(" => ");
1095 let empty_block;
1096 let mut body = &*arm.body;
1097 while let Expr::Block(expr) = body {
1098 if expr.attrs.is_empty() && expr.label.is_none() {
1099 let mut stmts = expr.block.stmts.iter();
1100 if let (Some(Stmt::Expr(inner, None)), None) = (stmts.next(), stmts.next()) {
1101 body = inner;
1102 continue;
1103 }
1104 }
1105 break;
1106 }
1107 if let Expr::Tuple(expr) = body {
1108 if expr.elems.is_empty() && expr.attrs.is_empty() {
1109 empty_block = Expr::Block(ExprBlock {
1110 attrs: Vec::new(),
1111 label: None,
1112 block: Block {
1113 brace_token: token::Brace::default(),
1114 stmts: Vec::new(),
1115 },
1116 });
1117 body = &empty_block;
1118 }
1119 }
1120 if let Expr::Block(body) = body {
1121 if let Some(label) = &body.label {
1122 self.label(label);
1123 }
1124 self.word("{");
1125 self.neverbreak();
1126 self.cbox(INDENT);
1127 self.hardbreak_if_nonempty();
1128 self.inner_attrs(&body.attrs);
1129 for stmt in body.block.stmts.iter().delimited() {
1130 self.stmt(&stmt, stmt.is_last);
1131 }
1132 self.offset(-INDENT);
1133 self.end();
1134 self.word("}");
1135 } else {
1136 self.neverbreak();
1137 self.cbox(INDENT);
1138 let okay_to_brace = parseable_as_stmt(body);
1139 self.scan_break(BreakToken {
1140 pre_break: Some(if okay_to_brace { '{' } else { '(' }),
1141 ..BreakToken::default()
1142 });
1143 self.expr_beginning_of_line(body, false, true, FixupContext::new_match_arm());
1144 self.scan_break(BreakToken {
1145 offset: -INDENT,
1146 pre_break: (okay_to_brace && stmt::add_semi(body)).then_some(';'),
1147 post_break: if okay_to_brace { "}" } else { ")," },
1148 no_break: classify::requires_comma_to_be_match_arm(body).then_some(','),
1149 ..BreakToken::default()
1150 });
1151 self.end();
1152 }
1153 self.end();
1154 }
1155
1156 fn call_args(&mut self, args: &Punctuated<Expr, Token![,]>) {
1157 let mut iter = args.iter();
1158 match (iter.next(), iter.next()) {
1159 (Some(expr), None) if is_blocklike(expr) => {
1160 self.expr(expr, FixupContext::NONE);
1161 }
1162 _ => {
1163 self.cbox(INDENT);
1164 self.zerobreak();
1165 for arg in args.iter().delimited() {
1166 self.expr(&arg, FixupContext::NONE);
1167 self.trailing_comma(arg.is_last);
1168 }
1169 self.offset(-INDENT);
1170 self.end();
1171 }
1172 }
1173 }
1174
1175 pub fn small_block(&mut self, block: &Block, attrs: &[Attribute]) {
1176 self.word("{");
1177 if attr::has_inner(attrs) || !block.stmts.is_empty() {
1178 self.space();
1179 self.inner_attrs(attrs);
1180 match block.stmts.as_slice() {
1181 [Stmt::Expr(expr, None)] if stmt::break_after(expr) => {
1182 self.ibox(0);
1183 self.expr_beginning_of_line(expr, false, true, FixupContext::new_stmt());
1184 self.end();
1185 self.space();
1186 }
1187 _ => {
1188 for stmt in block.stmts.iter().delimited() {
1189 self.stmt(&stmt, stmt.is_last);
1190 }
1191 }
1192 }
1193 self.offset(-INDENT);
1194 }
1195 self.word("}");
1196 }
1197
1198 pub fn expr_as_small_block(&mut self, expr: &Expr, indent: isize) {
1199 self.word("{");
1200 self.space();
1201 self.ibox(indent);
1202 self.expr_beginning_of_line(expr, false, true, FixupContext::new_stmt());
1203 self.end();
1204 self.space();
1205 self.offset(-INDENT);
1206 self.word("}");
1207 }
1208
1209 pub fn member(&mut self, member: &Member) {
1210 match member {
1211 Member::Named(ident) => self.ident(ident),
1212 Member::Unnamed(index) => self.index(index),
1213 }
1214 }
1215
1216 fn index(&mut self, member: &Index) {
1217 self.word(member.index.to_string());
1218 }
1219
1220 fn binary_operator(&mut self, op: &BinOp) {
1221 self.word(
1222 match op {
1223 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
1224 BinOp::Add(_) => "+",
1225 BinOp::Sub(_) => "-",
1226 BinOp::Mul(_) => "*",
1227 BinOp::Div(_) => "/",
1228 BinOp::Rem(_) => "%",
1229 BinOp::And(_) => "&&",
1230 BinOp::Or(_) => "||",
1231 BinOp::BitXor(_) => "^",
1232 BinOp::BitAnd(_) => "&",
1233 BinOp::BitOr(_) => "|",
1234 BinOp::Shl(_) => "<<",
1235 BinOp::Shr(_) => ">>",
1236 BinOp::Eq(_) => "==",
1237 BinOp::Lt(_) => "<",
1238 BinOp::Le(_) => "<=",
1239 BinOp::Ne(_) => "!=",
1240 BinOp::Ge(_) => ">=",
1241 BinOp::Gt(_) => ">",
1242 BinOp::AddAssign(_) => "+=",
1243 BinOp::SubAssign(_) => "-=",
1244 BinOp::MulAssign(_) => "*=",
1245 BinOp::DivAssign(_) => "/=",
1246 BinOp::RemAssign(_) => "%=",
1247 BinOp::BitXorAssign(_) => "^=",
1248 BinOp::BitAndAssign(_) => "&=",
1249 BinOp::BitOrAssign(_) => "|=",
1250 BinOp::ShlAssign(_) => "<<=",
1251 BinOp::ShrAssign(_) => ">>=",
1252 _ => unimplemented!("unknown BinOp"),
1253 },
1254 );
1255 }
1256
1257 fn unary_operator(&mut self, op: &UnOp) {
1258 self.word(
1259 match op {
1260 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
1261 UnOp::Deref(_) => "*",
1262 UnOp::Not(_) => "!",
1263 UnOp::Neg(_) => "-",
1264 _ => unimplemented!("unknown UnOp"),
1265 },
1266 );
1267 }
1268
1269 fn pointer_mutability(&mut self, mutability: &PointerMutability) {
1270 match mutability {
1271 PointerMutability::Const(_) => self.word("const"),
1272 PointerMutability::Mut(_) => self.word("mut"),
1273 }
1274 }
1275}
1276
1277fn needs_newline_if_wrap(expr: &Expr) -> bool {
1278 match expr {
1279 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
1280 Expr::Array(_)
1281 | Expr::Async(_)
1282 | Expr::Block(_)
1283 | Expr::Break(ExprBreak { expr: None, .. })
1284 | Expr::Closure(_)
1285 | Expr::Const(_)
1286 | Expr::Continue(_)
1287 | Expr::ForLoop(_)
1288 | Expr::If(_)
1289 | Expr::Infer(_)
1290 | Expr::Lit(_)
1291 | Expr::Loop(_)
1292 | Expr::Macro(_)
1293 | Expr::Match(_)
1294 | Expr::Path(_)
1295 | Expr::Range(ExprRange { end: None, .. })
1296 | Expr::Repeat(_)
1297 | Expr::Return(ExprReturn { expr: None, .. })
1298 | Expr::Struct(_)
1299 | Expr::TryBlock(_)
1300 | Expr::Tuple(_)
1301 | Expr::Unsafe(_)
1302 | Expr::Verbatim(_)
1303 | Expr::While(_)
1304 | Expr::Yield(ExprYield { expr: None, .. }) => false,
1305
1306 Expr::Assign(_)
1307 | Expr::Await(_)
1308 | Expr::Binary(_)
1309 | Expr::Cast(_)
1310 | Expr::Field(_)
1311 | Expr::Index(_)
1312 | Expr::MethodCall(_) => true,
1313
1314 Expr::Break(ExprBreak { expr: Some(e), .. })
1315 | Expr::Call(ExprCall { func: e, .. })
1316 | Expr::Group(ExprGroup { expr: e, .. })
1317 | Expr::Let(ExprLet { expr: e, .. })
1318 | Expr::Paren(ExprParen { expr: e, .. })
1319 | Expr::Range(ExprRange { end: Some(e), .. })
1320 | Expr::RawAddr(ExprRawAddr { expr: e, .. })
1321 | Expr::Reference(ExprReference { expr: e, .. })
1322 | Expr::Return(ExprReturn { expr: Some(e), .. })
1323 | Expr::Try(ExprTry { expr: e, .. })
1324 | Expr::Unary(ExprUnary { expr: e, .. })
1325 | Expr::Yield(ExprYield { expr: Some(e), .. }) => needs_newline_if_wrap(e),
1326
1327 _ => false,
1328 }
1329}
1330
1331fn is_short_ident(expr: &Expr) -> bool {
1332 if let Expr::Path(expr: &ExprPath) = expr {
1333 return expr.attrs.is_empty()
1334 && expr.qself.is_none()
1335 && expr
1336 .path
1337 .get_ident()
1338 .map_or(default:false, |ident: &Ident| ident.to_string().len() as isize <= INDENT);
1339 }
1340 false
1341}
1342
1343fn is_blocklike(expr: &Expr) -> bool {
1344 match expr {
1345 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
1346 Expr::Array(ExprArray { attrs, .. })
1347 | Expr::Async(ExprAsync { attrs, .. })
1348 | Expr::Block(ExprBlock { attrs, .. })
1349 | Expr::Closure(ExprClosure { attrs, .. })
1350 | Expr::Const(ExprConst { attrs, .. })
1351 | Expr::Struct(ExprStruct { attrs, .. })
1352 | Expr::TryBlock(ExprTryBlock { attrs, .. })
1353 | Expr::Tuple(ExprTuple { attrs, .. })
1354 | Expr::Unsafe(ExprUnsafe { attrs, .. }) => !attr::has_outer(attrs),
1355
1356 Expr::Assign(_)
1357 | Expr::Await(_)
1358 | Expr::Binary(_)
1359 | Expr::Break(_)
1360 | Expr::Call(_)
1361 | Expr::Cast(_)
1362 | Expr::Continue(_)
1363 | Expr::Field(_)
1364 | Expr::ForLoop(_)
1365 | Expr::If(_)
1366 | Expr::Index(_)
1367 | Expr::Infer(_)
1368 | Expr::Let(_)
1369 | Expr::Lit(_)
1370 | Expr::Loop(_)
1371 | Expr::Macro(_)
1372 | Expr::Match(_)
1373 | Expr::MethodCall(_)
1374 | Expr::Paren(_)
1375 | Expr::Path(_)
1376 | Expr::Range(_)
1377 | Expr::RawAddr(_)
1378 | Expr::Reference(_)
1379 | Expr::Repeat(_)
1380 | Expr::Return(_)
1381 | Expr::Try(_)
1382 | Expr::Unary(_)
1383 | Expr::Verbatim(_)
1384 | Expr::While(_)
1385 | Expr::Yield(_) => false,
1386
1387 Expr::Group(e) => is_blocklike(&e.expr),
1388
1389 _ => false,
1390 }
1391}
1392
1393pub fn simple_block(expr: &Expr) -> Option<&ExprBlock> {
1394 if let Expr::Block(expr: &ExprBlock) = expr {
1395 if expr.attrs.is_empty() && expr.label.is_none() {
1396 return Some(expr);
1397 }
1398 }
1399 None
1400}
1401
1402pub fn simple_array(elements: &Punctuated<Expr, Token![,]>) -> bool {
1403 for expr: &Expr in elements {
1404 if let Expr::Lit(expr: &ExprLit) = expr {
1405 match expr.lit {
1406 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
1407 Lit::Byte(_) | Lit::Char(_) | Lit::Int(_) | Lit::Bool(_) => {}
1408
1409 Lit::Str(_) | Lit::ByteStr(_) | Lit::CStr(_) | Lit::Float(_) | Lit::Verbatim(_) => {
1410 return false;
1411 }
1412
1413 _ => return false,
1414 }
1415 } else {
1416 return false;
1417 }
1418 }
1419 true
1420}
1421
1422// Expressions for which `$expr` and `{ $expr }` mean the same thing.
1423//
1424// This is not the case for all expressions. For example `{} | x | x` has some
1425// bitwise OR operators while `{ {} |x| x }` has a block followed by a closure.
1426fn parseable_as_stmt(mut expr: &Expr) -> bool {
1427 loop {
1428 match expr {
1429 #![cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
1430 Expr::Array(_)
1431 | Expr::Async(_)
1432 | Expr::Block(_)
1433 | Expr::Break(_)
1434 | Expr::Closure(_)
1435 | Expr::Const(_)
1436 | Expr::Continue(_)
1437 | Expr::ForLoop(_)
1438 | Expr::If(_)
1439 | Expr::Infer(_)
1440 | Expr::Lit(_)
1441 | Expr::Loop(_)
1442 | Expr::Macro(_)
1443 | Expr::Match(_)
1444 | Expr::Paren(_)
1445 | Expr::Path(_)
1446 | Expr::RawAddr(_)
1447 | Expr::Reference(_)
1448 | Expr::Repeat(_)
1449 | Expr::Return(_)
1450 | Expr::Struct(_)
1451 | Expr::TryBlock(_)
1452 | Expr::Tuple(_)
1453 | Expr::Unary(_)
1454 | Expr::Unsafe(_)
1455 | Expr::Verbatim(_)
1456 | Expr::While(_)
1457 | Expr::Yield(_) => return true,
1458
1459 Expr::Let(_) => return false,
1460
1461 Expr::Assign(e) => {
1462 if !classify::requires_semi_to_be_stmt(&e.left) {
1463 return false;
1464 }
1465 expr = &e.left;
1466 }
1467 Expr::Await(e) => expr = &e.base,
1468 Expr::Binary(e) => {
1469 if !classify::requires_semi_to_be_stmt(&e.left) {
1470 return false;
1471 }
1472 expr = &e.left;
1473 }
1474 Expr::Call(e) => {
1475 if !classify::requires_semi_to_be_stmt(&e.func) {
1476 return false;
1477 }
1478 expr = &e.func;
1479 }
1480 Expr::Cast(e) => {
1481 if !classify::requires_semi_to_be_stmt(&e.expr) {
1482 return false;
1483 }
1484 expr = &e.expr;
1485 }
1486 Expr::Field(e) => expr = &e.base,
1487 Expr::Group(e) => expr = &e.expr,
1488 Expr::Index(e) => {
1489 if !classify::requires_semi_to_be_stmt(&e.expr) {
1490 return false;
1491 }
1492 expr = &e.expr;
1493 }
1494 Expr::MethodCall(e) => expr = &e.receiver,
1495 Expr::Range(e) => match &e.start {
1496 None => return true,
1497 Some(start) => {
1498 if !classify::requires_semi_to_be_stmt(start) {
1499 return false;
1500 }
1501 expr = start;
1502 }
1503 },
1504 Expr::Try(e) => expr = &e.expr,
1505
1506 _ => return false,
1507 }
1508 }
1509}
1510