crates/ide_assists/src/tests.rs

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