benaryorg/pijul - Change HP7CKJIW6TOQZFAZKKJFF76LGE7EMQVDTRH2RWPM4POIG2WRKHBAC

Fixing a bug in unrecord

When unrecording a deletion, the down context could be dead.

The first bug fixed here was that unrecord didn't re-detect missing contexts after unapplying the patch. This was done in apply with libpijul::apply::collect_missing_contexts, but not in unrecord.

The second bug was that the repair (for both apply and unrecord) didn't insert the extra edges needed to reconnect the broken link in some cases. In particular, when the two ends of the edge had already been visited by the "repair DFS".

Created by pmeunier on April 21, 2025

HP7CKJIW6TOQZFAZKKJFF76LGE7EMQVDTRH2RWPM4POIG2WRKHBAC

Dependencies

In channels

main

Change contents

Replacement in libpijul/src/unrecord/mod.rs at line 264 [7.231493]
∅:D[5.1695] → [6.2349:2396]
B:BD[8.1137] → [6.2349:2396]
```
    crate::apply::clean_obsolete_pseudo_edges(
```
[5.1695]
[6.2396]
```
    let mut inodes = crate::apply::clean_obsolete_pseudo_edges(
```

Insertion in libpijul/src/unrecord/mod.rs at line 270 [7.231493]

[6.2490]

    debug!("inodes = {:?}", inodes);
    collect_missing_contexts(
        txn,
        txn.graph(channel),
        &mut ws.apply,
        &change,
        change_id,
        &mut inodes,
    )?;
    for i in inodes {
        debug!("inodes: repair zombie {:?}", i);
        crate::apply::repair_zombies(txn, T::graph_mut(channel), i)?;
    }

Insertion in libpijul/src/unrecord/mod.rs at line 285 [7.231493]
[9.925]
[7.235705]
```
    debug!("unapply done");
```
Deletion in libpijul/src/unrecord/mod.rs at line 422 [7.231493]
B:BD[10.1099] → [11.0:79]
```
    let hash: Hash = (*txn.get_external(&change_id).unwrap().unwrap()).into();
```
Replacement in libpijul/src/unrecord/mod.rs at line 433 [7.231493]
B:BD[11.98] → [12.0:32]
```
                if h == &hash {
```
[11.98]
[2.0]
```
                if h == &ext {
```

Replacement in libpijul/src/unrecord/mod.rs at line 441 [7.231493]

B:BD[11.381] → [11.381:461]

                        .knows(edge.introduced_by.as_ref().unwrap_or(&hash), h)

[11.381]

[11.461]

                        .knows(edge.introduced_by.as_ref().unwrap_or(&ext), h)

Replacement in libpijul/src/unrecord/mod.rs at line 470 [7.231493]

B:BD[7.242243] → [7.242243:242346]

    // does a patch introduced by an edge parallel to
    // this one remove this edge from the graph?

[7.242243]

[7.242346]

    // does a patch (call it q) other than the one (p) we're
    // unrecording remove this same edge (a, b, intro) from the graph?
    // This can happen e.g. if an edge is deleted twice, in which case
    // this unrecord is likely to introduce a zombie conflict between
    // p and q.

Replacement in libpijul/src/unrecord/mod.rs at line 492 [7.231493]

B:BD[13.2391] → [13.2391:2449]

        // reinsert a -> b: that edge was removed by `e`.

[13.2391]

[13.2449]

        // reinsert a -> b: that edge was removed when introducing
        // `e`.

Insertion in libpijul/src/unrecord/mod.rs at line 529 [7.231493]

[7.243938]

[14.12061]

/// Remove extra pseudo-edges introduced to mark a zombie conflict, if
/// the conflict is indeed removed by this unrecord.

Insertion in libpijul/src/unrecord/mod.rs at line 572 [7.231493]
[13.3233]
[13.3233]
```
            debug!("already seen");
```
Insertion in libpijul/src/unrecord/mod.rs at line 598 [7.231493]
[5.1910]
[5.1910]
```
    debug!("zombies collected");
```

