183 lines
6.3 KiB
Rust
183 lines
6.3 KiB
Rust
|
use std::{borrow::Cow, sync::Arc};
|
||
|
|
||
|
use ra_db::{FileId, SourceRoot};
|
||
|
use ra_syntax::SmolStr;
|
||
|
use relative_path::RelativePathBuf;
|
||
|
|
||
|
use crate::{DefDatabase, HirFileId, Name};
|
||
|
|
||
|
#[derive(Clone, Copy)]
|
||
|
pub(super) struct ParentModule<'a> {
|
||
|
pub(super) name: &'a Name,
|
||
|
pub(super) attr_path: Option<&'a SmolStr>,
|
||
|
}
|
||
|
|
||
|
impl<'a> ParentModule<'a> {
|
||
|
fn attribute_path(&self) -> Option<&SmolStr> {
|
||
|
self.attr_path.filter(|p| !p.is_empty())
|
||
|
}
|
||
|
}
|
||
|
|
||
|
pub(super) fn resolve_submodule(
|
||
|
db: &impl DefDatabase,
|
||
|
file_id: HirFileId,
|
||
|
name: &Name,
|
||
|
is_root: bool,
|
||
|
attr_path: Option<&SmolStr>,
|
||
|
parent_module: Option<ParentModule<'_>>,
|
||
|
) -> Result<FileId, RelativePathBuf> {
|
||
|
let file_id = file_id.original_file(db);
|
||
|
let source_root_id = db.file_source_root(file_id);
|
||
|
let path = db.file_relative_path(file_id);
|
||
|
let root = RelativePathBuf::default();
|
||
|
let dir_path = path.parent().unwrap_or(&root);
|
||
|
let mod_name = path.file_stem().unwrap_or("unknown");
|
||
|
|
||
|
let resolve_mode = match (attr_path.filter(|p| !p.is_empty()), parent_module) {
|
||
|
(Some(file_path), Some(parent_module)) => {
|
||
|
let file_path = normalize_attribute_path(file_path);
|
||
|
match parent_module.attribute_path() {
|
||
|
Some(parent_module_attr_path) => {
|
||
|
let path = dir_path
|
||
|
.join(format!(
|
||
|
"{}/{}",
|
||
|
normalize_attribute_path(parent_module_attr_path),
|
||
|
file_path
|
||
|
))
|
||
|
.normalize();
|
||
|
ResolutionMode::InlineModuleWithAttributePath(
|
||
|
InsideInlineModuleMode::WithAttributePath(path),
|
||
|
)
|
||
|
}
|
||
|
None => {
|
||
|
let path =
|
||
|
dir_path.join(format!("{}/{}", parent_module.name, file_path)).normalize();
|
||
|
ResolutionMode::InsideInlineModule(InsideInlineModuleMode::WithAttributePath(
|
||
|
path,
|
||
|
))
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
(None, Some(parent_module)) => match parent_module.attribute_path() {
|
||
|
Some(parent_module_attr_path) => {
|
||
|
let path = dir_path.join(format!(
|
||
|
"{}/{}.rs",
|
||
|
normalize_attribute_path(parent_module_attr_path),
|
||
|
name
|
||
|
));
|
||
|
ResolutionMode::InlineModuleWithAttributePath(InsideInlineModuleMode::File(path))
|
||
|
}
|
||
|
None => {
|
||
|
let path = dir_path.join(format!("{}/{}.rs", parent_module.name, name));
|
||
|
ResolutionMode::InsideInlineModule(InsideInlineModuleMode::File(path))
|
||
|
}
|
||
|
},
|
||
|
(Some(file_path), None) => {
|
||
|
let file_path = normalize_attribute_path(file_path);
|
||
|
let path = dir_path.join(file_path.as_ref()).normalize();
|
||
|
ResolutionMode::OutOfLine(OutOfLineMode::WithAttributePath(path))
|
||
|
}
|
||
|
_ => {
|
||
|
let is_dir_owner = is_root || mod_name == "mod";
|
||
|
if is_dir_owner {
|
||
|
let file_mod = dir_path.join(format!("{}.rs", name));
|
||
|
let dir_mod = dir_path.join(format!("{}/mod.rs", name));
|
||
|
ResolutionMode::OutOfLine(OutOfLineMode::RootOrModRs {
|
||
|
file: file_mod,
|
||
|
directory: dir_mod,
|
||
|
})
|
||
|
} else {
|
||
|
let path = dir_path.join(format!("{}/{}.rs", mod_name, name));
|
||
|
ResolutionMode::OutOfLine(OutOfLineMode::FileInDirectory(path))
|
||
|
}
|
||
|
}
|
||
|
};
|
||
|
|
||
|
resolve_mode.resolve(db.source_root(source_root_id))
|
||
|
}
|
||
|
|
||
|
fn normalize_attribute_path(file_path: &SmolStr) -> Cow<str> {
|
||
|
let current_dir = "./";
|
||
|
let windows_path_separator = r#"\"#;
|
||
|
let current_dir_normalize = if file_path.starts_with(current_dir) {
|
||
|
&file_path[current_dir.len()..]
|
||
|
} else {
|
||
|
file_path.as_str()
|
||
|
};
|
||
|
if current_dir_normalize.contains(windows_path_separator) {
|
||
|
Cow::Owned(current_dir_normalize.replace(windows_path_separator, "/"))
|
||
|
} else {
|
||
|
Cow::Borrowed(current_dir_normalize)
|
||
|
}
|
||
|
}
|
||
|
|
||
|
enum OutOfLineMode {
|
||
|
RootOrModRs { file: RelativePathBuf, directory: RelativePathBuf },
|
||
|
FileInDirectory(RelativePathBuf),
|
||
|
WithAttributePath(RelativePathBuf),
|
||
|
}
|
||
|
|
||
|
impl OutOfLineMode {
|
||
|
pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
|
||
|
match self {
|
||
|
OutOfLineMode::RootOrModRs { file, directory } => match source_root.files.get(file) {
|
||
|
None => resolve_simple_path(source_root, directory).map_err(|_| file.clone()),
|
||
|
file_id => resolve_find_result(file_id, file),
|
||
|
},
|
||
|
OutOfLineMode::FileInDirectory(path) => resolve_simple_path(source_root, path),
|
||
|
OutOfLineMode::WithAttributePath(path) => resolve_simple_path(source_root, path),
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
enum InsideInlineModuleMode {
|
||
|
File(RelativePathBuf),
|
||
|
WithAttributePath(RelativePathBuf),
|
||
|
}
|
||
|
|
||
|
impl InsideInlineModuleMode {
|
||
|
pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
|
||
|
match self {
|
||
|
InsideInlineModuleMode::File(path) => resolve_simple_path(source_root, path),
|
||
|
InsideInlineModuleMode::WithAttributePath(path) => {
|
||
|
resolve_simple_path(source_root, path)
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
enum ResolutionMode {
|
||
|
OutOfLine(OutOfLineMode),
|
||
|
InsideInlineModule(InsideInlineModuleMode),
|
||
|
InlineModuleWithAttributePath(InsideInlineModuleMode),
|
||
|
}
|
||
|
|
||
|
impl ResolutionMode {
|
||
|
pub fn resolve(&self, source_root: Arc<SourceRoot>) -> Result<FileId, RelativePathBuf> {
|
||
|
use self::ResolutionMode::*;
|
||
|
|
||
|
match self {
|
||
|
OutOfLine(mode) => mode.resolve(source_root),
|
||
|
InsideInlineModule(mode) => mode.resolve(source_root),
|
||
|
InlineModuleWithAttributePath(mode) => mode.resolve(source_root),
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
fn resolve_simple_path(
|
||
|
source_root: Arc<SourceRoot>,
|
||
|
path: &RelativePathBuf,
|
||
|
) -> Result<FileId, RelativePathBuf> {
|
||
|
resolve_find_result(source_root.files.get(path), path)
|
||
|
}
|
||
|
|
||
|
fn resolve_find_result(
|
||
|
file_id: Option<&FileId>,
|
||
|
path: &RelativePathBuf,
|
||
|
) -> Result<FileId, RelativePathBuf> {
|
||
|
match file_id {
|
||
|
Some(file_id) => Ok(file_id.clone()),
|
||
|
None => Err(path.clone()),
|
||
|
}
|
||
|
}
|