pijul/pijul - Change JUX2S7I2TLI2AF6DACY7YLIH5TWIA7Q42I3C3SCYTD2ABMWN43FQC

address a bunch of lints and code quality issues

Created by Ew7KaBx3ZgcVt6vMZm8hureVbCfQnKorjAHNEqH9tdvH on December 7, 2021

JUX2S7I2TLI2AF6DACY7YLIH5TWIA7Q42I3C3SCYTD2ABMWN43FQC

Dependencies

In discussions

#578 address a bunch of lints and code quality issues

Change contents

Insertion in rustfmt.toml at line 2 [15.15]
[15.33]
```
use_field_init_shorthand = true
```

Replacement in pijul-macros/src/lib.rs at line 482 [16.445]

B:BD[16.16213] → [16.16213:16387]

    let key = proc_macro2::TokenStream::from_iter(next(&mut input_iter).into_iter());
    let value = proc_macro2::TokenStream::from_iter(next(&mut input_iter).into_iter());

[16.16213]

[16.16387]

    let key = proc_macro2::TokenStream::from_iter(next(&mut input_iter));
    let value = proc_macro2::TokenStream::from_iter(next(&mut input_iter));

Replacement in pijul-macros/src/lib.rs at line 487 [16.445]
B:BD[17.4823] → [17.4823:4879]
```
        proc_macro2::TokenStream::from(quote! { TxnT })
```
[17.4823]
[17.4879]
```
        quote! { TxnT }
```

Replacement in pijul-macros/src/lib.rs at line 489 [16.445]

B:BD[17.4892] → [17.4892:4954]

        proc_macro2::TokenStream::from_iter(txnt.into_iter())

[17.4892]

[17.4954]

        proc_macro2::TokenStream::from_iter(txnt)

Replacement in pijul-macros/src/lib.rs at line 494 [16.445]
B:BD[17.5065] → [17.5065:5127]
```
        proc_macro2::TokenStream::from(quote! { GraphError })
```
[17.5065]
[17.5127]
```
        quote! { GraphError }
```

Replacement in pijul-macros/src/lib.rs at line 496 [16.445]

B:BD[17.5140] → [17.5140:5203]

        proc_macro2::TokenStream::from_iter(error.into_iter())

[17.5140]

[17.5203]

        proc_macro2::TokenStream::from_iter(error)

Replacement in libpijul/src/working_copy/mod.rs at line 28 [16.198172]
B:BD[18.33] → [18.33:73]
```
        self.read_file(&file, buffer)?;
```
[18.33]
[18.73]
```
        self.read_file(file, buffer)?;
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 50 [16.208900]
B:BD[16.209304] → [13.269:304]
```
        Cow::Borrowed(repo.into())
```
[16.209304]
[16.209341]
```
        Cow::Borrowed(repo)
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 65 [16.208900]

B:BD[13.743] → [13.743:838]

                Component::CurDir => {},
                Component::ParentDir => { p.pop(); },

[13.743]

[13.838]

                Component::CurDir => {}
                Component::ParentDir => {
                    p.pop();
                }

Replacement in libpijul/src/working_copy/filesystem.rs at line 169 [16.208900]
B:BD[19.752] → [20.1720:1755]
```
                repo_path.clone(),
```
[19.752]
[19.779]
```
                repo_path,
```

Replacement in libpijul/src/working_copy/filesystem.rs at line 187 [16.208900]

