diff --git a/src/common/extraction/extract_dependencies.rs b/src/common/extraction/extract_dependencies.rs index d6df0a8..e422873 100644 --- a/src/common/extraction/extract_dependencies.rs +++ b/src/common/extraction/extract_dependencies.rs @@ -208,10 +208,14 @@ fn collect_internal_aliases( ) -> AliasMap { let mut aliases = AliasMap::new(); for reference in references { - if !matches!( - reference.kind, - ImportKind::Use | ImportKind::PubUse | ImportKind::Mod - ) { + let self_crate_alias = + reference.kind == ImportKind::ExternCrate && reference.segments == ["self"]; + if !self_crate_alias + && !matches!( + reference.kind, + ImportKind::Use | ImportKind::PubUse | ImportKind::Mod + ) + { continue; } let Some(binding) = &reference.binding else { @@ -265,6 +269,12 @@ fn resolve_direct( candidates.insert(found); } } + // Unlike a `self::` path, `extern crate self` names this target's crate root. + "self" if reference.kind == ImportKind::ExternCrate => { + if let Some(found) = longest_prefix(index, &reference.module, &[], 0) { + candidates.insert(found); + } + } "self" => { let mut path = reference.module.segments.clone(); path.extend_from_slice(&reference.segments[1..]); @@ -416,12 +426,38 @@ mod tests { module("lib", &["consumer", "local"]), "src/consumer/local.rs", ), + (module("lib", &["sibling"]), "src/sibling.rs"), ] .into_iter() .map(|(module, source)| (module, source.to_owned())) .collect() } + fn alias(current: LogicalModule, binding: &str) -> RawReference { + let mut declaration = reference(current, &["self"]); + declaration.kind = ImportKind::ExternCrate; + declaration.binding = Some(binding.to_owned()); + declaration + } + + fn use_alias(current: LogicalModule, segments: &[&str], binding: &str) -> RawReference { + let mut reference = reference(current, segments); + reference.kind = ImportKind::Use; + reference.binding = Some(binding.to_owned()); + reference + } + + fn assert_alias_target(reference: &RawReference, aliases: &AliasMap, expected: &str) { + let ResolutionOutcome::Found(found) = resolve_reference(reference, &index(), aliases) + else { + panic!( + "expected {expected} for {}, got no unique target", + reference.rendered_path() + ); + }; + assert_eq!(found.source, expected); + } + #[test] fn resolves_explicit_roots_and_longest_internal_prefix() { let reference = reference( @@ -455,52 +491,163 @@ mod tests { } #[test] - fn resolves_paths_through_internal_use_aliases() { + fn resolves_paths_through_internal_aliases() { let current = module("lib", &["consumer"]); - let import = RawReference { - source: "src/consumer.rs".to_owned(), - module: current.clone(), - segments: vec!["crate".to_owned(), "api".to_owned()], - leading_colon: false, - kind: ImportKind::Use, - line: 1, - binding: Some("public_api".to_owned()), - declaration: None, - ignored: false, - }; - let aliases = collect_internal_aliases(&[import], &index()); - let reference = reference(current, &["public_api", "model", "User"]); + let crate_api = use_alias(current.clone(), &["crate", "api"], "public_api"); - let ResolutionOutcome::Found(found) = resolve_reference(&reference, &index(), &aliases) - else { - panic!("fixture alias should resolve uniquely"); - }; + for (declaration, binding, segments, expected) in [ + ( + crate_api, + "public_api", + &["public_api", "model", "User"][..], + "src/api/model.rs", + ), + ( + alias(current.clone(), "this_crate"), + "this_crate", + &["this_crate", "api", "model", "User"][..], + "src/api/model.rs", + ), + ] { + let aliases = collect_internal_aliases(&[declaration], &index()); + let reference = reference(current.clone(), segments); - assert_eq!(found.source, "src/api/model.rs"); + let ResolutionOutcome::Found(found) = resolve_reference(&reference, &index(), &aliases) + else { + panic!("fixture alias {binding} should resolve uniquely"); + }; + + assert_eq!(found.source, expected, "wrong target for alias {binding}"); + } } #[test] fn explicit_bindings_take_precedence_over_bare_module_candidates() { let current = module("lib", &["consumer"]); - let import = RawReference { - source: "src/consumer.rs".to_owned(), - module: current.clone(), - segments: vec!["crate".to_owned(), "api".to_owned()], - leading_colon: false, - kind: ImportKind::Use, - line: 1, - binding: Some("local".to_owned()), - declaration: None, - ignored: false, - }; - let aliases = collect_internal_aliases(&[import], &index()); - let reference = reference(current, &["local", "Thing"]); + let crate_api = use_alias(current.clone(), &["crate", "api"], "local"); - let ResolutionOutcome::Found(found) = resolve_reference(&reference, &index(), &aliases) - else { - panic!("the explicit local binding should win"); - }; + for (declaration, binding, segments, expected) in [ + (crate_api, "local", &["local", "Thing"][..], "src/api.rs"), + ( + alias(current.clone(), "api"), + "api", + &["api", "Risk"][..], + "src/lib.rs", + ), + ] { + let aliases = collect_internal_aliases(&[declaration], &index()); + let reference = reference(current.clone(), segments); + + let ResolutionOutcome::Found(found) = resolve_reference(&reference, &index(), &aliases) + else { + panic!("the explicit {binding} binding should win"); + }; - assert_eq!(found.source, "src/api.rs"); + assert_eq!(found.source, expected, "wrong precedence for {binding}"); + } + } + + #[test] + fn root_self_crate_alias_resolves_root_reexport() { + let root = module("lib", &[]); + let aliases = collect_internal_aliases(&[alias(root.clone(), "this_crate")], &index()); + + assert_alias_target( + &reference(root, &["this_crate", "Risk"]), + &aliases, + "src/lib.rs", + ); + } + + #[test] + fn self_crate_aliases_respect_competing_library_and_binary_roots() { + let targets = [ + ("lib", "src/lib.rs", "src/consumer.rs"), + ("bin", "src/main.rs", "src/bin_consumer.rs"), + ]; + let mut index = BTreeMap::new(); + let mut declarations = Vec::new(); + for (target, root, consumer) in targets { + index.insert(module(target, &[]), root.to_owned()); + + let mut declaration = alias(module(target, &["consumer"]), "local_crate"); + declaration.source = consumer.to_owned(); + index.insert(declaration.module.clone(), consumer.to_owned()); + declarations.push(declaration); + } + let mut library_only = declarations[0].clone(); + library_only.binding = Some("library_only".to_owned()); + let mut aliases = collect_internal_aliases(&declarations, &index); + aliases.extend(collect_internal_aliases(&[library_only], &index)); + + for (declaration, (target, root, _)) in declarations.iter().zip(targets) { + let mut qualified = declaration.clone(); + qualified.kind = ImportKind::PathReference; + qualified.binding = None; + qualified.segments = vec!["local_crate".to_owned(), "Item".to_owned()]; + for reference in [declaration, &qualified] { + let ResolutionOutcome::Found(found) = + resolve_reference(reference, &index, &aliases) + else { + panic!( + "expected {} to resolve in target {target}", + reference.rendered_path(), + ); + }; + assert_eq!(found.source, root, "wrong root for target {target}"); + } + + qualified.segments[0] = "library_only".to_owned(); + let outcome = resolve_reference(&qualified, &index, &aliases); + if target == "lib" { + assert!( + matches!(outcome, ResolutionOutcome::Found(found) if found.source == root), + "the library-only alias should resolve inside lib", + ); + } else { + assert!( + matches!(outcome, ResolutionOutcome::Unresolved), + "a library-only alias must not leak into the bin target", + ); + } + } + } + + #[test] + fn use_via_renamed_self_crate_alias_resolves_root() { + let current = module("lib", &["consumer"]); + let aliases = + collect_internal_aliases(&[alias(current.clone(), "renamed_crate")], &index()); + let import = use_alias(current, &["renamed_crate", "Risk"], "RenamedRisk"); + + assert_alias_target(&import, &aliases, "src/lib.rs"); + } + + #[test] + fn other_extern_crates_do_not_become_internal_aliases() { + let mut declaration = reference(module("lib", &["consumer"]), &["api"]); + declaration.kind = ImportKind::ExternCrate; + declaration.binding = Some("other_crate".to_owned()); + + let aliases = collect_internal_aliases(&[declaration], &index()); + + assert!(aliases.is_empty()); + } + + #[test] + fn nested_alias_does_not_leak_into_sibling_module() { + let aliases = collect_internal_aliases( + &[alias(module("lib", &["consumer"]), "this_crate")], + &index(), + ); + + assert!(matches!( + resolve_reference( + &reference(module("lib", &["sibling"]), &["this_crate", "Risk"]), + &index(), + &aliases, + ), + ResolutionOutcome::Unresolved + )); } } diff --git a/tests/fixtures/self_crate_alias_project/.gitignore b/tests/fixtures/self_crate_alias_project/.gitignore new file mode 100644 index 0000000..80faede --- /dev/null +++ b/tests/fixtures/self_crate_alias_project/.gitignore @@ -0,0 +1,2 @@ +Cargo.lock +/target/ diff --git a/tests/fixtures/self_crate_alias_project/Cargo.toml b/tests/fixtures/self_crate_alias_project/Cargo.toml new file mode 100644 index 0000000..8632de8 --- /dev/null +++ b/tests/fixtures/self_crate_alias_project/Cargo.toml @@ -0,0 +1,7 @@ +[package] +name = "archunit-self-crate-alias-fixture" +version = "0.0.0" +edition = "2024" +publish = false + +[workspace] diff --git a/tests/fixtures/self_crate_alias_project/src/api.rs b/tests/fixtures/self_crate_alias_project/src/api.rs new file mode 100644 index 0000000..71f713e --- /dev/null +++ b/tests/fixtures/self_crate_alias_project/src/api.rs @@ -0,0 +1 @@ +pub struct Model; diff --git a/tests/fixtures/self_crate_alias_project/src/consumer.rs b/tests/fixtures/self_crate_alias_project/src/consumer.rs new file mode 100644 index 0000000..9bfee07 --- /dev/null +++ b/tests/fixtures/self_crate_alias_project/src/consumer.rs @@ -0,0 +1,5 @@ +extern crate self as local_crate; + +pub fn item(_model: local_crate::api::Model) -> local_crate::Item { + local_crate::Item +} diff --git a/tests/fixtures/self_crate_alias_project/src/lib.rs b/tests/fixtures/self_crate_alias_project/src/lib.rs new file mode 100644 index 0000000..9180289 --- /dev/null +++ b/tests/fixtures/self_crate_alias_project/src/lib.rs @@ -0,0 +1,4 @@ +pub mod api; +pub mod consumer; + +pub struct Item; diff --git a/tests/public_graph_extraction.rs b/tests/public_graph_extraction.rs index 7ec4fbf..00a595c 100644 --- a/tests/public_graph_extraction.rs +++ b/tests/public_graph_extraction.rs @@ -2,7 +2,7 @@ use std::{collections::BTreeSet, path::PathBuf}; use archunit::{ Edge, ExtractionDiagnosticKind, ImportKind, ProjectLocator, SourceOptions, - enumerate_source_files, extract_graph, locate_project_from, + enumerate_source_files, extract_dependencies, extract_graph, locate_project_from, }; fn fixture_project() -> archunit::CargoProject { @@ -12,6 +12,13 @@ fn fixture_project() -> archunit::CargoProject { .expect("fixture workspace should be discoverable") } +fn self_crate_alias_project() -> archunit::CargoProject { + let fixture = + PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/self_crate_alias_project"); + locate_project_from(&ProjectLocator::from_path(fixture)) + .expect("self-crate alias fixture should be discoverable") +} + #[test] fn every_discovered_file_has_exactly_one_canonical_self_edge() { let project = fixture_project(); @@ -135,3 +142,72 @@ fn development_sources_receive_self_edges_only_when_selected() { + 3 ); } + +#[test] +fn nested_self_crate_alias_resolves_source_references_and_graph_edges() { + let project = self_crate_alias_project(); + let dependencies = extract_dependencies(&project, SourceOptions::default()) + .expect("self-crate alias dependencies should extract"); + + for (path, target, kind, count) in [ + ("self", "src/lib.rs", ImportKind::ExternCrate, 1), + ( + "local_crate::Item", + "src/lib.rs", + ImportKind::PathReference, + 2, + ), + ( + "local_crate::api::Model", + "src/api.rs", + ImportKind::PathReference, + 1, + ), + ] { + let references = dependencies + .references() + .iter() + .filter(|reference| { + reference.source() == "src/consumer.rs" + && reference.referenced_path() == path + && reference.kind() == kind + }) + .collect::>(); + assert_eq!( + references.len(), + count, + "expected {count} {kind:?} references to {path}", + ); + for reference in references { + assert_eq!( + reference.internal_target(), + Some(target), + "{path} at line {} should resolve to {target}", + reference.line(), + ); + } + } + + let graph = extract_graph(&project, SourceOptions::default()) + .expect("self-crate alias graph should extract"); + assert!( + graph.diagnostics().is_empty(), + "unexpected extraction diagnostics: {:?}", + graph.diagnostics(), + ); + for (target, kinds) in [ + ( + "src/lib.rs", + vec![ImportKind::ExternCrate, ImportKind::PathReference], + ), + ("src/api.rs", vec![ImportKind::PathReference]), + ] { + let edge = graph + .graph() + .iter() + .find(|edge| edge.source == "src/consumer.rs" && edge.target == target) + .unwrap_or_else(|| panic!("expected consumer-to-{target} edge")); + assert!(!edge.external); + assert_eq!(edge.import_kinds.iter().collect::>(), kinds); + } +}