use std::collections::BTreeMap;
use critpath_core::UnitKind;
use crate::error::{ParseError, UnitDescription};
use crate::metadata::PackageIndex;
use crate::timings::{TimingReport, TimingTarget, TimingUnit};
use crate::verbose::{Invocation, Role, VerboseLog};
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[non_exhaustive]
pub enum MatchMethod {
Manifest,
RegistryPath,
BuildDirectory,
CrateName,
Directory,
Features,
StartOrder,
SoleCandidate,
}
impl MatchMethod {
#[must_use]
pub const fn as_str(self) -> &'static str {
match self {
Self::Manifest => "manifest",
Self::RegistryPath => "registry-path",
Self::BuildDirectory => "build-directory",
Self::CrateName => "crate-name",
Self::Directory => "directory",
Self::Features => "features",
Self::StartOrder => "start-order",
Self::SoleCandidate => "sole-candidate",
}
}
#[must_use]
pub const fn is_exact(self) -> bool {
matches!(
self,
Self::Manifest | Self::RegistryPath | Self::BuildDirectory
)
}
}
pub(crate) struct Pairing {
pub(crate) invocation: usize,
pub(crate) unit: usize,
pub(crate) method: MatchMethod,
}
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord)]
enum Group {
Library,
BuildScriptCompile,
BuildScriptRun,
Named(String),
}
pub(crate) fn pair(
log: &VerboseLog,
report: &TimingReport,
packages: Option<&PackageIndex>,
) -> Result<Vec<Pairing>, ParseError> {
let mut index: BTreeMap<(Group, String), Vec<usize>> = BTreeMap::new();
for (position, unit) in report.units.iter().enumerate() {
let group = group_of_unit(&unit.target);
index
.entry((group.clone(), normalise(&unit.package)))
.or_default()
.push(position);
if let TimingTarget::Named { name, .. } = &unit.target {
let key = (group, normalise(name));
let slot = index.entry(key).or_default();
if !slot.contains(&position) {
slot.push(position);
}
}
}
let by_artifact: BTreeMap<&str, &Invocation> = log
.invocations
.iter()
.filter(|i| i.role == Role::Compile)
.filter_map(|i| Some((i.extra_filename.as_deref()?, i)))
.collect();
let mut claimed = vec![false; report.units.len()];
let mut pairings: Vec<Option<Pairing>> = Vec::with_capacity(log.invocations.len());
for (position, invocation) in log.invocations.iter().enumerate() {
let group = group_of_invocation(invocation);
let identity = identity_of(invocation, &by_artifact);
let mut found = None;
for (method, name, version) in candidates(invocation, identity, packages) {
let Some(pool) = index.get(&(group.clone(), normalise(&name))) else {
continue;
};
let available: Vec<usize> = pool
.iter()
.copied()
.filter(|&i| claimed.get(i) == Some(&false))
.collect();
if let Some((unit, refined)) =
choose(&available, &report.units, identity, version.as_deref())
{
found = Some(Pairing {
invocation: position,
unit,
method: refined.unwrap_or(method),
});
break;
}
}
if let Some(pairing) = &found {
if let Some(slot) = claimed.get_mut(pairing.unit) {
*slot = true;
}
}
pairings.push(found);
}
resolve_sole_candidates(log, report, &mut pairings, &mut claimed);
let in_log: Vec<UnitDescription> = log
.invocations
.iter()
.zip(pairings.iter())
.filter(|(_, pairing)| pairing.is_none())
.map(|(invocation, _)| {
describe_invocation(invocation, identity_of(invocation, &by_artifact), packages)
})
.collect();
let in_report: Vec<UnitDescription> = report
.units
.iter()
.enumerate()
.filter(|(i, _)| claimed.get(*i) != Some(&true))
.map(|(_, unit)| describe_unit(unit))
.collect();
if !in_log.is_empty() || !in_report.is_empty() {
return Err(ParseError::UnmatchedUnits {
in_log,
in_report,
had_metadata: packages.is_some(),
});
}
Ok(pairings.into_iter().flatten().collect())
}
fn choose(
available: &[usize],
units: &[TimingUnit],
invocation: &Invocation,
version: Option<&str>,
) -> Option<(usize, Option<MatchMethod>)> {
if available.is_empty() {
return None;
}
let narrowed: Vec<usize> = match version {
Some(version) => {
let same: Vec<usize> = available
.iter()
.copied()
.filter(|&i| units.get(i).is_some_and(|u| u.version == version))
.collect();
if same.is_empty() {
return None;
}
same
}
None => available.to_vec(),
};
if let [only] = narrowed.as_slice() {
return Some((*only, None));
}
let same_features: Vec<usize> = narrowed
.iter()
.copied()
.filter(|&i| {
units
.get(i)
.is_some_and(|u| u.features == invocation.features)
})
.collect();
if let [only] = same_features.as_slice() {
return Some((*only, Some(MatchMethod::Features)));
}
narrowed
.first()
.map(|&i| (i, Some(MatchMethod::StartOrder)))
}
fn resolve_sole_candidates(
log: &VerboseLog,
report: &TimingReport,
pairings: &mut [Option<Pairing>],
claimed: &mut [bool],
) {
let outstanding: Vec<usize> = pairings
.iter()
.enumerate()
.filter(|(_, pairing)| pairing.is_none())
.map(|(i, _)| i)
.collect();
if outstanding.is_empty() {
return;
}
let mut by_group: BTreeMap<Group, (Vec<usize>, Vec<usize>)> = BTreeMap::new();
for position in outstanding {
if let Some(invocation) = log.invocations.get(position) {
by_group
.entry(group_of_invocation(invocation))
.or_default()
.0
.push(position);
}
}
for (position, unit) in report.units.iter().enumerate() {
if claimed.get(position) == Some(&true) {
continue;
}
by_group
.entry(group_of_unit(&unit.target))
.or_default()
.1
.push(position);
}
for (invocations, units) in by_group.into_values() {
let ([invocation], [unit]) = (invocations.as_slice(), units.as_slice()) else {
continue;
};
if let Some(slot) = pairings.get_mut(*invocation) {
*slot = Some(Pairing {
invocation: *invocation,
unit: *unit,
method: MatchMethod::SoleCandidate,
});
}
if let Some(slot) = claimed.get_mut(*unit) {
*slot = true;
}
}
}
fn candidates(
invocation: &Invocation,
identity: &Invocation,
packages: Option<&PackageIndex>,
) -> Vec<(MatchMethod, String, Option<String>)> {
let mut out: Vec<(MatchMethod, String, Option<String>)> = Vec::new();
let mut push = |method, name: &str, version: Option<String>| {
if name.is_empty() {
return;
}
out.push((method, name.to_owned(), version));
};
if let Some((name, version)) = manifest_package(identity, packages) {
push(MatchMethod::Manifest, &name, Some(version));
}
if let Some(package) = &identity.registry_package {
push(
MatchMethod::RegistryPath,
&package.name,
Some(package.version.clone()),
);
}
if let Some(package) = &invocation.run_package {
push(MatchMethod::BuildDirectory, package, None);
}
push(MatchMethod::CrateName, &invocation.crate_name, None);
if let Some(package) = &identity.directory_package {
push(MatchMethod::Directory, package, None);
}
out.dedup_by(|a, b| a.1 == b.1 && a.2 == b.2);
out
}
fn group_of_unit(target: &TimingTarget) -> Group {
match target {
TimingTarget::Library => Group::Library,
TimingTarget::BuildScriptCompile => Group::BuildScriptCompile,
TimingTarget::BuildScriptRun => Group::BuildScriptRun,
TimingTarget::Named { kind, .. } => Group::Named(kind.clone()),
TimingTarget::Other(text) => Group::Named(text.clone()),
}
}
fn group_of_invocation(invocation: &Invocation) -> Group {
if invocation.role == Role::BuildScriptRun {
return Group::BuildScriptRun;
}
match invocation.kind {
UnitKind::BuildScriptCompile => Group::BuildScriptCompile,
UnitKind::Bin => Group::Named("bin".to_owned()),
UnitKind::Test => Group::Named("test".to_owned()),
_ => Group::Library,
}
}
fn normalise(name: &str) -> String {
name.replace('-', "_")
}
fn identity_of<'a>(
invocation: &'a Invocation,
by_artifact: &BTreeMap<&str, &'a Invocation>,
) -> &'a Invocation {
if invocation.role != Role::BuildScriptRun {
return invocation;
}
invocation
.run_artifact
.as_deref()
.and_then(|hash| by_artifact.get(hash).copied())
.unwrap_or(invocation)
}
fn manifest_package(
invocation: &Invocation,
packages: Option<&PackageIndex>,
) -> Option<(String, String)> {
if invocation.source_path.is_empty() {
return None;
}
packages?
.package_at(&invocation.source_path)
.map(|(name, version)| (name.to_owned(), version.to_owned()))
}
fn describe_invocation(
invocation: &Invocation,
identity: &Invocation,
packages: Option<&PackageIndex>,
) -> UnitDescription {
let (package, version) = manifest_package(identity, packages)
.or_else(|| {
identity
.registry_package
.as_ref()
.map(|p| (p.name.clone(), p.version.clone()))
})
.or_else(|| {
invocation
.run_package
.clone()
.map(|name| (name, String::new()))
})
.unwrap_or_else(|| (invocation.crate_name.clone(), String::new()));
UnitDescription {
package,
version,
target: invocation.kind.as_str().to_owned(),
position: invocation.position.saturating_add(1),
}
}
fn describe_unit(unit: &TimingUnit) -> UnitDescription {
UnitDescription {
package: unit.package.clone(),
version: unit.version.clone(),
target: unit.target.label().to_owned(),
position: unit.position.saturating_add(1),
}
}