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