diff options
| author | Aleksey Kladov <[email protected]> | 2020-11-09 12:28:04 +0000 |
|---|---|---|
| committer | Aleksey Kladov <[email protected]> | 2020-11-09 12:28:04 +0000 |
| commit | d31ce3b16cbd23950197d8992720b431e19b6af1 (patch) | |
| tree | 0db348ea912c0fec3d8a09183bf739980858e625 /crates/assists | |
| parent | 3cecf78488a40638c8f6ea8b9482080d4bfafca4 (diff) | |
Use standard style for test code
Diffstat (limited to 'crates/assists')
| -rw-r--r-- | crates/assists/src/handlers/wrap_return_type_in_result.rs | 1203 |
1 files changed, 635 insertions, 568 deletions
diff --git a/crates/assists/src/handlers/wrap_return_type_in_result.rs b/crates/assists/src/handlers/wrap_return_type_in_result.rs index e08981f89..59e5debb1 100644 --- a/crates/assists/src/handlers/wrap_return_type_in_result.rs +++ b/crates/assists/src/handlers/wrap_return_type_in_result.rs | |||
| @@ -281,14 +281,18 @@ mod tests { | |||
| 281 | fn wrap_return_type_in_result_simple() { | 281 | fn wrap_return_type_in_result_simple() { |
| 282 | check_assist( | 282 | check_assist( |
| 283 | wrap_return_type_in_result, | 283 | wrap_return_type_in_result, |
| 284 | r#"fn foo() -> i3<|>2 { | 284 | r#" |
| 285 | let test = "test"; | 285 | fn foo() -> i3<|>2 { |
| 286 | return 42i32; | 286 | let test = "test"; |
| 287 | }"#, | 287 | return 42i32; |
| 288 | r#"fn foo() -> Result<i32, ${0:_}> { | 288 | } |
| 289 | let test = "test"; | 289 | "#, |
| 290 | return Ok(42i32); | 290 | r#" |
| 291 | }"#, | 291 | fn foo() -> Result<i32, ${0:_}> { |
| 292 | let test = "test"; | ||
| 293 | return Ok(42i32); | ||
| 294 | } | ||
| 295 | "#, | ||
| 292 | ); | 296 | ); |
| 293 | } | 297 | } |
| 294 | 298 | ||
| @@ -296,18 +300,22 @@ mod tests { | |||
| 296 | fn wrap_return_type_in_result_simple_closure() { | 300 | fn wrap_return_type_in_result_simple_closure() { |
| 297 | check_assist( | 301 | check_assist( |
| 298 | wrap_return_type_in_result, | 302 | wrap_return_type_in_result, |
| 299 | r#"fn foo() { | 303 | r#" |
| 300 | || -> i32<|> { | 304 | fn foo() { |
| 301 | let test = "test"; | 305 | || -> i32<|> { |
| 302 | return 42i32; | 306 | let test = "test"; |
| 303 | }; | 307 | return 42i32; |
| 304 | }"#, | 308 | }; |
| 305 | r#"fn foo() { | 309 | } |
| 306 | || -> Result<i32, ${0:_}> { | 310 | "#, |
| 307 | let test = "test"; | 311 | r#" |
| 308 | return Ok(42i32); | 312 | fn foo() { |
| 309 | }; | 313 | || -> Result<i32, ${0:_}> { |
| 310 | }"#, | 314 | let test = "test"; |
| 315 | return Ok(42i32); | ||
| 316 | }; | ||
| 317 | } | ||
| 318 | "#, | ||
| 311 | ); | 319 | ); |
| 312 | } | 320 | } |
| 313 | 321 | ||
| @@ -315,10 +323,12 @@ mod tests { | |||
| 315 | fn wrap_return_type_in_result_simple_return_type_bad_cursor() { | 323 | fn wrap_return_type_in_result_simple_return_type_bad_cursor() { |
| 316 | check_assist_not_applicable( | 324 | check_assist_not_applicable( |
| 317 | wrap_return_type_in_result, | 325 | wrap_return_type_in_result, |
| 318 | r#"fn foo() -> i32 { | 326 | r#" |
| 319 | let test = "test";<|> | 327 | fn foo() -> i32 { |
| 320 | return 42i32; | 328 | let test = "test";<|> |
| 321 | }"#, | 329 | return 42i32; |
| 330 | } | ||
| 331 | "#, | ||
| 322 | ); | 332 | ); |
| 323 | } | 333 | } |
| 324 | 334 | ||
| @@ -326,33 +336,32 @@ mod tests { | |||
| 326 | fn wrap_return_type_in_result_simple_return_type_bad_cursor_closure() { | 336 | fn wrap_return_type_in_result_simple_return_type_bad_cursor_closure() { |
| 327 | check_assist_not_applicable( | 337 | check_assist_not_applicable( |
| 328 | wrap_return_type_in_result, | 338 | wrap_return_type_in_result, |
| 329 | r#"fn foo() { | 339 | r#" |
| 330 | || -> i32 { | 340 | fn foo() { |
| 331 | let test = "test";<|> | 341 | || -> i32 { |
| 332 | return 42i32; | 342 | let test = "test";<|> |
| 333 | }; | 343 | return 42i32; |
| 334 | }"#, | 344 | }; |
| 345 | } | ||
| 346 | "#, | ||
| 335 | ); | 347 | ); |
| 336 | } | 348 | } |
| 337 | 349 | ||
| 338 | #[test] | 350 | #[test] |
| 339 | fn wrap_return_type_in_result_closure_non_block() { | 351 | fn wrap_return_type_in_result_closure_non_block() { |
| 340 | check_assist_not_applicable( | 352 | check_assist_not_applicable(wrap_return_type_in_result, r#"fn foo() { || -> i<|>32 3; }"#); |
| 341 | wrap_return_type_in_result, | ||
| 342 | r#"fn foo() { | ||
| 343 | || -> i<|>32 3; | ||
| 344 | }"#, | ||
| 345 | ); | ||
| 346 | } | 353 | } |
| 347 | 354 | ||
| 348 | #[test] | 355 | #[test] |
| 349 | fn wrap_return_type_in_result_simple_return_type_already_result_std() { | 356 | fn wrap_return_type_in_result_simple_return_type_already_result_std() { |
| 350 | check_assist_not_applicable( | 357 | check_assist_not_applicable( |
| 351 | wrap_return_type_in_result, | 358 | wrap_return_type_in_result, |
| 352 | r#"fn foo() -> std::result::Result<i32<|>, String> { | 359 | r#" |
| 353 | let test = "test"; | 360 | fn foo() -> std::result::Result<i32<|>, String> { |
| 354 | return 42i32; | 361 | let test = "test"; |
| 355 | }"#, | 362 | return 42i32; |
| 363 | } | ||
| 364 | "#, | ||
| 356 | ); | 365 | ); |
| 357 | } | 366 | } |
| 358 | 367 | ||
| @@ -361,10 +370,12 @@ mod tests { | |||
| 361 | mark::check!(wrap_return_type_in_result_simple_return_type_already_result); | 370 | mark::check!(wrap_return_type_in_result_simple_return_type_already_result); |
| 362 | check_assist_not_applicable( | 371 | check_assist_not_applicable( |
| 363 | wrap_return_type_in_result, | 372 | wrap_return_type_in_result, |
| 364 | r#"fn foo() -> Result<i32<|>, String> { | 373 | r#" |
| 365 | let test = "test"; | 374 | fn foo() -> Result<i32<|>, String> { |
| 366 | return 42i32; | 375 | let test = "test"; |
| 367 | }"#, | 376 | return 42i32; |
| 377 | } | ||
| 378 | "#, | ||
| 368 | ); | 379 | ); |
| 369 | } | 380 | } |
| 370 | 381 | ||
| @@ -372,12 +383,14 @@ mod tests { | |||
| 372 | fn wrap_return_type_in_result_simple_return_type_already_result_closure() { | 383 | fn wrap_return_type_in_result_simple_return_type_already_result_closure() { |
| 373 | check_assist_not_applicable( | 384 | check_assist_not_applicable( |
| 374 | wrap_return_type_in_result, | 385 | wrap_return_type_in_result, |
| 375 | r#"fn foo() { | 386 | r#" |
| 376 | || -> Result<i32<|>, String> { | 387 | fn foo() { |
| 377 | let test = "test"; | 388 | || -> Result<i32<|>, String> { |
| 378 | return 42i32; | 389 | let test = "test"; |
| 379 | }; | 390 | return 42i32; |
| 380 | }"#, | 391 | }; |
| 392 | } | ||
| 393 | "#, | ||
| 381 | ); | 394 | ); |
| 382 | } | 395 | } |
| 383 | 396 | ||
| @@ -385,14 +398,18 @@ mod tests { | |||
| 385 | fn wrap_return_type_in_result_simple_with_cursor() { | 398 | fn wrap_return_type_in_result_simple_with_cursor() { |
| 386 | check_assist( | 399 | check_assist( |
| 387 | wrap_return_type_in_result, | 400 | wrap_return_type_in_result, |
| 388 | r#"fn foo() -> <|>i32 { | 401 | r#" |
| 389 | let test = "test"; | 402 | fn foo() -> <|>i32 { |
| 390 | return 42i32; | 403 | let test = "test"; |
| 391 | }"#, | 404 | return 42i32; |
| 392 | r#"fn foo() -> Result<i32, ${0:_}> { | 405 | } |
| 393 | let test = "test"; | 406 | "#, |
| 394 | return Ok(42i32); | 407 | r#" |
| 395 | }"#, | 408 | fn foo() -> Result<i32, ${0:_}> { |
| 409 | let test = "test"; | ||
| 410 | return Ok(42i32); | ||
| 411 | } | ||
| 412 | "#, | ||
| 396 | ); | 413 | ); |
| 397 | } | 414 | } |
| 398 | 415 | ||
| @@ -400,14 +417,18 @@ mod tests { | |||
| 400 | fn wrap_return_type_in_result_simple_with_tail() { | 417 | fn wrap_return_type_in_result_simple_with_tail() { |
| 401 | check_assist( | 418 | check_assist( |
| 402 | wrap_return_type_in_result, | 419 | wrap_return_type_in_result, |
| 403 | r#"fn foo() -><|> i32 { | 420 | r#" |
| 404 | let test = "test"; | 421 | fn foo() -><|> i32 { |
| 405 | 42i32 | 422 | let test = "test"; |
| 406 | }"#, | 423 | 42i32 |
| 407 | r#"fn foo() -> Result<i32, ${0:_}> { | 424 | } |
| 408 | let test = "test"; | 425 | "#, |
| 409 | Ok(42i32) | 426 | r#" |
| 410 | }"#, | 427 | fn foo() -> Result<i32, ${0:_}> { |
| 428 | let test = "test"; | ||
| 429 | Ok(42i32) | ||
| 430 | } | ||
| 431 | "#, | ||
| 411 | ); | 432 | ); |
| 412 | } | 433 | } |
| 413 | 434 | ||
| @@ -415,18 +436,22 @@ mod tests { | |||
| 415 | fn wrap_return_type_in_result_simple_with_tail_closure() { | 436 | fn wrap_return_type_in_result_simple_with_tail_closure() { |
| 416 | check_assist( | 437 | check_assist( |
| 417 | wrap_return_type_in_result, | 438 | wrap_return_type_in_result, |
| 418 | r#"fn foo() { | 439 | r#" |
| 419 | || -><|> i32 { | 440 | fn foo() { |
| 420 | let test = "test"; | 441 | || -><|> i32 { |
| 421 | 42i32 | 442 | let test = "test"; |
| 422 | }; | 443 | 42i32 |
| 423 | }"#, | 444 | }; |
| 424 | r#"fn foo() { | 445 | } |
| 425 | || -> Result<i32, ${0:_}> { | 446 | "#, |
| 426 | let test = "test"; | 447 | r#" |
| 427 | Ok(42i32) | 448 | fn foo() { |
| 428 | }; | 449 | || -> Result<i32, ${0:_}> { |
| 429 | }"#, | 450 | let test = "test"; |
| 451 | Ok(42i32) | ||
| 452 | }; | ||
| 453 | } | ||
| 454 | "#, | ||
| 430 | ); | 455 | ); |
| 431 | } | 456 | } |
| 432 | 457 | ||
| @@ -434,12 +459,8 @@ mod tests { | |||
| 434 | fn wrap_return_type_in_result_simple_with_tail_only() { | 459 | fn wrap_return_type_in_result_simple_with_tail_only() { |
| 435 | check_assist( | 460 | check_assist( |
| 436 | wrap_return_type_in_result, | 461 | wrap_return_type_in_result, |
| 437 | r#"fn foo() -> i32<|> { | 462 | r#"fn foo() -> i32<|> { 42i32 }"#, |
| 438 | 42i32 | 463 | r#"fn foo() -> Result<i32, ${0:_}> { Ok(42i32) }"#, |
| 439 | }"#, | ||
| 440 | r#"fn foo() -> Result<i32, ${0:_}> { | ||
| 441 | Ok(42i32) | ||
| 442 | }"#, | ||
| 443 | ); | 464 | ); |
| 444 | } | 465 | } |
| 445 | 466 | ||
| @@ -447,20 +468,24 @@ mod tests { | |||
| 447 | fn wrap_return_type_in_result_simple_with_tail_block_like() { | 468 | fn wrap_return_type_in_result_simple_with_tail_block_like() { |
| 448 | check_assist( | 469 | check_assist( |
| 449 | wrap_return_type_in_result, | 470 | wrap_return_type_in_result, |
| 450 | r#"fn foo() -> i32<|> { | 471 | r#" |
| 451 | if true { | 472 | fn foo() -> i32<|> { |
| 452 | 42i32 | 473 | if true { |
| 453 | } else { | 474 | 42i32 |
| 454 | 24i32 | 475 | } else { |
| 455 | } | 476 | 24i32 |
| 456 | }"#, | 477 | } |
| 457 | r#"fn foo() -> Result<i32, ${0:_}> { | 478 | } |
| 458 | if true { | 479 | "#, |
| 459 | Ok(42i32) | 480 | r#" |
| 460 | } else { | 481 | fn foo() -> Result<i32, ${0:_}> { |
| 461 | Ok(24i32) | 482 | if true { |
| 462 | } | 483 | Ok(42i32) |
| 463 | }"#, | 484 | } else { |
| 485 | Ok(24i32) | ||
| 486 | } | ||
| 487 | } | ||
| 488 | "#, | ||
| 464 | ); | 489 | ); |
| 465 | } | 490 | } |
| 466 | 491 | ||
| @@ -468,24 +493,28 @@ mod tests { | |||
| 468 | fn wrap_return_type_in_result_simple_without_block_closure() { | 493 | fn wrap_return_type_in_result_simple_without_block_closure() { |
| 469 | check_assist( | 494 | check_assist( |
| 470 | wrap_return_type_in_result, | 495 | wrap_return_type_in_result, |
| 471 | r#"fn foo() { | 496 | r#" |
| 472 | || -> i32<|> { | 497 | fn foo() { |
| 473 | if true { | 498 | || -> i32<|> { |
| 474 | 42i32 | 499 | if true { |
| 475 | } else { | 500 | 42i32 |
| 476 | 24i32 | 501 | } else { |
| 477 | } | 502 | 24i32 |
| 478 | }; | 503 | } |
| 479 | }"#, | 504 | }; |
| 480 | r#"fn foo() { | 505 | } |
| 481 | || -> Result<i32, ${0:_}> { | 506 | "#, |
| 482 | if true { | 507 | r#" |
| 483 | Ok(42i32) | 508 | fn foo() { |
| 484 | } else { | 509 | || -> Result<i32, ${0:_}> { |
| 485 | Ok(24i32) | 510 | if true { |
| 486 | } | 511 | Ok(42i32) |
| 487 | }; | 512 | } else { |
| 488 | }"#, | 513 | Ok(24i32) |
| 514 | } | ||
| 515 | }; | ||
| 516 | } | ||
| 517 | "#, | ||
| 489 | ); | 518 | ); |
| 490 | } | 519 | } |
| 491 | 520 | ||
| @@ -493,28 +522,32 @@ mod tests { | |||
| 493 | fn wrap_return_type_in_result_simple_with_nested_if() { | 522 | fn wrap_return_type_in_result_simple_with_nested_if() { |
| 494 | check_assist( | 523 | check_assist( |
| 495 | wrap_return_type_in_result, | 524 | wrap_return_type_in_result, |
| 496 | r#"fn foo() -> i32<|> { | 525 | r#" |
| 497 | if true { | 526 | fn foo() -> i32<|> { |
| 498 | if false { | 527 | if true { |
| 499 | 1 | 528 | if false { |
| 500 | } else { | 529 | 1 |
| 501 | 2 | 530 | } else { |
| 502 | } | 531 | 2 |
| 503 | } else { | 532 | } |
| 504 | 24i32 | 533 | } else { |
| 505 | } | 534 | 24i32 |
| 506 | }"#, | 535 | } |
| 507 | r#"fn foo() -> Result<i32, ${0:_}> { | 536 | } |
| 508 | if true { | 537 | "#, |
| 509 | if false { | 538 | r#" |
| 510 | Ok(1) | 539 | fn foo() -> Result<i32, ${0:_}> { |
| 511 | } else { | 540 | if true { |
| 512 | Ok(2) | 541 | if false { |
| 513 | } | 542 | Ok(1) |
| 514 | } else { | 543 | } else { |
| 515 | Ok(24i32) | 544 | Ok(2) |
| 516 | } | 545 | } |
| 517 | }"#, | 546 | } else { |
| 547 | Ok(24i32) | ||
| 548 | } | ||
| 549 | } | ||
| 550 | "#, | ||
| 518 | ); | 551 | ); |
| 519 | } | 552 | } |
| 520 | 553 | ||
| @@ -522,28 +555,32 @@ mod tests { | |||
| 522 | fn wrap_return_type_in_result_simple_with_await() { | 555 | fn wrap_return_type_in_result_simple_with_await() { |
| 523 | check_assist( | 556 | check_assist( |
| 524 | wrap_return_type_in_result, | 557 | wrap_return_type_in_result, |
| 525 | r#"async fn foo() -> i<|>32 { | 558 | r#" |
| 526 | if true { | 559 | async fn foo() -> i<|>32 { |
| 527 | if false { | 560 | if true { |
| 528 | 1.await | 561 | if false { |
| 529 | } else { | 562 | 1.await |
| 530 | 2.await | 563 | } else { |
| 531 | } | 564 | 2.await |
| 532 | } else { | 565 | } |
| 533 | 24i32.await | 566 | } else { |
| 534 | } | 567 | 24i32.await |
| 535 | }"#, | 568 | } |
| 536 | r#"async fn foo() -> Result<i32, ${0:_}> { | 569 | } |
| 537 | if true { | 570 | "#, |
| 538 | if false { | 571 | r#" |
| 539 | Ok(1.await) | 572 | async fn foo() -> Result<i32, ${0:_}> { |
| 540 | } else { | 573 | if true { |
| 541 | Ok(2.await) | 574 | if false { |
| 542 | } | 575 | Ok(1.await) |
| 543 | } else { | 576 | } else { |
| 544 | Ok(24i32.await) | 577 | Ok(2.await) |
| 545 | } | 578 | } |
| 546 | }"#, | 579 | } else { |
| 580 | Ok(24i32.await) | ||
| 581 | } | ||
| 582 | } | ||
| 583 | "#, | ||
| 547 | ); | 584 | ); |
| 548 | } | 585 | } |
| 549 | 586 | ||
| @@ -551,12 +588,8 @@ mod tests { | |||
| 551 | fn wrap_return_type_in_result_simple_with_array() { | 588 | fn wrap_return_type_in_result_simple_with_array() { |
| 552 | check_assist( | 589 | check_assist( |
| 553 | wrap_return_type_in_result, | 590 | wrap_return_type_in_result, |
| 554 | r#"fn foo() -> [i32;<|> 3] { | 591 | r#"fn foo() -> [i32;<|> 3] { [1, 2, 3] }"#, |
| 555 | [1, 2, 3] | 592 | r#"fn foo() -> Result<[i32; 3], ${0:_}> { Ok([1, 2, 3]) }"#, |
| 556 | }"#, | ||
| 557 | r#"fn foo() -> Result<[i32; 3], ${0:_}> { | ||
| 558 | Ok([1, 2, 3]) | ||
| 559 | }"#, | ||
| 560 | ); | 593 | ); |
| 561 | } | 594 | } |
| 562 | 595 | ||
| @@ -564,28 +597,32 @@ mod tests { | |||
| 564 | fn wrap_return_type_in_result_simple_with_cast() { | 597 | fn wrap_return_type_in_result_simple_with_cast() { |
| 565 | check_assist( | 598 | check_assist( |
| 566 | wrap_return_type_in_result, | 599 | wrap_return_type_in_result, |
| 567 | r#"fn foo() -<|>> i32 { | 600 | r#" |
| 568 | if true { | 601 | fn foo() -<|>> i32 { |
| 569 | if false { | 602 | if true { |
| 570 | 1 as i32 | 603 | if false { |
| 571 | } else { | 604 | 1 as i32 |
| 572 | 2 as i32 | 605 | } else { |
| 573 | } | 606 | 2 as i32 |
| 574 | } else { | 607 | } |
| 575 | 24 as i32 | 608 | } else { |
| 576 | } | 609 | 24 as i32 |
| 577 | }"#, | 610 | } |
| 578 | r#"fn foo() -> Result<i32, ${0:_}> { | 611 | } |
| 579 | if true { | 612 | "#, |
| 580 | if false { | 613 | r#" |
| 581 | Ok(1 as i32) | 614 | fn foo() -> Result<i32, ${0:_}> { |
| 582 | } else { | 615 | if true { |
| 583 | Ok(2 as i32) | 616 | if false { |
| 584 | } | 617 | Ok(1 as i32) |
| 585 | } else { | 618 | } else { |
| 586 | Ok(24 as i32) | 619 | Ok(2 as i32) |
| 587 | } | 620 | } |
| 588 | }"#, | 621 | } else { |
| 622 | Ok(24 as i32) | ||
| 623 | } | ||
| 624 | } | ||
| 625 | "#, | ||
| 589 | ); | 626 | ); |
| 590 | } | 627 | } |
| 591 | 628 | ||
| @@ -593,20 +630,24 @@ mod tests { | |||
| 593 | fn wrap_return_type_in_result_simple_with_tail_block_like_match() { | 630 | fn wrap_return_type_in_result_simple_with_tail_block_like_match() { |
| 594 | check_assist( | 631 | check_assist( |
| 595 | wrap_return_type_in_result, | 632 | wrap_return_type_in_result, |
| 596 | r#"fn foo() -> i32<|> { | 633 | r#" |
| 597 | let my_var = 5; | 634 | fn foo() -> i32<|> { |
| 598 | match my_var { | 635 | let my_var = 5; |
| 599 | 5 => 42i32, | 636 | match my_var { |
| 600 | _ => 24i32, | 637 | 5 => 42i32, |
| 601 | } | 638 | _ => 24i32, |
| 602 | }"#, | 639 | } |
| 603 | r#"fn foo() -> Result<i32, ${0:_}> { | 640 | } |
| 604 | let my_var = 5; | 641 | "#, |
| 605 | match my_var { | 642 | r#" |
| 606 | 5 => Ok(42i32), | 643 | fn foo() -> Result<i32, ${0:_}> { |
| 607 | _ => Ok(24i32), | 644 | let my_var = 5; |
| 608 | } | 645 | match my_var { |
| 609 | }"#, | 646 | 5 => Ok(42i32), |
| 647 | _ => Ok(24i32), | ||
| 648 | } | ||
| 649 | } | ||
| 650 | "#, | ||
| 610 | ); | 651 | ); |
| 611 | } | 652 | } |
| 612 | 653 | ||
| @@ -614,24 +655,26 @@ mod tests { | |||
| 614 | fn wrap_return_type_in_result_simple_with_loop_with_tail() { | 655 | fn wrap_return_type_in_result_simple_with_loop_with_tail() { |
| 615 | check_assist( | 656 | check_assist( |
| 616 | wrap_return_type_in_result, | 657 | wrap_return_type_in_result, |
| 617 | r#"fn foo() -> i32<|> { | 658 | r#" |
| 618 | let my_var = 5; | 659 | fn foo() -> i32<|> { |
| 619 | loop { | 660 | let my_var = 5; |
| 620 | println!("test"); | 661 | loop { |
| 621 | 5 | 662 | println!("test"); |
| 622 | } | 663 | 5 |
| 623 | 664 | } | |
| 624 | my_var | 665 | my_var |
| 625 | }"#, | 666 | } |
| 626 | r#"fn foo() -> Result<i32, ${0:_}> { | 667 | "#, |
| 627 | let my_var = 5; | 668 | r#" |
| 628 | loop { | 669 | fn foo() -> Result<i32, ${0:_}> { |
| 629 | println!("test"); | 670 | let my_var = 5; |
| 630 | 5 | 671 | loop { |
| 631 | } | 672 | println!("test"); |
| 632 | 673 | 5 | |
| 633 | Ok(my_var) | 674 | } |
| 634 | }"#, | 675 | Ok(my_var) |
| 676 | } | ||
| 677 | "#, | ||
| 635 | ); | 678 | ); |
| 636 | } | 679 | } |
| 637 | 680 | ||
| @@ -639,20 +682,22 @@ mod tests { | |||
| 639 | fn wrap_return_type_in_result_simple_with_loop_in_let_stmt() { | 682 | fn wrap_return_type_in_result_simple_with_loop_in_let_stmt() { |
| 640 | check_assist( | 683 | check_assist( |
| 641 | wrap_return_type_in_result, | 684 | wrap_return_type_in_result, |
| 642 | r#"fn foo() -> i32<|> { | 685 | r#" |
| 643 | let my_var = let x = loop { | 686 | fn foo() -> i32<|> { |
| 644 | break 1; | 687 | let my_var = let x = loop { |
| 645 | }; | 688 | break 1; |
| 646 | 689 | }; | |
| 647 | my_var | 690 | my_var |
| 648 | }"#, | 691 | } |
| 649 | r#"fn foo() -> Result<i32, ${0:_}> { | 692 | "#, |
| 650 | let my_var = let x = loop { | 693 | r#" |
| 651 | break 1; | 694 | fn foo() -> Result<i32, ${0:_}> { |
| 652 | }; | 695 | let my_var = let x = loop { |
| 653 | 696 | break 1; | |
| 654 | Ok(my_var) | 697 | }; |
| 655 | }"#, | 698 | Ok(my_var) |
| 699 | } | ||
| 700 | "#, | ||
| 656 | ); | 701 | ); |
| 657 | } | 702 | } |
| 658 | 703 | ||
| @@ -660,48 +705,52 @@ mod tests { | |||
| 660 | fn wrap_return_type_in_result_simple_with_tail_block_like_match_return_expr() { | 705 | fn wrap_return_type_in_result_simple_with_tail_block_like_match_return_expr() { |
| 661 | check_assist( | 706 | check_assist( |
| 662 | wrap_return_type_in_result, | 707 | wrap_return_type_in_result, |
| 663 | r#"fn foo() -> i32<|> { | 708 | r#" |
| 664 | let my_var = 5; | 709 | fn foo() -> i32<|> { |
| 665 | let res = match my_var { | 710 | let my_var = 5; |
| 666 | 5 => 42i32, | 711 | let res = match my_var { |
| 667 | _ => return 24i32, | 712 | 5 => 42i32, |
| 668 | }; | 713 | _ => return 24i32, |
| 669 | 714 | }; | |
| 670 | res | 715 | res |
| 671 | }"#, | 716 | } |
| 672 | r#"fn foo() -> Result<i32, ${0:_}> { | 717 | "#, |
| 673 | let my_var = 5; | 718 | r#" |
| 674 | let res = match my_var { | 719 | fn foo() -> Result<i32, ${0:_}> { |
| 675 | 5 => 42i32, | 720 | let my_var = 5; |
| 676 | _ => return Ok(24i32), | 721 | let res = match my_var { |
| 677 | }; | 722 | 5 => 42i32, |
| 678 | 723 | _ => return Ok(24i32), | |
| 679 | Ok(res) | 724 | }; |
| 680 | }"#, | 725 | Ok(res) |
| 726 | } | ||
| 727 | "#, | ||
| 681 | ); | 728 | ); |
| 682 | 729 | ||
| 683 | check_assist( | 730 | check_assist( |
| 684 | wrap_return_type_in_result, | 731 | wrap_return_type_in_result, |
| 685 | r#"fn foo() -> i32<|> { | 732 | r#" |
| 686 | let my_var = 5; | 733 | fn foo() -> i32<|> { |
| 687 | let res = if my_var == 5 { | 734 | let my_var = 5; |
| 688 | 42i32 | 735 | let res = if my_var == 5 { |
| 689 | } else { | 736 | 42i32 |
| 690 | return 24i32; | 737 | } else { |
| 691 | }; | 738 | return 24i32; |
| 692 | 739 | }; | |
| 693 | res | 740 | res |
| 694 | }"#, | 741 | } |
| 695 | r#"fn foo() -> Result<i32, ${0:_}> { | 742 | "#, |
| 696 | let my_var = 5; | 743 | r#" |
| 697 | let res = if my_var == 5 { | 744 | fn foo() -> Result<i32, ${0:_}> { |
| 698 | 42i32 | 745 | let my_var = 5; |
| 699 | } else { | 746 | let res = if my_var == 5 { |
| 700 | return Ok(24i32); | 747 | 42i32 |
| 701 | }; | 748 | } else { |
| 702 | 749 | return Ok(24i32); | |
| 703 | Ok(res) | 750 | }; |
| 704 | }"#, | 751 | Ok(res) |
| 752 | } | ||
| 753 | "#, | ||
| 705 | ); | 754 | ); |
| 706 | } | 755 | } |
| 707 | 756 | ||
| @@ -709,44 +758,48 @@ mod tests { | |||
| 709 | fn wrap_return_type_in_result_simple_with_tail_block_like_match_deeper() { | 758 | fn wrap_return_type_in_result_simple_with_tail_block_like_match_deeper() { |
| 710 | check_assist( | 759 | check_assist( |
| 711 | wrap_return_type_in_result, | 760 | wrap_return_type_in_result, |
| 712 | r#"fn foo() -> i32<|> { | 761 | r#" |
| 713 | let my_var = 5; | 762 | fn foo() -> i32<|> { |
| 714 | match my_var { | 763 | let my_var = 5; |
| 715 | 5 => { | 764 | match my_var { |
| 716 | if true { | 765 | 5 => { |
| 717 | 42i32 | 766 | if true { |
| 718 | } else { | 767 | 42i32 |
| 719 | 25i32 | 768 | } else { |
| 720 | } | 769 | 25i32 |
| 721 | }, | 770 | } |
| 722 | _ => { | 771 | }, |
| 723 | let test = "test"; | 772 | _ => { |
| 724 | if test == "test" { | 773 | let test = "test"; |
| 725 | return bar(); | 774 | if test == "test" { |
| 726 | } | 775 | return bar(); |
| 727 | 53i32 | 776 | } |
| 728 | }, | 777 | 53i32 |
| 729 | } | 778 | }, |
| 730 | }"#, | 779 | } |
| 731 | r#"fn foo() -> Result<i32, ${0:_}> { | 780 | } |
| 732 | let my_var = 5; | 781 | "#, |
| 733 | match my_var { | 782 | r#" |
| 734 | 5 => { | 783 | fn foo() -> Result<i32, ${0:_}> { |
| 735 | if true { | 784 | let my_var = 5; |
| 736 | Ok(42i32) | 785 | match my_var { |
| 737 | } else { | 786 | 5 => { |
| 738 | Ok(25i32) | 787 | if true { |
| 739 | } | 788 | Ok(42i32) |
| 740 | }, | 789 | } else { |
| 741 | _ => { | 790 | Ok(25i32) |
| 742 | let test = "test"; | 791 | } |
| 743 | if test == "test" { | 792 | }, |
| 744 | return Ok(bar()); | 793 | _ => { |
| 745 | } | 794 | let test = "test"; |
| 746 | Ok(53i32) | 795 | if test == "test" { |
| 747 | }, | 796 | return Ok(bar()); |
| 748 | } | 797 | } |
| 749 | }"#, | 798 | Ok(53i32) |
| 799 | }, | ||
| 800 | } | ||
| 801 | } | ||
| 802 | "#, | ||
| 750 | ); | 803 | ); |
| 751 | } | 804 | } |
| 752 | 805 | ||
| @@ -754,20 +807,24 @@ mod tests { | |||
| 754 | fn wrap_return_type_in_result_simple_with_tail_block_like_early_return() { | 807 | fn wrap_return_type_in_result_simple_with_tail_block_like_early_return() { |
| 755 | check_assist( | 808 | check_assist( |
| 756 | wrap_return_type_in_result, | 809 | wrap_return_type_in_result, |
| 757 | r#"fn foo() -> i<|>32 { | 810 | r#" |
| 758 | let test = "test"; | 811 | fn foo() -> i<|>32 { |
| 759 | if test == "test" { | 812 | let test = "test"; |
| 760 | return 24i32; | 813 | if test == "test" { |
| 761 | } | 814 | return 24i32; |
| 762 | 53i32 | 815 | } |
| 763 | }"#, | 816 | 53i32 |
| 764 | r#"fn foo() -> Result<i32, ${0:_}> { | 817 | } |
| 765 | let test = "test"; | 818 | "#, |
| 766 | if test == "test" { | 819 | r#" |
| 767 | return Ok(24i32); | 820 | fn foo() -> Result<i32, ${0:_}> { |
| 768 | } | 821 | let test = "test"; |
| 769 | Ok(53i32) | 822 | if test == "test" { |
| 770 | }"#, | 823 | return Ok(24i32); |
| 824 | } | ||
| 825 | Ok(53i32) | ||
| 826 | } | ||
| 827 | "#, | ||
| 771 | ); | 828 | ); |
| 772 | } | 829 | } |
| 773 | 830 | ||
| @@ -775,45 +832,40 @@ mod tests { | |||
| 775 | fn wrap_return_type_in_result_simple_with_closure() { | 832 | fn wrap_return_type_in_result_simple_with_closure() { |
| 776 | check_assist( | 833 | check_assist( |
| 777 | wrap_return_type_in_result, | 834 | wrap_return_type_in_result, |
| 778 | r#"fn foo(the_field: u32) -><|> u32 { | 835 | r#" |
| 779 | let true_closure = || { | 836 | fn foo(the_field: u32) -><|> u32 { |
| 780 | return true; | 837 | let true_closure = || { return true; }; |
| 781 | }; | 838 | if the_field < 5 { |
| 782 | if the_field < 5 { | 839 | let mut i = 0; |
| 783 | let mut i = 0; | 840 | if true_closure() { |
| 784 | 841 | return 99; | |
| 785 | 842 | } else { | |
| 786 | if true_closure() { | 843 | return 0; |
| 787 | return 99; | 844 | } |
| 788 | } else { | 845 | } |
| 789 | return 0; | 846 | the_field |
| 790 | } | 847 | } |
| 791 | } | 848 | "#, |
| 792 | 849 | r#" | |
| 793 | the_field | 850 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { |
| 794 | }"#, | 851 | let true_closure = || { return true; }; |
| 795 | r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> { | 852 | if the_field < 5 { |
| 796 | let true_closure = || { | 853 | let mut i = 0; |
| 797 | return true; | 854 | if true_closure() { |
| 798 | }; | 855 | return Ok(99); |
| 799 | if the_field < 5 { | 856 | } else { |
| 800 | let mut i = 0; | 857 | return Ok(0); |
| 801 | 858 | } | |
| 802 | 859 | } | |
| 803 | if true_closure() { | 860 | Ok(the_field) |
| 804 | return Ok(99); | 861 | } |
| 805 | } else { | 862 | "#, |
| 806 | return Ok(0); | ||
| 807 | } | ||
| 808 | } | ||
| 809 | |||
| 810 | Ok(the_field) | ||
| 811 | }"#, | ||
| 812 | ); | 863 | ); |
| 813 | 864 | ||
| 814 | check_assist( | 865 | check_assist( |
| 815 | wrap_return_type_in_result, | 866 | wrap_return_type_in_result, |
| 816 | r#"fn foo(the_field: u32) -> u32<|> { | 867 | r#" |
| 868 | fn foo(the_field: u32) -> u32<|> { | ||
| 817 | let true_closure = || { | 869 | let true_closure = || { |
| 818 | return true; | 870 | return true; |
| 819 | }; | 871 | }; |
| @@ -830,8 +882,10 @@ mod tests { | |||
| 830 | let t = None; | 882 | let t = None; |
| 831 | 883 | ||
| 832 | t.unwrap_or_else(|| the_field) | 884 | t.unwrap_or_else(|| the_field) |
| 833 | }"#, | 885 | } |
| 834 | r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> { | 886 | "#, |
| 887 | r#" | ||
| 888 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { | ||
| 835 | let true_closure = || { | 889 | let true_closure = || { |
| 836 | return true; | 890 | return true; |
| 837 | }; | 891 | }; |
| @@ -848,7 +902,8 @@ mod tests { | |||
| 848 | let t = None; | 902 | let t = None; |
| 849 | 903 | ||
| 850 | Ok(t.unwrap_or_else(|| the_field)) | 904 | Ok(t.unwrap_or_else(|| the_field)) |
| 851 | }"#, | 905 | } |
| 906 | "#, | ||
| 852 | ); | 907 | ); |
| 853 | } | 908 | } |
| 854 | 909 | ||
| @@ -856,236 +911,248 @@ mod tests { | |||
| 856 | fn wrap_return_type_in_result_simple_with_weird_forms() { | 911 | fn wrap_return_type_in_result_simple_with_weird_forms() { |
| 857 | check_assist( | 912 | check_assist( |
| 858 | wrap_return_type_in_result, | 913 | wrap_return_type_in_result, |
| 859 | r#"fn foo() -> i32<|> { | 914 | r#" |
| 860 | let test = "test"; | 915 | fn foo() -> i32<|> { |
| 861 | if test == "test" { | 916 | let test = "test"; |
| 862 | return 24i32; | 917 | if test == "test" { |
| 863 | } | 918 | return 24i32; |
| 864 | let mut i = 0; | 919 | } |
| 865 | loop { | 920 | let mut i = 0; |
| 866 | if i == 1 { | 921 | loop { |
| 867 | break 55; | 922 | if i == 1 { |
| 868 | } | 923 | break 55; |
| 869 | i += 1; | 924 | } |
| 870 | } | 925 | i += 1; |
| 871 | }"#, | 926 | } |
| 872 | r#"fn foo() -> Result<i32, ${0:_}> { | 927 | } |
| 873 | let test = "test"; | 928 | "#, |
| 874 | if test == "test" { | 929 | r#" |
| 875 | return Ok(24i32); | 930 | fn foo() -> Result<i32, ${0:_}> { |
| 876 | } | 931 | let test = "test"; |
| 877 | let mut i = 0; | 932 | if test == "test" { |
| 878 | loop { | 933 | return Ok(24i32); |
| 879 | if i == 1 { | 934 | } |
| 880 | break Ok(55); | 935 | let mut i = 0; |
| 881 | } | 936 | loop { |
| 882 | i += 1; | 937 | if i == 1 { |
| 883 | } | 938 | break Ok(55); |
| 884 | }"#, | 939 | } |
| 940 | i += 1; | ||
| 941 | } | ||
| 942 | } | ||
| 943 | "#, | ||
| 885 | ); | 944 | ); |
| 886 | 945 | ||
| 887 | check_assist( | 946 | check_assist( |
| 888 | wrap_return_type_in_result, | 947 | wrap_return_type_in_result, |
| 889 | r#"fn foo() -> i32<|> { | 948 | r#" |
| 890 | let test = "test"; | 949 | fn foo() -> i32<|> { |
| 891 | if test == "test" { | 950 | let test = "test"; |
| 892 | return 24i32; | 951 | if test == "test" { |
| 893 | } | 952 | return 24i32; |
| 894 | let mut i = 0; | 953 | } |
| 895 | loop { | 954 | let mut i = 0; |
| 896 | loop { | 955 | loop { |
| 897 | if i == 1 { | 956 | loop { |
| 898 | break 55; | 957 | if i == 1 { |
| 899 | } | 958 | break 55; |
| 900 | i += 1; | 959 | } |
| 901 | } | 960 | i += 1; |
| 902 | } | 961 | } |
| 903 | }"#, | 962 | } |
| 904 | r#"fn foo() -> Result<i32, ${0:_}> { | 963 | } |
| 905 | let test = "test"; | 964 | "#, |
| 906 | if test == "test" { | 965 | r#" |
| 907 | return Ok(24i32); | 966 | fn foo() -> Result<i32, ${0:_}> { |
| 908 | } | 967 | let test = "test"; |
| 909 | let mut i = 0; | 968 | if test == "test" { |
| 910 | loop { | 969 | return Ok(24i32); |
| 911 | loop { | 970 | } |
| 912 | if i == 1 { | 971 | let mut i = 0; |
| 913 | break Ok(55); | 972 | loop { |
| 914 | } | 973 | loop { |
| 915 | i += 1; | 974 | if i == 1 { |
| 916 | } | 975 | break Ok(55); |
| 917 | } | 976 | } |
| 918 | }"#, | 977 | i += 1; |
| 978 | } | ||
| 979 | } | ||
| 980 | } | ||
| 981 | "#, | ||
| 919 | ); | 982 | ); |
| 920 | 983 | ||
| 921 | check_assist( | 984 | check_assist( |
| 922 | wrap_return_type_in_result, | 985 | wrap_return_type_in_result, |
| 923 | r#"fn foo() -> i3<|>2 { | 986 | r#" |
| 924 | let test = "test"; | 987 | fn foo() -> i3<|>2 { |
| 925 | let other = 5; | 988 | let test = "test"; |
| 926 | if test == "test" { | 989 | let other = 5; |
| 927 | let res = match other { | 990 | if test == "test" { |
| 928 | 5 => 43, | 991 | let res = match other { |
| 929 | _ => return 56, | 992 | 5 => 43, |
| 930 | }; | 993 | _ => return 56, |
| 931 | } | 994 | }; |
| 932 | let mut i = 0; | 995 | } |
| 933 | loop { | 996 | let mut i = 0; |
| 934 | loop { | 997 | loop { |
| 935 | if i == 1 { | 998 | loop { |
| 936 | break 55; | 999 | if i == 1 { |
| 937 | } | 1000 | break 55; |
| 938 | i += 1; | 1001 | } |
| 939 | } | 1002 | i += 1; |
| 940 | } | 1003 | } |
| 941 | }"#, | 1004 | } |
| 942 | r#"fn foo() -> Result<i32, ${0:_}> { | 1005 | } |
| 943 | let test = "test"; | 1006 | "#, |
| 944 | let other = 5; | 1007 | r#" |
| 945 | if test == "test" { | 1008 | fn foo() -> Result<i32, ${0:_}> { |
| 946 | let res = match other { | 1009 | let test = "test"; |
| 947 | 5 => 43, | 1010 | let other = 5; |
| 948 | _ => return Ok(56), | 1011 | if test == "test" { |
| 949 | }; | 1012 | let res = match other { |
| 950 | } | 1013 | 5 => 43, |
| 951 | let mut i = 0; | 1014 | _ => return Ok(56), |
| 952 | loop { | 1015 | }; |
| 953 | loop { | 1016 | } |
| 954 | if i == 1 { | 1017 | let mut i = 0; |
| 955 | break Ok(55); | 1018 | loop { |
| 956 | } | 1019 | loop { |
| 957 | i += 1; | 1020 | if i == 1 { |
| 958 | } | 1021 | break Ok(55); |
| 959 | } | 1022 | } |
| 960 | }"#, | 1023 | i += 1; |
| 1024 | } | ||
| 1025 | } | ||
| 1026 | } | ||
| 1027 | "#, | ||
| 961 | ); | 1028 | ); |
| 962 | 1029 | ||
| 963 | check_assist( | 1030 | check_assist( |
| 964 | wrap_return_type_in_result, | 1031 | wrap_return_type_in_result, |
| 965 | r#"fn foo(the_field: u32) -> u32<|> { | 1032 | r#" |
| 966 | if the_field < 5 { | 1033 | fn foo(the_field: u32) -> u32<|> { |
| 967 | let mut i = 0; | 1034 | if the_field < 5 { |
| 968 | loop { | 1035 | let mut i = 0; |
| 969 | if i > 5 { | 1036 | loop { |
| 970 | return 55u32; | 1037 | if i > 5 { |
| 971 | } | 1038 | return 55u32; |
| 972 | i += 3; | 1039 | } |
| 973 | } | 1040 | i += 3; |
| 974 | 1041 | } | |
| 975 | match i { | 1042 | match i { |
| 976 | 5 => return 99, | 1043 | 5 => return 99, |
| 977 | _ => return 0, | 1044 | _ => return 0, |
| 978 | }; | 1045 | }; |
| 979 | } | 1046 | } |
| 980 | 1047 | the_field | |
| 981 | the_field | 1048 | } |
| 982 | }"#, | 1049 | "#, |
| 983 | r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> { | 1050 | r#" |
| 984 | if the_field < 5 { | 1051 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { |
| 985 | let mut i = 0; | 1052 | if the_field < 5 { |
| 986 | loop { | 1053 | let mut i = 0; |
| 987 | if i > 5 { | 1054 | loop { |
| 988 | return Ok(55u32); | 1055 | if i > 5 { |
| 989 | } | 1056 | return Ok(55u32); |
| 990 | i += 3; | 1057 | } |
| 991 | } | 1058 | i += 3; |
| 992 | 1059 | } | |
| 993 | match i { | 1060 | match i { |
| 994 | 5 => return Ok(99), | 1061 | 5 => return Ok(99), |
| 995 | _ => return Ok(0), | 1062 | _ => return Ok(0), |
| 996 | }; | 1063 | }; |
| 997 | } | 1064 | } |
| 998 | 1065 | Ok(the_field) | |
| 999 | Ok(the_field) | 1066 | } |
| 1000 | }"#, | 1067 | "#, |
| 1001 | ); | 1068 | ); |
| 1002 | 1069 | ||
| 1003 | check_assist( | 1070 | check_assist( |
| 1004 | wrap_return_type_in_result, | 1071 | wrap_return_type_in_result, |
| 1005 | r#"fn foo(the_field: u32) -> u3<|>2 { | 1072 | r#" |
| 1006 | if the_field < 5 { | 1073 | fn foo(the_field: u32) -> u3<|>2 { |
| 1007 | let mut i = 0; | 1074 | if the_field < 5 { |
| 1008 | 1075 | let mut i = 0; | |
| 1009 | match i { | 1076 | match i { |
| 1010 | 5 => return 99, | 1077 | 5 => return 99, |
| 1011 | _ => return 0, | 1078 | _ => return 0, |
| 1012 | } | 1079 | } |
| 1013 | } | 1080 | } |
| 1014 | 1081 | the_field | |
| 1015 | the_field | 1082 | } |
| 1016 | }"#, | 1083 | "#, |
| 1017 | r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> { | 1084 | r#" |
| 1018 | if the_field < 5 { | 1085 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { |
| 1019 | let mut i = 0; | 1086 | if the_field < 5 { |
| 1020 | 1087 | let mut i = 0; | |
| 1021 | match i { | 1088 | match i { |
| 1022 | 5 => return Ok(99), | 1089 | 5 => return Ok(99), |
| 1023 | _ => return Ok(0), | 1090 | _ => return Ok(0), |
| 1024 | } | 1091 | } |
| 1025 | } | 1092 | } |
| 1026 | 1093 | Ok(the_field) | |
| 1027 | Ok(the_field) | 1094 | } |
| 1028 | }"#, | 1095 | "#, |
| 1029 | ); | 1096 | ); |
| 1030 | 1097 | ||
| 1031 | check_assist( | 1098 | check_assist( |
| 1032 | wrap_return_type_in_result, | 1099 | wrap_return_type_in_result, |
| 1033 | r#"fn foo(the_field: u32) -> u32<|> { | 1100 | r#" |
| 1034 | if the_field < 5 { | 1101 | fn foo(the_field: u32) -> u32<|> { |
| 1035 | let mut i = 0; | 1102 | if the_field < 5 { |
| 1036 | 1103 | let mut i = 0; | |
| 1037 | if i == 5 { | 1104 | if i == 5 { |
| 1038 | return 99 | 1105 | return 99 |
| 1039 | } else { | 1106 | } else { |
| 1040 | return 0 | 1107 | return 0 |
| 1041 | } | 1108 | } |
| 1042 | } | 1109 | } |
| 1043 | 1110 | the_field | |
| 1044 | the_field | 1111 | } |
| 1045 | }"#, | 1112 | "#, |
| 1046 | r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> { | 1113 | r#" |
| 1047 | if the_field < 5 { | 1114 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { |
| 1048 | let mut i = 0; | 1115 | if the_field < 5 { |
| 1049 | 1116 | let mut i = 0; | |
| 1050 | if i == 5 { | 1117 | if i == 5 { |
| 1051 | return Ok(99) | 1118 | return Ok(99) |
| 1052 | } else { | 1119 | } else { |
| 1053 | return Ok(0) | 1120 | return Ok(0) |
| 1054 | } | 1121 | } |
| 1055 | } | 1122 | } |
| 1056 | 1123 | Ok(the_field) | |
| 1057 | Ok(the_field) | 1124 | } |
| 1058 | }"#, | 1125 | "#, |
| 1059 | ); | 1126 | ); |
| 1060 | 1127 | ||
| 1061 | check_assist( | 1128 | check_assist( |
| 1062 | wrap_return_type_in_result, | 1129 | wrap_return_type_in_result, |
| 1063 | r#"fn foo(the_field: u32) -> <|>u32 { | 1130 | r#" |
| 1064 | if the_field < 5 { | 1131 | fn foo(the_field: u32) -> <|>u32 { |
| 1065 | let mut i = 0; | 1132 | if the_field < 5 { |
| 1066 | 1133 | let mut i = 0; | |
| 1067 | if i == 5 { | 1134 | if i == 5 { |
| 1068 | return 99; | 1135 | return 99; |
| 1069 | } else { | 1136 | } else { |
| 1070 | return 0; | 1137 | return 0; |
| 1071 | } | 1138 | } |
| 1072 | } | 1139 | } |
| 1073 | 1140 | the_field | |
| 1074 | the_field | 1141 | } |
| 1075 | }"#, | 1142 | "#, |
| 1076 | r#"fn foo(the_field: u32) -> Result<u32, ${0:_}> { | 1143 | r#" |
| 1077 | if the_field < 5 { | 1144 | fn foo(the_field: u32) -> Result<u32, ${0:_}> { |
| 1078 | let mut i = 0; | 1145 | if the_field < 5 { |
| 1079 | 1146 | let mut i = 0; | |
| 1080 | if i == 5 { | 1147 | if i == 5 { |
| 1081 | return Ok(99); | 1148 | return Ok(99); |
| 1082 | } else { | 1149 | } else { |
| 1083 | return Ok(0); | 1150 | return Ok(0); |
| 1084 | } | 1151 | } |
| 1085 | } | 1152 | } |
| 1086 | 1153 | Ok(the_field) | |
| 1087 | Ok(the_field) | 1154 | } |
| 1088 | }"#, | 1155 | "#, |
| 1089 | ); | 1156 | ); |
| 1090 | } | 1157 | } |
| 1091 | } | 1158 | } |