finchie/depwiz - Change VMWXIDPEMIGIVB4YP4YKM2GFIO6O6J7HEYS5FNYPTUSQ3X5MWTMAC

Remove dependency on `guppy`

Probably the right decision in the long-term, as the unit-graph data makes it redundant. This change also makes the graph easier to work with, and hopefully will better support existing and future annotations.

Created by finchie on May 9, 2024

VMWXIDPEMIGIVB4YP4YKM2GFIO6O6J7HEYS5FNYPTUSQ3X5MWTMAC

Dependencies

In channels

main

Change contents

Replacement in src/visualize/treemap.rs at line 1 [3.35]

B:BD[3.35] → [4.0:28]

use crate::AnnotationGraph;

[3.35]

[3.60]

use crate::graph::Node;
use crate::{AnnotationGraph, Measurement};

Replacement in src/visualize/treemap.rs at line 8 [3.35]
B:BD[3.154] → [3.154:189]
```
use guppy::graph::PackageMetadata;
```
[3.154]
[3.189]
```
use petgraph::Direction;
```

Replacement in src/visualize/treemap.rs at line 24 [3.35]

B:BD[3.505] → [4.29:64]

∅:D[4.64] → [3.536:578]

B:BD[3.536] → [3.536:578]

    annotations: &AnnotationGraph,
    packages: &[PackageMetadata<'graph>],

[3.505]

[3.578]

    annotations: &'graph AnnotationGraph,
    packages: Vec<&'graph Node>,

Deletion in src/visualize/treemap.rs at line 28 [3.35]

B:BD[3.642] → [3.642:835]


    for pkg in packages {
        // Recursively call this function for all direct dependencies
        let direct_dependencies = pkg.direct_links().map(|link| link.to()).collect::<Vec<_>>();

Replacement in src/visualize/treemap.rs at line 29 [3.35]

B:BD[3.836] → [3.836:1415]

        let empty_vec = Vec::new();
        let self_times = annotations
            .pkg(pkg.id())
            .map(|node| node.timings().unwrap_or(&empty_vec))
            .unwrap_or(&empty_vec)
            .iter()
            .map(|message| TreemapData {
                value: message.duration,
                id: None,
                name: Some(format!("{:?} {:?}", message.mode, message.target.kind)),
                upper_label: None,
                visual_dimension: None,
                children: vec![],
                children_visible_min: None,
            });

[3.836]

[3.1415]

    for node in packages {
        let self_times = node.timings().iter().map(|message| TreemapData {
            value: message.duration,
            id: None,
            name: Some(format!("{:?} {:?}", message.mode, message.target.kind)),
            upper_label: None,
            visual_dimension: None,
            children: vec![],
            children_visible_min: None,
        });

Replacement in src/visualize/treemap.rs at line 40 [3.35]

B:BD[3.1416] → [3.1416:1484]

        let mut children = data(annotations, &direct_dependencies);

[3.1416]

[3.1484]

        // Recursively call this function for all direct dependencies
        let direct_dependencies = annotations
            .node_edges(node, Direction::Outgoing)
            .collect::<Vec<_>>();
        let mut children = data(annotations, direct_dependencies);

Deletion in src/visualize/treemap.rs at line 46 [3.35]

B:BD[3.1521] → [3.1521:1882]


        let mut total_duration = 0_f64;
        for child in &children {
            total_duration += child.value;
        }
        let dependent_count = pkg.reverse_direct_links().count();
        let relative_duration = if dependent_count == 0 {
            total_duration
        } else {
            total_duration / (dependent_count as f64)
        };

Replacement in src/visualize/treemap.rs at line 48 [3.35]

B:BD[3.1924] → [3.1924:1962]

            value: relative_duration,

[3.1924]

[3.1962]

            value: annotations.variable(
                node,
                crate::Variable::TotalDuration,
                Measurement::Relative,
            ),

Replacement in src/visualize/treemap.rs at line 54 [3.35]

B:BD[3.1984] → [3.1984:2032]

            name: Some(pkg.name().to_string()),

[3.1984]

[3.2032]

            name: Some(node.name().to_string()),

Replacement in src/visualize/sankey.rs at line 4 [6.34]

∅:D[4.200] → [5.127:242]

B:BD[5.127] → [5.127:242]

    annotations
        .packages()
        .map(|id| annotations.metadata(id).unwrap().name())
        .collect()

[4.200]

[6.215]

    annotations.packages().map(|node| node.name()).collect()

Replacement in src/visualize/sankey.rs at line 8 [6.34]

∅:D[4.302] → [5.340:457]

B:BD[5.340] → [5.340:457]

    let links = annotations.links().collect::<Vec<_>>();
    let mut sankey_links = Vec::with_capacity(links.len());

[4.302]

[6.450]

    let mut sankey_links = Vec::new();

Replacement in src/visualize/sankey.rs at line 10 [6.34]

B:BD[6.451] → [5.458:630]

    for (from, to) in links {
        let edge_weight = annotations
            .variable(to, Variable::UnitDuration, Measurement::Relative)
            .unwrap_or(0_f64);

[6.451]

[6.1157]

    for (source, target) in annotations.edges() {
        let edge_weight =
            annotations.variable(target, Variable::UnitDuration, Measurement::Relative);

Replacement in src/visualize/sankey.rs at line 14 [6.34]

B:BD[6.1158] → [5.631:851]

        let (from_meta, to_meta) = (
            annotations.metadata(from).unwrap(),
            annotations.metadata(to).unwrap(),
        );
        sankey_links.push((from_meta.name(), to_meta.name(), edge_weight));

[6.1158]

[6.1217]

        sankey_links.push((source.name(), target.name(), edge_weight));

Insertion in src/visualize/mod.rs at line 44 [8.54]

[7.188]

            let data = treemap::data(annotations, annotations.roots().collect::<Vec<_>>());

Replacement in src/visualize/mod.rs at line 46 [8.54]

B:BD[7.215] → [5.1131:1211]

                .data(treemap::data(annotations, &annotations.root_packages()))

[7.215]

[7.268]

                .data(data)

Replacement in src/visualize/mod.rs at line 52 [8.54]

B:BD[7.565] → [5.1212:1282]

                .levels(treemap::levels(annotations.links().count()))

[7.565]

[7.635]

                .levels(treemap::levels(annotations.edges().count()))

Replacement in src/visualize/histogram.rs at line 29 [9.817]

B:BD[5.1528] → [5.1528:1623]

        .filter_map(|id| annotations.variable(id, Variable::UnitDuration, Measurement::Exact))

[5.1528]

[5.1623]

        .map(|id| annotations.variable(id, Variable::UnitDuration, Measurement::Exact))

Replacement in src/visualize/histogram.rs at line 52 [9.817]

B:BD[5.1790] → [5.1790:1885]

        .filter_map(|id| annotations.variable(id, Variable::UnitDuration, Measurement::Exact))

[5.1790]

[5.1885]

        .map(|id| annotations.variable(id, Variable::UnitDuration, Measurement::Exact))

Insertion in src/visualize/graph.rs at line 1 [10.146]
[10.146]
[4.555]
```
use crate::graph::Node;
```
Deletion in src/visualize/graph.rs at line 5 [10.146]
B:BD[10.204] → [5.1966:2012]
```
use guppy::PackageId;
use indexmap::IndexMap;
```
Replacement in src/visualize/graph.rs at line 8 [10.146]
∅:D[11.421] → [10.352:428]
∅:D[4.651] → [10.352:428]
∅:D[5.2051] → [10.352:428]
B:BD[10.352] → [10.352:428]
B:BD[10.428] → [5.2052:2134]
∅:D[5.2134] → [10.540:561]
B:BD[10.540] → [10.540:561]
B:BD[10.561] → [5.2135:2176]
∅:D[5.2176] → [10.601:622]
B:BD[10.601] → [10.601:622]
```
) -> impl Iterator<Item = (&'graph PackageId, forceatlas2::Node<f64, 2>)> {
    let link_index: IndexMap<&PackageId, usize> = annotations
        .packages()
        .enumerate()
        .map(|(index, id)| (*id, index))
        .collect();
```
[4.651]
[5.2177]
```
) -> impl Iterator<Item = (&'graph Node<'graph>, forceatlas2::Node<f64, 2>)> {
```

Replacement in src/visualize/graph.rs at line 10 [10.146]

B:BD[5.2205] → [5.2205:2292]

∅:D[5.2292] → [10.821:879]

B:BD[10.821] → [10.821:879]

        .links()
        .map(|(from, to)| (link_index.get(from), link_index.get(to)))
        .map(|(from, to)| (*from.unwrap(), *to.unwrap()))

[5.2205]

[10.879]

        .edges()
        // Get the graph index of both nodes connected to the edge (NodeIndex)
        .map(|(source, target)| (source.index(), target.index()))
        // Get the integer representation of that index (usize)
        .map(|(source, target)| (source.index(), target.index()))

Replacement in src/visualize/graph.rs at line 17 [10.146]

B:BD[10.932] → [5.2293:2458]

    let sizes = link_index.keys().map(|id| {
        annotations
            .variable(id, Variable::UnitDuration, Measurement::Exact)
            .unwrap_or(0_f64)

[10.932]

[5.2458]

    let sizes = annotations.edges().map(|(source, _target)| {
        annotations.variable(source, Variable::UnitDuration, Measurement::Exact)

Replacement in src/visualize/graph.rs at line 27 [10.146]

B:BD[10.1214] → [10.1214:1215]

B:BD[10.1395] → [10.1395:1442]

B:BD[10.1442] → [5.2467:2543]


    layout
        .nodes
        .into_iter()
        .zip(annotations.packages())
        .map(|(node, id)| (*id, node))

[10.1214]

[10.1548]

    annotations.packages().zip(layout.nodes.into_iter())

Replacement in src/visualize/graph.rs at line 37 [10.146]

B:BD[10.1831] → [12.357:385]

B:BD[12.385] → [5.2656:2805]

        .map(|(id, node)| {
            let unit_time = annotations
                .variable(id, Variable::UnitDuration, Measurement::Exact)
                .unwrap_or(0_f64);

[10.1831]

[12.708]

        .map(|(graph_node, layout_node)| {
            let unit_time =
                annotations.variable(graph_node, Variable::UnitDuration, Measurement::Exact);

Replacement in src/visualize/graph.rs at line 43 [10.146]

B:BD[12.832] → [12.832:875]

B:BD[12.875] → [5.2806:2882]

∅:D[5.2882] → [12.945:1011]

B:BD[12.945] → [12.945:1011]

                id: id.repr().to_string(),
                name: annotations.metadata(id).unwrap().name().to_string(),
                x: node.pos.x(),
                y: node.pos.y(),

[12.832]

[12.1011]

                id: graph_node.id().repr.clone(),
                name: graph_node.name().to_string(),
                x: layout_node.pos.x(),
                y: layout_node.pos.y(),

Replacement in src/visualize/graph.rs at line 56 [10.146]
B:BD[5.2911] → [5.2911:2928]
```
        .links()
```
[5.2911]
[10.2376]
```
        .edges()
```

Replacement in src/visualize/graph.rs at line 58 [10.146]

B:BD[10.2438] → [5.2929:3023]

            source: source.repr().to_string(),
            target: target.repr().to_string(),

[10.2438]

[10.2542]

            source: source.id().repr.to_string(),
            target: target.id().repr.to_string(),

Deletion in src/main.rs at line 2 [14.49]
B:BD[13.24] → [13.24:25]
∅:D[13.25] → [10.0:51]
∅:D[11.63] → [10.0:51]
B:BD[15.85] → [10.0:51]
```
use guppy::{graph::PackageGraph, MetadataCommand};
```
Insertion in src/main.rs at line 7 [14.49]
[16.1078]
[4.741]
```
use cargo_metadata::MetadataCommand;
```

Replacement in src/main.rs at line 20 [14.49]

B:BD[17.2758] → [17.2758:2889]

    let mut metadata_cmd = MetadataCommand::new();
    let package_graph = PackageGraph::from_command(&mut metadata_cmd).unwrap();

[17.2758]

[14.896]

    let metadata = MetadataCommand::new().exec().unwrap();

Replacement in src/main.rs at line 22 [14.49]

B:BD[14.897] → [2.372:461]

    let graph = AnnotationGraph::new(&package_graph, timings, self_profile, unit_graph);

[14.897]

[5.3253]

    let graph = AnnotationGraph::new(metadata, timings, self_profile, &unit_graph);

Replacement in src/graph/mod.rs at line 3 [5.3449]

B:BD[5.3482] → [5.3482:3600]

use guppy::graph::{DependencyDirection, PackageGraph, PackageMetadata};
use guppy::PackageId;
use indexmap::IndexMap;

[5.3482]

[5.3600]

use cargo_metadata::{Metadata, Package, PackageId};

Insertion in src/graph/mod.rs at line 7 [5.3449]
[5.3711]
[5.3711]
```
use petgraph::visit::EdgeRef;
```
Insertion in src/graph/mod.rs at line 22 [5.3449]
[5.3935]
[5.3935]
```
/// A node in the unit graph
```

Replacement in src/graph/mod.rs at line 25 [5.3449]

B:BD[5.3985] → [5.3985:4056]

    id: &'graph PackageId,
    timings: Option<Vec<timings::Message>>,

[5.3985]

[5.4056]

    index: usize,
    metadata: Package,
    unit: &'graph unit_graph::Unit,
    timings: Vec<timings::Message>,

Replacement in src/graph/mod.rs at line 32 [5.3449]

B:BD[5.4087] → [5.4087:4179]

    pub fn timings(&self) -> Option<&Vec<timings::Message>> {
        self.timings.as_ref()

[5.4087]

[5.4179]

    pub fn index(&self) -> NodeIndex {
        NodeIndex::new(self.index)
    }
    pub fn id(&self) -> &PackageId {
        &self.unit.pkg_id
    }
    pub fn name(&self) -> &str {
        self.metadata.name.as_str()
    }
    pub fn timings(&self) -> &Vec<timings::Message> {
        &self.timings

Replacement in src/graph/mod.rs at line 49 [5.3449]
B:BD[5.4188] → [5.4188:4212]
```
#[derive(Debug, Clone)]
```
[5.4188]
[4.1103]
```
#[derive(Debug)]
```
Deletion in src/graph/mod.rs at line 51 [5.3449]
∅:D[4.1140] → [5.4245:4286]
B:BD[5.4245] → [5.4245:4286]
```
    package_graph: &'graph PackageGraph,
```

Replacement in src/graph/mod.rs at line 52 [5.3449]

B:BD[5.4322] → [5.4322:4376]

    node_indices: IndexMap<&'graph PackageId, usize>,

[5.4322]

[5.4376]

    timings: timings::Output,
    self_profile: self_profile::ProfileCollection,
    unit_graph: &'graph unit_graph::UnitGraph,

Replacement in src/graph/mod.rs at line 59 [5.3449]
B:BD[5.4430] → [5.4430:4475]
```
        package_graph: &'graph PackageGraph,
```
[5.4430]
[4.1181]
```
        metadata: Metadata,
```

Replacement in src/graph/mod.rs at line 62 [5.3449]

B:BD[4.1274] → [2.524:567]

        unit_graph: unit_graph::UnitGraph,

[4.1274]

[5.4539]

        unit_graph: &'graph unit_graph::UnitGraph,

Replacement in src/graph/mod.rs at line 64 [5.3449]
B:BD[5.4555] → [2.568:600]
```
        dbg!(unit_graph.roots);
```
[5.4555]
[4.1275]
```
        dbg!(&unit_graph.roots);
```

Replacement in src/graph/mod.rs at line 67 [5.3449]

∅:D[13.8252] → [5.4555:4623]

B:BD[5.4555] → [5.4555:4623]

        let node_indices = package_graph
            .package_ids()

[13.8252]

[5.4623]

        let nodes = unit_graph
            .units
            .iter()

Replacement in src/graph/mod.rs at line 71 [5.3449]

B:BD[5.4648] → [5.4648:4926]

B:BD[5.4926] → [4.1344:1394]

∅:D[4.1394] → [5.4971:5340]

B:BD[5.4971] → [5.4971:5340]

            .map(|(index, id)| (id, index))
            .collect::<IndexMap<&PackageId, usize>>();
        // Iterate over node_indicies.keys() to preserve ordering
        let nodes = node_indices.keys().map(|id| Element::Node {
            weight: Node {
                id,
                timings: timings.repr.remove(id),
            },
        });
        let package_set = package_graph.resolve_all();
        let edges = package_set
            .links(DependencyDirection::Forward)
            .map(|link| Element::Edge {
                source: *node_indices.get(link.from().id()).unwrap(),
                target: *node_indices.get(link.to().id()).unwrap(),
                weight: (),

[5.4648]

[5.5340]

            .map(|(index, unit)| Element::Node {
                weight: Node {
                    index,
                    metadata: metadata[&unit.pkg_id].clone(),
                    unit,
                    timings: timings.repr.remove(&unit.pkg_id).unwrap(),
                },

Insertion in src/graph/mod.rs at line 79 [5.3449]

[5.5356]

        let edges = unit_graph
            .units
            .iter()
            .map(|unit| unit.dependencies.iter())
            .enumerate()
            .map(|(index, deps)| {
                deps.map(move |dep| Element::Edge {
                    source: index,
                    target: dep.index,
                    weight: (),
                })
            })
            .flatten();

Deletion in src/graph/mod.rs at line 96 [5.3449]
B:BD[5.5435] → [5.5435:5462]
```
            package_graph,
```

Replacement in src/graph/mod.rs at line 97 [5.3449]

B:BD[5.5481] → [5.5481:5507]

            node_indices,

[5.5481]

[5.5507]

            timings,
            self_profile,
            unit_graph,

Deletion in src/graph/mod.rs at line 101 [5.3449]

B:BD[5.5517] → [5.5517:5726]

    }
    pub fn root_packages(&self) -> Vec<PackageMetadata> {
        self.package_graph
            .resolve_all()
            .root_packages(DependencyDirection::Forward)
            .collect::<Vec<_>>()

Replacement in src/graph/mod.rs at line 103 [5.3449]

B:BD[5.5733] → [5.5733:5892]

    fn node_index(&self, id: &PackageId) -> Option<NodeIndex> {
        let node_index = *self.node_indices.get(id)?;
        Some(NodeIndex::new(node_index))

[5.5733]

[5.5892]

    pub fn roots(&'graph self) -> impl Iterator<Item = &'graph Node> {
        self.unit_graph
            .roots
            .iter()
            .map(|root| NodeIndex::new(*root))
            .map(|index| &self.graph[index])

Replacement in src/graph/mod.rs at line 111 [5.3449]

B:BD[5.5899] → [5.5899:6041]

    pub fn pkg(&self, id: &PackageId) -> Option<&Node> {
        let node_index = self.node_index(id)?;
        Some(&self.graph[node_index])

[5.5899]

[5.6041]

    pub fn packages(&'graph self) -> impl Iterator<Item = &'graph Node> {
        self.graph.node_indices().map(|index| &self.graph[index])

Replacement in src/graph/mod.rs at line 115 [5.3449]

B:BD[5.6048] → [5.6048:6147]

    pub fn packages(&self) -> impl Iterator<Item = &&PackageId> {
        self.node_indices.keys()

[5.6048]

[5.6147]

    pub fn edges(&'graph self) -> impl Iterator<Item = (&'graph Node, &'graph Node)> {
        self.graph
            .edge_indices()
            .map(|edge| self.graph.edge_endpoints(edge))
            .map(Option::unwrap)
            .map(|(source, target)| (&self.graph[source], &self.graph[target]))

Replacement in src/graph/mod.rs at line 123 [5.3449]

B:BD[5.6154] → [5.6154:6230]

    pub fn links(&self) -> impl Iterator<Item = (&PackageId, &PackageId)> {

[5.6154]

[5.6230]

    pub fn node_edges(
        &'graph self,
        node: &Node,
        direction: Direction,
    ) -> impl Iterator<Item = &'graph Node> {
        let node_index = node.index();

Replacement in src/graph/mod.rs at line 130 [5.3449]

B:BD[5.6249] → [5.6249:6380]

            .raw_edges()
            .iter()
            .map(|edge| (self.graph[edge.source()].id, self.graph[edge.target()].id))

[5.6249]

[5.6380]

            .edges_directed(node_index, direction)
            .map(move |edge| match direction {
                Direction::Outgoing => edge.target(),
                Direction::Incoming => edge.source(),
            })
            .map(|index| &self.graph[index])

Replacement in src/graph/mod.rs at line 138 [5.3449]

B:BD[5.6387] → [5.6387:6941]

    pub fn metadata(&self, id: &PackageId) -> Result<PackageMetadata, guppy::Error> {
        self.package_graph.metadata(id)
    }
    pub fn dependents(&self, id: &PackageId) -> Option<usize> {
        let node_index = self.node_index(id)?;
        let dependents = self
            .graph
            .edges_directed(node_index, Direction::Incoming)
            .count();
        Some(dependents)
    }
    pub fn variable(
        &self,
        id: &PackageId,
        variable: Variable,
        measurement: Measurement,
    ) -> Option<f64> {

[5.6387]

[5.6941]

    pub fn variable(&self, node: &Node, variable: Variable, measurement: Measurement) -> f64 {

Replacement in src/graph/mod.rs at line 141 [5.3449]

B:BD[5.7030] → [5.7030:7126]

                let node = self.pkg(id)?;
                let timings = node.timings.as_ref()?;

[5.7030]

[5.7126]

                let timings = &node.timings;

Deletion in src/graph/mod.rs at line 144 [5.3449]

B:BD[5.7199] → [5.7199:7307]

                if id.repr().contains("windows") {
                    dbg!(id, timings);
                }

Deletion in src/graph/mod.rs at line 147 [5.3449]
B:BD[5.7394] → [5.7394:7449]
```
                let node_index = self.node_index(id)?;
```

Replacement in src/graph/mod.rs at line 149 [5.3449]

B:BD[5.7516] → [5.7516:7590]

                    .neighbors_directed(node_index, Direction::Outgoing);

[5.7516]

[5.7590]

                    .neighbors_directed(node.index(), Direction::Outgoing);

Replacement in src/graph/mod.rs at line 152 [5.3449]

B:BD[5.7634] → [5.7634:7706]

                    .filter_map(|dep| self.graph[dep].timings.as_ref())

[5.7634]

[5.7706]

                    .map(|dep| &self.graph[dep].timings)

Replacement in src/graph/mod.rs at line 156 [5.3449]

B:BD[5.7784] → [5.7784:7934]

                let self_timings = self
                    .variable(id, Variable::UnitDuration, measurement)
                    .unwrap_or(0_f64);

[5.7784]

[5.7934]

                let self_timings = self.variable(node, Variable::UnitDuration, measurement);

Replacement in src/graph/mod.rs at line 161 [5.3449]
B:BD[5.8012] → [5.8012:8045]
```
        Some(match measurement {
```
[5.8012]
[5.8045]
```
        match measurement {
```

Replacement in src/graph/mod.rs at line 164 [5.3449]

B:BD[5.8137] → [5.8137:8199]

                let dependents = self.dependents(id)? as f64;

[5.8137]

[5.8199]

                let dependents = self
                    .graph
                    .edges_directed(node.index(), Direction::Incoming)
                    .count() as f64;

Replacement in src/graph/mod.rs at line 175 [5.3449]
B:BD[5.8388] → [5.8388:8399]
```
        })
```
[5.8388]
[5.8399]
```
        }
```
Replacement in src/annotations/timings.rs at line 5 [17.35]
B:BD[18.61] → [18.61:83]
```
use guppy::PackageId;
```
[17.108]
[17.149]
```
use cargo_metadata::PackageId;
```
Replacement in src/annotations/timings.rs at line 34 [17.35]
B:BD[19.1627] → [7.968:1015]
```
    pub package_id: cargo_metadata::PackageId,
```
[19.1627]
[4.1395]
```
    pub package_id: PackageId,
```
Insertion in src/annotations/timings.rs at line 41 [17.35]
[17.907]
[18.146]
```
#[derive(Clone, Debug)]
```

Replacement in src/annotations/timings.rs at line 100 [17.35]

B:BD[18.1964] → [18.1964:2128]

            let pkg_id = PackageId::new(json_message.package_id.repr.clone());
            let pkg_timings: &mut Vec<Message> = timings.entry(pkg_id).or_default();

[18.1964]

[18.2128]

            let pkg_timings: &mut Vec<Message> =
                timings.entry(json_message.package_id.clone()).or_default();

Deletion in Cargo.toml at line 12 [14.962]
∅:D[16.1769] → [20.1337:1354]
B:BD[21.1656] → [20.1337:1354]
B:BD[20.1354] → [5.8408:8427]
```
guppy = "0.17.5"
indexmap = "2.2.6"
```

Deletion in Cargo.lock at line 6 [14.1102]

B:BD[21.1670] → [20.1355:1619]

B:BD[20.1619] → [13.8334:8349]

name = "ahash"
version = "0.8.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
dependencies = [
 "cfg-if",
 "getrandom",
 "once_cell",
 "version_check",
 "zerocopy",
]
[[package]]

Deletion in Cargo.lock at line 99 [14.1102]

B:BD[14.1963] → [20.1635:1879]

name = "cfg-expr"
version = "0.15.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d067ad48b8650848b989a59a86c6c36a995d02d2bf778d45c3c5d57bc2718f02"
dependencies = [
 "smallvec",
 "target-lexicon",
]
[[package]]

Deletion in Cargo.lock at line 156 [14.1102]

B:BD[21.2790] → [20.1880:2076]


[[package]]
name = "debug-ignore"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffe7ed1d93f4553003e20b629abe9085e1e81b1429520f897f8f8860bc6dfc21"

Deletion in Cargo.lock at line 190 [14.1102]
∅:D[16.3063] → [20.2077:2087]
B:BD[21.2817] → [20.2077:2087]
B:BD[20.2087] → [5.8447:8460]
```
 "guppy",
 "indexmap",
```

Deletion in Cargo.lock at line 255 [14.1102]

B:BD[20.2520] → [20.2520:3003]

]
[[package]]
name = "guppy"
version = "0.17.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34e99a7734579b834a076ef11789783c153c6eb5fb3520ed15bc41f483f0f317"
dependencies = [
 "ahash",
 "camino",
 "cargo_metadata",
 "cfg-if",
 "debug-ignore",
 "fixedbitset",
 "guppy-workspace-hack",
 "indexmap",
 "itertools",
 "nested",
 "once_cell",
 "pathdiff",
 "petgraph",
 "semver",
 "serde",
 "serde_json",
 "smallvec",
 "static_assertions",
 "target-spec",

Deletion in Cargo.lock at line 256 [14.1102]

B:BD[20.3005] → [20.3005:3209]


[[package]]
name = "guppy-workspace-hack"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "92620684d99f750bae383ecb3be3748142d6095760afd5cbcf2261e9a279d780"

Deletion in Cargo.lock at line 294 [14.1102]

∅:D[13.9855] → [15.2262:2277]

B:BD[15.2262] → [15.2262:2277]

B:BD[15.2277] → [20.3210:3419]

]
[[package]]
name = "itertools"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
dependencies = [
 "either",

Deletion in Cargo.lock at line 379 [14.1102]

B:BD[14.2237] → [20.3435:3625]

name = "nested"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca2b420f638f07fe83056b55ea190bb815f609ec5a35e7017884a10f78839c9e"
[[package]]

Deletion in Cargo.lock at line 442 [14.1102]

∅:D[16.4348] → [20.3626:3848]

B:BD[21.4358] → [20.3626:3848]

name = "pathdiff"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
dependencies = [
 "camino",
]
[[package]]

Deletion in Cargo.lock at line 680 [14.1102]

B:BD[20.4042] → [20.4042:4243]


[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"

Deletion in Cargo.lock at line 689 [14.1102]

B:BD[14.4041] → [14.4041:4074]

B:BD[14.4074] → [20.4244:4700]

 "unicode-ident",
]
[[package]]
name = "target-lexicon"
version = "0.12.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
[[package]]
name = "target-spec"
version = "3.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "36a8e795b1824524d13cdf04f73cf8b4f244ce86c96b4d2a83a6ca1a753d2752"
dependencies = [
 "cfg-expr",
 "guppy-workspace-hack",
 "target-lexicon",

Deletion in Cargo.lock at line 820 [14.1102]

B:BD[16.7980] → [16.7980:7993]

∅:D[16.7993] → [20.4959:5431]

B:BD[20.4959] → [20.4959:5431]


[[package]]
name = "zerocopy"
version = "0.7.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
dependencies = [
 "zerocopy-derive",
]
[[package]]
name = "zerocopy-derive"
version = "0.7.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
dependencies = [
 "proc-macro2",
 "quote",
 "syn",
]