cargo-rail 0.31.1

Cargo-native Rust workspace engine for affected CI, Rust source-surface analysis, compiler reuse, dependency coherence, exact-SHA releases, and split/sync
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

//! Shared Cargo-domain impact evidence for conservative reverse propagation.

use std::collections::BTreeSet;

use cargo_metadata::{DependencyKind, PackageId};
use rustc_hash::FxHashMap;

/// Compilation domain affected in a dependent workspace package.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum ImpactDomain {
    /// The package output may change, so impact continues through its consumers.
    Build,
    /// Only tests, examples, and benches consume the changed dependency.
    Development,
}

/// Evidence that forced conservative propagation rather than a proven active edge.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub(crate) enum ImpactFallback {
    /// Cargo reported a dependency kind unknown to this version of cargo-rail.
    UnknownDependencyKind,
}

/// One semantic edge that propagates impact into a workspace package.
#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) struct ImpactStep {
    pub(crate) dependency: PackageId,
    pub(crate) dependent: PackageId,
    pub(crate) alias: String,
    pub(crate) kind: DependencyKind,
    pub(crate) target: Option<String>,
    pub(crate) optional: bool,
    pub(crate) uses_default_features: bool,
    pub(crate) features: Vec<String>,
    pub(crate) proc_macro: bool,
    pub(crate) host: bool,
    pub(crate) domain: ImpactDomain,
    pub(crate) fallbacks: Vec<ImpactFallback>,
}

/// Complete package impact for one dependency universe.
#[derive(Debug, Default)]
pub(crate) struct ImpactPropagation {
    /// Packages whose build output may change.
    pub(crate) build: BTreeSet<PackageId>,
    /// Packages affected only in tests, examples, and benches.
    pub(crate) development: BTreeSet<PackageId>,
    /// Deterministic changed package whose build-domain path first reached each package.
    pub(crate) build_origins: FxHashMap<PackageId, PackageId>,
    /// Deterministic changed package whose development-domain path first reached each package.
    pub(crate) development_origins: FxHashMap<PackageId, PackageId>,
    /// Deterministically ordered semantic propagation evidence.
    pub(crate) steps: Vec<ImpactStep>,
}

impl ImpactPropagation {
    pub(super) fn normalize(&mut self) {
        self.development.retain(|package| !self.build.contains(package));
        self.development_origins
            .retain(|package, _| !self.build_origins.contains_key(package));
        sort_steps(&mut self.steps);
    }
}

fn sort_steps(steps: &mut Vec<ImpactStep>) {
    steps.sort_by(|left, right| {
        (
            &left.dependent,
            left.domain,
            &left.dependency,
            &left.alias,
            dependency_kind_rank(left.kind),
            &left.target,
            &left.features,
        )
            .cmp(&(
                &right.dependent,
                right.domain,
                &right.dependency,
                &right.alias,
                dependency_kind_rank(right.kind),
                &right.target,
                &right.features,
            ))
    });
    steps.dedup();
}

const fn dependency_kind_rank(kind: DependencyKind) -> u8 {
    match kind {
        DependencyKind::Normal => 0,
        DependencyKind::Development => 1,
        DependencyKind::Build => 2,
        DependencyKind::Unknown => 3,
    }
}