src/test/pretty/stmt_expr_attributes.rs

   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) { }