pub use crate::paths::module_children_dir;
use tree_sitter::Node;
use sephera_core::types::{ImportKind, ImportStatement};
use crate::names::{crate_root_file, names_a_crate_outside};
use crate::paths::{crate_root, module_path, qualify};
use sephera_core::{
path_utils as shared_paths,
plugins::{ImportPlugin, ResolveContext, ResolverPlugin},
};
impl ImportPlugin for RustPlugin {
fn extract_from_node(
&self,
source: &[u8],
node: &Node<'_>,
) -> Option<Vec<ImportStatement>> {
crate::extract::extract_from_node(source, node)
}
fn collect_declarations(
&self,
source: &[u8],
tree: &tree_sitter::Tree,
) -> Option<sephera_core::declarations::DeclaredNames> {
Some(sephera_core::declarations::collect_declared_names(
source, tree,
))
}
fn child_depth_step(&self, node: &Node<'_>) -> u8 {
u8::from(crate::extract::opens_inline_module(node))
}
fn is_cfg_gated(&self, source: &[u8], node: &Node<'_>) -> bool {
crate::extract::is_cfg_gated(source, node)
}
}
#[derive(Debug, Clone, Copy, Default)]
pub struct RustPlugin;
impl ResolverPlugin for RustPlugin {
fn resolve(
&self,
import_path: &str,
context: ResolveContext<'_>,
) -> Option<String> {
if import_path.starts_with("super::") {
let levels =
shared_paths::count_occurrences(import_path, "super::");
let rest = import_path
.trim_start_matches("super::")
.trim_start_matches(':');
let levels =
levels.saturating_sub(usize::from(context.module_depth));
let mut base = module_path(context.source_file);
for _ in 0..levels {
let parent = shared_paths::parent(&base);
if parent.is_empty() {
break;
}
base = parent;
}
return first_existing(context, &qualify(&base, rest), true);
}
let children = module_children_dir(context.source_file);
if let Some(rest) = import_path.strip_prefix("self::") {
return resolve_qualified(context, &children, rest, true);
}
if let Some(module_path) = import_path.strip_prefix("crate::") {
return resolve_qualified(
context,
&crate_root(context.source_file),
module_path,
true,
);
}
resolve_qualified(context, &children, import_path, false)
}
fn leaves_project(&self, name: &str, context: ResolveContext<'_>) -> bool {
let Some(index) = context.declarations else {
return false;
};
let Some(root_file) = crate_root_file(context, context.source_file)
else {
return false;
};
if !index.file_reaches(&root_file, name) {
return false;
}
let root = crate_root(context.source_file);
first_existing(context, &qualify(&root, name), true).is_none()
}
}
fn resolve_qualified(
context: ResolveContext<'_>,
base: &str,
path: &str,
qualified: bool,
) -> Option<String> {
if let Some(found) =
first_existing(context, &qualify(base, path), qualified)
{
return Some(found);
}
if !qualified {
return None;
}
let index = context.declarations?;
let (prefix, name) = path.rsplit_once("::").unwrap_or(("", path));
if !prefix.is_empty()
&& let Some(module_file) =
first_existing(context, &qualify(base, prefix), qualified)
&& index.file_declares(&module_file, name)
{
return Some(module_file);
}
let root_file = crate_root_file(context, context.source_file)?;
if index.file_reaches(&root_file, name) {
return Some(root_file);
}
if context.kind.is_dependency()
&& index.file_declares(context.source_file, name)
{
return Some(context.source_file.to_owned());
}
None
}
fn first_existing(
context: ResolveContext<'_>,
module_path: &str,
qualified: bool,
) -> Option<String> {
let module_path = shared_paths::replace_separator(module_path, ':');
let candidate = format!("{module_path}.rs");
if context.contains(&candidate) {
return Some(candidate);
}
let candidate = format!("{module_path}/mod.rs");
if context.contains(&candidate) {
return Some(candidate);
}
let parent = shared_paths::parent(&module_path);
if !parent.is_empty() {
let leaf = shared_paths::file_name(&module_path);
for candidate in [format!("{parent}.rs"), format!("{parent}/mod.rs")] {
if !context.contains(&candidate) {
continue;
}
if candidate == context.source_file
&& context.kind == ImportKind::ModuleDeclaration
{
continue;
}
if candidate == context.source_file
&& names_a_crate_outside(context, leaf, qualified)
{
continue;
}
return Some(candidate);
}
}
None
}
#[cfg(test)]
fn resolve(
import_path: &str,
source_file: &str,
files: &[&str],
) -> Option<String> {
let known: sephera_core::plugins::KnownFiles =
files.iter().map(|f| (*f).to_owned()).collect();
let context = sephera_core::plugins::test_context(source_file, &known);
RustPlugin.resolve(import_path, context)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn module_path_drops_both_file_spellings() {
assert_eq!(module_path("src/core/graph.rs"), "src/core/graph");
assert_eq!(module_path("src/core/graph/mod.rs"), "src/core/graph");
assert_eq!(module_path("main.rs"), "main");
assert_eq!(module_path("src/lib.rs"), "src/lib");
}
#[test]
fn crate_root_anchors_on_the_last_src() {
assert_eq!(crate_root("crates/x/src/main.rs"), "crates/x/src");
assert_eq!(crate_root("src/a/b/c.rs"), "src");
assert_eq!(crate_root("lib.rs"), "");
}
#[test]
fn resolves_crate_relative_module() {
let files = ["src/core/graph.rs", "src/main.rs"];
assert_eq!(
resolve("crate::core::graph", "src/main.rs", &files),
Some("src/core/graph.rs".to_owned())
);
}
#[test]
fn resolves_crate_relative_mod_rs() {
let files = ["src/core/graph/mod.rs", "src/main.rs"];
assert_eq!(
resolve("crate::core::graph", "src/main.rs", &files),
Some("src/core/graph/mod.rs".to_owned())
);
}
#[test]
fn resolves_self_relative_module() {
let files = ["src/core/graph/types.rs", "src/core/graph.rs"];
assert_eq!(
resolve("self::types", "src/core/graph.rs", &files),
Some("src/core/graph/types.rs".to_owned())
);
}
#[test]
fn an_integration_test_file_is_its_own_crate_root() {
let files = ["tests/support/mod.rs", "tests/case.rs"];
assert_eq!(
resolve("self::support", "tests/case.rs", &files),
Some("tests/support/mod.rs".to_owned())
);
}
#[test]
fn an_example_file_is_its_own_crate_root() {
let files = ["examples/demo.rs", "examples/helper/mod.rs"];
assert_eq!(
resolve("self::helper", "examples/demo.rs", &files),
Some("examples/helper/mod.rs".to_owned())
);
}
#[test]
fn a_mod_file_owns_its_own_directory() {
let files = ["src/core/graph/mod.rs", "src/core/graph/parser.rs"];
assert_eq!(
resolve("self::parser", "src/core/graph/mod.rs", &files),
Some("src/core/graph/parser.rs".to_owned())
);
}
#[test]
fn an_item_inside_a_directory_module_resolves_to_that_module() {
let files = ["crates/sephera_core/src/core/compression/mod.rs"];
assert_eq!(
resolve(
"crate::core::compression::CompressionMode",
"crates/sephera_core/src/core/context/builder.rs",
&files,
),
Some("crates/sephera_core/src/core/compression/mod.rs".to_owned())
);
}
#[test]
fn a_sibling_item_of_a_directory_module_resolves_too() {
let files = [
"crates/sephera_core/src/core/symbols/mod.rs",
"crates/sephera_core/src/core/symbols/types.rs",
];
assert_eq!(
resolve(
"crate::core::symbols::SymbolEntry",
"crates/sephera_core/src/core/runtime/context.rs",
&files,
),
Some("crates/sephera_core/src/core/symbols/mod.rs".to_owned())
);
}
#[test]
fn an_unresolvable_module_does_not_fall_back_to_the_declaring_file() {
let files = ["src/main.rs"];
assert_eq!(resolve("self::missing", "src/main.rs", &files), None);
}
#[test]
fn super_steps_out_of_the_files_own_module() {
let files = ["src/core/graph/types.rs", "src/core/graph/parser.rs"];
assert_eq!(
resolve("super::types", "src/core/graph/parser.rs", &files),
Some("src/core/graph/types.rs".to_owned())
);
}
#[test]
fn super_from_a_mod_file_resolves_to_the_owning_module() {
let files = ["src/core/types.rs", "src/core/graph/mod.rs"];
assert_eq!(
resolve("super::types", "src/core/graph/mod.rs", &files),
Some("src/core/types.rs".to_owned())
);
}
#[test]
fn super_escaping_a_nested_module_reaches_the_parent_directory() {
let files = ["src/core/types.rs", "src/core/graph/parser.rs"];
assert_eq!(
resolve("super::super::types", "src/core/graph/parser.rs", &files),
Some("src/core/types.rs".to_owned())
);
}
#[test]
fn falls_back_to_the_parent_module_file() {
let files = ["src/core/graph.rs", "src/main.rs"];
assert_eq!(
resolve("crate::core::graph::types", "src/main.rs", &files),
Some("src/core/graph.rs".to_owned())
);
}
#[test]
fn external_crate_is_not_resolved() {
let files = ["src/main.rs"];
assert_eq!(resolve("anyhow::Result", "src/main.rs", &files), None);
assert_eq!(resolve("serde::Serialize", "src/main.rs", &files), None);
assert_eq!(
resolve("std::collections::HashMap", "src/main.rs", &files),
None
);
}
#[test]
fn unresolved_local_module_returns_none() {
let files = ["src/main.rs"];
assert_eq!(resolve("crate::missing", "src/main.rs", &files), None);
}
#[test]
fn nested_crate_import_anchors_on_the_crate_root() {
let files = [
"crates/inner/src/lib.rs",
"crates/inner/src/util.rs",
"src/main.rs",
];
assert_eq!(
resolve("crate::util", "crates/inner/src/lib.rs", &files),
Some("crates/inner/src/util.rs".to_owned())
);
}
}