pub mod aliases;
pub mod calls;
pub mod context;
pub mod cross_repo;
pub mod http_calls;
pub mod non_calls;
pub mod overrides;
#[cfg(test)]
mod test_utils;
use anyhow::Result;
use rayon::prelude::*;
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use tracing::info;
use uuid::Uuid;
use crate::config::Config;
use crate::db::graph::{EntityMappings, GraphDb, RepoQueryExt, UpsertExt};
use crate::models::{EntityKind, ImportScope, ReferenceIntent, RelationshipType, ResolutionEntity};
pub use context::{ResolutionContext, RunMetrics};
pub use cross_repo::link_cross_repo_dependencies;
pub use http_calls::link_http_calls;
pub async fn resolve_and_save_relationships(
entities: &mut [ResolutionEntity],
graph_db: &GraphDb,
cfg: &Config,
) -> Result<RunMetrics> {
if !entities.is_empty() {
let auto_deps = graph_db
.find_repo_dependencies(&cfg.repo_name, 3)
.await
.unwrap_or_default();
let mut repos_to_load = vec![cfg.repo_name.clone()];
repos_to_load.extend(cfg.dependency_repos.clone());
repos_to_load.extend(auto_deps.clone());
repos_to_load.sort();
repos_to_load.dedup();
info!("Loading global entity context from Neo4j for relationship resolution...");
let mappings = graph_db
.load_entity_mappings(&repos_to_load, &cfg.repo_name)
.await?;
if !cfg.dependency_repos.is_empty() || !auto_deps.is_empty() {
info!(
"Cross-repository resolution enabled: {} local repo(s) + {} manual dep(s) + {} auto dep(s)",
1,
cfg.dependency_repos.len(),
auto_deps.len()
);
}
info!(
"Resolving reference intents with global context ({} FQNs, {} names)...",
mappings.fqn_to_uuid.len(),
mappings.name_to_uuids.len()
);
let metrics = resolve_reference_intents_with_mappings(entities, mappings);
info!("Creating typed relationships in Neo4j...");
graph_db.upsert_relationships(entities).await?;
Ok(metrics)
} else {
Ok(RunMetrics::new(0))
}
}
pub fn print_run_summary(metrics: &RunMetrics) {
use std::sync::atomic::Ordering;
let entities = metrics.entities_indexed.load(Ordering::Relaxed);
let resolved = metrics.references_resolved.load(Ordering::Relaxed);
let ambiguous = metrics.references_ambiguous_skipped.load(Ordering::Relaxed);
let unresolved = metrics.references_unresolved.load(Ordering::Relaxed);
info!(
"Indexing complete: {} entities, {} references resolved, {} ambiguous skipped, {} unresolved",
entities, resolved, ambiguous, unresolved
);
if ambiguous > 0 {
info!(
"Ambiguous references skipped: {} (set RUST_LOG=debug for details)",
ambiguous
);
}
}
fn resolve_vcl_include(
path: &str,
file_path: &str,
repo_name: &str,
fqn_to_uuid: &HashMap<String, Uuid>,
) -> Option<Uuid> {
let stripped_path = path.strip_prefix('/').unwrap_or(path);
let root_fqn = format!("vcl:{}:{}", repo_name, stripped_path);
if let Some(&uuid) = fqn_to_uuid.get(&root_fqn) {
return Some(uuid);
}
let parent_dir = std::path::Path::new(file_path)
.parent()
.and_then(|p| p.to_str())
.unwrap_or("");
let relative_path = if parent_dir.is_empty() {
path.to_string()
} else {
format!("{}/{}", parent_dir, stripped_path)
};
let relative_fqn = format!("vcl:{}:{}", repo_name, relative_path);
if let Some(&uuid) = fqn_to_uuid.get(&relative_fqn) {
return Some(uuid);
}
let file_name = std::path::Path::new(path)
.file_name()
.and_then(|n| n.to_str())
.unwrap_or(path);
let vcl_prefix = format!("vcl:{}", repo_name);
let candidates: Vec<(&str, Uuid)> = fqn_to_uuid
.iter()
.filter(|(fqn, _)| fqn.starts_with(&vcl_prefix) && fqn.ends_with(file_name))
.map(|(fqn, uuid)| (fqn.as_str(), *uuid))
.collect();
calls::pick_deterministic_candidate(&candidates, None)
}
fn build_extends_map(entities: &[ResolutionEntity]) -> HashMap<String, Vec<String>> {
entities
.iter()
.flat_map(|e| {
let parents: Vec<String> = e
.reference_intents
.iter()
.filter_map(|i| {
if let ReferenceIntent::Extends { parent, .. } = i {
Some(parent.clone())
} else {
None
}
})
.collect();
if parents.is_empty() {
return Vec::new();
}
let mut keys = vec![e.name.clone()];
if e.fqn != e.name {
keys.push(e.fqn.clone());
}
keys.into_iter().map(|key| (key, parents.clone())).collect()
})
.collect()
}
struct LookupMaps {
fqn_to_uuid: HashMap<String, Uuid>,
name_to_uuids: HashMap<String, Vec<Uuid>>,
uuid_to_file: HashMap<Uuid, String>,
uuid_to_arg_count: HashMap<Uuid, usize>,
uuid_to_fqn: HashMap<Uuid, String>,
uuid_to_kind: HashMap<Uuid, EntityKind>,
uuid_to_name: HashMap<Uuid, String>,
extends_map: HashMap<String, Vec<String>>,
alias_map: HashMap<Uuid, Uuid>,
class_member_index: HashMap<String, Vec<(String, Uuid)>>,
fqn_overloads: HashMap<String, Vec<Uuid>>,
dependency_uuids: HashSet<Uuid>,
local_type_names: HashSet<String>,
import_scopes: HashMap<String, Arc<ImportScope>>,
}
impl LookupMaps {
fn build(entities: &[ResolutionEntity], mappings: EntityMappings) -> Self {
let EntityMappings {
mut fqn_to_uuid,
mut name_to_uuids,
dependency_uuids,
mut local_type_names,
} = mappings;
local_type_names.extend(
entities
.iter()
.filter(|e| {
crate::cli_tools::kinds::TYPE_KINDS.contains(&e.kind.to_string().as_str())
})
.map(|e| e.name.clone()),
);
let uuid_to_file: HashMap<Uuid, String> = entities
.iter()
.map(|e| (e.uuid, e.file_path.clone()))
.collect();
let uuid_to_arg_count: HashMap<Uuid, usize> = entities
.iter()
.filter_map(|e| {
let signature = e.signature.as_deref()?;
let count = match overrides::declared_call_arity(signature, &e.name, &e.file_path) {
overrides::DeclaredArity::Fixed(count) => Some(count),
overrides::DeclaredArity::Variable => None,
overrides::DeclaredArity::Unparsed => count_params_from_signature(signature),
};
count.map(|c| (e.uuid, c))
})
.collect();
let mut fqn_overloads: HashMap<String, Vec<Uuid>> = HashMap::new();
for e in entities {
fqn_overloads.entry(e.fqn.clone()).or_default().push(e.uuid);
}
fqn_overloads.retain(|_, uuids| uuids.len() > 1);
for uuids in fqn_overloads.values_mut() {
uuids.sort();
}
let uuid_to_fqn: HashMap<Uuid, String> =
entities.iter().map(|e| (e.uuid, e.fqn.clone())).collect();
let uuid_to_kind: HashMap<Uuid, EntityKind> =
entities.iter().map(|e| (e.uuid, e.kind.clone())).collect();
let uuid_to_name: HashMap<Uuid, String> =
entities.iter().map(|e| (e.uuid, e.name.clone())).collect();
let extends_map = build_extends_map(entities);
let import_scopes: HashMap<String, Arc<ImportScope>> = entities
.iter()
.filter_map(|e| Some((e.file_path.clone(), Arc::clone(e.import_scope.as_ref()?))))
.collect();
for e in entities.iter() {
fqn_to_uuid.insert(e.fqn.clone(), e.uuid);
name_to_uuids
.entry(e.name.clone())
.or_default()
.push(e.uuid);
}
for uuids in name_to_uuids.values_mut() {
uuids.sort();
uuids.dedup();
}
let alias_map = aliases::build_alias_map(entities, &uuid_to_file);
let class_member_index = context::build_class_member_index(&fqn_to_uuid);
Self {
fqn_to_uuid,
name_to_uuids,
uuid_to_file,
uuid_to_arg_count,
uuid_to_fqn,
uuid_to_kind,
uuid_to_name,
extends_map,
alias_map,
class_member_index,
fqn_overloads,
dependency_uuids,
local_type_names,
import_scopes,
}
}
fn context(&self) -> ResolutionContext<'_> {
ResolutionContext {
fqn_to_uuid: &self.fqn_to_uuid,
name_to_uuids: &self.name_to_uuids,
uuid_to_file: &self.uuid_to_file,
extends_map: &self.extends_map,
uuid_to_arg_count: Some(&self.uuid_to_arg_count),
uuid_to_fqn: Some(&self.uuid_to_fqn),
uuid_to_kind: Some(&self.uuid_to_kind),
uuid_to_name: Some(&self.uuid_to_name),
class_member_index: &self.class_member_index,
fqn_overloads: &self.fqn_overloads,
dependency_uuids: &self.dependency_uuids,
local_type_names: &self.local_type_names,
import_scopes: &self.import_scopes,
alias_map: &self.alias_map,
}
}
}
pub fn resolve_reference_intents_with_context(
entities: &mut [ResolutionEntity],
fqn_to_uuid: HashMap<String, Uuid>,
name_to_uuids: HashMap<String, Vec<Uuid>>,
) -> RunMetrics {
resolve_reference_intents_with_mappings(
entities,
EntityMappings {
fqn_to_uuid,
name_to_uuids,
..EntityMappings::default()
},
)
}
pub fn resolve_reference_intents_with_mappings(
entities: &mut [ResolutionEntity],
mappings: EntityMappings,
) -> RunMetrics {
let maps = LookupMaps::build(entities, mappings);
let ctx = maps.context();
let metrics = RunMetrics::new(entities.len() as u64);
entities.par_iter_mut().for_each(|entity| {
let reference_intents = entity.reference_intents.clone();
let mut seen: HashSet<(Uuid, RelationshipType)> = HashSet::new();
for intent in &reference_intents {
let (uuid, rel_type) = resolve_intent(intent, entity, &ctx, &metrics);
let Some(uuid) = uuid.map(|u| maps.alias_map.get(&u).copied().unwrap_or(u)) else {
continue;
};
push_relationship(uuid, rel_type, entity, &ctx, &mut seen);
}
});
overrides::link_method_overrides(entities);
metrics
}
fn push_relationship(
uuid: Uuid,
rel_type: RelationshipType,
entity: &mut ResolutionEntity,
ctx: &ResolutionContext<'_>,
seen: &mut HashSet<(Uuid, RelationshipType)>,
) {
if rel_type == RelationshipType::References
&& let Some(uuid_to_fqn) = ctx.uuid_to_fqn
&& let Some(target_fqn) = uuid_to_fqn.get(&uuid)
&& target_fqn.starts_with(&format!("{}.", entity.fqn))
{
return;
}
if seen.insert((uuid, rel_type)) {
entity.relationships.push((uuid, rel_type));
}
}
fn caller_scope(entity: &ResolutionEntity) -> calls::CallerScope<'_> {
calls::CallerScope {
file_path: &entity.file_path,
enclosing_class: entity.enclosing_class.as_deref(),
enclosing_class_fqn: entity.enclosing_class_fqn.as_deref(),
is_rust: matches!(
entity.kind,
EntityKind::RustFunction
| EntityKind::RustMethod
| EntityKind::RustConstant
| EntityKind::RustStatic
| EntityKind::RustMacroDef
),
is_javascript: std::path::Path::new(&entity.file_path)
.extension()
.and_then(|extension| extension.to_str())
.is_some_and(|extension| {
matches!(
extension,
"js" | "jsx" | "mjs" | "cjs" | "ts" | "tsx" | "mts" | "cts"
)
}),
}
}
fn resolve_intent(
intent: &ReferenceIntent,
entity: &ResolutionEntity,
ctx: &ResolutionContext<'_>,
metrics: &RunMetrics,
) -> (Option<Uuid>, RelationshipType) {
match intent {
ReferenceIntent::Call {
method,
receiver,
arg_count,
..
} => (
resolve_call(method, receiver.as_deref(), *arg_count, entity, ctx),
RelationshipType::Calls,
),
ReferenceIntent::MemberAccess {
member, receiver, ..
} => resolve_member_access(member, receiver, entity, ctx),
ReferenceIntent::Extends { parent, .. } => (
resolve_typed(parent, entity, ctx, metrics),
RelationshipType::Extends,
),
ReferenceIntent::Implements { interface, .. } => (
resolve_typed(interface, entity, ctx, metrics),
RelationshipType::Implements,
),
ReferenceIntent::TypeReference { type_name, .. } => (
resolve_typed(type_name, entity, ctx, metrics),
RelationshipType::References,
),
ReferenceIntent::ValueReference { value_name, .. } => (
resolve_plain(value_name, entity, ctx, metrics),
RelationshipType::References,
),
ReferenceIntent::DomElementReference { element_id, .. } => (
resolve_web_reference(element_id, EntityKind::HtmlId, entity, ctx, metrics),
RelationshipType::ReferencesDOM,
),
ReferenceIntent::CssClassUsage { class_name, .. } => (
resolve_web_reference(class_name, EntityKind::CssClass, entity, ctx, metrics),
RelationshipType::UsesCSSClass,
),
ReferenceIntent::HtmlFileImport { file_path, .. } => (
ctx.fqn_to_uuid.get(file_path).copied(),
RelationshipType::ImportsScript,
),
ReferenceIntent::CssFileImport { file_path, .. } => (
ctx.fqn_to_uuid.get(file_path).copied(),
RelationshipType::ImportsStylesheet,
),
ReferenceIntent::RustMacroCall { macro_name, .. } => (
resolve_plain(macro_name, entity, ctx, metrics),
RelationshipType::MacroCalls,
),
ReferenceIntent::VclSubCall { sub_name, .. } => {
let call_intent = crate::models::CallIntent {
method: sub_name.clone(),
receiver: None,
line: 0,
arg_count: None,
};
let resolved =
calls::resolve_single_call_intent(&call_intent, &caller_scope(entity), ctx);
(resolved, RelationshipType::Calls)
}
ReferenceIntent::VclBackendRef { backend_name, .. } => (
resolve_plain(backend_name, entity, ctx, metrics),
RelationshipType::UsesBackend,
),
ReferenceIntent::VclProbeRef { probe_name, .. } => (
resolve_plain(probe_name, entity, ctx, metrics),
RelationshipType::UsesProbe,
),
ReferenceIntent::VclAclRef { acl_name, .. } => (
resolve_plain(acl_name, entity, ctx, metrics),
RelationshipType::UsesAcl,
),
ReferenceIntent::VclInclude { path, .. } => {
let repo_name = entity.fqn.split(':').nth(1).unwrap_or("");
let resolved_uuid =
resolve_vcl_include(path, &entity.file_path, repo_name, ctx.fqn_to_uuid);
(resolved_uuid, RelationshipType::Includes)
}
ReferenceIntent::VclVmodImport { module, .. } => (
resolve_plain(module, entity, ctx, metrics),
RelationshipType::ImportsVmod,
),
ReferenceIntent::VclUnusedRef { name, .. } => (
resolve_plain(name, entity, ctx, metrics),
RelationshipType::DeclaredUnused,
),
ReferenceIntent::RoutesTo { handler, .. } => (Some(*handler), RelationshipType::RoutesTo),
}
}
fn resolve_call(
method: &str,
receiver: Option<&str>,
arg_count: Option<usize>,
entity: &ResolutionEntity,
ctx: &ResolutionContext<'_>,
) -> Option<Uuid> {
let call_intent = crate::models::CallIntent {
method: method.to_string(),
receiver: receiver.map(str::to_string),
line: 0,
arg_count: arg_count.filter(|_| overrides::call_arity_is_binding(&entity.file_path)),
};
calls::resolve_single_call_intent(&call_intent, &caller_scope(entity), ctx)
.map(|uuid| calls::redirect_class_call_to_constructor(uuid, &entity.file_path, ctx))
}
fn resolve_member_access(
member: &str,
receiver: &str,
entity: &ResolutionEntity,
ctx: &ResolutionContext<'_>,
) -> (Option<Uuid>, RelationshipType) {
let access = crate::models::CallIntent {
method: member.to_string(),
receiver: Some(receiver.to_string()),
line: 0,
arg_count: None,
};
let resolved = calls::resolve_single_call_intent(&access, &caller_scope(entity), ctx);
let callable = resolved
.and_then(|uuid| ctx.uuid_to_kind.and_then(|kinds| kinds.get(&uuid)))
.is_some_and(|kind| matches!(kind, EntityKind::Method | EntityKind::Function));
let rel_type = if callable {
RelationshipType::Calls
} else {
RelationshipType::References
};
(resolved, rel_type)
}
fn resolve_plain(
name: &str,
entity: &ResolutionEntity,
ctx: &ResolutionContext<'_>,
metrics: &RunMetrics,
) -> Option<Uuid> {
non_calls::resolve_non_call_reference(
name,
&entity.file_path,
entity.enclosing_class.as_deref(),
ctx.fqn_to_uuid,
ctx.name_to_uuids,
ctx.uuid_to_file,
ctx.uuid_to_fqn,
metrics,
)
}
fn resolve_web_reference(
name: &str,
preferred: EntityKind,
entity: &ResolutionEntity,
ctx: &ResolutionContext<'_>,
metrics: &RunMetrics,
) -> Option<Uuid> {
non_calls::resolve_web_reference(
name,
preferred,
&entity.file_path,
ctx.name_to_uuids,
ctx.uuid_to_file,
ctx.uuid_to_kind,
metrics,
)
}
fn resolve_typed(
name: &str,
entity: &ResolutionEntity,
ctx: &ResolutionContext<'_>,
metrics: &RunMetrics,
) -> Option<Uuid> {
if let Some(pin) = calls::pinned_type(name, &entity.file_path, ctx) {
let target = match pin {
calls::TypePin::Indexed(type_fqn) => ctx.fqn_to_uuid.get(&type_fqn).copied(),
calls::TypePin::External => None,
};
let counter = if target.is_some() {
&metrics.references_resolved
} else {
&metrics.references_unresolved
};
counter.fetch_add(1, std::sync::atomic::Ordering::Relaxed);
return target;
}
non_calls::resolve_non_call_reference_typed(
name,
&entity.file_path,
entity.enclosing_class.as_deref(),
ctx.fqn_to_uuid,
ctx.name_to_uuids,
ctx.uuid_to_file,
ctx.uuid_to_kind,
ctx.uuid_to_fqn,
metrics,
)
}
pub fn resolve_reference_intents(entities: &mut [ResolutionEntity]) -> RunMetrics {
let fqn_to_uuid: HashMap<String, Uuid> =
entities.iter().map(|e| (e.fqn.clone(), e.uuid)).collect();
let mut name_to_uuids: HashMap<String, Vec<Uuid>> = HashMap::new();
for e in entities.iter() {
name_to_uuids
.entry(e.name.clone())
.or_default()
.push(e.uuid);
}
resolve_reference_intents_with_context(entities, fqn_to_uuid, name_to_uuids)
}
fn count_params_from_signature(sig: &str) -> Option<usize> {
let open = sig.rfind('(')?;
let close = sig.rfind(')')?;
if close <= open {
return None;
}
let params = sig[open + 1..close].trim();
if params.is_empty() {
Some(0)
} else {
Some(params.chars().filter(|&c| c == ',').count() + 1)
}
}
#[cfg(test)]
mod tests {
use super::test_utils::*;
use super::*;
use crate::models::{ReferenceIntent, RelationshipType, ResolutionEntity};
#[test]
fn test_resolve_deduplication() {
let mut caller = mock_resolution_entity("A", "A", None);
let callee = mock_resolution_entity("B", "B", None);
caller.reference_intents.push(ReferenceIntent::Call {
method: "B".to_string(),
receiver: None,
line: 1,
arg_count: None,
});
caller.reference_intents.push(ReferenceIntent::Call {
method: "B".to_string(),
receiver: None,
line: 2,
arg_count: None,
});
let mut entities = vec![caller, callee];
resolve_reference_intents(&mut entities);
assert_eq!(entities[0].relationships.len(), 1);
}
#[test]
fn test_routes_to_binds_the_handler_uuid() {
let handler =
mock_resolution_entity("read", "com.a.ItemsResource.read", Some("ItemsResource"));
let homonym = mock_resolution_entity("read", "com.b.Other.read", Some("Other"));
let mut endpoint = mock_resolution_entity_with_kind(
"GET /items",
"com.a.ItemsResource.read[GET /items]",
Some("ItemsResource"),
"test/file.java",
EntityKind::HttpEndpoint,
);
endpoint.reference_intents.push(ReferenceIntent::RoutesTo {
handler: handler.uuid,
line: 3,
});
let handler_uuid = handler.uuid;
let mut entities = vec![endpoint, homonym, handler];
resolve_reference_intents(&mut entities);
assert_eq!(
entities[0].relationships,
vec![(handler_uuid, RelationshipType::RoutesTo)]
);
}
#[test]
fn test_resolve_context_deduplication() {
let mut caller = mock_resolution_entity("caller", "caller", None);
caller.reference_intents.push(ReferenceIntent::Call {
method: "unique_func".to_string(),
receiver: None,
line: 1,
arg_count: None,
});
let entity =
mock_resolution_entity_at("unique_func", "unique_func", None, "test/unique.java");
let uuid = entity.uuid;
let fqn_to_uuid = HashMap::from([("unique_func".to_string(), uuid)]);
let name_to_uuids = HashMap::from([("unique_func".to_string(), vec![uuid])]);
let mut batch = vec![caller, entity];
resolve_reference_intents_with_context(&mut batch, fqn_to_uuid, name_to_uuids);
assert_eq!(batch[0].relationships.len(), 1);
assert_eq!(batch[0].relationships[0].0, uuid);
}
#[test]
fn test_parallel_resolution_deterministic() {
let mut entities: Vec<ResolutionEntity> = (0..50)
.map(|i| {
let mut e = mock_resolution_entity_with_kind(
&format!("Entity{i}"),
&format!("com.example.Entity{i}"),
Some(&format!("Class{i}")),
"test/file.java",
EntityKind::Class,
);
if i % 2 == 0 && i + 1 < 50 {
e.reference_intents.push(ReferenceIntent::TypeReference {
type_name: format!("Entity{}", i + 1),
line: 1,
});
}
e
})
.collect();
resolve_reference_intents(&mut entities);
for i in (0..50).step_by(2) {
if i + 1 < 50 {
let caller = &entities[i];
let callee = &entities[i + 1];
assert!(
caller
.relationships
.contains(&(callee.uuid, RelationshipType::References))
);
}
}
}
fn relationship_set(
entities: &[ResolutionEntity],
) -> HashSet<(String, Uuid, RelationshipType)> {
entities
.iter()
.flat_map(|e| {
e.relationships
.iter()
.map(move |(uuid, rel)| (e.fqn.clone(), *uuid, *rel))
})
.collect()
}
fn assert_resolution_deterministic(
entities: &[ResolutionEntity],
runs: usize,
) -> HashSet<(String, Uuid, RelationshipType)> {
let mut reference: Option<HashSet<(String, Uuid, RelationshipType)>> = None;
for run in 0..runs {
let mut batch = entities.to_vec();
resolve_reference_intents(&mut batch);
let got = relationship_set(&batch);
match &reference {
None => reference = Some(got),
Some(expected) => assert_eq!(
&got, expected,
"run {run} produced a different relationship set: HashMap \
iteration order leaked into the resolution result"
),
}
}
reference.expect("at least one run is required")
}
#[test]
fn test_resolution_deterministic_under_fqn_substring_collisions() {
let mut entities: Vec<ResolutionEntity> = [
("pkg.alpha.Widget.render", "src/alpha.rs"),
("pkg.beta.Widget.render", "src/beta.rs"),
("pkg.gamma.delta.Widget.render", "src/gamma.rs"),
]
.into_iter()
.map(|(fqn, file)| {
mock_resolution_entity_with_kind(
"render",
fqn,
Some("Widget"),
file,
EntityKind::Method,
)
})
.collect();
let expected_target = entities[0].uuid;
let mut caller = mock_resolution_entity_with_kind(
"caller",
"pkg.app.caller",
None,
"src/app.rs",
EntityKind::Method,
);
caller.reference_intents.push(ReferenceIntent::Call {
method: "render".to_string(),
receiver: Some("widget".to_string()),
line: 1,
arg_count: None,
});
entities.push(caller);
let rels = assert_resolution_deterministic(&entities, 64);
assert_eq!(
rels,
HashSet::from([(
"pkg.app.caller".to_string(),
expected_target,
RelationshipType::Calls
)]),
"an ambiguous receiver match must resolve to the lexicographically \
smallest matching FQN"
);
}
#[test]
fn test_resolution_prefers_same_file_candidate_in_fqn_scan() {
let mut entities: Vec<ResolutionEntity> = [
("pkg.alpha.Widget.render", "src/alpha.rs"),
("pkg.beta.Widget.render", "src/beta.rs"),
("pkg.gamma.delta.Widget.render", "src/gamma.rs"),
]
.into_iter()
.map(|(fqn, file)| {
mock_resolution_entity_with_kind(
"render",
fqn,
Some("Widget"),
file,
EntityKind::Method,
)
})
.collect();
let expected_target = entities[1].uuid;
let mut caller = mock_resolution_entity_with_kind(
"caller",
"pkg.app.caller",
None,
"src/beta.rs",
EntityKind::Method,
);
caller.reference_intents.push(ReferenceIntent::Call {
method: "render".to_string(),
receiver: Some("widget".to_string()),
line: 1,
arg_count: None,
});
entities.push(caller);
let rels = assert_resolution_deterministic(&entities, 64);
assert_eq!(
rels,
HashSet::from([(
"pkg.app.caller".to_string(),
expected_target,
RelationshipType::Calls
)]),
"a candidate declared in the caller's own file must win over the FQN ordering"
);
}
#[test]
fn test_resolution_deterministic_under_class_suffix_collisions() {
let mut entities: Vec<ResolutionEntity> = [
("pkg.alpha.ChatModel", "src/alpha.rs"),
("pkg.beta.ChatModel", "src/beta.rs"),
("pkg.gamma.delta.ChatModel", "src/gamma.rs"),
]
.into_iter()
.map(|(fqn, file)| {
mock_resolution_entity_with_kind("ChatModel", fqn, None, file, EntityKind::Class)
})
.collect();
let mut run_methods: Vec<ResolutionEntity> = [
("pkg.alpha.ChatModel.run", "src/alpha.rs"),
("pkg.beta.ChatModel.run", "src/beta.rs"),
("pkg.gamma.delta.ChatModel.run", "src/gamma.rs"),
]
.into_iter()
.map(|(fqn, file)| {
mock_resolution_entity_with_kind(
"run",
fqn,
Some("ChatModel"),
file,
EntityKind::Method,
)
})
.collect();
let expected_target = run_methods[0].uuid;
entities.append(&mut run_methods);
let mut child = mock_resolution_entity_with_kind(
"Child",
"pkg.app.Child",
None,
"src/app.rs",
EntityKind::Class,
);
child.reference_intents.push(ReferenceIntent::Extends {
parent: "ChatModel".to_string(),
line: 1,
});
entities.push(child);
let mut caller = mock_resolution_entity_with_kind(
"caller",
"pkg.app.Child.caller",
Some("Child"),
"src/app.rs",
EntityKind::Method,
);
caller.reference_intents.push(ReferenceIntent::Call {
method: "run".to_string(),
receiver: Some("super".to_string()),
line: 1,
arg_count: None,
});
entities.push(caller);
let rels = assert_resolution_deterministic(&entities, 64);
assert_eq!(
rels,
HashSet::from([(
"pkg.app.Child.caller".to_string(),
expected_target,
RelationshipType::Calls
)]),
"an ambiguous class-suffix match must resolve to the \
lexicographically smallest matching class FQN"
);
}
#[test]
fn test_resolution_deterministic_under_vcl_basename_collisions() {
let mut entities: Vec<ResolutionEntity> = [
"vcl:myrepo:alpha/shared.vcl",
"vcl:myrepo:beta/shared.vcl",
"vcl:myrepo:gamma/delta/shared.vcl",
]
.into_iter()
.map(|fqn| {
mock_resolution_entity_with_kind(
"shared",
fqn,
None,
fqn.trim_start_matches("vcl:myrepo:"),
EntityKind::Function,
)
})
.collect();
let expected_target = entities[0].uuid;
let mut caller = mock_resolution_entity_with_kind(
"entry",
"vcl:myrepo:entry.vcl",
None,
"entry.vcl",
EntityKind::Function,
);
caller.reference_intents.push(ReferenceIntent::VclInclude {
path: "shared.vcl".to_string(),
line: 1,
});
entities.push(caller);
let rels = assert_resolution_deterministic(&entities, 64);
assert_eq!(
rels,
HashSet::from([(
"vcl:myrepo:entry.vcl".to_string(),
expected_target,
RelationshipType::Includes
)]),
"an ambiguous VCL include basename match must resolve to the \
lexicographically smallest matching FQN"
);
}
#[test]
fn test_parallel_resolution_deduplication() {
let mut caller = mock_resolution_entity("A", "A", None);
let callee = mock_resolution_entity("B", "B", None);
for i in 0..100 {
caller.reference_intents.push(ReferenceIntent::Call {
method: "B".to_string(),
receiver: None,
line: i,
arg_count: None,
});
}
let mut entities = vec![caller, callee];
resolve_reference_intents(&mut entities);
assert_eq!(entities[0].relationships.len(), 1);
}
#[test]
fn test_parallel_resolution_many_to_one() {
let callee = mock_resolution_entity_with_kind(
"Target",
"com.Target",
None,
"test/target.java",
EntityKind::Class,
);
let callee_uuid = callee.uuid;
let mut callers: Vec<ResolutionEntity> = (0..20)
.map(|i| {
let mut e =
mock_resolution_entity(&format!("Caller{i}"), &format!("com.Caller{i}"), None);
e.reference_intents.push(ReferenceIntent::TypeReference {
type_name: "Target".to_string(),
line: 1,
});
e
})
.collect();
let mut entities = vec![callee];
entities.append(&mut callers);
resolve_reference_intents(&mut entities);
for e in entities.iter().skip(1) {
assert_eq!(e.relationships.len(), 1);
assert_eq!(
e.relationships[0],
(callee_uuid, RelationshipType::References)
);
}
}
}