Insertion in libpijul/src/unrecord/mod.rs at line 716 [7.231493]

[13.3885]


/// Same as crate::apply::collect_missing_contexts, but with the
/// directions reversed.
fn collect_missing_contexts<T: GraphMutTxnT + TreeTxnT>(
    txn: &T,
    channel: &T::Graph,
    ws: &mut crate::apply::Workspace,
    change: &Change,
    change_id: ChangeId,
    inodes: &mut HashSet<Position<ChangeId>>,
) -> Result<(), crate::apply::LocalApplyError<T>> {
    debug!("collect_missing_contexts");
    inodes.extend(
        ws.missing_context
            .unknown_parents
            .drain(..)
            .map(|x| internal_pos(txn, &x.2, change_id).unwrap()),
    );
    for atom in change.changes.iter().flat_map(|r| r.iter()) {
        match atom {
            // NewVertex is already collected when applying.
            Atom::NewVertex(_) => {}
            Atom::EdgeMap(ref n) => {
                crate::apply::has_missing_edge_context(
                    txn, channel, change_id, change, &n, inodes, true,
                )?;
            }
        }
    }
    Ok(())
}

Replacement in libpijul/src/missing_context.rs at line 24 [7.696460]
B:BD[7.696724] → [15.88638:88682]
```
    pub(crate) fn load_graph<T: GraphTxnT>(
```
[7.696724]
[7.696763]
```
    pub fn load_graph<T: GraphTxnT>(
```
Replacement in libpijul/src/missing_context.rs at line 236 [7.696460]
B:BD[7.706744] → [16.83467:83505]
```
    pub(crate) unknown_parents: Vec<(
```
[7.706744]
[7.706771]
```
    pub unknown_parents: Vec<(
```

Replacement in libpijul/src/missing_context.rs at line 243 [7.696460]

B:BD[17.123715] → [16.83506:83619]

    pub(crate) parents: HashSet<SerializedEdge>,
    pub(crate) pseudo: Vec<(Vertex<ChangeId>, SerializedEdge)>,

[17.123715]

[18.106]

    pub parents: HashSet<SerializedEdge>,
    pub pseudo: Vec<(Vertex<ChangeId>, SerializedEdge)>,

Replacement in libpijul/src/missing_context.rs at line 246 [7.696460]

B:BD[18.147] → [13.13188:13219]

∅:D[13.13219] → [7.707101:707180]

B:BD[7.707101] → [7.707101:707180]

B:BD[7.707180] → [13.13220:13269]

    pub(crate) graphs: Graphs,
    pub(crate) covered_parents: HashSet<(Vertex<ChangeId>, Vertex<ChangeId>)>,
    pub(crate) files: HashSet<Vertex<ChangeId>>,

[18.147]

[19.1732]

    pub graphs: Graphs,
    pub covered_parents: HashSet<(Vertex<ChangeId>, Vertex<ChangeId>)>,
    pub files: HashSet<Vertex<ChangeId>>,

Replacement in libpijul/src/missing_context.rs at line 256 [7.696460]
B:BD[13.13296] → [13.13296:13322]
```
pub(crate) struct Graphs(
```
[13.13296]
[13.13322]
```
pub struct Graphs(
```
Replacement in libpijul/src/lib.rs at line 18 [7.717381]
B:BD[7.717621] → [7.717621:717632]
```
mod apply;
```
[7.717621]
[7.717632]
```
pub mod apply;
```
Replacement in libpijul/src/lib.rs at line 23 [7.717381]
B:BD[7.717722] → [7.717722:717743]
```
mod missing_context;
```
[7.717722]
[7.717743]
```
pub mod missing_context;
```
Insertion in libpijul/src/change.rs at line 215 [7.831311]
[7.836189]
[7.836189]
```
        debug!("ch {:?}", ch);
```

Replacement in libpijul/src/change.rs at line 250 [7.831311]

