tests/pretty/stmt_expr_attributes.rs

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