use rustc_hash::FxHashSet;
use test_utils::mark;
-use crate::nameres::CrateDefMap;
+use crate::nameres::DefMap;
use crate::{
db::DefDatabase,
item_scope::ItemInNs,
}
}
-fn check_self_super(def_map: &CrateDefMap, item: ItemInNs, from: ModuleId) -> Option<ModPath> {
+fn check_self_super(def_map: &DefMap, 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()))
let code = r#"
//- /main.rs
struct S;
- <|>
+ $0
"#;
check_found_path(code, "S", "S", "crate::S", "self::S");
}
let code = r#"
//- /main.rs
enum E { A }
- <|>
+ $0
"#;
check_found_path(code, "E::A", "E::A", "E::A", "E::A");
}
mod foo {
pub struct S;
}
- <|>
+ $0
"#;
check_found_path(code, "foo::S", "foo::S", "crate::foo::S", "self::foo::S");
}
mod bar;
struct S;
//- /foo/bar.rs
- <|>
+ $0
"#;
check_found_path(code, "super::S", "super::S", "crate::foo::S", "super::S");
}
//- /main.rs
mod foo;
//- /foo.rs
- <|>
+ $0
"#;
check_found_path(code, "self", "self", "crate::foo", "self");
}
//- /main.rs
mod foo;
//- /foo.rs
- <|>
+ $0
"#;
check_found_path(code, "crate", "crate", "crate", "crate");
}
mod foo;
struct S;
//- /foo.rs
- <|>
+ $0
"#;
check_found_path(code, "crate::S", "crate::S", "crate::S", "crate::S");
}
fn different_crate() {
let code = r#"
//- /main.rs crate:main deps:std
- <|>
+ $0
//- /std.rs crate:std
pub struct S;
"#;
let code = r#"
//- /main.rs crate:main deps:std
extern crate std as std_renamed;
- <|>
+ $0
//- /std.rs crate:std
pub struct S;
"#;
//- /main.rs crate:main deps:syntax
use syntax::ast;
- <|>
+ $0
//- /lib.rs crate:syntax
pub mod ast {
let code = r#"
//- /main.rs crate:main deps:syntax
- <|>
+ $0
//- /lib.rs crate:syntax
pub mod ast {
mod foo { pub(super) struct S; }
pub(crate) use foo::*;
}
- <|>
+ $0
"#;
check_found_path(code, "bar::S", "bar::S", "crate::bar::S", "self::bar::S");
}
mod foo { pub(super) struct S; }
pub(crate) use foo::S as U;
}
- <|>
+ $0
"#;
check_found_path(code, "bar::U", "bar::U", "crate::bar::U", "self::bar::U");
}
fn different_crate_reexport() {
let code = r#"
//- /main.rs crate:main deps:std
- <|>
+ $0
//- /std.rs crate:std deps:core
pub use core::S;
//- /core.rs crate:core
fn prelude() {
let code = r#"
//- /main.rs crate:main deps:std
- <|>
+ $0
//- /std.rs crate:std
pub mod prelude { pub struct S; }
#[prelude_import]
fn enum_variant_from_prelude() {
let code = r#"
//- /main.rs crate:main deps:std
- <|>
+ $0
//- /std.rs crate:std
pub mod prelude {
pub enum Option<T> { Some(T), None }
pub mod foo;
pub mod baz;
struct S;
- <|>
+ $0
//- /foo.rs
pub mod bar { pub struct S; }
//- /baz.rs
pub mod bar { pub struct S; }
use bar::S;
//- /foo.rs
- <|>
+ $0
"#;
// crate::S would be shorter, but using private imports seems wrong
check_found_path(code, "crate::bar::S", "crate::bar::S", "crate::bar::S", "crate::bar::S");
pub mod bar;
pub mod baz;
//- /bar.rs
- <|>
+ $0
//- /foo.rs
pub use super::baz;
pub struct S;
mark::check!(prefer_std_paths);
let code = r#"
//- /main.rs crate:main deps:alloc,std
- <|>
+ $0
//- /std.rs crate:std deps:alloc
pub mod sync {
//- /main.rs crate:main deps:core,std
#![no_std]
- <|>
+ $0
//- /std.rs crate:std deps:core
//- /main.rs crate:main deps:alloc,std
#![no_std]
- <|>
+ $0
//- /std.rs crate:std deps:alloc
fn prefer_shorter_paths_if_not_alloc() {
let code = r#"
//- /main.rs crate:main deps:megaalloc,std
- <|>
+ $0
//- /std.rs crate:std deps:megaalloc
pub mod sync {
fn builtins_are_in_scope() {
let code = r#"
//- /main.rs
- <|>
+ $0
pub mod primitive {
pub use u8;