B:BD[7.837662] → [15.118124:118177]

∅:D[15.118177] → [7.837714:837741]

B:BD[7.837714] → [7.837714:837741]

    let deps = minimize_deps(txn, &channel, &deps)?;
    for d in deps.iter() {

[7.837662]

[7.837741]

    debug!("minimize");
    let deps_ = minimize_deps(txn, &channel, &deps)?;
    for d in deps_.iter() {

Insertion in libpijul/src/change.rs at line 330 [7.831311]
[15.119292]
[17.138625]
```
        debug!("add_zombie_deps_from {:?}", edge);
```
Insertion in libpijul/src/change.rs at line 355 [7.831311]
[20.336]
[7.839314]
```
    debug!("e_to {:?}", e_to);
```

Insertion in libpijul/src/change.rs at line 369 [7.831311]

[20.486]

[7.839565]

    debug!("to_pos {:?} to {:?}", to_pos, to);
    let mut h = HashSet::new();

Insertion in libpijul/src/change.rs at line 372 [7.831311]

[7.839576]

[17.138990]

        if !h.insert(*to) {
            error!("seen twice: {:?}", to);
            break;
        }

Insertion in libpijul/src/change.rs at line 377 [7.831311]
[17.139045]
[15.119673]
```
            debug!("add_zombie_deps_to {:?}", edge);
```
Insertion in libpijul/src/change.rs at line 394 [7.831311]
[7.840125]
[7.840125]
```
        debug!("to {:?} {:?}", to, e_to);
```

Replacement in libpijul/src/change.rs at line 418 [7.831311]

B:BD[7.840736] → [21.7238:7313]

B:BD[21.7313] → [17.139419:139460]

∅:D[21.7313] → [7.840811:840887]

∅:D[6.64432] → [7.840811:840887]

∅:D[15.120185] → [7.840811:840887]

∅:D[17.139460] → [7.840811:840887]

B:BD[7.840811] → [7.840811:840887]

        let time = txn.get_changeset(txn.changes(&channel), id)?.unwrap();
        let time = u64::from_le(time.0);
        debug!("time = {:?}", time);
        min_time = min_time.min(time);

[7.840736]

[7.840887]

        if let Some(time) = txn.get_changeset(txn.changes(&channel), id)? {
            let time = u64::from_le(time.0);
            debug!("time = {:?}", time);
            min_time = min_time.min(time);
        }

Insertion in libpijul/src/change.rs at line 1090 [7.831311]
[15.120624]
[7.860276]
```
        debug!("globalize");
```

Replacement in libpijul/src/change.rs at line 1099 [7.831311]

B:BD[7.860484] → [15.120625:120674]

∅:D[15.120674] → [7.860530:860639]

B:BD[7.860530] → [7.860530:860639]

B:BD[7.860639] → [22.19658:19856]

∅:D[22.19856] → [7.860716:860923]

∅:D[15.120761] → [7.860716:860923]

∅:D[17.139684] → [7.860716:860923]

B:BD[7.860716] → [7.860716:860923]

B:BD[7.860923] → [22.19857:20057]

∅:D[22.20057] → [7.861002:861217]

∅:D[15.120850] → [7.861002:861217]

∅:D[17.139798] → [7.861002:861217]

B:BD[7.861002] → [7.861002:861217]

B:BD[7.861217] → [22.20058:20243]

∅:D[22.20243] → [7.861293:861348]

∅:D[15.120936] → [7.861293:861348]

∅:D[17.139909] → [7.861293:861348]

B:BD[7.861293] → [7.861293:861348]

B:BD[7.861348] → [15.120937:121036]

∅:D[15.121036] → [7.861443:861673]

B:BD[7.861443] → [7.861443:861673]

B:BD[7.861673] → [22.20244:20323]

            }) => Ok(Atom::NewVertex(NewVertex {
                up_context: up_context
                    .iter()
                    .map(|&up| Position {
                        change: up
                            .change
                            .as_ref()
                            .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),
                        pos: up.pos,
                    })
                    .collect(),
                down_context: down_context
                    .iter()
                    .map(|&down| Position {
                        change: down
                            .change
                            .as_ref()
                            .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),
                        pos: down.pos,
                    })
                    .collect(),
                start: *start,
                end: *end,
                flag: *flag,
                inode: Position {
                    change: inode
                        .change
                        .as_ref()
                        .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),
                    pos: inode.pos,
                },
            })),
            Atom::EdgeMap(EdgeMap { edges, inode }) => Ok(Atom::EdgeMap(EdgeMap {
                edges: edges
                    .iter()
                    .map(|edge| NewEdge {
                        previous: edge.previous,
                        flag: edge.flag,
                        from: Position {
                            change: edge
                                .from

[7.860484]

[22.20323]

            }) => {
                debug!(
                    "globalize vertex {:?} {:?}",
                    up_context.len(),
                    down_context.len()
                );
                Ok(Atom::NewVertex(NewVertex {
                    up_context: up_context
                        .iter()
                        .map(|&up| Position {
                            change: up

Replacement in libpijul/src/change.rs at line 1113 [7.831311]

∅:D[22.20498] → [7.861761:861873]

∅:D[15.121134] → [7.861761:861873]

∅:D[17.140032] → [7.861761:861873]

B:BD[7.861761] → [7.861761:861873]

B:BD[7.861873] → [22.20499:20576]

                            pos: edge.from.pos,
                        },
                        to: Vertex {
                            change: edge
                                .to

[22.20498]

[22.20576]

                            pos: up.pos,
                        })
                        .collect(),
                    down_context: down_context
                        .iter()
                        .map(|&down| Position {
                            change: down

Replacement in libpijul/src/change.rs at line 1123 [7.831311]

∅:D[22.20751] → [7.861959:862082]

∅:D[15.121230] → [7.861959:862082]

∅:D[17.140153] → [7.861959:862082]

B:BD[7.861959] → [7.861959:862082]

B:BD[7.862082] → [17.140154:140231]

∅:D[17.140231] → [15.121231:121307]

B:BD[7.862150] → [15.121231:121307]

B:BD[15.121307] → [17.140232:140273]

∅:D[17.140273] → [7.862251:862500]

B:BD[7.862251] → [7.862251:862500]

B:BD[7.862500] → [22.20752:20937]

∅:D[22.20937] → [7.862576:862631]

∅:D[15.121393] → [7.862576:862631]

∅:D[17.140384] → [7.862576:862631]

B:BD[7.862576] → [7.862576:862631]

B:BD[7.862631] → [15.121394:121411]

                            start: edge.to.start,
                            end: edge.to.end,
                        },
                        introduced_by: edge.introduced_by.as_ref().map(|a| {
                            if let Some(a) = txn.get_external(a).unwrap() {
                                a.into()
                            } else {
                                panic!("introduced by {:?}", a);
                            }
                        }),
                    })
                    .collect(),
                inode: Position {
                    change: inode
                        .change
                        .as_ref()
                        .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),
                    pos: inode.pos,
                },
            })),

[22.20751]

[7.862647]

                            pos: down.pos,
                        })
                        .collect(),
                    start: *start,
                    end: *end,
                    flag: *flag,
                    inode: Position {
                        change: inode
                            .change
                            .as_ref()
                            .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),
                        pos: inode.pos,
                    },
                }))
            }
            Atom::EdgeMap(EdgeMap { edges, inode }) => {
                debug!("globalize edgemap {:?}", edges.len());
                Ok(Atom::EdgeMap(EdgeMap {
                    edges: edges
                        .iter()
                        .map(|edge| NewEdge {
                            previous: edge.previous,
                            flag: edge.flag,
                            from: Position {
                                change: edge
                                    .from
                                    .change
                                    .as_ref()
                                    .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),
                                pos: edge.from.pos,
                            },
                            to: Vertex {
                                change: edge
                                    .to
                                    .change
                                    .as_ref()
                                    .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),
                                start: edge.to.start,
                                end: edge.to.end,
                            },
                            introduced_by: edge.introduced_by.as_ref().map(|a| {
                                if let Some(a) = txn.get_external(a).unwrap() {
                                    a.into()
                                } else {
                                    panic!("introduced by {:?}", a);
                                }
                            }),
                        })
                        .collect(),
                    inode: Position {
                        change: inode
                            .change
                            .as_ref()
                            .and_then(|a| txn.get_external(a).unwrap().map(Into::into)),
                        pos: inode.pos,
                    },
                }))
            }

