mod generated;
use hir::Semantics;
-use ide_db::base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt};
-use ide_db::RootDatabase;
+use ide_db::{
+ base_db::{fixture::WithFixture, FileId, FileRange, SourceDatabaseExt},
+ helpers::{
+ insert_use::{InsertUseConfig, MergeBehavior},
+ SnippetCap,
+ },
+ source_change::FileSystemEdit,
+ RootDatabase,
+};
use syntax::TextRange;
use test_utils::{assert_eq_text, extract_offset, extract_range};
use crate::{handlers::Handler, Assist, AssistConfig, AssistContext, AssistKind, Assists};
use stdx::{format_to, trim_indent};
+pub(crate) const TEST_CONFIG: AssistConfig = AssistConfig {
+ snippet_cap: SnippetCap::new(true),
+ allowed: None,
+ insert_use: InsertUseConfig {
+ merge: Some(MergeBehavior::Full),
+ prefix_kind: hir::PrefixKind::Plain,
+ },
+};
+
pub(crate) fn with_single_file(text: &str) -> (RootDatabase, FileId) {
RootDatabase::with_single_file(text)
}
let before = db.file_text(file_id).to_string();
let frange = FileRange { file_id, range: selection.into() };
- let mut assist = Assist::resolved(&db, &AssistConfig::default(), frange)
+ let assist = Assist::get(&db, &TEST_CONFIG, true, frange)
.into_iter()
- .find(|assist| assist.assist.id.0 == assist_id)
+ .find(|assist| assist.id.0 == assist_id)
.unwrap_or_else(|| {
panic!(
"\n\nAssist is not applicable: {}\nAvailable assists: {}",
assist_id,
- Assist::resolved(&db, &AssistConfig::default(), frange)
+ Assist::get(&db, &TEST_CONFIG, false, frange)
.into_iter()
- .map(|assist| assist.assist.id.0)
+ .map(|assist| assist.id.0)
.collect::<Vec<_>>()
.join(", ")
)
});
let actual = {
- let change = assist.source_change.source_file_edits.pop().unwrap();
+ let source_change = assist.source_change.unwrap();
let mut actual = before;
- change.edit.apply(&mut actual);
+ if let Some(source_file_edit) = source_change.get_source_edit(file_id) {
+ source_file_edit.apply(&mut actual);
+ }
actual
};
assert_eq_text!(&after, &actual);
let frange = FileRange { file_id: file_with_caret_id, range: range_or_offset.into() };
let sema = Semantics::new(&db);
- let config = AssistConfig::default();
+ let config = TEST_CONFIG;
let ctx = AssistContext::new(sema, &config, frange);
- let mut acc = Assists::new_resolved(&ctx);
+ let mut acc = Assists::new(&ctx, true);
handler(&mut acc, &ctx);
- let mut res = acc.finish_resolved();
+ let mut res = acc.finish();
let assist = match assist_label {
- Some(label) => res.into_iter().find(|resolved| resolved.assist.label == label),
+ Some(label) => res.into_iter().find(|resolved| resolved.label == label),
None => res.pop(),
};
match (assist, expected) {
(Some(assist), ExpectedResult::After(after)) => {
- let mut source_change = assist.source_change;
+ let source_change = assist.source_change.unwrap();
assert!(!source_change.source_file_edits.is_empty());
- let skip_header = source_change.source_file_edits.len() == 1;
- source_change.source_file_edits.sort_by_key(|it| it.file_id);
+ let skip_header = source_change.source_file_edits.len() == 1
+ && source_change.file_system_edits.len() == 0;
let mut buf = String::new();
- for source_file_edit in source_change.source_file_edits {
- let mut text = db.file_text(source_file_edit.file_id).as_ref().to_owned();
- source_file_edit.edit.apply(&mut text);
+ for (file_id, edit) in source_change.source_file_edits {
+ let mut text = db.file_text(file_id).as_ref().to_owned();
+ edit.apply(&mut text);
if !skip_header {
- let sr = db.file_source_root(source_file_edit.file_id);
+ let sr = db.file_source_root(file_id);
let sr = db.source_root(sr);
- let path = sr.path_for_file(&source_file_edit.file_id).unwrap();
+ let path = sr.path_for_file(&file_id).unwrap();
format_to!(buf, "//- {}\n", path)
}
buf.push_str(&text);
}
+ for file_system_edit in source_change.file_system_edits {
+ if let FileSystemEdit::CreateFile { dst, initial_contents } = file_system_edit {
+ let sr = db.file_source_root(dst.anchor);
+ let sr = db.source_root(sr);
+ let mut base = sr.path_for_file(&dst.anchor).unwrap().clone();
+ base.pop();
+ let created_file_path = format!("{}{}", base.to_string(), &dst.path[1..]);
+ format_to!(buf, "//- {}\n", created_file_path);
+ buf.push_str(&initial_contents);
+ }
+ }
+
assert_eq_text!(after, &buf);
}
(Some(assist), ExpectedResult::Target(target)) => {
- let range = assist.assist.target;
+ let range = assist.target;
assert_eq_text!(&text_without_caret[range], target);
}
(Some(_), ExpectedResult::NotApplicable) => panic!("assist should not be applicable!"),
#[test]
fn assist_order_field_struct() {
- let before = "struct Foo { <|>bar: u32 }";
+ let before = "struct Foo { $0bar: u32 }";
let (before_cursor_pos, before) = extract_offset(before);
let (db, file_id) = with_single_file(&before);
let frange = FileRange { file_id, range: TextRange::empty(before_cursor_pos) };
- let assists = Assist::resolved(&db, &AssistConfig::default(), frange);
+ let assists = Assist::get(&db, &TEST_CONFIG, false, frange);
let mut assists = assists.iter();
- assert_eq!(
- assists.next().expect("expected assist").assist.label,
- "Change visibility to pub(crate)"
- );
- assert_eq!(assists.next().expect("expected assist").assist.label, "Add `#[derive]`");
+ assert_eq!(assists.next().expect("expected assist").label, "Change visibility to pub(crate)");
+ assert_eq!(assists.next().expect("expected assist").label, "Generate a getter method");
+ assert_eq!(assists.next().expect("expected assist").label, "Generate a mut getter method");
+ assert_eq!(assists.next().expect("expected assist").label, "Generate a setter method");
+ assert_eq!(assists.next().expect("expected assist").label, "Add `#[derive]`");
}
#[test]
fn assist_order_if_expr() {
let before = "
pub fn test_some_range(a: int) -> bool {
- if let 2..6 = <|>5<|> {
+ if let 2..6 = $05$0 {
true
} else {
false
let (range, before) = extract_range(before);
let (db, file_id) = with_single_file(&before);
let frange = FileRange { file_id, range };
- let assists = Assist::resolved(&db, &AssistConfig::default(), frange);
+ let assists = Assist::get(&db, &TEST_CONFIG, false, frange);
let mut assists = assists.iter();
- assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
- assert_eq!(assists.next().expect("expected assist").assist.label, "Replace with match");
+ assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
+ assert_eq!(assists.next().expect("expected assist").label, "Replace with match");
}
#[test]
fn assist_filter_works() {
let before = "
pub fn test_some_range(a: int) -> bool {
- if let 2..6 = <|>5<|> {
+ if let 2..6 = $05$0 {
true
} else {
false
let frange = FileRange { file_id, range };
{
- let mut cfg = AssistConfig::default();
+ let mut cfg = TEST_CONFIG;
cfg.allowed = Some(vec![AssistKind::Refactor]);
- let assists = Assist::resolved(&db, &cfg, frange);
+ let assists = Assist::get(&db, &cfg, false, frange);
let mut assists = assists.iter();
- assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
- assert_eq!(assists.next().expect("expected assist").assist.label, "Replace with match");
+ assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
+ assert_eq!(assists.next().expect("expected assist").label, "Replace with match");
}
{
- let mut cfg = AssistConfig::default();
+ let mut cfg = TEST_CONFIG;
cfg.allowed = Some(vec![AssistKind::RefactorExtract]);
- let assists = Assist::resolved(&db, &cfg, frange);
+ let assists = Assist::get(&db, &cfg, false, frange);
assert_eq!(assists.len(), 1);
let mut assists = assists.iter();
- assert_eq!(assists.next().expect("expected assist").assist.label, "Extract into variable");
+ assert_eq!(assists.next().expect("expected assist").label, "Extract into variable");
}
{
- let mut cfg = AssistConfig::default();
+ let mut cfg = TEST_CONFIG;
cfg.allowed = Some(vec![AssistKind::QuickFix]);
- let assists = Assist::resolved(&db, &cfg, frange);
+ let assists = Assist::get(&db, &cfg, false, frange);
assert!(assists.is_empty(), "All asserts but quickfixes should be filtered out");
}
}