use super::{ModuleMove, plan_reference_rewrites};
use crate::syntax::apply_text_edits;
fn moved(from: &str, to: &str) -> ModuleMove {
ModuleMove {
from: from.to_owned(),
to: to.to_owned(),
}
}
#[test]
fn a_crate_root_reexport_follows_the_move_and_keeps_its_alias() {
let source = "pub use crate::control::object::button as button_api;\n";
let plan = plan_reference_rewrites(
source,
&[moved(
"control::object::button",
"control::object::panel::button",
)],
false,
)
.expect("a use tree parses");
assert!(plan.unresolved.is_empty(), "{:?}", plan.unresolved);
let rewritten = apply_text_edits(source, &plan.edits);
assert_eq!(
rewritten, "pub use crate::control::object::panel::button as button_api;\n",
"the alias name is preserved and only the module path moved"
);
}
#[test]
fn a_bare_import_is_only_rewritten_at_a_crate_root() {
let source = "pub use control::object::button as button_api;\n";
let moves = [moved(
"control::object::button",
"control::object::panel::button",
)];
let at_root = plan_reference_rewrites(source, &moves, true).expect("parses");
assert_eq!(
apply_text_edits(source, &at_root.edits),
"pub use control::object::panel::button as button_api;\n"
);
let elsewhere = plan_reference_rewrites(source, &moves, false).expect("parses");
assert!(
elsewhere.edits.is_empty(),
"a bare path away from the crate root could be an external crate: {:?}",
elsewhere.edits
);
}
#[test]
fn a_grouped_import_rewrites_only_the_changed_tail() {
let base_move = "use crate::control::object::{button, slider};\n";
let item = plan_reference_rewrites(
base_move,
&[moved(
"control::object::button",
"control::object::panel::button",
)],
false,
)
.expect("parses");
assert_eq!(
apply_text_edits(base_move, &item.edits),
"use crate::control::object::{panel::button, slider};\n"
);
let group_base = plan_reference_rewrites(
base_move,
&[moved("control::object", "control::moved")],
false,
)
.expect("parses");
assert_eq!(
apply_text_edits(base_move, &group_base.edits),
"use crate::control::moved::{button, slider};\n",
"a match entirely in the brace base replaces that base once"
);
}
#[test]
fn typed_and_expression_paths_follow_the_move() {
let source = "pub fn build() -> crate::control::object::button::Button {\n \
crate::control::object::button::Button::new()\n}\n";
let plan = plan_reference_rewrites(
source,
&[moved(
"control::object::button",
"control::object::panel::button",
)],
false,
)
.expect("parses");
let rewritten = apply_text_edits(source, &plan.edits);
assert_eq!(
rewritten,
"pub fn build() -> crate::control::object::panel::button::Button {\n \
crate::control::object::panel::button::Button::new()\n}\n"
);
}
#[test]
fn ordinary_strings_and_comments_are_not_touched() {
let source = "// pub use crate::control::object::button as button_api;\n\
pub const NOTE: &str = \"crate::control::object::button\";\n\
pub use crate::control::object::button as button_api;\n";
let plan = plan_reference_rewrites(
source,
&[moved(
"control::object::button",
"control::object::panel::button",
)],
false,
)
.expect("parses");
let rewritten = apply_text_edits(source, &plan.edits);
assert_eq!(
rewritten,
"// pub use crate::control::object::button as button_api;\n\
pub const NOTE: &str = \"crate::control::object::button\";\n\
pub use crate::control::object::panel::button as button_api;\n"
);
}
#[test]
fn relative_imports_that_could_name_the_move_are_reported() {
let source = "use super::button::run;\n";
let plan = plan_reference_rewrites(
source,
&[moved(
"control::object::button",
"control::object::panel::button",
)],
false,
)
.expect("parses");
assert!(plan.edits.is_empty(), "{:?}", plan.edits);
assert_eq!(plan.unresolved.len(), 1, "{:?}", plan.unresolved);
assert!(
plan.unresolved[0].contains("super::") && plan.unresolved[0].contains("button"),
"the obligation names the spelling and the module: {:?}",
plan.unresolved
);
}
#[test]
fn a_path_nested_in_a_generic_argument_is_rewritten() {
let source = "type X = Option<crate::control::button::Button>;\n";
let plan = plan_reference_rewrites(
source,
&[moved("control::button", "control::panel::button")],
false,
)
.expect("parses");
assert!(plan.unresolved.is_empty(), "{:?}", plan.unresolved);
assert_eq!(
apply_text_edits(source, &plan.edits),
"type X = Option<crate::control::panel::button::Button>;\n"
);
}
#[test]
fn nested_generic_qself_and_trait_positions_are_all_rewritten() {
let source = "fn f() -> impl Iterator<Item = <crate::control::button::B as crate::control::button::T>::Out> {\n \
let _ = crate::control::button::make::<crate::control::button::B>();\n \
std::iter::empty()\n}\n";
let plan = plan_reference_rewrites(
source,
&[moved("control::button", "control::panel::button")],
false,
)
.expect("parses");
let rewritten = apply_text_edits(source, &plan.edits);
assert!(
!rewritten.contains("crate::control::button"),
"every nested position follows the move: {rewritten}"
);
assert_eq!(
rewritten.matches("crate::control::panel::button").count(),
4,
"the turbofish, the QSelf halves and the impl-Trait bound all moved: {rewritten}"
);
}
#[test]
fn a_nested_module_that_declares_the_head_keeps_its_own_bare_path() {
let source = "mod local { mod control { pub mod button { pub const N: u32 = 1; } } \
fn f() -> u32 { control::button::N } }\n";
let plan = plan_reference_rewrites(
source,
&[moved("control::button", "control::panel::button")],
true,
)
.expect("parses");
assert!(plan.edits.is_empty(), "{:?}", plan.edits);
assert_eq!(apply_text_edits(source, &plan.edits), source);
}
#[test]
fn a_function_local_alias_hides_the_bare_head_for_its_block() {
let source = "fn f() { use crate::other as control; control::button::call(); }\n\
fn g() { crate::control::button::call(); }\n";
let plan = plan_reference_rewrites(
source,
&[moved("control::button", "control::panel::button")],
true,
)
.expect("parses");
let rewritten = apply_text_edits(source, &plan.edits);
assert_eq!(
rewritten,
"fn f() { use crate::other as control; control::button::call(); }\n\
fn g() { crate::control::panel::button::call(); }\n",
"the shadowed call keeps its bytes; the crate-qualified one follows the move"
);
}
#[test]
fn a_root_import_of_the_ancestor_keeps_bare_uses_in_scope() {
let source = "use crate::control;\nfn f() -> control::button::B { control::button::B }\n";
let plan = plan_reference_rewrites(
source,
&[moved("control::button", "control::panel::button")],
true,
)
.expect("parses");
let rewritten = apply_text_edits(source, &plan.edits);
assert!(rewritten.contains("use crate::control;"), "{rewritten}");
assert_eq!(rewritten.matches("control::panel::button").count(), 2);
}
#[test]
fn an_absolute_expression_path_is_reported_not_rewritten() {
let source = "fn f() { ::control::button::call(); }\n";
let plan = plan_reference_rewrites(
source,
&[moved("control::button", "control::panel::button")],
true,
)
.expect("parses");
assert!(plan.edits.is_empty(), "{:?}", plan.edits);
assert_eq!(plan.unresolved.len(), 1, "{:?}", plan.unresolved);
assert!(
plan.unresolved[0].contains("external crate"),
"{:?}",
plan.unresolved
);
}
#[test]
fn an_unrelated_absolute_path_is_not_reported() {
let source = "fn f() { ::std::mem::size_of::<u8>(); }\n";
let plan = plan_reference_rewrites(
source,
&[moved("control::button", "control::panel::button")],
true,
)
.expect("parses");
assert!(plan.is_empty(), "{:?}", plan);
}
#[test]
fn a_macro_that_spells_the_moved_module_is_reported() {
let moves = [moved("control::button", "control::panel::button")];
let reported = plan_reference_rewrites(
"macro_rules! m { () => { control::button::call() } }\n",
&moves,
true,
)
.expect("parses");
assert_eq!(reported.unresolved.len(), 1, "{:?}", reported.unresolved);
let quiet = plan_reference_rewrites("fn f() { format!(\"control::button\"); }\n", &moves, true)
.expect("parses");
assert!(quiet.is_empty(), "{:?}", quiet);
let unrelated =
plan_reference_rewrites("fn f() { println!(\"hi\"); }\n", &moves, true).expect("parses");
assert!(unrelated.is_empty(), "{:?}", unrelated);
}
#[test]
fn cfg_gated_branches_are_both_rewritten() {
let source = "#[cfg(feature = \"a\")]\nfn a() -> crate::control::button::B { todo!() }\n\
#[cfg(not(feature = \"a\"))]\nfn b() -> crate::control::button::B { todo!() }\n";
let plan = plan_reference_rewrites(
source,
&[moved("control::button", "control::panel::button")],
false,
)
.expect("parses");
let rewritten = apply_text_edits(source, &plan.edits);
assert_eq!(
rewritten.matches("crate::control::panel::button").count(),
2
);
}