B:BD[21.3672] → [21.3672:3758]

        for p in self.iterate_prefix_rec(repo_path.clone(), full.clone(), threads)? {

[21.3672]

[21.3758]

        for p in self.iterate_prefix_rec(repo_path, full, threads)? {

Replacement in libpijul/src/working_copy/filesystem.rs at line 247 [16.208900]

B:BD[22.1058] → [23.296:394]

                                if p.ends_with("~") || (p.starts_with("#") && p.ends_with("#")) {

[22.1058]

[22.1188]

                                if p.ends_with('~') || (p.starts_with('#') && p.ends_with('#')) {

Replacement in libpijul/src/working_copy/filesystem.rs at line 308 [16.208900]
B:BD[24.535] → [24.535:560]
```
            txn.clone(),
```
[24.535]
[24.560]
```
            txn,
```
Replacement in libpijul/src/working_copy/filesystem.rs at line 367 [16.208900]
B:BD[25.1384] → [25.1384:1439]
```
        Ok(std::fs::create_dir_all(&self.path(file))?)
```
[25.1384]
[25.1439]
```
        std::fs::create_dir_all(&self.path(file))
```

Replacement in libpijul/src/unrecord/mod.rs at line 62 [16.231493]

B:BD[16.232079] → [17.22651:22721]

    let unused = unused_in_other_channels(txn, &channel, change_id)?;

[16.232079]

[26.859]

    let unused = unused_in_other_channels(txn, channel, change_id)?;

Replacement in libpijul/src/tag.rs at line 482 [27.6397]
B:BD[27.19898] → [27.19898:19922]
```
            tags: tags,
```
[27.19898]
[27.19922]
```
            tags,
```

Replacement in libpijul/src/record.rs at line 413 [16.488880]

B:BD[26.97174] → [26.97174:97231]

∅:D[26.97231] → [28.47703:47765]

B:BD[28.47703] → [28.47703:47765]

                    let mut channel = channel.r.write();
                    let mut graph = txn.graph(&mut *channel);

[26.97174]

[28.47765]

                    let channel = channel.r.write();
                    let graph = txn.graph(&channel);

Replacement in libpijul/src/record.rs at line 417 [16.488880]
B:BD[28.47851] → [28.47851:47887]
```
                        &mut graph,
```
[28.47851]
[26.97232]
```
                        graph,
```
Replacement in libpijul/src/record.rs at line 609 [16.488880]
B:BD[28.53115] → [28.53115:53149]
```
                        &channel,
```
[28.53115]
[28.53149]
```
                        channel,
```
Replacement in libpijul/src/record.rs at line 987 [16.488880]
B:BD[29.8417] → [29.8417:8440]
```
                &item,
```
[29.8417]
[29.8440]
```
                item,
```

Replacement in libpijul/src/record.rs at line 1029 [16.488880]

B:BD[29.9912] → [29.9912:9955]

                &self.actions.len() - len,

[29.9912]

[29.9955]

                self.actions.len() - len,

Replacement in libpijul/src/record.rs at line 1063 [16.488880]

B:BD[11.86] → [11.86:145]

            moved.resurrect.extend(moved.alive.drain(..));

[11.86]

[30.6276]

            moved.resurrect.append(&mut moved.alive);

Replacement in libpijul/src/record.rs at line 1065 [16.488880]

B:BD[30.6314] → [30.6314:6377]

                moved.resurrect.extend(moved.edges.drain(..));

[30.6314]

[30.6377]

                moved.resurrect.append(&mut moved.edges);

Replacement in libpijul/src/record.rs at line 1089 [16.488880]
B:BD[31.1901] → [31.1901:1941]
```
            encoding: encoding.clone(),
```
[31.1901]
[16.509236]
```
            encoding,
```

Replacement in libpijul/src/record.rs at line 1099 [16.488880]

B:BD[11.371] → [11.371:434]

                    moved.edges.extend(moved.alive.drain(..));

[11.371]

[11.434]

                    moved.edges.append(&mut moved.alive);

Replacement in libpijul/src/record.rs at line 1141 [16.488880]

B:BD[32.169] → [32.169:237]

        std::mem::replace(&mut self.updatables, HashMap::default())

[32.169]

[32.237]

        std::mem::take(&mut self.updatables)

Replacement in libpijul/src/record.rs at line 1165 [16.488880]

B:BD[32.956] → [32.956:1146]

        Ok(crate::change::LocalChange::make_change(
            txn,
            &channel,
            actions,
            contents,
            header,
            Vec::new(),
        )?)

[32.956]

[16.510502]

        crate::change::LocalChange::make_change(txn, channel, actions, contents, header, Vec::new())

Replacement in libpijul/src/pristine/sanakirja.rs at line 162 [16.531056]

B:BD[27.22535] → [27.22535:22595]

                return Err(SanakirjaError::Version.into());

[27.22535]

[27.22595]

                return Err(SanakirjaError::Version);

Replacement in libpijul/src/pristine/sanakirja.rs at line 358 [16.531056]
∅:D[33.1653] → [34.64580:64638]
B:BD[34.64580] → [34.64580:64638]
```
        ::sanakirja::debug::check_free(&self.txn, &refs);
```
[33.1653]
[16.542213]
```
        ::sanakirja::debug::check_free(&self.txn, refs);
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 410 [16.531056]

B:BD[35.30500] → [34.65574:65642]

            match btree::get(&self.txn, &self.internal, &p, None) {

[35.30500]

[34.65642]

            match btree::get(&self.txn, &self.internal, p, None) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 511 [16.531056]

B:BD[34.67196] → [34.67196:67285]

        btree::cursor::Cursor::new(txn, &graph).map_err(|x| BlockError::Txn(x.into()))?;

[34.67196]

[36.7888]

        btree::cursor::Cursor::new(txn, graph).map_err(|x| BlockError::Txn(x.into()))?;

Replacement in libpijul/src/pristine/sanakirja.rs at line 718 [16.531056]
B:BD[37.2226] → [34.70686:70723]
```
        channel.apply_counter.into()
```
[37.2226]
[35.39486]
```
        channel.apply_counter
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 721 [16.531056]
B:BD[37.2289] → [34.70724:70761]
```
        channel.last_modified.into()
```
[37.2289]
[35.39577]
```
        channel.last_modified
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1271 [16.531056]

B:BD[38.27022] → [26.98701:98762]

        match self.open_remotes.lock().entry(name.clone()) {

[38.27022]

[36.8251]

        match self.open_remotes.lock().entry(name) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1279 [16.531056]

B:BD[38.27289] → [38.27289:27343]

                        id_rev: remote.id_rev.into(),

[38.27289]

[38.27343]

                        id_rev: remote.id_rev,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1302 [16.531056]
B:BD[16.551179] → [36.9534:9572]
```
                _ => return Ok(None),
```
[16.551179]
[36.9572]
```
                _ => Ok(None),
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1400 [16.531056]

B:BD[38.28104] → [26.98763:98824]

        match self.open_remotes.lock().entry(name.clone()) {

[38.28104]

[36.9588]

        match self.open_remotes.lock().entry(name) {

Replacement in libpijul/src/pristine/sanakirja.rs at line 1408 [16.531056]

B:BD[38.28383] → [38.28383:28441]

                            id_rev: remote.id_rev.into(),

[38.28383]

[38.28441]

                            id_rev: remote.id_rev,

Replacement in libpijul/src/pristine/sanakirja.rs at line 1602 [16.531056]
B:BD[35.47850] → [34.83576:83621]
```
            channel.last_modified = t.into()
```
[35.47850]
[35.47888]
```
            channel.last_modified = t
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1604 [16.531056]

B:BD[35.47984] → [34.83622:83684]

            channel.last_modified = duration.as_secs().into()

[35.47984]

[35.48039]

            channel.last_modified = duration.as_secs()

Replacement in libpijul/src/pristine/sanakirja.rs at line 1643 [16.531056]
B:BD[34.84483] → [34.84483:84514]
```
            Ok(Some(m.into()))
```
[34.84483]
[16.561074]
```
            Ok(Some(m))
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1763 [16.531056]
B:BD[34.85876] → [34.85876:85918]
```
            &Pair { a: h, b: m.clone() },
```
[34.85876]
[34.85918]
```
            &Pair { a: h, b: m },
```
Replacement in libpijul/src/pristine/sanakirja.rs at line 1779 [16.531056]
B:BD[34.86262] → [34.86262:86297]
```
                let p = p.clone();
```
[34.86262]
[34.86297]
```
                let p = *p;
```

Replacement in libpijul/src/pristine/sanakirja.rs at line 1782 [16.531056]

B:BD[34.86446] → [34.86446:86629]

                Ok(btree::del(
                    &mut self.txn,
                    &mut remote.remote,
                    &k.into(),
                    None,
                )?)

[34.86446]

[34.86629]

                Ok(btree::del(&mut self.txn, &mut remote.remote, &k, None)?)

Replacement in libpijul/src/pristine/sanakirja.rs at line 2029 [16.531056]

B:BD[38.30751] → [38.30751:30809]

                            id_rev: remote.id_rev.into(),

[38.30751]

[38.30809]

                            id_rev: remote.id_rev,

Replacement in libpijul/src/pristine/sanakirja.rs at line 2076 [16.531056]

B:BD[16.570575] → [26.99955:100081]

            let open_channels =
                std::mem::replace(self.open_channels.lock().deref_mut(), HashMap::default());

[16.570575]

[16.570703]

            let open_channels = std::mem::take(self.open_channels.lock().deref_mut());

Replacement in libpijul/src/pristine/sanakirja.rs at line 2083 [16.531056]

B:BD[16.570887] → [26.100082:100206]

            let open_remotes =
                std::mem::replace(self.open_remotes.lock().deref_mut(), HashMap::default());

[16.570887]

[34.92228]

            let open_remotes = std::mem::take(self.open_remotes.lock().deref_mut());

Replacement in libpijul/src/pristine/sanakirja.rs at line 2205 [16.531056]
B:BD[38.32795] → [38.32795:32833]
```
            _id_rev: r.id_rev.into(),
```
[38.32795]
[38.32833]
```
            _id_rev: r.id_rev,
```
Replacement in libpijul/src/pristine/path_id.rs at line 42 [16.584967]
B:BD[16.585964] → [16.585964:586017]
```
            parent_inode: self.parent_inode.clone(),
```
[16.585964]
[16.586017]
```
            parent_inode: self.parent_inode,
```
Replacement in libpijul/src/pristine/mod.rs at line 214 [16.586748]
B:BD[38.35211] → [26.101354:101406]
```
    pub fn set_id_revision(&self, rev: u64) -> () {
```
[38.35211]
[26.101406]
```
    pub fn set_id_revision(&self, rev: u64) {
```
Replacement in libpijul/src/pristine/mod.rs at line 236 [16.586748]
B:BD[16.588808] → [38.35416:35449]
```
            id: self.id.clone(),
```
[16.588808]
[38.35449]
```
            id: self.id,
```
Replacement in libpijul/src/pristine/mod.rs at line 500 [16.586748]
B:BD[7.295] → [7.295:313]
```
            g: g,
```
[7.295]
[7.313]
```
            g,
```

Replacement in libpijul/src/pristine/mod.rs at line 810 [16.586748]

B:BD[17.61472] → [34.103869:103938]

        Some(ref h) => Ok(txn.get_internal(&h.into())?.map(|x| *x)),

[17.61472]

[17.61473]

        Some(ref h) => Ok(txn.get_internal(&h.into())?.copied()),

Replacement in libpijul/src/pristine/mod.rs at line 888 [16.586748]

B:BD[17.62677] → [37.2954:3021]

        .rev_cursor_revchangeset(txn.rev_changes(&channel), None)?

[17.62677]

[39.40311]

        .rev_cursor_revchangeset(txn.rev_changes(channel), None)?

Replacement in libpijul/src/pristine/mod.rs at line 905 [16.586748]

B:BD[17.63316] → [37.3074:3144]

    Ok(txn.rev_cursor_revchangeset(txn.rev_changes(&channel), from)?)

[17.63316]

[39.40926]

    txn.rev_cursor_revchangeset(txn.rev_changes(&channel), from)

Replacement in libpijul/src/pristine/mod.rs at line 921 [16.586748]
B:BD[36.15155] → [36.15155:15194]
```
            txn.rev_changes(&channel),
```
[36.15155]
[36.15194]
```
            txn.rev_changes(channel),
```

Replacement in libpijul/src/pristine/mod.rs at line 941 [16.586748]

B:BD[17.63962] → [36.15248:15361]

        iter: txn
            .rev_cursor_revchangeset(txn.rev_changes(&channel), Some(from_timestamp.into()))?,

[17.63962]

[39.41610]

        iter: txn.rev_cursor_revchangeset(txn.rev_changes(channel), Some(from_timestamp.into()))?,

Replacement in libpijul/src/pristine/mod.rs at line 961 [16.586748]
∅:D[34.104530] → [35.53761:53800]
B:BD[35.53761] → [35.53761:53800]
```
        Some(Err(e)) => Err(e.into()),
```
[34.104530]
[35.53800]
```
        Some(Err(e)) => Err(e),
```

Replacement in libpijul/src/pristine/mod.rs at line 1130 [16.586748]

B:BD[40.17878] → [7.705:769]

    let mut cursor = txn.graph_cursor(&channel, None).unwrap();

[40.17878]

[39.45536]

    let mut cursor = txn.graph_cursor(channel, None).unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 1134 [16.586748]

B:BD[39.45655] → [35.54091:54155]

    while let Some(x) = txn.next_graph(&channel, &mut cursor) {

[39.45655]

[17.66350]

    while let Some(x) = txn.next_graph(channel, &mut cursor) {

Replacement in libpijul/src/pristine/mod.rs at line 1163 [16.586748]
B:BD[39.46446] → [39.46446:46468]
```
            &channel,
```
[39.46446]
[39.46468]
```
            channel,
```

Replacement in libpijul/src/pristine/mod.rs at line 1171 [16.586748]

B:BD[17.66516] → [34.105363:105433]

            stack.push(*txn.find_block(&channel, e.dest()).unwrap());

[17.66516]

[16.614068]

            stack.push(*txn.find_block(channel, e.dest()).unwrap());

Replacement in libpijul/src/pristine/mod.rs at line 1178 [16.586748]

B:BD[28.70044] → [7.770:834]

    let mut cursor = txn.graph_cursor(&channel, None).unwrap();

[28.70044]

[35.54329]

    let mut cursor = txn.graph_cursor(channel, None).unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 1185 [16.586748]

B:BD[39.47042] → [35.54331:54395]

    while let Some(x) = txn.next_graph(&channel, &mut cursor) {

[39.47042]

[34.105434]

    while let Some(x) = txn.next_graph(channel, &mut cursor) {

Replacement in libpijul/src/pristine/mod.rs at line 1192 [16.586748]

B:BD[17.66698] → [17.66698:66783]

                    find_file(txn, &channel, k0, &mut stack, &mut visited).unwrap(),

[17.66698]

[17.66783]

                    find_file(txn, channel, k0, &mut stack, &mut visited).unwrap(),

Replacement in libpijul/src/pristine/mod.rs at line 1215 [16.586748]

B:BD[41.4618] → [17.66803:66890]

            let file = find_file(txn, &channel, k, &mut stack, &mut visited).unwrap();

[41.4618]

[41.4696]

            let file = find_file(txn, channel, k, &mut stack, &mut visited).unwrap();

Replacement in libpijul/src/pristine/mod.rs at line 1222 [16.586748]

B:BD[17.66939] → [17.66939:67016]

            find_file(txn, &channel, k0, &mut stack, &mut visited).unwrap(),

[17.66939]

[17.67016]

            find_file(txn, channel, k0, &mut stack, &mut visited).unwrap(),

Replacement in libpijul/src/pristine/mod.rs at line 1244 [16.586748]

B:BD[39.48684] → [17.67147:67237]

        for e in iter_adjacent(txn, &channel, kk, EdgeFlags::PARENT, EdgeFlags::all())? {

[39.48684]

[17.67237]

        for e in iter_adjacent(txn, channel, kk, EdgeFlags::PARENT, EdgeFlags::all())? {

Replacement in libpijul/src/pristine/mod.rs at line 1360 [16.586748]

B:BD[16.618942] → [34.107022:107088]

    } else if let Ok(dest) = txn.find_block(&channel, v.dest()) {

[16.618942]

[16.619006]

    } else if let Ok(dest) = txn.find_block(channel, v.dest()) {

Replacement in libpijul/src/pristine/mod.rs at line 1504 [16.586748]
B:BD[16.623307] → [17.69988:70035]
```
        while let Some(x) = self.iter.next() {
```
[16.623307]
[34.108615]
```
        for x in self.iter.by_ref() {
```

Replacement in libpijul/src/pristine/mod.rs at line 1567 [16.586748]

B:BD[16.624262] → [34.109258:109358]

                match is_ancestor_of(self.txn, self.txn.graph(&self.channel), self.key, *touched) {

[16.624262]

[36.15914]

                match is_ancestor_of(self.txn, self.txn.graph(self.channel), self.key, *touched) {

Replacement in libpijul/src/pristine/mod.rs at line 2065 [16.586748]

B:BD[42.3892] → [37.3675:3736]

        .rev_cursor_revchangeset(txn.rev_changes(&c), None)?

[42.3892]

[42.3952]

        .rev_cursor_revchangeset(txn.rev_changes(c), None)?

Replacement in libpijul/src/pristine/mod.rs at line 2070 [16.586748]
B:BD[34.111755] → [34.111755:111794]
```
        Ok(Some((b, state.b.clone())))
```
[34.111755]
[42.4037]
```
        Ok(Some((b, state.b)))
```

Replacement in libpijul/src/pristine/mod.rs at line 2127 [16.586748]

B:BD[43.1006] → [34.112243:112314]

        if !is_alive(txn, &channel, &vertex.inode_vertex()).unwrap() {

[43.1006]

[17.76835]

        if !is_alive(txn, channel, &vertex.inode_vertex()).unwrap() {

Replacement in libpijul/src/pristine/merkle.rs at line 67 [16.638683]

B:BD[16.640467] → [16.640467:640609]

        let bytes = if let Ok(b) = data_encoding::BASE32_NOPAD.decode(s) {
            b
        } else {
            return None;
        };

[16.640467]

[2.0]

        let bytes = data_encoding::BASE32_NOPAD.decode(s).ok()?;

Replacement in libpijul/src/pristine/hash.rs at line 72 [16.644439]

B:BD[16.646354] → [16.646354:646434]

        if s.len() >= 1 + BLAKE3_BYTES && s[0] == HashAlgorithm::Blake3 as u8 {

[16.646354]

[16.646434]

        if s.len() > BLAKE3_BYTES && s[0] == HashAlgorithm::Blake3 as u8 {

Replacement in libpijul/src/pristine/hash.rs at line 87 [16.644439]

B:BD[16.646836] → [16.646836:646989]

        let bytes = if let Ok(bytes) = data_encoding::BASE32_NOPAD.decode(&b32) {
            bytes
        } else {
            return None;
        };

[16.646836]

[16.646989]

        let bytes = data_encoding::BASE32_NOPAD.decode(&b32).ok()?;

Replacement in libpijul/src/pristine/hash.rs at line 110 [16.644439]

B:BD[16.647741] → [16.647741:647883]

        let bytes = if let Ok(s) = data_encoding::BASE32_NOPAD.decode(s) {
            s
        } else {
            return None;
        };

[16.647741]

[44.2790]

        let bytes = data_encoding::BASE32_NOPAD.decode(s).ok()?;

Deletion in libpijul/src/pristine/hash.rs at line 201 [16.644439]
B:BD[34.115901] → [34.115901:115952]
```
        } else if self.t == b.t {
            true
```
Replacement in libpijul/src/pristine/hash.rs at line 202 [16.644439]
B:BD[34.115969] → [34.115969:115987]
```
            false
```
[34.115969]
[34.115987]
```
            self.t == b.t
```
Replacement in libpijul/src/pristine/hash.rs at line 243 [16.644439]
B:BD[34.116960] → [34.116960:117004]
```
                h: H { blake3: s.clone() },
```
[34.116960]
[34.117004]
```
                h: H { blake3: *s },
```
Replacement in libpijul/src/pristine/edge.rs at line 107 [16.648958]
B:BD[34.117745] → [34.117745:117782]
```
        let ref mut f = (self.0)[0];
```
[34.117745]
[34.117782]
```
        let f = &mut (self.0)[0];
```

Replacement in libpijul/src/pristine/change_id.rs at line 29 [16.666427]

B:BD[16.667267] → [45.0:154]

        let len = if let Ok(len) = data_encoding::BASE32_NOPAD.decode_len(b.len()) {
            len
        } else {
            return None;
        };

[16.667267]

[3.0]

        let len = data_encoding::BASE32_NOPAD.decode_len(b.len()).ok()?;

Replacement in libpijul/src/output/output.rs at line 109 [16.671807]
B:BD[28.74923] → [28.74923:74950]
```
                    &repo,
```
[28.74923]
[8.464]
```
                    repo,
```

Replacement in libpijul/src/output/output.rs at line 289 [16.671807]

B:BD[29.16201] → [29.16201:16281]

                kill_dead_files::<T, R, P>(&mut *txn, &channel, &repo, &dead)?;

[29.16201]

[28.77878]

                kill_dead_files::<T, R, P>(&mut *txn, channel, repo, &dead)?;

Replacement in libpijul/src/output/output.rs at line 395 [16.671807]

B:BD[29.19924] → [29.19924:20004]

            let path = std::mem::replace(&mut output_item.path, String::new());

[29.19924]

[29.20004]

            let path = std::mem::take(&mut output_item.path);

Replacement in libpijul/src/output/output.rs at line 398 [16.671807]
B:BD[29.20084] → [29.20084:20107]
```
                &repo,
```
[29.20084]
[29.20107]
```
                repo,
```
Replacement in libpijul/src/output/output.rs at line 403 [16.671807]
B:BD[29.20221] → [29.20221:20249]
```
                &file_name,
```
[29.20221]
[29.20249]
```
                file_name,
```

Insertion in libpijul/src/output/output.rs at line 430 [16.671807]

[29.20967]

            } else if needs_output(repo, self.if_modified_after, &path) {
                self.work
                    .push((output_item.clone(), inode, path.clone(), tmp.clone()));

Replacement in libpijul/src/output/output.rs at line 434 [16.671807]

B:BD[29.20988] → [29.20988:21089]

B:BD[29.21089] → [8.580:668]

∅:D[8.668] → [29.21170:21251]

B:BD[29.21170] → [29.21170:21251]

∅:D[29.21251] → [16.678892:678910]

B:BD[16.678892] → [16.678892:678910]

                if needs_output(repo, self.if_modified_after, &path) {
                    self.work
                        .push((output_item.clone(), inode, path.clone(), tmp.clone()));
                } else {
                    debug!("Not outputting {:?}", path)
                }

[29.20988]

[29.21252]

                debug!("Not outputting {:?}", path)

Replacement in libpijul/src/output/output.rs at line 490 [16.671807]
B:BD[16.679990] → [16.679990:680043]
```
        basename: SmallString::from_str(&file_name),
```
[16.679990]
[16.680043]
```
        basename: SmallString::from_str(file_name),
```

Replacement in libpijul/src/output/output.rs at line 517 [16.671807]

B:BD[16.681223] → [40.21340:21394]

                repo.rename(&current_name, &tmp_path)

[16.681222]

[40.21394]

                repo.rename(current_name, &tmp_path)

Replacement in libpijul/src/output/output.rs at line 604 [16.671807]
B:BD[8.709] → [8.709:747]
```
            .write_file(&path, inode)
```
[8.709]
[8.747]
```
            .write_file(path, inode)
```

Replacement in libpijul/src/output/output.rs at line 606 [16.671807]

∅:D[8.796] → [26.103237:103315]

B:BD[28.81670] → [26.103237:103315]

        let mut f = vertex_buffer::ConflictsWriter::new(w, &path, conflicts);

[8.796]

[28.81760]

        let mut f = vertex_buffer::ConflictsWriter::new(w, path, conflicts);

Replacement in libpijul/src/output/output.rs at line 684 [16.671807]

B:BD[5.695] → [5.695:774]

                        if let Some(vertex) = txn.get_inodes(&inode_, None)? {

[5.695]

[5.774]

                        if let Some(vertex) = txn.get_inodes(inode_, None)? {

Replacement in libpijul/src/output/output.rs at line 717 [16.671807]
B:BD[16.685693] → [34.121753:121802]
```
        del_tree_with_rev(txn, &fileid, inode)?;
```
[16.685693]
[4.703]
```
        del_tree_with_rev(txn, fileid, inode)?;
```
Replacement in libpijul/src/output/output.rs at line 723 [16.671807]
B:BD[4.902] → [4.902:950]
```
        txn.del_tree(&file_id_, Some(&inode))?;
```
[4.902]
[34.121802]
```
        txn.del_tree(&file_id_, Some(inode))?;
```

Replacement in libpijul/src/output/output.rs at line 734 [16.671807]

B:BD[47.596] → [48.806:857]

                    repo.remove_path(&name, false)

[47.596]

[48.857]

                    repo.remove_path(name, false)

Replacement in libpijul/src/output/archive.rs at line 61 [16.690044]

B:BD[16.691496] → [16.691496:691562]

            buf: std::mem::replace(&mut self.buffer, Vec::new()),

[16.691496]

[16.691562]

            buf: std::mem::take(&mut self.buffer),

Replacement in libpijul/src/output/archive.rs at line 213 [16.690044]

∅:D[49.5361] → [16.694807:694891]

B:BD[16.694807] → [16.694807:694891]

                let path = std::mem::replace(&mut output_item.path, String::new());

[49.5361]

[50.0]

                let path = std::mem::take(&mut output_item.path);

Replacement in libpijul/src/key.rs at line 134 [51.5013]

B:BD[51.8892] → [51.8892:8938]

                    expires: expires.clone(),

[51.8892]

[51.8938]

                    expires: *expires,

Replacement in libpijul/src/key.rs at line 146 [51.5013]

B:BD[51.9229] → [51.9229:9330]

                    bincode::serialize(&(Algorithm::Ed25519, expires.clone(), key.public)).unwrap();

[51.9229]

[51.9330]

                    bincode::serialize(&(Algorithm::Ed25519, expires, key.public)).unwrap();

Replacement in libpijul/src/key.rs at line 152 [51.5013]

B:BD[51.9687] → [51.9687:9733]

                    expires: expires.clone(),

[51.9687]

[6.1745]

                    expires: *expires,

Replacement in libpijul/src/key.rs at line 164 [51.5013]

B:BD[51.10091] → [51.10091:10192]

                    bincode::serialize(&(Algorithm::Ed25519, expires.clone(), key.public)).unwrap();

[51.10091]

[51.10192]

                    bincode::serialize(&(Algorithm::Ed25519, expires, key.public)).unwrap();

Replacement in libpijul/src/key.rs at line 168 [51.5013]

B:BD[51.10464] → [51.10464:10555]

                    expires: expires.clone(),
                    key: key.public.clone(),

[51.10464]

[38.38827]

                    expires: *expires,
                    key: key.public,

Replacement in libpijul/src/key.rs at line 210 [51.5013]

B:BD[51.11735] → [51.11735:11865]

                    bincode::serialize(&(Algorithm::Ed25519, self.expires.clone(), &self.key))
                        .unwrap();

[51.11735]

[38.39174]

                    bincode::serialize(&(Algorithm::Ed25519, self.expires, &self.key)).unwrap();

Replacement in libpijul/src/key.rs at line 228 [51.5013]

B:BD[51.12601] → [38.39593:39619]

∅:D[38.39619] → [51.12630:12730]

B:BD[51.12630] → [51.12630:12730]

                let msg =
                    bincode::serialize(&(Algorithm::Ed25519, self.expires.clone(), &key)).unwrap();

[51.12601]

[38.39620]

                let msg = bincode::serialize(&(Algorithm::Ed25519, self.expires, &key)).unwrap();

Replacement in libpijul/src/key.rs at line 232 [51.5013]

B:BD[51.12924] → [51.12924:12975]

                    expires: self.expires.clone(),

[51.12924]

[51.12975]

                    expires: self.expires,

Replacement in libpijul/src/key.rs at line 377 [51.5013]

B:BD[52.4102] → [52.4102:4149]

                ed25519: k.as_bytes().clone(),

[52.4102]

[52.4149]

                ed25519: *k.as_bytes(),

Replacement in libpijul/src/fs.rs at line 385 [16.737429]

B:BD[17.105682] → [17.105682:105732]

                        if k.basename.len() > 0 {

[17.105682]

[34.131344]

                        if !k.basename.is_empty() {

Replacement in libpijul/src/fs.rs at line 624 [16.737429]
∅:D[29.26900] → [17.109690:109758]
∅:D[35.61410] → [17.109690:109758]
∅:D[34.131956] → [17.109690:109758]
B:BD[17.109690] → [17.109690:109758]
```
        let mut buf = std::mem::replace(&mut self.buf, Vec::new());
```
[29.26900]
[53.1605]
```
        let mut buf = std::mem::take(&mut self.buf);
```
Replacement in libpijul/src/fs.rs at line 722 [16.737429]
∅:D[10.116] → [16.755231:755303]
∅:D[36.18754] → [16.755231:755303]
∅:D[35.61875] → [16.755231:755303]
∅:D[39.63214] → [16.755231:755303]
∅:D[34.132238] → [16.755231:755303]
B:BD[16.755231] → [16.755231:755303]
```
            let mut buf = std::mem::replace(&mut self.buf, Vec::new());
```
[10.116]
[53.1750]
```
            let mut buf = std::mem::take(&mut self.buf);
```

Replacement in libpijul/src/fs.rs at line 1012 [16.737429]

B:BD[50.631] → [50.631:729]

pub fn get_latest_touch<'a, T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>(

[50.631]

[50.729]

pub fn get_latest_touch<T: ChannelTxnT + DepsTxnT<DepsError = <T as GraphTxnT>::GraphError>>(

Replacement in libpijul/src/fs.rs at line 1020 [16.737429]

B:BD[50.970] → [50.970:1033]

    let mut log_iter = changeid_rev_log(txn, &channel, None)?;

[50.970]

[50.1033]

    let mut log_iter = changeid_rev_log(txn, channel, None)?;

Insertion in libpijul/src/diff/replace.rs at line 10 [16.779907]
[54.1]
[16.780322]
```
#[derive(Default)]
```

Replacement in libpijul/src/diff/replace.rs at line 20 [16.779907]

B:BD[16.780591] → [16.780591:780618]

B:BD[16.780618] → [28.85663:85827]

∅:D[28.85827] → [16.780766:780776]

B:BD[16.780766] → [16.780766:780776]

        ConflictContexts {
            side_ends: HashMap::default(),
            up: HashMap::default(),
            active: HashSet::default(),
            reorderings: HashMap::default(),
        }

[16.780591]

[16.780776]

        Self::default()

Replacement in libpijul/src/diff/replace.rs at line 186 [16.779907]

B:BD[16.786271] → [16.786271:786348]

    if let Some(ref up) = conflict_contexts.side_ends.get(&up_context_idx) {

[16.786212]

[16.786348]

    if let Some(up) = conflict_contexts.side_ends.get(&up_context_idx) {

Replacement in libpijul/src/diff/mod.rs at line 144 [16.793247]
∅:D[28.86502] → [16.794500:794570]
B:BD[16.794500] → [16.794500:794570]
```
        let mut d = vertex_buffer::Diff::new(inode, path.clone(), a);
```
[28.86502]
[16.794570]
```
        let mut d = vertex_buffer::Diff::new(inode, path, a);
```

Replacement in libpijul/src/diff/mod.rs at line 152 [16.793247]

B:BD[55.2103] → [55.2103:2176]

            let (bb, new) = bin::make_new_chunks(ROLLING_SIZE, &ah, &b);

[55.2103]

[55.2176]

            let (bb, new) = bin::make_new_chunks(ROLLING_SIZE, &ah, b);

Replacement in libpijul/src/diff/mod.rs at line 156 [16.793247]

B:BD[55.2253] → [56.1929:2004]

            (make_old_lines(&d, separator), make_new_lines(&b, separator))

[55.2253]

[55.2306]

            (make_old_lines(&d, separator), make_new_lines(b, separator))

Replacement in libpijul/src/diff/diff.rs at line 15 [16.801479]

B:BD[16.801776] → [14.480:582]

pub(super) fn diff(lines_a: &[Line], lines_b: &[Line], algorithm: Algorithm, stop_early: bool) -> D {

[16.801776]

[14.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 [16.801479]
B:BD[16.802409] → [14.739:767]
```
            .unwrap_or(()),
```
[16.802409]
[16.802428]
```
        .unwrap_or(()),
```

Replacement in libpijul/src/diff/delete.rs at line 177 [16.805350]

B:BD[17.117025] → [17.117025:117053]

∅:D[17.117053] → [39.65763:65866]

B:BD[39.65763] → [39.65763:65866]

B:BD[39.65866] → [17.117054:117063]

    for e in iter_adjacent(
        txn,
        &channel,
        graph_key,
        EdgeFlags::PARENT,
        EdgeFlags::all(),
    )? {

[17.117025]

[17.117063]

    for e in iter_adjacent(txn, channel, graph_key, EdgeFlags::PARENT, EdgeFlags::all())? {

Replacement in libpijul/src/diff/delete.rs at line 356 [16.805350]
∅:D[39.66060] → [16.816456:816474]
B:BD[16.816456] → [16.816456:816474]
```
        &channel,
```
[39.66060]
[16.816474]
```
        channel,
```
Replacement in libpijul/src/chardetng/tld.rs at line 244 [57.289]
B:BD[57.8070] → [57.8070:8116]
```
static PUNYCODE_KEYS: [&'static [u8]; 46] = [
```
[57.8070]
[57.8116]
```
static PUNYCODE_KEYS: [&[u8]; 46] = [
```
Replacement in libpijul/src/chardetng/mod.rs at line 147 [57.12027]
B:BD[57.16896] → [57.16896:16930]
```
    for &b in label.into_iter() {
```
[57.16896]
[57.16930]
```
    for &b in label {
```
Replacement in libpijul/src/chardetng/mod.rs at line 154 [57.12027]
B:BD[57.17046] → [57.17046:17082]
```
        if b >= b'A' && b <= b'Z' {
```
[57.17046]
[57.17082]
```
        if (b'A'..=b'Z').contains(&b) {
```
Replacement in libpijul/src/chardetng/mod.rs at line 199 [57.12027]
B:BD[57.18037] → [57.18037:18061]
```
            data: data,
```
[57.18037]
[57.18061]
```
            data,
```

Replacement in libpijul/src/chardetng/mod.rs at line 323 [57.12027]

B:BD[57.23454] → [57.23454:23711]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic {
                    score += LATIN_ADJACENCY_PENALTY;
                } else if caseless_class == LATIN_LETTER
                    && self.data.is_non_latin_alphabetic(self.prev, false)

[57.23454]

[57.23711]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic
                    || caseless_class == LATIN_LETTER
                        && self.data.is_non_latin_alphabetic(self.prev, false)

Replacement in libpijul/src/chardetng/mod.rs at line 366 [57.12027]
B:BD[57.24600] → [57.24600:24624]
```
            data: data,
```
[57.24600]
[57.24624]
```
            data,
```
Replacement in libpijul/src/chardetng/mod.rs at line 623 [57.12027]
B:BD[57.36457] → [57.36457:36481]
```
            data: data,
```
[57.36457]
[57.36481]
```
            data,
```

Replacement in libpijul/src/chardetng/mod.rs at line 684 [57.12027]

B:BD[57.38743] → [57.38743:38999]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic {
                    score += LATIN_ADJACENCY_PENALTY;
                } else if caseless_class == LATIN_LETTER
                    && self.data.is_non_latin_alphabetic(self.prev, true)

[57.38743]

[57.38999]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic
                    || caseless_class == LATIN_LETTER
                        && self.data.is_non_latin_alphabetic(self.prev, true)

Replacement in libpijul/src/chardetng/mod.rs at line 710 [57.12027]
B:BD[57.39476] → [57.39476:39500]
```
            data: data,
```
[57.39476]
[57.39500]
```
            data,
```

Replacement in libpijul/src/chardetng/mod.rs at line 744 [57.12027]

B:BD[57.40558] → [57.40558:40815]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic {
                    score += LATIN_ADJACENCY_PENALTY;
                } else if caseless_class == LATIN_LETTER
                    && self.data.is_non_latin_alphabetic(self.prev, false)

[57.40558]

[57.40815]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic
                    || caseless_class == LATIN_LETTER
                        && self.data.is_non_latin_alphabetic(self.prev, false)

Replacement in libpijul/src/chardetng/mod.rs at line 760 [57.12027]

B:BD[57.41080] → [57.41080:41180]

    match byte {
        b'.' | b',' | b':' | b';' | b'?' | b'!' => true,
        _ => false,
    }

[57.41080]

[57.41180]

    matches!(byte, b'.' | b',' | b':' | b';' | b'?' | b'!')

Replacement in libpijul/src/chardetng/mod.rs at line 775 [57.12027]
B:BD[57.41468] → [57.41468:41492]
```
            data: data,
```
[57.41468]
[57.41492]
```
            data,
```

Replacement in libpijul/src/chardetng/mod.rs at line 815 [57.12027]

B:BD[57.42849] → [57.42849:43062]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic {
                    score += LATIN_ADJACENCY_PENALTY;
                } else if caseless_class == LATIN_LETTER && prev_non_ascii_alphabetic {

[57.42849]

[57.43062]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic
                    || caseless_class == LATIN_LETTER && prev_non_ascii_alphabetic
                {

Replacement in libpijul/src/chardetng/mod.rs at line 842 [57.12027]
B:BD[57.43575] → [57.43575:43599]
```
            data: data,
```
[57.43575]
[57.43599]
```
            data,
```

Replacement in libpijul/src/chardetng/mod.rs at line 882 [57.12027]

B:BD[57.44862] → [57.44862:45119]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic {
                    score += LATIN_ADJACENCY_PENALTY;
                } else if caseless_class == LATIN_LETTER
                    && self.data.is_non_latin_alphabetic(self.prev, false)

[57.44862]

[57.45119]

                if self.prev == LATIN_LETTER && non_ascii_alphabetic
                    || caseless_class == LATIN_LETTER
                        && self.data.is_non_latin_alphabetic(self.prev, false)

Replacement in libpijul/src/chardetng/mod.rs at line 1030 [57.12027]

B:BD[57.49053] → [57.49053:49108]

                } else if u >= 0x4E00 && u <= 0x9FA5 {

[57.49053]

[57.49108]

                } else if (0x4E00..=0x9FA5).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1035 [57.12027]

B:BD[57.49287] → [57.49287:49335]

                    if b >= 0xA1 && b <= 0xFE {

[57.49287]

[57.49335]

                    if (0xA1..=0xFE).contains(&b) {

Replacement in libpijul/src/chardetng/mod.rs at line 1054 [57.12027]

B:BD[57.50212] → [57.50212:50299]

                } else if (u >= 0x3400 && u < 0xA000) || (u >= 0xF900 && u < 0xFB00) {

[57.50212]

[57.50299]

                } else if (0x3400..0xA000).contains(&u) || (0xF900..0xFB00).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1064 [57.12027]

B:BD[57.50700] → [57.50700:50754]

                } else if u >= 0xE000 && u < 0xF900 {

[57.50700]

[57.50754]

                } else if (0xE000..0xF900).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1132 [57.12027]

B:BD[57.53771] → [57.53771:53819]

                if u >= 0xDB80 && u <= 0xDBFF {

[57.53771]

[57.53819]

                if (0xDB80..=0xDBFF).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1135 [57.12027]

B:BD[57.53913] → [57.53913:53967]

                } else if u >= 0xD480 && u < 0xD880 {

[57.53913]

[57.53967]

                } else if (0xD480..0xD880).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1158 [57.12027]

B:BD[57.55055] → [57.55055:55137]

                        if (b >= b'a' && b <= b'z') || (b >= b'A' && b <= b'Z') {

[57.55055]

[57.55137]

                        if (b'a'..=b'z').contains(&b) || (b'A'..=b'Z').contains(&b) {

Replacement in libpijul/src/chardetng/mod.rs at line 1207 [57.12027]

B:BD[57.57152] → [57.57152:57270]

    match b {
        0x91..=0x97 | 0x9A | 0x8A | 0x9B | 0x8B | 0x9E | 0x8E | 0xB0 => true,
        _ => false,
    }

[57.57152]

[57.57270]

    matches!(
        b,
        0x91..=0x97 | 0x9A | 0x8A | 0x9B | 0x8B | 0x9E | 0x8E | 0xB0
    )

Replacement in libpijul/src/chardetng/mod.rs at line 1259 [57.12027]

B:BD[57.58927] → [57.58927:58982]

                } else if u >= 0xFF61 && u <= 0xFF9F {

[57.58927]

[57.58982]

                } else if (0xFF61..=0xFF9F).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1268 [57.12027]

B:BD[57.59400] → [57.59400:59469]

                    if (u >= 0xFF76 && u <= 0xFF84) || u == 0xFF73 {

[57.59400]

[57.59469]

                    if (0xFF76..=0xFF84).contains(&u) || u == 0xFF73 {

Replacement in libpijul/src/chardetng/mod.rs at line 1270 [57.12027]

B:BD[57.59561] → [57.59561:59620]

                    } else if u >= 0xFF8A && u <= 0xFF8E {

[57.59561]

[57.59620]

                    } else if (0xFF8A..=0xFF8E).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1293 [57.12027]

B:BD[57.60685] → [57.60685:60739]

                } else if u >= 0x3040 && u < 0x3100 {

[57.60685]

[57.60739]

                } else if (0x3040..0x3100).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1303 [57.12027]

B:BD[57.61161] → [57.61161:61248]

                } else if (u >= 0x3400 && u < 0xA000) || (u >= 0xF900 && u < 0xFB00) {

[57.61161]

[57.61248]

                } else if (0x3400..0xA000).contains(&u) || (0xF900..0xFB00).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1320 [57.12027]

B:BD[57.62088] → [57.62088:62142]

                } else if u >= 0xE000 && u < 0xF900 {

[57.62088]

[57.62142]

                } else if (0xE000..0xF900).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1372 [57.12027]

B:BD[57.64653] → [57.64653:64736]

                        && ((b >= 0x40 && b <= 0x7E) || (b >= 0x80 && b <= 0xFC)))

[57.64653]

[57.64736]

                        && ((0x40..=0x7E).contains(&b) || (0x80..=0xFC).contains(&b)))

Replacement in libpijul/src/chardetng/mod.rs at line 1374 [57.12027]

B:BD[57.64803] → [57.64803:64902]

                            || (self.prev_byte == 0x84 && ((b >= 0xDD && b <= 0xE4) || b >= 0xFB))

[57.64803]

[57.64902]

                            || (self.prev_byte == 0x84
                                && ((0xDD..=0xE4).contains(&b) || b >= 0xFB))

Replacement in libpijul/src/chardetng/mod.rs at line 1452 [57.12027]

B:BD[57.67826] → [57.67826:67878]

                    if u >= 0xFF61 && u <= 0xFF9F {

[57.67826]

[57.67878]

                    if (0xFF61..=0xFF9F).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1455 [57.12027]

B:BD[57.67940] → [57.67940:67991]

                    if u >= 0x3040 && u < 0x3100 {

[57.67940]

[57.67991]

                    if (0x3040..0x3100).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1468 [57.12027]

B:BD[57.68540] → [57.68540:68595]

                } else if u >= 0xFF61 && u <= 0xFF9F {

[57.68540]

[57.68595]

                } else if (0xFF61..=0xFF9F).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1471 [57.12027]

B:BD[57.68652] → [57.68652:68721]

                    if (u >= 0xFF76 && u <= 0xFF84) || u == 0xFF73 {

[57.68652]

[57.68721]

                    if (0xFF76..=0xFF84).contains(&u) || u == 0xFF73 {

Replacement in libpijul/src/chardetng/mod.rs at line 1473 [57.12027]

B:BD[57.68813] → [57.68813:68872]

                    } else if u >= 0xFF8A && u <= 0xFF8E {

[57.68813]

[57.68872]

                    } else if (0xFF8A..=0xFF8E).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1496 [57.12027]

B:BD[57.69940] → [57.69940:70029]

                } else if (u >= 0x3041 && u <= 0x3093) || (u >= 0x30A1 && u <= 0x30F6) {

[57.69940]

[57.70029]

                } else if (0x3041..=0x3093).contains(&u) || (0x30A1..=0x30F6).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1514 [57.12027]

B:BD[57.70769] → [57.70769:70856]

                } else if (u >= 0x3400 && u < 0xA000) || (u >= 0xF900 && u < 0xFB00) {

[57.70769]

[57.70856]

                } else if (0x3400..0xA000).contains(&u) || (0xF900..0xFB00).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1550 [57.12027]

B:BD[57.72425] → [57.72425:72495]

                    if b >= 0xA1
                        && b <= 0xFE

[57.72425]

[57.72495]

                    if (0xA1..=0xFE).contains(&b)

Replacement in libpijul/src/chardetng/mod.rs at line 1638 [57.12027]

B:BD[57.75786] → [57.75786:75873]

                } else if (u >= 0x3400 && u < 0xA000) || (u >= 0xF900 && u < 0xFB00) {

[57.75786]

[57.75873]

                } else if (0x3400..0xA000).contains(&u) || (0xF900..0xFB00).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1714 [57.12027]

B:BD[57.79496] → [57.79496:79578]

                        && ((b >= 0x40 && b <= 0x7E) || (b >= 0xA1 && b <= 0xFE))

[57.79496]

[57.79578]

                        && ((0x40..=0x7E).contains(&b) || (0xA1..=0xFE).contains(&b))

Replacement in libpijul/src/chardetng/mod.rs at line 1739 [57.12027]

B:BD[57.80945] → [57.80945:81027]

                        if (b >= b'a' && b <= b'z') || (b >= b'A' && b <= b'Z') {

[57.80945]

[57.81027]

                        if (b'a'..=b'z').contains(&b) || (b'A'..=b'Z').contains(&b) {

Replacement in libpijul/src/chardetng/mod.rs at line 1805 [57.12027]

B:BD[57.83179] → [57.83179:83234]

            let in_euc_range = b >= 0xA1 && b <= 0xFE;

[57.83179]

[57.83234]

            let in_euc_range = (0xA1..=0xFE).contains(&b);

Replacement in libpijul/src/chardetng/mod.rs at line 1824 [57.12027]

B:BD[57.84053] → [57.84053:84108]

                } else if u >= 0xAC00 && u <= 0xD7A3 {

[57.84053]

[57.84108]

                } else if (0xAC00..=0xD7A3).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1843 [57.12027]

B:BD[57.85029] → [57.85029:85117]

                } else if (u >= 0x4E00 && u < 0xAC00) || (u >= 0xF900 && u <= 0xFA0B) {

[57.85029]

[57.85117]

                } else if (0x4E00..0xAC00).contains(&u) || (0xF900..=0xFA0B).contains(&u) {

Replacement in libpijul/src/chardetng/mod.rs at line 1908 [57.12027]

B:BD[57.88096] → [57.88096:88148]

                        && (b >= 0x7B && b <= 0x7D)

[57.88096]

[57.88148]

                        && (0x7B..=0x7D).contains(&b)

Replacement in libpijul/src/chardetng/mod.rs at line 1925 [57.12027]

B:BD[57.89087] → [57.89087:89169]

                        if (b >= b'a' && b <= b'z') || (b >= b'A' && b <= b'Z') {

[57.89087]

[57.89169]

                        if (b'a'..=b'z').contains(&b) || (b'A'..=b'Z').contains(&b) {

Replacement in libpijul/src/chardetng/mod.rs at line 1992 [57.12027]

B:BD[57.91530] → [57.91530:91756]

                        if let Some(additional_score) = c.feed(b" ") {
                            Some(new_score + additional_score)
                        } else {
                            None
                        }

[57.91530]

[57.91756]

                        c.feed(b" ")
                            .map(|additional_score| new_score + additional_score)

Replacement in libpijul/src/chardetng/mod.rs at line 2005 [57.12027]

B:BD[57.92118] → [57.92118:92344]

                        if let Some(additional_score) = c.feed(b" ") {
                            Some(new_score + additional_score)
                        } else {
                            None
                        }

[57.92118]

[57.92344]

                        c.feed(b" ")
                            .map(|additional_score| new_score + additional_score)

Replacement in libpijul/src/chardetng/mod.rs at line 2018 [57.12027]

B:BD[57.92701] → [57.92701:92927]

                        if let Some(additional_score) = c.feed(b" ") {
                            Some(new_score + additional_score)
                        } else {
                            None
                        }

[57.92701]

[57.92927]

                        c.feed(b" ")
                            .map(|additional_score| new_score + additional_score)

Replacement in libpijul/src/chardetng/mod.rs at line 2031 [57.12027]

B:BD[57.93288] → [57.93288:93514]

                        if let Some(additional_score) = c.feed(b" ") {
                            Some(new_score + additional_score)
                        } else {
                            None
                        }

[57.93288]

[57.93514]

                        c.feed(b" ")
                            .map(|additional_score| new_score + additional_score)

Replacement in libpijul/src/chardetng/mod.rs at line 2044 [57.12027]

B:BD[57.93870] → [57.93870:94096]

                        if let Some(additional_score) = c.feed(b" ") {
                            Some(new_score + additional_score)
                        } else {
                            None
                        }

[57.93870]

[57.94096]

                        c.feed(b" ")
                            .map(|additional_score| new_score + additional_score)

Replacement in libpijul/src/chardetng/mod.rs at line 2057 [57.12027]

B:BD[57.94451] → [57.94451:94677]

                        if let Some(additional_score) = c.feed(b" ") {
                            Some(new_score + additional_score)
                        } else {
                            None
                        }

[57.94451]

[57.94677]

                        c.feed(b" ")
                            .map(|additional_score| new_score + additional_score)

Replacement in libpijul/src/chardetng/mod.rs at line 2650 [57.12027]

B:BD[57.118075] → [57.118075:118286]

            InnerCandidate::Logical(c) => {
                return c.plausible_punctuation;
            }
            InnerCandidate::Visual(c) => {
                return c.plausible_punctuation;
            }

[57.118075]

[57.118286]

            InnerCandidate::Logical(c) => c.plausible_punctuation,
            InnerCandidate::Visual(c) => c.plausible_punctuation,

Replacement in libpijul/src/chardetng/mod.rs at line 2660 [57.12027]

B:BD[57.118442] → [57.118442:119648]

            InnerCandidate::Latin(c) => {
                return c.data.encoding;
            }
            InnerCandidate::NonLatinCased(c) => {
                return c.data.encoding;
            }
            InnerCandidate::Caseless(c) => {
                return c.data.encoding;
            }
            InnerCandidate::ArabicFrench(c) => {
                return c.data.encoding;
            }
            InnerCandidate::Logical(c) => {
                return c.data.encoding;
            }
            InnerCandidate::Visual(c) => {
                return c.data.encoding;
            }
            InnerCandidate::Shift(_) => {
                return SHIFT_JIS;
            }
            InnerCandidate::EucJp(_) => {
                return EUC_JP;
            }
            InnerCandidate::Big5(_) => {
                return BIG5;
            }
            InnerCandidate::EucKr(_) => {
                return EUC_KR;
            }
            InnerCandidate::Gbk(_) => {
                return GBK;
            }
            InnerCandidate::Utf8(_) => {
                return UTF_8;
            }
            InnerCandidate::Iso2022(_) => {
                return ISO_2022_JP;
            }

[57.118442]

[57.119648]

            InnerCandidate::Latin(c) => c.data.encoding,
            InnerCandidate::NonLatinCased(c) => c.data.encoding,
            InnerCandidate::Caseless(c) => c.data.encoding,
            InnerCandidate::ArabicFrench(c) => c.data.encoding,
            InnerCandidate::Logical(c) => c.data.encoding,
            InnerCandidate::Visual(c) => c.data.encoding,
            InnerCandidate::Shift(_) => SHIFT_JIS,
            InnerCandidate::EucJp(_) => EUC_JP,
            InnerCandidate::Big5(_) => BIG5,
            InnerCandidate::EucKr(_) => EUC_KR,
            InnerCandidate::Gbk(_) => GBK,
            InnerCandidate::Utf8(_) => UTF_8,
            InnerCandidate::Iso2022(_) => ISO_2022_JP,

Replacement in libpijul/src/chardetng/mod.rs at line 2892 [57.12027]

B:BD[57.128794] → [58.177:232]

∅:D[58.232] → [57.128849:128923]

∅:D[59.1544] → [57.128849:128923]

B:BD[57.128849] → [57.128849:128923]

B:BD[57.128923] → [58.233:277]

∅:D[58.277] → [57.128967:128981]

∅:D[59.1588] → [57.128967:128981]

B:BD[57.128967] → [57.128967:128981]

        if self.non_ascii_seen == 0 && self.esc_seen {
            if self.candidates[Self::ISO_2022_JP_INDEX].score.is_some() {
                return (ISO_2022_JP, true);
            }

[57.128794]

[57.128981]

        if self.non_ascii_seen == 0
            && self.esc_seen
            && self.candidates[Self::ISO_2022_JP_INDEX].score.is_some()
        {
            return (ISO_2022_JP, true);

Replacement in libpijul/src/chardetng/data.rs at line 1082 [57.154500]

B:BD[57.306690] → [57.306690:308184]

        } else {
            if previous_usize < stored_boundary {
                // Current above, prev below
                if previous_usize == 0
                    || previous_usize == ASCII_DIGIT
                    || (is_windows_1256 && previous_usize == WINDOWS_1256_ZWNJ)
                {
                    // Previous is space-like
                    0
                } else {
                    // Current is alphabetic
                    let current_unstored = current_usize - stored_boundary;
                    match current_unstored {
                        PLAUSIBLE_NEXT_TO_ALPHABETIC_ON_EITHER_SIDE => 0,
                        IMPLAUSIBLE_NEXT_TO_ALPHABETIC_ON_EITHER_SIDE => IMPLAUSIBILITY_PENALTY,
                        IMPLAUSIBLE_BEFORE_ALPHABETIC => 0,
                        IMPLAUSIBLE_AFTER_ALPHABETIC => IMPLAUSIBILITY_PENALTY,
                        PLAUSIBLE_NEXT_TO_NON_ASCII_ALPHABETIC_ON_EITHER_SIDE => {
                            if previous_usize < self.ascii {
                                IMPLAUSIBILITY_PENALTY
                            } else {
                                0
                            }
                        }
                        PLAUSIBLE_NEXT_TO_ASCII_ALPHABETIC_ON_EITHER_SIDE => {
                            if previous_usize < self.ascii {
                                0
                            } else {
                                IMPLAUSIBILITY_PENALTY
                            }

[57.306690]

[57.308184]

        } else if previous_usize < stored_boundary {
            // Current above, prev below
            if previous_usize == 0
                || previous_usize == ASCII_DIGIT
                || (is_windows_1256 && previous_usize == WINDOWS_1256_ZWNJ)
            {
                // Previous is space-like
                0
            } else {
                // Current is alphabetic
                let current_unstored = current_usize - stored_boundary;
                match current_unstored {
                    PLAUSIBLE_NEXT_TO_ALPHABETIC_ON_EITHER_SIDE => 0,
                    IMPLAUSIBLE_NEXT_TO_ALPHABETIC_ON_EITHER_SIDE => IMPLAUSIBILITY_PENALTY,
                    IMPLAUSIBLE_BEFORE_ALPHABETIC => 0,
                    IMPLAUSIBLE_AFTER_ALPHABETIC => IMPLAUSIBILITY_PENALTY,
                    PLAUSIBLE_NEXT_TO_NON_ASCII_ALPHABETIC_ON_EITHER_SIDE => {
                        if previous_usize < self.ascii {
                            IMPLAUSIBILITY_PENALTY
                        } else {
                            0

Replacement in libpijul/src/chardetng/data.rs at line 1104 [57.154500]

B:BD[57.308210] → [57.308210:308315]

                        _ => {
                            debug_assert_eq!(current_usize, ASCII_DIGIT);

[57.308210]

[57.308315]

                    }
                    PLAUSIBLE_NEXT_TO_ASCII_ALPHABETIC_ON_EITHER_SIDE => {
                        if previous_usize < self.ascii {

Insertion in libpijul/src/chardetng/data.rs at line 1108 [57.154500]

[57.308345]

                        } else {
                            IMPLAUSIBILITY_PENALTY

Insertion in libpijul/src/chardetng/data.rs at line 1112 [57.154500]

[57.308393]

                    _ => {
                        debug_assert_eq!(current_usize, ASCII_DIGIT);
                        0
                    }

Deletion in libpijul/src/chardetng/data.rs at line 1117 [57.154500]

B:BD[57.308411] → [57.308411:308605]

            } else if current_usize == ASCII_DIGIT || previous_usize == ASCII_DIGIT {
                0
            } else {
                // Both above
                IMPLAUSIBILITY_PENALTY

Insertion in libpijul/src/chardetng/data.rs at line 1118 [57.154500]

[57.308619]

        } else if current_usize == ASCII_DIGIT || previous_usize == ASCII_DIGIT {
            0
        } else {
            // Both above
            IMPLAUSIBILITY_PENALTY

Replacement in libpijul/src/chardetng/data.rs at line 1130 [57.154500]
B:BD[57.308739] → [57.308739:308815]
```
        (self as *const SingleByteData) == (other as *const SingleByteData)
```
[57.308739]
[57.308815]
```
        std::ptr::eq(self, other)
```

Replacement in libpijul/src/changestore/memory.rs at line 104 [16.820702]

B:BD[16.823381] → [60.1456:1520]

        let hash = p.hash().map_err(|e| Self::Error::from(e))?;

[16.823381]

[60.1520]

        let hash = p.hash().map_err(Self::Error::from)?;

Replacement in libpijul/src/changestore/filesystem.rs at line 90 [16.824013]

∅:D[28.88174] → [16.826317:826399]

B:BD[16.826317] → [16.826317:826399]

            let p = crate::change::ChangeFile::open(h, &path.to_str().unwrap())?;

[28.88174]

[28.88175]

            let p = crate::change::ChangeFile::open(h, path.to_str().unwrap())?;

Replacement in libpijul/src/changestore/filesystem.rs at line 137 [16.824013]

B:BD[16.828061] → [16.828061:828149]

        if let Ok(p) = crate::change::ChangeFile::open(hash, &path.to_str().unwrap()) {

[16.828061]

[16.828149]

        if let Ok(p) = crate::change::ChangeFile::open(hash, path.to_str().unwrap()) {

Replacement in libpijul/src/changestore/filesystem.rs at line 146 [16.824013]

B:BD[16.828343] → [16.828343:828422]

        let p = crate::change::ChangeFile::open(*h, &path.to_str().unwrap())?;

[16.828343]

[16.828422]

        let p = crate::change::ChangeFile::open(*h, path.to_str().unwrap())?;

Replacement in libpijul/src/changestore/filesystem.rs at line 179 [16.824013]

B:BD[16.829392] → [16.829392:829483]

            let mut p = crate::change::ChangeFile::open(change, &path.to_str().unwrap())?;

[16.829392]

[34.137981]

            let mut p = crate::change::ChangeFile::open(change, path.to_str().unwrap())?;

Replacement in libpijul/src/changestore/filesystem.rs at line 239 [16.824013]
B:BD[16.831236] → [16.831236:831290]
```
        Ok(Change::deserialize(&file_name, Some(h))?)
```
[16.831236]
[16.831290]
```
        Ok(Change::deserialize(file_name, Some(h))?)
```
Replacement in libpijul/src/change.rs at line 235 [16.831311]
B:BD[16.837662] → [17.118124:118177]
```
    let deps = minimize_deps(txn, &channel, &deps)?;
```
[16.837662]
[16.837714]
```
    let deps = minimize_deps(txn, channel, &deps)?;
```
Replacement in libpijul/src/change.rs at line 243 [16.831311]
∅:D[34.138223] → [37.6986:7038]
B:BD[17.118290] → [37.6986:7038]
```
        txn.get_changeset(txn.changes(&channel), a)
```
[34.138223]
[17.118291]
```
        txn.get_changeset(txn.changes(channel), a)
```

Replacement in libpijul/src/change.rs at line 245 [16.831311]

B:BD[17.118313] → [37.7039:7111]

            .cmp(&txn.get_changeset(txn.changes(&channel), b).unwrap())

[17.118313]

[61.644]

            .cmp(&txn.get_changeset(txn.changes(channel), b).unwrap())

Replacement in libpijul/src/change.rs at line 364 [16.831311]

B:BD[16.840736] → [37.7238:7313]

        let time = txn.get_changeset(txn.changes(&channel), id)?.unwrap();

[16.840736]

[34.139419]

        let time = txn.get_changeset(txn.changes(channel), id)?.unwrap();

Replacement in libpijul/src/change.rs at line 1483 [16.831311]

B:BD[16.872645] → [40.37530:37588]

            return Err((ChangeError::ChangeHashMismatch {

[16.872645]

[16.872697]

            return Err(ChangeError::ChangeHashMismatch {

Replacement in libpijul/src/change.rs at line 1486 [16.831311]
B:BD[16.872770] → [16.872770:872807]
```
            })
            .into());
```
[16.872770]
[16.872807]
```
            });
```

Replacement in libpijul/src/change/text_changes.rs at line 55 [40.37976]

B:BD[40.39268] → [40.39268:39326]

                            .chain(n.down_context.iter())

[40.39268]

[40.39326]

                            .chain(&n.down_context)

Replacement in libpijul/src/change/text_changes.rs at line 57 [40.37976]

B:BD[40.39373] → [40.39373:39441]

                            .chain(std::iter::once(n.inode.change))

[40.39373]

[40.39441]

                            .chain([n.inode.change])
                            .flatten()

Replacement in libpijul/src/change/text_changes.rs at line 60 [40.37976]

B:BD[40.39467] → [40.39467:39710]

                            if let Some(change) = change {
                                if let Hash::None = change {
                                    continue;
                                }
                                f(change)?

[40.39467]

[40.39710]

                            if let Hash::None = change {
                                continue;

Insertion in libpijul/src/change/text_changes.rs at line 63 [40.37976]
[40.39740]
[40.39740]
```
                            f(change)?
```

Replacement in libpijul/src/change/text_changes.rs at line 102 [40.37976]

B:BD[40.41137] → [40.41137:41211]

                return Err((TextSerError::MissingContents { h }).into());

[40.41137]

[40.41211]

                return Err(TextSerError::MissingContents { h });

Replacement in libpijul/src/change/text_changes.rs at line 406 [40.37976]
B:BD[62.16508] → [62.16508:16558]
```
                    content_edges: content_edges,
```
[62.16508]
[62.16558]
```
                    content_edges,
```
Replacement in libpijul/src/change/text_changes.rs at line 431 [40.37976]
B:BD[62.17204] → [62.17204:17254]
```
                    content_edges: content_edges,
```
[62.17204]
[62.17254]
```
                    content_edges,
```

Replacement in libpijul/src/change/text_changes.rs at line 464 [40.37976]

B:BD[62.17631] → [62.17631:17717]

                        parent: crate::path::parent(&path).unwrap_or("").to_string(),

[62.17631]

[62.17717]

                        parent: crate::path::parent(path).unwrap_or_default().to_string(),

Replacement in libpijul/src/change/text_changes.rs at line 533 [40.37976]
B:BD[62.20337] → [62.20337:20385]
```
                    encoding: encoding.clone(),
```
[62.20337]
[62.20385]
```
                    encoding,
```
Replacement in libpijul/src/change/text_changes.rs at line 546 [40.37976]
B:BD[62.20953] → [62.20953:21001]
```
                    encoding: encoding.clone(),
```
[62.20953]
[62.21001]
```
                    encoding,
```

Replacement in libpijul/src/change/text_changes.rs at line 730 [40.37976]

B:BD[62.27090] → [63.2470:2514]

                    path: if parent == "" {

[62.27090]

[63.2514]

                    path: if parent.is_empty() {

Replacement in libpijul/src/change/text_changes.rs at line 808 [40.37976]
B:BD[62.29674] → [62.29674:29712]
```
                        inode: inode,
```
[62.29674]
[62.29712]
```
                        inode,
```
Replacement in libpijul/src/change/text_changes.rs at line 851 [40.37976]
B:BD[62.31042] → [62.31042:31080]
```
                        inode: inode,
```
[62.31042]
[62.31080]
```
                        inode,
```
Replacement in libpijul/src/change/text_changes.rs at line 1017 [40.37976]
∅:D[62.34439] → [40.81459:81511]
B:BD[40.81459] → [40.81459:81511]
```
            if let Some(&pos) = offsets.get(&pos) {
```
[62.34439]
[40.81511]
```
            if let Some(&pos) = offsets.get(pos) {
```

Replacement in libpijul/src/change/text_changes.rs at line 1159 [40.37976]

B:BD[9.2738] → [9.2738:2796]

                            .chain(n.down_context.iter())

[9.2738]

[9.2796]

                            .chain(&n.down_context)

Replacement in libpijul/src/change/text_changes.rs at line 1161 [40.37976]

B:BD[9.2843] → [9.2843:2911]

                            .chain(std::iter::once(n.inode.change))

[9.2843]

[9.2911]

                            .chain([n.inode.change])
                            .flatten()

Replacement in libpijul/src/change/text_changes.rs at line 1164 [40.37976]

B:BD[9.2937] → [9.2937:3180]

                            if let Some(change) = change {
                                if let Hash::None = change {
                                    continue;
                                }
                                f(change)?

[9.2937]

[9.3180]

                            if let Hash::None = change {
                                continue;

Insertion in libpijul/src/change/text_changes.rs at line 1167 [40.37976]
[9.3210]
[9.3210]
```
                            f(change)?
```
Replacement in libpijul/src/change/printable.rs at line 453 [62.36296]
B:BD[62.48215] → [62.48215:48251]
```
                    Escaped(&path),
```
[62.48215]
[62.48251]
```
                    Escaped(path),
```
Replacement in libpijul/src/change/printable.rs at line 484 [62.36296]
B:BD[62.48851] → [62.48851:48887]
```
                    Escaped(&path),
```
[62.48851]
[62.48887]
```
                    Escaped(path),
```

Replacement in libpijul/src/change/printable.rs at line 610 [62.36296]

B:BD[62.52476] → [62.52476:52599]

    if let Some(e) = detector.get_valid(None, true, &contents) {
        Some(Encoding(e))
    } else {
        None
    }

[62.52476]

[62.52599]

    detector.get_valid(None, true, contents).map(Encoding)

Replacement in libpijul/src/change/printable.rs at line 629 [62.36296]

B:BD[62.52988] → [62.52988:53087]

        let dec = encoding.decode(&contents);
        let ends_with_newline = dec.ends_with("\n");

[62.52988]

[62.53087]

        let dec = encoding.decode(contents);
        let ends_with_newline = dec.ends_with('\n');

Replacement in libpijul/src/change/parse.rs at line 571 [62.64713]
B:BD[62.80878] → [62.80878:80913]
```
        |s| toml::de::from_str(s),
```
[62.80878]
[62.80913]
```
        toml::de::from_str,
```

Replacement in libpijul/src/apply.rs at line 94 [16.944089]

∅:D[28.90041] → [40.94700:94778]

B:BD[16.945044] → [40.94700:94778]

    let change = changes.get_change(&hash).map_err(ApplyError::Changestore)?;

[16.944998]

[16.945089]

    let change = changes.get_change(hash).map_err(ApplyError::Changestore)?;

Replacement in libpijul/src/apply.rs at line 101 [16.944089]

∅:D[34.143354] → [37.7447:7521]

B:BD[17.124523] → [37.7447:7521]

            if txn.get_changeset(txn.changes(&channel), int)?.is_some() {

[34.143354]

[16.945329]

            if txn.get_changeset(txn.changes(channel), int)?.is_some() {

Replacement in libpijul/src/apply.rs at line 111 [16.944089]

B:BD[16.945534] → [17.124662:124723]

        let internal: ChangeId = make_changeid(txn, &hash)?;

[16.945534]

[34.143509]

        let internal: ChangeId = make_changeid(txn, hash)?;

Replacement in libpijul/src/apply.rs at line 117 [16.944089]

B:BD[40.94973] → [64.4296:4355]

        txn, channel, internal, &hash, &change, workspace,

[40.94973]

[40.95077]

        txn, channel, internal, hash, &change, workspace,

Replacement in libpijul/src/apply.rs at line 142 [16.944089]

B:BD[65.267] → [37.7522:7592]

                    .get_changeset(txn.changes(&channel), change_id)?

[65.267]

[65.337]

                    .get_changeset(txn.changes(channel), change_id)?

Replacement in libpijul/src/apply.rs at line 158 [16.944089]

∅:D[34.143835] → [37.7593:7666]

B:BD[17.125043] → [37.7593:7666]

                txn.get_changeset(txn.changes(&channel), int)?.is_some()

[34.143835]

[16.946906]

                txn.get_changeset(txn.changes(channel), int)?.is_some()

Replacement in libpijul/src/apply.rs at line 339 [16.944089]

B:BD[66.290] → [34.144326:144407]

        return Err((LocalApplyError::DependencyMissing { hash: *hash }).into());

[66.290]

[66.354]

        return Err(LocalApplyError::DependencyMissing { hash: *hash });

Replacement in libpijul/src/apply.rs at line 342 [16.944089]

B:BD[66.361] → [34.144408:144461]

∅:D[40.96399] → [67.227:321]

∅:D[17.127224] → [67.227:321]

∅:D[34.144461] → [67.227:321]

B:BD[39.67381] → [67.227:321]

    register_change(txn, &internal, hash, &change)?;
    let n = apply_change_to_channel(txn, &mut channel, internal, &hash, &change, workspace)?;

[66.361]

[16.953210]

    register_change(txn, &internal, hash, change)?;
    let n = apply_change_to_channel(txn, &mut channel, internal, hash, change, workspace)?;

Replacement in libpijul/src/apply.rs at line 560 [16.944089]

B:BD[30.22391] → [34.147440:147524]

        let up = *txn.find_block_end(channel, internal_pos(txn, &up, change_id)?)?;

[30.22391]

[34.147524]

        let up = *txn.find_block_end(channel, internal_pos(txn, up, change_id)?)?;

Replacement in libpijul/src/apply.rs at line 591 [16.944089]

B:BD[17.132985] → [34.147568:147652]

        let down = *txn.find_block(channel, internal_pos(txn, &down, change_id)?)?;

[17.132985]

[17.132986]

        let down = *txn.find_block(channel, internal_pos(txn, down, change_id)?)?;

Replacement in libpijul/src/apply.rs at line 655 [16.944089]

B:BD[16.978857] → [28.90347:90437]

    let mut files = std::mem::replace(&mut ws.missing_context.files, HashSet::default());

[16.978857]

[30.25224]

    let mut files = std::mem::take(&mut ws.missing_context.files);

Replacement in libpijul/src/apply/vertex.rs at line 129 [28.90459]
B:BD[28.94792] → [28.94792:94836]
```
    let k = *txn.find_block(&graph, down)?;
```
[28.94792]
[28.94836]
```
    let k = *txn.find_block(graph, down)?;
```

Replacement in libpijul/src/apply/vertex.rs at line 148 [28.90459]

B:BD[28.95484] → [28.95484:95559]

    for parent in iter_adjacent(txn, &graph, down_vertex, flag0, flag1)? {

[28.95484]

[28.95559]

    for parent in iter_adjacent(txn, graph, down_vertex, flag0, flag1)? {

Replacement in libpijul/src/apply/vertex.rs at line 153 [28.90459]

B:BD[28.95699] → [28.95699:96060]

        if parent.flag().contains(EdgeFlags::PARENT | EdgeFlags::BLOCK) {
            if parent.flag().contains(EdgeFlags::DELETED) {
                let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();
                if !ch.knows(&introduced_by) {
                    ws.deleted_by.insert(parent.introduced_by());
                }

[28.95699]

[28.96060]

        if parent.flag().contains(EdgeFlags::PARENT | EdgeFlags::BLOCK)
            && parent.flag().contains(EdgeFlags::DELETED)
        {
            let introduced_by = txn.get_external(&parent.introduced_by())?.unwrap().into();
            if !ch.knows(&introduced_by) {
                ws.deleted_by.insert(parent.introduced_by());

Replacement in libpijul/src/apply/edge.rs at line 26 [28.96160]

B:BD[28.96947] → [28.96947:97006]

        return Err(LocalApplyError::InvalidChange.into());

[28.96947]

[28.97006]

        return Err(LocalApplyError::InvalidChange);

Replacement in libpijul/src/apply/edge.rs at line 148 [28.96160]

B:BD[28.100827] → [28.100827:100886]

        return Err(LocalApplyError::InvalidChange.into());

[28.100827]

[28.100886]

        return Err(LocalApplyError::InvalidChange);

Replacement in libpijul/src/apply/edge.rs at line 166 [28.96160]

B:BD[28.101319] → [28.101319:101407]

    let mut source = *txn.find_block_end(&channel, internal_pos(txn, &from, change)?)?;

[28.101319]

[28.101407]

    let mut source = *txn.find_block_end(channel, internal_pos(txn, from, change)?)?;

Replacement in libpijul/src/apply/edge.rs at line 208 [28.96160]
B:BD[28.102788] → [28.102788:102806]
```
        &channel,
```
[28.102788]
[28.102806]
```
        channel,
```

Replacement in libpijul/src/apply/edge.rs at line 252 [28.96160]

B:BD[28.104147] → [28.104147:104206]

        return Err(LocalApplyError::InvalidChange.into());

[28.104147]

[28.104206]

        return Err(LocalApplyError::InvalidChange);

Replacement in libpijul/src/apply/edge.rs at line 256 [28.96160]
B:BD[28.104258] → [28.104258:104289]
```
        &graph,
        &vids,
```
[28.104258]
[28.104289]
```
        graph,
        vids,
```

Replacement in libpijul/src/apply/edge.rs at line 266 [28.96160]

B:BD[28.104491] → [28.104491:104577]

    crate::alive::remove_redundant_children(&graph, &vids, &mut ws.children, target);

[28.104491]

[28.104577]

    crate::alive::remove_redundant_children(graph, vids, &mut ws.children, target);

Replacement in libpijul/src/apply/edge.rs at line 297 [28.96160]

B:BD[28.105518] → [28.105518:105583]

    while let Ok(&dest_vertex) = txn.find_block(&channel, pos) {

[28.105518]

[28.105583]

    while let Ok(&dest_vertex) = txn.find_block(channel, pos) {

Replacement in libpijul/src/alive/retrieve.rs at line 38 [16.984582]
∅:D[39.72657] → [16.985823:985845]
B:BD[16.985823] → [16.985823:985845]
```
            &channel,
```
[39.72657]
[16.985845]
```
            channel,
```

Replacement in libpijul/src/alive/output.rs at line 68 [16.988425]

B:BD[16.990674] → [16.990674:990748]

                        let sides = std::mem::replace(sides, Vec::new());

[16.990674]

[16.990748]

                        let sides = std::mem::take(sides);

Replacement in libpijul/src/alive/output.rs at line 120 [16.988425]

B:BD[16.991876] → [34.148887:148979]

                        txn.get_changeset(txn.changes(&channel), &graph[*x].vertex.change)?

[16.991876]

[16.991967]

                        txn.get_changeset(txn.changes(channel), &graph[*x].vertex.change)?

Replacement in libpijul/src/alive/mod.rs at line 99 [16.995164]
B:BD[56.2600] → [56.2600:2643]
```
    pub fn children<'a>(
        &'a self,
```
[56.2600]
[56.2643]
```
    pub fn children(
        &self,
```

Replacement in libpijul/src/alive/mod.rs at line 102 [16.995164]

B:BD[56.2664] → [56.2664:2736]

    ) -> impl Iterator<Item = &'a (Option<SerializedEdge>, VertexId)> {

[56.2664]

[41.7904]

    ) -> impl Iterator<Item = &(Option<SerializedEdge>, VertexId)> {

Insertion in Cargo.lock at line 1854 [16.1030385]

[12.495]

[68.42097]

source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "46a4bfba9a6943c9daee0362ee0269491cef32d93135cb40b87d96c637b89cd8"

Insertion in Cargo.lock at line 1870 [16.1030385]

[69.6939]

[68.42427]

source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53353e72455c4885f7d26fe9b1626c650234f08efb71b9f3baf95901b41e55ab"

address a bunch of lints and code quality issues

Dependencies

In discussions

Change contents

Insertion in rustfmt.toml at line 2 [15.15]

Replacement in pijul-macros/src/lib.rs at line 482 [16.445]

Replacement in pijul-macros/src/lib.rs at line 487 [16.445]

Replacement in pijul-macros/src/lib.rs at line 489 [16.445]

Replacement in pijul-macros/src/lib.rs at line 494 [16.445]

Replacement in pijul-macros/src/lib.rs at line 496 [16.445]

Replacement in libpijul/src/working_copy/mod.rs at line 28 [16.198172]

Replacement in libpijul/src/working_copy/filesystem.rs at line 50 [16.208900]

Replacement in libpijul/src/working_copy/filesystem.rs at line 65 [16.208900]

Replacement in libpijul/src/working_copy/filesystem.rs at line 169 [16.208900]

Replacement in libpijul/src/working_copy/filesystem.rs at line 187 [16.208900]

Replacement in libpijul/src/working_copy/filesystem.rs at line 247 [16.208900]

Replacement in libpijul/src/working_copy/filesystem.rs at line 308 [16.208900]

Replacement in libpijul/src/working_copy/filesystem.rs at line 367 [16.208900]

Replacement in libpijul/src/unrecord/mod.rs at line 62 [16.231493]

Replacement in libpijul/src/tag.rs at line 482 [27.6397]

Replacement in libpijul/src/record.rs at line 413 [16.488880]

Replacement in libpijul/src/record.rs at line 417 [16.488880]

Replacement in libpijul/src/record.rs at line 609 [16.488880]

Replacement in libpijul/src/record.rs at line 987 [16.488880]

Replacement in libpijul/src/record.rs at line 1029 [16.488880]

Replacement in libpijul/src/record.rs at line 1063 [16.488880]

Replacement in libpijul/src/record.rs at line 1065 [16.488880]

Replacement in libpijul/src/record.rs at line 1089 [16.488880]

Replacement in libpijul/src/record.rs at line 1099 [16.488880]

Replacement in libpijul/src/record.rs at line 1141 [16.488880]

Replacement in libpijul/src/record.rs at line 1165 [16.488880]

Replacement in libpijul/src/pristine/sanakirja.rs at line 162 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 358 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 410 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 511 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 718 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 721 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1271 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1279 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1302 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1400 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1408 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1602 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1604 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1643 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1763 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1779 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 1782 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 2029 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 2076 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 2083 [16.531056]

Replacement in libpijul/src/pristine/sanakirja.rs at line 2205 [16.531056]

Replacement in libpijul/src/pristine/path_id.rs at line 42 [16.584967]

Replacement in libpijul/src/pristine/mod.rs at line 214 [16.586748]

Replacement in libpijul/src/pristine/mod.rs at line 236 [16.586748]

Replacement in libpijul/src/pristine/mod.rs at line 500 [16.586748]