Insertion in libpijul/src/change.rs at line 1391 [7.831311]
[20.1058]
[23.105473]
```
        info!("computing dependencies");
```
Insertion in libpijul/src/change.rs at line 1394 [7.831311]
[7.867547]
[7.867547]
```
        info!("hashing patch");
```
Insertion in libpijul/src/change/text_changes.rs at line 265 [25.37976]
[24.11439]
[24.11439]
```
            debug!("dep hash {:?}", dep.hash);
```
Replacement in libpijul/src/apply.rs at line 10 [7.944089]
B:BD[25.93417] → [10.1216:1237]
```
pub(crate) mod edge;
```
[25.93417]
[16.89930]
```
pub mod edge;
```
Replacement in libpijul/src/apply.rs at line 12 [7.944089]
B:BD[16.89954] → [16.89954:89966]
```
mod vertex;
```
[16.89954]
[16.89966]
```
pub mod vertex;
```

Replacement in libpijul/src/apply.rs at line 519 [7.944089]

B:BD[7.961195] → [7.961195:961276]

B:BD[7.961276] → [17.145857:145934]

∅:D[17.145934] → [13.19463:19498]

B:BD[7.961343] → [13.19463:19498]

∅:D[13.19498] → [7.961391:961430]

B:BD[7.961391] → [7.961391:961430]

