]>
Commit | Line | Data |
---|---|---|
1 | // Copyright 2015 The Rust Project Developers. See the COPYRIGHT | |
2 | // file at the top-level directory of this distribution and at | |
3 | // http://rust-lang.org/COPYRIGHT. | |
4 | // | |
5 | // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or | |
6 | // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license | |
7 | // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your | |
8 | // option. This file may not be copied, modified, or distributed | |
9 | // except according to those terms. | |
10 | ||
11 | // pp-exact | |
12 | ||
13 | #![feature(custom_attribute)] | |
14 | #![feature(box_syntax)] | |
15 | #![feature(placement_in_syntax)] | |
16 | #![feature(stmt_expr_attributes)] | |
17 | ||
18 | fn main() { } | |
19 | ||
20 | fn _0() { | |
21 | ||
22 | #[attr] | |
23 | foo(); | |
24 | } | |
25 | ||
26 | fn _1() { | |
27 | ||
28 | #[attr] | |
29 | unsafe { | |
30 | // code | |
31 | } | |
32 | } | |
33 | ||
34 | fn _2() { | |
35 | ||
36 | #[attr] | |
37 | { foo(); } | |
38 | ||
39 | { | |
40 | #![attr] | |
41 | ||
42 | foo() | |
43 | } | |
44 | } | |
45 | ||
46 | fn _3() { | |
47 | ||
48 | #[attr] | |
49 | match () { _ => { } } | |
50 | } | |
51 | ||
52 | fn _4() { | |
53 | ||
54 | #[attr] | |
55 | match () { | |
56 | #![attr] | |
57 | _ => (), | |
58 | } | |
59 | ||
60 | let _ = | |
61 | #[attr] match () { | |
62 | #![attr] | |
63 | () => (), | |
64 | }; | |
65 | } | |
66 | ||
67 | fn _5() { | |
68 | ||
69 | #[attr] | |
70 | let x = 1; | |
71 | ||
72 | let x = #[attr] 1; | |
73 | ||
74 | let y = (); | |
75 | let z = (); | |
76 | ||
77 | foo3(x, #[attr] y, z); | |
78 | ||
79 | qux(3 + #[attr] 2); | |
80 | } | |
81 | ||
82 | fn _6() { | |
83 | ||
84 | #[attr] | |
85 | [#![attr] 1, 2, 3]; | |
86 | ||
87 | let _ = #[attr] [#![attr] 1, 2, 3]; | |
88 | ||
89 | #[attr] | |
90 | [#![attr] 1; 4]; | |
91 | ||
92 | let _ = #[attr] [#![attr] 1; 4]; | |
93 | } | |
94 | ||
95 | struct Foo { | |
96 | data: (), | |
97 | } | |
98 | ||
99 | struct Bar(()); | |
100 | ||
101 | fn _7() { | |
102 | ||
103 | #[attr] | |
104 | Foo{#![attr] data: (),}; | |
105 | ||
106 | let _ = #[attr] Foo{#![attr] data: (),}; | |
107 | } | |
108 | ||
109 | fn _8() { | |
110 | ||
111 | #[attr] | |
112 | (#![attr] ); | |
113 | ||
114 | #[attr] | |
115 | (#![attr] 0); | |
116 | ||
117 | #[attr] | |
118 | (#![attr] 0,); | |
119 | ||
120 | #[attr] | |
121 | (#![attr] 0, 1); | |
122 | } | |
123 | ||
124 | fn _9() { | |
125 | macro_rules! stmt_mac(( ) => { let _ = ( ) ; }); | |
126 | ||
127 | #[attr] | |
128 | stmt_mac!(); | |
129 | ||
130 | /* | |
131 | // pre existing pp bug: delimiter styles gets lost: | |
132 | ||
133 | #[attr] | |
134 | stmt_mac!{ }; | |
135 | ||
136 | #[attr] | |
137 | stmt_mac![]; | |
138 | ||
139 | #[attr] | |
140 | stmt_mac!{ } // pre-existing pp bug: compiler ICEs with a None unwrap | |
141 | */ | |
142 | ||
143 | let _ = (); | |
144 | } | |
145 | ||
146 | macro_rules! expr_mac(( ) => { ( ) }); | |
147 | ||
148 | fn _10() { | |
149 | ||
150 | let _ = #[attr] expr_mac!(); | |
151 | ||
152 | /* | |
153 | // pre existing pp bug: delimiter styles gets lost: | |
154 | let _ = #[attr] expr_mac![]; | |
155 | let _ = #[attr] expr_mac!{}; | |
156 | */ | |
157 | } | |
158 | ||
159 | fn _11() { | |
160 | let _ = #[attr] box 0; | |
161 | let _: [(); 0] = #[attr] [#![attr] ]; | |
162 | let _ = #[attr] [#![attr] 0, 0]; | |
163 | let _ = #[attr] [#![attr] 0; 0]; | |
164 | let _ = #[attr] foo(); | |
165 | let _ = #[attr] 1i32.clone(); | |
166 | let _ = #[attr] (#![attr] ); | |
167 | let _ = #[attr] (#![attr] 0); | |
168 | let _ = #[attr] (#![attr] 0,); | |
169 | let _ = #[attr] (#![attr] 0, 0); | |
170 | let _ = #[attr] 0 + #[attr] 0; | |
171 | let _ = #[attr] !0; | |
172 | let _ = #[attr] -0i32; | |
173 | let _ = #[attr] false; | |
174 | let _ = #[attr] 'c'; | |
175 | let _ = #[attr] 0; | |
176 | let _ = #[attr] 0 as usize; | |
177 | let _ = | |
178 | #[attr] while false { | |
179 | #![attr] | |
180 | }; | |
181 | let _ = | |
182 | #[attr] while let None = Some(()) { | |
183 | #![attr] | |
184 | }; | |
185 | let _ = | |
186 | #[attr] for _ in 0..0 { | |
187 | #![attr] | |
188 | }; | |
189 | // FIXME: pp bug, two spaces after the loop | |
190 | let _ = | |
191 | #[attr] loop { | |
192 | #![attr] | |
193 | }; | |
194 | let _ = | |
195 | #[attr] match false { | |
196 | #![attr] | |
197 | _ => (), | |
198 | }; | |
199 | let _ = #[attr] || #[attr] (); | |
200 | let _ = #[attr] move || #[attr] (); | |
201 | let _ = #[attr] || { | |
202 | #![attr] | |
203 | #[attr] | |
204 | () }; | |
205 | let _ = #[attr] move || { | |
206 | #![attr] | |
207 | #[attr] | |
208 | () }; | |
209 | let _ = | |
210 | #[attr] { | |
211 | #![attr] | |
212 | }; | |
213 | let _ = | |
214 | #[attr] { | |
215 | #![attr] | |
216 | let _ = (); | |
217 | }; | |
218 | let _ = | |
219 | #[attr] { | |
220 | #![attr] | |
221 | let _ = (); | |
222 | () | |
223 | }; | |
224 | let mut x = 0; | |
225 | let _ = #[attr] x = 15; | |
226 | let _ = #[attr] x += 15; | |
227 | let s = Foo{data: (),}; | |
228 | let _ = #[attr] s.data; | |
229 | let _ = (#[attr] s).data; | |
230 | let t = Bar(()); | |
231 | let _ = #[attr] t.0; | |
232 | let _ = (#[attr] t).0; | |
233 | let v = vec!(0); | |
234 | let _ = #[attr] v[0]; | |
235 | let _ = (#[attr] v)[0]; | |
236 | let _ = #[attr] 0..#[attr] 0; | |
237 | let _ = #[attr] 0..; | |
238 | let _ = #[attr] (0..0); | |
239 | let _ = #[attr] (0..); | |
240 | let _ = #[attr] (..0); | |
241 | let _ = #[attr] (..); | |
242 | let _: fn(&u32) -> u32 = #[attr] std::clone::Clone::clone; | |
243 | let _ = #[attr] &0; | |
244 | let _ = #[attr] &mut 0; | |
245 | let _ = #[attr] &#[attr] 0; | |
246 | let _ = #[attr] &mut #[attr] 0; | |
247 | // FIXME: pp bug, extra space after keyword? | |
248 | while false { let _ = #[attr] continue ; } | |
249 | while true { let _ = #[attr] break ; } | |
250 | || #[attr] return; | |
251 | let _ = #[attr] expr_mac!(); | |
252 | /* FIXME: pp bug, loosing delimiter styles | |
253 | let _ = #[attr] expr_mac![]; | |
254 | let _ = #[attr] expr_mac!{}; | |
255 | */ | |
256 | let _ = #[attr] Foo{#![attr] data: (),}; | |
257 | let _ = #[attr] Foo{#![attr] ..s}; | |
258 | let _ = #[attr] Foo{#![attr] data: (), ..s}; | |
259 | let _ = #[attr] (#![attr] 0); | |
260 | } | |
261 | ||
262 | fn _12() { | |
263 | #[attr] | |
264 | let _ = 0; | |
265 | ||
266 | #[attr] | |
267 | 0; | |
268 | ||
269 | #[attr] | |
270 | expr_mac!(); | |
271 | ||
272 | #[attr] | |
273 | { | |
274 | #![attr] | |
275 | } | |
276 | } | |
277 | ||
278 | ///////////////// | |
279 | ||
280 | fn foo() { } | |
281 | fn foo3(_: i32, _: (), _: ()) { } | |
282 | fn qux(_: i32) { } |