cleanup: replace `x[n..n+l]` by `x[n..][..l]`

This avoids repeating the `n` in these expressions. Thanks to
@Dr-Emann for the suggestion.

lib/src/default_index_store.rs

···
     // to better cache locality when walking it; ability to quickly find all
     // commits associated with a change id.
     fn change_id(&self) -> ChangeId {
-        ChangeId::new(self.data[20..20 + self.change_id_length].to_vec())
+        ChangeId::new(self.data[20..][..self.change_id_length].to_vec())
     }
 
     fn commit_id(&self) -> CommitId {
-        CommitId::from_bytes(
-            &self.data
-                [20 + self.change_id_length..20 + self.change_id_length + self.commit_id_length],
-        )
+        CommitId::from_bytes(&self.data[20 + self.change_id_length..][..self.commit_id_length])
     }
 }
 
···
 
     fn pos(&self) -> IndexPosition {
         IndexPosition(
-            (&self.data[self.commit_id_length..self.commit_id_length + 4])
+            (&self.data[self.commit_id_length..][..4])
                 .read_u32::<LittleEndian>()
                 .unwrap(),
         )
···
             buf.write_u32::<LittleEndian>(pos.0).unwrap();
         }
 
-        (&mut buf[parent_overflow_offset..parent_overflow_offset + 4])
+        (&mut buf[parent_overflow_offset..][..4])
             .write_u32::<LittleEndian>(parent_overflow.len() as u32)
             .unwrap();
         for parent_pos in parent_overflow {
···
     fn graph_entry(&self, local_pos: u32) -> CommitGraphEntry {
         let offset = (local_pos as usize) * self.commit_graph_entry_size;
         CommitGraphEntry {
-            data: &self.graph[offset..offset + self.commit_graph_entry_size],
+            data: &self.graph[offset..][..self.commit_graph_entry_size],
             commit_id_length: self.commit_id_length,
             change_id_length: self.change_id_length,
         }
···
     fn lookup_entry(&self, lookup_pos: u32) -> CommitLookupEntry {
         let offset = (lookup_pos as usize) * self.commit_lookup_entry_size;
         CommitLookupEntry {
-            data: &self.lookup[offset..offset + self.commit_lookup_entry_size],
+            data: &self.lookup[offset..][..self.commit_lookup_entry_size],
             commit_id_length: self.commit_id_length,
         }
     }
···
     fn overflow_parent(&self, overflow_pos: u32) -> IndexPosition {
         let offset = (overflow_pos as usize) * 4;
         IndexPosition(
-            (&self.overflow_parent[offset..offset + 4])
+            (&self.overflow_parent[offset..][..4])
                 .read_u32::<LittleEndian>()
                 .unwrap(),
         )

lib/src/stacked_table.rs

···
     fn new(table: &'table ReadonlyTable, pos: usize) -> Self {
         let entry_size = ReadonlyTableIndexEntry::size(table.key_size);
         let offset = entry_size * pos;
-        let data = &table.index[offset..offset + entry_size];
+        let data = &table.index[offset..][..entry_size];
         ReadonlyTableIndexEntry { data }
     }
 

lib/tests/test_merge_trees.rs

···
     let write_tree = |index: usize| -> Tree {
         let mut tree_builder = store.tree_builder(store.empty_tree_id().clone());
         for path in &files {
-            let contents = &path[index..index + 1];
+            let contents = &path[index..][..1];
             if contents != "_" {
                 testutils::write_normal_file(
                     &mut tree_builder,
···
     fn contents_in_tree<'a>(files: &[&'a str], index: usize) -> Vec<(&'a str, bool)> {
         files
             .iter()
-            .map(|f| (*f, &f[index..index + 1] == "x"))
+            .map(|f| (*f, &f[index..][..1] == "x"))
             .collect()
     }