nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-28 01:34:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make find_path_prefixed configurable

Browse Source
This commit is contained in:
Lukas Wirth 2020-10-05 17:12:37 +02:00
parent e5f252ade7
commit 67e71619b9
2 changed files with 140 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
crates/hir/src/code_model.rs
View File

@ -4,6 +4,7 @@ use std::{iter, sync::Arc};
use arrayvec::ArrayVec;
use base_db::{CrateId, Edition, FileId};
use either::Either;
use hir_def::find_path::PrefixKind;
use hir_def::{
adt::ReprKind,
adt::StructKind,
@ -391,7 +392,7 @@ impl Module {
db: &dyn DefDatabase,
item: impl Into<ItemInNs>,
) -> Option<ModPath> {
hir_def::find_path::find_path_prefixed(db, item.into(), self.into())
hir_def::find_path::find_path_prefixed(db, item.into(), self.into(), PrefixKind::Plain)
}
}

247
crates/hir_def/src/find_path.rs
View File

@ -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<ModPath> {
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<ModPath> {
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<ModPath> {
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<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,
}))
{
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<ModPath> {
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<PathKind> {
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<PrefixKind>,
) -> Option<ModPath> {
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<PrefixKind>) {
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");
}
}