1 //! An algorithm to find a path to refer to a certain item.
3 use hir_expand::name::{known, AsName, Name};
4 use rustc_hash::FxHashSet;
7 use crate::nameres::CrateDefMap;
11 path::{ModPath, PathKind},
12 visibility::Visibility,
13 ModuleDefId, ModuleId,
16 // FIXME: handle local items
18 /// Find a path that can be used to refer to a certain item. This can depend on
19 /// *from where* you're referring to the item, hence the `from` parameter.
20 pub fn find_path(db: &dyn DefDatabase, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
21 let _p = profile::span("find_path");
22 find_path_inner(db, item, from, MAX_PATH_LEN, None)
25 pub fn find_path_prefixed(
29 prefix_kind: PrefixKind,
30 ) -> Option<ModPath> {
31 let _p = profile::span("find_path_prefixed");
32 find_path_inner(db, item, from, MAX_PATH_LEN, Some(prefix_kind))
35 const MAX_PATH_LEN: usize = 15;
38 fn starts_with_std(&self) -> bool {
39 self.segments.first() == Some(&known::std)
42 // When std library is present, paths starting with `std::`
43 // should be preferred over paths starting with `core::` and `alloc::`
44 fn can_start_with_std(&self) -> bool {
45 let first_segment = self.segments.first();
46 first_segment == Some(&known::alloc) || first_segment == Some(&known::core)
50 fn check_self_super(def_map: &CrateDefMap, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
51 if item == ItemInNs::Types(from.into()) {
52 // - if the item is the module we're in, use `self`
53 Some(ModPath::from_segments(PathKind::Super(0), Vec::new()))
54 } else if let Some(parent_id) = def_map.modules[from.local_id].parent {
55 // - if the item is the parent module, use `super` (this is not used recursively, since `super::super` is ugly)
57 == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
62 Some(ModPath::from_segments(PathKind::Super(1), Vec::new()))
71 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
73 /// Causes paths to always start with either `self`, `super`, `crate` or a crate-name.
74 /// This is the same as plain, just that paths will start with `self` iprepended f the path
75 /// starts with an identifier that is not a crate.
77 /// Causes paths to ignore imports in the local module.
79 /// Causes paths to start with `crate` where applicable, effectively forcing paths to be absolute.
85 fn prefix(self) -> PathKind {
87 PrefixKind::BySelf => PathKind::Super(0),
88 PrefixKind::Plain => PathKind::Plain,
89 PrefixKind::ByCrate => PathKind::Crate,
94 fn is_absolute(&self) -> bool {
95 self == &PrefixKind::ByCrate
100 db: &dyn DefDatabase,
104 prefixed: Option<PrefixKind>,
105 ) -> Option<ModPath> {
112 // - if the item is already in scope, return the name under which it is
113 let def_map = db.crate_def_map(from.krate);
114 let from_scope: &crate::item_scope::ItemScope = &def_map.modules[from.local_id].scope;
116 if let Some((name, _)) = from_scope.name_of(item) { Some(name.clone()) } else { None };
117 if prefixed.is_none() && scope_name.is_some() {
119 .map(|scope_name| ModPath::from_segments(PathKind::Plain, vec![scope_name]));
122 // - if the item is the crate root, return `crate`
124 == ItemInNs::Types(ModuleDefId::ModuleId(ModuleId {
126 local_id: def_map.root,
129 return Some(ModPath::from_segments(PathKind::Crate, Vec::new()));
132 if prefixed.filter(PrefixKind::is_absolute).is_none() {
133 if let modpath @ Some(_) = check_self_super(&def_map, item, from) {
138 // - if the item is the crate root of a dependency crate, return the name from the extern prelude
139 for (name, def_id) in &def_map.extern_prelude {
140 if item == ItemInNs::Types(*def_id) {
141 let name = scope_name.unwrap_or_else(|| name.clone());
142 return Some(ModPath::from_segments(PathKind::Plain, vec![name]));
146 // - if the item is in the prelude, return the name from there
147 if let Some(prelude_module) = def_map.prelude {
148 let prelude_def_map = db.crate_def_map(prelude_module.krate);
149 let prelude_scope: &crate::item_scope::ItemScope =
150 &prelude_def_map.modules[prelude_module.local_id].scope;
151 if let Some((name, vis)) = prelude_scope.name_of(item) {
152 if vis.is_visible_from(db, from) {
153 return Some(ModPath::from_segments(PathKind::Plain, vec![name.clone()]));
158 // - if the item is a builtin, it's in scope
159 if let ItemInNs::Types(ModuleDefId::BuiltinType(builtin)) = item {
160 return Some(ModPath::from_segments(PathKind::Plain, vec![builtin.as_name()]));
164 // - if the item is an enum variant, refer to it via the enum
165 if let Some(ModuleDefId::EnumVariantId(variant)) = item.as_module_def_id() {
166 if let Some(mut path) = find_path(db, ItemInNs::Types(variant.parent.into()), from) {
167 let data = db.enum_data(variant.parent);
168 path.segments.push(data.variants[variant.local_id].name.clone());
171 // If this doesn't work, it seems we have no way of referring to the
172 // enum; that's very weird, but there might still be a reexport of the
176 // - otherwise, look for modules containing (reexporting) it and import it from one of those
178 let crate_root = ModuleId { local_id: def_map.root, krate: from.krate };
179 let crate_attrs = db.attrs(crate_root.into());
180 let prefer_no_std = crate_attrs.by_key("no_std").exists();
181 let mut best_path = None;
182 let mut best_path_len = max_len;
184 if item.krate(db) == Some(from.krate) {
185 // Item was defined in the same crate that wants to import it. It cannot be found in any
186 // dependency in this case.
188 let local_imports = find_local_import_locations(db, item, from);
189 for (module_id, name) in local_imports {
190 if let Some(mut path) = find_path_inner(
192 ItemInNs::Types(ModuleDefId::ModuleId(module_id)),
197 path.segments.push(name);
199 let new_path = if let Some(best_path) = best_path {
200 select_best_path(best_path, path, prefer_no_std)
204 best_path_len = new_path.len();
205 best_path = Some(new_path);
209 // Item was defined in some upstream crate. This means that it must be exported from one,
210 // too (unless we can't name it at all). It could *also* be (re)exported by the same crate
211 // that wants to import it here, but we always prefer to use the external path here.
213 let crate_graph = db.crate_graph();
214 let extern_paths = crate_graph[from.krate].dependencies.iter().filter_map(|dep| {
215 let import_map = db.import_map(dep.crate_id);
216 import_map.import_info_for(item).and_then(|info| {
217 // Determine best path for containing module and append last segment from `info`.
218 let mut path = find_path_inner(
220 ItemInNs::Types(ModuleDefId::ModuleId(info.container)),
225 mark::hit!(partially_imported);
226 path.segments.push(info.path.segments.last().unwrap().clone());
231 for path in extern_paths {
232 let new_path = if let Some(best_path) = best_path {
233 select_best_path(best_path, path, prefer_no_std)
237 best_path = Some(new_path);
241 if let Some(prefix) = prefixed.map(PrefixKind::prefix) {
242 best_path.or_else(|| {
243 scope_name.map(|scope_name| ModPath::from_segments(prefix, vec![scope_name]))
250 fn select_best_path(old_path: ModPath, new_path: ModPath, prefer_no_std: bool) -> ModPath {
251 if old_path.starts_with_std() && new_path.can_start_with_std() {
253 mark::hit!(prefer_no_std_paths);
256 mark::hit!(prefer_std_paths);
259 } else if new_path.starts_with_std() && old_path.can_start_with_std() {
261 mark::hit!(prefer_no_std_paths);
264 mark::hit!(prefer_std_paths);
267 } else if new_path.len() < old_path.len() {
274 /// Finds locations in `from.krate` from which `item` can be imported by `from`.
275 fn find_local_import_locations(
276 db: &dyn DefDatabase,
279 ) -> Vec<(ModuleId, Name)> {
280 let _p = profile::span("find_local_import_locations");
282 // `from` can import anything below `from` with visibility of at least `from`, and anything
283 // above `from` with any visibility. That means we do not need to descend into private siblings
284 // of `from` (and similar).
286 let def_map = db.crate_def_map(from.krate);
288 // Compute the initial worklist. We start with all direct child modules of `from` as well as all
289 // of its (recursive) parent modules.
290 let data = &def_map.modules[from.local_id];
291 let mut worklist = data
294 .map(|child| ModuleId { krate: from.krate, local_id: *child })
295 .collect::<Vec<_>>();
296 let mut parent = data.parent;
297 while let Some(p) = parent {
298 worklist.push(ModuleId { krate: from.krate, local_id: p });
299 parent = def_map.modules[p].parent;
302 let mut seen: FxHashSet<_> = FxHashSet::default();
304 let mut locations = Vec::new();
305 while let Some(module) = worklist.pop() {
306 if !seen.insert(module) {
307 continue; // already processed this module
311 let data = if module.krate == from.krate {
312 &def_map[module.local_id]
314 // The crate might reexport a module defined in another crate.
315 ext_def_map = db.crate_def_map(module.krate);
316 &ext_def_map[module.local_id]
319 if let Some((name, vis)) = data.scope.name_of(item) {
320 if vis.is_visible_from(db, from) {
321 let is_private = if let Visibility::Module(private_to) = vis {
322 private_to.local_id == module.local_id
326 let is_original_def = if let Some(module_def_id) = item.as_module_def_id() {
327 data.scope.declarations().any(|it| it == module_def_id)
332 // Ignore private imports. these could be used if we are
333 // in a submodule of this module, but that's usually not
334 // what the user wants; and if this module can import
335 // the item and we're a submodule of it, so can we.
336 // Also this keeps the cached data smaller.
337 if !is_private || is_original_def {
338 locations.push((module, name.clone()));
343 // Descend into all modules visible from `from`.
344 for (_, per_ns) in data.scope.entries() {
345 if let Some((ModuleDefId::ModuleId(module), vis)) = per_ns.take_types_vis() {
346 if vis.is_visible_from(db, from) {
347 worklist.push(module);
358 use base_db::fixture::WithFixture;
359 use hir_expand::hygiene::Hygiene;
360 use syntax::ast::AstNode;
361 use test_utils::mark;
363 use crate::test_db::TestDB;
367 /// `code` needs to contain a cursor marker; checks that `find_path` for the
368 /// item the `path` refers to returns that same path when called from the
369 /// module the cursor is in.
370 fn check_found_path_(ra_fixture: &str, path: &str, prefix_kind: Option<PrefixKind>) {
371 let (db, pos) = TestDB::with_position(ra_fixture);
372 let module = db.module_for_file(pos.file_id);
373 let parsed_path_file = syntax::SourceFile::parse(&format!("use {};", path));
375 parsed_path_file.syntax_node().descendants().find_map(syntax::ast::Path::cast).unwrap();
376 let mod_path = ModPath::from_src(ast_path, &Hygiene::new_unhygienic()).unwrap();
378 let crate_def_map = db.crate_def_map(module.krate);
379 let resolved = crate_def_map
384 crate::item_scope::BuiltinShadowMode::Module,
391 find_path_inner(&db, ItemInNs::Types(resolved), module, MAX_PATH_LEN, prefix_kind);
392 assert_eq!(found_path, Some(mod_path), "{:?}", prefix_kind);
402 check_found_path_(ra_fixture, unprefixed, None);
403 check_found_path_(ra_fixture, prefixed, Some(PrefixKind::Plain));
404 check_found_path_(ra_fixture, absolute, Some(PrefixKind::ByCrate));
405 check_found_path_(ra_fixture, self_prefixed, Some(PrefixKind::BySelf));
415 check_found_path(code, "S", "S", "crate::S", "self::S");
425 check_found_path(code, "E::A", "E::A", "E::A", "E::A");
437 check_found_path(code, "foo::S", "foo::S", "crate::foo::S", "self::foo::S");
451 check_found_path(code, "super::S", "super::S", "crate::foo::S", "super::S");
462 check_found_path(code, "self", "self", "crate::foo", "self");
473 check_found_path(code, "crate", "crate", "crate", "crate");
485 check_found_path(code, "crate::S", "crate::S", "crate::S", "crate::S");
489 fn different_crate() {
491 //- /main.rs crate:main deps:std
493 //- /std.rs crate:std
496 check_found_path(code, "std::S", "std::S", "std::S", "std::S");
500 fn different_crate_renamed() {
502 //- /main.rs crate:main deps:std
503 extern crate std as std_renamed;
505 //- /std.rs crate:std
518 fn partially_imported() {
519 mark::check!(partially_imported);
520 // Tests that short paths are used even for external items, when parts of the path are
523 //- /main.rs crate:main deps:syntax
528 //- /lib.rs crate:syntax
530 pub enum ModuleItem {
538 "syntax::ast::ModuleItem",
539 "syntax::ast::ModuleItem",
540 "syntax::ast::ModuleItem",
544 //- /main.rs crate:main deps:syntax
548 //- /lib.rs crate:syntax
550 pub enum ModuleItem {
557 "syntax::ast::ModuleItem",
558 "syntax::ast::ModuleItem",
559 "syntax::ast::ModuleItem",
560 "syntax::ast::ModuleItem",
565 fn same_crate_reexport() {
569 mod foo { pub(super) struct S; }
570 pub(crate) use foo::*;
574 check_found_path(code, "bar::S", "bar::S", "crate::bar::S", "self::bar::S");
578 fn same_crate_reexport_rename() {
582 mod foo { pub(super) struct S; }
583 pub(crate) use foo::S as U;
587 check_found_path(code, "bar::U", "bar::U", "crate::bar::U", "self::bar::U");
591 fn different_crate_reexport() {
593 //- /main.rs crate:main deps:std
595 //- /std.rs crate:std deps:core
597 //- /core.rs crate:core
600 check_found_path(code, "std::S", "std::S", "std::S", "std::S");
606 //- /main.rs crate:main deps:std
608 //- /std.rs crate:std
609 pub mod prelude { pub struct S; }
613 check_found_path(code, "S", "S", "S", "S");
617 fn enum_variant_from_prelude() {
619 //- /main.rs crate:main deps:std
621 //- /std.rs crate:std
623 pub enum Option<T> { Some(T), None }
629 check_found_path(code, "None", "None", "None", "None");
630 check_found_path(code, "Some", "Some", "Some", "Some");
642 pub mod bar { pub struct S; }
644 pub use crate::foo::bar::S;
646 check_found_path(code, "baz::S", "baz::S", "crate::baz::S", "self::baz::S");
650 fn discount_private_imports() {
654 pub mod bar { pub struct S; }
659 // crate::S would be shorter, but using private imports seems wrong
660 check_found_path(code, "crate::bar::S", "crate::bar::S", "crate::bar::S", "crate::bar::S");
678 check_found_path(code, "crate::foo::S", "crate::foo::S", "crate::foo::S", "crate::foo::S");
682 fn prefer_std_paths_over_alloc() {
683 mark::check!(prefer_std_paths);
685 //- /main.rs crate:main deps:alloc,std
688 //- /std.rs crate:std deps:alloc
690 pub use alloc::sync::Arc;
693 //- /zzz.rs crate:alloc
708 fn prefer_core_paths_over_std() {
709 mark::check!(prefer_no_std_paths);
711 //- /main.rs crate:main deps:core,std
716 //- /std.rs crate:std deps:core
719 pub use core::fmt::Error;
722 //- /zzz.rs crate:core
738 fn prefer_alloc_paths_over_std() {
740 //- /main.rs crate:main deps:alloc,std
745 //- /std.rs crate:std deps:alloc
748 pub use alloc::sync::Arc;
751 //- /zzz.rs crate:alloc
767 fn prefer_shorter_paths_if_not_alloc() {
769 //- /main.rs crate:main deps:megaalloc,std
772 //- /std.rs crate:std deps:megaalloc
774 pub use megaalloc::sync::Arc;
777 //- /zzz.rs crate:megaalloc
790 fn builtins_are_in_scope() {
799 check_found_path(code, "u8", "u8", "u8", "u8");
800 check_found_path(code, "u16", "u16", "u16", "u16");