tests/source/expr.rs

   1 // rustfmt-normalize_comments: true
   2 // rustfmt-wrap_comments: true
   3 // Test expressions
   4
   5 fn foo() -> bool {
   6     let boxed: Box<i32> = box   5;
   7     let referenced = &5 ;
   8
   9     let very_long_variable_name = ( a +  first +   simple + test   );
  10     let very_long_variable_name = (a + first + simple + test + AAAAAAAAAAAAA + BBBBBBBBBBBBBBBBB + b + c);
  11
  12     let is_internalxxxx = self.codemap.span_to_filename(s) == self.codemap.span_to_filename(m.inner);
  13
  14     let some_val = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa * bbbb / (bbbbbb -
  15         function_call(x, *very_long_pointer, y))
  16     + 1000  ;
  17
  18 some_ridiculously_loooooooooooooooooooooong_function(10000 * 30000000000 + 40000 / 1002200000000
  19                                                      - 50000 * sqrt(-1),
  20                                                      trivial_value);
  21     (((((((((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + a +
  22              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaa)))))))))   ;
  23
  24     { for _ in 0..10 {} }
  25
  26     {{{{}}}}
  27
  28      if  1  + 2 > 0  { let result = 5; result } else { 4};
  29
  30     if  let   Some(x)  =  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {
  31         // Nothing
  32     }
  33
  34     if  let   Some(x)  =  (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}
  35
  36     if let (some_very_large,
  37             tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple) = 1
  38         + 2 + 3 {
  39     }
  40
  41     if let (some_very_large,
  42             tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple) = 1111 + 2222 {}
  43
  44     if let (some_very_large, tuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuple) = 1
  45  + 2 + 3 {
  46     }
  47
  48     if let ast::ItemKind::Trait(_, unsafety, ref generics, ref type_param_bounds, ref trait_items) = item.node
  49     {
  50         // nothing
  51     }
  52
  53     let test = if true { 5 } else { 3 };
  54
  55     if cond() {
  56         something();
  57     } else  if different_cond() {
  58         something_else();
  59     } else {
  60         // Check subformatting
  61         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
  62     }
  63 }
  64
  65 fn bar() {
  66     let range = (   111111111 + 333333333333333333 + 1111 +   400000000000000000) .. (2222 +  2333333333333333);
  67
  68     let another_range = 5..some_func( a , b /* comment */);
  69
  70     for _  in  1 ..{ call_forever(); }
  71
  72     syntactically_correct(loop { sup( '?'); }, if cond { 0 } else { 1 });
  73
  74     let third = ..10;
  75     let infi_range = ..   ;
  76     let foo = 1..;
  77     let bar = 5 ;
  78     let nonsense = (10 .. 0)..(0..10);
  79
  80     loop{if true {break}}
  81
  82     let x = (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&
  83              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,
  84              a);
  85 }
  86
  87 fn baz() {
  88     unsafe    /*    {}{}{}{{{{}}   */   {
  89         let foo = 1u32;
  90     }
  91
  92     unsafe /* very looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong comment */ {}
  93
  94     unsafe // So this is a very long comment.
  95            // Multi-line, too.
  96            // Will it still format correctly?
  97     {
  98     }
  99
 100     unsafe {
 101         // Regular unsafe block
 102     }
 103
 104     unsafe {
 105         foo()
 106     }
 107
 108     unsafe {
 109         foo();
 110     }
 111 }
 112
 113 // Test some empty blocks.
 114 fn qux() {
 115     {}
 116     // FIXME this one could be done better.
 117     { /* a block with a comment */ }
 118     {
 119
 120     }
 121     {
 122         // A block with a comment.
 123     }
 124 }
 125
 126 fn issue227() {
 127     {
 128         let handler = box DocumentProgressHandler::new(addr, DocumentProgressTask::DOMContentLoaded);
 129     }
 130 }
 131
 132 fn issue184(source: &str) {
 133     for c in source.chars() {
 134         if index < 'a' {
 135             continue;
 136         }
 137     }
 138 }
 139
 140 fn arrays() {
 141     let x = [0,
 142          1,
 143          2,
 144          3,
 145          4,
 146          5,
 147          6,
 148          7,
 149          8,
 150          9,
 151          0,
 152          1,
 153          2,
 154          3,
 155          4,
 156          5,
 157          6,
 158          7,
 159          8,
 160          9,
 161          0,
 162          7,
 163          8,
 164          9,
 165          0,
 166          1,
 167          2,
 168          3,
 169          4,
 170          5,
 171          6,
 172          7,
 173          8,
 174          9,
 175          0];
 176
 177     let y = [/* comment */ 1, 2 /* post comment */, 3];
 178
 179     let xy =    [ strukt  { test123: value_one_two_three_four, turbo: coolio(), } , /* comment  */   1 ];
 180
 181         let a =WeightedChoice::new(&mut [Weighted {
 182             weightweight: x,
 183             item: 0,
 184         },
 185                                   Weighted {
 186             weightweight: 1,
 187             item: 1,
 188         },
 189                                   Weighted {
 190             weightweight: x,
 191             item: 2,
 192         },
 193                                   Weighted {
 194             weightweight: 1,
 195             item: 3,
 196         }]);
 197
 198     let z = [xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx, yyyyyyyyyyyyyyyyyyyyyyyyyyy, zzzzzzzzzzzzzzzzzz, q];
 199
 200     [ 1 +   3, 4 ,  5, 6, 7, 7, fncall::<Vec<_>>(3-1)]
 201 }
 202
 203 fn returns() {
 204     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa && return;
 205
 206     return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;
 207 }
 208
 209 fn addrof() {
 210     &    mut(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
 211     &    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);
 212 }
 213
 214 fn casts() {
 215     fn unpack(packed: u32) -> [u16; 2] {
 216         [
 217             (packed >> 16) as u16,
 218             (packed >>  0) as u16,
 219         ]
 220     }
 221
 222     let some_trait_xxx = xxxxxxxxxxx + xxxxxxxxxxxxx
 223         as SomeTraitXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX;
 224     let slightly_longer_trait = yyyyyyyyy + yyyyyyyyyyy as SomeTraitYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY;
 225 }
 226
 227 fn indices() {
 228     let x = (aaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb+cccccccccccccccc) [ x + y + z ];
 229     let y = (aaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccc)[ xxxxx + yyyyy + zzzzz ];
 230     let z = xxxxxxxxxx.x().y().zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz()[aaaaa];
 231     let z = xxxxxxxxxx.x().y().zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz()[aaaaa];
 232 }
 233
 234 fn repeats() {
 235     let x = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa+bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb+cccccccccccccccc; x + y + z ];
 236     let y = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccc; xxxxx + yyyyy + zzzzz ];
 237 }
 238
 239 fn blocks() {
 240     if 1 + 1 == 2 {
 241         println!("yay arithmetix!");
 242     };
 243 }
 244
 245 fn issue767() {
 246     if false {
 247         if false {
 248         } else {
 249             // A let binding here seems necessary to trigger it.
 250             let _ = ();
 251         }
 252     } else if let false = false {
 253     }
 254 }
 255
 256 fn ranges() {
 257     let x = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa .. bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
 258     let y = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ..= bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;
 259     let z = ..= x ;
 260
 261     // #1766
 262     let x = [0. ..10.0];
 263     let x = [0. ..=10.0];
 264
 265     a ..= b
 266
 267     // the expr below won't compile because inclusive ranges need a defined end
 268     // let a = 0 ..= ;
 269 }
 270
 271 fn if_else() {
 272   let exact = diff /
 273             (if size == 0 {
 274     1
 275 } else {
 276     size
 277 });
 278
 279             let cx = tp1.x +
 280                  any * radius *
 281                  if anticlockwise {
 282             1.0
 283       } else {
 284            -1.0
 285        };
 286 }
 287
 288 fn complex_if_else() {
 289     if let Some(x) = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx {
 290     } else if let Some(x) = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx {
 291         ha();
 292     } else if xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + xxxxxxxx {
 293         yo();
 294     } else if let Some(x) = xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx {
 295         ha();
 296     } else if xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx + xxxxxxxxx {
 297         yo();
 298     }
 299 }
 300
 301 fn issue1106() {
 302     {
 303     if let hir::ItemEnum(ref enum_def, ref generics) = self.ast_map.expect_item(enum_node_id).node {
 304     }
 305     }
 306
 307     for entry in
 308     WalkDir::new(path)
 309         .into_iter()
 310         .filter_entry(|entry| exclusions.filter_entry(entry)) {
 311     }
 312 }
 313
 314 fn issue1570() {
 315     a_very_long_function_name({some_func(1, {1})})
 316 }
 317
 318 fn issue1714() {
 319     v = &mut {v}[mid..];
 320     let (left, right) = {v}.split_at_mut(mid);
 321 }
 322
 323 // Multi-lined index should be put on the next line if it fits in one line.
 324 fn issue1749() {
 325     {
 326         {
 327             {
 328                 if self.shape[(r as f32 + self.x_offset) as usize][(c as f32 + self.y_offset) as usize] != 0 {
 329                     // hello
 330                 }
 331             }
 332         }
 333     }
 334 }
 335
 336 // #1172
 337 fn newlines_between_list_like_expr() {
 338     foo(
 339         xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,
 340
 341         yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,
 342
 343         zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
 344     );
 345
 346     vec![
 347         xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx,
 348
 349         yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy,
 350
 351         zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz,
 352     ];
 353
 354     match x {
 355         xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx |
 356
 357         yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy |
 358
 359         zzzzzzzzzzzzzzzzzzzzzzzzzzzzzz => foo(a, b, c),
 360         _ => bar(),
 361     };
 362 }