src/test/pretty/stmt_expr_attributes.rs

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