diff options
Diffstat (limited to 'crates/ide/src')
-rw-r--r-- | crates/ide/src/diagnostics.rs | 531 | ||||
-rw-r--r-- | crates/ide/src/diagnostics/fixes.rs | 245 | ||||
-rw-r--r-- | crates/ide/src/diagnostics/fixes/change_case.rs | 155 | ||||
-rw-r--r-- | crates/ide/src/diagnostics/fixes/create_field.rs | 157 | ||||
-rw-r--r-- | crates/ide/src/diagnostics/fixes/remove_semicolon.rs | 31 | ||||
-rw-r--r-- | crates/ide/src/diagnostics/fixes/replace_with_find_map.rs | 42 | ||||
-rw-r--r-- | crates/ide/src/diagnostics/fixes/unresolved_module.rs | 87 | ||||
-rw-r--r-- | crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs | 211 |
8 files changed, 693 insertions, 766 deletions
diff --git a/crates/ide/src/diagnostics.rs b/crates/ide/src/diagnostics.rs index d5fba6740..4172f6cae 100644 --- a/crates/ide/src/diagnostics.rs +++ b/crates/ide/src/diagnostics.rs | |||
@@ -375,7 +375,7 @@ mod tests { | |||
375 | assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics); | 375 | assert_eq!(diagnostics.len(), 0, "unexpected diagnostics:\n{:#?}", diagnostics); |
376 | } | 376 | } |
377 | 377 | ||
378 | fn check_expect(ra_fixture: &str, expect: Expect) { | 378 | pub(crate) fn check_expect(ra_fixture: &str, expect: Expect) { |
379 | let (analysis, file_id) = fixture::file(ra_fixture); | 379 | let (analysis, file_id) = fixture::file(ra_fixture); |
380 | let diagnostics = analysis | 380 | let diagnostics = analysis |
381 | .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id) | 381 | .diagnostics(&DiagnosticsConfig::default(), AssistResolveStrategy::All, file_id) |
@@ -384,374 +384,6 @@ mod tests { | |||
384 | } | 384 | } |
385 | 385 | ||
386 | #[test] | 386 | #[test] |
387 | fn test_wrap_return_type_option() { | ||
388 | check_fix( | ||
389 | r#" | ||
390 | //- /main.rs crate:main deps:core | ||
391 | use core::option::Option::{self, Some, None}; | ||
392 | |||
393 | fn div(x: i32, y: i32) -> Option<i32> { | ||
394 | if y == 0 { | ||
395 | return None; | ||
396 | } | ||
397 | x / y$0 | ||
398 | } | ||
399 | //- /core/lib.rs crate:core | ||
400 | pub mod result { | ||
401 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
402 | } | ||
403 | pub mod option { | ||
404 | pub enum Option<T> { Some(T), None } | ||
405 | } | ||
406 | "#, | ||
407 | r#" | ||
408 | use core::option::Option::{self, Some, None}; | ||
409 | |||
410 | fn div(x: i32, y: i32) -> Option<i32> { | ||
411 | if y == 0 { | ||
412 | return None; | ||
413 | } | ||
414 | Some(x / y) | ||
415 | } | ||
416 | "#, | ||
417 | ); | ||
418 | } | ||
419 | |||
420 | #[test] | ||
421 | fn test_wrap_return_type() { | ||
422 | check_fix( | ||
423 | r#" | ||
424 | //- /main.rs crate:main deps:core | ||
425 | use core::result::Result::{self, Ok, Err}; | ||
426 | |||
427 | fn div(x: i32, y: i32) -> Result<i32, ()> { | ||
428 | if y == 0 { | ||
429 | return Err(()); | ||
430 | } | ||
431 | x / y$0 | ||
432 | } | ||
433 | //- /core/lib.rs crate:core | ||
434 | pub mod result { | ||
435 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
436 | } | ||
437 | pub mod option { | ||
438 | pub enum Option<T> { Some(T), None } | ||
439 | } | ||
440 | "#, | ||
441 | r#" | ||
442 | use core::result::Result::{self, Ok, Err}; | ||
443 | |||
444 | fn div(x: i32, y: i32) -> Result<i32, ()> { | ||
445 | if y == 0 { | ||
446 | return Err(()); | ||
447 | } | ||
448 | Ok(x / y) | ||
449 | } | ||
450 | "#, | ||
451 | ); | ||
452 | } | ||
453 | |||
454 | #[test] | ||
455 | fn test_wrap_return_type_handles_generic_functions() { | ||
456 | check_fix( | ||
457 | r#" | ||
458 | //- /main.rs crate:main deps:core | ||
459 | use core::result::Result::{self, Ok, Err}; | ||
460 | |||
461 | fn div<T>(x: T) -> Result<T, i32> { | ||
462 | if x == 0 { | ||
463 | return Err(7); | ||
464 | } | ||
465 | $0x | ||
466 | } | ||
467 | //- /core/lib.rs crate:core | ||
468 | pub mod result { | ||
469 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
470 | } | ||
471 | pub mod option { | ||
472 | pub enum Option<T> { Some(T), None } | ||
473 | } | ||
474 | "#, | ||
475 | r#" | ||
476 | use core::result::Result::{self, Ok, Err}; | ||
477 | |||
478 | fn div<T>(x: T) -> Result<T, i32> { | ||
479 | if x == 0 { | ||
480 | return Err(7); | ||
481 | } | ||
482 | Ok(x) | ||
483 | } | ||
484 | "#, | ||
485 | ); | ||
486 | } | ||
487 | |||
488 | #[test] | ||
489 | fn test_wrap_return_type_handles_type_aliases() { | ||
490 | check_fix( | ||
491 | r#" | ||
492 | //- /main.rs crate:main deps:core | ||
493 | use core::result::Result::{self, Ok, Err}; | ||
494 | |||
495 | type MyResult<T> = Result<T, ()>; | ||
496 | |||
497 | fn div(x: i32, y: i32) -> MyResult<i32> { | ||
498 | if y == 0 { | ||
499 | return Err(()); | ||
500 | } | ||
501 | x $0/ y | ||
502 | } | ||
503 | //- /core/lib.rs crate:core | ||
504 | pub mod result { | ||
505 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
506 | } | ||
507 | pub mod option { | ||
508 | pub enum Option<T> { Some(T), None } | ||
509 | } | ||
510 | "#, | ||
511 | r#" | ||
512 | use core::result::Result::{self, Ok, Err}; | ||
513 | |||
514 | type MyResult<T> = Result<T, ()>; | ||
515 | |||
516 | fn div(x: i32, y: i32) -> MyResult<i32> { | ||
517 | if y == 0 { | ||
518 | return Err(()); | ||
519 | } | ||
520 | Ok(x / y) | ||
521 | } | ||
522 | "#, | ||
523 | ); | ||
524 | } | ||
525 | |||
526 | #[test] | ||
527 | fn test_wrap_return_type_not_applicable_when_expr_type_does_not_match_ok_type() { | ||
528 | check_no_diagnostics( | ||
529 | r#" | ||
530 | //- /main.rs crate:main deps:core | ||
531 | use core::result::Result::{self, Ok, Err}; | ||
532 | |||
533 | fn foo() -> Result<(), i32> { 0 } | ||
534 | |||
535 | //- /core/lib.rs crate:core | ||
536 | pub mod result { | ||
537 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
538 | } | ||
539 | pub mod option { | ||
540 | pub enum Option<T> { Some(T), None } | ||
541 | } | ||
542 | "#, | ||
543 | ); | ||
544 | } | ||
545 | |||
546 | #[test] | ||
547 | fn test_wrap_return_type_not_applicable_when_return_type_is_not_result_or_option() { | ||
548 | check_no_diagnostics( | ||
549 | r#" | ||
550 | //- /main.rs crate:main deps:core | ||
551 | use core::result::Result::{self, Ok, Err}; | ||
552 | |||
553 | enum SomeOtherEnum { Ok(i32), Err(String) } | ||
554 | |||
555 | fn foo() -> SomeOtherEnum { 0 } | ||
556 | |||
557 | //- /core/lib.rs crate:core | ||
558 | pub mod result { | ||
559 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
560 | } | ||
561 | pub mod option { | ||
562 | pub enum Option<T> { Some(T), None } | ||
563 | } | ||
564 | "#, | ||
565 | ); | ||
566 | } | ||
567 | |||
568 | #[test] | ||
569 | fn test_fill_struct_fields_empty() { | ||
570 | check_fix( | ||
571 | r#" | ||
572 | struct TestStruct { one: i32, two: i64 } | ||
573 | |||
574 | fn test_fn() { | ||
575 | let s = TestStruct {$0}; | ||
576 | } | ||
577 | "#, | ||
578 | r#" | ||
579 | struct TestStruct { one: i32, two: i64 } | ||
580 | |||
581 | fn test_fn() { | ||
582 | let s = TestStruct { one: (), two: () }; | ||
583 | } | ||
584 | "#, | ||
585 | ); | ||
586 | } | ||
587 | |||
588 | #[test] | ||
589 | fn test_fill_struct_fields_self() { | ||
590 | check_fix( | ||
591 | r#" | ||
592 | struct TestStruct { one: i32 } | ||
593 | |||
594 | impl TestStruct { | ||
595 | fn test_fn() { let s = Self {$0}; } | ||
596 | } | ||
597 | "#, | ||
598 | r#" | ||
599 | struct TestStruct { one: i32 } | ||
600 | |||
601 | impl TestStruct { | ||
602 | fn test_fn() { let s = Self { one: () }; } | ||
603 | } | ||
604 | "#, | ||
605 | ); | ||
606 | } | ||
607 | |||
608 | #[test] | ||
609 | fn test_fill_struct_fields_enum() { | ||
610 | check_fix( | ||
611 | r#" | ||
612 | enum Expr { | ||
613 | Bin { lhs: Box<Expr>, rhs: Box<Expr> } | ||
614 | } | ||
615 | |||
616 | impl Expr { | ||
617 | fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr { | ||
618 | Expr::Bin {$0 } | ||
619 | } | ||
620 | } | ||
621 | "#, | ||
622 | r#" | ||
623 | enum Expr { | ||
624 | Bin { lhs: Box<Expr>, rhs: Box<Expr> } | ||
625 | } | ||
626 | |||
627 | impl Expr { | ||
628 | fn new_bin(lhs: Box<Expr>, rhs: Box<Expr>) -> Expr { | ||
629 | Expr::Bin { lhs: (), rhs: () } | ||
630 | } | ||
631 | } | ||
632 | "#, | ||
633 | ); | ||
634 | } | ||
635 | |||
636 | #[test] | ||
637 | fn test_fill_struct_fields_partial() { | ||
638 | check_fix( | ||
639 | r#" | ||
640 | struct TestStruct { one: i32, two: i64 } | ||
641 | |||
642 | fn test_fn() { | ||
643 | let s = TestStruct{ two: 2$0 }; | ||
644 | } | ||
645 | "#, | ||
646 | r" | ||
647 | struct TestStruct { one: i32, two: i64 } | ||
648 | |||
649 | fn test_fn() { | ||
650 | let s = TestStruct{ two: 2, one: () }; | ||
651 | } | ||
652 | ", | ||
653 | ); | ||
654 | } | ||
655 | |||
656 | #[test] | ||
657 | fn test_fill_struct_fields_raw_ident() { | ||
658 | check_fix( | ||
659 | r#" | ||
660 | struct TestStruct { r#type: u8 } | ||
661 | |||
662 | fn test_fn() { | ||
663 | TestStruct { $0 }; | ||
664 | } | ||
665 | "#, | ||
666 | r" | ||
667 | struct TestStruct { r#type: u8 } | ||
668 | |||
669 | fn test_fn() { | ||
670 | TestStruct { r#type: () }; | ||
671 | } | ||
672 | ", | ||
673 | ); | ||
674 | } | ||
675 | |||
676 | #[test] | ||
677 | fn test_fill_struct_fields_no_diagnostic() { | ||
678 | check_no_diagnostics( | ||
679 | r" | ||
680 | struct TestStruct { one: i32, two: i64 } | ||
681 | |||
682 | fn test_fn() { | ||
683 | let one = 1; | ||
684 | let s = TestStruct{ one, two: 2 }; | ||
685 | } | ||
686 | ", | ||
687 | ); | ||
688 | } | ||
689 | |||
690 | #[test] | ||
691 | fn test_fill_struct_fields_no_diagnostic_on_spread() { | ||
692 | check_no_diagnostics( | ||
693 | r" | ||
694 | struct TestStruct { one: i32, two: i64 } | ||
695 | |||
696 | fn test_fn() { | ||
697 | let one = 1; | ||
698 | let s = TestStruct{ ..a }; | ||
699 | } | ||
700 | ", | ||
701 | ); | ||
702 | } | ||
703 | |||
704 | #[test] | ||
705 | fn test_unresolved_module_diagnostic() { | ||
706 | check_expect( | ||
707 | r#"mod foo;"#, | ||
708 | expect![[r#" | ||
709 | [ | ||
710 | Diagnostic { | ||
711 | message: "unresolved module", | ||
712 | range: 0..8, | ||
713 | severity: Error, | ||
714 | fix: Some( | ||
715 | Assist { | ||
716 | id: AssistId( | ||
717 | "create_module", | ||
718 | QuickFix, | ||
719 | ), | ||
720 | label: "Create module", | ||
721 | group: None, | ||
722 | target: 0..8, | ||
723 | source_change: Some( | ||
724 | SourceChange { | ||
725 | source_file_edits: {}, | ||
726 | file_system_edits: [ | ||
727 | CreateFile { | ||
728 | dst: AnchoredPathBuf { | ||
729 | anchor: FileId( | ||
730 | 0, | ||
731 | ), | ||
732 | path: "foo.rs", | ||
733 | }, | ||
734 | initial_contents: "", | ||
735 | }, | ||
736 | ], | ||
737 | is_snippet: false, | ||
738 | }, | ||
739 | ), | ||
740 | }, | ||
741 | ), | ||
742 | unused: false, | ||
743 | code: Some( | ||
744 | DiagnosticCode( | ||
745 | "unresolved-module", | ||
746 | ), | ||
747 | ), | ||
748 | }, | ||
749 | ] | ||
750 | "#]], | ||
751 | ); | ||
752 | } | ||
753 | |||
754 | #[test] | ||
755 | fn test_unresolved_macro_range() { | 387 | fn test_unresolved_macro_range() { |
756 | check_expect( | 388 | check_expect( |
757 | r#"foo::bar!(92);"#, | 389 | r#"foo::bar!(92);"#, |
@@ -891,53 +523,6 @@ mod a { | |||
891 | } | 523 | } |
892 | 524 | ||
893 | #[test] | 525 | #[test] |
894 | fn test_add_field_from_usage() { | ||
895 | check_fix( | ||
896 | r" | ||
897 | fn main() { | ||
898 | Foo { bar: 3, baz$0: false}; | ||
899 | } | ||
900 | struct Foo { | ||
901 | bar: i32 | ||
902 | } | ||
903 | ", | ||
904 | r" | ||
905 | fn main() { | ||
906 | Foo { bar: 3, baz: false}; | ||
907 | } | ||
908 | struct Foo { | ||
909 | bar: i32, | ||
910 | baz: bool | ||
911 | } | ||
912 | ", | ||
913 | ) | ||
914 | } | ||
915 | |||
916 | #[test] | ||
917 | fn test_add_field_in_other_file_from_usage() { | ||
918 | check_fix( | ||
919 | r#" | ||
920 | //- /main.rs | ||
921 | mod foo; | ||
922 | |||
923 | fn main() { | ||
924 | foo::Foo { bar: 3, $0baz: false}; | ||
925 | } | ||
926 | //- /foo.rs | ||
927 | struct Foo { | ||
928 | bar: i32 | ||
929 | } | ||
930 | "#, | ||
931 | r#" | ||
932 | struct Foo { | ||
933 | bar: i32, | ||
934 | pub(crate) baz: bool | ||
935 | } | ||
936 | "#, | ||
937 | ) | ||
938 | } | ||
939 | |||
940 | #[test] | ||
941 | fn test_disabled_diagnostics() { | 526 | fn test_disabled_diagnostics() { |
942 | let mut config = DiagnosticsConfig::default(); | 527 | let mut config = DiagnosticsConfig::default(); |
943 | config.disabled.insert("unresolved-module".into()); | 528 | config.disabled.insert("unresolved-module".into()); |
@@ -955,120 +540,6 @@ struct Foo { | |||
955 | } | 540 | } |
956 | 541 | ||
957 | #[test] | 542 | #[test] |
958 | fn test_rename_incorrect_case() { | ||
959 | check_fix( | ||
960 | r#" | ||
961 | pub struct test_struct$0 { one: i32 } | ||
962 | |||
963 | pub fn some_fn(val: test_struct) -> test_struct { | ||
964 | test_struct { one: val.one + 1 } | ||
965 | } | ||
966 | "#, | ||
967 | r#" | ||
968 | pub struct TestStruct { one: i32 } | ||
969 | |||
970 | pub fn some_fn(val: TestStruct) -> TestStruct { | ||
971 | TestStruct { one: val.one + 1 } | ||
972 | } | ||
973 | "#, | ||
974 | ); | ||
975 | |||
976 | check_fix( | ||
977 | r#" | ||
978 | pub fn some_fn(NonSnakeCase$0: u8) -> u8 { | ||
979 | NonSnakeCase | ||
980 | } | ||
981 | "#, | ||
982 | r#" | ||
983 | pub fn some_fn(non_snake_case: u8) -> u8 { | ||
984 | non_snake_case | ||
985 | } | ||
986 | "#, | ||
987 | ); | ||
988 | |||
989 | check_fix( | ||
990 | r#" | ||
991 | pub fn SomeFn$0(val: u8) -> u8 { | ||
992 | if val != 0 { SomeFn(val - 1) } else { val } | ||
993 | } | ||
994 | "#, | ||
995 | r#" | ||
996 | pub fn some_fn(val: u8) -> u8 { | ||
997 | if val != 0 { some_fn(val - 1) } else { val } | ||
998 | } | ||
999 | "#, | ||
1000 | ); | ||
1001 | |||
1002 | check_fix( | ||
1003 | r#" | ||
1004 | fn some_fn() { | ||
1005 | let whatAWeird_Formatting$0 = 10; | ||
1006 | another_func(whatAWeird_Formatting); | ||
1007 | } | ||
1008 | "#, | ||
1009 | r#" | ||
1010 | fn some_fn() { | ||
1011 | let what_a_weird_formatting = 10; | ||
1012 | another_func(what_a_weird_formatting); | ||
1013 | } | ||
1014 | "#, | ||
1015 | ); | ||
1016 | } | ||
1017 | |||
1018 | #[test] | ||
1019 | fn test_uppercase_const_no_diagnostics() { | ||
1020 | check_no_diagnostics( | ||
1021 | r#" | ||
1022 | fn foo() { | ||
1023 | const ANOTHER_ITEM$0: &str = "some_item"; | ||
1024 | } | ||
1025 | "#, | ||
1026 | ); | ||
1027 | } | ||
1028 | |||
1029 | #[test] | ||
1030 | fn test_rename_incorrect_case_struct_method() { | ||
1031 | check_fix( | ||
1032 | r#" | ||
1033 | pub struct TestStruct; | ||
1034 | |||
1035 | impl TestStruct { | ||
1036 | pub fn SomeFn$0() -> TestStruct { | ||
1037 | TestStruct | ||
1038 | } | ||
1039 | } | ||
1040 | "#, | ||
1041 | r#" | ||
1042 | pub struct TestStruct; | ||
1043 | |||
1044 | impl TestStruct { | ||
1045 | pub fn some_fn() -> TestStruct { | ||
1046 | TestStruct | ||
1047 | } | ||
1048 | } | ||
1049 | "#, | ||
1050 | ); | ||
1051 | } | ||
1052 | |||
1053 | #[test] | ||
1054 | fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() { | ||
1055 | let input = r#"fn FOO$0() {}"#; | ||
1056 | let expected = r#"fn foo() {}"#; | ||
1057 | |||
1058 | let (analysis, file_position) = fixture::position(input); | ||
1059 | let diagnostics = analysis | ||
1060 | .diagnostics( | ||
1061 | &DiagnosticsConfig::default(), | ||
1062 | AssistResolveStrategy::All, | ||
1063 | file_position.file_id, | ||
1064 | ) | ||
1065 | .unwrap(); | ||
1066 | assert_eq!(diagnostics.len(), 1); | ||
1067 | |||
1068 | check_fix(input, expected); | ||
1069 | } | ||
1070 | |||
1071 | #[test] | ||
1072 | fn unlinked_file_prepend_first_item() { | 543 | fn unlinked_file_prepend_first_item() { |
1073 | cov_mark::check!(unlinked_file_prepend_before_first_item); | 544 | cov_mark::check!(unlinked_file_prepend_before_first_item); |
1074 | check_fix( | 545 | check_fix( |
diff --git a/crates/ide/src/diagnostics/fixes.rs b/crates/ide/src/diagnostics/fixes.rs index 5330449f9..92b3f5a2d 100644 --- a/crates/ide/src/diagnostics/fixes.rs +++ b/crates/ide/src/diagnostics/fixes.rs | |||
@@ -1,32 +1,18 @@ | |||
1 | //! Provides a way to attach fixes to the diagnostics. | 1 | //! Provides a way to attach fixes to the diagnostics. |
2 | //! The same module also has all curret custom fixes for the diagnostics implemented. | 2 | //! The same module also has all curret custom fixes for the diagnostics implemented. |
3 | mod change_case; | ||
4 | mod create_field; | ||
3 | mod fill_missing_fields; | 5 | mod fill_missing_fields; |
6 | mod remove_semicolon; | ||
7 | mod replace_with_find_map; | ||
8 | mod unresolved_module; | ||
9 | mod wrap_tail_expr; | ||
4 | 10 | ||
5 | use hir::{ | 11 | use hir::{diagnostics::Diagnostic, Semantics}; |
6 | db::AstDatabase, | ||
7 | diagnostics::{ | ||
8 | Diagnostic, IncorrectCase, MissingOkOrSomeInTailExpr, NoSuchField, RemoveThisSemicolon, | ||
9 | ReplaceFilterMapNextWithFindMap, UnresolvedModule, | ||
10 | }, | ||
11 | HasSource, HirDisplay, InFile, Semantics, VariantDef, | ||
12 | }; | ||
13 | use ide_assists::AssistResolveStrategy; | 12 | use ide_assists::AssistResolveStrategy; |
14 | use ide_db::{ | 13 | use ide_db::RootDatabase; |
15 | base_db::{AnchoredPathBuf, FileId}, | ||
16 | source_change::{FileSystemEdit, SourceChange}, | ||
17 | RootDatabase, | ||
18 | }; | ||
19 | use syntax::{ | ||
20 | ast::{self, edit::IndentLevel, make, ArgListOwner}, | ||
21 | AstNode, TextRange, | ||
22 | }; | ||
23 | use text_edit::TextEdit; | ||
24 | 14 | ||
25 | use crate::{ | 15 | use crate::Assist; |
26 | diagnostics::{fix, unresolved_fix}, | ||
27 | references::rename::rename_with_semantics, | ||
28 | Assist, FilePosition, | ||
29 | }; | ||
30 | 16 | ||
31 | /// A [Diagnostic] that potentially has a fix available. | 17 | /// A [Diagnostic] that potentially has a fix available. |
32 | /// | 18 | /// |
@@ -43,216 +29,3 @@ pub(crate) trait DiagnosticWithFix: Diagnostic { | |||
43 | _resolve: &AssistResolveStrategy, | 29 | _resolve: &AssistResolveStrategy, |
44 | ) -> Option<Assist>; | 30 | ) -> Option<Assist>; |
45 | } | 31 | } |
46 | |||
47 | impl DiagnosticWithFix for UnresolvedModule { | ||
48 | fn fix( | ||
49 | &self, | ||
50 | sema: &Semantics<RootDatabase>, | ||
51 | _resolve: &AssistResolveStrategy, | ||
52 | ) -> Option<Assist> { | ||
53 | let root = sema.db.parse_or_expand(self.file)?; | ||
54 | let unresolved_module = self.decl.to_node(&root); | ||
55 | Some(fix( | ||
56 | "create_module", | ||
57 | "Create module", | ||
58 | FileSystemEdit::CreateFile { | ||
59 | dst: AnchoredPathBuf { | ||
60 | anchor: self.file.original_file(sema.db), | ||
61 | path: self.candidate.clone(), | ||
62 | }, | ||
63 | initial_contents: "".to_string(), | ||
64 | } | ||
65 | .into(), | ||
66 | unresolved_module.syntax().text_range(), | ||
67 | )) | ||
68 | } | ||
69 | } | ||
70 | |||
71 | impl DiagnosticWithFix for NoSuchField { | ||
72 | fn fix( | ||
73 | &self, | ||
74 | sema: &Semantics<RootDatabase>, | ||
75 | _resolve: &AssistResolveStrategy, | ||
76 | ) -> Option<Assist> { | ||
77 | let root = sema.db.parse_or_expand(self.file)?; | ||
78 | missing_record_expr_field_fix( | ||
79 | &sema, | ||
80 | self.file.original_file(sema.db), | ||
81 | &self.field.to_node(&root), | ||
82 | ) | ||
83 | } | ||
84 | } | ||
85 | |||
86 | impl DiagnosticWithFix for MissingOkOrSomeInTailExpr { | ||
87 | fn fix( | ||
88 | &self, | ||
89 | sema: &Semantics<RootDatabase>, | ||
90 | _resolve: &AssistResolveStrategy, | ||
91 | ) -> Option<Assist> { | ||
92 | let root = sema.db.parse_or_expand(self.file)?; | ||
93 | let tail_expr = self.expr.to_node(&root); | ||
94 | let tail_expr_range = tail_expr.syntax().text_range(); | ||
95 | let replacement = format!("{}({})", self.required, tail_expr.syntax()); | ||
96 | let edit = TextEdit::replace(tail_expr_range, replacement); | ||
97 | let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit); | ||
98 | let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" }; | ||
99 | Some(fix("wrap_tail_expr", name, source_change, tail_expr_range)) | ||
100 | } | ||
101 | } | ||
102 | |||
103 | impl DiagnosticWithFix for RemoveThisSemicolon { | ||
104 | fn fix( | ||
105 | &self, | ||
106 | sema: &Semantics<RootDatabase>, | ||
107 | _resolve: &AssistResolveStrategy, | ||
108 | ) -> Option<Assist> { | ||
109 | let root = sema.db.parse_or_expand(self.file)?; | ||
110 | |||
111 | let semicolon = self | ||
112 | .expr | ||
113 | .to_node(&root) | ||
114 | .syntax() | ||
115 | .parent() | ||
116 | .and_then(ast::ExprStmt::cast) | ||
117 | .and_then(|expr| expr.semicolon_token())? | ||
118 | .text_range(); | ||
119 | |||
120 | let edit = TextEdit::delete(semicolon); | ||
121 | let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit); | ||
122 | |||
123 | Some(fix("remove_semicolon", "Remove this semicolon", source_change, semicolon)) | ||
124 | } | ||
125 | } | ||
126 | |||
127 | impl DiagnosticWithFix for IncorrectCase { | ||
128 | fn fix( | ||
129 | &self, | ||
130 | sema: &Semantics<RootDatabase>, | ||
131 | resolve: &AssistResolveStrategy, | ||
132 | ) -> Option<Assist> { | ||
133 | let root = sema.db.parse_or_expand(self.file)?; | ||
134 | let name_node = self.ident.to_node(&root); | ||
135 | |||
136 | let name_node = InFile::new(self.file, name_node.syntax()); | ||
137 | let frange = name_node.original_file_range(sema.db); | ||
138 | let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() }; | ||
139 | |||
140 | let label = format!("Rename to {}", self.suggested_text); | ||
141 | let mut res = unresolved_fix("change_case", &label, frange.range); | ||
142 | if resolve.should_resolve(&res.id) { | ||
143 | let source_change = rename_with_semantics(sema, file_position, &self.suggested_text); | ||
144 | res.source_change = Some(source_change.ok().unwrap_or_default()); | ||
145 | } | ||
146 | |||
147 | Some(res) | ||
148 | } | ||
149 | } | ||
150 | |||
151 | impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap { | ||
152 | fn fix( | ||
153 | &self, | ||
154 | sema: &Semantics<RootDatabase>, | ||
155 | _resolve: &AssistResolveStrategy, | ||
156 | ) -> Option<Assist> { | ||
157 | let root = sema.db.parse_or_expand(self.file)?; | ||
158 | let next_expr = self.next_expr.to_node(&root); | ||
159 | let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?; | ||
160 | |||
161 | let filter_map_call = ast::MethodCallExpr::cast(next_call.receiver()?.syntax().clone())?; | ||
162 | let filter_map_name_range = filter_map_call.name_ref()?.ident_token()?.text_range(); | ||
163 | let filter_map_args = filter_map_call.arg_list()?; | ||
164 | |||
165 | let range_to_replace = | ||
166 | TextRange::new(filter_map_name_range.start(), next_expr.syntax().text_range().end()); | ||
167 | let replacement = format!("find_map{}", filter_map_args.syntax().text()); | ||
168 | let trigger_range = next_expr.syntax().text_range(); | ||
169 | |||
170 | let edit = TextEdit::replace(range_to_replace, replacement); | ||
171 | |||
172 | let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit); | ||
173 | |||
174 | Some(fix( | ||
175 | "replace_with_find_map", | ||
176 | "Replace filter_map(..).next() with find_map()", | ||
177 | source_change, | ||
178 | trigger_range, | ||
179 | )) | ||
180 | } | ||
181 | } | ||
182 | |||
183 | fn missing_record_expr_field_fix( | ||
184 | sema: &Semantics<RootDatabase>, | ||
185 | usage_file_id: FileId, | ||
186 | record_expr_field: &ast::RecordExprField, | ||
187 | ) -> Option<Assist> { | ||
188 | let record_lit = ast::RecordExpr::cast(record_expr_field.syntax().parent()?.parent()?)?; | ||
189 | let def_id = sema.resolve_variant(record_lit)?; | ||
190 | let module; | ||
191 | let def_file_id; | ||
192 | let record_fields = match def_id { | ||
193 | VariantDef::Struct(s) => { | ||
194 | module = s.module(sema.db); | ||
195 | let source = s.source(sema.db)?; | ||
196 | def_file_id = source.file_id; | ||
197 | let fields = source.value.field_list()?; | ||
198 | record_field_list(fields)? | ||
199 | } | ||
200 | VariantDef::Union(u) => { | ||
201 | module = u.module(sema.db); | ||
202 | let source = u.source(sema.db)?; | ||
203 | def_file_id = source.file_id; | ||
204 | source.value.record_field_list()? | ||
205 | } | ||
206 | VariantDef::Variant(e) => { | ||
207 | module = e.module(sema.db); | ||
208 | let source = e.source(sema.db)?; | ||
209 | def_file_id = source.file_id; | ||
210 | let fields = source.value.field_list()?; | ||
211 | record_field_list(fields)? | ||
212 | } | ||
213 | }; | ||
214 | let def_file_id = def_file_id.original_file(sema.db); | ||
215 | |||
216 | let new_field_type = sema.type_of_expr(&record_expr_field.expr()?)?; | ||
217 | if new_field_type.is_unknown() { | ||
218 | return None; | ||
219 | } | ||
220 | let new_field = make::record_field( | ||
221 | None, | ||
222 | make::name(&record_expr_field.field_name()?.text()), | ||
223 | make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?), | ||
224 | ); | ||
225 | |||
226 | let last_field = record_fields.fields().last()?; | ||
227 | let last_field_syntax = last_field.syntax(); | ||
228 | let indent = IndentLevel::from_node(last_field_syntax); | ||
229 | |||
230 | let mut new_field = new_field.to_string(); | ||
231 | if usage_file_id != def_file_id { | ||
232 | new_field = format!("pub(crate) {}", new_field); | ||
233 | } | ||
234 | new_field = format!("\n{}{}", indent, new_field); | ||
235 | |||
236 | let needs_comma = !last_field_syntax.to_string().ends_with(','); | ||
237 | if needs_comma { | ||
238 | new_field = format!(",{}", new_field); | ||
239 | } | ||
240 | |||
241 | let source_change = SourceChange::from_text_edit( | ||
242 | def_file_id, | ||
243 | TextEdit::insert(last_field_syntax.text_range().end(), new_field), | ||
244 | ); | ||
245 | return Some(fix( | ||
246 | "create_field", | ||
247 | "Create field", | ||
248 | source_change, | ||
249 | record_expr_field.syntax().text_range(), | ||
250 | )); | ||
251 | |||
252 | fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> { | ||
253 | match field_def_list { | ||
254 | ast::FieldList::RecordFieldList(it) => Some(it), | ||
255 | ast::FieldList::TupleFieldList(_) => None, | ||
256 | } | ||
257 | } | ||
258 | } | ||
diff --git a/crates/ide/src/diagnostics/fixes/change_case.rs b/crates/ide/src/diagnostics/fixes/change_case.rs new file mode 100644 index 000000000..80aca58a1 --- /dev/null +++ b/crates/ide/src/diagnostics/fixes/change_case.rs | |||
@@ -0,0 +1,155 @@ | |||
1 | use hir::{db::AstDatabase, diagnostics::IncorrectCase, InFile, Semantics}; | ||
2 | use ide_assists::{Assist, AssistResolveStrategy}; | ||
3 | use ide_db::{base_db::FilePosition, RootDatabase}; | ||
4 | use syntax::AstNode; | ||
5 | |||
6 | use crate::{ | ||
7 | diagnostics::{unresolved_fix, DiagnosticWithFix}, | ||
8 | references::rename::rename_with_semantics, | ||
9 | }; | ||
10 | |||
11 | impl DiagnosticWithFix for IncorrectCase { | ||
12 | fn fix( | ||
13 | &self, | ||
14 | sema: &Semantics<RootDatabase>, | ||
15 | resolve: &AssistResolveStrategy, | ||
16 | ) -> Option<Assist> { | ||
17 | let root = sema.db.parse_or_expand(self.file)?; | ||
18 | let name_node = self.ident.to_node(&root); | ||
19 | |||
20 | let name_node = InFile::new(self.file, name_node.syntax()); | ||
21 | let frange = name_node.original_file_range(sema.db); | ||
22 | let file_position = FilePosition { file_id: frange.file_id, offset: frange.range.start() }; | ||
23 | |||
24 | let label = format!("Rename to {}", self.suggested_text); | ||
25 | let mut res = unresolved_fix("change_case", &label, frange.range); | ||
26 | if resolve.should_resolve(&res.id) { | ||
27 | let source_change = rename_with_semantics(sema, file_position, &self.suggested_text); | ||
28 | res.source_change = Some(source_change.ok().unwrap_or_default()); | ||
29 | } | ||
30 | |||
31 | Some(res) | ||
32 | } | ||
33 | } | ||
34 | |||
35 | #[cfg(test)] | ||
36 | mod change_case { | ||
37 | use crate::{ | ||
38 | diagnostics::tests::{check_fix, check_no_diagnostics}, | ||
39 | fixture, AssistResolveStrategy, DiagnosticsConfig, | ||
40 | }; | ||
41 | |||
42 | #[test] | ||
43 | fn test_rename_incorrect_case() { | ||
44 | check_fix( | ||
45 | r#" | ||
46 | pub struct test_struct$0 { one: i32 } | ||
47 | |||
48 | pub fn some_fn(val: test_struct) -> test_struct { | ||
49 | test_struct { one: val.one + 1 } | ||
50 | } | ||
51 | "#, | ||
52 | r#" | ||
53 | pub struct TestStruct { one: i32 } | ||
54 | |||
55 | pub fn some_fn(val: TestStruct) -> TestStruct { | ||
56 | TestStruct { one: val.one + 1 } | ||
57 | } | ||
58 | "#, | ||
59 | ); | ||
60 | |||
61 | check_fix( | ||
62 | r#" | ||
63 | pub fn some_fn(NonSnakeCase$0: u8) -> u8 { | ||
64 | NonSnakeCase | ||
65 | } | ||
66 | "#, | ||
67 | r#" | ||
68 | pub fn some_fn(non_snake_case: u8) -> u8 { | ||
69 | non_snake_case | ||
70 | } | ||
71 | "#, | ||
72 | ); | ||
73 | |||
74 | check_fix( | ||
75 | r#" | ||
76 | pub fn SomeFn$0(val: u8) -> u8 { | ||
77 | if val != 0 { SomeFn(val - 1) } else { val } | ||
78 | } | ||
79 | "#, | ||
80 | r#" | ||
81 | pub fn some_fn(val: u8) -> u8 { | ||
82 | if val != 0 { some_fn(val - 1) } else { val } | ||
83 | } | ||
84 | "#, | ||
85 | ); | ||
86 | |||
87 | check_fix( | ||
88 | r#" | ||
89 | fn some_fn() { | ||
90 | let whatAWeird_Formatting$0 = 10; | ||
91 | another_func(whatAWeird_Formatting); | ||
92 | } | ||
93 | "#, | ||
94 | r#" | ||
95 | fn some_fn() { | ||
96 | let what_a_weird_formatting = 10; | ||
97 | another_func(what_a_weird_formatting); | ||
98 | } | ||
99 | "#, | ||
100 | ); | ||
101 | } | ||
102 | |||
103 | #[test] | ||
104 | fn test_uppercase_const_no_diagnostics() { | ||
105 | check_no_diagnostics( | ||
106 | r#" | ||
107 | fn foo() { | ||
108 | const ANOTHER_ITEM$0: &str = "some_item"; | ||
109 | } | ||
110 | "#, | ||
111 | ); | ||
112 | } | ||
113 | |||
114 | #[test] | ||
115 | fn test_rename_incorrect_case_struct_method() { | ||
116 | check_fix( | ||
117 | r#" | ||
118 | pub struct TestStruct; | ||
119 | |||
120 | impl TestStruct { | ||
121 | pub fn SomeFn$0() -> TestStruct { | ||
122 | TestStruct | ||
123 | } | ||
124 | } | ||
125 | "#, | ||
126 | r#" | ||
127 | pub struct TestStruct; | ||
128 | |||
129 | impl TestStruct { | ||
130 | pub fn some_fn() -> TestStruct { | ||
131 | TestStruct | ||
132 | } | ||
133 | } | ||
134 | "#, | ||
135 | ); | ||
136 | } | ||
137 | |||
138 | #[test] | ||
139 | fn test_single_incorrect_case_diagnostic_in_function_name_issue_6970() { | ||
140 | let input = r#"fn FOO$0() {}"#; | ||
141 | let expected = r#"fn foo() {}"#; | ||
142 | |||
143 | let (analysis, file_position) = fixture::position(input); | ||
144 | let diagnostics = analysis | ||
145 | .diagnostics( | ||
146 | &DiagnosticsConfig::default(), | ||
147 | AssistResolveStrategy::All, | ||
148 | file_position.file_id, | ||
149 | ) | ||
150 | .unwrap(); | ||
151 | assert_eq!(diagnostics.len(), 1); | ||
152 | |||
153 | check_fix(input, expected); | ||
154 | } | ||
155 | } | ||
diff --git a/crates/ide/src/diagnostics/fixes/create_field.rs b/crates/ide/src/diagnostics/fixes/create_field.rs new file mode 100644 index 000000000..24e0fda52 --- /dev/null +++ b/crates/ide/src/diagnostics/fixes/create_field.rs | |||
@@ -0,0 +1,157 @@ | |||
1 | use hir::{db::AstDatabase, diagnostics::NoSuchField, HasSource, HirDisplay, Semantics}; | ||
2 | use ide_db::{base_db::FileId, source_change::SourceChange, RootDatabase}; | ||
3 | use syntax::{ | ||
4 | ast::{self, edit::IndentLevel, make}, | ||
5 | AstNode, | ||
6 | }; | ||
7 | use text_edit::TextEdit; | ||
8 | |||
9 | use crate::{ | ||
10 | diagnostics::{fix, DiagnosticWithFix}, | ||
11 | Assist, AssistResolveStrategy, | ||
12 | }; | ||
13 | |||
14 | impl DiagnosticWithFix for NoSuchField { | ||
15 | fn fix( | ||
16 | &self, | ||
17 | sema: &Semantics<RootDatabase>, | ||
18 | _resolve: &AssistResolveStrategy, | ||
19 | ) -> Option<Assist> { | ||
20 | let root = sema.db.parse_or_expand(self.file)?; | ||
21 | missing_record_expr_field_fix( | ||
22 | &sema, | ||
23 | self.file.original_file(sema.db), | ||
24 | &self.field.to_node(&root), | ||
25 | ) | ||
26 | } | ||
27 | } | ||
28 | |||
29 | fn missing_record_expr_field_fix( | ||
30 | sema: &Semantics<RootDatabase>, | ||
31 | usage_file_id: FileId, | ||
32 | record_expr_field: &ast::RecordExprField, | ||
33 | ) -> Option<Assist> { | ||
34 | let record_lit = ast::RecordExpr::cast(record_expr_field.syntax().parent()?.parent()?)?; | ||
35 | let def_id = sema.resolve_variant(record_lit)?; | ||
36 | let module; | ||
37 | let def_file_id; | ||
38 | let record_fields = match def_id { | ||
39 | hir::VariantDef::Struct(s) => { | ||
40 | module = s.module(sema.db); | ||
41 | let source = s.source(sema.db)?; | ||
42 | def_file_id = source.file_id; | ||
43 | let fields = source.value.field_list()?; | ||
44 | record_field_list(fields)? | ||
45 | } | ||
46 | hir::VariantDef::Union(u) => { | ||
47 | module = u.module(sema.db); | ||
48 | let source = u.source(sema.db)?; | ||
49 | def_file_id = source.file_id; | ||
50 | source.value.record_field_list()? | ||
51 | } | ||
52 | hir::VariantDef::Variant(e) => { | ||
53 | module = e.module(sema.db); | ||
54 | let source = e.source(sema.db)?; | ||
55 | def_file_id = source.file_id; | ||
56 | let fields = source.value.field_list()?; | ||
57 | record_field_list(fields)? | ||
58 | } | ||
59 | }; | ||
60 | let def_file_id = def_file_id.original_file(sema.db); | ||
61 | |||
62 | let new_field_type = sema.type_of_expr(&record_expr_field.expr()?)?; | ||
63 | if new_field_type.is_unknown() { | ||
64 | return None; | ||
65 | } | ||
66 | let new_field = make::record_field( | ||
67 | None, | ||
68 | make::name(&record_expr_field.field_name()?.text()), | ||
69 | make::ty(&new_field_type.display_source_code(sema.db, module.into()).ok()?), | ||
70 | ); | ||
71 | |||
72 | let last_field = record_fields.fields().last()?; | ||
73 | let last_field_syntax = last_field.syntax(); | ||
74 | let indent = IndentLevel::from_node(last_field_syntax); | ||
75 | |||
76 | let mut new_field = new_field.to_string(); | ||
77 | if usage_file_id != def_file_id { | ||
78 | new_field = format!("pub(crate) {}", new_field); | ||
79 | } | ||
80 | new_field = format!("\n{}{}", indent, new_field); | ||
81 | |||
82 | let needs_comma = !last_field_syntax.to_string().ends_with(','); | ||
83 | if needs_comma { | ||
84 | new_field = format!(",{}", new_field); | ||
85 | } | ||
86 | |||
87 | let source_change = SourceChange::from_text_edit( | ||
88 | def_file_id, | ||
89 | TextEdit::insert(last_field_syntax.text_range().end(), new_field), | ||
90 | ); | ||
91 | |||
92 | return Some(fix( | ||
93 | "create_field", | ||
94 | "Create field", | ||
95 | source_change, | ||
96 | record_expr_field.syntax().text_range(), | ||
97 | )); | ||
98 | |||
99 | fn record_field_list(field_def_list: ast::FieldList) -> Option<ast::RecordFieldList> { | ||
100 | match field_def_list { | ||
101 | ast::FieldList::RecordFieldList(it) => Some(it), | ||
102 | ast::FieldList::TupleFieldList(_) => None, | ||
103 | } | ||
104 | } | ||
105 | } | ||
106 | |||
107 | #[cfg(test)] | ||
108 | mod tests { | ||
109 | use crate::diagnostics::tests::check_fix; | ||
110 | |||
111 | #[test] | ||
112 | fn test_add_field_from_usage() { | ||
113 | check_fix( | ||
114 | r" | ||
115 | fn main() { | ||
116 | Foo { bar: 3, baz$0: false}; | ||
117 | } | ||
118 | struct Foo { | ||
119 | bar: i32 | ||
120 | } | ||
121 | ", | ||
122 | r" | ||
123 | fn main() { | ||
124 | Foo { bar: 3, baz: false}; | ||
125 | } | ||
126 | struct Foo { | ||
127 | bar: i32, | ||
128 | baz: bool | ||
129 | } | ||
130 | ", | ||
131 | ) | ||
132 | } | ||
133 | |||
134 | #[test] | ||
135 | fn test_add_field_in_other_file_from_usage() { | ||
136 | check_fix( | ||
137 | r#" | ||
138 | //- /main.rs | ||
139 | mod foo; | ||
140 | |||
141 | fn main() { | ||
142 | foo::Foo { bar: 3, $0baz: false}; | ||
143 | } | ||
144 | //- /foo.rs | ||
145 | struct Foo { | ||
146 | bar: i32 | ||
147 | } | ||
148 | "#, | ||
149 | r#" | ||
150 | struct Foo { | ||
151 | bar: i32, | ||
152 | pub(crate) baz: bool | ||
153 | } | ||
154 | "#, | ||
155 | ) | ||
156 | } | ||
157 | } | ||
diff --git a/crates/ide/src/diagnostics/fixes/remove_semicolon.rs b/crates/ide/src/diagnostics/fixes/remove_semicolon.rs new file mode 100644 index 000000000..058002c69 --- /dev/null +++ b/crates/ide/src/diagnostics/fixes/remove_semicolon.rs | |||
@@ -0,0 +1,31 @@ | |||
1 | use hir::{db::AstDatabase, diagnostics::RemoveThisSemicolon, Semantics}; | ||
2 | use ide_assists::{Assist, AssistResolveStrategy}; | ||
3 | use ide_db::{source_change::SourceChange, RootDatabase}; | ||
4 | use syntax::{ast, AstNode}; | ||
5 | use text_edit::TextEdit; | ||
6 | |||
7 | use crate::diagnostics::{fix, DiagnosticWithFix}; | ||
8 | |||
9 | impl DiagnosticWithFix for RemoveThisSemicolon { | ||
10 | fn fix( | ||
11 | &self, | ||
12 | sema: &Semantics<RootDatabase>, | ||
13 | _resolve: &AssistResolveStrategy, | ||
14 | ) -> Option<Assist> { | ||
15 | let root = sema.db.parse_or_expand(self.file)?; | ||
16 | |||
17 | let semicolon = self | ||
18 | .expr | ||
19 | .to_node(&root) | ||
20 | .syntax() | ||
21 | .parent() | ||
22 | .and_then(ast::ExprStmt::cast) | ||
23 | .and_then(|expr| expr.semicolon_token())? | ||
24 | .text_range(); | ||
25 | |||
26 | let edit = TextEdit::delete(semicolon); | ||
27 | let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit); | ||
28 | |||
29 | Some(fix("remove_semicolon", "Remove this semicolon", source_change, semicolon)) | ||
30 | } | ||
31 | } | ||
diff --git a/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs b/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs new file mode 100644 index 000000000..5ddfd2064 --- /dev/null +++ b/crates/ide/src/diagnostics/fixes/replace_with_find_map.rs | |||
@@ -0,0 +1,42 @@ | |||
1 | use hir::{db::AstDatabase, diagnostics::ReplaceFilterMapNextWithFindMap, Semantics}; | ||
2 | use ide_assists::{Assist, AssistResolveStrategy}; | ||
3 | use ide_db::{source_change::SourceChange, RootDatabase}; | ||
4 | use syntax::{ | ||
5 | ast::{self, ArgListOwner}, | ||
6 | AstNode, TextRange, | ||
7 | }; | ||
8 | use text_edit::TextEdit; | ||
9 | |||
10 | use crate::diagnostics::{fix, DiagnosticWithFix}; | ||
11 | |||
12 | impl DiagnosticWithFix for ReplaceFilterMapNextWithFindMap { | ||
13 | fn fix( | ||
14 | &self, | ||
15 | sema: &Semantics<RootDatabase>, | ||
16 | _resolve: &AssistResolveStrategy, | ||
17 | ) -> Option<Assist> { | ||
18 | let root = sema.db.parse_or_expand(self.file)?; | ||
19 | let next_expr = self.next_expr.to_node(&root); | ||
20 | let next_call = ast::MethodCallExpr::cast(next_expr.syntax().clone())?; | ||
21 | |||
22 | let filter_map_call = ast::MethodCallExpr::cast(next_call.receiver()?.syntax().clone())?; | ||
23 | let filter_map_name_range = filter_map_call.name_ref()?.ident_token()?.text_range(); | ||
24 | let filter_map_args = filter_map_call.arg_list()?; | ||
25 | |||
26 | let range_to_replace = | ||
27 | TextRange::new(filter_map_name_range.start(), next_expr.syntax().text_range().end()); | ||
28 | let replacement = format!("find_map{}", filter_map_args.syntax().text()); | ||
29 | let trigger_range = next_expr.syntax().text_range(); | ||
30 | |||
31 | let edit = TextEdit::replace(range_to_replace, replacement); | ||
32 | |||
33 | let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit); | ||
34 | |||
35 | Some(fix( | ||
36 | "replace_with_find_map", | ||
37 | "Replace filter_map(..).next() with find_map()", | ||
38 | source_change, | ||
39 | trigger_range, | ||
40 | )) | ||
41 | } | ||
42 | } | ||
diff --git a/crates/ide/src/diagnostics/fixes/unresolved_module.rs b/crates/ide/src/diagnostics/fixes/unresolved_module.rs new file mode 100644 index 000000000..81244b293 --- /dev/null +++ b/crates/ide/src/diagnostics/fixes/unresolved_module.rs | |||
@@ -0,0 +1,87 @@ | |||
1 | use hir::{db::AstDatabase, diagnostics::UnresolvedModule, Semantics}; | ||
2 | use ide_assists::{Assist, AssistResolveStrategy}; | ||
3 | use ide_db::{base_db::AnchoredPathBuf, source_change::FileSystemEdit, RootDatabase}; | ||
4 | use syntax::AstNode; | ||
5 | |||
6 | use crate::diagnostics::{fix, DiagnosticWithFix}; | ||
7 | |||
8 | impl DiagnosticWithFix for UnresolvedModule { | ||
9 | fn fix( | ||
10 | &self, | ||
11 | sema: &Semantics<RootDatabase>, | ||
12 | _resolve: &AssistResolveStrategy, | ||
13 | ) -> Option<Assist> { | ||
14 | let root = sema.db.parse_or_expand(self.file)?; | ||
15 | let unresolved_module = self.decl.to_node(&root); | ||
16 | Some(fix( | ||
17 | "create_module", | ||
18 | "Create module", | ||
19 | FileSystemEdit::CreateFile { | ||
20 | dst: AnchoredPathBuf { | ||
21 | anchor: self.file.original_file(sema.db), | ||
22 | path: self.candidate.clone(), | ||
23 | }, | ||
24 | initial_contents: "".to_string(), | ||
25 | } | ||
26 | .into(), | ||
27 | unresolved_module.syntax().text_range(), | ||
28 | )) | ||
29 | } | ||
30 | } | ||
31 | |||
32 | #[cfg(test)] | ||
33 | mod tests { | ||
34 | use expect_test::expect; | ||
35 | |||
36 | use crate::diagnostics::tests::check_expect; | ||
37 | |||
38 | #[test] | ||
39 | fn test_unresolved_module_diagnostic() { | ||
40 | check_expect( | ||
41 | r#"mod foo;"#, | ||
42 | expect![[r#" | ||
43 | [ | ||
44 | Diagnostic { | ||
45 | message: "unresolved module", | ||
46 | range: 0..8, | ||
47 | severity: Error, | ||
48 | fix: Some( | ||
49 | Assist { | ||
50 | id: AssistId( | ||
51 | "create_module", | ||
52 | QuickFix, | ||
53 | ), | ||
54 | label: "Create module", | ||
55 | group: None, | ||
56 | target: 0..8, | ||
57 | source_change: Some( | ||
58 | SourceChange { | ||
59 | source_file_edits: {}, | ||
60 | file_system_edits: [ | ||
61 | CreateFile { | ||
62 | dst: AnchoredPathBuf { | ||
63 | anchor: FileId( | ||
64 | 0, | ||
65 | ), | ||
66 | path: "foo.rs", | ||
67 | }, | ||
68 | initial_contents: "", | ||
69 | }, | ||
70 | ], | ||
71 | is_snippet: false, | ||
72 | }, | ||
73 | ), | ||
74 | }, | ||
75 | ), | ||
76 | unused: false, | ||
77 | code: Some( | ||
78 | DiagnosticCode( | ||
79 | "unresolved-module", | ||
80 | ), | ||
81 | ), | ||
82 | }, | ||
83 | ] | ||
84 | "#]], | ||
85 | ); | ||
86 | } | ||
87 | } | ||
diff --git a/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs b/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs new file mode 100644 index 000000000..66676064a --- /dev/null +++ b/crates/ide/src/diagnostics/fixes/wrap_tail_expr.rs | |||
@@ -0,0 +1,211 @@ | |||
1 | use hir::{db::AstDatabase, diagnostics::MissingOkOrSomeInTailExpr, Semantics}; | ||
2 | use ide_assists::{Assist, AssistResolveStrategy}; | ||
3 | use ide_db::{source_change::SourceChange, RootDatabase}; | ||
4 | use syntax::AstNode; | ||
5 | use text_edit::TextEdit; | ||
6 | |||
7 | use crate::diagnostics::{fix, DiagnosticWithFix}; | ||
8 | |||
9 | impl DiagnosticWithFix for MissingOkOrSomeInTailExpr { | ||
10 | fn fix( | ||
11 | &self, | ||
12 | sema: &Semantics<RootDatabase>, | ||
13 | _resolve: &AssistResolveStrategy, | ||
14 | ) -> Option<Assist> { | ||
15 | let root = sema.db.parse_or_expand(self.file)?; | ||
16 | let tail_expr = self.expr.to_node(&root); | ||
17 | let tail_expr_range = tail_expr.syntax().text_range(); | ||
18 | let replacement = format!("{}({})", self.required, tail_expr.syntax()); | ||
19 | let edit = TextEdit::replace(tail_expr_range, replacement); | ||
20 | let source_change = SourceChange::from_text_edit(self.file.original_file(sema.db), edit); | ||
21 | let name = if self.required == "Ok" { "Wrap with Ok" } else { "Wrap with Some" }; | ||
22 | Some(fix("wrap_tail_expr", name, source_change, tail_expr_range)) | ||
23 | } | ||
24 | } | ||
25 | |||
26 | #[cfg(test)] | ||
27 | mod tests { | ||
28 | use crate::diagnostics::tests::{check_fix, check_no_diagnostics}; | ||
29 | |||
30 | #[test] | ||
31 | fn test_wrap_return_type_option() { | ||
32 | check_fix( | ||
33 | r#" | ||
34 | //- /main.rs crate:main deps:core | ||
35 | use core::option::Option::{self, Some, None}; | ||
36 | |||
37 | fn div(x: i32, y: i32) -> Option<i32> { | ||
38 | if y == 0 { | ||
39 | return None; | ||
40 | } | ||
41 | x / y$0 | ||
42 | } | ||
43 | //- /core/lib.rs crate:core | ||
44 | pub mod result { | ||
45 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
46 | } | ||
47 | pub mod option { | ||
48 | pub enum Option<T> { Some(T), None } | ||
49 | } | ||
50 | "#, | ||
51 | r#" | ||
52 | use core::option::Option::{self, Some, None}; | ||
53 | |||
54 | fn div(x: i32, y: i32) -> Option<i32> { | ||
55 | if y == 0 { | ||
56 | return None; | ||
57 | } | ||
58 | Some(x / y) | ||
59 | } | ||
60 | "#, | ||
61 | ); | ||
62 | } | ||
63 | |||
64 | #[test] | ||
65 | fn test_wrap_return_type() { | ||
66 | check_fix( | ||
67 | r#" | ||
68 | //- /main.rs crate:main deps:core | ||
69 | use core::result::Result::{self, Ok, Err}; | ||
70 | |||
71 | fn div(x: i32, y: i32) -> Result<i32, ()> { | ||
72 | if y == 0 { | ||
73 | return Err(()); | ||
74 | } | ||
75 | x / y$0 | ||
76 | } | ||
77 | //- /core/lib.rs crate:core | ||
78 | pub mod result { | ||
79 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
80 | } | ||
81 | pub mod option { | ||
82 | pub enum Option<T> { Some(T), None } | ||
83 | } | ||
84 | "#, | ||
85 | r#" | ||
86 | use core::result::Result::{self, Ok, Err}; | ||
87 | |||
88 | fn div(x: i32, y: i32) -> Result<i32, ()> { | ||
89 | if y == 0 { | ||
90 | return Err(()); | ||
91 | } | ||
92 | Ok(x / y) | ||
93 | } | ||
94 | "#, | ||
95 | ); | ||
96 | } | ||
97 | |||
98 | #[test] | ||
99 | fn test_wrap_return_type_handles_generic_functions() { | ||
100 | check_fix( | ||
101 | r#" | ||
102 | //- /main.rs crate:main deps:core | ||
103 | use core::result::Result::{self, Ok, Err}; | ||
104 | |||
105 | fn div<T>(x: T) -> Result<T, i32> { | ||
106 | if x == 0 { | ||
107 | return Err(7); | ||
108 | } | ||
109 | $0x | ||
110 | } | ||
111 | //- /core/lib.rs crate:core | ||
112 | pub mod result { | ||
113 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
114 | } | ||
115 | pub mod option { | ||
116 | pub enum Option<T> { Some(T), None } | ||
117 | } | ||
118 | "#, | ||
119 | r#" | ||
120 | use core::result::Result::{self, Ok, Err}; | ||
121 | |||
122 | fn div<T>(x: T) -> Result<T, i32> { | ||
123 | if x == 0 { | ||
124 | return Err(7); | ||
125 | } | ||
126 | Ok(x) | ||
127 | } | ||
128 | "#, | ||
129 | ); | ||
130 | } | ||
131 | |||
132 | #[test] | ||
133 | fn test_wrap_return_type_handles_type_aliases() { | ||
134 | check_fix( | ||
135 | r#" | ||
136 | //- /main.rs crate:main deps:core | ||
137 | use core::result::Result::{self, Ok, Err}; | ||
138 | |||
139 | type MyResult<T> = Result<T, ()>; | ||
140 | |||
141 | fn div(x: i32, y: i32) -> MyResult<i32> { | ||
142 | if y == 0 { | ||
143 | return Err(()); | ||
144 | } | ||
145 | x $0/ y | ||
146 | } | ||
147 | //- /core/lib.rs crate:core | ||
148 | pub mod result { | ||
149 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
150 | } | ||
151 | pub mod option { | ||
152 | pub enum Option<T> { Some(T), None } | ||
153 | } | ||
154 | "#, | ||
155 | r#" | ||
156 | use core::result::Result::{self, Ok, Err}; | ||
157 | |||
158 | type MyResult<T> = Result<T, ()>; | ||
159 | |||
160 | fn div(x: i32, y: i32) -> MyResult<i32> { | ||
161 | if y == 0 { | ||
162 | return Err(()); | ||
163 | } | ||
164 | Ok(x / y) | ||
165 | } | ||
166 | "#, | ||
167 | ); | ||
168 | } | ||
169 | |||
170 | #[test] | ||
171 | fn test_wrap_return_type_not_applicable_when_expr_type_does_not_match_ok_type() { | ||
172 | check_no_diagnostics( | ||
173 | r#" | ||
174 | //- /main.rs crate:main deps:core | ||
175 | use core::result::Result::{self, Ok, Err}; | ||
176 | |||
177 | fn foo() -> Result<(), i32> { 0 } | ||
178 | |||
179 | //- /core/lib.rs crate:core | ||
180 | pub mod result { | ||
181 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
182 | } | ||
183 | pub mod option { | ||
184 | pub enum Option<T> { Some(T), None } | ||
185 | } | ||
186 | "#, | ||
187 | ); | ||
188 | } | ||
189 | |||
190 | #[test] | ||
191 | fn test_wrap_return_type_not_applicable_when_return_type_is_not_result_or_option() { | ||
192 | check_no_diagnostics( | ||
193 | r#" | ||
194 | //- /main.rs crate:main deps:core | ||
195 | use core::result::Result::{self, Ok, Err}; | ||
196 | |||
197 | enum SomeOtherEnum { Ok(i32), Err(String) } | ||
198 | |||
199 | fn foo() -> SomeOtherEnum { 0 } | ||
200 | |||
201 | //- /core/lib.rs crate:core | ||
202 | pub mod result { | ||
203 | pub enum Result<T, E> { Ok(T), Err(E) } | ||
204 | } | ||
205 | pub mod option { | ||
206 | pub enum Option<T> { Some(T), None } | ||
207 | } | ||
208 | "#, | ||
209 | ); | ||
210 | } | ||
211 | } | ||