B:BD[7.961430] → [26.69614:69655]

∅:D[26.69655] → [7.961479:961591]

B:BD[7.961479] → [7.961479:961591]

B:BD[7.961591] → [17.145935:145968]

B:BD[17.145968] → [27.241:341]

    parents: HashSet<Vertex<ChangeId>>,
    children: HashSet<Vertex<ChangeId>>,
    pseudo: Vec<(Vertex<ChangeId>, SerializedEdge, Position<Option<Hash>>)>,
    deleted_by: HashSet<ChangeId>,
    up_context: Vec<Vertex<ChangeId>>,
    down_context: Vec<Vertex<ChangeId>>,
    pub(crate) missing_context: crate::missing_context::Workspace,
    rooted: HashMap<Vertex<ChangeId>, bool>,
    adjbuf: Vec<SerializedEdge>,
    alive_folder: HashMap<Vertex<ChangeId>, bool>,
    folder_stack: Vec<(Vertex<ChangeId>, bool)>,

[7.961195]

[7.961591]

    pub parents: HashSet<Vertex<ChangeId>>,
    pub children: HashSet<Vertex<ChangeId>>,
    pub pseudo: Vec<(Vertex<ChangeId>, SerializedEdge, Position<Option<Hash>>)>,
    pub deleted_by: HashSet<ChangeId>,
    pub up_context: Vec<Vertex<ChangeId>>,
    pub down_context: Vec<Vertex<ChangeId>>,
    pub missing_context: crate::missing_context::Workspace,
    pub rooted: HashMap<Vertex<ChangeId>, bool>,
    pub adjbuf: Vec<SerializedEdge>,
    pub alive_folder: HashMap<Vertex<ChangeId>, bool>,
    pub folder_stack: Vec<(Vertex<ChangeId>, bool)>,

