src/test/pretty/stmt_expr_attributes.rs

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