From 67e71619b95dc674c93bd11fb21b311bfc2fb95a Mon Sep 17 00:00:00 2001 From: Lukas Wirth Date: Mon, 5 Oct 2020 17:12:37 +0200 Subject: Make find_path_prefixed configurable --- crates/hir_def/src/find_path.rs | 247 ++++++++++++++++++++++------------------ 1 file changed, 138 insertions(+), 109 deletions(-) (limited to 'crates/hir_def/src/find_path.rs') diff --git a/crates/hir_def/src/find_path.rs b/crates/hir_def/src/find_path.rs index baf374144..9106ed45f 100644 --- a/crates/hir_def/src/find_path.rs +++ b/crates/hir_def/src/find_path.rs @@ -19,12 +19,17 @@ use crate::{ /// *from where* you're referring to the item, hence the `from` parameter. pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option { let _p = profile::span("find_path"); - find_path_inner(db, item, from, MAX_PATH_LEN, Prefixed::Not) + find_path_inner(db, item, from, MAX_PATH_LEN, None) } -pub fn find_path_prefixed(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option { - let _p = profile::span("find_path_absolute"); - find_path_inner(db, item, from, MAX_PATH_LEN, Prefixed::Plain) +pub fn find_path_prefixed( + db: &dyn DefDatabase, + item: ItemInNs, + from: ModuleId, + prefix_kind: PrefixKind, +) -> Option { + let _p = profile::span("find_path_prefixed"); + find_path_inner(db, item, from, MAX_PATH_LEN, Some(prefix_kind)) } const MAX_PATH_LEN: usize = 15; @@ -42,58 +47,52 @@ impl ModPath { } } -fn check_crate_self_super( - def_map: &CrateDefMap, - item: ItemInNs, - from: ModuleId, -) -> Option { - // - if the item is the crate root, return `crate` - if item - == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId { - krate: from.krate, - local_id: def_map.root, - })) - { - Some(ModPath::from_segments(PathKind::Crate, Vec::new())) - } else if item == ItemInNs::Types(from.into()) { +fn check_self_super(def_map: &CrateDefMap, item: ItemInNs, from: ModuleId) -> Option { + if item == ItemInNs::Types(from.into()) { // - if the item is the module we're in, use `self` Some(ModPath::from_segments(PathKind::Super(0), Vec::new())) - } else { - if let Some(parent_id) = def_map.modules[from.local_id].parent { - // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly) - if item - == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId { - krate: from.krate, - local_id: parent_id, - })) - { - return Some(ModPath::from_segments(PathKind::Super(1), Vec::new())); - } + } else if let Some(parent_id) = def_map.modules[from.local_id].parent { + // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly) + if item + == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId { + krate: from.krate, + local_id: parent_id, + })) + { + Some(ModPath::from_segments(PathKind::Super(1), Vec::new())) + } else { + None } + } else { None } } -#[derive(Copy, Clone, PartialEq, Eq)] -pub enum Prefixed { - Not, +#[derive(Copy, Clone, Debug, PartialEq, Eq)] +pub enum PrefixKind { + /// Causes paths to always start with either `self`, `super`, `crate` or a crate-name. + /// This is the same as plain, just that paths will start with `self` iprepended f the path + /// starts with an identifier that is not a crate. BySelf, + /// Causes paths to ignore imports in the local module. Plain, + /// Causes paths to start with `crate` where applicable, effectively forcing paths to be absolute. + ByCrate, } -impl Prefixed { +impl PrefixKind { #[inline] - fn prefix(self) -> Option { + fn prefix(self) -> PathKind { match self { - Prefixed::Not => None, - Prefixed::BySelf => Some(PathKind::Super(0)), - Prefixed::Plain => Some(PathKind::Plain), + PrefixKind::BySelf => PathKind::Super(0), + PrefixKind::Plain => PathKind::Plain, + PrefixKind::ByCrate => PathKind::Crate, } } #[inline] - fn prefixed(self) -> bool { - self != Prefixed::Not + fn is_absolute(&self) -> bool { + self == &PrefixKind::ByCrate } } @@ -102,7 +101,7 @@ fn find_path_inner( item: ItemInNs, from: ModuleId, max_len: usize, - prefixed: Prefixed, + prefixed: Option, ) -> Option { if max_len == 0 { return None; @@ -115,13 +114,25 @@ fn find_path_inner( let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope; let scope_name = if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None }; - if !prefixed.prefixed() && scope_name.is_some() { + if prefixed.is_none() && scope_name.is_some() { return scope_name .map(|scope_name| ModPath::from_segments(PathKind::Plain, vec![scope_name])); } - if let modpath @ Some(_) = check_crate_self_super(&def_map, item, from) { - return modpath; + // - if the item is the crate root, return `crate` + if item + == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId { + krate: from.krate, + local_id: def_map.root, + })) + { + return Some(ModPath::from_segments(PathKind::Crate, Vec::new())); + } + + if prefixed.filter(PrefixKind::is_absolute).is_none() { + if let modpath @ Some(_) = check_self_super(&def_map, item, from) { + return modpath; + } } // - if the item is the crate root of a dependency crate, return the name from the extern prelude @@ -226,7 +237,7 @@ fn find_path_inner( } } - if let Some(prefix) = prefixed.prefix() { + if let Some(prefix) = prefixed.map(PrefixKind::prefix) { best_path.or_else(|| { scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name])) }) @@ -355,7 +366,7 @@ mod tests { /// `code` needs to contain a cursor marker; checks that `find_path` for the /// item the `path` refers to returns that same path when called from the /// module the cursor is in. - fn check_found_path_(ra_fixture: &str, path: &str, absolute: bool) { + fn check_found_path_(ra_fixture: &str, path: &str, prefix_kind: Option) { let (db, pos) = TestDB::with_position(ra_fixture); let module = db.module_for_file(pos.file_id); let parsed_path_file = syntax::SourceFile::parse(&format!("use {};", path)); @@ -375,20 +386,22 @@ mod tests { .take_types() .unwrap(); - let found_path = if absolute { find_path_prefixed } else { find_path }( - &db, - ItemInNs::Types(resolved), - module, - ); - assert_eq!(found_path, Some(mod_path), "absolute {}", absolute); + let found_path = + find_path_inner(&db, ItemInNs::Types(resolved), module, MAX_PATH_LEN, prefix_kind); + assert_eq!(found_path, Some(mod_path), "{:?}", prefix_kind); } - fn check_found_path(ra_fixture: &str, path: &str) { - check_found_path_(ra_fixture, path, false); - } - - fn check_found_path_abs(ra_fixture: &str, path: &str) { - check_found_path_(ra_fixture, path, true); + fn check_found_path( + ra_fixture: &str, + unprefixed: &str, + prefixed: &str, + absolute: &str, + self_prefixed: &str, + ) { + check_found_path_(ra_fixture, unprefixed, None); + check_found_path_(ra_fixture, prefixed, Some(PrefixKind::Plain)); + check_found_path_(ra_fixture, absolute, Some(PrefixKind::ByCrate)); + check_found_path_(ra_fixture, self_prefixed, Some(PrefixKind::BySelf)); } #[test] @@ -398,8 +411,7 @@ mod tests { struct S; <|> "#; - check_found_path(code, "S"); - check_found_path_abs(code, "S"); + check_found_path(code, "S", "S", "crate::S", "self::S"); } #[test] @@ -409,8 +421,7 @@ mod tests { enum E { A } <|> "#; - check_found_path(code, "E::A"); - check_found_path_abs(code, "E::A"); + check_found_path(code, "E::A", "E::A", "E::A", "E::A"); } #[test] @@ -422,8 +433,7 @@ mod tests { } <|> "#; - check_found_path(code, "foo::S"); - check_found_path_abs(code, "foo::S"); + check_found_path(code, "foo::S", "foo::S", "crate::foo::S", "self::foo::S"); } #[test] @@ -437,8 +447,7 @@ mod tests { //- /foo/bar.rs <|> "#; - check_found_path(code, "super::S"); - check_found_path_abs(code, "super::S"); + check_found_path(code, "super::S", "super::S", "crate::foo::S", "super::S"); } #[test] @@ -449,8 +458,7 @@ mod tests { //- /foo.rs <|> "#; - check_found_path(code, "self"); - check_found_path_abs(code, "self"); + check_found_path(code, "self", "self", "crate::foo", "self"); } #[test] @@ -461,8 +469,7 @@ mod tests { //- /foo.rs <|> "#; - check_found_path(code, "crate"); - check_found_path_abs(code, "crate"); + check_found_path(code, "crate", "crate", "crate", "crate"); } #[test] @@ -474,8 +481,7 @@ mod tests { //- /foo.rs <|> "#; - check_found_path(code, "crate::S"); - check_found_path_abs(code, "crate::S"); + check_found_path(code, "crate::S", "crate::S", "crate::S", "crate::S"); } #[test] @@ -486,8 +492,7 @@ mod tests { //- /std.rs crate:std pub struct S; "#; - check_found_path(code, "std::S"); - check_found_path_abs(code, "std::S"); + check_found_path(code, "std::S", "std::S", "std::S", "std::S"); } #[test] @@ -499,8 +504,13 @@ mod tests { //- /std.rs crate:std pub struct S; "#; - check_found_path(code, "std_renamed::S"); - check_found_path_abs(code, "std_renamed::S"); + check_found_path( + code, + "std_renamed::S", + "std_renamed::S", + "std_renamed::S", + "std_renamed::S", + ); } #[test] @@ -520,8 +530,13 @@ mod tests { } } "#; - check_found_path(code, "ast::ModuleItem"); - check_found_path_abs(code, "syntax::ast::ModuleItem"); + check_found_path( + code, + "ast::ModuleItem", + "syntax::ast::ModuleItem", + "syntax::ast::ModuleItem", + "syntax::ast::ModuleItem", + ); let code = r#" //- /main.rs crate:main deps:syntax @@ -535,8 +550,13 @@ mod tests { } } "#; - check_found_path(code, "syntax::ast::ModuleItem"); - check_found_path_abs(code, "syntax::ast::ModuleItem"); + check_found_path( + code, + "syntax::ast::ModuleItem", + "syntax::ast::ModuleItem", + "syntax::ast::ModuleItem", + "syntax::ast::ModuleItem", + ); } #[test] @@ -549,8 +569,7 @@ mod tests { } <|> "#; - check_found_path(code, "bar::S"); - check_found_path_abs(code, "bar::S"); + check_found_path(code, "bar::S", "bar::S", "crate::bar::S", "self::bar::S"); } #[test] @@ -563,8 +582,7 @@ mod tests { } <|> "#; - check_found_path(code, "bar::U"); - check_found_path_abs(code, "bar::U"); + check_found_path(code, "bar::U", "bar::U", "crate::bar::U", "self::bar::U"); } #[test] @@ -577,8 +595,7 @@ mod tests { //- /core.rs crate:core pub struct S; "#; - check_found_path(code, "std::S"); - check_found_path_abs(code, "std::S"); + check_found_path(code, "std::S", "std::S", "std::S", "std::S"); } #[test] @@ -591,8 +608,7 @@ mod tests { #[prelude_import] pub use prelude::*; "#; - check_found_path(code, "S"); - check_found_path_abs(code, "S"); + check_found_path(code, "S", "S", "S", "S"); } #[test] @@ -608,10 +624,8 @@ mod tests { #[prelude_import] pub use prelude::*; "#; - check_found_path(code, "None"); - check_found_path(code, "Some"); - check_found_path_abs(code, "None"); - check_found_path_abs(code, "Some"); + check_found_path(code, "None", "None", "None", "None"); + check_found_path(code, "Some", "Some", "Some", "Some"); } #[test] @@ -627,8 +641,7 @@ mod tests { //- /baz.rs pub use crate::foo::bar::S; "#; - check_found_path(code, "baz::S"); - check_found_path_abs(code, "baz::S"); + check_found_path(code, "baz::S", "baz::S", "crate::baz::S", "self::baz::S"); } #[test] @@ -642,8 +655,7 @@ mod tests { <|> "#; // crate::S would be shorter, but using private imports seems wrong - check_found_path(code, "crate::bar::S"); - check_found_path_abs(code, "crate::bar::S"); + check_found_path(code, "crate::bar::S", "crate::bar::S", "crate::bar::S", "crate::bar::S"); } #[test] @@ -661,8 +673,7 @@ mod tests { //- /baz.rs pub use super::foo; "#; - check_found_path(code, "crate::foo::S"); - check_found_path_abs(code, "crate::foo::S"); + check_found_path(code, "crate::foo::S", "crate::foo::S", "crate::foo::S", "crate::foo::S"); } #[test] @@ -682,8 +693,13 @@ mod tests { pub struct Arc; } "#; - check_found_path(code, "std::sync::Arc"); - check_found_path_abs(code, "std::sync::Arc"); + check_found_path( + code, + "std::sync::Arc", + "std::sync::Arc", + "std::sync::Arc", + "std::sync::Arc", + ); } #[test] @@ -707,8 +723,13 @@ mod tests { pub struct Error; } "#; - check_found_path(code, "core::fmt::Error"); - check_found_path_abs(code, "core::fmt::Error"); + check_found_path( + code, + "core::fmt::Error", + "core::fmt::Error", + "core::fmt::Error", + "core::fmt::Error", + ); } #[test] @@ -731,8 +752,13 @@ mod tests { pub struct Arc; } "#; - check_found_path(code, "alloc::sync::Arc"); - check_found_path_abs(code, "alloc::sync::Arc"); + check_found_path( + code, + "alloc::sync::Arc", + "alloc::sync::Arc", + "alloc::sync::Arc", + "alloc::sync::Arc", + ); } #[test] @@ -749,8 +775,13 @@ mod tests { //- /zzz.rs crate:megaalloc pub struct Arc; "#; - check_found_path(code, "megaalloc::Arc"); - check_found_path_abs(code, "megaalloc::Arc"); + check_found_path( + code, + "megaalloc::Arc", + "megaalloc::Arc", + "megaalloc::Arc", + "megaalloc::Arc", + ); } #[test] @@ -763,9 +794,7 @@ mod tests { pub use u8; } "#; - check_found_path(code, "u8"); - check_found_path(code, "u16"); - check_found_path_abs(code, "u8"); - check_found_path_abs(code, "u16"); + check_found_path(code, "u8", "u8", "u8", "u8"); + check_found_path(code, "u16", "u16", "u16", "u16"); } } -- cgit v1.2.3