Fix all clippy warnings (#578)

* Fix all clippy warnings

Addresses clippy errors so that
`cargo clippy --locked --all-targets -- -D warnings` passes cleanly:

- assert_eq!(x, true/false) -> assert!(x) / assert!(!x) in tests
- Remove needless borrows (&path.path(), &geojson, etc.)
- Change `const TEST_X: LazyLock<...>` to `static` (interior mutability
  in const), which also fixes downstream borrow_interior_mutable_const
  warnings
- Replace `x == None` with `x.is_none()`
- Replace manual Option::map(|x| x.clone()) with .cloned()
- Elide redundant lifetime in atp::mod::tags
- Remove redundant `use predicates;` import
- Fix inconsistent digit grouping (11_000_000_0 -> 110_000_000, etc.)
- Replace assert!(false, ...) with panic!(...)
- Replace .into_iter() on array ref with .iter()
- Remove redundant & in format! argument

Also ran cargo fmt to keep formatting consistent.

src/pipeline/osm/id_tagging_schema.rs is excluded here: it's generated
by scripts/generate_id_tagging_schema.py, so its remaining clippy
warnings (bool_assert_comparison) will be fixed by updating the
generator in a separate PR.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* Group positive/negative cases in test_is_wikidata_id

Per review feedback: visually separate the wikidata-key assertions
into a "true" block and a "false" block within the same test, instead
of interleaving them.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

* Group positive/negative cases in remaining bool assertions

Per review feedback: visually separate the "should be present"
assertions from the "should be absent" ones, in the same tests, for
src/tables/u64_set.rs (test_contains, test_create,
writer::tests::test_create, writer::tests::test_create_single_value)
and src/coverage.rs (contains_wikidata_item test).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>

Author: brawer

src/atp/fetch.rs

@@ -144,7 +144,7 @@ mod tests {
         let client = test_client(&server);
         let progress = MultiProgress::with_draw_target(ProgressDrawTarget::hidden());
         let workdir = TempDir::new()?;
-        let path = fetch_atp(&mock_history_url, &client, &progress, &workdir.path()).await?;
+        let path = fetch_atp(&mock_history_url, &client, &progress, workdir.path()).await?;
         mock_history.assert_async().await;
         mock_atp_data.assert_async().await;
 

src/atp/mod.rs

@@ -388,7 +388,7 @@ mod tests {
 
     #[test]
     fn test_find_point_for_line_string() {
-        let pt = find_point(&BICYCLE_ROAD).unwrap();
+        let pt = find_point(BICYCLE_ROAD).unwrap();
         assert!((pt.x() - 7.4593195).abs() < 1e-6);
         assert!((pt.y() - 46.9423753).abs() < 1e-6);
     }
@@ -413,12 +413,12 @@ mod tests {
                ]
            }
         }"#;
-        let pt = find_point(&geojson).unwrap();
+        let pt = find_point(geojson).unwrap();
         assert!((pt.x() - -72.4474).abs() < 1e-3);
         assert!((pt.y() - 25.3935).abs() < 1e-3);
     }
 
