src/tools/rust-analyzer/crates/ide-assists/src/tests.rs

   1 mod generated;
   2 #[cfg(not(feature = "in-rust-tree"))]
   3 mod sourcegen;
   4
   5 use expect_test::expect;
   6 use hir::{db::DefDatabase, Semantics};
   7 use ide_db::{
   8     base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt},
   9     imports::insert_use::{ImportGranularity, InsertUseConfig},
  10     source_change::FileSystemEdit,
  11     RootDatabase, SnippetCap,
  12 };
  13 use stdx::{format_to, trim_indent};
  14 use syntax::TextRange;
  15 use test_utils::{assert_eq_text, extract_offset};
  16
  17 use crate::{
  18     assists, handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind,
  19     AssistResolveStrategy, Assists, SingleResolve,
  20 };
  21
  22 pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
  23     snippet_cap: SnippetCap::new(true),
  24     allowed: None,
  25     insert_use: InsertUseConfig {
  26         granularity: ImportGranularity::Crate,
  27         prefix_kind: hir::PrefixKind::Plain,
  28         enforce_granularity: true,
  29         group: true,
  30         skip_glob_imports: true,
  31     },
  32 };
  33
  34 pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
  35     RootDatabase::with_single_file(text)
  36 }
  37
  38 #[track_caller]
  39 pub(crate) fn check_assist(assist: Handler, ra_fixture_before: &str, ra_fixture_after: &str) {
  40     let ra_fixture_after = trim_indent(ra_fixture_after);
  41     check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after), None);
  42 }
  43
  44 // There is no way to choose what assist within a group you want to test against,
  45 // so this is here to allow you choose.
  46 pub(crate) fn check_assist_by_label(
  47     assist: Handler,
  48     ra_fixture_before: &str,
  49     ra_fixture_after: &str,
  50     label: &str,
  51 ) {
  52     let ra_fixture_after = trim_indent(ra_fixture_after);
  53     check(assist, ra_fixture_before, ExpectedResult::After(&ra_fixture_after), Some(label));
  54 }
  55
  56 // FIXME: instead of having a separate function here, maybe use
  57 // `extract_ranges` and mark the target as `<target> </target>` in the
  58 // fixture?
  59 #[track_caller]
  60 pub(crate) fn check_assist_target(assist: Handler, ra_fixture: &str, target: &str) {
  61     check(assist, ra_fixture, ExpectedResult::Target(target), None);
  62 }
  63
  64 #[track_caller]
  65 pub(crate) fn check_assist_not_applicable(assist: Handler, ra_fixture: &str) {
  66     check(assist, ra_fixture, ExpectedResult::NotApplicable, None);
  67 }
  68
  69 /// Check assist in unresolved state. Useful to check assists for lazy computation.
  70 #[track_caller]
  71 pub(crate) fn check_assist_unresolved(assist: Handler, ra_fixture: &str) {
  72     check(assist, ra_fixture, ExpectedResult::Unresolved, None);
  73 }
  74
  75 #[track_caller]
  76 fn check_doc_test(assist_id: &str, before: &str, after: &str) {
  77     let after = trim_indent(after);
  78     let (db, file_id, selection) = RootDatabase::with_range_or_offset(before);
  79     let before = db.file_text(file_id).to_string();
  80     let frange = FileRange { file_id, range: selection.into() };
  81
  82     let assist = assists(&db, &TEST_CONFIG, AssistResolveStrategy::All, frange)
  83         .into_iter()
  84         .find(|assist| assist.id.0 == assist_id)
  85         .unwrap_or_else(|| {
  86             panic!(
  87                 "\n\nAssist is not applicable: {}\nAvailable assists: {}",
  88                 assist_id,
  89                 assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange)
  90                     .into_iter()
  91                     .map(|assist| assist.id.0)
  92                     .collect::<Vec<_>>()
  93                     .join(", ")
  94             )
  95         });
  96
  97     let actual = {
  98         let source_change =
  99             assist.source_change.expect("Assist did not contain any source changes");
 100         let mut actual = before;
 101         if let Some(source_file_edit) = source_change.get_source_edit(file_id) {
 102             source_file_edit.apply(&mut actual);
 103         }
 104         actual
 105     };
 106     assert_eq_text!(&after, &actual);
 107 }
 108
 109 enum ExpectedResult<'a> {
 110     NotApplicable,
 111     Unresolved,
 112     After(&'a str),
 113     Target(&'a str),
 114 }
 115
 116 #[track_caller]
 117 fn check(handler: Handler, before: &str, expected: ExpectedResult<'_>, assist_label: Option<&str>) {
 118     let (mut db, file_with_caret_id, range_or_offset) = RootDatabase::with_range_or_offset(before);
 119     db.set_enable_proc_attr_macros(true);
 120     let text_without_caret = db.file_text(file_with_caret_id).to_string();
 121
 122     let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
 123
 124     let sema = Semantics::new(&db);
 125     let config = TEST_CONFIG;
 126     let ctx = AssistContext::new(sema, &config, frange);
 127     let resolve = match expected {
 128         ExpectedResult::Unresolved => AssistResolveStrategy::None,
 129         _ => AssistResolveStrategy::All,
 130     };
 131     let mut acc = Assists::new(&ctx, resolve);
 132     handler(&mut acc, &ctx);
 133     let mut res = acc.finish();
 134
 135     let assist = match assist_label {
 136         Some(label) => res.into_iter().find(|resolved| resolved.label == label),
 137         None => res.pop(),
 138     };
 139
 140     match (assist, expected) {
 141         (Some(assist), ExpectedResult::After(after)) => {
 142             let source_change =
 143                 assist.source_change.expect("Assist did not contain any source changes");
 144             let skip_header = source_change.source_file_edits.len() == 1
 145                 && source_change.file_system_edits.len() == 0;
 146
 147             let mut buf = String::new();
 148             for (file_id, edit) in source_change.source_file_edits {
 149                 let mut text = db.file_text(file_id).as_ref().to_owned();
 150                 edit.apply(&mut text);
 151                 if !skip_header {
 152                     let sr = db.file_source_root(file_id);
 153                     let sr = db.source_root(sr);
 154                     let path = sr.path_for_file(&file_id).unwrap();
 155                     format_to!(buf, "//- {}\n", path)
 156                 }
 157                 buf.push_str(&text);
 158             }
 159
 160             for file_system_edit in source_change.file_system_edits {
 161                 let (dst, contents) = match file_system_edit {
 162                     FileSystemEdit::CreateFile { dst, initial_contents } => (dst, initial_contents),
 163                     FileSystemEdit::MoveFile { src, dst } => {
 164                         (dst, db.file_text(src).as_ref().to_owned())
 165                     }
 166                     FileSystemEdit::MoveDir { src, src_id, dst } => {
 167                         // temporary placeholder for MoveDir since we are not using MoveDir in ide assists yet.
 168                         (dst, format!("{:?}\n{:?}", src_id, src))
 169                     }
 170                 };
 171                 let sr = db.file_source_root(dst.anchor);
 172                 let sr = db.source_root(sr);
 173                 let mut base = sr.path_for_file(&dst.anchor).unwrap().clone();
 174                 base.pop();
 175                 let created_file_path = base.join(&dst.path).unwrap();
 176                 format_to!(buf, "//- {}\n", created_file_path);
 177                 buf.push_str(&contents);
 178             }
 179
 180             assert_eq_text!(after, &buf);
 181         }
 182         (Some(assist), ExpectedResult::Target(target)) => {
 183             let range = assist.target;
 184             assert_eq_text!(&text_without_caret[range], target);
 185         }
 186         (Some(assist), ExpectedResult::Unresolved) => assert!(
 187             assist.source_change.is_none(),
 188             "unresolved assist should not contain source changes"
 189         ),
 190         (Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
 191         (
 192             None,
 193             ExpectedResult::After(_) | ExpectedResult::Target(_) | ExpectedResult::Unresolved,
 194         ) => {
 195             panic!("code action is not applicable")
 196         }
 197         (None, ExpectedResult::NotApplicable) => (),
 198     };
 199 }
 200
 201 fn labels(assists: &[Assist]) -> String {
 202     let mut labels = assists
 203         .iter()
 204         .map(|assist| {
 205             let mut label = match &assist.group {
 206                 Some(g) => g.0.clone(),
 207                 None => assist.label.to_string(),
 208             };
 209             label.push('\n');
 210             label
 211         })
 212         .collect::<Vec<_>>();
 213     labels.dedup();
 214     labels.into_iter().collect::<String>()
 215 }
 216
 217 #[test]
 218 fn assist_order_field_struct() {
 219     let before = "struct Foo { $0bar: u32 }";
 220     let (before_cursor_pos, before) = extract_offset(before);
 221     let (db, file_id) = with_single_file(&before);
 222     let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
 223     let assists = assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
 224     let mut assists = assists.iter();
 225
 226     assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
 227     assert_eq!(assists.next().expect("expected assist").label, "Generate a getter method");
 228     assert_eq!(assists.next().expect("expected assist").label, "Generate a mut getter method");
 229     assert_eq!(assists.next().expect("expected assist").label, "Generate a setter method");
 230     assert_eq!(assists.next().expect("expected assist").label, "Add `#[derive]`");
 231 }
 232
 233 #[test]
 234 fn assist_order_if_expr() {
 235     let (db, frange) = RootDatabase::with_range(
 236         r#"
 237 pub fn test_some_range(a: int) -> bool {
 238     if let 2..6 = $05$0 {
 239         true
 240     } else {
 241         false
 242     }
 243 }
 244 "#,
 245     );
 246
 247     let assists = assists(&db, &TEST_CONFIG, AssistResolveStrategy::None, frange);
 248     let expected = labels(&assists);
 249
 250     expect![[r#"
 251         Convert integer base
 252         Extract into variable
 253         Extract into function
 254         Replace if let with match
 255     "#]]
 256     .assert_eq(&expected);
 257 }
 258
 259 #[test]
 260 fn assist_filter_works() {
 261     let (db, frange) = RootDatabase::with_range(
 262         r#"
 263 pub fn test_some_range(a: int) -> bool {
 264     if let 2..6 = $05$0 {
 265         true
 266     } else {
 267         false
 268     }
 269 }
 270 "#,
 271     );
 272     {
 273         let mut cfg = TEST_CONFIG;
 274         cfg.allowed = Some(vec![AssistKind::Refactor]);
 275
 276         let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
 277         let expected = labels(&assists);
 278
 279         expect![[r#"
 280             Convert integer base
 281             Extract into variable
 282             Extract into function
 283             Replace if let with match
 284         "#]]
 285         .assert_eq(&expected);
 286     }
 287
 288     {
 289         let mut cfg = TEST_CONFIG;
 290         cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
 291         let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
 292         let expected = labels(&assists);
 293
 294         expect![[r#"
 295             Extract into variable
 296             Extract into function
 297         "#]]
 298         .assert_eq(&expected);
 299     }
 300
 301     {
 302         let mut cfg = TEST_CONFIG;
 303         cfg.allowed = Some(vec![AssistKind::QuickFix]);
 304         let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
 305         let expected = labels(&assists);
 306
 307         expect![[r#""#]].assert_eq(&expected);
 308     }
 309 }
 310
 311 #[test]
 312 fn various_resolve_strategies() {
 313     let (db, frange) = RootDatabase::with_range(
 314         r#"
 315 pub fn test_some_range(a: int) -> bool {
 316     if let 2..6 = $05$0 {
 317         true
 318     } else {
 319         false
 320     }
 321 }
 322 "#,
 323     );
 324
 325     let mut cfg = TEST_CONFIG;
 326     cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
 327
 328     {
 329         let assists = assists(&db, &cfg, AssistResolveStrategy::None, frange);
 330         assert_eq!(2, assists.len());
 331         let mut assists = assists.into_iter();
 332
 333         let extract_into_variable_assist = assists.next().unwrap();
 334         expect![[r#"
 335             Assist {
 336                 id: AssistId(
 337                     "extract_variable",
 338                     RefactorExtract,
 339                 ),
 340                 label: "Extract into variable",
 341                 group: None,
 342                 target: 59..60,
 343                 source_change: None,
 344                 trigger_signature_help: false,
 345             }
 346         "#]]
 347         .assert_debug_eq(&extract_into_variable_assist);
 348
 349         let extract_into_function_assist = assists.next().unwrap();
 350         expect![[r#"
 351             Assist {
 352                 id: AssistId(
 353                     "extract_function",
 354                     RefactorExtract,
 355                 ),
 356                 label: "Extract into function",
 357                 group: None,
 358                 target: 59..60,
 359                 source_change: None,
 360                 trigger_signature_help: false,
 361             }
 362         "#]]
 363         .assert_debug_eq(&extract_into_function_assist);
 364     }
 365
 366     {
 367         let assists = assists(
 368             &db,
 369             &cfg,
 370             AssistResolveStrategy::Single(SingleResolve {
 371                 assist_id: "SOMETHING_MISMATCHING".to_string(),
 372                 assist_kind: AssistKind::RefactorExtract,
 373             }),
 374             frange,
 375         );
 376         assert_eq!(2, assists.len());
 377         let mut assists = assists.into_iter();
 378
 379         let extract_into_variable_assist = assists.next().unwrap();
 380         expect![[r#"
 381             Assist {
 382                 id: AssistId(
 383                     "extract_variable",
 384                     RefactorExtract,
 385                 ),
 386                 label: "Extract into variable",
 387                 group: None,
 388                 target: 59..60,
 389                 source_change: None,
 390                 trigger_signature_help: false,
 391             }
 392         "#]]
 393         .assert_debug_eq(&extract_into_variable_assist);
 394
 395         let extract_into_function_assist = assists.next().unwrap();
 396         expect![[r#"
 397             Assist {
 398                 id: AssistId(
 399                     "extract_function",
 400                     RefactorExtract,
 401                 ),
 402                 label: "Extract into function",
 403                 group: None,
 404                 target: 59..60,
 405                 source_change: None,
 406                 trigger_signature_help: false,
 407             }
 408         "#]]
 409         .assert_debug_eq(&extract_into_function_assist);
 410     }
 411
 412     {
 413         let assists = assists(
 414             &db,
 415             &cfg,
 416             AssistResolveStrategy::Single(SingleResolve {
 417                 assist_id: "extract_variable".to_string(),
 418                 assist_kind: AssistKind::RefactorExtract,
 419             }),
 420             frange,
 421         );
 422         assert_eq!(2, assists.len());
 423         let mut assists = assists.into_iter();
 424
 425         let extract_into_variable_assist = assists.next().unwrap();
 426         expect![[r#"
 427             Assist {
 428                 id: AssistId(
 429                     "extract_variable",
 430                     RefactorExtract,
 431                 ),
 432                 label: "Extract into variable",
 433                 group: None,
 434                 target: 59..60,
 435                 source_change: Some(
 436                     SourceChange {
 437                         source_file_edits: {
 438                             FileId(
 439                                 0,
 440                             ): TextEdit {
 441                                 indels: [
 442                                     Indel {
 443                                         insert: "let $0var_name = 5;\n    ",
 444                                         delete: 45..45,
 445                                     },
 446                                     Indel {
 447                                         insert: "var_name",
 448                                         delete: 59..60,
 449                                     },
 450                                 ],
 451                             },
 452                         },
 453                         file_system_edits: [],
 454                         is_snippet: true,
 455                     },
 456                 ),
 457                 trigger_signature_help: false,
 458             }
 459         "#]]
 460         .assert_debug_eq(&extract_into_variable_assist);
 461
 462         let extract_into_function_assist = assists.next().unwrap();
 463         expect![[r#"
 464             Assist {
 465                 id: AssistId(
 466                     "extract_function",
 467                     RefactorExtract,
 468                 ),
 469                 label: "Extract into function",
 470                 group: None,
 471                 target: 59..60,
 472                 source_change: None,
 473                 trigger_signature_help: false,
 474             }
 475         "#]]
 476         .assert_debug_eq(&extract_into_function_assist);
 477     }
 478
 479     {
 480         let assists = assists(&db, &cfg, AssistResolveStrategy::All, frange);
 481         assert_eq!(2, assists.len());
 482         let mut assists = assists.into_iter();
 483
 484         let extract_into_variable_assist = assists.next().unwrap();
 485         expect![[r#"
 486             Assist {
 487                 id: AssistId(
 488                     "extract_variable",
 489                     RefactorExtract,
 490                 ),
 491                 label: "Extract into variable",
 492                 group: None,
 493                 target: 59..60,
 494                 source_change: Some(
 495                     SourceChange {
 496                         source_file_edits: {
 497                             FileId(
 498                                 0,
 499                             ): TextEdit {
 500                                 indels: [
 501                                     Indel {
 502                                         insert: "let $0var_name = 5;\n    ",
 503                                         delete: 45..45,
 504                                     },
 505                                     Indel {
 506                                         insert: "var_name",
 507                                         delete: 59..60,
 508                                     },
 509                                 ],
 510                             },
 511                         },
 512                         file_system_edits: [],
 513                         is_snippet: true,
 514                     },
 515                 ),
 516                 trigger_signature_help: false,
 517             }
 518         "#]]
 519         .assert_debug_eq(&extract_into_variable_assist);
 520
 521         let extract_into_function_assist = assists.next().unwrap();
 522         expect![[r#"
 523             Assist {
 524                 id: AssistId(
 525                     "extract_function",
 526                     RefactorExtract,
 527                 ),
 528                 label: "Extract into function",
 529                 group: None,
 530                 target: 59..60,
 531                 source_change: Some(
 532                     SourceChange {
 533                         source_file_edits: {
 534                             FileId(
 535                                 0,
 536                             ): TextEdit {
 537                                 indels: [
 538                                     Indel {
 539                                         insert: "fun_name()",
 540                                         delete: 59..60,
 541                                     },
 542                                     Indel {
 543                                         insert: "\n\nfn $0fun_name() -> i32 {\n    5\n}",
 544                                         delete: 110..110,
 545                                     },
 546                                 ],
 547                             },
 548                         },
 549                         file_system_edits: [],
 550                         is_snippet: true,
 551                     },
 552                 ),
 553                 trigger_signature_help: false,
 554             }
 555         "#]]
 556         .assert_debug_eq(&extract_into_function_assist);
 557     }
 558 }