]>
Commit | Line | Data |
---|---|---|
b7449926 | 1 | // run-pass |
0bf4aa26 XL |
2 | #![allow(dead_code)] |
3 | #![allow(unused_assignments)] | |
94b46f34 XL |
4 | #![feature(label_break_value)] |
5 | ||
6 | // Test control flow to follow label_break_value semantics | |
7 | fn label_break(a: bool, b: bool) -> u32 { | |
8 | let mut v = 0; | |
9 | 'b: { | |
10 | v = 1; | |
11 | if a { | |
12 | break 'b; | |
13 | } | |
14 | v = 2; | |
15 | if b { | |
16 | break 'b; | |
17 | } | |
18 | v = 3; | |
19 | } | |
20 | return v; | |
21 | } | |
22 | ||
23 | // Test that values can be returned | |
24 | fn break_value(a: bool, b: bool) -> u32 { | |
25 | let result = 'block: { | |
26 | if a { break 'block 1; } | |
27 | if b { break 'block 2; } | |
28 | 3 | |
29 | }; | |
30 | result | |
31 | } | |
32 | ||
33 | // Test nesting of labeled blocks | |
34 | // here we only check that it compiles | |
35 | fn label_break_nested() { | |
36 | 'b: { | |
37 | println!("hi"); | |
38 | if false { | |
39 | break 'b; | |
40 | } | |
41 | 'c: { | |
42 | if false { | |
43 | break 'b; | |
44 | } | |
45 | break 'c; | |
46 | } | |
47 | println!("hello"); | |
48 | if true { | |
49 | break 'b; | |
50 | } | |
51 | } | |
52 | } | |
53 | ||
54 | // Tests for mixing labeled blocks with loop constructs | |
55 | // This function should be the identity function | |
56 | fn label_break_mixed(v: u32) -> u32 { | |
57 | let mut r = 0; | |
58 | 'b: { | |
59 | // Unlabeled break still works | |
60 | // (only crossing boundaries is an error) | |
61 | loop { | |
62 | break; | |
63 | } | |
64 | if v == 0 { | |
65 | break 'b; | |
66 | } | |
67 | // Labeled breaking an inner loop still works | |
68 | 'c: loop { | |
69 | if r == 1 { | |
70 | break 'c; | |
71 | } | |
72 | r += 1; | |
73 | } | |
74 | assert_eq!(r, 1); | |
75 | if v == 1 { | |
76 | break 'b; | |
77 | } | |
78 | // Labeled breaking an outer loop still works | |
79 | 'd: loop { | |
60c5eb7d | 80 | { |
94b46f34 XL |
81 | if v == r { |
82 | break 'b; | |
83 | } | |
84 | if r == 5 { | |
85 | break 'd; | |
86 | } | |
87 | r += 1; | |
88 | } | |
89 | } | |
90 | assert_eq!(r, 5); | |
91 | assert!(v > r); | |
92 | // Here we test return from inside a labeled block | |
93 | return v; | |
94 | } | |
95 | r | |
96 | } | |
97 | ||
04454e1e FG |
98 | fn label_break_match(c: u8, xe: u8, ye: i8) { |
99 | let mut x = 0; | |
100 | let y = 'a: { | |
101 | match c { | |
102 | 0 => break 'a 0, | |
103 | v if { if v % 2 == 0 { break 'a 1; }; v % 3 == 0 } => { x += 1; }, | |
104 | v if { 'b: { break 'b v == 5; } } => { x = 41; }, | |
923072b8 | 105 | _ => 'b: { |
04454e1e FG |
106 | break 'b (); |
107 | }, | |
108 | } | |
109 | x += 1; | |
110 | -1 | |
111 | }; | |
112 | ||
113 | assert_eq!(x, xe); | |
114 | assert_eq!(y, ye); | |
115 | } | |
116 | ||
117 | #[allow(unused_labels)] | |
118 | fn label_break_macro() { | |
119 | macro_rules! mac1 { | |
120 | ($target:lifetime, $val:expr) => { | |
121 | break $target $val; | |
122 | }; | |
123 | } | |
124 | let x: u8 = 'a: { | |
125 | 'b: { | |
126 | mac1!('b, 1); | |
127 | }; | |
128 | 0 | |
129 | }; | |
130 | assert_eq!(x, 0); | |
923072b8 FG |
131 | let x: u8 = 'a: { |
132 | 'b: { | |
04454e1e FG |
133 | if true { |
134 | mac1!('a, 1); | |
135 | } | |
136 | }; | |
137 | 0 | |
138 | }; | |
139 | assert_eq!(x, 1); | |
140 | } | |
141 | ||
94b46f34 XL |
142 | pub fn main() { |
143 | assert_eq!(label_break(true, false), 1); | |
144 | assert_eq!(label_break(false, true), 2); | |
145 | assert_eq!(label_break(false, false), 3); | |
146 | ||
147 | assert_eq!(break_value(true, false), 1); | |
148 | assert_eq!(break_value(false, true), 2); | |
149 | assert_eq!(break_value(false, false), 3); | |
150 | ||
151 | assert_eq!(label_break_mixed(0), 0); | |
152 | assert_eq!(label_break_mixed(1), 1); | |
153 | assert_eq!(label_break_mixed(2), 2); | |
154 | assert_eq!(label_break_mixed(3), 3); | |
155 | assert_eq!(label_break_mixed(4), 4); | |
156 | assert_eq!(label_break_mixed(5), 5); | |
157 | assert_eq!(label_break_mixed(6), 6); | |
158 | ||
04454e1e FG |
159 | label_break_match(0, 0, 0); |
160 | label_break_match(1, 1, -1); | |
161 | label_break_match(2, 0, 1); | |
162 | label_break_match(3, 2, -1); | |
163 | label_break_match(5, 42, -1); | |
164 | label_break_match(7, 1, -1); | |
165 | ||
166 | label_break_macro(); | |
94b46f34 | 167 | } |