chore(ci): enforce clippy and cargo fmt in CI

.github/workflows/formatting.yml

@@ -0,0 +1,64 @@
+name: Clippy
+
+on:
+  pull_request:
+  merge_group:
+  push:
+    branches:
+      - master
+
+# This will cancel previous runs when a branch or PR is updated
+concurrency:
+  group: ${{ github.workflow }}-${{ github.head_ref || github.ref || github.run_id }}
+  cancel-in-progress: true
+
+jobs:
+  clippy:
+    name: cargo clippy
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 30
+    env:
+      CACHED_PATHS: |
+        ~/.cargo/bin/
+        ~/.cargo/registry/index/
+        ~/.cargo/registry/cache/
+        ~/.cargo/git/db/
+        target/
+
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - runner: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Restore cargo cache
+        uses: actions/cache/restore@v3
+        id: cache
+        with:
+          path: ${{ env.CACHED_PATHS }}
+          key: ${{ matrix.target }}-cargo-test-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Setup toolchain
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: stable # We do not use MSRV so we can benefit from newer lints
+          targets: ${{ matrix.target }}
+          components: clippy, rustfmt
+
+      - name: Run `cargo clippy`
+        run: cargo clippy --workspace --locked --release
+
+      - name: Run `cargo fmt`
+        run: cargo fmt --all --check
+
+      - uses: actions/cache/save@v3
+        # Write a cache entry even if the tests fail but don't create any for the merge queue.
+        if: ${{ always() && steps.cache.outputs.cache-hit != 'true' && github.event_name != 'merge_group' }}
+        with:
+          path: ${{ env.CACHED_PATHS }}
+          key: ${{ steps.cache.outputs.cache-primary-key }}

crates/noirc_evaluator/src/ssa/ir/map.rs

@@ -1,4 +1,4 @@
 use fxhash::FxHashMap as HashMap;
 use std::{
     hash::Hash,
     sync::atomic::{AtomicUsize, Ordering},
@@ -74,7 +74,7 @@
 
 impl<T> Clone for Id<T> {
     fn clone(&self) -> Self {
-        Self { index: self.index, _marker: self._marker }
+        *self
     }
 }
 
@@ -237,7 +237,7 @@
 }
 
 /// A TwoWayMap is a map from both key to value and value to key.
 /// This is accomplished by keeping the map bijective - for every
 /// value there is exactly one key and vice-versa. Any duplicate values
 /// are prevented in the call to insert.
 #[derive(Debug)]

crates/noirc_frontend/src/hir/def_collector/dc_mod.rs

@@ -6,8 +6,8 @@ use crate::{
     hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait},
     node_interner::TraitId,
     parser::SubModule,
-    FunctionDefinition, Ident, LetStatement, NoirFunction, NoirStruct,
-    NoirTrait, NoirTypeAlias, ParsedModule, TraitImpl, TraitImplItem, TraitItem, TypeImpl,
+    FunctionDefinition, Ident, LetStatement, NoirFunction, NoirStruct, NoirTrait, NoirTypeAlias,
+    ParsedModule, TraitImpl, TraitImplItem, TraitItem, TypeImpl,
 };
 
 use super::{

crates/noirc_frontend/src/hir/def_map/namespace.rs

@@ -21,11 +21,11 @@ impl PerNs {
     }
 
     pub fn iter_defs(self) -> impl Iterator<Item = ModuleDefId> {
-        self.types.map(|it| it.0).into_iter().chain(self.values.map(|it| it.0).into_iter())
+        self.types.map(|it| it.0).into_iter().chain(self.values.map(|it| it.0))
     }
 
     pub fn iter_items(self) -> impl Iterator<Item = (ModuleDefId, Visibility)> {
-        self.types.into_iter().chain(self.values.into_iter())
+        self.types.into_iter().chain(self.values)
     }
 
     pub fn is_none(&self) -> bool {