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