use crate::paths::{crate_root, module_path};
use sephera_core::{path_utils as shared_paths, plugins::ResolveContext};
#[must_use]
pub fn is_qualifier(name: &str) -> bool {
matches!(name, "super" | "self" | "crate")
}
#[must_use]
pub fn names_a_crate_outside(
context: ResolveContext<'_>,
name: &str,
qualified: bool,
) -> bool {
if name.is_empty() || name.contains(':') || is_qualifier(name) {
return false;
}
if context
.files()
.any(|known| shared_paths::file_name(&module_path(known)) == name)
{
return false;
}
if context.declarations.is_some_and(|index| {
index.file_declares(context.source_file, name)
|| (qualified && index.file_reaches(context.source_file, name))
}) {
return false;
}
!crate_root(context.source_file).is_empty()
}
#[must_use]
pub fn crate_root_file(
context: ResolveContext<'_>,
source_file: &str,
) -> Option<String> {
let root = crate_root(source_file);
if root.is_empty() {
return None;
}
for name in ["lib", "main", "mod"] {
let candidate = format!("{root}/{name}.rs");
if context.contains(&candidate) {
return Some(candidate);
}
}
None
}
#[cfg(test)]
mod tests {
use super::*;
fn context_over<'a>(
known: &'a std::collections::BTreeSet<String>,
source_file: &'a str,
) -> ResolveContext<'a> {
ResolveContext {
source_file,
known_files: known,
module_depth: 0,
kind: sephera_core::types::ImportKind::Dependency,
declarations: None,
manifests: None,
base_path: std::path::Path::new(""),
}
}
fn a_crate_under_src(extra: &str) -> std::collections::BTreeSet<String> {
["src/leaf.rs".to_owned(), extra.to_owned()]
.into_iter()
.collect()
}
struct ReexportingFile {
known: std::collections::BTreeSet<String>,
index: sephera_core::declarations::DeclarationIndex,
}
impl ReexportingFile {
fn new(reexported: &str) -> Self {
let mut index =
sephera_core::declarations::DeclarationIndex::default();
index.insert(
"src/leaf.rs",
sephera_core::declarations::DeclaredNames::from_names_and_reexports(
[],
[reexported],
),
);
Self {
known: a_crate_under_src(""),
index,
}
}
fn context(&self) -> ResolveContext<'_> {
ResolveContext {
source_file: "src/leaf.rs",
known_files: &self.known,
module_depth: 0,
kind: sephera_core::types::ImportKind::Dependency,
declarations: Some(&self.index),
manifests: None,
base_path: std::path::Path::new(""),
}
}
}
#[test]
fn a_qualifier_is_never_a_crate_name() {
assert!(is_qualifier("super"));
assert!(is_qualifier("self"));
assert!(is_qualifier("crate"));
assert!(!is_qualifier("fastrand"));
assert!(!is_qualifier("MultipartForm"));
}
#[test]
fn a_bare_name_with_no_file_is_a_crate_outside() {
let known = a_crate_under_src("");
assert!(names_a_crate_outside(
context_over(&known, "src/leaf.rs"),
"fastrand",
false
));
}
#[test]
fn a_qualified_name_is_never_a_bare_crate() {
let known = a_crate_under_src("");
assert!(!names_a_crate_outside(
context_over(&known, "src/leaf.rs"),
"serde::Serialize",
true
));
}
#[test]
fn a_file_named_after_the_word_makes_it_local() {
let known = a_crate_under_src("src/store.rs");
assert!(!names_a_crate_outside(
context_over(&known, "src/leaf.rs"),
"store",
false
));
}
#[test]
fn a_reexport_does_not_make_a_bare_name_local() {
let file = ReexportingFile::new("typed_json");
assert!(names_a_crate_outside(file.context(), "typed_json", false));
}
#[test]
fn a_reexport_makes_a_qualified_name_local() {
let file = ReexportingFile::new("BlastRadius");
assert!(!names_a_crate_outside(file.context(), "BlastRadius", true));
}
#[test]
fn a_generic_struct_is_still_a_declaration() {
let mut parser = sephera_compression::new_parser(
sephera_compression::SupportedLanguage::Rust,
)
.expect("rust parser");
let source = "pub struct JsonLines<S, T = AsExtractor> {}\n";
let tree = parser.parse(source.as_bytes(), None).expect("parses");
let names = sephera_core::declarations::collect_declared_names(
source.as_bytes(),
&tree,
);
assert!(names.declares("JsonLines"));
}
#[test]
fn without_a_crate_root_a_bare_name_is_not_guessed_at() {
let known: std::collections::BTreeSet<String> =
std::iter::once("tests/leaf.rs".to_owned()).collect();
assert!(!names_a_crate_outside(
context_over(&known, "tests/leaf.rs"),
"anything",
false
));
}
}