chore: Fix all clippy lints and check them on CI (petgraph#726)

drive-by: Bump edition from `2018` to `2021`

---------

Co-authored-by: Agustín Borgna <[email protected]>

Author: ABorgna

.github/workflows/ci.yml

@@ -12,6 +12,8 @@ name: Continuous integration
 env:
   CARGO_TERM_COLOR: always
   CARGO_INCREMENTAL: 0
+  SCCACHE_GHA_ENABLED: "true"
+  RUSTC_WRAPPER: "sccache"
 
 jobs:
   tests:
@@ -29,58 +31,74 @@ jobs:
             features: unstable quickcheck rayon
             test_all: --all
             bench: true
+    name: Tests (Rust ${{ matrix.rust }})
 
     steps:
       - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: mozilla-actions/[email protected]
+      - id: toolchain
+        uses: dtolnay/rust-toolchain@master
         with:
-          profile: minimal
           toolchain: ${{ matrix.rust }}
-          override: true
+      - name: Configure default rust toolchain
+        run: rustup override set ${{steps.toolchain.outputs.name}}
+
       - name: MSRV downgrade
         if: matrix.rust == '1.64.0'
         run: |
           cargo generate-lockfile
           cargo update -p hashbrown --precise 0.15.0
-      - name: Build
-        run: |
-          cargo build --verbose --no-default-features
-          cargo build --verbose --features "${{ matrix.features }}"
-      - name: Tests
-        run: |
-          cargo test --verbose --no-default-features
-          cargo test ${{ matrix.test_all }} --verbose --features "${{ matrix.features }}"
+
+      - name: Build with no features
+        run: cargo build --verbose --no-default-features
+      - name: Test with no features
+        run: cargo test --verbose --no-default-features
+
+      - name: Build with features "${{ matrix.features }}"
+        run: cargo build --verbose --features "${{ matrix.features }}"
+      - name: Test with features "${{ matrix.features }}"
+        run: cargo test ${{ matrix.test_all }} --verbose --features "${{ matrix.features }}"
+
       - name: Build benchmarks
         if: ${{ matrix.bench }}
         run: |
           cargo bench --verbose --no-run
           cargo bench --verbose --no-run --all-features
 
-  rustfmt:
+  check:
+    name: Lints
     runs-on: ubuntu-latest
-    continue-on-error: true
-    strategy:
-      matrix:
-        include:
-          - rust: stable
-            rustfmt: rustfmt
-
     steps:
       - uses: actions/checkout@v4
-      - uses: actions-rs/toolchain@v1
+      - uses: mozilla-actions/[email protected]
+      - name: Install stable toolchain
+        uses: dtolnay/rust-toolchain@stable
         with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          components: ${{ matrix.rustfmt }}
-          override: true
-      - name: Rustfmt
-        if: matrix.rustfmt
+          components: rustfmt, clippy
+
+      - name: Check formatting
         run: cargo fmt -- --check
 
+      - name: Run clippy
+        # The benchmarks target require nightly,
+        # so we cannot use --all-targets here.
+        run: |
+          cargo clippy --all-features \
+            --lib --bins --examples --tests \
+            -- -D warnings
+
+      - name: Build docs
+        run: cargo doc --no-deps --all-features
+        env:
+          RUSTDOCFLAGS: "-Dwarnings"
+
   miri:
+    name: Unsoundness check
+    if: github.event_name != 'merge_group'
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - uses: mozilla-actions/[email protected]
       - uses: dtolnay/rust-toolchain@nightly
         with:
           components: miri

Cargo.toml

@@ -4,7 +4,7 @@ name = "petgraph"
 version = "0.7.1"
 readme = "README.md"
 license = "MIT OR Apache-2.0"
-authors = ["bluss", "mitchmindtree"]
+authors = { workspace = true }
 
 description = "Graph data structure library. Provides graph types and graph algorithms."
 documentation = "https://docs.rs/petgraph/"
@@ -13,16 +13,23 @@ repository = "https://github.com/petgraph/petgraph"
 keywords = ["data-structure", "graph", "unionfind", "graph-algorithms"]
 categories = ["data-structures"]
 
-rust-version = "1.64"
-
-edition = "2018"
+rust-version = { workspace = true }
+edition = { workspace = true }
 
 [package.metadata.docs.rs]
 features = ["rayon", "serde-1", "quickcheck"]
 
 [package.metadata.release]
 no-dev-version = true
 
+[workspace.package]
+rust-version = "1.64"
+edition = "2021"
+authors = ["bluss", "mitchmindtree"]
+
+[workspace]
+members = [".", "serialization-tests"]
+
 [lib]
 bench = false
 
@@ -71,6 +78,3 @@ matrix_graph = []
 serde-1 = ["serde", "serde_derive"]
 stable_graph = []
 unstable = ["generate"]
-
-[workspace]
-members = ["serialization-tests"]

benches/articulation_points.rs

@@ -11,13 +11,12 @@ use test::Bencher;
 fn bridges_bench(bench: &mut Bencher) {
     static NODE_COUNT: usize = 1000;
     let mut g = Graph::new_undirected();
-    let nodes: Vec<NodeIndex<_>> = (0..NODE_COUNT).into_iter().map(|i| g.add_node(i)).collect();
+    let nodes: Vec<NodeIndex<_>> = (0..NODE_COUNT).map(|i| g.add_node(i)).collect();
     for i in 0..NODE_COUNT {
         let n1 = nodes[i];
         let neighbour_count = i % 8 + 1;
 
-        for j in (i % 117)..(i % 117) + neighbour_count {
-            let n2 = nodes[j];
+        for &n2 in nodes.iter().skip(i % 117).take(neighbour_count) {
             g.add_edge(n1, n2, ());
         }
     }

benches/coloring.rs

@@ -13,12 +13,14 @@ use petgraph::algo::dsatur_coloring;
 fn dsatur_coloring_bench(bench: &mut Bencher) {
     static NODE_COUNT: usize = 10_000;
     let mut g = Graph::new_undirected();
-    let nodes: Vec<NodeIndex<_>> = (0..NODE_COUNT).into_iter().map(|i| g.add_node(i)).collect();
+    let nodes: Vec<NodeIndex<_>> = (0..NODE_COUNT).map(|i| g.add_node(i)).collect();
     for i in 0..NODE_COUNT {
         let n1 = nodes[i];
         let neighbour_count = i % 8 + 3;
         let j_from = max(0, i as i32 - neighbour_count as i32 / 2) as usize;
         let j_to = min(NODE_COUNT, j_from + neighbour_count);
+
+        #[allow(clippy::needless_range_loop)]
         for j in j_from..j_to {
             let n2 = nodes[j];
             g.add_edge(n1, n2, ());

benches/common/factories.rs

@@ -177,9 +177,8 @@ const BIPARTITE: &str = "
 ";
 
 /// Parse a text adjacency matrix format into a directed graph
-fn parse_graph<Ty, G>(s: &str) -> G
+fn parse_graph<G>(s: &str) -> G
 where
-    Ty: EdgeType,
     G: Default + Build<NodeWeight = (), EdgeWeight = ()> + NodeIndexable,
 {
     let mut g: G = Default::default();
@@ -221,35 +220,35 @@ where
     }
 
     pub fn petersen_a(self) -> G {
-        parse_graph::<Ty, _>(PETERSEN_A)
+        parse_graph::<_>(PETERSEN_A)
     }
 
     pub fn petersen_b(self) -> G {
-        parse_graph::<Ty, _>(PETERSEN_B)
+        parse_graph::<_>(PETERSEN_B)
     }
 
     pub fn full_a(self) -> G {
-        parse_graph::<Ty, _>(FULL_A)
+        parse_graph::<_>(FULL_A)
     }
 
     pub fn full_b(self) -> G {
-        parse_graph::<Ty, _>(FULL_B)
+        parse_graph::<_>(FULL_B)
     }
 
     pub fn praust_a(self) -> G {
-        parse_graph::<Ty, _>(PRAUST_A)
+        parse_graph::<_>(PRAUST_A)
     }
 
     pub fn praust_b(self) -> G {
-        parse_graph::<Ty, _>(PRAUST_B)
+        parse_graph::<_>(PRAUST_B)
     }
 
     pub fn bigger(self) -> G {
-        parse_graph::<Ty, _>(BIGGER)
+        parse_graph::<_>(BIGGER)
     }
 
     pub fn bipartite(self) -> G {
-        parse_graph::<Ty, _>(BIPARTITE)
+        parse_graph::<_>(BIPARTITE)
     }
 }
 

benches/graphmap.rs

@@ -30,12 +30,12 @@ fn test_nodes() -> Vec<MyStruct> {
 }
 
 fn test_graph<H: BuildHasher + Default>(
-    data: &Vec<MyStruct>,
+    data: &[MyStruct],
 ) -> GraphMap<&MyStruct, usize, Directed, H> {
     let mut gr = GraphMap::new();
 
-    for i in 0..2500 {
-        gr.add_node(&data[i]);
+    for val in data {
+        gr.add_node(val);
     }
 
     for i in 0..1_000 {
@@ -76,7 +76,7 @@ fn graphmap_parallel_bench(bench: &mut Bencher) {
     let data = test_nodes();
     let gr = test_graph::<std::hash::RandomState>(&data);
     bench.iter(|| {
-        let sources: Vec<MyStruct> = gr
+        let _sources: Vec<MyStruct> = gr
             .par_nodes()
             .map(|n| {
                 let mut sources = vec![];

benches/page_rank.rs

@@ -13,8 +13,6 @@ use common::directed_fan;
 
 #[cfg(feature = "rayon")]
 use petgraph::algo::page_rank::parallel_page_rank;
-#[cfg(feature = "rayon")]
-use rayon::prelude::*;
 
 #[bench]
 fn page_rank_bench(bench: &mut Bencher) {

clippy.toml

@@ -4,9 +4,10 @@ name = "petgraph-serialization-tests"
 version = "0.0.0"
 publish = false
 license = "MIT/Apache-2.0"
-authors = [
-"bluss",
-]
+authors = ["bluss"]
+
+rust-version = { workspace = true }
+edition = { workspace = true }
 
 description = ""
 documentation = ""

serialization-tests/Cargo.toml

@@ -23,23 +23,21 @@ use std::hash::Hash;
 ///     algo::articulation_points::articulation_points,
 /// };
 ///
-/// fn main() {
-///     let mut gr = UnGraph::<&str, ()>::new_undirected();
-///     let a = gr.add_node("A");
-///     let b = gr.add_node("B");
-///     let c = gr.add_node("C");
+/// let mut gr = UnGraph::<&str, ()>::new_undirected();
+/// let a = gr.add_node("A");
+/// let b = gr.add_node("B");
+/// let c = gr.add_node("C");
 ///
-///     gr.add_edge(a, b, ());
-///     gr.add_edge(b, c, ());
+/// gr.add_edge(a, b, ());
+/// gr.add_edge(b, c, ());
 ///
-///     let articulation_points: Vec<&str> = articulation_points(&gr)
-///         .into_iter()
-///         .map(|node_idx| gr[node_idx])
-///         .collect();
+/// let articulation_points: Vec<&str> = articulation_points(&gr)
+///     .into_iter()
+///     .map(|node_idx| gr[node_idx])
+///     .collect();
 ///
-///     // Articulation Points: ["B"]
-///     println!("Articulation Points: {:?}", articulation_points);
-/// }
+/// // Articulation Points: ["B"]
+/// println!("Articulation Points: {:?}", articulation_points);
 /// ```
 pub fn articulation_points<G>(g: G) -> HashSet<G::NodeId>
 where

src/algo/articulation_points.rs

@@ -5,7 +5,7 @@ use crate::scored::MaxScored;
 use crate::visit::{IntoEdges, IntoNodeIdentifiers, NodeIndexable, VisitMap, Visitable};
 
 /// \[Generic\] DStatur algorithm to properly color a non weighted undirected graph.
-/// https://en.wikipedia.org/wiki/DSatur
+/// <https://en.wikipedia.org/wiki/DSatur>
 ///
 /// This is a heuristic. So, it does not necessarily return a minimum coloring.
 ///
@@ -47,7 +47,6 @@ use crate::visit::{IntoEdges, IntoNodeIdentifiers, NodeIndexable, VisitMap, Visi
 /// assert_eq!(nb_colors, 2);
 /// assert_ne!(coloring[&a], coloring[&b]);
 /// ```
-
 pub fn dsatur_coloring<G>(graph: G) -> (HashMap<G::NodeId, usize>, usize)
 where
     G: IntoEdges + IntoNodeIdentifiers + Visitable + NodeIndexable,

src/algo/coloring.rs

@@ -149,7 +149,7 @@ where
 
 /// The undefined dominator sentinel, for when we have not yet discovered a
 /// node's dominator.
-const UNDEFINED: usize = ::std::usize::MAX;
+const UNDEFINED: usize = usize::MAX;
 
 /// This is an implementation of the engineered ["Simple, Fast Dominance
 /// Algorithm"][0] discovered by Cooper et al.