1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
|
//@ compile-flags: -Zunpretty=expanded
//@ check-pass
// This test covers the AST pretty-printer's insertion of parentheses in some
// macro metavariable edge cases. Synthetic parentheses (i.e. not appearing in
// the syntax tree) need to be printed in order for the printed code to be valid
// Rust syntax. We also test negative cases: the pretty-printer should not be
// synthesizing parentheses indiscriminately; only where necessary.
#![feature(let_chains)]
#![feature(if_let_guard)]
macro_rules! expr {
($expr:expr) => { $expr };
}
macro_rules! stmt {
($stmt:stmt) => { $stmt };
}
fn break_labeled_loop() {
let no_paren = 'outer: loop {
break 'outer expr!('inner: loop { break 'inner 1; } + 1);
};
let paren_around_break_value = 'outer: loop {
break expr!('inner: loop { break 'inner 1; } + 1);
};
macro_rules! breaking {
($value:expr) => {
break $value
};
}
let paren_around_break_value = loop {
breaking!('inner: loop { break 'inner 1; } + 1);
};
}
fn if_let() {
macro_rules! if_let {
($pat:pat, $expr:expr) => {
if let $pat = $expr {}
};
}
if let no_paren = true && false {}
if_let!(paren_around_binary, true && false);
if_let!(no_paren, true);
struct Struct {}
match () {
_ if let no_paren = Struct {} => {}
}
}
fn let_else() {
let no_paren = expr!(1 + 1) else { return; };
let paren_around_loop = expr!(loop {}) else { return; };
}
fn local() {
macro_rules! let_expr_minus_one {
($pat:pat, $expr:expr) => {
let $pat = $expr - 1;
};
}
let void;
let_expr_minus_one!(no_paren, match void {});
macro_rules! let_expr_else_return {
($pat:pat, $expr:expr) => {
let $pat = $expr else { return; };
};
}
let_expr_else_return!(no_paren, void());
}
fn match_arm() {
macro_rules! match_arm {
($pat:pat, $expr:expr) => {
match () { $pat => $expr }
};
}
match_arm!(no_paren, 1 - 1);
match_arm!(paren_around_brace, { 1 } - 1);
}
/// https://github.com/rust-lang/rust/issues/98790
fn stmt_boundary() {
macro_rules! expr_as_stmt {
($expr:expr) => {
stmt!($expr)
};
}
let paren_around_match;
expr_as_stmt!(match paren_around_match {} | true);
macro_rules! minus_one {
($expr:expr) => {
expr_as_stmt!($expr - 1)
};
}
let (no_paren, paren_around_loop);
minus_one!(no_paren);
minus_one!(match paren_around_match {});
minus_one!(match paren_around_match {}());
minus_one!(match paren_around_match {}[0]);
minus_one!(loop { break paren_around_loop; });
}
fn vis_inherited() {
macro_rules! vis_inherited {
($vis:vis struct) => {
$vis struct Struct;
};
}
vis_inherited!(struct);
}
|