-    fn tags<'a>(place: &'a Place) -> Vec<(&'a str, &'a str)> {
+    fn tags(place: &Place) -> Vec<(&str, &str)> {
         place
             .tags
             .iter()
@@ -504,54 +504,42 @@ mod tests {
 
     #[test]
     fn test_is_usable_for_osm() {
-        assert_eq!(
-            is_usable_for_osm(&make_dataset(&[("use:openstreetmap", "yes")])),
-            true
-        );
-        assert_eq!(
-            is_usable_for_osm(&make_dataset(&[("use:openstreetmap", "no")])),
-            false
-        );
-        assert_eq!(
-            is_usable_for_osm(&make_dataset(&[
-                ("license", "Creative Commons Zero"),
-                ("license:wikidata", "Q6938433"),
-                ("spider:lineage", "S_ATP_AGGREGATORS"),
-            ])),
-            true
-        );
-        assert_eq!(
-            is_usable_for_osm(&make_dataset(&[
-                ("license", "Creative Commons Zero"),
-                ("license:wikidata", "Q6938433"),
-                ("use:openstreetmap", "no"),
-            ])),
-            false
-        );
-        assert_eq!(
-            is_usable_for_osm(&make_dataset(&[("spider:lineage", "S_ATP_BRANDS")])),
-            true
-        );
-        assert_eq!(
-            is_usable_for_osm(&make_dataset(&[
-                ("license", "Creative Commons Attribution 4.0 International"),
-                ("license:wikidata", "Q20007257"),
-                ("spider:lineage", "S_ATP_BRANDS")
-            ])),
-            false
-        );
-        assert_eq!(
-            is_usable_for_osm(&make_dataset(&[
-                ("license", "Etalab Open License 2.0"),
-                ("license:wikidata", "Q80939351"),
-                ("spider:lineage", "S_ATP_GOVERNMENT")
-            ])),
-            true
-        );
-        assert_eq!(
-            is_usable_for_osm(&make_dataset(&[("spider:lineage", "S_ATP_AGGREGATORS")])),
-            false
-        );
+        assert!(is_usable_for_osm(&make_dataset(&[(
+            "use:openstreetmap",
+            "yes"
+        )])));
+        assert!(!is_usable_for_osm(&make_dataset(&[(
+            "use:openstreetmap",
+            "no"
+        )])));
+        assert!(is_usable_for_osm(&make_dataset(&[
+            ("license", "Creative Commons Zero"),
+            ("license:wikidata", "Q6938433"),
+            ("spider:lineage", "S_ATP_AGGREGATORS"),
+        ])));
+        assert!(!is_usable_for_osm(&make_dataset(&[
+            ("license", "Creative Commons Zero"),
+            ("license:wikidata", "Q6938433"),
+            ("use:openstreetmap", "no"),
+        ])));
+        assert!(is_usable_for_osm(&make_dataset(&[(
+            "spider:lineage",
+            "S_ATP_BRANDS"
+        )])));
+        assert!(!is_usable_for_osm(&make_dataset(&[
+            ("license", "Creative Commons Attribution 4.0 International"),
+            ("license:wikidata", "Q20007257"),
+            ("spider:lineage", "S_ATP_BRANDS")
+        ])));
+        assert!(is_usable_for_osm(&make_dataset(&[
+            ("license", "Etalab Open License 2.0"),
+            ("license:wikidata", "Q80939351"),
+            ("spider:lineage", "S_ATP_GOVERNMENT")
+        ])));
+        assert!(!is_usable_for_osm(&make_dataset(&[(
+            "spider:lineage",
+            "S_ATP_AGGREGATORS"
+        )])));
     }
 
     fn make_dataset(tags: &[(&str, &str)]) -> geojson::FeatureCollection {

src/coverage.rs

@@ -40,12 +40,13 @@ mod tests {
 
     #[test]
     fn test_is_wikidata_id() {
-        assert_eq!(is_wikidata_key("highway"), false);
-        assert_eq!(is_wikidata_key("wikidata"), true);
-        assert_eq!(is_wikidata_key("brand:wikidata"), true);
-        assert_eq!(is_wikidata_key("network:wikidata"), true);
-        assert_eq!(is_wikidata_key("operator:wikidata"), true);
-        assert_eq!(is_wikidata_key("species:wikidata"), false);
+        assert!(is_wikidata_key("wikidata"));
+        assert!(is_wikidata_key("brand:wikidata"));
+        assert!(is_wikidata_key("network:wikidata"));
+        assert!(is_wikidata_key("operator:wikidata"));
+
+        assert!(!is_wikidata_key("highway"));
+        assert!(!is_wikidata_key("species:wikidata"));
     }
 
     #[test]
@@ -211,7 +212,7 @@ mod reader {
             let mut bytes = Vec::new();
             bytes.extend_from_slice(b"diffed-places coverage\0\0");
             bytes.extend_from_slice(&2_u64.to_le_bytes());
-            assert!(Coverage::get_offset_size(b"some_key", &bytes, 1) == None);
+            assert!(Coverage::get_offset_size(b"some_key", &bytes, 1).is_none());
             for (key, offset, size) in [(b"some_key", 80, 16), (b"otherkey", 83, 2)] {
                 bytes.extend_from_slice(key as &[u8; 8]);
                 bytes.extend_from_slice(&(offset as u64).to_le_bytes());
@@ -721,12 +722,13 @@ mod writer {
                 );
             }
 
-            assert_eq!(cov.contains_wikidata_item(1), false);
-            assert_eq!(cov.contains_wikidata_item(23), true);
-            assert_eq!(cov.contains_wikidata_item(51), false);
-            assert_eq!(cov.contains_wikidata_item(77), true);
-            assert_eq!(cov.contains_wikidata_item(88), true);
-            assert_eq!(cov.contains_wikidata_item(89), false);
+            assert!(cov.contains_wikidata_item(23));
+            assert!(cov.contains_wikidata_item(77));
+            assert!(cov.contains_wikidata_item(88));
+
+            assert!(!cov.contains_wikidata_item(1));
+            assert!(!cov.contains_wikidata_item(51));
+            assert!(!cov.contains_wikidata_item(89));
 
             Ok(())
         }

src/pipeline/mod.rs

@@ -78,7 +78,7 @@ mod tests {
         f7.as_file().set_modified(t7)?;
 
         assert!(last_modified(&[]).is_err());
-        assert!(last_modified(&[&Path::new("/no/such/file")]).is_err());
+        assert!(last_modified(&[Path::new("/no/such/file")]).is_err());
 
         assert_eq!(last_modified(&[f0.path()])?, t0);
         assert_eq!(last_modified(&[f0.path(), f2.path()])?, t2);

src/pipeline/osm/coords.rs

@@ -69,7 +69,7 @@ mod tests {
         let workdir = TempDir::new()?;
         let keys_file = NamedTempFile::new()?;
         let data_file = NamedTempFile::new()?;
-        build_tables(rx, &workdir.path(), &keys_file.path(), &data_file.path())?;
+        build_tables(rx, workdir.path(), keys_file.path(), data_file.path())?;
 
         let keys: Vec<u64> = {
             let mut buf = Vec::new();

src/pipeline/osm/filter.rs

@@ -1065,7 +1065,7 @@ pub mod filtered_file {
             bytes.extend_from_slice(&0xdeadbeefcafefeed_u64.to_le_bytes()); // [32..40]: data[0]
             bytes.extend_from_slice(&42_u64.to_le_bytes()); // [40..48]: data[1]
             bytes.extend_from_slice(&2_u64.to_le_bytes()); // [48..56]: num_headers
-            assert!(FilteredFile::get_offset_size(b"some_key", &bytes, 1) == None);
+            assert!(FilteredFile::get_offset_size(b"some_key", &bytes, 1).is_none());
             for (key, offset, size) in [(b"some_key", 88, 16), (b"otherkey", 91, 2)] {
                 bytes.extend_from_slice(key as &[u8; 8]);
                 bytes.extend_from_slice(&(offset as u64).to_le_bytes());
@@ -1120,7 +1120,7 @@ pub mod filtered_file {
                 }
                 file.sync_all()?;
             }
-            writer.write_coords(&keys_path, &data.path())?;
+            writer.write_coords(&keys_path, data.path())?;
             writer.close()?;
             let ff = FilteredFile::open(tmp.path())?;
             assert_eq!(
@@ -1195,12 +1195,12 @@ pub mod filtered_file {
             writer.write_node_refs(&test_data_path("u64_le_0_2_7"))?;
             writer.close()?;
             let ff = FilteredFile::open(tmp.path())?;
-            assert_eq!(ff.has_node_ref(0), true);
-            assert_eq!(ff.has_node_ref(2), true);
-            assert_eq!(ff.has_node_ref(7), true);
-            assert_eq!(ff.has_node_ref(1), false);
-            assert_eq!(ff.has_node_ref(8), false);
-            assert_eq!(ff.has_node_ref(1234567890123456789), false);
+            assert!(ff.has_node_ref(0));
+            assert!(ff.has_node_ref(2));
+            assert!(ff.has_node_ref(7));
+            assert!(!ff.has_node_ref(1));
+            assert!(!ff.has_node_ref(8));
+            assert!(!ff.has_node_ref(1234567890123456789));
             Ok(())
         }
 
@@ -1211,12 +1211,12 @@ pub mod filtered_file {
             writer.write_way_refs(&test_data_path("u64_le_0_2_7"))?;
             writer.close()?;
             let ff = FilteredFile::open(tmp.path())?;
-            assert_eq!(ff.has_way_ref(0), true);
-            assert_eq!(ff.has_way_ref(2), true);
-            assert_eq!(ff.has_way_ref(7), true);
-            assert_eq!(ff.has_way_ref(1), false);
-            assert_eq!(ff.has_way_ref(8), false);
-            assert_eq!(ff.has_way_ref(1234567890123456789), false);
+            assert!(ff.has_way_ref(0));
+            assert!(ff.has_way_ref(2));
+            assert!(ff.has_way_ref(7));
+            assert!(!ff.has_way_ref(1));
+            assert!(!ff.has_way_ref(8));
+            assert!(!ff.has_way_ref(1234567890123456789));
             Ok(())
         }
 
@@ -1230,8 +1230,8 @@ pub mod filtered_file {
             assert_eq!(ff.get_coord(5), None);
             assert_eq!(ff.feature_count(), 0);
             assert_eq!(ff.feature_data(17123), None);
-            assert_eq!(ff.has_node_ref(123), false);
-            assert_eq!(ff.has_way_ref(789), false);
+            assert!(!ff.has_node_ref(123));
+            assert!(!ff.has_way_ref(789));
             Ok(())
         }
 

src/pipeline/osm/mod.rs

@@ -520,27 +520,15 @@ mod tests {
 
     impl FeatureStore for MockFeatureStore {
         fn get_node(&self, id: u64) -> Option<Node> {
-            if let Some(node) = self.nodes.get(&id) {
-                Some(node.clone())
-            } else {
-                None
-            }
+            self.nodes.get(&id).cloned()
         }
 
         fn get_way(&self, id: u64) -> Option<Way> {
-            if let Some(way) = self.ways.get(&id) {
-                Some(way.clone())
-            } else {
-                None
-            }
+            self.ways.get(&id).cloned()
         }
 
         fn get_relation(&self, id: u64) -> Option<Relation> {
-            if let Some(relation) = self.relations.get(&id) {
-                Some(relation.clone())
-            } else {
-                None
-            }
+            self.relations.get(&id).cloned()
         }
 
         fn node_count(&self) -> u64 {

src/pipeline/osm/old_assemble.rs

@@ -189,8 +189,8 @@ mod tests {
                 changeset: NonZeroU64::new(999),
                 version: NonZeroU32::new(7),
                 tags: vec![String::from("shop"), String::from("supermarket")],
-                lon_e7: 11_000_000_0,
-                lat_e7: 12_000_000_0,
+                lon_e7: 110_000_000,
+                lat_e7: 120_000_000,
             }],
             vec![],
             vec![],
@@ -224,16 +224,16 @@ mod tests {
                     changeset: NonZeroU64::new(1999),
                     version: NonZeroU32::new(17),
                     tags: vec![],
-                    lon_e7: 50_000_000_0,
-                    lat_e7: 20_000_000_0,
+                    lon_e7: 500_000_000,
+                    lat_e7: 200_000_000,
                 },
                 Node {
                     id: 2,
                     changeset: NonZeroU64::new(2999),
                     version: NonZeroU32::new(27),
                     tags: vec![],
-                    lon_e7: 70_000_000_0,
-                    lat_e7: 40_000_000_0,
+                    lon_e7: 700_000_000,
+                    lat_e7: 400_000_000,
                 },
             ],
             vec![Way {

src/pipeline/tiles.rs

@@ -118,7 +118,7 @@ mod tests {
             .get_args()
             .map(|s| s.to_string_lossy().into_owned())
             .collect();
-        let shop_layer_arg = format!("--named-layer=Shops:{}", &layers[1].path.display());
+        let shop_layer_arg = format!("--named-layer=Shops:{}", layers[1].path.display());
         let workdir_abs = std::path::absolute(&workdir).expect("absolute path of workdir");
         assert_eq!(
             args,

src/places/mod.rs

@@ -194,8 +194,8 @@ mod tests {
             vec![],
         )
         .unwrap();
-        assert_eq!(a.eq(&b), false);
-        assert_eq!(a.eq(&a), true);
+        assert!(!a.eq(&b));
+        assert!(a.eq(&a));
         assert_eq!(a.cmp(&b), a.s2_cell_id.cmp(&b.s2_cell_id));
         assert_eq!(a.partial_cmp(&b), a.s2_cell_id.partial_cmp(&b.s2_cell_id));
     }
@@ -217,7 +217,7 @@ mod tests {
             assert_eq!(p.x(), 7.4478123);
             assert_eq!(p.y(), 46.9479801);
         } else {
-            assert!(false, "expected a point, got {:?}", shape);
+            panic!("expected a point, got {:?}", shape);
         };
     }
 }