Function desired_tree_paths

atomic-repository/src/repository/deferred_tree.rs:67–131

(
    ops: &[DeferredTreeOp],
    visible_changes: &HashSet<Hash>,
)

type DeferredPathClaim = (Position<Hash>, Option<usize>);

fn desired_tree_paths(
    ops: &[DeferredTreeOp],
    visible_changes: &HashSet<Hash>,
) -> HashMap<Position<Hash>, DesiredTreePath> {
    let mut desired = HashMap::new();

    for (order, op) in ops.iter().enumerate() {
        let state = desired.entry(op.inode).or_insert_with(|| DesiredTreePath {
            desired_path: op.baseline_path.clone(),
            last_set_order: None,
        });
        if !visible_changes.contains(&op.change) {
            continue;
        }

        match &op.action {
            DeferredTreeAction::Set { path } => {
                state.desired_path = Some(path.clone());
                state.last_set_order = Some(order);
            }
            DeferredTreeAction::Delete => {
                state.desired_path = None;
                state.last_set_order = None;
            }
        }
    }

    // TREE is a one-to-one path↔inode index, while two overlay-visible changes
    // can independently add the same path. Match the lifecycle order Atomic
    // established when those changes were recorded/imported: the latest
    // visible Set owns the path. Baseline-only duplicates remain untouched so
    // apply_deferred_tree_ops_in_txn still fails closed on corrupt TREE state.
    let mut claims: HashMap<String, Vec<DeferredPathClaim>> = HashMap::new();
    for (inode, state) in &desired {
        if let Some(path) = &state.desired_path {
            claims
                .entry(path.clone())
                .or_default()
                .push((*inode, state.last_set_order));
        }
    }
    for claimants in claims.into_values().filter(|claimants| claimants.len() > 1) {
        let Some(max_order) = claimants.iter().filter_map(|(_, order)| *order).max() else {
            continue;
        };
        if claimants
            .iter()
            .filter(|(_, order)| *order == Some(max_order))
            .count()
            != 1
        {
            continue;
        }
        for (inode, order) in claimants {
            if order != Some(max_order) {
                desired
                    .get_mut(&inode)
                    .expect("claimant exists")