Deletion in libpijul/src/apply.rs at line 598 [7.944089]
B:BD[4.531] → [4.531:572]
```
        debug!("visited {:?}", visited);
```
Deletion in libpijul/src/apply.rs at line 600 [7.944089]
B:BD[4.653] → [4.653:707]
```
            debug!("descendants {:#?}", descendants);
```
Insertion in libpijul/src/apply.rs at line 602 [7.944089]
[4.821]
[4.821]
```
                debug!("descendant {:#?}", r);
```

Insertion in libpijul/src/apply.rs at line 613 [7.944089]

[4.1081]

[28.35835]

            // Reconnect with ancestor.
            for v in stack.iter().rev() {
                if v.is_on_path {
                    debug!("on path: {:?}", v);
                    // If the last vertex on the path to `current` is not
                    // alive, a reconnect is needed.
                    if v.is_alive() {
                        // We need to reconnect, and we can do it now
                        // since we won't have a chance to visit that
                        // edge (because non-PARENT edge we are
                        // inserting now starts from a vertex that is
                        // on the path, which means we've already
                        // pushed all its children onto the stack.).
                        put_graph_with_rev(
                            txn,
                            channel,
                            EdgeFlags::PSEUDO,
                            v.vertex,
                            elt.vertex,
                            ChangeId::ROOT,
                        )?;
                        break;
                    } else {
                        // Remember that those dead vertices have
                        // `elt.vertex` as a descendant.
                        descendants.insert((v.vertex, elt.vertex));
                    }
                }
            }

Insertion in libpijul/src/apply.rs at line 693 [7.944089]
[4.2236]
[4.2236]
```
                    debug!("on path: {:?}", v);
```

Replacement in libpijul/src/apply.rs at line 707 [7.944089]

B:BD[4.2971] → [4.2971:3015]

                            elt.last_alive,

[4.2971]

[4.3015]

                            v.last_alive,

Replacement in libpijul/src/apply.rs at line 715 [7.944089]

B:BD[4.3330] → [4.3330:3409]

                        descendants.insert((v.vertex, stack[len - 1].vertex));

[4.3330]

[4.3409]

                        descendants.insert((v.vertex, elt.vertex));

Replacement in libpijul/src/apply.rs at line 898 [7.944089]

B:BD[27.3809] → [29.5424:5481]

