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     [#![rustc_dummy] 1, 2, 3];
  75
  76     let _ = #[rustc_dummy] [#![rustc_dummy] 1, 2, 3];
  77
  78     #[rustc_dummy]
  79     [#![rustc_dummy] 1; 4];
  80
  81     let _ = #[rustc_dummy] [#![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{#![rustc_dummy] data: (),};
  94
  95     let _ = #[rustc_dummy] Foo{#![rustc_dummy] data: (),};
  96 }
  97
  98 fn _8() {
  99
 100     #[rustc_dummy]
 101     (#![rustc_dummy] );
 102
 103     #[rustc_dummy]
 104     (#![rustc_dummy] 0);
 105
 106     #[rustc_dummy]
 107     (#![rustc_dummy] 0,);
 108
 109     #[rustc_dummy]
 110     (#![rustc_dummy] 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] [#![rustc_dummy] ];
 142     let _ = #[rustc_dummy] [#![rustc_dummy] 0, 0];
 143     let _ = #[rustc_dummy] [#![rustc_dummy] 0; 0];
 144     let _ = #[rustc_dummy] foo();
 145     let _ = #[rustc_dummy] 1i32.clone();
 146     let _ = #[rustc_dummy] (#![rustc_dummy] );
 147     let _ = #[rustc_dummy] (#![rustc_dummy] 0);
 148     let _ = #[rustc_dummy] (#![rustc_dummy] 0,);
 149     let _ = #[rustc_dummy] (#![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     // FIXME: pp bug, two spaces after the loop
 170     let _ =
 171         #[rustc_dummy] loop  {
 172                            #![rustc_dummy]
 173                        };
 174     let _ =
 175         #[rustc_dummy] match false {
 176                            #![rustc_dummy]
 177                            _ => (),
 178                        };
 179     let _ = #[rustc_dummy] || #[rustc_dummy] ();
 180     let _ = #[rustc_dummy] move || #[rustc_dummy] ();
 181     let _ =
 182         #[rustc_dummy] ||
 183                            {
 184                                #![rustc_dummy]
 185                                #[rustc_dummy]
 186                                ()
 187                            };
 188     let _ =
 189         #[rustc_dummy] move ||
 190                            {
 191                                #![rustc_dummy]
 192                                #[rustc_dummy]
 193                                ()
 194                            };
 195     let _ =
 196         #[rustc_dummy] {
 197                            #![rustc_dummy]
 198                        };
 199     let _ =
 200         #[rustc_dummy] {
 201                            #![rustc_dummy]
 202                            let _ = ();
 203                        };
 204     let _ =
 205         #[rustc_dummy] {
 206                            #![rustc_dummy]
 207                            let _ = ();
 208                            ()
 209                        };
 210     let mut x = 0;
 211     let _ = #[rustc_dummy] x = 15;
 212     let _ = #[rustc_dummy] x += 15;
 213     let s = Foo{data: (),};
 214     let _ = #[rustc_dummy] s.data;
 215     let _ = (#[rustc_dummy] s).data;
 216     let t = Bar(());
 217     let _ = #[rustc_dummy] t.0;
 218     let _ = (#[rustc_dummy] t).0;
 219     let v = vec!(0);
 220     let _ = #[rustc_dummy] v[0];
 221     let _ = (#[rustc_dummy] v)[0];
 222     let _ = #[rustc_dummy] 0..#[rustc_dummy] 0;
 223     let _ = #[rustc_dummy] 0..;
 224     let _ = #[rustc_dummy] (0..0);
 225     let _ = #[rustc_dummy] (0..);
 226     let _ = #[rustc_dummy] (..0);
 227     let _ = #[rustc_dummy] (..);
 228     let _: fn(&u32) -> u32 = #[rustc_dummy] std::clone::Clone::clone;
 229     let _ = #[rustc_dummy] &0;
 230     let _ = #[rustc_dummy] &mut 0;
 231     let _ = #[rustc_dummy] &#[rustc_dummy] 0;
 232     let _ = #[rustc_dummy] &mut #[rustc_dummy] 0;
 233     // FIXME: pp bug, extra space after keyword?
 234     while false { let _ = #[rustc_dummy] continue ; }
 235     while true { let _ = #[rustc_dummy] break ; }
 236     || #[rustc_dummy] return;
 237     let _ = #[rustc_dummy] expr_mac!();
 238     let _ = #[rustc_dummy] expr_mac![];
 239     let _ = #[rustc_dummy] expr_mac! { };
 240     let _ = #[rustc_dummy] Foo{#![rustc_dummy] data: (),};
 241     let _ = #[rustc_dummy] Foo{#![rustc_dummy] ..s};
 242     let _ = #[rustc_dummy] Foo{#![rustc_dummy] data: (), ..s};
 243     let _ = #[rustc_dummy] (#![rustc_dummy] 0);
 244 }
 245
 246 fn _12() {
 247     #[rustc_dummy]
 248     let _ = 0;
 249
 250     #[rustc_dummy]
 251     0;
 252
 253     #[rustc_dummy]
 254     expr_mac!();
 255
 256     #[rustc_dummy]
 257     {
 258         #![rustc_dummy]
 259     }
 260 }
 261
 262 fn foo() { }
 263 fn foo3(_: i32, _: (), _: ()) { }
 264 fn qux(_: i32) { }