Nicer conflict markers

pmeunier

Dec 8, 2021, 10:31 AM

GA3P7FOMATKDOGCZDYWLZJHAUNOWMRIP3BXTYFEH7PNWTTYYVLIAC

Dependencies

• [2] LOJL4HMY Recording a prefix we just deleted (mostly useful in `pijul git`, regular records returned NotFound)
• [3] OY3CGEHQ Early stop in the diff algorithms for diff --short
• [4] TVVW53HZ Conflict resolution
• [5] DNQHXWRZ address clippy hard errors
• [6] SXEYMYF7 Fixing the bad changes in history (unfortunately, by rebooting).
• [7] VO5OQW4W Removing anyhow in libpijul
• [8] CCLLB7OI Upgrading to Sanakirja 0.15 + version bump
• [9] Z7J55B4P Fix the concatenation of repository root and file when recording
• [10] GUL4M5FI Cleanup and formatting
• [11] WKX5S4Z4 remove unneccesary explicit lifetimes
• [12] JACZYXK4 Fixing a bug in unrecord
• [13] Z6FWHKCA Improving the UI around zombie conflicts

Change contents

• replacement in pijul/src/commands/credit.rs at line 157
  [4.182632]→[4.1109:1191](∅→∅)
  − fn output_conflict_marker(&mut self, s: &str) -> Result<(), std::io::Error> {
  [4.182632]

  [4.182713]
  + fn output_conflict_marker(

  + &mut self,

  + marker: &str,

  + id: usize,

  + sides: &[&Hash],

  + ) -> Result<(), std::io::Error> {
• replacement in pijul/src/commands/credit.rs at line 164
  [4.182741]→[4.0:45](∅→∅),[4.45]→[4.182782:182799](∅→∅),[4.182782]→[4.182782:182799](∅→∅),[4.182799]→[4.46:97](∅→∅)
  − self.w.write_all(s.as_bytes())?;

  − } else {

  − self.w.write_all(&s.as_bytes()[1..])?;
  [4.182741]

  [4.182846]
  + self.w.write_all(b"\n")?;

  + }

  + write!(self.w, "{} {}", marker, id)?;

  + for side in sides {

  + let h = side.to_base32();

  + write!(self.w, " [{}]", h.split_at(8).0)?;
• edit in pijul/src/commands/credit.rs at line 171
  [4.182856]

  [4.182856]
  + self.w.write_all(b"\n")?;
• replacement in libpijul/src/working_copy/filesystem.rs at line 65
  [2.743]→[2.743:838](∅→∅)
  − Component::CurDir => {},

  − Component::ParentDir => { p.pop(); },
  [2.743]

  [2.838]
  + Component::CurDir => {}

  + Component::ParentDir => {

  + p.pop();

  + }
• replacement in libpijul/src/vertex_buffer.rs at line 3
  [4.217283]→[4.172:243](∅→∅)
  − pub const START_MARKER: &str = "\n>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>\n";
  [4.217283]

  [4.217362]
  + pub const START_MARKER: &str = ">>>>>>>";
• replacement in libpijul/src/vertex_buffer.rs at line 5
  [4.217363]→[4.244:312](∅→∅)
  − pub const SEPARATOR: &str = "\n================================\n";
  [4.217363]

  [4.217439]
  + pub const SEPARATOR: &str = "=======";
• replacement in libpijul/src/vertex_buffer.rs at line 7
  [4.217440]→[4.313:382](∅→∅)
  − pub const END_MARKER: &str = "\n<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<\n";
  [4.217440]

  [4.217517]
  + pub const END_MARKER: &str = "<<<<<<<";
• replacement in libpijul/src/vertex_buffer.rs at line 19
  [4.217953]→[4.5173:5319](∅→∅),[4.5319]→[4.218097:218147](∅→∅),[4.218097]→[4.218097:218147](∅→∅)
  − fn output_conflict_marker(&mut self, s: &str) -> Result<(), std::io::Error>;

  − fn begin_conflict(&mut self) -> Result<(), std::io::Error> {

  − self.output_conflict_marker(START_MARKER)
  [4.217953]

  [4.218147]
  + fn output_conflict_marker(

  + &mut self,

  + s: &str,

  + id: usize,

  + sides: &[&Hash],

  + ) -> Result<(), std::io::Error>;

  + fn begin_conflict(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {

  + self.output_conflict_marker(START_MARKER, id, side)
• replacement in libpijul/src/vertex_buffer.rs at line 28
  [4.218153]→[4.5320:5392](∅→∅),[4.5392]→[4.218224:218254](∅→∅),[4.218224]→[4.218224:218254](∅→∅)
  − fn begin_zombie_conflict(&mut self) -> Result<(), std::io::Error> {

  − self.begin_conflict()
  [4.218153]

  [4.218254]
  + fn begin_zombie_conflict(

  + &mut self,

  + id: usize,

  + add_del: &[&Hash],

  + ) -> Result<(), std::io::Error> {

  + self.output_conflict_marker(START_MARKER, id, add_del)
• replacement in libpijul/src/vertex_buffer.rs at line 35
  [4.218260]→[4.5393:5465](∅→∅),[4.5465]→[4.218331:218361](∅→∅),[4.218331]→[4.218331:218361](∅→∅)
  − fn begin_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

  − self.begin_conflict()
  [4.218260]

  [4.218361]
  + fn begin_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {

  + self.output_conflict_marker(START_MARKER, id, &[])
• replacement in libpijul/src/vertex_buffer.rs at line 38
  [4.218367]→[4.5466:5530](∅→∅),[4.5530]→[4.218430:218477](∅→∅),[4.218430]→[4.218430:218477](∅→∅)
  − fn conflict_next(&mut self) -> Result<(), std::io::Error> {

  − self.output_conflict_marker(SEPARATOR)
  [4.218367]

  [4.218477]
  + fn conflict_next(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {

  + self.output_conflict_marker(SEPARATOR, id, side)
• replacement in libpijul/src/vertex_buffer.rs at line 41
  [4.218483]→[4.5531:5594](∅→∅),[4.5594]→[4.218545:218593](∅→∅),[4.218545]→[4.218545:218593](∅→∅)
  − fn end_conflict(&mut self) -> Result<(), std::io::Error> {

  − self.output_conflict_marker(END_MARKER)
  [4.218483]

  [4.218593]
  + fn end_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {

  + self.output_conflict_marker(END_MARKER, id, &[])
• replacement in libpijul/src/vertex_buffer.rs at line 44
  [4.218599]→[4.5595:5665](∅→∅),[4.5665]→[4.0:28](∅→∅)
  − fn end_zombie_conflict(&mut self) -> Result<(), std::io::Error> {

  − self.end_conflict()
  [4.218599]

  [4.218716]
  + fn end_zombie_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {

  + self.end_conflict(id)
• replacement in libpijul/src/vertex_buffer.rs at line 47
  [4.218722]→[4.5666:5736](∅→∅),[4.5736]→[4.218791:218839](∅→∅),[4.218791]→[4.218791:218839](∅→∅)
  − fn end_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

  − self.output_conflict_marker(END_MARKER)
  [4.218722]

  [4.218839]
  + fn end_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {

  + self.output_conflict_marker(END_MARKER, id, &[])
• replacement in libpijul/src/vertex_buffer.rs at line 107
  [4.220451]→[4.5917:5999](∅→∅)
  − fn output_conflict_marker(&mut self, s: &str) -> Result<(), std::io::Error> {
  [4.220451]

  [4.220532]
  + fn output_conflict_marker(

  + &mut self,

  + s: &str,

  + id: usize,

  + sides: &[&Hash],

  + ) -> Result<(), std::io::Error> {
• replacement in libpijul/src/vertex_buffer.rs at line 116
  [4.220651]→[4.98:143](∅→∅)
  − self.w.write_all(s.as_bytes())?;
  [4.220651]

  [4.220692]
  + self.w.write_all(b"\n")?;
• replacement in libpijul/src/vertex_buffer.rs at line 119
  [4.220738]→[4.220738:220786](∅→∅),[4.220786]→[4.144:195](∅→∅)
  − debug!("{:?}", &s.as_bytes()[1..]);

  − self.w.write_all(&s.as_bytes()[1..])?;
  [4.220738]

  [4.220833]
  + debug!("{:?}", s.as_bytes());

  + }

  + write!(self.w, "{} {}", s, id)?;

  + for side in sides {

  + let h = side.to_base32();

  + write!(self.w, " [{}]", h.split_at(8).0)?;
• edit in libpijul/src/vertex_buffer.rs at line 126
  [4.220843]

  [4.220843]
  + self.w.write_all(b"\n")?;
• replacement in libpijul/src/vertex_buffer.rs at line 131
  [4.220895]→[4.6000:6065](∅→∅)
  − fn begin_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.220895]

  [4.220959]
  + fn begin_conflict(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {
• replacement in libpijul/src/vertex_buffer.rs at line 136
  [4.221103]→[4.221103:221153](∅→∅)
  − self.output_conflict_marker(START_MARKER)
  [4.221103]

  [4.221153]
  + self.output_conflict_marker(START_MARKER, id, side)
• replacement in libpijul/src/vertex_buffer.rs at line 138
  [4.221159]→[4.6066:6138](∅→∅)
  − fn begin_zombie_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.221159]

  [4.221230]
  + fn begin_zombie_conflict(

  + &mut self,

  + id: usize,

  + add_del: &[&Hash],

  + ) -> Result<(), std::io::Error> {
• replacement in libpijul/src/vertex_buffer.rs at line 147
  [4.221375]→[4.221375:221425](∅→∅)
  − self.output_conflict_marker(START_MARKER)
  [4.221375]

  [4.221425]
  + self.output_conflict_marker(START_MARKER, id, add_del)
• replacement in libpijul/src/vertex_buffer.rs at line 149
  [4.221431]→[4.6139:6211](∅→∅)
  − fn begin_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.221431]

  [4.221502]
  + fn begin_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
• replacement in libpijul/src/vertex_buffer.rs at line 154
  [4.221647]→[4.221647:221697](∅→∅)
  − self.output_conflict_marker(START_MARKER)
  [4.221647]

  [4.221697]
  + self.output_conflict_marker(START_MARKER, id, &[])
• replacement in libpijul/src/vertex_buffer.rs at line 211
  [4.222923]→[4.6392:6474](∅→∅)
  − fn output_conflict_marker(&mut self, s: &str) -> Result<(), std::io::Error> {
  [4.222923]

  [4.223004]
  + fn output_conflict_marker(

  + &mut self,

  + s: &str,

  + id: usize,

  + sides: &[&Hash],

  + ) -> Result<(), std::io::Error> {
• replacement in libpijul/src/vertex_buffer.rs at line 219
  [4.223094]→[4.196:241](∅→∅),[4.241]→[4.223135:223200](∅→∅),[4.223135]→[4.223135:223200](∅→∅),[4.223200]→[4.242:293](∅→∅)
  − self.w.write_all(s.as_bytes())?;

  − } else {

  − debug!("{:?}", &s.as_bytes()[1..]);

  − self.w.write_all(&s.as_bytes()[1..])?;
  [4.223094]

  [4.223247]
  + self.w.write_all(b"\n")?;

  + }

  + write!(self.w, "{} {}", s, id)?;

  + for side in sides {

  + let h = side.to_base32();

  + write!(self.w, " [{}]", h.split_at(8).0)?;
• edit in libpijul/src/vertex_buffer.rs at line 226
  [4.223257]

  [4.223257]
  + self.w.write_all(b"\n")?;
• replacement in libpijul/src/vertex_buffer.rs at line 230
  [4.223279]→[4.6475:6540](∅→∅),[4.6540]→[4.223343:223393](∅→∅),[4.223343]→[4.223343:223393](∅→∅)
  − fn begin_conflict(&mut self) -> Result<(), std::io::Error> {

  − self.output_conflict_marker(START_MARKER)
  [4.223279]

  [4.223393]
  + fn begin_conflict(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {

  + self.output_conflict_marker(START_MARKER, id, side)
• replacement in libpijul/src/vertex_buffer.rs at line 233
  [4.223399]→[4.71:134](∅→∅)
  − fn end_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.223399]

  [4.134]
  + fn end_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
• replacement in libpijul/src/vertex_buffer.rs at line 235
  [4.166]→[4.166:214](∅→∅)
  − self.output_conflict_marker(END_MARKER)
  [4.166]

  [4.214]
  + self.output_conflict_marker(END_MARKER, id, &[])
• replacement in libpijul/src/vertex_buffer.rs at line 237
  [4.220]→[4.6541:6613](∅→∅),[4.223399]→[4.6541:6613](∅→∅)
  − fn begin_zombie_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.220]

  [4.221]
  + fn begin_zombie_conflict(

  + &mut self,

  + id: usize,

  + add_del: &[&Hash],

  + ) -> Result<(), std::io::Error> {
• replacement in libpijul/src/vertex_buffer.rs at line 246
  [4.320]→[4.320:354](∅→∅)
  − self.begin_conflict()
  [4.320]

  [4.354]
  + self.output_conflict_marker(START_MARKER, id, add_del)
• replacement in libpijul/src/vertex_buffer.rs at line 249
  [4.370]→[4.370:440](∅→∅)
  − fn end_zombie_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.370]

  [4.440]
  + fn end_zombie_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
• replacement in libpijul/src/vertex_buffer.rs at line 251
  [4.472]→[4.472:520](∅→∅)
  − self.output_conflict_marker(END_MARKER)
  [4.472]

  [4.223520]
  + self.output_conflict_marker(END_MARKER, id, &[])
• replacement in libpijul/src/vertex_buffer.rs at line 253
  [4.223526]→[4.6614:6686](∅→∅),[4.6686]→[4.223597:223647](∅→∅),[4.223597]→[4.223597:223647](∅→∅)
  − fn begin_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {

  − self.output_conflict_marker(START_MARKER)
  [4.223526]

  [4.223647]
  + fn begin_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {

  + self.output_conflict_marker(START_MARKER, id, &[])
• replacement in libpijul/src/diff/vertex_buffer.rs at line 157
  [4.32714]→[4.32714:32779](∅→∅)
  − fn begin_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.32714]

  [4.774201]
  + fn begin_conflict(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {
• replacement in libpijul/src/diff/vertex_buffer.rs at line 159
  [4.774252]→[4.774252:774317](∅→∅)
  − self.output_conflict_marker(vertex_buffer::START_MARKER)
  [4.774252]

  [4.774317]
  + self.output_conflict_marker(vertex_buffer::START_MARKER, id, side)
• replacement in libpijul/src/diff/vertex_buffer.rs at line 162
  [4.774324]→[4.32780:32852](∅→∅)
  − fn begin_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.774324]

  [4.774395]
  + fn begin_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
• replacement in libpijul/src/diff/vertex_buffer.rs at line 166
  [4.774541]→[4.774541:774606](∅→∅)
  − self.output_conflict_marker(vertex_buffer::START_MARKER)
  [4.774541]

  [4.774606]
  + self.output_conflict_marker(vertex_buffer::START_MARKER, id, &[])
• replacement in libpijul/src/diff/vertex_buffer.rs at line 169
  [4.774613]→[4.32853:32925](∅→∅)
  − fn begin_zombie_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.774613]

  [4.774684]
  + fn begin_zombie_conflict(

  + &mut self,

  + id: usize,

  + add_del: &[&Hash],

  + ) -> Result<(), std::io::Error> {
• replacement in libpijul/src/diff/vertex_buffer.rs at line 175
  [4.774736]→[4.774736:774801](∅→∅)
  − self.output_conflict_marker(vertex_buffer::START_MARKER)
  [4.774736]

  [4.774801]
  + self.output_conflict_marker(vertex_buffer::START_MARKER, id, add_del)
• replacement in libpijul/src/diff/vertex_buffer.rs at line 178
  [4.32927]→[4.32927:32990](∅→∅)
  − fn end_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.32927]

  [4.774928]
  + fn end_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
• replacement in libpijul/src/diff/vertex_buffer.rs at line 187
  [4.775223]→[4.775223:775288](∅→∅)
  − self.output_conflict_marker(vertex_buffer::END_MARKER)?;
  [4.775223]

  [4.775288]
  + self.output_conflict_marker(vertex_buffer::END_MARKER, id, &[])?;
• replacement in libpijul/src/diff/vertex_buffer.rs at line 194
  [4.775540]→[4.32991:33061](∅→∅)
  − fn end_cyclic_conflict(&mut self) -> Result<(), std::io::Error> {
  [4.775540]

  [4.775609]
  + fn end_cyclic_conflict(&mut self, id: usize) -> Result<(), std::io::Error> {
• replacement in libpijul/src/diff/vertex_buffer.rs at line 196
  [4.775648]→[4.775648:775678](∅→∅)
  − self.end_conflict()?;
  [4.775648]

  [4.775678]
  + self.end_conflict(id)?;
• replacement in libpijul/src/diff/vertex_buffer.rs at line 201
  [4.33063]→[4.33063:33127](∅→∅)
  − fn conflict_next(&mut self) -> Result<(), std::io::Error> {
  [4.33063]

  [4.775903]
  + fn conflict_next(&mut self, id: usize, side: &[&Hash]) -> Result<(), std::io::Error> {
• replacement in libpijul/src/diff/vertex_buffer.rs at line 211
  [4.776274]→[4.776274:776336](∅→∅)
  − self.output_conflict_marker(vertex_buffer::SEPARATOR)
  [4.776274]

  [4.776336]
  + self.output_conflict_marker(vertex_buffer::SEPARATOR, id, side)
• replacement in libpijul/src/diff/vertex_buffer.rs at line 214
  [4.33129]→[4.33129:33216](∅→∅)
  − fn output_conflict_marker(&mut self, marker: &str) -> Result<(), std::io::Error> {
  [4.33129]

  [4.776487]
  + fn output_conflict_marker(

  + &mut self,

  + marker: &str,

  + id: usize,

  + sides: &[&Hash],

  + ) -> Result<(), std::io::Error> {
• replacement in libpijul/src/diff/vertex_buffer.rs at line 228
  [4.776719]→[4.776719:777145](∅→∅)
  − let pos = match self.contents_a.last() {

  − Some(&b'\n') | None => {

  − let len = self.contents_a.len();

  − self.contents_a.extend(marker.as_bytes().iter().skip(1));

  − len

  − }

  − _ => {

  − let len = self.contents_a.len() + 1;

  − self.contents_a.extend(marker.as_bytes().iter());

  − len

  − }

  − };
  [4.776719]

  [4.777145]
  + match self.contents_a.last() {

  + Some(&b'\n') | None => {}

  + _ => self.contents_a.push(b'\n'),

  + }

  + let pos = self.contents_a.len();

  + use std::io::Write;

  + write!(self.contents_a, "{} {}", marker, id)?;

  + for side in sides {

  + let h = side.to_base32();

  + write!(self.contents_a, " [{}]", h.split_at(8).0)?;

  + }

  + self.contents_a.write_all(b"\n")?;

  +
• replacement in libpijul/src/diff/diff.rs at line 15
  [4.801776]→[3.480:582](∅→∅)
  − pub(super) fn diff(lines_a: &[Line], lines_b: &[Line], algorithm: Algorithm, stop_early: bool) -> D {
  [4.801776]

  [3.582]
  + pub(super) fn diff(

  + lines_a: &[Line],

  + lines_b: &[Line],

  + algorithm: Algorithm,

  + stop_early: bool,

  + ) -> D {
• replacement in libpijul/src/diff/diff.rs at line 45
  [4.802409]→[3.739:767](∅→∅)
  − .unwrap_or(()),
  [4.802409]

  [4.802428]
  + .unwrap_or(()),
• replacement in libpijul/src/alive/output.rs at line 30
  [4.989204]→[4.507:538](∅→∅)
  − let mut is_zombie = false;
  [4.989204]

  [4.989204]
  + let mut is_zombie = None;

  + let mut id = 0;
• edit in libpijul/src/alive/output.rs at line 34
  [4.989290]

  [4.989353]
  + let id0 = id;
• edit in libpijul/src/alive/output.rs at line 51
  [4.990046]

  [4.990046]
  + match elt.conflict[elt.side].path[elt.idx] {

  + PathElement::Scc { scc } => {

  + let vid = sccs[scc][0];

  + let ext = txn.get_external(&graph[vid].vertex.change)?.unwrap();

  + line_buf.begin_conflict(id, &[&ext.into()])?;

  + }

  + _ => {

  + line_buf.begin_conflict(id, &[])?;

  + }

  + }

  + id += 1;
• replacement in libpijul/src/alive/output.rs at line 67
  [4.990237]→[4.539:662](∅→∅)
  − if is_zombie {

  − is_zombie = false;

  − line_buf.end_zombie_conflict()?;
  [4.990237]

  [4.662]
  + if let Some(id) = is_zombie.take() {

  + line_buf.end_zombie_conflict(id)?;
• replacement in libpijul/src/alive/output.rs at line 70
  [4.680]→[4.990237:990280](∅→∅),[4.990237]→[4.990237:990280](∅→∅)
  − line_buf.conflict_next()?;
  [4.680]

  [4.990280]
  + match elt.conflict[elt.side].path[elt.idx] {

  + PathElement::Scc { scc } => {

  + let vid = sccs[scc][0];

  + let ext = txn.get_external(&graph[vid].vertex.change)?.unwrap();

  + line_buf.conflict_next(id0, &[&ext.into()])?;

  + }

  + _ => {

  + line_buf.conflict_next(id0, &[])?;

  + }

  + }
• replacement in libpijul/src/alive/output.rs at line 84
  [4.990469]→[4.681:777](∅→∅)
  − output_scc(changes, txn, graph, &sccs[scc], &mut is_zombie, line_buf)?;
  [4.990469]

  [4.990549]
  + output_scc(

  + changes,

  + txn,

  + graph,

  + &sccs[scc],

  + &mut is_zombie,

  + &mut id,

  + line_buf,

  + )?;
• replacement in libpijul/src/alive/output.rs at line 113
  [4.991266]→[4.778:901](∅→∅)
  − if is_zombie {

  − is_zombie = false;

  − line_buf.end_zombie_conflict()?;
  [4.991266]

  [4.901]
  + if let Some(id) = is_zombie.take() {

  + line_buf.end_zombie_conflict(id)?;
• replacement in libpijul/src/alive/output.rs at line 116
  [4.919]→[4.991266:991308](∅→∅),[4.991266]→[4.991266:991308](∅→∅)
  − line_buf.end_conflict()?;
  [4.919]

  [4.991308]
  + line_buf.end_conflict(id0)?;
• replacement in libpijul/src/alive/output.rs at line 119
  [4.991339]→[4.920:1031](∅→∅)
  − if is_zombie {

  − is_zombie = false;

  − line_buf.end_zombie_conflict()?;
  [4.991339]

  [4.1031]
  + if let Some(id) = is_zombie.take() {

  + line_buf.end_zombie_conflict(id)?;
• replacement in libpijul/src/alive/output.rs at line 126
  [4.1052]→[4.1052:1112](∅→∅)
  − if is_zombie {

  − line_buf.end_zombie_conflict()?;
  [4.1052]

  [4.991416]
  + if let Some(id) = is_zombie.take() {

  + line_buf.end_zombie_conflict(id)?;
• replacement in libpijul/src/alive/output.rs at line 188
  [4.993063]→[4.1113:1139](∅→∅)
  − is_zombie: &mut bool,
  [4.993063]

  [4.993063]
  + is_zombie: &mut Option<usize>,

  + id: &mut usize,
• edit in libpijul/src/alive/output.rs at line 192
  [4.137371]

  [4.993114]
  + let id_cyclic = *id;
• replacement in libpijul/src/alive/output.rs at line 194
  [4.993137]→[4.100525:100564](∅→∅)
  − vbuf.begin_cyclic_conflict()?;
  [4.993137]

  [4.993175]
  + vbuf.begin_cyclic_conflict(*id)?;

  + *id += 1;
• replacement in libpijul/src/alive/output.rs at line 200
  [4.993305]→[4.1140:1251](∅→∅)
  − if !*is_zombie {

  − *is_zombie = true;

  − vbuf.begin_zombie_conflict()?;
  [4.993305]

  [4.1251]
  + if is_zombie.is_none() {

  + *is_zombie = Some(*id);

  + let hash = txn.get_external(&graph[v].vertex.change)?.unwrap();

  + vbuf.begin_zombie_conflict(*id, &[&hash.into()])?;

  + *id += 1
• replacement in libpijul/src/alive/output.rs at line 206
  [4.1265]→[4.1265:1369](∅→∅)
  − } else if *is_zombie {

  − *is_zombie = false;

  − vbuf.end_zombie_conflict()?;
  [4.1265]

  [4.993348]
  + } else if let Some(id) = is_zombie.take() {

  + vbuf.end_zombie_conflict(id)?;
• replacement in libpijul/src/alive/output.rs at line 234
  [4.994106]→[4.994106:994143](∅→∅)
  − vbuf.end_cyclic_conflict()?;
  [4.994106]

  [4.994143]
  + vbuf.end_cyclic_conflict(id_cyclic)?;
• edit in libpijul/src/alive/output.rs at line 263
  [4.989411]→[4.989411:989451](∅→∅)
  − line_buf.begin_conflict()?;