fn collect_missing_contexts<T: GraphMutTxnT + TreeTxnT>(

[27.3809]

[29.5481]

pub fn collect_missing_contexts<T: GraphMutTxnT + TreeTxnT>(

Replacement in libpijul/src/apply.rs at line 951 [7.944089]

B:BD[7.976997] → [29.7258:7345]

                has_missing_edge_context(txn, channel, change_id, change, n, inodes)?;

[7.976997]

[15.133135]

                has_missing_edge_context(txn, channel, change_id, change, n, inodes, false)?;

Replacement in libpijul/src/apply.rs at line 958 [7.944089]

B:BD[13.24008] → [29.7346:7403]

fn has_missing_edge_context<T: GraphMutTxnT + TreeTxnT>(

[13.24008]

[29.7403]

/// Collect inodes with missing contexts into `inodes`.
pub(crate) fn has_missing_edge_context<T: GraphMutTxnT + TreeTxnT>(

Insertion in libpijul/src/apply.rs at line 966 [7.944089]
[29.7487]
[14.42707]
```
    reverse: bool,
```

Replacement in libpijul/src/apply.rs at line 969 [7.944089]

B:BD[29.7545] → [29.7545:8133]

B:BD[29.8133] → [28.36342:36481]

∅:D[28.36481] → [29.8311:8416]

B:BD[30.1384] → [29.8311:8416]

    if !inodes.contains(&inode) {
        for e in n.edges.iter() {
            assert!(!e.flag.contains(EdgeFlags::PARENT));
            if e.flag.contains(EdgeFlags::DELETED) {
                trace!("repairing context deleted {:?}", e);
                if has_missing_context_deleted(txn, channel, change_id, |h| change.knows(&h), e)
                    .map_err(LocalApplyError::from_missing)?
                {
                    inodes.insert(inode);
                    break;
                }
            } else {
                trace!("repairing context nondeleted {:?}", e);
                if has_missing_context_nondeleted(txn, channel, change_id, e)
                    .map_err(LocalApplyError::from_missing)?
                {
                    inodes.insert(inode);
                    break;
                }

[29.7545]

[29.8416]

    // If the inode is already in there, no need to do anything.
    if inodes.contains(&inode) {
        return Ok(());
    }
    let ext: Hash = if reverse {
        (*txn.get_external(&change_id).unwrap().unwrap()).into()
    } else {
        // Unused, hence we avoid one Sanakirja lookup.
        Hash::None
    };
    for e in n.edges.iter() {
        let e = if reverse {
            e.reverse(Some(ext))
        } else {
            e.clone()
        };
        assert!(!e.flag.contains(EdgeFlags::PARENT));
        if e.flag.contains(EdgeFlags::DELETED) {
            trace!("repairing context deleted {:?}", e);
            if has_missing_context_deleted(txn, channel, change_id, |h| change.knows(&h), &e)
                .map_err(LocalApplyError::from_missing)?
            {
                inodes.insert(inode);
                break;
            }
        } else {
            trace!("repairing context nondeleted {:?}", e);
            if has_missing_context_nondeleted(txn, channel, change_id, &e)
                .map_err(LocalApplyError::from_missing)?
            {
                inodes.insert(inode);
                break;

Replacement in libpijul/src/apply/edge.rs at line 118 [16.96160]
B:BD[16.99267] → [10.1552:1589]
```
fn collect_nondeleted_zombies<T, K>(
```
[16.99267]
[16.99307]
```
pub fn collect_nondeleted_zombies<T, K>(
```
Replacement in libpijul/src/apply/edge.rs at line 224 [16.96160]
B:BD[16.102516] → [14.43866:43919]
```
fn collect_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(
```
[16.102516]
[16.102558]
```
pub fn collect_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(
```
Replacement in libpijul/src/apply/edge.rs at line 263 [16.96160]
B:BD[16.103722] → [14.43959:44014]
```
fn reconnect_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(
```
[16.103722]
[16.103766]
```
pub fn reconnect_pseudo_edges<T: GraphMutTxnT + TreeTxnT>(
```

Insertion in libpijul/src/alive/output.rs at line 130 [7.988425]

[31.7130]

[32.6094]

                    debug!("end zombie conflict {id} (line {})", line!());

Insertion in libpijul/src/alive/output.rs at line 137 [7.988425]

[31.7281]

[32.6209]

                debug!("end zombie conflict {id} (line {})", line!());

Replacement in libpijul/src/alive/output.rs at line 213 [7.988425]

B:BD[31.7560] → [3.0:47]

        vbuf.begin_cyclic_conflict::<P>(*id)?;

[31.7560]

[7.993175]

        debug!("begin cyclic conflict {id_cyclic}");
        vbuf.begin_cyclic_conflict::<P>(id_cyclic)?;

Insertion in libpijul/src/alive/output.rs at line 222 [7.988425]
[31.7638]
[33.9909]
```
                debug!("begin zombie conflict {id}");
```
Insertion in libpijul/src/alive/output.rs at line 228 [7.988425]
[31.7863]
[32.6448]
```
            debug!("end zombie conflict {id}");
```

Fixing a bug in unrecord

Dependencies

In channels

Change contents

Replacement in libpijul/src/unrecord/mod.rs at line 264 [7.231493]

Insertion in libpijul/src/unrecord/mod.rs at line 270 [7.231493]

Insertion in libpijul/src/unrecord/mod.rs at line 285 [7.231493]

Deletion in libpijul/src/unrecord/mod.rs at line 422 [7.231493]

Replacement in libpijul/src/unrecord/mod.rs at line 433 [7.231493]

Replacement in libpijul/src/unrecord/mod.rs at line 441 [7.231493]

Replacement in libpijul/src/unrecord/mod.rs at line 470 [7.231493]

Replacement in libpijul/src/unrecord/mod.rs at line 492 [7.231493]

Insertion in libpijul/src/unrecord/mod.rs at line 529 [7.231493]

Insertion in libpijul/src/unrecord/mod.rs at line 572 [7.231493]

Insertion in libpijul/src/unrecord/mod.rs at line 598 [7.231493]

Insertion in libpijul/src/unrecord/mod.rs at line 716 [7.231493]

Replacement in libpijul/src/missing_context.rs at line 24 [7.696460]

Replacement in libpijul/src/missing_context.rs at line 236 [7.696460]

Replacement in libpijul/src/missing_context.rs at line 243 [7.696460]

Replacement in libpijul/src/missing_context.rs at line 246 [7.696460]

Replacement in libpijul/src/missing_context.rs at line 256 [7.696460]

Replacement in libpijul/src/lib.rs at line 18 [7.717381]

Replacement in libpijul/src/lib.rs at line 23 [7.717381]

Insertion in libpijul/src/change.rs at line 215 [7.831311]

Replacement in libpijul/src/change.rs at line 250 [7.831311]

Insertion in libpijul/src/change.rs at line 330 [7.831311]

Insertion in libpijul/src/change.rs at line 355 [7.831311]

Insertion in libpijul/src/change.rs at line 369 [7.831311]

Insertion in libpijul/src/change.rs at line 372 [7.831311]

Insertion in libpijul/src/change.rs at line 377 [7.831311]

Insertion in libpijul/src/change.rs at line 394 [7.831311]

Replacement in libpijul/src/change.rs at line 418 [7.831311]

Insertion in libpijul/src/change.rs at line 1090 [7.831311]

Replacement in libpijul/src/change.rs at line 1099 [7.831311]

Replacement in libpijul/src/change.rs at line 1113 [7.831311]

Replacement in libpijul/src/change.rs at line 1123 [7.831311]

Insertion in libpijul/src/change.rs at line 1391 [7.831311]

Insertion in libpijul/src/change.rs at line 1394 [7.831311]

Insertion in libpijul/src/change/text_changes.rs at line 265 [25.37976]

Replacement in libpijul/src/apply.rs at line 10 [7.944089]

Replacement in libpijul/src/apply.rs at line 12 [7.944089]

Replacement in libpijul/src/apply.rs at line 519 [7.944089]

Deletion in libpijul/src/apply.rs at line 598 [7.944089]

Deletion in libpijul/src/apply.rs at line 600 [7.944089]

Insertion in libpijul/src/apply.rs at line 602 [7.944089]

Insertion in libpijul/src/apply.rs at line 613 [7.944089]

Insertion in libpijul/src/apply.rs at line 693 [7.944089]

Replacement in libpijul/src/apply.rs at line 707 [7.944089]

Replacement in libpijul/src/apply.rs at line 715 [7.944089]

Replacement in libpijul/src/apply.rs at line 898 [7.944089]

Replacement in libpijul/src/apply.rs at line 951 [7.944089]

Replacement in libpijul/src/apply.rs at line 958 [7.944089]

Insertion in libpijul/src/apply.rs at line 966 [7.944089]

Replacement in libpijul/src/apply.rs at line 969 [7.944089]

Replacement in libpijul/src/apply/edge.rs at line 118 [16.96160]

Replacement in libpijul/src/apply/edge.rs at line 224 [16.96160]

Replacement in libpijul/src/apply/edge.rs at line 263 [16.96160]

Insertion in libpijul/src/alive/output.rs at line 130 [7.988425]

Insertion in libpijul/src/alive/output.rs at line 137 [7.988425]

Replacement in libpijul/src/alive/output.rs at line 213 [7.988425]

Insertion in libpijul/src/alive/output.rs at line 222 [7.988425]

Insertion in libpijul/src/alive/output.rs at line 228 [7.988425]