fix clippy warnings that showed up in rust 1.54 (#153)

molpopgen · web-flow · commit 8a553eaa80d7 · 2021-08-02T14:53:09.000-07:00
diff --git a/examples/forward_simulation.rs b/examples/forward_simulation.rs
@@ -372,8 +372,8 @@ fn runsim(params: &SimParams) -> tskit::TableCollection {
 
     for step in (0..params.nsteps).rev() {
         parents.clear();
-        death_and_parents(&alive, &params, &mut parents, &mut rng);
-        births(&parents, &params, step, &mut tables, &mut alive, &mut rng);
+        death_and_parents(&alive, params, &mut parents, &mut rng);
+        births(&parents, params, step, &mut tables, &mut alive, &mut rng);
         let remainder = step % params.simplification_interval;
         match step < params.nsteps && remainder == 0 {
             true => {
diff --git a/examples/tree_traversals.rs b/examples/tree_traversals.rs
@@ -42,8 +42,8 @@ fn main() {
     let mut tree_iterator = treeseq.tree_iterator(tskit::TreeFlags::default()).unwrap();
 
     while let Some(tree) = tree_iterator.next() {
-        traverse_upwards(&tree);
-        traverse_upwards_with_iterator(&tree);
-        preorder_traversal(&tree);
+        traverse_upwards(tree);
+        traverse_upwards_with_iterator(tree);
+        preorder_traversal(tree);
     }
 }
diff --git a/src/edge_table.rs b/src/edge_table.rs
@@ -134,7 +134,7 @@ impl<'a> EdgeTable<'a> {
     /// The value of the iterator is [`EdgeTableRow`].
     ///
     pub fn iter(&self) -> EdgeTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&EdgeTable<'a>>(&self)
+        crate::table_iterator::make_table_iterator::<&EdgeTable<'a>>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/individual_table.rs b/src/individual_table.rs
@@ -27,7 +27,7 @@ impl PartialEq for IndividualTableRow {
                             false
                         } else {
                             for (i, j) in a.iter().enumerate() {
-                                if !crate::util::f64_partial_cmp_equal(&j, &b[i]) {
+                                if !crate::util::f64_partial_cmp_equal(j, &b[i]) {
                                     return false;
                                 }
                             }
@@ -164,7 +164,7 @@ impl<'a> IndividualTable<'a> {
     /// The value of the iterator is [`IndividualTableRow`].
     ///
     pub fn iter(&self) -> IndividualTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&IndividualTable<'a>>(&self)
+        crate::table_iterator::make_table_iterator::<&IndividualTable<'a>>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/migration_table.rs b/src/migration_table.rs
@@ -173,7 +173,7 @@ impl<'a> MigrationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`MigrationTableRow`].
     pub fn iter(&self) -> MigrationTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&MigrationTable<'a>>(&self)
+        crate::table_iterator::make_table_iterator::<&MigrationTable<'a>>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/mutation_table.rs b/src/mutation_table.rs
@@ -49,7 +49,7 @@ impl<'a> Iterator for MutationTableRefIterator<'a> {
     type Item = MutationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_mutation_table_row(&self.table, self.pos);
+        let rv = make_mutation_table_row(self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -164,7 +164,7 @@ impl<'a> MutationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`MutationTableRow`].
     pub fn iter(&self) -> MutationTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&MutationTable<'a>>(&self)
+        crate::table_iterator::make_table_iterator::<&MutationTable<'a>>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/node_table.rs b/src/node_table.rs
@@ -170,7 +170,7 @@ impl<'a> NodeTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`NodeTableRow`].
     pub fn iter(&self) -> NodeTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&NodeTable<'a>>(&self)
+        crate::table_iterator::make_table_iterator::<&NodeTable<'a>>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/population_table.rs b/src/population_table.rs
@@ -37,7 +37,7 @@ impl<'a> Iterator for PopulationTableRefIterator<'a> {
     type Item = PopulationTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_population_table_row(&self.table, self.pos);
+        let rv = make_population_table_row(self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -83,7 +83,7 @@ impl<'a> PopulationTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`PopulationTableRow`].
     pub fn iter(&self) -> PopulationTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&PopulationTable<'a>>(&self)
+        crate::table_iterator::make_table_iterator::<&PopulationTable<'a>>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/provenance.rs b/src/provenance.rs
@@ -269,7 +269,7 @@ impl<'a> ProvenanceTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`ProvenanceTableRow`].
     pub fn iter(&self) -> ProvenanceTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&ProvenanceTable<'a>>(&self)
+        crate::table_iterator::make_table_iterator::<&ProvenanceTable<'a>>(self)
     }
 }
 
@@ -301,7 +301,7 @@ mod test_provenance_tables {
         let records = vec!["banana".to_string(), "split".to_string()];
         let mut tables = make_empty_table_collection(1.);
         for (i, r) in records.iter().enumerate() {
-            let row_id = tables.add_provenance(&r).unwrap();
+            let row_id = tables.add_provenance(r).unwrap();
             assert!(row_id == ProvenanceId(i as crate::tsk_id_t));
             assert_eq!(tables.provenances().record(row_id).unwrap(), *r);
         }
diff --git a/src/site_table.rs b/src/site_table.rs
@@ -42,7 +42,7 @@ impl<'a> Iterator for SiteTableRefIterator<'a> {
     type Item = SiteTableRow;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let rv = make_site_table_row(&self.table, self.pos);
+        let rv = make_site_table_row(self.table, self.pos);
         self.pos += 1;
         rv
     }
@@ -121,7 +121,7 @@ impl<'a> SiteTable<'a> {
     /// Return an iterator over rows of the table.
     /// The value of the iterator is [`SiteTableRow`].
     pub fn iter(&self) -> SiteTableRefIterator {
-        crate::table_iterator::make_table_iterator::<&SiteTable<'a>>(&self)
+        crate::table_iterator::make_table_iterator::<&SiteTable<'a>>(self)
     }
 
     /// Return row `r` of the table.
diff --git a/src/table_collection.rs b/src/table_collection.rs
@@ -1192,10 +1192,10 @@ mod test {
             .unwrap();
         tables.add_edge(0., tables.sequence_length(), 1, 0).unwrap();
         tables
-            .dump(&treefile, TableOutputOptions::default())
+            .dump(treefile, TableOutputOptions::default())
             .unwrap();
 
-        let tables2 = TableCollection::new_from_file(&treefile).unwrap();
+        let tables2 = TableCollection::new_from_file(treefile).unwrap();
         assert!(tables.equals(&tables2, TableEqualityOptions::default()));
 
         std::fs::remove_file(&treefile).unwrap();
@@ -1266,7 +1266,7 @@ mod test {
             Some(x) => {
                 assert_eq!(x.len(), location.len());
                 for (i, l) in x.iter().enumerate() {
-                    assert!(crate::util::f64_partial_cmp_equal(&l, &location[i]));
+                    assert!(crate::util::f64_partial_cmp_equal(l, &location[i]));
                 }
             }
             None => panic!("expected some locations"),
diff --git a/src/test_simplification.rs b/src/test_simplification.rs
@@ -34,7 +34,7 @@ mod tests {
         let ts = treeseq_from_small_table_collection_two_trees();
         let samples = ts.sample_nodes();
         let (_, idmap_option) = ts
-            .simplify(&samples, SimplificationOptions::default(), true)
+            .simplify(samples, SimplificationOptions::default(), true)
             .unwrap();
         assert!(idmap_option.is_some());
         let idmap = idmap_option.unwrap();
diff --git a/src/trees.rs b/src/trees.rs
@@ -440,7 +440,7 @@ impl Tree {
     ///
     /// [`TskitError::IndexError`] if `u` is out of range.
     pub fn children(&self, u: NodeId) -> Result<impl Iterator<Item = NodeId> + '_, TskitError> {
-        ChildIterator::new(&self, u)
+        ChildIterator::new(self, u)
     }
     /// Return an [`Iterator`] over the sample nodes descending from node `u`.
     ///
@@ -491,7 +491,7 @@ impl Tree {
         order: NodeTraversalOrder,
     ) -> Box<dyn Iterator<Item = NodeId> + '_> {
         match order {
-            NodeTraversalOrder::Preorder => Box::new(PreorderNodeIterator::new(&self)),
+            NodeTraversalOrder::Preorder => Box::new(PreorderNodeIterator::new(self)),
         }
     }
 
@@ -585,7 +585,7 @@ impl streaming_iterator::StreamingIterator for Tree {
 
     fn get(&self) -> Option<&Tree> {
         match self.advanced {
-            true => Some(&self),
+            true => Some(self),
             false => None,
         }
     }

Original file line number	Diff line number	Diff line change
`@@ -42,8 +42,8 @@ fn main() {`
`42`	`42`	`let mut tree_iterator = treeseq.tree_iterator(tskit::TreeFlags::default()).unwrap();`
`43`	`43`
`44`	`44`	`while let Some(tree) = tree_iterator.next() {`
`45`		`- traverse_upwards(&tree);`
`46`		`- traverse_upwards_with_iterator(&tree);`
`47`		`- preorder_traversal(&tree);`
	`45`	`+ traverse_upwards(tree);`
	`46`	`+ traverse_upwards_with_iterator(tree);`
	`47`	`+ preorder_traversal(tree);`
`48`	`48`	`}`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -134,7 +134,7 @@ impl<'a> EdgeTable<'a> {`
`134`	`134`	/// The value of the iterator is [`EdgeTableRow`].
`135`	`135`	`///`
`136`	`136`	`pub fn iter(&self) -> EdgeTableRefIterator {`
`137`		`- crate::table_iterator::make_table_iterator::<&EdgeTable<'a>>(&self)`
	`137`	`+ crate::table_iterator::make_table_iterator::<&EdgeTable<'a>>(self)`
`138`	`138`	`}`
`139`	`139`
`140`	`140`	/// Return row `r` of the table.
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ impl PartialEq for IndividualTableRow {`
`27`	`27`	`false`
`28`	`28`	`} else {`
`29`	`29`	`for (i, j) in a.iter().enumerate() {`
`30`		`- if !crate::util::f64_partial_cmp_equal(&j, &b[i]) {`
	`30`	`+ if !crate::util::f64_partial_cmp_equal(j, &b[i]) {`
`31`	`31`	`return false;`
`32`	`32`	`}`
`33`	`33`	`}`
`@@ -164,7 +164,7 @@ impl<'a> IndividualTable<'a> {`
`164`	`164`	/// The value of the iterator is [`IndividualTableRow`].
`165`	`165`	`///`
`166`	`166`	`pub fn iter(&self) -> IndividualTableRefIterator {`
`167`		`- crate::table_iterator::make_table_iterator::<&IndividualTable<'a>>(&self)`
	`167`	`+ crate::table_iterator::make_table_iterator::<&IndividualTable<'a>>(self)`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	/// Return row `r` of the table.
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ impl<'a> MigrationTable<'a> {`
`173`	`173`	`/// Return an iterator over rows of the table.`
`174`	`174`	/// The value of the iterator is [`MigrationTableRow`].
`175`	`175`	`pub fn iter(&self) -> MigrationTableRefIterator {`
`176`		`- crate::table_iterator::make_table_iterator::<&MigrationTable<'a>>(&self)`
	`176`	`+ crate::table_iterator::make_table_iterator::<&MigrationTable<'a>>(self)`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	/// Return row `r` of the table.
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ impl<'a> NodeTable<'a> {`
`170`	`170`	`/// Return an iterator over rows of the table.`
`171`	`171`	/// The value of the iterator is [`NodeTableRow`].
`172`	`172`	`pub fn iter(&self) -> NodeTableRefIterator {`
`173`		`- crate::table_iterator::make_table_iterator::<&NodeTable<'a>>(&self)`
	`173`	`+ crate::table_iterator::make_table_iterator::<&NodeTable<'a>>(self)`
`174`	`174`	`}`
`175`	`175`
`176`	`176`	/// Return row `r` of the table.
Original file line number	Diff line number	Diff line change
`@@ -269,7 +269,7 @@ impl<'a> ProvenanceTable<'a> {`
`269`	`269`	`/// Return an iterator over rows of the table.`
`270`	`270`	/// The value of the iterator is [`ProvenanceTableRow`].
`271`	`271`	`pub fn iter(&self) -> ProvenanceTableRefIterator {`
`272`		`- crate::table_iterator::make_table_iterator::<&ProvenanceTable<'a>>(&self)`
	`272`	`+ crate::table_iterator::make_table_iterator::<&ProvenanceTable<'a>>(self)`
`273`	`273`	`}`
`274`	`274`	`}`
`275`	`275`
`@@ -301,7 +301,7 @@ mod test_provenance_tables {`
`301`	`301`	`let records = vec!["banana".to_string(), "split".to_string()];`
`302`	`302`	`let mut tables = make_empty_table_collection(1.);`
`303`	`303`	`for (i, r) in records.iter().enumerate() {`
`304`		`- let row_id = tables.add_provenance(&r).unwrap();`
	`304`	`+ let row_id = tables.add_provenance(r).unwrap();`
`305`	`305`	`assert!(row_id == ProvenanceId(i as crate::tsk_id_t));`
`306`	`306`	`assert_eq!(tables.provenances().record(row_id).unwrap(), *r);`
`307`	`307`	`}`