From 6d226be76b3708c98a52ec831a8d2e965e4acac8 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 17:52:25 -0300
Subject: [PATCH 01/93] Change CI

---
 .github/workflows/test-detectors.yml | 110 +++++++++------------------
 1 file changed, 34 insertions(+), 76 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 3c17adc4..de777e14 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -5,13 +5,11 @@ on:
     branches:
       - "main"
     paths:
-      - "apps/cargo-scout-audit/**"
       - "detectors/**"
       - "test-cases/**"
       - "Makefile"
   pull_request:
     paths:
-      - "apps/cargo-scout-audit/**"
       - "detectors/**"
       - "test-cases/**"
       - "Makefile"
@@ -22,36 +20,8 @@ env:
   RUST_BACKTRACE: full
 
 jobs:
-  check-config:
-    name: Check config
-    strategy:
-      matrix:
-        os:
-          - ubuntu-latest
-          - macos-latest
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-
-      - name: Install python dependencies
-        run: pip3 install pyyaml
-
-      - name: Check test matrix is complete
-        run: python3 scripts/check-ci-detectors-to-test.py .github/workflows/test-detectors.yml detectors
-
-      - name: Check detectors for repeated names
-        run: python3 scripts/check-detectors-repeated-names.py detectors
-
-      - name: Check detector names with underscore
-        run: python3 scripts/check-detectors-underscore-names.py detectors
-
-      - name: Check detector names different than their folders
-        run: python3 scripts/check-detectors-names-match-folder.py detectors
-
   build:
     name: Build
-    needs: check-config
     strategy:
       matrix:
         os:
@@ -60,75 +30,63 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Cache cargo-scout dependencies
         id: cache-cargo-scout-dependencies
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cargo
-            apps/cargo-scout-audit/target
-            detectors/target
-            detectors/Cargo.lock
           key: ${{ runner.os }}-cargo-scout-dependencies-${{ github.run_id }}
 
-      - name: Install Rust nightly-2023-09-29
-        run: rustup install nightly-2023-09-29 --profile minimal
+      - name: Update Rust Toolchain
+        run: rustup update
 
-      - name: Install dylint-link
-        run: cargo install dylint-link
+      - name: Install dylint and dylint-link
+        run: cargo +nightly install cargo-dylint dylint-link
 
-      - name: Compile cargo-scout-audit tests
-        working-directory: apps/cargo-scout-audit
-        run: cargo test --no-run
+      - name: Install cargo-scout-audit
+        run: cargo +nightly install cargo-scout-audit
 
-      - name: Compile detectors
-        working-directory: detectors
-        run: cargo build --release
+  prepare-test-matrix:
+    name: Prepare Test Matrix
+    runs-on: ubuntu-latest
+    outputs:
+      matrix: ${{ steps.set-matrix.outputs.matrix }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - id: set-matrix
+        run: |
+          echo "::set-output name=matrix::$(find test-cases -mindepth 1 -maxdepth 1 -type d -printf '"%f", ' | sed 's/, $//')"
 
-  test:
-    name: Test
-    needs: build
+  integration-tests:
+    name: Integration Tests
+    needs: [build, prepare-test-matrix]
     strategy:
+      fail-fast: false
       matrix:
         os:
           - ubuntu-latest
           - macos-latest
-        test:
-          [
-            "avoid-core-mem-forget",
-            "avoid-panic-error",
-            "avoid-unsafe-block",
-            "divide-before-multiply",
-            "dos-unbounded-operation",
-            "insufficiently-random-values",
-            "overflow-check",
-            "set-contract-storage",
-            "unprotected-update-current-contract-wasm",
-            "unsafe-expect",
-            "unsafe-unwrap",
-            "unused-return-enum",
-          ]
+        test-case: ${{fromJson(needs.prepare-test-matrix.outputs.matrix)}}
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
-      - name: Cache cargo-scout dependencies
-        id: cache-cargo-scout-dependencies
-        uses: actions/cache@v3
+      - name: Cache cargo dependencies
+        uses: actions/cache@v4
         with:
           path: |
             ~/.cargo
-            apps/cargo-scout-audit/target
-            detectors/target
-            detectors/Cargo.lock
-          key: ${{ runner.os }}-cargo-scout-dependencies-${{ github.run_id  }}
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           fail-on-cache-miss: true
 
-      - name: Run tests
-        working-directory: apps/cargo-scout-audit
-        env:
-          INTEGRATION_TESTS_TO_RUN: ${{ matrix.test }}
-        run: cargo test -- --nocapture
+      - name: Run integration test for a specific test case
+        run: |
+          cd ${{ matrix.test-case }}
+          cargo test

From fd697d883142912d69b5037f44a27fc2e4989658 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 17:53:06 -0300
Subject: [PATCH 02/93] Trigger CI

---
 test-cases/README.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/test-cases/README.md b/test-cases/README.md
index 18afcac7..197bf071 100644
--- a/test-cases/README.md
+++ b/test-cases/README.md
@@ -57,7 +57,6 @@ Check our
 [test-cases](https://github.com/CoinFabrik/scout-soroban/tree/main/test-cases)
 for code examples of these vulnerabilities and their respective remediations.
 
-
 ### Divide before multiply
 
 This vulnerability class relates to the order of operations in Rust, specifically in integer arithmetic. Performing a division operation before a multiplication can lead to a loss of precision. This issue becomes significant in programs like smart contracts where numerical precision is crucial.
@@ -65,7 +64,6 @@ This vulnerability class relates to the order of operations in Rust, specificall
 This vulnerability falls under the [Arithmetic](#vulnerability-categories) category
 and has a Medium Severity.
 
-
 ### Unsafe unrwap
 
 This vulnerability class pertains to the inappropriate usage of the `unwrap` method in Rust, which is commonly employed for error handling. The `unwrap` method retrieves the inner value of an `Option` or `Result`, but if an error or `None` occurs, it triggers a panic and crashes the program.
@@ -74,7 +72,6 @@ This vulnerability again falls under the [Validations and error handling](#vulne
 
 In our example, we consider an contract that utilizes the `unwrap` method to retrieve the balance of an account from a mapping. If there is no entry for the specified account, the contract will panic and abruptly halt execution, opening avenues for malicious exploitation.
 
-
 ### Unsafe expect
 
 In Rust, the `expect` method is commonly used for error handling. It retrieves the value from a `Result` or `Option` and panics with a specified error message if an error occurs. However, using `expect` can lead to unexpected program crashes.
@@ -105,7 +102,6 @@ Notwithstanding, there are contexts where developers do turn off checks for
 valid reasons and hence the reason for including this vulnerability in the
 list.
 
-
 ### Insufficiently random values
 
 Using block attributes like ledger `timestamp()` and ledger `sequence()` for random number generation in Soroban smart contracts is not recommended due to the predictability of these values. Block attributes are publicly visible and deterministic, making it easy for malicious actors to anticipate their values and manipulate outcomes to their advantage. Furthermore, validators could potentially influence these attributes, further exacerbating the risk of manipulation. For truly random number generation, it's important to use a source that is both unpredictable and external to the blockchain environment, reducing the potential for malicious exploitation.

From e40b4839aa6a05d3f665e723316b9fa3f568dfc4 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 18:07:17 -0300
Subject: [PATCH 03/93] Update general rust

---
 .github/workflows/general-rust.yml | 95 ++++++++++++++++++++++--------
 1 file changed, 69 insertions(+), 26 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 0e7444ec..59e945e9 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -5,13 +5,11 @@ on:
     branches:
       - "main"
     paths:
-      - "apps/cargo-scout-audit/**"
       - "detectors/**"
       - "test-cases/**"
       - "Makefile"
   pull_request:
     paths:
-      - "apps/cargo-scout-audit/**"
       - "detectors/**"
       - "test-cases/**"
       - "Makefile"
@@ -22,48 +20,93 @@ env:
 
 jobs:
   format:
-    name: Format
+    name: Check Rust Format
     runs-on: ubuntu-latest
+
     steps:
-      - uses: actions/checkout@v3
+      - name: Checkout Code
+        uses: actions/checkout@v4
 
-      - name: Update Rust
+      - name: Update Rust Toolchain
         run: rustup update
 
       - name: Install Rust nightly
         run: rustup install nightly --profile minimal
 
-      - name: Install Rustfmt
-        run: rustup component add rustfmt --toolchain nightly
+      - name: Install rustfmt
+        run: rustup component add rustfmt
+
+      - name: Check Formatting in Detectors
+        run: |
+          cd detectors
+          cargo +nightly fmt -- --check
 
-      - name: Run cargo fmt
-        run: make fmt-rust-check
+      - name: Check Formatting in Test Cases
+        run: |
+          find test-cases -name Cargo.toml -execdir cargo +nightly fmt -- --check \;
 
   clippy:
-    name: Clippy
+    name: Lint with Clippy
     runs-on: ubuntu-latest
+
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
+      - name: Checkout Code
+        uses: actions/checkout@v4
 
-      - name: Cache cargo-scout-audit dependencies
-        id: cache-cargo-scout-audit-dependencies
-        uses: actions/cache@v3
+      - name: Cache Rust Dependencies
+        uses: actions/cache@v4
         with:
-          path: ./apps/cargo-scout-audit/target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('apps/cargo-scout-audit/Cargo.lock') }}
+          path: |
+            ~/.cargo
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Update Rust
+      - name: Update Rust Toolchain
         run: rustup update
 
-      - name: Install Rust nightly-2023-09-29
-        run: rustup install nightly-2023-09-29-x86_64-unknown-linux-gnu --profile minimal
+      - name: Install Rust nightly
+        run: rustup install nightly --profile minimal
+
+      - name: Install clippy
+        run: rustup component add clippy
+
+      - name: Lint Code in Detectors
+        run: |
+          cd detectors
+          cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: Lint Code in Test Cases
+        run: |
+          find test-cases -name Cargo.toml -execdir cargo clippy --all-targets --all-features -- -D warnings \;
+
+  udeps:
+    name: Check Unused Dependencies with cargo-udeps
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Cache Rust Dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
+      - name: Update Rust Toolchain
+        run: rustup update
+
+      - name: Install Rust nightly
+        run: rustup install nightly --profile minimal
 
-      - name: Install Clippy
-        run: rustup component add clippy --toolchain nightly-2023-09-29-x86_64-unknown-linux-gnu
+      - name: Install cargo-udeps
+        run: cargo install cargo-udeps
 
-      - name: Install dylint-link
-        run: cargo install dylint-link
+      - name: Check Unused Dependencies in Detectors
+        run: |
+          cd detectors
+          cargo +nightly udeps --all-targets
 
-      - name: Run clippy
-        run: make lint
+      - name: Check Unused Dependencies in Test Cases
+        run: |
+          find test-cases -name Cargo.toml -execdir cargo +nightly udeps --all-targets \;

From 35f7c85c175d325bfb134c32ded76799dd9a3b80 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 18:09:57 -0300
Subject: [PATCH 04/93] Update general and integration

---
 .github/workflows/general-rust.yml   | 2 +-
 .github/workflows/test-detectors.yml | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 59e945e9..6073fb66 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -34,7 +34,7 @@ jobs:
         run: rustup install nightly --profile minimal
 
       - name: Install rustfmt
-        run: rustup component add rustfmt
+        run: rustup component add rustfmt --toolchain nightly
 
       - name: Check Formatting in Detectors
         run: |
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index de777e14..15d7ca1a 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -43,6 +43,9 @@ jobs:
       - name: Update Rust Toolchain
         run: rustup update
 
+      - name: Install Rust nightly
+        run: rustup install nightly --profile minimal
+
       - name: Install dylint and dylint-link
         run: cargo +nightly install cargo-dylint dylint-link
 

From 1dde419c9d8a0ec6b25063f8eac4a382ddde0eca Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 18:13:53 -0300
Subject: [PATCH 05/93] Edit general rust

---
 .github/workflows/general-rust.yml | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 6073fb66..8262b732 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -38,12 +38,11 @@ jobs:
 
       - name: Check Formatting in Detectors
         run: |
-          cd detectors
-          cargo +nightly fmt -- --check
+          cd detectors && cargo +nightly fmt -- --check -v
 
       - name: Check Formatting in Test Cases
         run: |
-          find test-cases -name Cargo.toml -execdir cargo +nightly fmt -- --check \;
+          find test-cases -name Cargo.toml -execdir cargo +nightly fmt -- --check -v \;
 
   clippy:
     name: Lint with Clippy
@@ -67,12 +66,11 @@ jobs:
         run: rustup install nightly --profile minimal
 
       - name: Install clippy
-        run: rustup component add clippy
+        run: rustup component add clippy --toolchain nightly
 
       - name: Lint Code in Detectors
         run: |
-          cd detectors
-          cargo clippy --all-targets --all-features -- -D warnings
+          cd detectors && cargo clippy --all-targets --all-features -- -D warnings
 
       - name: Lint Code in Test Cases
         run: |

From fac155ad8a27f1fbbc1383b45eedf3760fc80f59 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 18:17:11 -0300
Subject: [PATCH 06/93] Update general rust

---
 .github/workflows/general-rust.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 8262b732..1ebbc16a 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -68,6 +68,9 @@ jobs:
       - name: Install clippy
         run: rustup component add clippy --toolchain nightly
 
+      - name: Install dylint-link
+        run: cargo install dylint-link
+
       - name: Lint Code in Detectors
         run: |
           cd detectors && cargo clippy --all-targets --all-features -- -D warnings

From a7e6760b3c68de96de5c2cd912a576669193952b Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 18:26:19 -0300
Subject: [PATCH 07/93] Update udeps CI error

---
 .github/workflows/general-rust.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 1ebbc16a..f3dd194f 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -103,6 +103,9 @@ jobs:
       - name: Install cargo-udeps
         run: cargo install cargo-udeps
 
+      - name: Install dylint-link
+        run: cargo install dylint-link
+
       - name: Check Unused Dependencies in Detectors
         run: |
           cd detectors

From 7f86b64851dc0244279d07b27b5001e2417264fe Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 18:52:43 -0300
Subject: [PATCH 08/93] Update deprecated github output

---
 .github/workflows/test-detectors.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 15d7ca1a..cf5043da 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -63,7 +63,7 @@ jobs:
 
       - id: set-matrix
         run: |
-          echo "::set-output name=matrix::$(find test-cases -mindepth 1 -maxdepth 1 -type d -printf '"%f", ' | sed 's/, $//')"
+          echo "name=matrix::$(find test-cases -mindepth 1 -maxdepth 1 -type d -printf '"%f", ' | sed 's/, $//')" >> $GITHUB_OUTPUT
 
   integration-tests:
     name: Integration Tests

From 9fbd1b14a1ed6dd04e88cee6fdd8a4fc0e255f93 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 19:03:43 -0300
Subject: [PATCH 09/93] Edit udeps CI

---
 .github/workflows/general-rust.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index f3dd194f..56f17db5 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -100,6 +100,9 @@ jobs:
       - name: Install Rust nightly
         run: rustup install nightly --profile minimal
 
+      - name: Install rust-src, rustc-dev, and llvm-tools-preview
+        run: rustup component add rust-src rustc-dev llvm-tools-preview
+
       - name: Install cargo-udeps
         run: cargo install cargo-udeps
 

From d85550b1741da4291e30fd42515cb45a392a6c16 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 22:06:19 -0300
Subject: [PATCH 10/93] Update prepare-matrix

---
 .github/workflows/test-detectors.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index cf5043da..af628046 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -63,7 +63,7 @@ jobs:
 
       - id: set-matrix
         run: |
-          echo "name=matrix::$(find test-cases -mindepth 1 -maxdepth 1 -type d -printf '"%f", ' | sed 's/, $//')" >> $GITHUB_OUTPUT
+         echo "matrix=$(find test-cases -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
   integration-tests:
     name: Integration Tests

From c17b583b739c949ea1627d3f8a9d964ea6e48754 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 22:21:51 -0300
Subject: [PATCH 11/93] Update integration test CI

---
 .github/workflows/test-detectors.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index af628046..05874de8 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -63,7 +63,7 @@ jobs:
 
       - id: set-matrix
         run: |
-         echo "matrix=$(find test-cases -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
+          echo "matrix=$(find test-cases -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
   integration-tests:
     name: Integration Tests
@@ -87,7 +87,6 @@ jobs:
             ~/.cargo
             target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          fail-on-cache-miss: true
 
       - name: Run integration test for a specific test case
         run: |

From 44dda78aae37bfaa01dcbee8222a5e2f93a90bd3 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 22:37:58 -0300
Subject: [PATCH 12/93] Update CI

---
 .github/workflows/general-rust.yml            | 22 ++---
 .../test-detector-soroban-version.yml         | 95 -------------------
 .github/workflows/test-detectors.yml          | 36 ++++++-
 3 files changed, 41 insertions(+), 112 deletions(-)
 delete mode 100644 .github/workflows/test-detector-soroban-version.yml

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 56f17db5..858da53e 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -37,12 +37,11 @@ jobs:
         run: rustup component add rustfmt --toolchain nightly
 
       - name: Check Formatting in Detectors
-        run: |
-          cd detectors && cargo +nightly fmt -- --check -v
+        working-directory: detectors
+        run: cargo +nightly fmt -- --check -v
 
       - name: Check Formatting in Test Cases
-        run: |
-          find test-cases -name Cargo.toml -execdir cargo +nightly fmt -- --check -v \;
+        run: find test-cases -name Cargo.toml -execdir cargo +nightly fmt -- --check -v \;
 
   clippy:
     name: Lint with Clippy
@@ -72,12 +71,11 @@ jobs:
         run: cargo install dylint-link
 
       - name: Lint Code in Detectors
-        run: |
-          cd detectors && cargo clippy --all-targets --all-features -- -D warnings
+        working-directory: detectors
+        run: cargo clippy --all-targets --all-features -- -D warnings
 
       - name: Lint Code in Test Cases
-        run: |
-          find test-cases -name Cargo.toml -execdir cargo clippy --all-targets --all-features -- -D warnings \;
+        run: find test-cases -name Cargo.toml -execdir cargo clippy --all-targets --all-features -- -D warnings \;
 
   udeps:
     name: Check Unused Dependencies with cargo-udeps
@@ -110,10 +108,8 @@ jobs:
         run: cargo install dylint-link
 
       - name: Check Unused Dependencies in Detectors
-        run: |
-          cd detectors
-          cargo +nightly udeps --all-targets
+        working-directory: detectors
+        run: cargo +nightly udeps --all-targets
 
       - name: Check Unused Dependencies in Test Cases
-        run: |
-          find test-cases -name Cargo.toml -execdir cargo +nightly udeps --all-targets \;
+        run: find test-cases -name Cargo.toml -execdir cargo +nightly udeps --all-targets \;
diff --git a/.github/workflows/test-detector-soroban-version.yml b/.github/workflows/test-detector-soroban-version.yml
deleted file mode 100644
index d4728229..00000000
--- a/.github/workflows/test-detector-soroban-version.yml
+++ /dev/null
@@ -1,95 +0,0 @@
-name: Test Detectors
-
-on:
-  push:
-    branches:
-      - "main"
-    paths:
-      - "apps/cargo-scout-audit/**"
-      - "detectors/**"
-      - "test-cases/**"
-      - "Makefile"
-  pull_request:
-    paths:
-      - "apps/cargo-scout-audit/**"
-      - "detectors/**"
-      - "test-cases/**"
-      - "Makefile"
-  workflow_dispatch:
-
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: full
-
-jobs:
-  build:
-    name: Build
-    strategy:
-      matrix:
-        os:
-          - ubuntu-latest
-          - macos-latest
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-
-      - name: Cache cargo-scout dependencies
-        id: cache-cargo-scout-dependencies
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cargo
-            apps/cargo-scout-audit/target
-            detectors/target
-            detectors/Cargo.lock
-          key: ${{ runner.os }}-cargo-scout-dependencies-${{ github.run_id }}
-
-      - name: Install Rust nightly-2023-09-29
-        run: rustup install nightly-2023-09-29 --profile minimal
-
-      - name: Install dylint-link
-        run: cargo install dylint-link
-
-      - name: Compile cargo-scout-audit tests
-        working-directory: apps/cargo-scout-audit
-        run: cargo test --no-run
-
-      - name: Compile detectors
-        working-directory: detectors
-        run: cargo build --release
-
-  test:
-    name: Test
-    needs: build
-    strategy:
-      matrix:
-        os:
-          - ubuntu-latest
-          - macos-latest
-        test:
-          [
-            "soroban-version",
-          ]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v3
-
-      - name: Cache cargo-scout dependencies
-        id: cache-cargo-scout-dependencies
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cargo
-            apps/cargo-scout-audit/target
-            detectors/target
-            detectors/Cargo.lock
-          key: ${{ runner.os }}-cargo-scout-dependencies-${{ github.run_id  }}
-          fail-on-cache-miss: true
-
-      - name: Run tests
-        working-directory: apps/cargo-scout-audit
-        env:
-          INTEGRATION_TESTS_TO_RUN: ${{ matrix.test }}
-        run: cargo test -- --nocapture
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 05874de8..100dc841 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -65,7 +65,7 @@ jobs:
         run: |
           echo "matrix=$(find test-cases -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
-  integration-tests:
+  unit-tests:
     name: Integration Tests
     needs: [build, prepare-test-matrix]
     strategy:
@@ -89,6 +89,34 @@ jobs:
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Run integration test for a specific test case
-        run: |
-          cd ${{ matrix.test-case }}
-          cargo test
+        working-directory: test-cases/${{ matrix.test-case }}
+        run: cargo test
+
+  integration-tests:
+    name: Integration Tests
+    needs: [build, prepare-test-matrix]
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - ubuntu-latest
+          - macos-latest
+        test-case: ${{fromJson(needs.prepare-test-matrix.outputs.matrix)}}
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Cache cargo-scout dependencies
+        id: cache-cargo-scout-dependencies
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/.cargo
+            target
+          key: ${{ runner.os }}-cargo-scout-dependencies-${{ github.run_id  }}
+          fail-on-cache-miss: true
+
+      - name: Run integration test for a specific test case
+        working-directory: test-cases/${{ matrix.test-case }}
+        run: cargo test --features integration-tests

From 15ef379476cc8adceed14d83175dfd1551e77acf Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 25 Mar 2024 22:55:56 -0300
Subject: [PATCH 13/93] Edit CI

---
 .github/workflows/test-detectors.yml | 41 +++++-----------------------
 1 file changed, 7 insertions(+), 34 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 100dc841..b4daeba6 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -32,13 +32,15 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
-      - name: Cache cargo-scout dependencies
-        id: cache-cargo-scout-dependencies
+      - name: Cache cargo dependencies
         uses: actions/cache@v4
         with:
           path: |
             ~/.cargo
-          key: ${{ runner.os }}-cargo-scout-dependencies-${{ github.run_id }}
+            target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -63,7 +65,7 @@ jobs:
 
       - id: set-matrix
         run: |
-          echo "matrix=$(find test-cases -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
+          echo "matrix=$(find test-cases -name Cargo.toml -exec dirname {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
   unit-tests:
     name: Integration Tests
@@ -89,34 +91,5 @@ jobs:
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Run integration test for a specific test case
-        working-directory: test-cases/${{ matrix.test-case }}
+        working-directory: ${{ matrix.test-case }}
         run: cargo test
-
-  integration-tests:
-    name: Integration Tests
-    needs: [build, prepare-test-matrix]
-    strategy:
-      fail-fast: false
-      matrix:
-        os:
-          - ubuntu-latest
-          - macos-latest
-        test-case: ${{fromJson(needs.prepare-test-matrix.outputs.matrix)}}
-    runs-on: ${{ matrix.os }}
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Cache cargo-scout dependencies
-        id: cache-cargo-scout-dependencies
-        uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cargo
-            target
-          key: ${{ runner.os }}-cargo-scout-dependencies-${{ github.run_id  }}
-          fail-on-cache-miss: true
-
-      - name: Run integration test for a specific test case
-        working-directory: test-cases/${{ matrix.test-case }}
-        run: cargo test --features integration-tests

From 2cd26cf0d3d98fb5c726c96043bad053c1d65fda Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 09:21:31 -0300
Subject: [PATCH 14/93] Update CI to run based on detectors

---
 .github/workflows/general-rust.yml   |  2 +-
 .github/workflows/test-detectors.yml | 16 ++++++++++------
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 858da53e..931f583a 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -78,7 +78,7 @@ jobs:
         run: find test-cases -name Cargo.toml -execdir cargo clippy --all-targets --all-features -- -D warnings \;
 
   udeps:
-    name: Check Unused Dependencies with cargo-udeps
+    name: Check Unused Dependencies
     runs-on: ubuntu-latest
 
     steps:
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index b4daeba6..a8c1b661 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -57,6 +57,7 @@ jobs:
   prepare-test-matrix:
     name: Prepare Test Matrix
     runs-on: ubuntu-latest
+    needs: build
     outputs:
       matrix: ${{ steps.set-matrix.outputs.matrix }}
     steps:
@@ -64,11 +65,12 @@ jobs:
         uses: actions/checkout@v4
 
       - id: set-matrix
+        working-directory: test-cases
         run: |
-          echo "matrix=$(find test-cases -name Cargo.toml -exec dirname {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
+          echo "matrix=$(find . -mindepth 1 -maxdepth 1 | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
-  unit-tests:
-    name: Integration Tests
+  test:
+    name: Test detector
     needs: [build, prepare-test-matrix]
     strategy:
       fail-fast: false
@@ -76,7 +78,7 @@ jobs:
         os:
           - ubuntu-latest
           - macos-latest
-        test-case: ${{fromJson(needs.prepare-test-matrix.outputs.matrix)}}
+        detector: ${{fromJson(needs.prepare-test-matrix.outputs.matrix)}}
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
@@ -91,5 +93,7 @@ jobs:
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Run integration test for a specific test case
-        working-directory: ${{ matrix.test-case }}
-        run: cargo test
+        working-directory: test-cases
+        run: |
+          cd ${{ matrix.detector }}
+          cargo test

From d1ae929739f22c9d9cdfc934dc16c7bcaf0f79e3 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 09:27:16 -0300
Subject: [PATCH 15/93] Update unit test CI

---
 .github/workflows/test-detectors.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index a8c1b661..eae5e7bb 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -92,8 +92,9 @@ jobs:
             target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Run integration test for a specific test case
+      - name: Run unit tests for a specific detector
         working-directory: test-cases
         run: |
           cd ${{ matrix.detector }}
-          cargo test
+          find . -name Cargo.toml -execdir cargo test \;
+

From 1b16486586abfe80caf636e2c4724a843d4a4c3b Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 09:48:57 -0300
Subject: [PATCH 16/93] Edit CI to find by directory on tests

---
 .github/workflows/general-rust.yml   |  5 -----
 .github/workflows/test-detectors.yml | 19 +++++++------------
 2 files changed, 7 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 931f583a..6e163d3a 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -13,7 +13,6 @@ on:
       - "detectors/**"
       - "test-cases/**"
       - "Makefile"
-  workflow_dispatch:
 
 env:
   CARGO_TERM_COLOR: always
@@ -107,9 +106,5 @@ jobs:
       - name: Install dylint-link
         run: cargo install dylint-link
 
-      - name: Check Unused Dependencies in Detectors
-        working-directory: detectors
-        run: cargo +nightly udeps --all-targets
-
       - name: Check Unused Dependencies in Test Cases
         run: find test-cases -name Cargo.toml -execdir cargo +nightly udeps --all-targets \;
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index eae5e7bb..df52aaf9 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -13,7 +13,6 @@ on:
       - "detectors/**"
       - "test-cases/**"
       - "Makefile"
-  workflow_dispatch:
 
 env:
   CARGO_TERM_COLOR: always
@@ -48,14 +47,11 @@ jobs:
       - name: Install Rust nightly
         run: rustup install nightly --profile minimal
 
-      - name: Install dylint and dylint-link
-        run: cargo +nightly install cargo-dylint dylint-link
+      - name: Install dylint, dylint-link and cargo-scout-audit
+        run: cargo +nightly install cargo-dylint dylint-link cargo-scout-audit
 
-      - name: Install cargo-scout-audit
-        run: cargo +nightly install cargo-scout-audit
-
-  prepare-test-matrix:
-    name: Prepare Test Matrix
+  prepare-detector-matrix:
+    name: Prepare Detector Matrix
     runs-on: ubuntu-latest
     needs: build
     outputs:
@@ -67,18 +63,18 @@ jobs:
       - id: set-matrix
         working-directory: test-cases
         run: |
-          echo "matrix=$(find . -mindepth 1 -maxdepth 1 | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
+          echo "matrix=$(find . -mindepth 1 -maxdepth 1 -type d | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
   test:
     name: Test detector
-    needs: [build, prepare-test-matrix]
+    needs: [build, prepare-detector-matrix]
     strategy:
       fail-fast: false
       matrix:
         os:
           - ubuntu-latest
           - macos-latest
-        detector: ${{fromJson(needs.prepare-test-matrix.outputs.matrix)}}
+        detector: ${{fromJson(needs.prepare-detector-matrix.outputs.matrix)}}
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
@@ -97,4 +93,3 @@ jobs:
         run: |
           cd ${{ matrix.detector }}
           find . -name Cargo.toml -execdir cargo test \;
-

From 6c23075ebaf43d3046f7baa1d0a688866c5950e2 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 10:28:51 -0300
Subject: [PATCH 17/93] Cache general rust and add setup step

---
 .github/workflows/general-rust.yml | 70 +++++++++++++++++++-----------
 1 file changed, 45 insertions(+), 25 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 6e163d3a..c514b9b9 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -7,31 +7,64 @@ on:
     paths:
       - "detectors/**"
       - "test-cases/**"
-      - "Makefile"
   pull_request:
     paths:
       - "detectors/**"
       - "test-cases/**"
-      - "Makefile"
 
 env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  format:
-    name: Check Rust Format
+  setup:
+    name: Setup
     runs-on: ubuntu-latest
 
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
 
+      - name: Cache Rust Tools and Targets
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo
+            test-cases/**/target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
       - name: Update Rust Toolchain
         run: rustup update
 
       - name: Install Rust nightly
         run: rustup install nightly --profile minimal
 
+      - name: Install dylint-link
+        run: cargo install dylint-link
+
+      - name: Update cargo
+        run: cargo update
+
+  format:
+    name: Check Rust Format
+    runs-on: ubuntu-latest
+    needs: setup
+
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Cache Rust Dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo
+            test-cases/**/target
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-cargo-
+
       - name: Install rustfmt
         run: rustup component add rustfmt --toolchain nightly
 
@@ -45,6 +78,7 @@ jobs:
   clippy:
     name: Lint with Clippy
     runs-on: ubuntu-latest
+    needs: setup
 
     steps:
       - name: Checkout Code
@@ -55,20 +89,14 @@ jobs:
         with:
           path: |
             ~/.cargo
+            test-cases/**/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Update Rust Toolchain
-        run: rustup update
-
-      - name: Install Rust nightly
-        run: rustup install nightly --profile minimal
+          restore-keys: |
+            ${{ runner.os }}-cargo-
 
       - name: Install clippy
         run: rustup component add clippy --toolchain nightly
 
-      - name: Install dylint-link
-        run: cargo install dylint-link
-
       - name: Lint Code in Detectors
         working-directory: detectors
         run: cargo clippy --all-targets --all-features -- -D warnings
@@ -79,6 +107,7 @@ jobs:
   udeps:
     name: Check Unused Dependencies
     runs-on: ubuntu-latest
+    needs: setup
 
     steps:
       - name: Checkout Code
@@ -89,22 +118,13 @@ jobs:
         with:
           path: |
             ~/.cargo
+            test-cases/**/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Update Rust Toolchain
-        run: rustup update
-
-      - name: Install Rust nightly
-        run: rustup install nightly --profile minimal
-
-      - name: Install rust-src, rustc-dev, and llvm-tools-preview
-        run: rustup component add rust-src rustc-dev llvm-tools-preview
+          restore-keys: |
+            ${{ runner.os }}-cargo-
 
       - name: Install cargo-udeps
         run: cargo install cargo-udeps
 
-      - name: Install dylint-link
-        run: cargo install dylint-link
-
       - name: Check Unused Dependencies in Test Cases
         run: find test-cases -name Cargo.toml -execdir cargo +nightly udeps --all-targets \;

From e51eaa057a7e508a542a1295cd185d863d857e58 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 10:32:15 -0300
Subject: [PATCH 18/93] Fix CI

---
 .github/workflows/general-rust.yml | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index c514b9b9..d661d28c 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -41,10 +41,7 @@ jobs:
         run: rustup install nightly --profile minimal
 
       - name: Install dylint-link
-        run: cargo install dylint-link
-
-      - name: Update cargo
-        run: cargo update
+        run: cargo install dylint-link --force
 
   format:
     name: Check Rust Format
@@ -124,7 +121,7 @@ jobs:
             ${{ runner.os }}-cargo-
 
       - name: Install cargo-udeps
-        run: cargo install cargo-udeps
+        run: cargo install cargo-udeps --force
 
       - name: Check Unused Dependencies in Test Cases
         run: find test-cases -name Cargo.toml -execdir cargo +nightly udeps --all-targets \;

From af5b3d688f89f9bdbeaa5792f43e937beae3b09b Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 10:40:20 -0300
Subject: [PATCH 19/93] Cache rustup

---
 .github/workflows/general-rust.yml | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index d661d28c..3e3ad7e9 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -29,6 +29,7 @@ jobs:
         with:
           path: |
             ~/.cargo
+            ~/.rustup
             test-cases/**/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
@@ -57,11 +58,15 @@ jobs:
         with:
           path: |
             ~/.cargo
+            ~/.rustup
             test-cases/**/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
             ${{ runner.os }}-cargo-
 
+      - name: Use Rust nightly
+        run: rustup default nightly
+
       - name: Install rustfmt
         run: rustup component add rustfmt --toolchain nightly
 
@@ -86,6 +91,7 @@ jobs:
         with:
           path: |
             ~/.cargo
+            ~/.rustup
             test-cases/**/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
@@ -115,6 +121,7 @@ jobs:
         with:
           path: |
             ~/.cargo
+            ~/.rustup
             test-cases/**/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |

From 38766db9ef5aa74fd6e18578bf5f9822104c1888 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 10:49:06 -0300
Subject: [PATCH 20/93] Update general rust

---
 .github/workflows/general-rust.yml | 68 +++++++++---------------------
 1 file changed, 20 insertions(+), 48 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 3e3ad7e9..88474296 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -16,57 +16,19 @@ env:
   CARGO_TERM_COLOR: always
 
 jobs:
-  setup:
-    name: Setup
+  format:
+    name: Check Rust Format
     runs-on: ubuntu-latest
-
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
 
-      - name: Cache Rust Tools and Targets
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo
-            ~/.rustup
-            test-cases/**/target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-
-
       - name: Update Rust Toolchain
         run: rustup update
 
       - name: Install Rust nightly
         run: rustup install nightly --profile minimal
 
-      - name: Install dylint-link
-        run: cargo install dylint-link --force
-
-  format:
-    name: Check Rust Format
-    runs-on: ubuntu-latest
-    needs: setup
-
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-
-      - name: Cache Rust Dependencies
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo
-            ~/.rustup
-            test-cases/**/target
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-
-
-      - name: Use Rust nightly
-        run: rustup default nightly
-
       - name: Install rustfmt
         run: rustup component add rustfmt --toolchain nightly
 
@@ -80,8 +42,6 @@ jobs:
   clippy:
     name: Lint with Clippy
     runs-on: ubuntu-latest
-    needs: setup
-
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
@@ -94,8 +54,15 @@ jobs:
             ~/.rustup
             test-cases/**/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-
+
+      - name: Update Rust Toolchain
+        run: rustup update
+
+      - name: Install Rust nightly
+        run: rustup install nightly --profile minimal
+
+      - name: Install dylint-link
+        run: cargo install dylint-link --force
 
       - name: Install clippy
         run: rustup component add clippy --toolchain nightly
@@ -110,8 +77,6 @@ jobs:
   udeps:
     name: Check Unused Dependencies
     runs-on: ubuntu-latest
-    needs: setup
-
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
@@ -124,8 +89,15 @@ jobs:
             ~/.rustup
             test-cases/**/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-
+
+      - name: Update Rust Toolchain
+        run: rustup update
+
+      - name: Install Rust nightly
+        run: rustup install nightly --profile minimal
+
+      - name: Install dylint-link
+        run: cargo install dylint-link --force
 
       - name: Install cargo-udeps
         run: cargo install cargo-udeps --force

From 72fb62e961630617f6710b71dededa0cfd8e9563 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 11:34:21 -0300
Subject: [PATCH 21/93] Cache all targets

---
 .github/workflows/general-rust.yml   | 6 +++---
 .github/workflows/test-detectors.yml | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 88474296..b26a11f4 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -52,7 +52,7 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-            test-cases/**/target
+            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
@@ -87,7 +87,7 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-            test-cases/**/target
+            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
@@ -103,4 +103,4 @@ jobs:
         run: cargo install cargo-udeps --force
 
       - name: Check Unused Dependencies in Test Cases
-        run: find test-cases -name Cargo.toml -execdir cargo +nightly udeps --all-targets \;
+        run: find test-cases -name Cargo.toml -execdir bash -c 'cargo +nightly udeps --all-targets || exit 255' \;
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index df52aaf9..31324092 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -36,7 +36,7 @@ jobs:
         with:
           path: |
             ~/.cargo
-            target
+            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
             ${{ runner.os }}-cargo-
@@ -85,7 +85,7 @@ jobs:
         with:
           path: |
             ~/.cargo
-            target
+            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Run unit tests for a specific detector

From 1d30ebf0d5e485bb2cfa5d1937d61b55283743a0 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 12:22:36 -0300
Subject: [PATCH 22/93] Update udeps ci

---
 .github/workflows/general-rust.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index b26a11f4..4d35287c 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -103,4 +103,6 @@ jobs:
         run: cargo install cargo-udeps --force
 
       - name: Check Unused Dependencies in Test Cases
-        run: find test-cases -name Cargo.toml -execdir bash -c 'cargo +nightly udeps --all-targets || exit 255' \;
+        run: |
+          set -e
+          find test-cases -name Cargo.toml -execdir bash -c 'cargo +nightly udeps --all-targets' \;

From b53b2d08b1ee038b72965a36ea506da729d2d760 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 13:17:22 -0300
Subject: [PATCH 23/93] Add test-cases structure validation

---
 .github/workflows/test-detectors.yml          |  16 +++
 scripts/validate-detectors.py                 | 120 ++++++++++++++++++
 .../Cargo.toml                                |   0
 .../src/lib.rs                                |   0
 4 files changed, 136 insertions(+)
 create mode 100644 scripts/validate-detectors.py
 rename test-cases/soroban-version/soroban-version-1/{remediated-example.skip => remediated-example}/Cargo.toml (100%)
 rename test-cases/soroban-version/soroban-version-1/{remediated-example.skip => remediated-example}/src/lib.rs (100%)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 31324092..dfdfb217 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -19,8 +19,24 @@ env:
   RUST_BACKTRACE: full
 
 jobs:
+  validate-detectors:
+    name: Validate
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+
+      - name: Validate detectors
+        run: python scripts/validate-detectors.py
+
   build:
     name: Build
+    needs: validate-detectors
     strategy:
       matrix:
         os:
diff --git a/scripts/validate-detectors.py b/scripts/validate-detectors.py
new file mode 100644
index 00000000..df858353
--- /dev/null
+++ b/scripts/validate-detectors.py
@@ -0,0 +1,120 @@
+import os
+import sys
+import re
+from fuzzywuzzy import process
+
+
+def is_rust_project(dir_path):
+    """Check if a directory contains a Rust project with a Cargo.toml and src/lib.rs."""
+    errors = []
+    has_cargo_toml = os.path.isfile(os.path.join(dir_path, "Cargo.toml"))
+    has_lib_rs = os.path.isfile(os.path.join(dir_path, "src", "lib.rs"))
+
+    if not has_cargo_toml:
+        errors.append(f"Missing Cargo.toml in {dir_path}.")
+    if not has_lib_rs:
+        errors.append(f"Missing src/lib.rs in {dir_path}.")
+
+    return errors
+
+
+def check_for_extra_files(directory):
+    """Ensure there are no unexpected files in a given directory."""
+    errors = []
+    for item in os.listdir(directory):
+        item_path = os.path.join(directory, item)
+        if os.path.isfile(item_path):
+            errors.append(f"Unexpected file found: {item_path}")
+    return errors
+
+
+def validate_naming_convention(example, detector_name):
+    """Validate the naming convention of the example."""
+    if not re.match(f"{re.escape(detector_name)}-\\d+$", example):
+        return [
+            f"Naming issue for '{example}' in {detector_name}: Expected format is {detector_name}-[number]."
+        ]
+    return []
+
+
+def validate_example_structure(example_path, example_name):
+    """Ensure each example has the required subdirectories with detailed errors."""
+    errors = []
+    expected_subs = ["vulnerable-example", "remediated-example"]
+    actual_subs = [
+        d
+        for d in os.listdir(example_path)
+        if os.path.isdir(os.path.join(example_path, d))
+    ]
+
+    for expected_sub in expected_subs:
+        if expected_sub not in actual_subs:
+            error_msg = f"Directory '{expected_sub}' not found in {example_path}."
+            closest_match = process.extractOne(
+                expected_sub, actual_subs, score_cutoff=80
+            )
+            if closest_match:
+                error_msg += f" A similar directory exists: '{closest_match[0]}', please rename it to '{expected_sub}'."
+            errors.append(error_msg)
+        else:
+            sub_errors = is_rust_project(os.path.join(example_path, expected_sub))
+            for error in sub_errors:
+                errors.append(error)
+
+    return errors
+
+
+def validate_examples(detector_path, examples):
+    """Validate the structure and naming convention of examples."""
+    errors = []
+    detector_name = os.path.basename(detector_path)
+    example_suffixes = set()
+
+    for example in examples:
+        example_path = os.path.join(detector_path, example)
+        errors.extend(check_for_extra_files(example_path))
+        errors.extend(validate_naming_convention(example, detector_name))
+        suffix = example.split("-")[-1]
+        if suffix in example_suffixes:
+            errors.append(
+                f"Duplicate example number found in {detector_name}: {example}"
+            )
+        else:
+            example_suffixes.add(suffix)
+        errors.extend(validate_example_structure(example_path, example))
+
+    return errors
+
+
+def validate_detectors(base_path):
+    """Validate the structure of the test-cases directory."""
+    all_errors = []
+
+    for detector in os.listdir(base_path):
+        detector_path = os.path.join(base_path, detector)
+        if detector == "README.md" or not os.path.isdir(detector_path):
+            continue
+
+        all_errors.extend(check_for_extra_files(detector_path))
+        examples = [
+            e
+            for e in os.listdir(detector_path)
+            if os.path.isdir(os.path.join(detector_path, e))
+        ]
+        if not examples:
+            all_errors.append(f"No examples found in {detector}.")
+        else:
+            all_errors.extend(validate_examples(detector_path, examples))
+
+    if all_errors:
+        print("Validation errors found:")
+        for error in all_errors:
+            print(f"* {error}")
+        sys.exit(1)
+    else:
+        print("No validation errors found.")
+
+
+if __name__ == "__main__":
+    BASE_PATH = "test-cases"
+    validate_detectors(BASE_PATH)
diff --git a/test-cases/soroban-version/soroban-version-1/remediated-example.skip/Cargo.toml b/test-cases/soroban-version/soroban-version-1/remediated-example/Cargo.toml
similarity index 100%
rename from test-cases/soroban-version/soroban-version-1/remediated-example.skip/Cargo.toml
rename to test-cases/soroban-version/soroban-version-1/remediated-example/Cargo.toml
diff --git a/test-cases/soroban-version/soroban-version-1/remediated-example.skip/src/lib.rs b/test-cases/soroban-version/soroban-version-1/remediated-example/src/lib.rs
similarity index 100%
rename from test-cases/soroban-version/soroban-version-1/remediated-example.skip/src/lib.rs
rename to test-cases/soroban-version/soroban-version-1/remediated-example/src/lib.rs

From 34b88e56d4e4cc66a1a4091bb60328eaa92de84d Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 13:19:23 -0300
Subject: [PATCH 24/93] Add dependencies

---
 .github/workflows/test-detectors.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index dfdfb217..389546c5 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -31,6 +31,9 @@ jobs:
         with:
           python-version: "3.9"
 
+      - name: Install dependencies
+        run: pip install fuzzywuzzy
+
       - name: Validate detectors
         run: python scripts/validate-detectors.py
 

From fa329c479ad6f4e3201a6632c8cb11cb0508008e Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 13:48:56 -0300
Subject: [PATCH 25/93] Remove target caching due to memory constraints

---
 .github/workflows/general-rust.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 4d35287c..101f6548 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -52,7 +52,6 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
@@ -87,7 +86,6 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain

From f832fdfb9e0f4baa8f756d2ef939b7a8e32638c5 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 19:17:08 -0300
Subject: [PATCH 26/93] Update udeps CI

---
 .github/workflows/general-rust.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 101f6548..8c05eb61 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -103,4 +103,4 @@ jobs:
       - name: Check Unused Dependencies in Test Cases
         run: |
           set -e
-          find test-cases -name Cargo.toml -execdir bash -c 'cargo +nightly udeps --all-targets' \;
+          find test-cases -name Cargo.toml -execdir bash -c 'cargo update && cargo +nightly udeps --all-targets || exit 255' \;

From b7ba07406c3c36fb8d900c634ca16dd2137b0166 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 19:41:02 -0300
Subject: [PATCH 27/93] Try fix exit on find

---
 .github/workflows/general-rust.yml   | 10 ++++------
 .github/workflows/test-detectors.yml |  2 +-
 2 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 8c05eb61..a2f43512 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -36,8 +36,8 @@ jobs:
         working-directory: detectors
         run: cargo +nightly fmt -- --check -v
 
-      - name: Check Formatting in Test Cases
-        run: find test-cases -name Cargo.toml -execdir cargo +nightly fmt -- --check -v \;
+      - name: Format Code in Test Cases
+        run: find test-cases -name Cargo.toml -print0 | xargs -0 -I{} bash -c 'cd "$(dirname {})" && cargo +nightly fmt -- --check -v || exit 255'
 
   clippy:
     name: Lint with Clippy
@@ -71,7 +71,7 @@ jobs:
         run: cargo clippy --all-targets --all-features -- -D warnings
 
       - name: Lint Code in Test Cases
-        run: find test-cases -name Cargo.toml -execdir cargo clippy --all-targets --all-features -- -D warnings \;
+        run: find test-cases -name Cargo.toml -print0 | xargs -0 -I {} sh -c 'cd $(dirname {}) && cargo clippy --all-targets --all-features -- -D warnings || exit 255'
 
   udeps:
     name: Check Unused Dependencies
@@ -101,6 +101,4 @@ jobs:
         run: cargo install cargo-udeps --force
 
       - name: Check Unused Dependencies in Test Cases
-        run: |
-          set -e
-          find test-cases -name Cargo.toml -execdir bash -c 'cargo update && cargo +nightly udeps --all-targets || exit 255' \;
+        run: find test-cases -name Cargo.toml -print0 | xargs -0 -I{} bash -c 'cd "$(dirname {})" && cargo update && cargo +nightly udeps --all-targets || exit 255'
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 389546c5..cee490c2 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -111,4 +111,4 @@ jobs:
         working-directory: test-cases
         run: |
           cd ${{ matrix.detector }}
-          find . -name Cargo.toml -execdir cargo test \;
+          find . -name Cargo.toml -print0 | xargs -0 -I{} bash -c 'cd "$(dirname {})" && cargo test || exit 255'

From 622c1fa68c1f967ae085c4f3ee83a929028599f3 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 20:46:43 -0300
Subject: [PATCH 28/93] Use python for clippy and fmt

---
 .github/workflows/general-rust.yml | 26 ++++++++++----------
 scripts/run-clippy.py              | 38 ++++++++++++++++++++++++++++++
 scripts/run-fmt.py                 | 38 ++++++++++++++++++++++++++++++
 3 files changed, 90 insertions(+), 12 deletions(-)
 create mode 100644 scripts/run-clippy.py
 create mode 100644 scripts/run-fmt.py

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index a2f43512..7bbcd19d 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -23,6 +23,11 @@ jobs:
       - name: Checkout Code
         uses: actions/checkout@v4
 
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+
       - name: Update Rust Toolchain
         run: rustup update
 
@@ -32,12 +37,8 @@ jobs:
       - name: Install rustfmt
         run: rustup component add rustfmt --toolchain nightly
 
-      - name: Check Formatting in Detectors
-        working-directory: detectors
-        run: cargo +nightly fmt -- --check -v
-
-      - name: Format Code in Test Cases
-        run: find test-cases -name Cargo.toml -print0 | xargs -0 -I{} bash -c 'cd "$(dirname {})" && cargo +nightly fmt -- --check -v || exit 255'
+      - name: Check Format
+        run: python scripts/run-fmt.py
 
   clippy:
     name: Lint with Clippy
@@ -46,6 +47,11 @@ jobs:
       - name: Checkout Code
         uses: actions/checkout@v4
 
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+
       - name: Cache Rust Dependencies
         uses: actions/cache@v4
         with:
@@ -66,12 +72,8 @@ jobs:
       - name: Install clippy
         run: rustup component add clippy --toolchain nightly
 
-      - name: Lint Code in Detectors
-        working-directory: detectors
-        run: cargo clippy --all-targets --all-features -- -D warnings
-
-      - name: Lint Code in Test Cases
-        run: find test-cases -name Cargo.toml -print0 | xargs -0 -I {} sh -c 'cd $(dirname {}) && cargo clippy --all-targets --all-features -- -D warnings || exit 255'
+      - name: Lint with Clippy
+        run: python scripts/run-clippy.py
 
   udeps:
     name: Check Unused Dependencies
diff --git a/scripts/run-clippy.py b/scripts/run-clippy.py
new file mode 100644
index 00000000..10df80ca
--- /dev/null
+++ b/scripts/run-clippy.py
@@ -0,0 +1,38 @@
+import os
+import subprocess
+
+RED = '\033[91m'
+GREEN = '\033[92m'
+ENDC = '\033[0m'
+
+def run_clippy(directories):
+    errors = []
+    for directory in directories:
+        print(f"/n{GREEN}Running clippy in {directory}:{ENDC}")
+        for root, _, files in os.walk(directory):
+            if 'Cargo.toml' in files:
+                print(f"Running clippy in: {root}")
+                result = subprocess.run(['cargo', 'clippy', '--all-targets', '--all-features', '--', '-D', 'warnings'], cwd=root, capture_output=True, text=True)
+                if result.returncode != 0:
+                    print(f"\n{RED}Clippy issues found in: {root}{ENDC}\n")
+                    error_message = result.stderr.strip()
+                    for line in error_message.split('\n'):
+                        print(f"| {RED}{line}{ENDC}")
+                    print("\n")
+                    errors.append(root)
+    return errors
+
+def print_clippy_errors(errors):
+    if errors:
+        print(f"{RED}\nClippy errors detected in the following directories:{ENDC}")
+        for error_dir in errors:
+            print(f"• {error_dir}")
+    else:
+        print(f"{GREEN}\nNo clippy issues found across all directories.{ENDC}")
+
+if __name__ == "__main__":
+    directories = ['test-cases', 'detectors']
+    errors = run_clippy(directories)
+    print_clippy_errors(errors)
+    if errors:
+        exit(1)
diff --git a/scripts/run-fmt.py b/scripts/run-fmt.py
new file mode 100644
index 00000000..e4fbe0af
--- /dev/null
+++ b/scripts/run-fmt.py
@@ -0,0 +1,38 @@
+import os
+import subprocess
+
+RED = '\033[91m'
+GREEN = '\033[92m'
+ENDC = '\033[0m'
+
+def run_fmt(directories):
+    errors = []
+    for directory in directories:
+        print(f"\n{GREEN}Checking format in {directory}:{ENDC}")
+        for root, _, files in os.walk(directory):
+            if 'Cargo.toml' in files:
+                print(f"Checking format in: {root}")
+                result = subprocess.run(['cargo', '+nightly', 'fmt', '--', '--check', '-v'], cwd=root, capture_output=True, text=True)
+                if result.returncode != 0:
+                    print(f"\n{RED}Formatting issues found in: {root}{ENDC}\n")
+                    error_message = result.stdout.strip()
+                    for line in error_message.split('\n'):
+                        print(f"| {line}")
+                    print("\n")
+                    errors.append(root)
+    return errors
+
+def print_fmt_errors(errors):
+    if errors:
+        print(f"{RED}\nFormatting errors detected in the following directories:{ENDC}")
+        for error_dir in errors:
+            print(f"• {error_dir}")
+    else:
+        print(f"{GREEN}\nNo formatting issues found across all directories.{ENDC}")
+
+if __name__ == "__main__":
+    directories = ['test-cases', 'detectors']
+    errors = run_fmt(directories)
+    print_fmt_errors(errors)
+    if errors:
+        exit(1)

From cde130bc26b276dee4b6da2bbb0e51aeaa2c502e Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 26 Mar 2024 20:52:26 -0300
Subject: [PATCH 29/93] Unbuffer python output

---
 .github/workflows/general-rust.yml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 7bbcd19d..fafee21d 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -14,6 +14,7 @@ on:
 
 env:
   CARGO_TERM_COLOR: always
+  PYTHONUNBUFFERED: 1
 
 jobs:
   format:

From c3afb9b9d3d8bab948f53c46ca323b8b11ae9930 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 09:54:06 -0300
Subject: [PATCH 30/93] Edit udeps ci

---
 .github/workflows/general-rust.yml | 14 ++++++-----
 scripts/run-clippy.py              |  4 ++--
 scripts/run-udeps.py               | 38 ++++++++++++++++++++++++++++++
 3 files changed, 48 insertions(+), 8 deletions(-)
 create mode 100644 scripts/run-udeps.py

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index fafee21d..7dfcec14 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -83,6 +83,11 @@ jobs:
       - name: Checkout Code
         uses: actions/checkout@v4
 
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+
       - name: Cache Rust Dependencies
         uses: actions/cache@v4
         with:
@@ -98,10 +103,7 @@ jobs:
         run: rustup install nightly --profile minimal
 
       - name: Install dylint-link
-        run: cargo install dylint-link --force
-
-      - name: Install cargo-udeps
-        run: cargo install cargo-udeps --force
+        run: cargo install dylint-link cargo-udeps --force
 
-      - name: Check Unused Dependencies in Test Cases
-        run: find test-cases -name Cargo.toml -print0 | xargs -0 -I{} bash -c 'cd "$(dirname {})" && cargo update && cargo +nightly udeps --all-targets || exit 255'
+      - name: Find unused dependencies
+        run: python scripts/run-udeps.py
diff --git a/scripts/run-clippy.py b/scripts/run-clippy.py
index 10df80ca..8b4b5ce3 100644
--- a/scripts/run-clippy.py
+++ b/scripts/run-clippy.py
@@ -8,7 +8,7 @@
 def run_clippy(directories):
     errors = []
     for directory in directories:
-        print(f"/n{GREEN}Running clippy in {directory}:{ENDC}")
+        print(f"\n{GREEN}Running clippy in {directory}:{ENDC}")
         for root, _, files in os.walk(directory):
             if 'Cargo.toml' in files:
                 print(f"Running clippy in: {root}")
@@ -17,7 +17,7 @@ def run_clippy(directories):
                     print(f"\n{RED}Clippy issues found in: {root}{ENDC}\n")
                     error_message = result.stderr.strip()
                     for line in error_message.split('\n'):
-                        print(f"| {RED}{line}{ENDC}")
+                        print(f"| {line}")
                     print("\n")
                     errors.append(root)
     return errors
diff --git a/scripts/run-udeps.py b/scripts/run-udeps.py
new file mode 100644
index 00000000..651f2bd8
--- /dev/null
+++ b/scripts/run-udeps.py
@@ -0,0 +1,38 @@
+import os
+import subprocess
+
+RED = '\033[91m'
+GREEN = '\033[92m'
+ENDC = '\033[0m'
+
+def run_udeps(directories):
+    errors = []
+    for directory in directories:
+        print(f"\n{GREEN}Checking unused dependencies in {directory}:{ENDC}")
+        for root, _, files in os.walk(directory):
+            if 'Cargo.toml' in files:
+                print(f"Checking unused dependencies in: {root}")
+                result = subprocess.run(['cargo', '+nightly', 'udeps', '--no-default-features'], cwd=root, capture_output=True, text=True)
+                if result.returncode != 0:
+                    print(f"\n{RED}Unused dependencies found in: {root}{ENDC}\n")
+                    error_message = result.stdout.strip()
+                    for line in error_message.split('\n'):
+                        print(f"| {line}")
+                    print("\n")
+                    errors.append(root)
+    return errors
+
+def print_udeps_errors(errors):
+    if errors:
+        print(f"{RED}\nUnused dependencies detected in the following directories:{ENDC}")
+        for error_dir in errors:
+            print(f"• {error_dir}")
+    else:
+        print(f"{GREEN}\nNo unused dependencies found across all directories.{ENDC}")
+
+if __name__ == "__main__":
+    directories = ['test-cases', 'detectors']
+    errors = run_udeps(directories)
+    print_udeps_errors(errors)
+    if errors:
+        exit(1)

From e82e50d66c65a49816c60ba9127b7021620c05c0 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 10:10:45 -0300
Subject: [PATCH 31/93] Test fix udeps ci

---
 scripts/run-udeps.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/scripts/run-udeps.py b/scripts/run-udeps.py
index 651f2bd8..9e045236 100644
--- a/scripts/run-udeps.py
+++ b/scripts/run-udeps.py
@@ -12,10 +12,11 @@ def run_udeps(directories):
         for root, _, files in os.walk(directory):
             if 'Cargo.toml' in files:
                 print(f"Checking unused dependencies in: {root}")
-                result = subprocess.run(['cargo', '+nightly', 'udeps', '--no-default-features'], cwd=root, capture_output=True, text=True)
+                subprocess.run(['cargo', 'update'], cwd=root)
+                result = subprocess.run(['cargo', '+nightly', 'udeps', '--no-default-features', '--frozen', '--backend=save-analysis'], cwd=root, capture_output=True, text=True)
                 if result.returncode != 0:
                     print(f"\n{RED}Unused dependencies found in: {root}{ENDC}\n")
-                    error_message = result.stdout.strip()
+                    error_message = result.stderr.strip()
                     for line in error_message.split('\n'):
                         print(f"| {line}")
                     print("\n")

From b1131336c559321eaa2d3a6661c2da1b966d943c Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 10:57:02 -0300
Subject: [PATCH 32/93] frozen -> locked on udeps ci

---
 scripts/run-udeps.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/run-udeps.py b/scripts/run-udeps.py
index 9e045236..2c4d7c16 100644
--- a/scripts/run-udeps.py
+++ b/scripts/run-udeps.py
@@ -13,7 +13,7 @@ def run_udeps(directories):
             if 'Cargo.toml' in files:
                 print(f"Checking unused dependencies in: {root}")
                 subprocess.run(['cargo', 'update'], cwd=root)
-                result = subprocess.run(['cargo', '+nightly', 'udeps', '--no-default-features', '--frozen', '--backend=save-analysis'], cwd=root, capture_output=True, text=True)
+                result = subprocess.run(['cargo', '+nightly', 'udeps', '--no-default-features', '--locked', '--backend=save-analysis'], cwd=root, capture_output=True, text=True)
                 if result.returncode != 0:
                     print(f"\n{RED}Unused dependencies found in: {root}{ENDC}\n")
                     error_message = result.stderr.strip()

From f7fb77b4cc54273cfe8a9cd73e5cd3c83fb52ee1 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 11:33:54 -0300
Subject: [PATCH 33/93] Test udeps with macos

---
 .github/workflows/general-rust.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 7dfcec14..fb79a052 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -78,7 +78,7 @@ jobs:
 
   udeps:
     name: Check Unused Dependencies
-    runs-on: ubuntu-latest
+    runs-on: macos-latest
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4

From 875f754d1c00424881126e64a388690c0b172304 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 12:55:40 -0300
Subject: [PATCH 34/93] Remove udeps step, try fix clippy warnings, add python
 for tests ci

---
 .github/workflows/general-rust.yml            | 32 ---------
 .github/workflows/test-detectors.yml          | 10 +--
 scripts/run-clippy.py                         | 39 ++++++++---
 scripts/run-fmt.py                            | 32 ++++++---
 scripts/run-tests.py                          | 70 +++++++++++++++++++
 .../vulnerable-example/src/lib.rs             |  6 ++
 .../remediated-example/src/lib.rs             |  2 +-
 7 files changed, 138 insertions(+), 53 deletions(-)
 create mode 100644 scripts/run-tests.py

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index fb79a052..df09d26f 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -75,35 +75,3 @@ jobs:
 
       - name: Lint with Clippy
         run: python scripts/run-clippy.py
-
-  udeps:
-    name: Check Unused Dependencies
-    runs-on: macos-latest
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.9"
-
-      - name: Cache Rust Dependencies
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo
-            ~/.rustup
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Update Rust Toolchain
-        run: rustup update
-
-      - name: Install Rust nightly
-        run: rustup install nightly --profile minimal
-
-      - name: Install dylint-link
-        run: cargo install dylint-link cargo-udeps --force
-
-      - name: Find unused dependencies
-        run: python scripts/run-udeps.py
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index cee490c2..4022d46d 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -99,6 +99,11 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+
       - name: Cache cargo dependencies
         uses: actions/cache@v4
         with:
@@ -108,7 +113,4 @@ jobs:
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Run unit tests for a specific detector
-        working-directory: test-cases
-        run: |
-          cd ${{ matrix.detector }}
-          find . -name Cargo.toml -print0 | xargs -0 -I{} bash -c 'cd "$(dirname {})" && cargo test || exit 255'
+        run: python scripts/run-tests.py --detector=${{ matrix.detector }}
diff --git a/scripts/run-clippy.py b/scripts/run-clippy.py
index 8b4b5ce3..02d8b909 100644
--- a/scripts/run-clippy.py
+++ b/scripts/run-clippy.py
@@ -1,27 +1,49 @@
 import os
 import subprocess
+import time
+
+RED = "\033[91m"
+GREEN = "\033[92m"
+BLUE = "\033[94m"
+ENDC = "\033[0m"
 
-RED = '\033[91m'
-GREEN = '\033[92m'
-ENDC = '\033[0m'
 
 def run_clippy(directories):
     errors = []
     for directory in directories:
         print(f"\n{GREEN}Running clippy in {directory}:{ENDC}")
         for root, _, files in os.walk(directory):
-            if 'Cargo.toml' in files:
-                print(f"Running clippy in: {root}")
-                result = subprocess.run(['cargo', 'clippy', '--all-targets', '--all-features', '--', '-D', 'warnings'], cwd=root, capture_output=True, text=True)
+            if "Cargo.toml" in files:
+                start_time = time.time()
+                result = subprocess.run(
+                    [
+                        "cargo",
+                        "clippy",
+                        "--all-targets",
+                        "--all-features",
+                        "--",
+                        "-D",
+                        "warnings",
+                    ],
+                    cwd=root,
+                    capture_output=True,
+                    text=True,
+                )
+                end_time = time.time()
+                elapsed_time = end_time - start_time
+                print(
+                    f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed clippy check in: {root}."
+                )
                 if result.returncode != 0:
                     print(f"\n{RED}Clippy issues found in: {root}{ENDC}\n")
                     error_message = result.stderr.strip()
-                    for line in error_message.split('\n'):
+                    for line in error_message.split("\n"):
                         print(f"| {line}")
                     print("\n")
                     errors.append(root)
     return errors
 
+
 def print_clippy_errors(errors):
     if errors:
         print(f"{RED}\nClippy errors detected in the following directories:{ENDC}")
@@ -30,8 +52,9 @@ def print_clippy_errors(errors):
     else:
         print(f"{GREEN}\nNo clippy issues found across all directories.{ENDC}")
 
+
 if __name__ == "__main__":
-    directories = ['test-cases', 'detectors']
+    directories = ["test-cases", "detectors"]
     errors = run_clippy(directories)
     print_clippy_errors(errors)
     if errors:
diff --git a/scripts/run-fmt.py b/scripts/run-fmt.py
index e4fbe0af..043106b1 100644
--- a/scripts/run-fmt.py
+++ b/scripts/run-fmt.py
@@ -1,27 +1,42 @@
 import os
 import subprocess
+import time
+from datetime import datetime
+
+RED = "\033[91m"
+GREEN = "\033[92m"
+BLUE = "\033[94m"
+ENDC = "\033[0m"
 
-RED = '\033[91m'
-GREEN = '\033[92m'
-ENDC = '\033[0m'
 
 def run_fmt(directories):
     errors = []
     for directory in directories:
         print(f"\n{GREEN}Checking format in {directory}:{ENDC}")
         for root, _, files in os.walk(directory):
-            if 'Cargo.toml' in files:
-                print(f"Checking format in: {root}")
-                result = subprocess.run(['cargo', '+nightly', 'fmt', '--', '--check', '-v'], cwd=root, capture_output=True, text=True)
+            if "Cargo.toml" in files:
+                start_time = time.time()
+                result = subprocess.run(
+                    ["cargo", "+nightly", "fmt", "--", "--check", "-v"],
+                    cwd=root,
+                    capture_output=True,
+                    text=True,
+                )
+                end_time = time.time()
+                elapsed_time = end_time - start_time
+                print(
+                    f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed format check in: {root}."
+                )
                 if result.returncode != 0:
                     print(f"\n{RED}Formatting issues found in: {root}{ENDC}\n")
                     error_message = result.stdout.strip()
-                    for line in error_message.split('\n'):
+                    for line in error_message.split("\n"):
                         print(f"| {line}")
                     print("\n")
                     errors.append(root)
     return errors
 
+
 def print_fmt_errors(errors):
     if errors:
         print(f"{RED}\nFormatting errors detected in the following directories:{ENDC}")
@@ -30,8 +45,9 @@ def print_fmt_errors(errors):
     else:
         print(f"{GREEN}\nNo formatting issues found across all directories.{ENDC}")
 
+
 if __name__ == "__main__":
-    directories = ['test-cases', 'detectors']
+    directories = ["test-cases", "detectors"]
     errors = run_fmt(directories)
     print_fmt_errors(errors)
     if errors:
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
new file mode 100644
index 00000000..774db322
--- /dev/null
+++ b/scripts/run-tests.py
@@ -0,0 +1,70 @@
+import os
+import subprocess
+import argparse
+import time
+
+RED = "\033[91m"
+GREEN = "\033[92m"
+BLUE = "\033[94m"
+ENDC = "\033[0m"
+
+
+def run_tests(detector):
+    errors = []
+    directory = os.path.join("test-cases", detector)
+    print(f"\n{GREEN}Performing tests in {directory}:{ENDC}")
+    if os.path.exists(directory):
+        for root, _, files in os.walk(directory):
+            if "Cargo.toml" in files:
+                start_time = time.time()
+                result = subprocess.run(
+                    ["cargo", "test", "--all-features", "--all"],
+                    cwd=root,
+                    capture_output=True,
+                    text=True,
+                )
+                end_time = time.time()
+                elapsed_time = end_time - start_time
+                print(
+                    f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed test in: {root}."
+                )
+                if result.returncode != 0:
+                    print(f"\n{RED}Test error found in: {root}{ENDC}\n")
+                    error_message = result.stdout.strip()
+                    for line in error_message.split("\n"):
+                        print(f"| {line}")
+                    print("\n")
+                    errors.append(root)
+    else:
+        print(
+            f"{RED}The specified detector directory does not exist: {directory}{ENDC}"
+        )
+    return errors
+
+
+def print_tests_errors(errors):
+    if errors:
+        print(f"{RED}\nErrors detected in the following directories:{ENDC}")
+        for error_dir in errors:
+            print(f"• {error_dir}")
+    else:
+        print(f"{GREEN}\nNo errors found in the specified directory.{ENDC}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Run tests for a specific detector.")
+    parser.add_argument(
+        "--detector",
+        type=str,
+        help='The detector to run tests for, e.g., "./unsafe-unwrap"',
+    )
+
+    args = parser.parse_args()
+
+    if args.detector:
+        errors = run_tests(args.detector.strip("./"))
+        print_tests_errors(errors)
+        if errors:
+            exit(1)
+    else:
+        print(f"{RED}No detector specified. Please provide a detector argument.{ENDC}")
diff --git a/test-cases/avoid-core-mem-forget/avoid-core-mem-forget-1/vulnerable-example/src/lib.rs b/test-cases/avoid-core-mem-forget/avoid-core-mem-forget-1/vulnerable-example/src/lib.rs
index 9f8aa0df..56c855ba 100644
--- a/test-cases/avoid-core-mem-forget/avoid-core-mem-forget-1/vulnerable-example/src/lib.rs
+++ b/test-cases/avoid-core-mem-forget/avoid-core-mem-forget-1/vulnerable-example/src/lib.rs
@@ -11,6 +11,12 @@ pub struct WithoutCopy {
     pub b: u64,
 }
 
+impl Drop for WithoutCopy {
+    fn drop(&mut self) {
+        // Prevent clippy warning
+    }
+}
+
 #[contractimpl]
 impl AvoidCoreMemForget {
     pub fn forget_something(n: WithoutCopy) -> u64 {
diff --git a/test-cases/divide-before-multiply/divide-before-multiply-3/remediated-example/src/lib.rs b/test-cases/divide-before-multiply/divide-before-multiply-3/remediated-example/src/lib.rs
index ef8b3125..b4115335 100644
--- a/test-cases/divide-before-multiply/divide-before-multiply-3/remediated-example/src/lib.rs
+++ b/test-cases/divide-before-multiply/divide-before-multiply-3/remediated-example/src/lib.rs
@@ -7,7 +7,7 @@ pub struct DivideBeforeMultiply;
 #[contractimpl]
 impl DivideBeforeMultiply {
     pub fn hybrid_split_profit(percentage: u64, total_profit: u64) -> Option<u64> {
-        Some((percentage * total_profit).checked_div(100)?)
+        (percentage * total_profit).checked_div(100)
     }
 }
 

From c858551b466820b803fb43781182bf166c84ba5b Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 13:31:25 -0300
Subject: [PATCH 35/93] Delete unused scripts, add make ci, unbuffer python in
 tests

---
 .github/workflows/test-detectors.yml          |  3 +-
 Makefile                                      | 38 ++++--------
 scripts/check-ci-detectors-to-test.py         | 26 --------
 scripts/check-detectors-names-match-folder.py | 49 ---------------
 scripts/check-detectors-repeated-names.py     | 59 ------------------
 scripts/check-detectors-underscore-names.py   | 47 ---------------
 scripts/list-cargo-directories.sh             |  9 ---
 scripts/new-test-case.py                      | 35 -----------
 scripts/publish-to-crates-io.py               | 60 -------------------
 scripts/run-cargo-clippy.sh                   | 22 -------
 scripts/run-cargo-fmt.sh                      | 37 ------------
 scripts/run-cargo-test.sh                     | 22 -------
 12 files changed, 14 insertions(+), 393 deletions(-)
 delete mode 100644 scripts/check-ci-detectors-to-test.py
 delete mode 100644 scripts/check-detectors-names-match-folder.py
 delete mode 100644 scripts/check-detectors-repeated-names.py
 delete mode 100644 scripts/check-detectors-underscore-names.py
 delete mode 100755 scripts/list-cargo-directories.sh
 delete mode 100644 scripts/new-test-case.py
 delete mode 100644 scripts/publish-to-crates-io.py
 delete mode 100755 scripts/run-cargo-clippy.sh
 delete mode 100755 scripts/run-cargo-fmt.sh
 delete mode 100755 scripts/run-cargo-test.sh

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 4022d46d..c7a905a4 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -7,16 +7,15 @@ on:
     paths:
       - "detectors/**"
       - "test-cases/**"
-      - "Makefile"
   pull_request:
     paths:
       - "detectors/**"
       - "test-cases/**"
-      - "Makefile"
 
 env:
   CARGO_TERM_COLOR: always
   RUST_BACKTRACE: full
+  PYTHONUNBUFFERED: 1
 
 jobs:
   validate-detectors:
diff --git a/Makefile b/Makefile
index ef1eec12..a838e462 100644
--- a/Makefile
+++ b/Makefile
@@ -1,31 +1,19 @@
-ci: fmt lint test
-ci-check: fmt-check lint test
-
-fmt: fmt-rust
-fmt-check: fmt-rust-check
-lint: lint-cargo-scout-audit lint-detectors lint-scout-audit-internal
+ci: fmt-rust lint test
+ci-no-test: fmt-rust lint
 
 fmt-rust:
 	@echo "Formatting Rust code..."
-	@./scripts/list-cargo-directories.sh | ./scripts/run-cargo-fmt.sh
-
-fmt-rust-check:
-	@echo "Checking Rust code formatting..."
-	@./scripts/list-cargo-directories.sh | ./scripts/run-cargo-fmt.sh --check
-
-lint-cargo-scout-audit:
-	@echo "Linting cargo-scout-audit..."
-	@cd apps/cargo-scout-audit && cargo clippy --all --all-features --quiet -- -D warnings
-
-lint-detectors:
-	@echo "Linting detectors..."
-	@cd detectors && ../scripts/list-cargo-directories.sh | ../scripts/run-cargo-clippy.sh
+	@python3 scripts/run-fmt.py
 
-lint-scout-audit-internal:
-	@echo "Linting scout-audit-internal..."
-	@cd scout-audit-internal && cargo clippy --all --all-features --quiet -- -D warnings
+lint:
+	@echo "Linting detectors and test-cases..."
+	@python3 scripts/run-clippy.py
 
 test:
-	@echo "Running tests..."
-	@cd apps/cargo-scout-audit && cargo test --all --all-features -- --nocapture
-	@cd test-cases && ../scripts/list-cargo-directories.sh | ../scripts/run-cargo-test.sh
+	@echo "Generating test matrix and running tests..."
+	@for detector in test-cases/*; do \
+		if [ -d "$$detector" ]; then \
+			detector_name=$$(basename $$detector); \
+			python3 scripts/run-tests.py --detector=$$detector_name; \
+		fi \
+	done
diff --git a/scripts/check-ci-detectors-to-test.py b/scripts/check-ci-detectors-to-test.py
deleted file mode 100644
index b1d4ad59..00000000
--- a/scripts/check-ci-detectors-to-test.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import argparse
-import os
-import yaml
-
-def is_special_directory(directory):
-    return directory == ".cargo" or directory == ".git" or directory == "target"
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Check if all detectors were tested by the CI")
-    parser.add_argument("gh_workflow_path", type=str, help="Path to the github workflow.")
-    parser.add_argument("detectors_path", type=str, help="Path to detectors folder")
-    args = parser.parse_args()
-
-    with open(args.gh_workflow_path, "r") as f:
-        workflow = yaml.safe_load(f)
-        detectors_to_test = set(workflow["jobs"]["test"]["strategy"]["matrix"]["test"])
-
-        detectors = set(f.name for f in os.scandir(args.detectors_path) if f.is_dir() and not is_special_directory(f.name))
-        # detectors.sort()
-
-        sym_diff = detectors ^ detectors_to_test
-        if len(sym_diff)!=0 and sym_diff!=set(['soroban-version']):
-            print("Detectors to test in the workflow are not the same as the detectors in the detectors folder.")
-            print("Detectors to test: ", detectors_to_test)
-            print("Detectors in the folder: ", detectors)
-            exit(1)
diff --git a/scripts/check-detectors-names-match-folder.py b/scripts/check-detectors-names-match-folder.py
deleted file mode 100644
index 0a4be5cb..00000000
--- a/scripts/check-detectors-names-match-folder.py
+++ /dev/null
@@ -1,49 +0,0 @@
-import argparse
-import os
-from pathlib import Path
-
-def get_recursive_package_names(root_path):
-    results = []
-
-    # Walk through the directory structure
-    for dirpath, dirnames, filenames in os.walk(root_path):
-        if "Cargo.toml" in filenames:
-            file_path = os.path.join(dirpath, "Cargo.toml")
-            with open(file_path, "r") as f:
-                lines = f.readlines()
-                found_package_name = False
-                for line in lines:
-                    if line.strip() == "[workspace]":
-                        found_package_name = True
-                        break
-                    if "name =" in line:
-                        package_name = line.split("=")[1].strip().replace('"', "")
-                        results.append((file_path, package_name))
-                        found_package_name = True
-                        break
-                if not found_package_name:
-                    raise Exception(f"Failed to parse package name from {file_path}")
-    return results
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Check if any detectors names don't match their folder"
-    )
-    parser.add_argument("detectors_path", type=str, help="Path to detectors folder")
-    args = parser.parse_args()
-
-    results = get_recursive_package_names(args.detectors_path)
-    sorted_results = sorted(results, key=lambda x: x[1])
-
-    # Check if they match the name of the folder
-    failed_results = []
-    for r in sorted_results:
-        folder_name = Path(r[0]).parent.name
-        if folder_name != r[1]:
-            failed_results.append(r)
-
-    if len(failed_results) > 0:
-        print("Found detectors with different package names than their folder:")
-        for fr in failed_results:
-            print(f"\t{fr[0]} - {fr[1]}")
-        exit(1)
diff --git a/scripts/check-detectors-repeated-names.py b/scripts/check-detectors-repeated-names.py
deleted file mode 100644
index b8aa5282..00000000
--- a/scripts/check-detectors-repeated-names.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import argparse
-import os
-
-
-def get_recursive_package_names(root_path):
-    results = []
-
-    # Walk through the directory structure
-    for dirpath, dirnames, filenames in os.walk(root_path):
-        if "Cargo.toml" in filenames:
-            file_path = os.path.join(dirpath, "Cargo.toml")
-            with open(file_path, "r") as f:
-                lines = f.readlines()
-                found_package_name = False
-                for line in lines:
-                    if line.strip() == "[workspace]":
-                        found_package_name = True
-                        break
-                    if "name =" in line:
-                        package_name = line.split("=")[1].strip().replace('"', "")
-                        results.append((file_path, package_name))
-                        found_package_name = True
-                        break
-                if not found_package_name:
-                    raise Exception(f"Failed to parse package name from {file_path}")
-    return results
-
-
-def find_repeated(item_list):
-    seen = set()
-    dupes = [x for x in item_list if x in seen or seen.add(x)]
-    return list(set(dupes))
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Check if any detectors names are the same"
-    )
-    parser.add_argument("detectors_path", type=str, help="Path to detectors folder")
-    args = parser.parse_args()
-
-    results = get_recursive_package_names(args.detectors_path)
-
-    # Find repeated and print results
-    sorted_results = sorted(results, key=lambda x: x[1])
-    sorted_packages = [r[1] for r in sorted_results]
-    repeated_packages = find_repeated(sorted_packages)
-
-    repeated_results = []
-    for rp in repeated_packages:
-        matches = [x for x in sorted_results if x[1] == rp]
-        repeated_results.append(matches)
-
-    if len(repeated_results) > 0:
-        for rr in repeated_results:
-            print(f"Found detectors with the same name `{rr[0][1]}`:")
-            for r in rr:
-                print(f"\t{r[0]}")
-        exit(1)
diff --git a/scripts/check-detectors-underscore-names.py b/scripts/check-detectors-underscore-names.py
deleted file mode 100644
index 9e42044d..00000000
--- a/scripts/check-detectors-underscore-names.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import argparse
-import os
-
-
-def get_recursive_package_names(root_path):
-    results = []
-
-    # Walk through the directory structure
-    for dirpath, dirnames, filenames in os.walk(root_path):
-        if "Cargo.toml" in filenames:
-            file_path = os.path.join(dirpath, "Cargo.toml")
-            with open(file_path, "r") as f:
-                lines = f.readlines()
-                found_package_name = False
-                for line in lines:
-                    if line.strip() == "[workspace]":
-                        found_package_name = True
-                        break
-                    if "name =" in line:
-                        package_name = line.split("=")[1].strip().replace('"', "")
-                        results.append((file_path, package_name))
-                        found_package_name = True
-                        break
-                if not found_package_name:
-                    raise Exception(f"Failed to parse package name from {file_path}")
-    return results
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(
-        description="Check if any detectors names have underscores instead of hyphens"
-    )
-    parser.add_argument("detectors_path", type=str, help="Path to detectors folder")
-    args = parser.parse_args()
-
-    results = get_recursive_package_names(args.detectors_path)
-    sorted_results = sorted(results, key=lambda x: x[1])
-
-    # Check if they have underscores instead of hyphens
-    failed_results = []
-    for r in sorted_results:
-        if "_" in r[1]:
-            failed_results.append(r)
-    if len(failed_results) > 0:
-        print("Found detectors with underscores instead of hyphens:")
-        for fr in failed_results:
-            print(f"\t{fr[0]} - {fr[1]}")
-        exit(1)
diff --git a/scripts/list-cargo-directories.sh b/scripts/list-cargo-directories.sh
deleted file mode 100755
index f2703d20..00000000
--- a/scripts/list-cargo-directories.sh
+++ /dev/null
@@ -1,9 +0,0 @@
-#!/bin/bash
-
-# Find all directories with a Cargo.toml file
-directories=$(find . -name Cargo.toml -exec dirname {} \; | sort -u)
-
-# Print out the list of directories
-for directory in $directories; do
-  echo "$directory"
-done
diff --git a/scripts/new-test-case.py b/scripts/new-test-case.py
deleted file mode 100644
index c1155de3..00000000
--- a/scripts/new-test-case.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# receive a name
-# cd to test cases
-# if the directory with that name exists
-# go inside and create a new directory with
-# name-n with n being how many directories there already are +1
-# if the directory does not exist
-# create a new directory with that name
-# and inside create a directory with that name and -1
-
-import os
-import sys
-
-def main():
-    if len(sys.argv) != 2:
-        print("Usage: python3 new-test-case.py <test-case-name>")
-        return
-
-    test_case_name = sys.argv[1]
-    test_case_path = os.path.join(os.getcwd(), "test-cases")
-    test_case_dir = os.path.join(test_case_path, test_case_name)
-    test_case_dir_n = os.path.join(test_case_dir, test_case_name + "-1")
-
-    if os.path.exists(test_case_dir):
-        n = len(os.listdir(test_case_dir))
-        test_case_dir_n = os.path.join(test_case_dir, test_case_name + "-" + str(n + 1))
-        os.mkdir(test_case_dir_n)
-    else:
-        os.mkdir(test_case_dir)
-        os.mkdir(test_case_dir_n)
-
-    os.mkdir(os.path.join(test_case_dir_n, "remediated-example"))
-    os.mkdir(os.path.join(test_case_dir_n, "vulnerable-example"))
-
-if __name__ == "__main__":
-    main()
diff --git a/scripts/publish-to-crates-io.py b/scripts/publish-to-crates-io.py
deleted file mode 100644
index dfbf187d..00000000
--- a/scripts/publish-to-crates-io.py
+++ /dev/null
@@ -1,60 +0,0 @@
-from pathlib import Path
-import shutil
-import subprocess
-import tempfile
-import time
-
-def get_package_name(file_path):
-    with open(file_path, "r") as f:
-        for line in f:
-            if line.startswith("name"):
-                return line.split("=")[1].strip().strip('"')
-    raise Exception("Could not find package name in Cargo.toml")
-
-def get_package_version(file_path):
-    with open(file_path, "r") as f:
-        for line in f:
-            if line.startswith("version"):
-                return line.split("=")[1].strip().strip('"')
-    raise Exception("Could not find package version in Cargo.toml")
-
-def is_package_published(package_name, package_version, package_path):
-    with tempfile.TemporaryDirectory() as tmpdirname:
-        subprocess.call(["cargo", "init"], cwd=tmpdirname)
-        if (package_path / "rust-toolchain").exists():
-            shutil.copy(package_path / "rust-toolchain", Path(tmpdirname) / "rust-toolchain")
-        with open(Path(tmpdirname) / "Cargo.toml", "a") as f:
-            f.write(f'{package_name} = "={package_version}"')
-        print(f"Checking if {package_name} {package_version} is published...")
-        try:
-            subprocess.check_output(["cargo", "check"], cwd=tmpdirname)
-            return True
-        except subprocess.CalledProcessError:
-            return False
-        except:
-            raise
-
-def publish_package(package_path):
-    subprocess.check_output(["cargo", "publish"], cwd=package_path)
-
-if __name__ == "__main__":
-    ROOT_PATH = Path(__file__).parent.parent
-    CARGO_SCOUT_AUDIT_PATH = ROOT_PATH / "apps" / "cargo-scout-audit"
-    SCOUT_AUDIT_CLIPPY_UTILS = ROOT_PATH / "scout-audit-clippy-utils"
-    SCOUT_AUDIT_INTERNAL_PATH = ROOT_PATH / "scout-audit-internal"
-
-    packages_paths = [SCOUT_AUDIT_CLIPPY_UTILS, SCOUT_AUDIT_INTERNAL_PATH, CARGO_SCOUT_AUDIT_PATH]
-
-    for path in packages_paths:
-        package_name = get_package_name(path / "Cargo.toml")
-        package_version = get_package_version(path / "Cargo.toml")
-        print(f"Publishing {package_name} {package_version}...")
-
-        if not is_package_published(package_name, package_version, path):
-            publish_package(path)
-            while not is_package_published(package_name, package_version, path):
-                print(f"{package_name} {package_version} is not published yet, waiting 10 seconds...")
-                time.sleep(10)
-            print(f"{package_name} {package_version} is published")
-        else:
-            print(f"{package_name} {package_version} is already published")
diff --git a/scripts/run-cargo-clippy.sh b/scripts/run-cargo-clippy.sh
deleted file mode 100755
index 0efacf2d..00000000
--- a/scripts/run-cargo-clippy.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-
-# Read the list of directories from stdin
-directories=$(cat)
-
-# Create a list of directories to push into if any fail
-failed_directories=""
-
-# Run cargo clippy on each directory
-for directory in $directories; do
-    echo "Running cargo clippy on $directory"
-    (cd "$directory" && cargo clippy --all --all-features --quiet -- -D warnings)
-    if [ $? -ne 0 ]; then
-        failed_directories="$failed_directories\n$directory"
-    fi
-done
-
-# If any directories failed, print them out and exit with an error
-if [ -n "$failed_directories" ]; then
-    printf "\nThe following directories failed cargo clippy:$failed_directories\n"
-    exit 1
-fi
diff --git a/scripts/run-cargo-fmt.sh b/scripts/run-cargo-fmt.sh
deleted file mode 100755
index d97a9ce6..00000000
--- a/scripts/run-cargo-fmt.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/bin/bash
-
-# Parse command line arguments
-check=0
-while [[ "$#" -gt 0 ]]; do
-    case $1 in
-        --check) check=1 ;;
-        *) echo "Unknown parameter passed: $1"; exit 1 ;;
-    esac
-    shift
-done
-
-# Read the list of directories from stdin
-directories=$(cat)
-
-# Create a list of directories to push into if any fail
-failed_directories=""
-
-# Run cargo fmt on each directory
-for directory in $directories; do
-    echo "Running cargo fmt on $directory"
-    if [[ $check -eq 1 ]]; then
-        (cd "$directory" && cargo +nightly fmt --check)
-    else
-        (cd "$directory" && cargo +nightly fmt)
-    fi
-
-    if [ $? -ne 0 ]; then
-        failed_directories="$failed_directories\n$directory"
-    fi
-done
-
-# If any directories failed, print them out and exit with an error
-if [ -n "$failed_directories" ]; then
-    printf "\nThe following directories failed cargo fmt:$failed_directories\n"
-    exit 1
-fi
diff --git a/scripts/run-cargo-test.sh b/scripts/run-cargo-test.sh
deleted file mode 100755
index 42efcb5b..00000000
--- a/scripts/run-cargo-test.sh
+++ /dev/null
@@ -1,22 +0,0 @@
-#!/bin/bash
-
-# Read the list of directories from stdin
-directories=$(cat)
-
-# Create a list of directories to push into if any fail
-failed_directories=""
-
-# Run cargo fmt on each directory
-for directory in $directories; do
-    echo "Running cargo test on $directory"
-    (cd "$directory" && cargo test --all --all-features --quiet)
-    if [ $? -ne 0 ]; then
-        failed_directories="$failed_directories\n$directory"
-    fi
-done
-
-# If any directories failed, print them out and exit with an error
-if [ -n "$failed_directories" ]; then
-    printf "\nThe following directories failed cargo test:$failed_directories\n"
-    exit 1
-fi

From 10766bf40f939c76630dfcbe5e13b8f30ac6f061 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 13:42:06 -0300
Subject: [PATCH 36/93] Try to test on windows-latest

---
 .github/workflows/test-detectors.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index c7a905a4..ebad4f30 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -44,6 +44,7 @@ jobs:
         os:
           - ubuntu-latest
           - macos-latest
+          - windows-latest
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
@@ -92,6 +93,7 @@ jobs:
         os:
           - ubuntu-latest
           - macos-latest
+          - windows-latest
         detector: ${{fromJson(needs.prepare-detector-matrix.outputs.matrix)}}
     runs-on: ${{ matrix.os }}
     steps:

From 6643a547360c41649301f945a9c1025c5e43cd1d Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 14:03:02 -0300
Subject: [PATCH 37/93] Remove windows (not yet supported)

---
 .github/workflows/test-detectors.yml | 2 --
 1 file changed, 2 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index ebad4f30..c7a905a4 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -44,7 +44,6 @@ jobs:
         os:
           - ubuntu-latest
           - macos-latest
-          - windows-latest
     runs-on: ${{ matrix.os }}
     steps:
       - name: Checkout repository
@@ -93,7 +92,6 @@ jobs:
         os:
           - ubuntu-latest
           - macos-latest
-          - windows-latest
         detector: ${{fromJson(needs.prepare-detector-matrix.outputs.matrix)}}
     runs-on: ${{ matrix.os }}
     steps:

From a45ef20e8c801586d4687498892a4ecb4f8c3a3e Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 17:02:36 -0300
Subject: [PATCH 38/93] Try clean udeps ci

---
 .github/workflows/general-rust.yml | 25 ++++++++++++-
 scripts/run-clippy.py              | 22 ++++++++++-
 scripts/run-fmt.py                 | 22 ++++++++++-
 scripts/run-udeps.py               | 60 ++++++++++++++++++++++++------
 4 files changed, 112 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index df09d26f..52df409b 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -39,7 +39,7 @@ jobs:
         run: rustup component add rustfmt --toolchain nightly
 
       - name: Check Format
-        run: python scripts/run-fmt.py
+        run: python scripts/run-fmt.py --dir test-cases detectors
 
   clippy:
     name: Lint with Clippy
@@ -74,4 +74,25 @@ jobs:
         run: rustup component add clippy --toolchain nightly
 
       - name: Lint with Clippy
-        run: python scripts/run-clippy.py
+        run: python scripts/run-clippy.py --dir test-cases detectors
+
+  udeps:
+    name: Check for unused dependencies
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.9"
+
+      - name: Update Rust Toolchain
+        run: rustup update
+
+      - name: Install cargo-udeps
+        run: cargo install cargo-udeps
+
+      - name: Check for unused dependencies
+        run: python scripts/run-udeps.py --dir test-cases detectors
diff --git a/scripts/run-clippy.py b/scripts/run-clippy.py
index 02d8b909..6e10c3c5 100644
--- a/scripts/run-clippy.py
+++ b/scripts/run-clippy.py
@@ -1,3 +1,4 @@
+import argparse
 import os
 import subprocess
 import time
@@ -11,6 +12,12 @@
 def run_clippy(directories):
     errors = []
     for directory in directories:
+        if not os.path.isdir(directory):
+            errors.append(
+                f"Error: The specified path '{directory}' is not a directory or does not exist."
+            )
+            continue
+
         print(f"\n{GREEN}Running clippy in {directory}:{ENDC}")
         for root, _, files in os.walk(directory):
             if "Cargo.toml" in files:
@@ -54,8 +61,19 @@ def print_clippy_errors(errors):
 
 
 if __name__ == "__main__":
-    directories = ["test-cases", "detectors"]
-    errors = run_clippy(directories)
+    parser = argparse.ArgumentParser(
+        description="Run cargo-clippy for specified directories"
+    )
+    parser.add_argument(
+        "--dir",
+        nargs="+",
+        required=True,
+        help="Specify the directories to run cargo-clippy on. Multiple directories can be specified.",
+    )
+
+    args = parser.parse_args()
+
+    errors = run_clippy(args.dir)
     print_clippy_errors(errors)
     if errors:
         exit(1)
diff --git a/scripts/run-fmt.py b/scripts/run-fmt.py
index 043106b1..ad061a14 100644
--- a/scripts/run-fmt.py
+++ b/scripts/run-fmt.py
@@ -1,3 +1,4 @@
+import argparse
 import os
 import subprocess
 import time
@@ -12,6 +13,12 @@
 def run_fmt(directories):
     errors = []
     for directory in directories:
+        if not os.path.isdir(directory):
+            errors.append(
+                f"Error: The specified path '{directory}' is not a directory or does not exist."
+            )
+            continue
+
         print(f"\n{GREEN}Checking format in {directory}:{ENDC}")
         for root, _, files in os.walk(directory):
             if "Cargo.toml" in files:
@@ -47,8 +54,19 @@ def print_fmt_errors(errors):
 
 
 if __name__ == "__main__":
-    directories = ["test-cases", "detectors"]
-    errors = run_fmt(directories)
+    parser = argparse.ArgumentParser(
+        description="Run cargo-fmt for specified directories"
+    )
+    parser.add_argument(
+        "--dir",
+        nargs="+",
+        required=True,
+        help="Specify the directories to run cargo-fmt on. Multiple directories can be specified.",
+    )
+
+    args = parser.parse_args()
+
+    errors = run_fmt(args.dir)
     print_fmt_errors(errors)
     if errors:
         exit(1)
diff --git a/scripts/run-udeps.py b/scripts/run-udeps.py
index 2c4d7c16..39896f60 100644
--- a/scripts/run-udeps.py
+++ b/scripts/run-udeps.py
@@ -1,39 +1,77 @@
+import argparse
 import os
 import subprocess
+import time
+
+RED = "\033[91m"
+GREEN = "\033[92m"
+BLUE = "\033[94m"
+ENDC = "\033[0m"
 
-RED = '\033[91m'
-GREEN = '\033[92m'
-ENDC = '\033[0m'
 
 def run_udeps(directories):
     errors = []
     for directory in directories:
+        if not os.path.isdir(directory):
+            errors.append(
+                f"Error: The specified path '{directory}' is not a directory or does not exist."
+            )
+            continue
+
         print(f"\n{GREEN}Checking unused dependencies in {directory}:{ENDC}")
         for root, _, files in os.walk(directory):
-            if 'Cargo.toml' in files:
-                print(f"Checking unused dependencies in: {root}")
-                subprocess.run(['cargo', 'update'], cwd=root)
-                result = subprocess.run(['cargo', '+nightly', 'udeps', '--no-default-features', '--locked', '--backend=save-analysis'], cwd=root, capture_output=True, text=True)
+            if "Cargo.toml" in files:
+                start_time = time.time()
+                result = subprocess.run(
+                    [
+                        "cargo",
+                        "udeps",
+                        "--all-targets",
+                    ],
+                    cwd=root,
+                    capture_output=True,
+                    text=True,
+                )
+                end_time = time.time()
+                elapsed_time = end_time - start_time
+                print(
+                    f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed udeps check in: {root}."
+                )
                 if result.returncode != 0:
                     print(f"\n{RED}Unused dependencies found in: {root}{ENDC}\n")
                     error_message = result.stderr.strip()
-                    for line in error_message.split('\n'):
+                    for line in error_message.split("\n"):
                         print(f"| {line}")
                     print("\n")
                     errors.append(root)
     return errors
 
+
 def print_udeps_errors(errors):
     if errors:
-        print(f"{RED}\nUnused dependencies detected in the following directories:{ENDC}")
+        print(
+            f"{RED}\nUnused dependencies detected in the following directories:{ENDC}"
+        )
         for error_dir in errors:
             print(f"• {error_dir}")
     else:
         print(f"{GREEN}\nNo unused dependencies found across all directories.{ENDC}")
 
+
 if __name__ == "__main__":
-    directories = ['test-cases', 'detectors']
-    errors = run_udeps(directories)
+    parser = argparse.ArgumentParser(
+        description="Run cargo-udeps for specified directories"
+    )
+    parser.add_argument(
+        "--dir",
+        nargs="+",
+        required=True,
+        help="Specify the directories to run cargo-udeps on. Multiple directories can be specified.",
+    )
+
+    args = parser.parse_args()
+
+    errors = run_udeps(args.dir)
     print_udeps_errors(errors)
     if errors:
         exit(1)

From 45aedec1851a713839e07f2022bff5c3835c0009 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 17:13:01 -0300
Subject: [PATCH 39/93] Default to specific nightly

---
 .github/workflows/general-rust.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 52df409b..3ac43482 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -91,6 +91,12 @@ jobs:
       - name: Update Rust Toolchain
         run: rustup update
 
+      - name: Install Rust nightly
+        run: rustup install nightly-2023-12-16
+
+      - name: Default to nightly
+        run: rustup default nightly-2023-12-16
+
       - name: Install cargo-udeps
         run: cargo install cargo-udeps
 

From 0d9b5326058706eb337c3e63438c85c759cb33b3 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 17:26:03 -0300
Subject: [PATCH 40/93] Use scout-audit toolchain

---
 .github/workflows/general-rust.yml | 17 +++++++++++------
 scripts/run-udeps.py               |  1 +
 2 files changed, 12 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 3ac43482..2e4fa3f9 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -65,10 +65,10 @@ jobs:
         run: rustup update
 
       - name: Install Rust nightly
-        run: rustup install nightly --profile minimal
+        run: rustup install nightly-2023-12-16 --profile minimal
 
       - name: Install dylint-link
-        run: cargo install dylint-link --force
+        run: cargo install dylint-link
 
       - name: Install clippy
         run: rustup component add clippy --toolchain nightly
@@ -88,14 +88,19 @@ jobs:
         with:
           python-version: "3.9"
 
+      - name: Cache Rust Dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo
+            ~/.rustup
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
       - name: Update Rust Toolchain
         run: rustup update
 
       - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16
-
-      - name: Default to nightly
-        run: rustup default nightly-2023-12-16
+        run: rustup install nightly-2023-12-16 --profile minimal
 
       - name: Install cargo-udeps
         run: cargo install cargo-udeps
diff --git a/scripts/run-udeps.py b/scripts/run-udeps.py
index 39896f60..6bc83f30 100644
--- a/scripts/run-udeps.py
+++ b/scripts/run-udeps.py
@@ -25,6 +25,7 @@ def run_udeps(directories):
                 result = subprocess.run(
                     [
                         "cargo",
+                        "+nightly",
                         "udeps",
                         "--all-targets",
                     ],

From ddfab9fa0719f50cb94407bbead5d5ca0f9f8e82 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 17:29:50 -0300
Subject: [PATCH 41/93] Do not share cache with clippy

---
 .github/workflows/general-rust.yml | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 2e4fa3f9..a53c26bf 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -59,13 +59,14 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
+            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
 
       - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16 --profile minimal
+        run: rustup install nightly --profile minimal
 
       - name: Install dylint-link
         run: cargo install dylint-link
@@ -94,13 +95,13 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-cargo-udeps-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
 
       - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16 --profile minimal
+        run: rustup install nightly-2023-12-16
 
       - name: Install cargo-udeps
         run: cargo install cargo-udeps

From 637e29049178f2dca3e066a7c8f92e8f09ab2262 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 17:37:43 -0300
Subject: [PATCH 42/93] Try run udeps

---
 .github/workflows/general-rust.yml | 3 +++
 scripts/run-udeps.py               | 1 -
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index a53c26bf..ef03f115 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -103,6 +103,9 @@ jobs:
       - name: Install Rust nightly
         run: rustup install nightly-2023-12-16
 
+      - name: Default to nightly
+        run: rustup default nightly
+
       - name: Install cargo-udeps
         run: cargo install cargo-udeps
 
diff --git a/scripts/run-udeps.py b/scripts/run-udeps.py
index 6bc83f30..39896f60 100644
--- a/scripts/run-udeps.py
+++ b/scripts/run-udeps.py
@@ -25,7 +25,6 @@ def run_udeps(directories):
                 result = subprocess.run(
                     [
                         "cargo",
-                        "+nightly",
                         "udeps",
                         "--all-targets",
                     ],

From 868cca1bebdae6fcc6d755b1f92604d785f66b6b Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 17:46:57 -0300
Subject: [PATCH 43/93] Go back to when udeps worked

---
 .github/workflows/general-rust.yml | 10 +---------
 1 file changed, 1 insertion(+), 9 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index ef03f115..90b0a5d0 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -89,14 +89,6 @@ jobs:
         with:
           python-version: "3.9"
 
-      - name: Cache Rust Dependencies
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo
-            ~/.rustup
-          key: ${{ runner.os }}-cargo-udeps-${{ hashFiles('**/Cargo.lock') }}
-
       - name: Update Rust Toolchain
         run: rustup update
 
@@ -104,7 +96,7 @@ jobs:
         run: rustup install nightly-2023-12-16
 
       - name: Default to nightly
-        run: rustup default nightly
+        run: rustup default nightly-2023-12-16
 
       - name: Install cargo-udeps
         run: cargo install cargo-udeps

From 56cdbfaaa898bf4086ffdb29f4b6ed923f211864 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 17:57:31 -0300
Subject: [PATCH 44/93] Cache udeps

---
 .github/workflows/general-rust.yml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 90b0a5d0..3ab09549 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -59,7 +59,6 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
@@ -89,6 +88,14 @@ jobs:
         with:
           python-version: "3.9"
 
+      - name: Cache Rust Dependencies
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo
+            ~/.rustup
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+
       - name: Update Rust Toolchain
         run: rustup update
 

From 89275b33732496bba3dbfb1653f8ff18d2cdd2a7 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 18:22:52 -0300
Subject: [PATCH 45/93] Try fix soroban-version udeps error

---
 .github/workflows/general-rust.yml                        | 4 ++--
 .github/workflows/test-detectors.yml                      | 8 ++++++++
 .../soroban-version-1/remediated-example/Cargo.toml       | 4 ++--
 .../soroban-version-1/vulnerable-example/Cargo.toml       | 1 -
 4 files changed, 12 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 3ab09549..29df57e0 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -59,7 +59,7 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -94,7 +94,7 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-cargo-udeps-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index c7a905a4..a136f3cb 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -36,6 +36,14 @@ jobs:
       - name: Validate detectors
         run: python scripts/validate-detectors.py
 
+      - name: Create or Update Comment
+        uses: peter-evans/create-or-update-comment@v4.0.0
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.pull_request.number }}
+          body: |
+            ✅ All detectors are valid.
+
   build:
     name: Build
     needs: validate-detectors
diff --git a/test-cases/soroban-version/soroban-version-1/remediated-example/Cargo.toml b/test-cases/soroban-version/soroban-version-1/remediated-example/Cargo.toml
index f615db19..2bfb6108 100644
--- a/test-cases/soroban-version/soroban-version-1/remediated-example/Cargo.toml
+++ b/test-cases/soroban-version/soroban-version-1/remediated-example/Cargo.toml
@@ -7,10 +7,10 @@ edition = "2021"
 crate-type = ["cdylib"]
 
 [dependencies]
-soroban-sdk = { version = "=20.3.2" }
+soroban-sdk = { version = "20.0.0" }
 
 [dev_dependencies]
-soroban-sdk = { version = "=20.3.2", features = ["testutils"] }
+soroban-sdk = { version = "20.0.0", features = ["testutils"] }
 
 [features]
 testutils = ["soroban-sdk/testutils"]
diff --git a/test-cases/soroban-version/soroban-version-1/vulnerable-example/Cargo.toml b/test-cases/soroban-version/soroban-version-1/vulnerable-example/Cargo.toml
index 24ca1d8c..c5771258 100644
--- a/test-cases/soroban-version/soroban-version-1/vulnerable-example/Cargo.toml
+++ b/test-cases/soroban-version/soroban-version-1/vulnerable-example/Cargo.toml
@@ -3,7 +3,6 @@ name = "soroban-version-vulnerable-1"
 version = "0.1.0"
 edition = "2021"
 
-
 [lib]
 crate-type = ["cdylib"]
 

From 1d6b0ea47334bd160bb1d1c07822d9236d23df1e Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 18:35:18 -0300
Subject: [PATCH 46/93] Improve comment

---
 .github/workflows/test-detectors.yml | 36 +++++++++++++++++++++-------
 1 file changed, 28 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index a136f3cb..19277b19 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -21,6 +21,8 @@ jobs:
   validate-detectors:
     name: Validate
     runs-on: ubuntu-latest
+    outputs:
+      status: ${{ job.status }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -36,14 +38,6 @@ jobs:
       - name: Validate detectors
         run: python scripts/validate-detectors.py
 
-      - name: Create or Update Comment
-        uses: peter-evans/create-or-update-comment@v4.0.0
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          issue-number: ${{ github.event.pull_request.number }}
-          body: |
-            ✅ All detectors are valid.
-
   build:
     name: Build
     needs: validate-detectors
@@ -53,6 +47,8 @@ jobs:
           - ubuntu-latest
           - macos-latest
     runs-on: ${{ matrix.os }}
+    outputs:
+      status: ${{ job.status }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -102,6 +98,8 @@ jobs:
           - macos-latest
         detector: ${{fromJson(needs.prepare-detector-matrix.outputs.matrix)}}
     runs-on: ${{ matrix.os }}
+    outputs:
+      status: ${{ job.status }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -121,3 +119,25 @@ jobs:
 
       - name: Run unit tests for a specific detector
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
+
+  comment-on-pr:
+    name: Comment on PR
+    runs-on: ubuntu-latest
+    needs: [validate-detectors, build, test]
+    steps:
+      - name: Create or Update PR Comment
+        uses: peter-evans/create-or-update-comment@v4.0.0
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.pull_request.number }}
+          body: |
+            🎉 **Test Detectors Workflow Summary** 🎉
+
+            | Component               | Status |
+            |-------------------------|--------|
+            | Detector Validation     | ${{ (needs.validate-detectors.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Build on Ubuntu         | ${{ (contains(needs.build.result, 'ubuntu-latest') && needs.build.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Build on macOS          | ${{ (contains(needs.build.result, 'macos-latest') && needs.build.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Tests Execution         | ${{ (needs.test.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+
+            The workflow has completed. Please check the statuses above for more details. Great job! 🚀

From a7a9a0eca5973ba019f13a5a29cb4d4052c1bab5 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 19:44:50 -0300
Subject: [PATCH 47/93] Try fix comment and cache individual tests

---
 .github/workflows/general-rust.yml   | 27 +++++++++++++++++++++++++++
 .github/workflows/test-detectors.yml | 17 +++++++++++++----
 2 files changed, 40 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 29df57e0..1ac24554 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -20,6 +20,8 @@ jobs:
   format:
     name: Check Rust Format
     runs-on: ubuntu-latest
+    outputs:
+      status: ${{ job.status }}
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
@@ -44,6 +46,8 @@ jobs:
   clippy:
     name: Lint with Clippy
     runs-on: ubuntu-latest
+    outputs:
+      status: ${{ job.status }}
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
@@ -79,6 +83,8 @@ jobs:
   udeps:
     name: Check for unused dependencies
     runs-on: ubuntu-latest
+    outputs:
+      status: ${{ job.status }}
     steps:
       - name: Checkout Code
         uses: actions/checkout@v4
@@ -110,3 +116,24 @@ jobs:
 
       - name: Check for unused dependencies
         run: python scripts/run-udeps.py --dir test-cases detectors
+
+  comment-on-pr:
+    name: Comment on PR
+    runs-on: ubuntu-latest
+    needs: [format, clippy, udeps]
+    steps:
+      - name: Create or Update PR Comment
+        uses: peter-evans/create-or-update-comment@v4.0.0
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          issue-number: ${{ github.event.pull_request.number }}
+          body: |
+            🎉 **General Rust Workflow Summary** 🎉
+
+            | Component                 | Status |
+            |---------------------------|--------|
+            | Check Rust Format         | ${{ (needs.format.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Lint with Clippy          | ${{ (needs.clippy.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Check for unused deps (udeps) | ${{ (needs.udeps.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+
+            The workflow has completed. Please check the statuses above for more details. Great job! 🚀
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 19277b19..50be5074 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -48,7 +48,8 @@ jobs:
           - macos-latest
     runs-on: ${{ matrix.os }}
     outputs:
-      status: ${{ job.status }}
+      ubuntu-status: ${{ (matrix.os == 'ubuntu-latest' && job.status) || 'not-applicable' }}
+      macos-status: ${{ (matrix.os == 'macos-latest' && job.status) || 'not-applicable' }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -114,9 +115,17 @@ jobs:
         with:
           path: |
             ~/.cargo
-            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
+      - name: Cache build artifacts for ${{ matrix.detector }}
+        uses: actions/cache@v4
+        with:
+          path: |
+            target
+          key: ${{ runner.os }}-${{ matrix.detector }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: |
+            ${{ runner.os }}-${{ matrix.detector }}-
+
       - name: Run unit tests for a specific detector
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 
@@ -136,8 +145,8 @@ jobs:
             | Component               | Status |
             |-------------------------|--------|
             | Detector Validation     | ${{ (needs.validate-detectors.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
-            | Build on Ubuntu         | ${{ (contains(needs.build.result, 'ubuntu-latest') && needs.build.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
-            | Build on macOS          | ${{ (contains(needs.build.result, 'macos-latest') && needs.build.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Build on Ubuntu         | ${{ (needs.build.outputs.ubuntu-status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Build on macOS          | ${{ (needs.build.outputs.macos-status == 'success' && '✅ Successful') || '❌ Failed' }} |
             | Tests Execution         | ${{ (needs.test.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
 
             The workflow has completed. Please check the statuses above for more details. Great job! 🚀

From 2093cf3499b5f17898e37d92a386ea6e3c3c3ef6 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 19:55:46 -0300
Subject: [PATCH 48/93] Try fix individual caching in tests

---
 .github/workflows/general-rust.yml   | 2 +-
 .github/workflows/test-detectors.yml | 4 ++--
 scripts/run-tests.py                 | 4 ++--
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 1ac24554..bd193671 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -112,7 +112,7 @@ jobs:
         run: rustup default nightly-2023-12-16
 
       - name: Install cargo-udeps
-        run: cargo install cargo-udeps
+        run: cargo install dylint-link cargo-udeps
 
       - name: Check for unused dependencies
         run: python scripts/run-udeps.py --dir test-cases detectors
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 50be5074..956028d1 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -86,7 +86,7 @@ jobs:
       - id: set-matrix
         working-directory: test-cases
         run: |
-          echo "matrix=$(find . -mindepth 1 -maxdepth 1 -type d | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
+          echo "matrix=$(find . -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
   test:
     name: Test detector
@@ -121,7 +121,7 @@ jobs:
         uses: actions/cache@v4
         with:
           path: |
-            target
+            test-cases/${{ matrix.detector }}/target
           key: ${{ runner.os }}-${{ matrix.detector }}-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
             ${{ runner.os }}-${{ matrix.detector }}-
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 774db322..dab6f5ab 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -56,13 +56,13 @@ def print_tests_errors(errors):
     parser.add_argument(
         "--detector",
         type=str,
-        help='The detector to run tests for, e.g., "./unsafe-unwrap"',
+        help='The detector to run tests for, e.g., "unsafe-unwrap"',
     )
 
     args = parser.parse_args()
 
     if args.detector:
-        errors = run_tests(args.detector.strip("./"))
+        errors = run_tests(args.detector)
         print_tests_errors(errors)
         if errors:
             exit(1)

From de86b85fe6902baedb9b16828b71edd82cf12631 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 27 Mar 2024 20:01:51 -0300
Subject: [PATCH 49/93] Fix cache on tests

---
 .github/workflows/test-detectors.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 956028d1..8bfd19c5 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -121,7 +121,7 @@ jobs:
         uses: actions/cache@v4
         with:
           path: |
-            test-cases/${{ matrix.detector }}/target
+            test-cases/${{ matrix.detector }}/**/target
           key: ${{ runner.os }}-${{ matrix.detector }}-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
             ${{ runner.os }}-${{ matrix.detector }}-

From 86f45ca7ace43b8c5434af89d054340cbf290ea5 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 28 Mar 2024 14:04:41 -0300
Subject: [PATCH 50/93] Try fix comment and remove individual cache, share
 general rust cache

---
 .github/workflows/general-rust.yml   | 11 ++++---
 .github/workflows/test-detectors.yml | 49 +++++++++++++++++++---------
 2 files changed, 40 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index bd193671..77b06354 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -63,19 +63,19 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-          key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
 
       - name: Install Rust nightly
-        run: rustup install nightly --profile minimal
+        run: rustup install nightly-2023-12-16 --profile minimal
 
       - name: Install dylint-link
         run: cargo install dylint-link
 
       - name: Install clippy
-        run: rustup component add clippy --toolchain nightly
+        run: rustup component add clippy --toolchain nightly-2023-12-16
 
       - name: Lint with Clippy
         run: python scripts/run-clippy.py --dir test-cases detectors
@@ -100,13 +100,13 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-          key: ${{ runner.os }}-cargo-udeps-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
 
       - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16
+        run: rustup install nightly-2023-12-16 --profile minimal
 
       - name: Default to nightly
         run: rustup default nightly-2023-12-16
@@ -120,6 +120,7 @@ jobs:
   comment-on-pr:
     name: Comment on PR
     runs-on: ubuntu-latest
+    if: ${{ always()}}
     needs: [format, clippy, udeps]
     steps:
       - name: Create or Update PR Comment
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 8bfd19c5..279f8a96 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -47,9 +47,6 @@ jobs:
           - ubuntu-latest
           - macos-latest
     runs-on: ${{ matrix.os }}
-    outputs:
-      ubuntu-status: ${{ (matrix.os == 'ubuntu-latest' && job.status) || 'not-applicable' }}
-      macos-status: ${{ (matrix.os == 'macos-latest' && job.status) || 'not-applicable' }}
     steps:
       - name: Checkout repository
         uses: actions/checkout@v4
@@ -59,7 +56,6 @@ jobs:
         with:
           path: |
             ~/.cargo
-            **/target
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: |
             ${{ runner.os }}-cargo-
@@ -73,6 +69,15 @@ jobs:
       - name: Install dylint, dylint-link and cargo-scout-audit
         run: cargo +nightly install cargo-dylint dylint-link cargo-scout-audit
 
+      - name: Determine build status and write to file
+        run: echo "${{ job.status }}" > status-${{ matrix.os }}.txt
+
+      - name: Upload build status artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: build-status-${{ matrix.os }}
+          path: status-${{ matrix.os }}.txt
+
   prepare-detector-matrix:
     name: Prepare Detector Matrix
     runs-on: ubuntu-latest
@@ -117,27 +122,41 @@ jobs:
             ~/.cargo
           key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Cache build artifacts for ${{ matrix.detector }}
-        uses: actions/cache@v4
-        with:
-          path: |
-            test-cases/${{ matrix.detector }}/**/target
-          key: ${{ runner.os }}-${{ matrix.detector }}-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-${{ matrix.detector }}-
-
       - name: Run unit tests for a specific detector
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 
   comment-on-pr:
     name: Comment on PR
     runs-on: ubuntu-latest
+    if: ${{ always() }}
     needs: [validate-detectors, build, test]
     steps:
+      - name: Download build status artifacts
+        uses: actions/download-artifact@v4
+        with:
+          pattern: build-status-*
+
+      - name: Read Ubuntu build status
+        id: ubuntu_status
+        run: echo "status=$(cat status-ubuntu-latest.txt)" >> $GITHUB_OUTPUT
+
+      - name: Read macOS build status
+        id: macos_status
+        run: echo "status=$(cat status-macos-latest.txt)" >> $GITHUB_OUTPUT
+
+      - name: Find comment
+        id: find_comment
+        uses: peter-evans/find-comment@v3
+        with:
+          issue-number: ${{ github.event.pull_request.number }}
+          comment-author: "github-actions[bot]"
+          body-includes: "🎉 **Test Detectors Workflow Summary** 🎉"
+
       - name: Create or Update PR Comment
         uses: peter-evans/create-or-update-comment@v4.0.0
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
+          comment-id: ${{ steps.find_comment.outputs.comment-id }}
           issue-number: ${{ github.event.pull_request.number }}
           body: |
             🎉 **Test Detectors Workflow Summary** 🎉
@@ -145,8 +164,8 @@ jobs:
             | Component               | Status |
             |-------------------------|--------|
             | Detector Validation     | ${{ (needs.validate-detectors.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
-            | Build on Ubuntu         | ${{ (needs.build.outputs.ubuntu-status == 'success' && '✅ Successful') || '❌ Failed' }} |
-            | Build on macOS          | ${{ (needs.build.outputs.macos-status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Build on Ubuntu         | ${{ (steps.ubuntu_status.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
+            | Build on macOS          | ${{ (steps.macos_status.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
             | Tests Execution         | ${{ (needs.test.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
 
             The workflow has completed. Please check the statuses above for more details. Great job! 🚀

From 4dd80b5eb52e9c5d25b1f4ee52faa50440abae3b Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 28 Mar 2024 15:34:32 -0300
Subject: [PATCH 51/93] Find comment in general-rust, debug test detector
 output

---
 .github/workflows/general-rust.yml   |  8 ++++++++
 .github/workflows/test-detectors.yml | 10 ++++++++--
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 77b06354..d1a86256 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -123,10 +123,18 @@ jobs:
     if: ${{ always()}}
     needs: [format, clippy, udeps]
     steps:
+      - name: Find comment
+        id: find_comment
+        uses: peter-evans/find-comment@v1
+        with:
+          issue-number: ${{ github.event.pull_request.number }}
+          body-includes: "🎉 **General Rust Workflow Summary** 🎉"
+
       - name: Create or Update PR Comment
         uses: peter-evans/create-or-update-comment@v4.0.0
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
+          comment-id: ${{ steps.find_comment.outputs.comment-id }}
           issue-number: ${{ github.event.pull_request.number }}
           body: |
             🎉 **General Rust Workflow Summary** 🎉
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 279f8a96..ec52b9cd 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -138,11 +138,17 @@ jobs:
 
       - name: Read Ubuntu build status
         id: ubuntu_status
-        run: echo "status=$(cat status-ubuntu-latest.txt)" >> $GITHUB_OUTPUT
+        run: |
+          ls -l
+          cat status-ubuntu-latest.txt
+          echo "status=$(cat status-ubuntu-latest.txt)" >> $GITHUB_OUTPUT
 
       - name: Read macOS build status
         id: macos_status
-        run: echo "status=$(cat status-macos-latest.txt)" >> $GITHUB_OUTPUT
+        run: |
+          ls -l
+          cat status-macos-latest.txt
+          echo "status=$(cat status-macos-latest.txt)" >> $GITHUB_OUTPUT
 
       - name: Find comment
         id: find_comment

From 250a8e535c59862f2865b32bfb6410c04a1261c2 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 28 Mar 2024 16:02:34 -0300
Subject: [PATCH 52/93] Try fix comment

---
 .github/workflows/general-rust.yml   |  4 ++--
 .github/workflows/test-detectors.yml | 12 ++++++------
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index d1a86256..70a4d123 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -63,7 +63,7 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -100,7 +100,7 @@ jobs:
           path: |
             ~/.cargo
             ~/.rustup
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-cargo-udeps-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index ec52b9cd..cccc1769 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -56,9 +56,7 @@ jobs:
         with:
           path: |
             ~/.cargo
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: |
-            ${{ runner.os }}-cargo-
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -120,7 +118,7 @@ jobs:
         with:
           path: |
             ~/.cargo
-          key: ${{ runner.os }}-cargo-${{ hashFiles('**/Cargo.lock') }}
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Run unit tests for a specific detector
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
@@ -138,15 +136,17 @@ jobs:
 
       - name: Read Ubuntu build status
         id: ubuntu_status
+        working-directory: status-ubuntu-latest
         run: |
-          ls -l
+          ls
           cat status-ubuntu-latest.txt
           echo "status=$(cat status-ubuntu-latest.txt)" >> $GITHUB_OUTPUT
 
       - name: Read macOS build status
         id: macos_status
+        working-directory: status-macos-latest
         run: |
-          ls -l
+          ls
           cat status-macos-latest.txt
           echo "status=$(cat status-macos-latest.txt)" >> $GITHUB_OUTPUT
 

From 031f9b0b255dfdda51a30fcc30605bc2fe1afaaf Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 28 Mar 2024 16:39:13 -0300
Subject: [PATCH 53/93] Try fix artifacts download

---
 .github/workflows/general-rust.yml   | 1 +
 .github/workflows/test-detectors.yml | 5 +----
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 70a4d123..99ebb600 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -135,6 +135,7 @@ jobs:
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           comment-id: ${{ steps.find_comment.outputs.comment-id }}
+          edit-mode: replace
           issue-number: ${{ github.event.pull_request.number }}
           body: |
             🎉 **General Rust Workflow Summary** 🎉
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index cccc1769..4ee3a5dd 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -131,12 +131,9 @@ jobs:
     steps:
       - name: Download build status artifacts
         uses: actions/download-artifact@v4
-        with:
-          pattern: build-status-*
 
       - name: Read Ubuntu build status
         id: ubuntu_status
-        working-directory: status-ubuntu-latest
         run: |
           ls
           cat status-ubuntu-latest.txt
@@ -144,7 +141,6 @@ jobs:
 
       - name: Read macOS build status
         id: macos_status
-        working-directory: status-macos-latest
         run: |
           ls
           cat status-macos-latest.txt
@@ -163,6 +159,7 @@ jobs:
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           comment-id: ${{ steps.find_comment.outputs.comment-id }}
+          edit-mode: replace
           issue-number: ${{ github.event.pull_request.number }}
           body: |
             🎉 **Test Detectors Workflow Summary** 🎉

From 88938329c0251f4b57e8cbfb2cb3ad3f32241c05 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 28 Mar 2024 17:15:31 -0300
Subject: [PATCH 54/93] Try fix again

---
 .github/workflows/test-detectors.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 4ee3a5dd..2bd2410f 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -134,6 +134,7 @@ jobs:
 
       - name: Read Ubuntu build status
         id: ubuntu_status
+        working-directory: build-status-ubuntu-latest
         run: |
           ls
           cat status-ubuntu-latest.txt
@@ -141,6 +142,7 @@ jobs:
 
       - name: Read macOS build status
         id: macos_status
+        working-directory: build-status-macos-latest
         run: |
           ls
           cat status-macos-latest.txt

From 41b56849b091ea5a4d30f7e51af7133135e166a3 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 3 Apr 2024 13:21:10 -0300
Subject: [PATCH 55/93] Update messages and format

---
 .github/workflows/general-rust.yml   |  4 ++--
 .github/workflows/test-detectors.yml | 22 ++++++----------------
 2 files changed, 8 insertions(+), 18 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 99ebb600..1e3bd73f 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -125,7 +125,7 @@ jobs:
     steps:
       - name: Find comment
         id: find_comment
-        uses: peter-evans/find-comment@v1
+        uses: peter-evans/find-comment@v3
         with:
           issue-number: ${{ github.event.pull_request.number }}
           body-includes: "🎉 **General Rust Workflow Summary** 🎉"
@@ -146,4 +146,4 @@ jobs:
             | Lint with Clippy          | ${{ (needs.clippy.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
             | Check for unused deps (udeps) | ${{ (needs.udeps.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
 
-            The workflow has completed. Please check the statuses above for more details. Great job! 🚀
+            The workflow has completed. Great job! 🚀
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 2bd2410f..8639cfc8 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -54,8 +54,7 @@ jobs:
       - name: Cache cargo dependencies
         uses: actions/cache@v4
         with:
-          path: |
-            ~/.cargo
+          path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Update Rust Toolchain
@@ -88,8 +87,7 @@ jobs:
 
       - id: set-matrix
         working-directory: test-cases
-        run: |
-          echo "matrix=$(find . -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
+        run: echo "matrix=$(find . -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
 
   test:
     name: Test detector
@@ -116,8 +114,7 @@ jobs:
       - name: Cache cargo dependencies
         uses: actions/cache@v4
         with:
-          path: |
-            ~/.cargo
+          path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Run unit tests for a specific detector
@@ -135,25 +132,18 @@ jobs:
       - name: Read Ubuntu build status
         id: ubuntu_status
         working-directory: build-status-ubuntu-latest
-        run: |
-          ls
-          cat status-ubuntu-latest.txt
-          echo "status=$(cat status-ubuntu-latest.txt)" >> $GITHUB_OUTPUT
+        run: echo "status=$(cat status-ubuntu-latest.txt)" >> $GITHUB_OUTPUT
 
       - name: Read macOS build status
         id: macos_status
         working-directory: build-status-macos-latest
-        run: |
-          ls
-          cat status-macos-latest.txt
-          echo "status=$(cat status-macos-latest.txt)" >> $GITHUB_OUTPUT
+        run: echo "status=$(cat status-macos-latest.txt)" >> $GITHUB_OUTPUT
 
       - name: Find comment
         id: find_comment
         uses: peter-evans/find-comment@v3
         with:
           issue-number: ${{ github.event.pull_request.number }}
-          comment-author: "github-actions[bot]"
           body-includes: "🎉 **Test Detectors Workflow Summary** 🎉"
 
       - name: Create or Update PR Comment
@@ -173,4 +163,4 @@ jobs:
             | Build on macOS          | ${{ (steps.macos_status.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
             | Tests Execution         | ${{ (needs.test.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
 
-            The workflow has completed. Please check the statuses above for more details. Great job! 🚀
+            The workflow has completed. Great job! 🚀

From 58eadf5965118f0014695f677c3eb242295dcff6 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 8 Apr 2024 17:55:53 -0300
Subject: [PATCH 56/93] Delete udeps and add integration tests to ci

---
 .github/workflows/general-rust.yml |  40 +---------
 scripts/run-tests.py               | 118 ++++++++++++++++++++++++-----
 2 files changed, 98 insertions(+), 60 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 1e3bd73f..b2d21e80 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -80,48 +80,11 @@ jobs:
       - name: Lint with Clippy
         run: python scripts/run-clippy.py --dir test-cases detectors
 
-  udeps:
-    name: Check for unused dependencies
-    runs-on: ubuntu-latest
-    outputs:
-      status: ${{ job.status }}
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.9"
-
-      - name: Cache Rust Dependencies
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.cargo
-            ~/.rustup
-          key: ${{ runner.os }}-cargo-udeps-${{ hashFiles('**/Cargo.lock') }}
-
-      - name: Update Rust Toolchain
-        run: rustup update
-
-      - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16 --profile minimal
-
-      - name: Default to nightly
-        run: rustup default nightly-2023-12-16
-
-      - name: Install cargo-udeps
-        run: cargo install dylint-link cargo-udeps
-
-      - name: Check for unused dependencies
-        run: python scripts/run-udeps.py --dir test-cases detectors
-
   comment-on-pr:
     name: Comment on PR
     runs-on: ubuntu-latest
     if: ${{ always()}}
-    needs: [format, clippy, udeps]
+    needs: [format, clippy]
     steps:
       - name: Find comment
         id: find_comment
@@ -144,6 +107,5 @@ jobs:
             |---------------------------|--------|
             | Check Rust Format         | ${{ (needs.format.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
             | Lint with Clippy          | ${{ (needs.clippy.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
-            | Check for unused deps (udeps) | ${{ (needs.udeps.outputs.status == 'success' && '✅ Successful') || '❌ Failed' }} |
 
             The workflow has completed. Great job! 🚀
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index dab6f5ab..15e939a3 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -1,4 +1,6 @@
+import json
 import os
+import re
 import subprocess
 import argparse
 import time
@@ -9,6 +11,97 @@
 ENDC = "\033[0m"
 
 
+def parse_json_from_string(console_output):
+    brace_count = 0
+    json_start = None
+    json_end = None
+
+    for i, char in enumerate(console_output):
+        if char == "{":
+            brace_count += 1
+            if brace_count == 1:
+                json_start = i
+        elif char == "}":
+            brace_count -= 1
+            if brace_count == 0 and json_start is not None:
+                json_end = i + 1
+                break
+
+    if json_start is not None and json_end is not None:
+        json_str = console_output[json_start:json_end]
+        try:
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            return "Extracted string is not valid JSON"
+    else:
+        return "No JSON found in the console output"
+
+
+def run_unit_tests(root):
+    start_time = time.time()
+    result = subprocess.run(
+        ["cargo", "test", "--all-features", "--all"],
+        cwd=root,
+        capture_output=True,
+        text=True,
+    )
+    end_time = time.time()
+    elapsed_time = end_time - start_time
+    print(f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed unit test in: {root}.")
+    if result.returncode != 0:
+        print(f"\n{RED}Test error found in: {root}{ENDC}\n")
+        error_message = result.stdout.strip()
+        for line in error_message.split("\n"):
+            print(f"| {line}")
+        print("\n")
+        return True
+    return False
+
+
+def run_integration_tests(detector, root):
+    start_time = time.time()
+    short_message = ""
+    detector_metadata_result = subprocess.run(
+        ["cargo", "scout-audit", "--filter", detector, "--metadata"],
+        cwd=root,
+        capture_output=True,
+        text=True,
+    )
+
+    detector_metadata = parse_json_from_string(detector_metadata_result.stdout)
+    if not isinstance(detector_metadata, dict):
+        print("Failed to extract JSON:", detector_metadata)
+        return False
+
+    detector_key = detector.replace("-", "_")
+    short_message = detector_metadata.get(detector_key, {}).get("short_message")
+
+    result = subprocess.run(
+        ["cargo", "scout-audit", "--filter", detector],
+        cwd=root,
+        capture_output=True,
+        text=True,
+    )
+
+    elapsed_time = time.time() - start_time
+    print(
+        f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed integration test in: {root}."
+    )
+
+    should_lint = root.endswith("vulnerable-example")
+    if result.returncode != 0 or (
+        should_lint and short_message and short_message not in result.stderr
+    ):
+        print(f"\n{RED}Test error found in: {root}{ENDC}\n")
+        error_message = result.stderr.strip()
+        for line in error_message.split("\n"):
+            print(f"| {line}")
+        print("\n")
+        return True
+
+    return False
+
+
 def run_tests(detector):
     errors = []
     directory = os.path.join("test-cases", detector)
@@ -16,29 +109,12 @@ def run_tests(detector):
     if os.path.exists(directory):
         for root, _, files in os.walk(directory):
             if "Cargo.toml" in files:
-                start_time = time.time()
-                result = subprocess.run(
-                    ["cargo", "test", "--all-features", "--all"],
-                    cwd=root,
-                    capture_output=True,
-                    text=True,
-                )
-                end_time = time.time()
-                elapsed_time = end_time - start_time
-                print(
-                    f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed test in: {root}."
-                )
-                if result.returncode != 0:
-                    print(f"\n{RED}Test error found in: {root}{ENDC}\n")
-                    error_message = result.stdout.strip()
-                    for line in error_message.split("\n"):
-                        print(f"| {line}")
-                    print("\n")
+                if run_unit_tests(root):
+                    errors.append(root)
+                if run_integration_tests(detector, root):
                     errors.append(root)
     else:
-        print(
-            f"{RED}The specified detector directory does not exist: {directory}{ENDC}"
-        )
+        print(f"{RED}The specified directory does not exist.{ENDC}")
     return errors
 
 

From 5d90d55694b2cef872d81f2e0dc06bad4c0a95af Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Mon, 8 Apr 2024 18:04:07 -0300
Subject: [PATCH 57/93] Try fix test passing on invalid json output

---
 .github/workflows/test-detectors.yml | 2 +-
 scripts/run-tests.py                 | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 8639cfc8..e4e9a14f 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -117,7 +117,7 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Run unit tests for a specific detector
+      - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 
   comment-on-pr:
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 15e939a3..9dbf356b 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -71,7 +71,7 @@ def run_integration_tests(detector, root):
     detector_metadata = parse_json_from_string(detector_metadata_result.stdout)
     if not isinstance(detector_metadata, dict):
         print("Failed to extract JSON:", detector_metadata)
-        return False
+        return True
 
     detector_key = detector.replace("-", "_")
     short_message = detector_metadata.get(detector_key, {}).get("short_message")

From 4b779819bbe60741dd9b7611fc3ab723af964a17 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 12:28:48 -0300
Subject: [PATCH 58/93] Delete release worfklow, add utils file

---
 .github/workflows/release.yml |  60 --------------
 scripts/run-clippy.py         |  33 ++------
 scripts/run-fmt.py            |  35 ++------
 scripts/run-tests.py          | 151 +++++++++++-----------------------
 scripts/run-udeps.py          |  41 ++-------
 scripts/utils.py              |  98 ++++++++++++++++++++++
 6 files changed, 171 insertions(+), 247 deletions(-)
 delete mode 100644 .github/workflows/release.yml
 create mode 100644 scripts/utils.py

diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
deleted file mode 100644
index e21aa8f4..00000000
--- a/.github/workflows/release.yml
+++ /dev/null
@@ -1,60 +0,0 @@
-name: Release
-
-on:
-  push:
-    tags:
-      - "v*.*.*"
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  release:
-    name: Release
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Login to crates.io
-        run: echo ${{ secrets.CRATES_TOKEN }} | cargo login
-
-      - name: Publish to crates.io
-        run: python scripts/publish-to-crates-io.py
-
-      - name: Create release notes
-        run: sed -n '/^## ${{ github.ref_name }}/,/^## v/{/^## ${{ github.ref_name }}/p; /^## v/!p;}' CHANGELOG.md | awk 'NF {print $0}' | tee body.md
-
-      - name: Create release
-        uses: softprops/action-gh-release@v1
-        with:
-          tag_name: ${{ github.ref }}
-          name: ${{ github.ref_name }}
-          body_path: body.md
-          draft: false
-          prerelease: ${{ contains(github.ref, 'pre') || contains(github.ref, 'rc') }}
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-  upload-binaries:
-    strategy:
-      matrix:
-        include:
-          - { o: macos-latest,   t: x86_64-apple-darwin                              }
-          - { o: ubuntu-latest,  t: x86_64-unknown-linux-gnu                         }
-          - { o: windows-latest, t: x86_64-pc-windows-msvc                           }
-
-    name: Upload binaries
-    runs-on: ${{ matrix.o }}
-    needs: release
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-
-      - name: Build and publish
-        uses: taiki-e/upload-rust-binary-action@v1
-        with:
-          manifest_path: apps/cargo-scout-audit/Cargo.toml
-          bin: cargo-scout-audit
-          archive: cargo-scout-audit-${{ github.ref_name }}-${{ matrix.t }}-${{ matrix.o }}
-          tar: unix
-          zip: windows
-          token: ${{ secrets.GITHUB_TOKEN }}
diff --git a/scripts/run-clippy.py b/scripts/run-clippy.py
index 6e10c3c5..4c36fb85 100644
--- a/scripts/run-clippy.py
+++ b/scripts/run-clippy.py
@@ -1,8 +1,9 @@
 import argparse
 import os
-import subprocess
 import time
 
+from utils import print_errors, print_results, run_subprocess
+
 RED = "\033[91m"
 GREEN = "\033[92m"
 BLUE = "\033[94m"
@@ -22,7 +23,7 @@ def run_clippy(directories):
         for root, _, files in os.walk(directory):
             if "Cargo.toml" in files:
                 start_time = time.time()
-                result = subprocess.run(
+                returncode, _, stderr = run_subprocess(
                     [
                         "cargo",
                         "clippy",
@@ -33,31 +34,14 @@ def run_clippy(directories):
                         "warnings",
                     ],
                     cwd=root,
-                    capture_output=True,
-                    text=True,
                 )
-                end_time = time.time()
-                elapsed_time = end_time - start_time
-                print(
-                    f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed clippy check in: {root}."
+                print_results(
+                    returncode, stderr, "clippy", root, time.time() - start_time
                 )
-                if result.returncode != 0:
-                    print(f"\n{RED}Clippy issues found in: {root}{ENDC}\n")
-                    error_message = result.stderr.strip()
-                    for line in error_message.split("\n"):
-                        print(f"| {line}")
-                    print("\n")
+                if returncode != 0:
                     errors.append(root)
-    return errors
-
 
-def print_clippy_errors(errors):
-    if errors:
-        print(f"{RED}\nClippy errors detected in the following directories:{ENDC}")
-        for error_dir in errors:
-            print(f"• {error_dir}")
-    else:
-        print(f"{GREEN}\nNo clippy issues found across all directories.{ENDC}")
+    return errors
 
 
 if __name__ == "__main__":
@@ -70,10 +54,9 @@ def print_clippy_errors(errors):
         required=True,
         help="Specify the directories to run cargo-clippy on. Multiple directories can be specified.",
     )
-
     args = parser.parse_args()
 
     errors = run_clippy(args.dir)
-    print_clippy_errors(errors)
+    print_errors(errors)
     if errors:
         exit(1)
diff --git a/scripts/run-fmt.py b/scripts/run-fmt.py
index ad061a14..3e330ff0 100644
--- a/scripts/run-fmt.py
+++ b/scripts/run-fmt.py
@@ -1,8 +1,8 @@
 import argparse
 import os
-import subprocess
 import time
-from datetime import datetime
+
+from utils import print_errors, print_results, run_subprocess
 
 RED = "\033[91m"
 GREEN = "\033[92m"
@@ -23,36 +23,18 @@ def run_fmt(directories):
         for root, _, files in os.walk(directory):
             if "Cargo.toml" in files:
                 start_time = time.time()
-                result = subprocess.run(
-                    ["cargo", "+nightly", "fmt", "--", "--check", "-v"],
+                returncode, _, stderr = run_subprocess(
+                    ["cargo", "fmt", "--all"],
                     cwd=root,
-                    capture_output=True,
-                    text=True,
                 )
-                end_time = time.time()
-                elapsed_time = end_time - start_time
-                print(
-                    f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed format check in: {root}."
+                print_results(
+                    returncode, stderr, "format", root, time.time() - start_time
                 )
-                if result.returncode != 0:
-                    print(f"\n{RED}Formatting issues found in: {root}{ENDC}\n")
-                    error_message = result.stdout.strip()
-                    for line in error_message.split("\n"):
-                        print(f"| {line}")
-                    print("\n")
+                if returncode != 0:
                     errors.append(root)
     return errors
 
 
-def print_fmt_errors(errors):
-    if errors:
-        print(f"{RED}\nFormatting errors detected in the following directories:{ENDC}")
-        for error_dir in errors:
-            print(f"• {error_dir}")
-    else:
-        print(f"{GREEN}\nNo formatting issues found across all directories.{ENDC}")
-
-
 if __name__ == "__main__":
     parser = argparse.ArgumentParser(
         description="Run cargo-fmt for specified directories"
@@ -63,10 +45,9 @@ def print_fmt_errors(errors):
         required=True,
         help="Specify the directories to run cargo-fmt on. Multiple directories can be specified.",
     )
-
     args = parser.parse_args()
 
     errors = run_fmt(args.dir)
-    print_fmt_errors(errors)
+    print_errors(errors)
     if errors:
         exit(1)
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 9dbf356b..aae41f2a 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -1,74 +1,55 @@
 import json
 import os
-import re
-import subprocess
 import argparse
 import time
 
+from utils import parse_json_from_string, print_errors, print_results, run_subprocess
+
 RED = "\033[91m"
 GREEN = "\033[92m"
 BLUE = "\033[94m"
 ENDC = "\033[0m"
 
 
-def parse_json_from_string(console_output):
-    brace_count = 0
-    json_start = None
-    json_end = None
-
-    for i, char in enumerate(console_output):
-        if char == "{":
-            brace_count += 1
-            if brace_count == 1:
-                json_start = i
-        elif char == "}":
-            brace_count -= 1
-            if brace_count == 0 and json_start is not None:
-                json_end = i + 1
-                break
-
-    if json_start is not None and json_end is not None:
-        json_str = console_output[json_start:json_end]
-        try:
-            return json.loads(json_str)
-        except json.JSONDecodeError:
-            return "Extracted string is not valid JSON"
-    else:
-        return "No JSON found in the console output"
+def run_tests(detector):
+    errors = []
+    directory = os.path.join("test-cases", detector)
+    print(f"\n{GREEN}Performing tests in {directory}:{ENDC}")
+    if not os.path.exists(directory):
+        print(f"{RED}The specified directory does not exist.{ENDC}")
+        return errors
+
+    for root, _, files in os.walk(directory):
+        if "Cargo.toml" in files:
+            if run_unit_tests(root):
+                errors.append(root)
+            if run_integration_tests(detector, root):
+                errors.append(root)
+    return errors
 
 
 def run_unit_tests(root):
     start_time = time.time()
-    result = subprocess.run(
-        ["cargo", "test", "--all-features", "--all"],
-        cwd=root,
-        capture_output=True,
-        text=True,
+    returncode, stdout, _ = run_subprocess(
+        ["cargo", "test", "--all-features", "--all"], root
     )
-    end_time = time.time()
-    elapsed_time = end_time - start_time
-    print(f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed unit test in: {root}.")
-    if result.returncode != 0:
-        print(f"\n{RED}Test error found in: {root}{ENDC}\n")
-        error_message = result.stdout.strip()
-        for line in error_message.split("\n"):
-            print(f"| {line}")
-        print("\n")
-        return True
-    return False
+    print_results(
+        returncode,
+        stdout,
+        "unit-test",
+        root,
+        time.time() - start_time,
+    )
+    return returncode != 0
 
 
 def run_integration_tests(detector, root):
     start_time = time.time()
-    short_message = ""
-    detector_metadata_result = subprocess.run(
-        ["cargo", "scout-audit", "--filter", detector, "--metadata"],
-        cwd=root,
-        capture_output=True,
-        text=True,
+    returncode, stdout, _ = run_subprocess(
+        ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
     )
+    detector_metadata = parse_json_from_string(stdout)
 
-    detector_metadata = parse_json_from_string(detector_metadata_result.stdout)
     if not isinstance(detector_metadata, dict):
         print("Failed to extract JSON:", detector_metadata)
         return True
@@ -76,55 +57,22 @@ def run_integration_tests(detector, root):
     detector_key = detector.replace("-", "_")
     short_message = detector_metadata.get(detector_key, {}).get("short_message")
 
-    result = subprocess.run(
-        ["cargo", "scout-audit", "--filter", detector],
-        cwd=root,
-        capture_output=True,
-        text=True,
-    )
-
-    elapsed_time = time.time() - start_time
-    print(
-        f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed integration test in: {root}."
+    returncode, _, stderr = run_subprocess(
+        ["cargo", "scout-audit", "--filter", detector], root
     )
 
     should_lint = root.endswith("vulnerable-example")
-    if result.returncode != 0 or (
-        should_lint and short_message and short_message not in result.stderr
-    ):
-        print(f"\n{RED}Test error found in: {root}{ENDC}\n")
-        error_message = result.stderr.strip()
-        for line in error_message.split("\n"):
-            print(f"| {line}")
-        print("\n")
-        return True
-
-    return False
-
-
-def run_tests(detector):
-    errors = []
-    directory = os.path.join("test-cases", detector)
-    print(f"\n{GREEN}Performing tests in {directory}:{ENDC}")
-    if os.path.exists(directory):
-        for root, _, files in os.walk(directory):
-            if "Cargo.toml" in files:
-                if run_unit_tests(root):
-                    errors.append(root)
-                if run_integration_tests(detector, root):
-                    errors.append(root)
-    else:
-        print(f"{RED}The specified directory does not exist.{ENDC}")
-    return errors
-
-
-def print_tests_errors(errors):
-    if errors:
-        print(f"{RED}\nErrors detected in the following directories:{ENDC}")
-        for error_dir in errors:
-            print(f"• {error_dir}")
-    else:
-        print(f"{GREEN}\nNo errors found in the specified directory.{ENDC}")
+    if should_lint and short_message and short_message not in stderr:
+        returncode = 1
+
+    print_results(
+        returncode,
+        stderr,
+        "integration-test",
+        root,
+        time.time() - start_time,
+    )
+    return returncode != 0
 
 
 if __name__ == "__main__":
@@ -132,15 +80,12 @@ def print_tests_errors(errors):
     parser.add_argument(
         "--detector",
         type=str,
+        required=True,
         help='The detector to run tests for, e.g., "unsafe-unwrap"',
     )
-
     args = parser.parse_args()
 
-    if args.detector:
-        errors = run_tests(args.detector)
-        print_tests_errors(errors)
-        if errors:
-            exit(1)
-    else:
-        print(f"{RED}No detector specified. Please provide a detector argument.{ENDC}")
+    errors = run_tests(args.detector)
+    print_errors(errors)
+    if errors:
+        exit(1)
diff --git a/scripts/run-udeps.py b/scripts/run-udeps.py
index 39896f60..774d8df1 100644
--- a/scripts/run-udeps.py
+++ b/scripts/run-udeps.py
@@ -3,6 +3,8 @@
 import subprocess
 import time
 
+from utils import print_errors, print_results
+
 RED = "\033[91m"
 GREEN = "\033[92m"
 BLUE = "\033[94m"
@@ -22,40 +24,16 @@ def run_udeps(directories):
         for root, _, files in os.walk(directory):
             if "Cargo.toml" in files:
                 start_time = time.time()
-                result = subprocess.run(
-                    [
-                        "cargo",
-                        "udeps",
-                        "--all-targets",
-                    ],
-                    cwd=root,
-                    capture_output=True,
-                    text=True,
+                returncode, _, stderr = subprocess.run(
+                    ["cargo", "udeps"], cwd=root, capture_output=True, text=True
                 )
-                end_time = time.time()
-                elapsed_time = end_time - start_time
-                print(
-                    f"{BLUE}[> {elapsed_time:.2f} sec]{ENDC} - Completed udeps check in: {root}."
+                print_results(
+                    returncode, stderr, "udeps", root, time.time() - start_time
                 )
-                if result.returncode != 0:
-                    print(f"\n{RED}Unused dependencies found in: {root}{ENDC}\n")
-                    error_message = result.stderr.strip()
-                    for line in error_message.split("\n"):
-                        print(f"| {line}")
-                    print("\n")
+                if returncode != 0:
                     errors.append(root)
-    return errors
-
 
-def print_udeps_errors(errors):
-    if errors:
-        print(
-            f"{RED}\nUnused dependencies detected in the following directories:{ENDC}"
-        )
-        for error_dir in errors:
-            print(f"• {error_dir}")
-    else:
-        print(f"{GREEN}\nNo unused dependencies found across all directories.{ENDC}")
+    return errors
 
 
 if __name__ == "__main__":
@@ -68,10 +46,9 @@ def print_udeps_errors(errors):
         required=True,
         help="Specify the directories to run cargo-udeps on. Multiple directories can be specified.",
     )
-
     args = parser.parse_args()
 
     errors = run_udeps(args.dir)
-    print_udeps_errors(errors)
+    print_errors(errors)
     if errors:
         exit(1)
diff --git a/scripts/utils.py b/scripts/utils.py
new file mode 100644
index 00000000..3ac311b5
--- /dev/null
+++ b/scripts/utils.py
@@ -0,0 +1,98 @@
+import json
+import subprocess
+from typing import Tuple, Optional
+
+RED = "\033[91m"
+GREEN = "\033[92m"
+BLUE = "\033[94m"
+ENDC = "\033[0m"
+
+
+def parse_json_from_string(console_output):
+    json_start, json_end = None, None
+    brace_count = 0
+
+    for i, char in enumerate(console_output):
+        if char == "{":
+            brace_count += 1
+            if brace_count == 1:
+                json_start = i
+        elif char == "}":
+            brace_count -= 1
+            if brace_count == 0 and json_start is not None:
+                json_end = i + 1
+                break
+
+    if json_start is not None and json_end is not None:
+        json_str = console_output[json_start:json_end]
+        try:
+            return json.loads(json_str)
+        except json.JSONDecodeError:
+            return "Extracted string is not valid JSON"
+    else:
+        return "No JSON found in the console output"
+
+
+def run_subprocess(
+    command: list, cwd: str, capture: bool = True, handle_stderr: bool = True
+) -> Tuple[int, Optional[str], Optional[str]]:
+    result = subprocess.run(command, cwd=cwd, capture_output=capture, text=True)
+    stdout = result.stdout.strip() if capture and result.stdout else None
+    stderr = result.stderr.strip() if handle_stderr and result.stderr else None
+    return (result.returncode, stdout, stderr)
+
+
+def print_errors(errors):
+    if errors:
+        print(f"{RED}\nErrors detected in the following directories:{ENDC}")
+        for error_dir in errors:
+            print(f"• {error_dir}")
+    else:
+        print(f"{GREEN}\nNo errors found in the specified directory.{ENDC}")
+
+
+def print_results(
+    returncode,
+    error_message,
+    check_type,
+    root,
+    elapsed_time,
+    issue_type="issues",
+    action_type="check",
+):
+    message_color = RED if returncode != 0 else BLUE
+    print(
+        f"{message_color}[> {elapsed_time:.2f} sec]{ENDC} - Completed {check_type} {action_type} in: {root}."
+    )
+    if returncode != 0:
+        print(f"\n{RED}{check_type.capitalize()} {issue_type} found in: {root}{ENDC}\n")
+        for line in error_message.strip().split("\n"):
+            print(f"| {line}")
+        print("\n")
+
+
+def print_results(returncode, error_message, check_type, root, elapsed_time):
+    allowed_check_types = ["clippy", "fmt", "udeps", "unit-test", "integration-test"]
+    if check_type not in allowed_check_types:
+        raise ValueError(
+            f"Invalid check_type '{check_type}'. Allowed values are: {', '.join(allowed_check_types)}"
+        )
+
+    if check_type in ["clippy", "fmt", "udeps"]:
+        issue_type = "issues"
+        action_type = "check"
+    elif check_type in ["unit-test", "integration-test"]:
+        issue_type = "errors"
+        action_type = "run"
+    else:
+        raise ValueError(f"Invalid check_type '{check_type}'.")
+
+    message_color = RED if returncode != 0 else BLUE
+    print(
+        f"{message_color}[> {elapsed_time:.2f} sec]{ENDC} - Completed {check_type} {action_type} in: {root}."
+    )
+    if returncode != 0:
+        print(f"\n{RED}{check_type.capitalize()} {issue_type} found in: {root}{ENDC}\n")
+        for line in error_message.strip().split("\n"):
+            print(f"| {line}")
+        print("\n")

From 70b460dbdcb3f8521611a936dc4453aef81fe097 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 12:30:23 -0300
Subject: [PATCH 59/93] Fix format issue

---
 scripts/utils.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/utils.py b/scripts/utils.py
index 3ac311b5..0e1acfd0 100644
--- a/scripts/utils.py
+++ b/scripts/utils.py
@@ -72,13 +72,13 @@ def print_results(
 
 
 def print_results(returncode, error_message, check_type, root, elapsed_time):
-    allowed_check_types = ["clippy", "fmt", "udeps", "unit-test", "integration-test"]
+    allowed_check_types = ["clippy", "format", "udeps", "unit-test", "integration-test"]
     if check_type not in allowed_check_types:
         raise ValueError(
             f"Invalid check_type '{check_type}'. Allowed values are: {', '.join(allowed_check_types)}"
         )
 
-    if check_type in ["clippy", "fmt", "udeps"]:
+    if check_type in ["clippy", "format", "udeps"]:
         issue_type = "issues"
         action_type = "check"
     elif check_type in ["unit-test", "integration-test"]:

From 18217d6a5817552c6bd855016a9812cc75f2b391 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 13:50:08 -0300
Subject: [PATCH 60/93] Clean scripts

---
 scripts/run-clippy.py | 2 --
 scripts/run-fmt.py    | 2 --
 scripts/run-tests.py  | 9 +++++++--
 scripts/run-udeps.py  | 2 --
 4 files changed, 7 insertions(+), 8 deletions(-)

diff --git a/scripts/run-clippy.py b/scripts/run-clippy.py
index 4c36fb85..ddbc08cb 100644
--- a/scripts/run-clippy.py
+++ b/scripts/run-clippy.py
@@ -4,9 +4,7 @@
 
 from utils import print_errors, print_results, run_subprocess
 
-RED = "\033[91m"
 GREEN = "\033[92m"
-BLUE = "\033[94m"
 ENDC = "\033[0m"
 
 
diff --git a/scripts/run-fmt.py b/scripts/run-fmt.py
index 3e330ff0..83148142 100644
--- a/scripts/run-fmt.py
+++ b/scripts/run-fmt.py
@@ -4,9 +4,7 @@
 
 from utils import print_errors, print_results, run_subprocess
 
-RED = "\033[91m"
 GREEN = "\033[92m"
-BLUE = "\033[94m"
 ENDC = "\033[0m"
 
 
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index aae41f2a..9296a4cf 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -1,4 +1,3 @@
-import json
 import os
 import argparse
 import time
@@ -7,7 +6,6 @@
 
 RED = "\033[91m"
 GREEN = "\033[92m"
-BLUE = "\033[94m"
 ENDC = "\033[0m"
 
 
@@ -48,6 +46,13 @@ def run_integration_tests(detector, root):
     returncode, stdout, _ = run_subprocess(
         ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
     )
+
+    if stdout is None:
+        print(
+            f"{RED}Failed to run integration tests in {root} - Metadata returned empty.{ENDC}"
+        )
+        return True
+
     detector_metadata = parse_json_from_string(stdout)
 
     if not isinstance(detector_metadata, dict):
diff --git a/scripts/run-udeps.py b/scripts/run-udeps.py
index 774d8df1..1d22a2e6 100644
--- a/scripts/run-udeps.py
+++ b/scripts/run-udeps.py
@@ -5,9 +5,7 @@
 
 from utils import print_errors, print_results
 
-RED = "\033[91m"
 GREEN = "\033[92m"
-BLUE = "\033[94m"
 ENDC = "\033[0m"
 
 

From adb36005a8316080bd228f9ceff4311a62cf0a89 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 14:45:09 -0300
Subject: [PATCH 61/93] Debug metadata on scout-audit

---
 scripts/utils.py | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/scripts/utils.py b/scripts/utils.py
index 0e1acfd0..061271cc 100644
--- a/scripts/utils.py
+++ b/scripts/utils.py
@@ -33,12 +33,14 @@ def parse_json_from_string(console_output):
         return "No JSON found in the console output"
 
 
-def run_subprocess(
-    command: list, cwd: str, capture: bool = True, handle_stderr: bool = True
-) -> Tuple[int, Optional[str], Optional[str]]:
-    result = subprocess.run(command, cwd=cwd, capture_output=capture, text=True)
-    stdout = result.stdout.strip() if capture and result.stdout else None
-    stderr = result.stderr.strip() if handle_stderr and result.stderr else None
+def run_subprocess(command: list, cwd: str):
+    result = subprocess.run(command, cwd=cwd, capture_output=True, text=True)
+    print(f"Running command: {command} in {cwd}")
+    print(f"Return code: {result.returncode}")
+    print(f"stdout: {result.stdout}")
+    print(f"stderr: {result.stderr}")
+    stdout = result.stdout.strip() if result.stdout else None
+    stderr = result.stderr.strip() if result.stderr else None
     return (result.returncode, stdout, stderr)
 
 

From c55d647bbddfaf85f8d75d2e922e8d84dbbc4eac Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 15:20:42 -0300
Subject: [PATCH 62/93] Run tests on nightly 2023-12-16

---
 .github/workflows/test-detectors.yml | 8 +++++---
 scripts/validate-detectors.py        | 1 +
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index e4e9a14f..0ac5d68b 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -61,10 +61,10 @@ jobs:
         run: rustup update
 
       - name: Install Rust nightly
-        run: rustup install nightly --profile minimal
+        run: rustup install nightly-2023-12-16 --profile minimal
 
       - name: Install dylint, dylint-link and cargo-scout-audit
-        run: cargo +nightly install cargo-dylint dylint-link cargo-scout-audit
+        run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
 
       - name: Determine build status and write to file
         run: echo "${{ job.status }}" > status-${{ matrix.os }}.txt
@@ -87,7 +87,9 @@ jobs:
 
       - id: set-matrix
         working-directory: test-cases
-        run: echo "matrix=$(find . -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')" >> $GITHUB_OUTPUT
+        run: |
+          matrix=$(find . -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')
+          echo "matrix=$matrix" >> $GITHUB_OUTPUT
 
   test:
     name: Test detector
diff --git a/scripts/validate-detectors.py b/scripts/validate-detectors.py
index df858353..16f7de34 100644
--- a/scripts/validate-detectors.py
+++ b/scripts/validate-detectors.py
@@ -95,6 +95,7 @@ def validate_detectors(base_path):
         if detector == "README.md" or not os.path.isdir(detector_path):
             continue
 
+        print(f"Validating {detector}...")
         all_errors.extend(check_for_extra_files(detector_path))
         examples = [
             e

From c95eb0ea6643030bd863de7ac5ff6e350b4abbeb Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 15:28:06 -0300
Subject: [PATCH 63/93] Default to nightly

---
 .github/workflows/test-detectors.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 0ac5d68b..c487668b 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -119,6 +119,9 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
+      - name: Default to nightly toolchain
+        run: rustup default nightly-2023-12-16
+
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 

From bd44c1a48b14de91fa6c0ce725529a0581305892 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Agust=C3=ADn=20Losiggio?= <arlosiggio@gmail.com>
Date: Tue, 9 Apr 2024 16:48:31 -0300
Subject: [PATCH 64/93] run only the tests on nightly-2023-12-16

---
 .github/workflows/test-detectors.yml | 3 ---
 scripts/run-tests.py                 | 4 ++--
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index c487668b..0ac5d68b 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -119,9 +119,6 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Default to nightly toolchain
-        run: rustup default nightly-2023-12-16
-
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 9296a4cf..b7237160 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -44,7 +44,7 @@ def run_unit_tests(root):
 def run_integration_tests(detector, root):
     start_time = time.time()
     returncode, stdout, _ = run_subprocess(
-        ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
+        ["cargo", "+nightly-2023-12-16", "scout-audit", "--filter", detector, "--metadata"], root
     )
 
     if stdout is None:
@@ -63,7 +63,7 @@ def run_integration_tests(detector, root):
     short_message = detector_metadata.get(detector_key, {}).get("short_message")
 
     returncode, _, stderr = run_subprocess(
-        ["cargo", "scout-audit", "--filter", detector], root
+        ["cargo", "+nightly-2023-12-16", "scout-audit", "--filter", detector], root
     )
 
     should_lint = root.endswith("vulnerable-example")

From c9a26cfa4b77ad31d55d50ecbbfca9ca61591a8a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Agust=C3=ADn=20Losiggio?= <arlosiggio@gmail.com>
Date: Tue, 9 Apr 2024 17:14:40 -0300
Subject: [PATCH 65/93] add nightly toolchain

---
 .github/workflows/test-detectors.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 0ac5d68b..6719e3a1 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -113,6 +113,9 @@ jobs:
         with:
           python-version: "3.9"
 
+      - name: Install Rust nightly
+        run: rustup install nightly-2023-12-16 --profile minimal
+
       - name: Cache cargo dependencies
         uses: actions/cache@v4
         with:

From 198e7024572d0e6983844ecde4d571d5035f96fd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Agust=C3=ADn=20Losiggio?= <arlosiggio@gmail.com>
Date: Tue, 9 Apr 2024 17:24:57 -0300
Subject: [PATCH 66/93] test

---
 scripts/run-tests.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index b7237160..9296a4cf 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -44,7 +44,7 @@ def run_unit_tests(root):
 def run_integration_tests(detector, root):
     start_time = time.time()
     returncode, stdout, _ = run_subprocess(
-        ["cargo", "+nightly-2023-12-16", "scout-audit", "--filter", detector, "--metadata"], root
+        ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
     )
 
     if stdout is None:
@@ -63,7 +63,7 @@ def run_integration_tests(detector, root):
     short_message = detector_metadata.get(detector_key, {}).get("short_message")
 
     returncode, _, stderr = run_subprocess(
-        ["cargo", "+nightly-2023-12-16", "scout-audit", "--filter", detector], root
+        ["cargo", "scout-audit", "--filter", detector], root
     )
 
     should_lint = root.endswith("vulnerable-example")

From dfe171cb25e8c5c8e1256d5bf5030f2f561606b0 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 17:40:20 -0300
Subject: [PATCH 67/93] Test cache

---
 .github/workflows/test-detectors.yml | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 6719e3a1..0ac5d68b 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -113,9 +113,6 @@ jobs:
         with:
           python-version: "3.9"
 
-      - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16 --profile minimal
-
       - name: Cache cargo dependencies
         uses: actions/cache@v4
         with:

From 25b3ed3d0d4657df0421ca14dbae387500c8a3ff Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 18:12:16 -0300
Subject: [PATCH 68/93] Test

---
 .github/workflows/test-detectors.yml | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 0ac5d68b..c4cbcf35 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -119,6 +119,12 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
+      - name: Install Rust nightly
+        run: rustup install nightly-2023-12-16 --profile minimal
+
+      - name: Install dylint, dylint-link and cargo-scout-audit
+        run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
+
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 

From 1f4c277ab460fcadb5f29122c8231b9f739f65f5 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 18:16:31 -0300
Subject: [PATCH 69/93] Test without minimal

---
 .github/workflows/test-detectors.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index c4cbcf35..3f2e232b 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -61,7 +61,7 @@ jobs:
         run: rustup update
 
       - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16 --profile minimal
+        run: rustup install nightly-2023-12-16
 
       - name: Install dylint, dylint-link and cargo-scout-audit
         run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
@@ -120,7 +120,7 @@ jobs:
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
       - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16 --profile minimal
+        run: rustup install nightly-2023-12-16
 
       - name: Install dylint, dylint-link and cargo-scout-audit
         run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit

From a4d8601810965624f57f6b5ff4f69ce03ab57ffd Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 18:27:06 -0300
Subject: [PATCH 70/93] Do cargo build

---
 .github/workflows/test-detectors.yml | 6 ------
 scripts/run-tests.py                 | 6 ++++++
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 3f2e232b..447bc042 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -119,12 +119,6 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16
-
-      - name: Install dylint, dylint-link and cargo-scout-audit
-        run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
-
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 9296a4cf..1b80fe42 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -43,6 +43,12 @@ def run_unit_tests(root):
 
 def run_integration_tests(detector, root):
     start_time = time.time()
+
+    returncode, stdout, stderr = run_subprocess(["cargo", "build"], root)
+    print("Build returncode:", returncode)
+    print("Build stdout:", stdout)
+    print("Build stderr:", stderr)
+
     returncode, stdout, _ = run_subprocess(
         ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
     )

From b475b36fcd881d07aedd75083a2565695aba7359 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 18:47:49 -0300
Subject: [PATCH 71/93] Find librustc_driver

---
 .github/workflows/test-detectors.yml    |   5 +
 Makefile                                |  23 ++++-
 detectors/Cargo.toml                    |   5 +-
 detectors/test-unsafe-unwrap/Cargo.toml |  16 ++++
 detectors/test-unsafe-unwrap/src/lib.rs | 116 ++++++++++++++++++++++++
 scripts/run-tests.py                    |   5 -
 6 files changed, 158 insertions(+), 12 deletions(-)
 create mode 100644 detectors/test-unsafe-unwrap/Cargo.toml
 create mode 100644 detectors/test-unsafe-unwrap/src/lib.rs

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 447bc042..e2697ced 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -119,6 +119,11 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
+      - name: Find librustc_driver-*.so
+        id: find-librustc_driver
+        run: |
+          find / -name "librustc_driver-*.so" | head -n 1
+
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 
diff --git a/Makefile b/Makefile
index a838e462..415c915a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,19 +1,32 @@
+.PHONY: ci fmt-rust lint test ci-no-test
+
 ci: fmt-rust lint test
-ci-no-test: fmt-rust lint
 
 fmt-rust:
 	@echo "Formatting Rust code..."
-	@python3 scripts/run-fmt.py
+	@for dir in test-cases/*; do \
+		if [ -d "$$dir" ]; then \
+			echo "Formatting $$dir..."; \
+			python3 scripts/run-fmt.py --dir $$dir; \
+		fi; \
+	done
 
 lint:
 	@echo "Linting detectors and test-cases..."
-	@python3 scripts/run-clippy.py
+	@for dir in test-cases/*; do \
+		if [ -d "$$dir" ]; then \
+			echo "Linting $$dir..."; \
+			python3 scripts/run-clippy.py --dir $$dir; \
+		fi; \
+	done
 
 test:
-	@echo "Generating test matrix and running tests..."
+	@echo "Running tests..."
 	@for detector in test-cases/*; do \
 		if [ -d "$$detector" ]; then \
 			detector_name=$$(basename $$detector); \
 			python3 scripts/run-tests.py --detector=$$detector_name; \
-		fi \
+		fi; \
 	done
+
+ci-no-test: fmt-rust lint
diff --git a/detectors/Cargo.toml b/detectors/Cargo.toml
index 8a1e925d..50303457 100644
--- a/detectors/Cargo.toml
+++ b/detectors/Cargo.toml
@@ -1,10 +1,11 @@
 [workspace]
 members = ["*"]
-exclude = [".cargo", "target"]
+exclude = [".cargo", "target",  "test", "test-unsafe-unwrap"]
 resolver = "2"
 
 [workspace.dependencies]
-dylint_linting = { package = "scout-audit-dylint-linting", version = "3.0.0" }
+dylint_linting = { version = "3.0.0", package = "scout-audit-dylint-linting"}
 if_chain = "1.0.2"
 
 scout-audit-clippy-utils = { version = "=0.2.3" }
+
diff --git a/detectors/test-unsafe-unwrap/Cargo.toml b/detectors/test-unsafe-unwrap/Cargo.toml
new file mode 100644
index 00000000..ec5e3065
--- /dev/null
+++ b/detectors/test-unsafe-unwrap/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "unsafe-unwrap-test"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+dylint_linting = { workspace = true }
+if_chain = { workspace = true }
+
+scout-audit-internal = { workspace = true }
+
+[package.metadata.rust-analyzer]
+rustc_private = true
diff --git a/detectors/test-unsafe-unwrap/src/lib.rs b/detectors/test-unsafe-unwrap/src/lib.rs
new file mode 100644
index 00000000..ed7e5952
--- /dev/null
+++ b/detectors/test-unsafe-unwrap/src/lib.rs
@@ -0,0 +1,116 @@
+#![feature(rustc_private)]
+
+extern crate rustc_ast;
+extern crate rustc_hir;
+extern crate rustc_span;
+
+use rustc_hir::{
+    def_id::LocalDefId,
+    intravisit::{walk_expr, FnKind, Visitor},
+    Body, Expr, ExprKind, FnDecl, HirId,
+};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_span::{sym, Span, Symbol};
+use scout_audit_internal::{DetectorImpl, SorobanDetector as Detector};
+
+dylint_linting::declare_late_lint! {
+    /// ### What it does
+    /// Checks for usage of `unwrap`
+    ///
+    /// ### Why is this bad?
+    /// `unwrap` might panic if the result value is an error or `None`.
+    ///
+    /// ### Example
+    /// ```rust
+    /// // example code where a warning is issued
+    /// fn main() {
+    ///    let result = result_fn().unwrap("error");
+    /// }
+    ///
+    /// fn result_fn() -> Result<u8, Error> {
+    ///     Err(Error::new(ErrorKind::Other, "error"))
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```rust
+    /// // example code that does not raise a warning
+    /// fn main() {
+    ///    let result = if let Ok(result) = result_fn() {
+    ///       result
+    ///   }
+    /// }
+    ///
+    /// fn result_fn() -> Result<u8, Error> {
+    ///     Err(Error::new(ErrorKind::Other, "error"))
+    /// }
+    /// ```
+    pub UNSAFE_UNWRAP,
+    Warn,
+    ""
+}
+
+struct UnsafeUnwrapVisitor<'a, 'tcx> {
+    cx: &'a LateContext<'tcx>,
+    checked_exprs: Vec<HirId>,
+    unwrap_spans: Vec<Span>,
+}
+
+impl<'tcx> LateLintPass<'tcx> for UnsafeUnwrap {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        _: FnKind<'tcx>,
+        _: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        span: Span,
+        _: LocalDefId,
+    ) {
+        if span.from_expansion() {
+            return;
+        }
+
+        let asd = cx.tcx.all_diagnostic_items(());
+        println!("diag items {:?}", asd);
+
+        impl<'a, 'tcx> Visitor<'tcx> for UnsafeUnwrapVisitor<'a, 'tcx> {
+            fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
+                if let ExprKind::If(condition, block, _) = &expr.kind {
+                    if let ExprKind::MethodCall(path_segment, args, _, _) =
+                        &condition.peel_drop_temps().kind
+                    {
+                        if path_segment.ident.name == Symbol::intern("is_err") {
+                            if let ExprKind::Block(block, _) = block.kind {
+
+                            }
+                        }
+                    }
+                }
+                if let ExprKind::MethodCall(path_segment, receiver, _, _) = &expr.kind {
+                    if path_segment.ident.name == sym::unwrap
+                        && !self.checked_exprs.contains(&receiver.hir_id)
+                    {
+                        self.unwrap_spans.push(expr.span);
+                    }
+                }
+                walk_expr(self, expr);
+            }
+        }
+
+        let mut visitor = UnsafeUnwrapVisitor {
+            cx,
+            unwrap_spans: Vec::new(),
+            checked_exprs: Vec::new(),
+        };
+
+        walk_expr(&mut visitor, body.value);
+
+        visitor.unwrap_spans.iter().for_each(|span| {
+            Detector::UnsafeUnwrap.span_lint_and_help(
+                cx,
+                UNSAFE_UNWRAP,
+                *span,
+                "Please, use a custom error instead of `unwrap`",
+            );
+        });
+    }
+}
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 1b80fe42..33291f54 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -44,11 +44,6 @@ def run_unit_tests(root):
 def run_integration_tests(detector, root):
     start_time = time.time()
 
-    returncode, stdout, stderr = run_subprocess(["cargo", "build"], root)
-    print("Build returncode:", returncode)
-    print("Build stdout:", stdout)
-    print("Build stderr:", stderr)
-
     returncode, stdout, _ = run_subprocess(
         ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
     )

From 0d53e32fa299530c5ccc1e0a38ada0297f8d1ac1 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 18:49:27 -0300
Subject: [PATCH 72/93] Revert "Find librustc_driver"

This reverts commit b475b36fcd881d07aedd75083a2565695aba7359.
---
 .github/workflows/test-detectors.yml    |   5 -
 Makefile                                |  23 +----
 detectors/Cargo.toml                    |   5 +-
 detectors/test-unsafe-unwrap/Cargo.toml |  16 ----
 detectors/test-unsafe-unwrap/src/lib.rs | 116 ------------------------
 scripts/run-tests.py                    |   5 +
 6 files changed, 12 insertions(+), 158 deletions(-)
 delete mode 100644 detectors/test-unsafe-unwrap/Cargo.toml
 delete mode 100644 detectors/test-unsafe-unwrap/src/lib.rs

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index e2697ced..447bc042 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -119,11 +119,6 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Find librustc_driver-*.so
-        id: find-librustc_driver
-        run: |
-          find / -name "librustc_driver-*.so" | head -n 1
-
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 
diff --git a/Makefile b/Makefile
index 415c915a..a838e462 100644
--- a/Makefile
+++ b/Makefile
@@ -1,32 +1,19 @@
-.PHONY: ci fmt-rust lint test ci-no-test
-
 ci: fmt-rust lint test
+ci-no-test: fmt-rust lint
 
 fmt-rust:
 	@echo "Formatting Rust code..."
-	@for dir in test-cases/*; do \
-		if [ -d "$$dir" ]; then \
-			echo "Formatting $$dir..."; \
-			python3 scripts/run-fmt.py --dir $$dir; \
-		fi; \
-	done
+	@python3 scripts/run-fmt.py
 
 lint:
 	@echo "Linting detectors and test-cases..."
-	@for dir in test-cases/*; do \
-		if [ -d "$$dir" ]; then \
-			echo "Linting $$dir..."; \
-			python3 scripts/run-clippy.py --dir $$dir; \
-		fi; \
-	done
+	@python3 scripts/run-clippy.py
 
 test:
-	@echo "Running tests..."
+	@echo "Generating test matrix and running tests..."
 	@for detector in test-cases/*; do \
 		if [ -d "$$detector" ]; then \
 			detector_name=$$(basename $$detector); \
 			python3 scripts/run-tests.py --detector=$$detector_name; \
-		fi; \
+		fi \
 	done
-
-ci-no-test: fmt-rust lint
diff --git a/detectors/Cargo.toml b/detectors/Cargo.toml
index 50303457..8a1e925d 100644
--- a/detectors/Cargo.toml
+++ b/detectors/Cargo.toml
@@ -1,11 +1,10 @@
 [workspace]
 members = ["*"]
-exclude = [".cargo", "target",  "test", "test-unsafe-unwrap"]
+exclude = [".cargo", "target"]
 resolver = "2"
 
 [workspace.dependencies]
-dylint_linting = { version = "3.0.0", package = "scout-audit-dylint-linting"}
+dylint_linting = { package = "scout-audit-dylint-linting", version = "3.0.0" }
 if_chain = "1.0.2"
 
 scout-audit-clippy-utils = { version = "=0.2.3" }
-
diff --git a/detectors/test-unsafe-unwrap/Cargo.toml b/detectors/test-unsafe-unwrap/Cargo.toml
deleted file mode 100644
index ec5e3065..00000000
--- a/detectors/test-unsafe-unwrap/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "unsafe-unwrap-test"
-version = "0.1.0"
-edition = "2021"
-
-[lib]
-crate-type = ["cdylib"]
-
-[dependencies]
-dylint_linting = { workspace = true }
-if_chain = { workspace = true }
-
-scout-audit-internal = { workspace = true }
-
-[package.metadata.rust-analyzer]
-rustc_private = true
diff --git a/detectors/test-unsafe-unwrap/src/lib.rs b/detectors/test-unsafe-unwrap/src/lib.rs
deleted file mode 100644
index ed7e5952..00000000
--- a/detectors/test-unsafe-unwrap/src/lib.rs
+++ /dev/null
@@ -1,116 +0,0 @@
-#![feature(rustc_private)]
-
-extern crate rustc_ast;
-extern crate rustc_hir;
-extern crate rustc_span;
-
-use rustc_hir::{
-    def_id::LocalDefId,
-    intravisit::{walk_expr, FnKind, Visitor},
-    Body, Expr, ExprKind, FnDecl, HirId,
-};
-use rustc_lint::{LateContext, LateLintPass};
-use rustc_span::{sym, Span, Symbol};
-use scout_audit_internal::{DetectorImpl, SorobanDetector as Detector};
-
-dylint_linting::declare_late_lint! {
-    /// ### What it does
-    /// Checks for usage of `unwrap`
-    ///
-    /// ### Why is this bad?
-    /// `unwrap` might panic if the result value is an error or `None`.
-    ///
-    /// ### Example
-    /// ```rust
-    /// // example code where a warning is issued
-    /// fn main() {
-    ///    let result = result_fn().unwrap("error");
-    /// }
-    ///
-    /// fn result_fn() -> Result<u8, Error> {
-    ///     Err(Error::new(ErrorKind::Other, "error"))
-    /// }
-    /// ```
-    /// Use instead:
-    /// ```rust
-    /// // example code that does not raise a warning
-    /// fn main() {
-    ///    let result = if let Ok(result) = result_fn() {
-    ///       result
-    ///   }
-    /// }
-    ///
-    /// fn result_fn() -> Result<u8, Error> {
-    ///     Err(Error::new(ErrorKind::Other, "error"))
-    /// }
-    /// ```
-    pub UNSAFE_UNWRAP,
-    Warn,
-    ""
-}
-
-struct UnsafeUnwrapVisitor<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    checked_exprs: Vec<HirId>,
-    unwrap_spans: Vec<Span>,
-}
-
-impl<'tcx> LateLintPass<'tcx> for UnsafeUnwrap {
-    fn check_fn(
-        &mut self,
-        cx: &LateContext<'tcx>,
-        _: FnKind<'tcx>,
-        _: &'tcx FnDecl<'tcx>,
-        body: &'tcx Body<'tcx>,
-        span: Span,
-        _: LocalDefId,
-    ) {
-        if span.from_expansion() {
-            return;
-        }
-
-        let asd = cx.tcx.all_diagnostic_items(());
-        println!("diag items {:?}", asd);
-
-        impl<'a, 'tcx> Visitor<'tcx> for UnsafeUnwrapVisitor<'a, 'tcx> {
-            fn visit_expr(&mut self, expr: &'tcx Expr<'_>) {
-                if let ExprKind::If(condition, block, _) = &expr.kind {
-                    if let ExprKind::MethodCall(path_segment, args, _, _) =
-                        &condition.peel_drop_temps().kind
-                    {
-                        if path_segment.ident.name == Symbol::intern("is_err") {
-                            if let ExprKind::Block(block, _) = block.kind {
-
-                            }
-                        }
-                    }
-                }
-                if let ExprKind::MethodCall(path_segment, receiver, _, _) = &expr.kind {
-                    if path_segment.ident.name == sym::unwrap
-                        && !self.checked_exprs.contains(&receiver.hir_id)
-                    {
-                        self.unwrap_spans.push(expr.span);
-                    }
-                }
-                walk_expr(self, expr);
-            }
-        }
-
-        let mut visitor = UnsafeUnwrapVisitor {
-            cx,
-            unwrap_spans: Vec::new(),
-            checked_exprs: Vec::new(),
-        };
-
-        walk_expr(&mut visitor, body.value);
-
-        visitor.unwrap_spans.iter().for_each(|span| {
-            Detector::UnsafeUnwrap.span_lint_and_help(
-                cx,
-                UNSAFE_UNWRAP,
-                *span,
-                "Please, use a custom error instead of `unwrap`",
-            );
-        });
-    }
-}
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 33291f54..1b80fe42 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -44,6 +44,11 @@ def run_unit_tests(root):
 def run_integration_tests(detector, root):
     start_time = time.time()
 
+    returncode, stdout, stderr = run_subprocess(["cargo", "build"], root)
+    print("Build returncode:", returncode)
+    print("Build stdout:", stdout)
+    print("Build stderr:", stderr)
+
     returncode, stdout, _ = run_subprocess(
         ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
     )

From a2a43ee8300cfb34ea8f0b69070125fae92cb59b Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Tue, 9 Apr 2024 18:51:57 -0300
Subject: [PATCH 73/93] Find lib rustc driver

---
 .github/workflows/test-detectors.yml | 5 +++++
 scripts/run-tests.py                 | 5 -----
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 447bc042..e2697ced 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -119,6 +119,11 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
+      - name: Find librustc_driver-*.so
+        id: find-librustc_driver
+        run: |
+          find / -name "librustc_driver-*.so" | head -n 1
+
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 1b80fe42..33291f54 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -44,11 +44,6 @@ def run_unit_tests(root):
 def run_integration_tests(detector, root):
     start_time = time.time()
 
-    returncode, stdout, stderr = run_subprocess(["cargo", "build"], root)
-    print("Build returncode:", returncode)
-    print("Build stdout:", stdout)
-    print("Build stderr:", stderr)
-
     returncode, stdout, _ = run_subprocess(
         ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
     )

From 927b7e0dee58feb2ea9d42f308582d877523c139 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 10:07:15 -0300
Subject: [PATCH 74/93] Update makefile

---
 Makefile | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/Makefile b/Makefile
index a838e462..98d90f99 100644
--- a/Makefile
+++ b/Makefile
@@ -1,19 +1,30 @@
 ci: fmt-rust lint test
 ci-no-test: fmt-rust lint
-
 fmt-rust:
 	@echo "Formatting Rust code..."
-	@python3 scripts/run-fmt.py
+	@for dir in test-cases/*; do \
+		if [ -d "$$dir" ]; then \
+			echo "Formatting $$dir..."; \
+			python3 scripts/run-fmt.py --dir $$dir; \
+		fi; \
+	done
 
 lint:
 	@echo "Linting detectors and test-cases..."
-	@python3 scripts/run-clippy.py
+	@for dir in test-cases/*; do \
+		if [ -d "$$dir" ]; then \
+			echo "Linting $$dir..."; \
+			python3 scripts/run-clippy.py --dir $$dir; \
+		fi; \
+	done
 
 test:
-	@echo "Generating test matrix and running tests..."
+	@echo "Running tests..."
 	@for detector in test-cases/*; do \
 		if [ -d "$$detector" ]; then \
 			detector_name=$$(basename $$detector); \
 			python3 scripts/run-tests.py --detector=$$detector_name; \
-		fi \
+		fi; \
 	done
+
+

From 0bd8fdebf909322ac4bbda6f5d7ce8507581920d Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 10:32:50 -0300
Subject: [PATCH 75/93] Run with localdetectors

---
 scripts/run-tests.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 33291f54..d31d9cab 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -64,7 +64,15 @@ def run_integration_tests(detector, root):
     short_message = detector_metadata.get(detector_key, {}).get("short_message")
 
     returncode, _, stderr = run_subprocess(
-        ["cargo", "scout-audit", "--filter", detector], root
+        [
+            "cargo",
+            "scout-audit",
+            "--filter",
+            detector,
+            "--local-detectors",
+            "../detectors",
+        ],
+        root,
     )
 
     should_lint = root.endswith("vulnerable-example")

From 7d587950cc925610166f83df41635b3c4fa49bc6 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 10:34:08 -0300
Subject: [PATCH 76/93] Run on local detectors

---
 scripts/run-tests.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index d31d9cab..7ddde29f 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -45,7 +45,16 @@ def run_integration_tests(detector, root):
     start_time = time.time()
 
     returncode, stdout, _ = run_subprocess(
-        ["cargo", "scout-audit", "--filter", detector, "--metadata"], root
+        [
+            "cargo",
+            "scout-audit",
+            "--filter",
+            detector,
+            "--metadata",
+            "--local-detectors",
+            "../detectors",
+        ],
+        root,
     )
 
     if stdout is None:

From ca7934612c58bb408d19a932e741caff8370d1de Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 10:49:32 -0300
Subject: [PATCH 77/93] Remove find *.so

---
 .github/workflows/test-detectors.yml | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index e2697ced..447bc042 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -119,11 +119,6 @@ jobs:
           path: ~/.cargo
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Find librustc_driver-*.so
-        id: find-librustc_driver
-        run: |
-          find / -name "librustc_driver-*.so" | head -n 1
-
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 

From 7f11566dcacb4535c7e7a58dca9567bd76cdc774 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 14:26:35 -0300
Subject: [PATCH 78/93] Try fix local detectors flag

---
 scripts/run-tests.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 7ddde29f..9a43f5e0 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -52,7 +52,7 @@ def run_integration_tests(detector, root):
             detector,
             "--metadata",
             "--local-detectors",
-            "../detectors",
+            os.path.join("detectors"),
         ],
         root,
     )
@@ -79,7 +79,7 @@ def run_integration_tests(detector, root):
             "--filter",
             detector,
             "--local-detectors",
-            "../detectors",
+            os.path.join("detectors"),
         ],
         root,
     )

From 739900e087f46dd97feeb4c1a7ce31b220b7922e Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 14:30:04 -0300
Subject: [PATCH 79/93] Test new cache action

---
 .github/workflows/test-detectors.yml | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 447bc042..58442c84 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -51,11 +51,10 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
-      - name: Cache cargo dependencies
-        uses: actions/cache@v4
+      - name: Cache Rust dependencies
+        uses: Swatinem/rust-cache@v2
         with:
-          path: ~/.cargo
-          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
+          cache-targets: false
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -113,11 +112,10 @@ jobs:
         with:
           python-version: "3.9"
 
-      - name: Cache cargo dependencies
-        uses: actions/cache@v4
+      - name: Cache Rust dependencies
+        uses: Swatinem/rust-cache@v2
         with:
-          path: ~/.cargo
-          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
+          cache-targets: false
 
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}

From 7c55a237da2851aecb353701b2ba751b33e537e5 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 15:02:20 -0300
Subject: [PATCH 80/93] Test new cache strategy

---
 .github/workflows/test-detectors.yml | 24 +++++++++++++++++-------
 1 file changed, 17 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 58442c84..d13d5756 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -51,10 +51,13 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v4
 
-      - name: Cache Rust dependencies
-        uses: Swatinem/rust-cache@v2
+      - name: Cache cargo dependencies and tool versions
+        uses: actions/cache@v4
         with:
-          cache-targets: false
+          path: |
+            ~/.cargo
+            versions.txt
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock', 'versions.txt') }}
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -63,7 +66,11 @@ jobs:
         run: rustup install nightly-2023-12-16
 
       - name: Install dylint, dylint-link and cargo-scout-audit
-        run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
+        run: |
+          cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
+          cargo +nightly-2023-12-16 dylint --version > versions.txt
+          cargo +nightly-2023-12-16 dylint-link --version >> versions.txt
+          cargo +nightly-2023-12-16 scout-audit --version >> versions.txt
 
       - name: Determine build status and write to file
         run: echo "${{ job.status }}" > status-${{ matrix.os }}.txt
@@ -112,10 +119,13 @@ jobs:
         with:
           python-version: "3.9"
 
-      - name: Cache Rust dependencies
-        uses: Swatinem/rust-cache@v2
+      - name: Cache cargo dependencies and tool versions
+        uses: actions/cache@v4
         with:
-          cache-targets: false
+          path: |
+            ~/.cargo
+            versions.txt
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock', 'versions.txt') }}
 
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}

From 2e03bf3f9c789ae740758ee87351dfceabcf8134 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 15:25:08 -0300
Subject: [PATCH 81/93] Cache

---
 .github/workflows/test-detectors.yml | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index d13d5756..dd090fa7 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -56,8 +56,9 @@ jobs:
         with:
           path: |
             ~/.cargo
-            versions.txt
-          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock', 'versions.txt') }}
+            checksum.txt
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-tests-
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -66,11 +67,7 @@ jobs:
         run: rustup install nightly-2023-12-16
 
       - name: Install dylint, dylint-link and cargo-scout-audit
-        run: |
-          cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
-          cargo +nightly-2023-12-16 dylint --version > versions.txt
-          cargo +nightly-2023-12-16 dylint-link --version >> versions.txt
-          cargo +nightly-2023-12-16 scout-audit --version >> versions.txt
+        run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
 
       - name: Determine build status and write to file
         run: echo "${{ job.status }}" > status-${{ matrix.os }}.txt
@@ -122,10 +119,9 @@ jobs:
       - name: Cache cargo dependencies and tool versions
         uses: actions/cache@v4
         with:
-          path: |
-            ~/.cargo
-            versions.txt
-          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock', 'versions.txt') }}
+          path: ~/.cargo
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-tests-
 
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}

From 817c9fe4705fcc514e207f5a45c4c2cc6b113209 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 15:46:55 -0300
Subject: [PATCH 82/93] Test rust-actions

---
 .github/workflows/general-rust.yml   | 34 +++++++++++++---------------
 .github/workflows/test-detectors.yml |  5 ++--
 2 files changed, 18 insertions(+), 21 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index b2d21e80..8d8b3fcd 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -29,16 +29,15 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.9"
+          python-version: "3.10"
 
-      - name: Update Rust Toolchain
-        run: rustup update
-
-      - name: Install Rust nightly
-        run: rustup install nightly --profile minimal
-
-      - name: Install rustfmt
-        run: rustup component add rustfmt --toolchain nightly
+      - name: Install rust toolchain and components
+        uses: actions-rs/toolchain@v1
+        with:
+          components: rustfmt
+          default: true
+          profile: minimal
+          toolchain: nightly
 
       - name: Check Format
         run: python scripts/run-fmt.py --dir test-cases detectors
@@ -55,7 +54,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.9"
+          python-version: "3.10"
 
       - name: Cache Rust Dependencies
         uses: actions/cache@v4
@@ -65,18 +64,17 @@ jobs:
             ~/.rustup
           key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Update Rust Toolchain
-        run: rustup update
-
-      - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16 --profile minimal
+      - name: Install rust toolchain and components
+        uses: actions-rs/toolchain@v1
+        with:
+          components: clippy
+          default: true
+          profile: minimal
+          toolchain: nightly-2023-12-16
 
       - name: Install dylint-link
         run: cargo install dylint-link
 
-      - name: Install clippy
-        run: rustup component add clippy --toolchain nightly-2023-12-16
-
       - name: Lint with Clippy
         run: python scripts/run-clippy.py --dir test-cases detectors
 
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index dd090fa7..82aa19ec 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -30,7 +30,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.9"
+          python-version: "3.10"
 
       - name: Install dependencies
         run: pip install fuzzywuzzy
@@ -56,7 +56,6 @@ jobs:
         with:
           path: |
             ~/.cargo
-            checksum.txt
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-tests-
 
@@ -114,7 +113,7 @@ jobs:
       - name: Set up Python
         uses: actions/setup-python@v5
         with:
-          python-version: "3.9"
+          python-version: "3.10"
 
       - name: Cache cargo dependencies and tool versions
         uses: actions/cache@v4

From be08a346a9a0e5972e9772807f2b4616cd581f90 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 16:19:06 -0300
Subject: [PATCH 83/93] Try cache with binaries hash

---
 .github/workflows/general-rust.yml   | 30 +++++++++++++++-------------
 .github/workflows/test-detectors.yml | 14 +++++++------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 8d8b3fcd..5f858716 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -31,13 +31,14 @@ jobs:
         with:
           python-version: "3.10"
 
-      - name: Install rust toolchain and components
-        uses: actions-rs/toolchain@v1
-        with:
-          components: rustfmt
-          default: true
-          profile: minimal
-          toolchain: nightly
+      - name: Update Rust Toolchain
+        run: rustup update
+
+      - name: Install Rust nightly
+        run: rustup install nightly --profile minimal
+
+      - name: Install rustfmt
+        run: rustup component add rustfmt --toolchain nightly
 
       - name: Check Format
         run: python scripts/run-fmt.py --dir test-cases detectors
@@ -64,17 +65,18 @@ jobs:
             ~/.rustup
           key: ${{ runner.os }}-cargo-clippy-${{ hashFiles('**/Cargo.lock') }}
 
-      - name: Install rust toolchain and components
-        uses: actions-rs/toolchain@v1
-        with:
-          components: clippy
-          default: true
-          profile: minimal
-          toolchain: nightly-2023-12-16
+      - name: Update Rust Toolchain
+        run: rustup update
+
+      - name: Install Rust nightly
+        run: rustup install nightly-2023-12-16 --profile minimal
 
       - name: Install dylint-link
         run: cargo install dylint-link
 
+      - name: Install clippy
+        run: rustup component add clippy --toolchain nightly-2023-12-16
+
       - name: Lint with Clippy
         run: python scripts/run-clippy.py --dir test-cases detectors
 
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 82aa19ec..a0b4d243 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -54,10 +54,9 @@ jobs:
       - name: Cache cargo dependencies and tool versions
         uses: actions/cache@v4
         with:
-          path: |
-            ~/.cargo
-          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-tests-
+          path: ~/.cargo
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}-binaries-${{ hashFiles('~/hash.txt') }}
+          restore-keys: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}-
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -68,6 +67,9 @@ jobs:
       - name: Install dylint, dylint-link and cargo-scout-audit
         run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
 
+      - name: Hash binaries
+        run: sha256sum ~/.cargo/bin/* > ~/hash.txt
+
       - name: Determine build status and write to file
         run: echo "${{ job.status }}" > status-${{ matrix.os }}.txt
 
@@ -119,8 +121,8 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cargo
-          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
-          restore-keys: ${{ runner.os }}-tests-
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}-binaries-${{ hashFiles('~/hash.txt') }}
+          restore-keys: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}-
 
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}

From 11fc44b83777ffd2fcde72c11a9243ffb3f9e08f Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 16:53:40 -0300
Subject: [PATCH 84/93] Try fix local-detectors path, remove cache by binaries

---
 .github/workflows/test-detectors.yml | 12 +++++-------
 Makefile                             | 11 ++++-------
 scripts/run-tests.py                 |  4 ++--
 scripts/utils.py                     |  4 ----
 4 files changed, 11 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index a0b4d243..4d131d63 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -55,8 +55,8 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cargo
-          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}-binaries-${{ hashFiles('~/hash.txt') }}
-          restore-keys: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}-
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-tests-
 
       - name: Update Rust Toolchain
         run: rustup update
@@ -67,9 +67,6 @@ jobs:
       - name: Install dylint, dylint-link and cargo-scout-audit
         run: cargo +nightly-2023-12-16 install cargo-dylint dylint-link cargo-scout-audit
 
-      - name: Hash binaries
-        run: sha256sum ~/.cargo/bin/* > ~/hash.txt
-
       - name: Determine build status and write to file
         run: echo "${{ job.status }}" > status-${{ matrix.os }}.txt
 
@@ -93,6 +90,7 @@ jobs:
         working-directory: test-cases
         run: |
           matrix=$(find . -mindepth 1 -maxdepth 1 -type d -exec basename {} \; | jq -R -cs 'split("\n")[:-1]')
+          echo "Matrix: $matrix"
           echo "matrix=$matrix" >> $GITHUB_OUTPUT
 
   test:
@@ -121,8 +119,8 @@ jobs:
         uses: actions/cache@v4
         with:
           path: ~/.cargo
-          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}-binaries-${{ hashFiles('~/hash.txt') }}
-          restore-keys: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}-
+          key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: ${{ runner.os }}-tests-
 
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
diff --git a/Makefile b/Makefile
index 98d90f99..f59878f8 100644
--- a/Makefile
+++ b/Makefile
@@ -1,30 +1,27 @@
 ci: fmt-rust lint test
 ci-no-test: fmt-rust lint
+
 fmt-rust:
-	@echo "Formatting Rust code..."
+	@echo "\nFormatting Rust code..."
 	@for dir in test-cases/*; do \
 		if [ -d "$$dir" ]; then \
-			echo "Formatting $$dir..."; \
 			python3 scripts/run-fmt.py --dir $$dir; \
 		fi; \
 	done
 
 lint:
-	@echo "Linting detectors and test-cases..."
+	@echo "\nLinting detectors and test-cases..."
 	@for dir in test-cases/*; do \
 		if [ -d "$$dir" ]; then \
-			echo "Linting $$dir..."; \
 			python3 scripts/run-clippy.py --dir $$dir; \
 		fi; \
 	done
 
 test:
-	@echo "Running tests..."
+	@echo "\nRunning tests..."
 	@for detector in test-cases/*; do \
 		if [ -d "$$detector" ]; then \
-			detector_name=$$(basename $$detector); \
 			python3 scripts/run-tests.py --detector=$$detector_name; \
 		fi; \
 	done
 
-
diff --git a/scripts/run-tests.py b/scripts/run-tests.py
index 9a43f5e0..8fd11f43 100644
--- a/scripts/run-tests.py
+++ b/scripts/run-tests.py
@@ -52,7 +52,7 @@ def run_integration_tests(detector, root):
             detector,
             "--metadata",
             "--local-detectors",
-            os.path.join("detectors"),
+            os.path.join(os.getcwd(), "detectors"),
         ],
         root,
     )
@@ -79,7 +79,7 @@ def run_integration_tests(detector, root):
             "--filter",
             detector,
             "--local-detectors",
-            os.path.join("detectors"),
+            os.path.join(os.getcwd(), "detectors"),
         ],
         root,
     )
diff --git a/scripts/utils.py b/scripts/utils.py
index 061271cc..25247f87 100644
--- a/scripts/utils.py
+++ b/scripts/utils.py
@@ -35,10 +35,6 @@ def parse_json_from_string(console_output):
 
 def run_subprocess(command: list, cwd: str):
     result = subprocess.run(command, cwd=cwd, capture_output=True, text=True)
-    print(f"Running command: {command} in {cwd}")
-    print(f"Return code: {result.returncode}")
-    print(f"stdout: {result.stdout}")
-    print(f"stderr: {result.stderr}")
     stdout = result.stdout.strip() if result.stdout else None
     stderr = result.stderr.strip() if result.stderr else None
     return (result.returncode, stdout, stderr)

From d2e34fb4fd73af9f4fd56b2cd955a63466727040 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 17:10:06 -0300
Subject: [PATCH 85/93] Print statements to debug

---
 Makefile         | 31 ++++++++++++++++++++++---------
 scripts/utils.py |  4 ++++
 2 files changed, 26 insertions(+), 9 deletions(-)

diff --git a/Makefile b/Makefile
index f59878f8..93dbcf2f 100644
--- a/Makefile
+++ b/Makefile
@@ -1,27 +1,40 @@
-ci: fmt-rust lint test
-ci-no-test: fmt-rust lint
+ci: fmt lint test
+ci-no-test: fmt lint
 
-fmt-rust:
-	@echo "\nFormatting Rust code..."
+fmt:
+	@echo "\nFormatting test cases..."
 	@for dir in test-cases/*; do \
 		if [ -d "$$dir" ]; then \
 			python3 scripts/run-fmt.py --dir $$dir; \
 		fi; \
 	done
+	@echo "\nFormatting detectors..."
+	@for dir in detectors/*; do \
+		if [ -d "$$dir" ]; then \
+			python3 scripts/run-fmt.py --dir $$dir; \
+		fi; \
+	done
+
 
 lint:
-	@echo "\nLinting detectors and test-cases..."
+	@echo "\nLinting test cases..."
 	@for dir in test-cases/*; do \
 		if [ -d "$$dir" ]; then \
 			python3 scripts/run-clippy.py --dir $$dir; \
 		fi; \
 	done
+	@echo "\nLinting detectors..."
+	@for dir in detectors/*; do \
+		if [ -d "$$dir" ]; then \
+			python3 scripts/run-clippy.py --dir $$dir; \
+		fi; \
+	done
 
 test:
-	@echo "\nRunning tests..."
-	@for detector in test-cases/*; do \
-		if [ -d "$$detector" ]; then \
+	@echo "\nRunning tests for test cases..."
+	@for dir in test-cases/*; do \
+		if [ -d "$$dir" ]; then \
+			detector_name=$$(basename "$$dir"); \
 			python3 scripts/run-tests.py --detector=$$detector_name; \
 		fi; \
 	done
-
diff --git a/scripts/utils.py b/scripts/utils.py
index 25247f87..1b7f9077 100644
--- a/scripts/utils.py
+++ b/scripts/utils.py
@@ -37,6 +37,10 @@ def run_subprocess(command: list, cwd: str):
     result = subprocess.run(command, cwd=cwd, capture_output=True, text=True)
     stdout = result.stdout.strip() if result.stdout else None
     stderr = result.stderr.strip() if result.stderr else None
+    print(f"Command: {command}")
+    print(f"Return code: {result.returncode}")
+    print(f"stdout: {stdout}")
+    print(f"stderr: {stderr}")
     return (result.returncode, stdout, stderr)
 
 

From 94f3f822913cc08163a291e240549579f5f9ad82 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Wed, 10 Apr 2024 17:17:07 -0300
Subject: [PATCH 86/93] Debug

---
 .github/workflows/test-detectors.yml | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 4d131d63..472383fc 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -122,6 +122,11 @@ jobs:
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-tests-
 
+      - run: rustup show
+
+      - name: Install Rust nightly
+        run: rustup install nightly-2023-12-16
+
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 

From ad7a667017fa1d37f03f215afeb6fbe9d23740f3 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 11 Apr 2024 09:57:38 -0300
Subject: [PATCH 87/93] Cargo clean on tests, cache rustup on build

---
 .github/workflows/test-detectors.yml | 8 ++++++--
 scripts/run-clippy.py                | 4 ++++
 scripts/utils.py                     | 4 ----
 3 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 472383fc..063d9714 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -54,7 +54,9 @@ jobs:
       - name: Cache cargo dependencies and tool versions
         uses: actions/cache@v4
         with:
-          path: ~/.cargo
+          path: |
+            ~/.cargo
+            ~/.rustup
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-tests-
 
@@ -118,7 +120,9 @@ jobs:
       - name: Cache cargo dependencies and tool versions
         uses: actions/cache@v4
         with:
-          path: ~/.cargo
+          path: |
+            ~/.cargo
+            ~/.rustup
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-tests-
 
diff --git a/scripts/run-clippy.py b/scripts/run-clippy.py
index ddbc08cb..885661cd 100644
--- a/scripts/run-clippy.py
+++ b/scripts/run-clippy.py
@@ -36,6 +36,10 @@ def run_clippy(directories):
                 print_results(
                     returncode, stderr, "clippy", root, time.time() - start_time
                 )
+
+                if root.startswith("test-cases"):
+                    run_subprocess(["cargo", "clean"], cwd=root)
+
                 if returncode != 0:
                     errors.append(root)
 
diff --git a/scripts/utils.py b/scripts/utils.py
index 1b7f9077..25247f87 100644
--- a/scripts/utils.py
+++ b/scripts/utils.py
@@ -37,10 +37,6 @@ def run_subprocess(command: list, cwd: str):
     result = subprocess.run(command, cwd=cwd, capture_output=True, text=True)
     stdout = result.stdout.strip() if result.stdout else None
     stderr = result.stderr.strip() if result.stderr else None
-    print(f"Command: {command}")
-    print(f"Return code: {result.returncode}")
-    print(f"stdout: {stdout}")
-    print(f"stderr: {stderr}")
     return (result.returncode, stdout, stderr)
 
 

From 7388b09f17b12231fb0d16851452bcbcc6dc611b Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 11 Apr 2024 10:34:20 -0300
Subject: [PATCH 88/93] Remove unneeded stuff

---
 .github/workflows/test-detectors.yml | 11 -----------
 1 file changed, 11 deletions(-)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 063d9714..a5f7be4a 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -48,9 +48,6 @@ jobs:
           - macos-latest
     runs-on: ${{ matrix.os }}
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
       - name: Cache cargo dependencies and tool versions
         uses: actions/cache@v4
         with:
@@ -60,9 +57,6 @@ jobs:
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-tests-
 
-      - name: Update Rust Toolchain
-        run: rustup update
-
       - name: Install Rust nightly
         run: rustup install nightly-2023-12-16
 
@@ -126,11 +120,6 @@ jobs:
           key: ${{ runner.os }}-tests-${{ hashFiles('**/Cargo.lock') }}
           restore-keys: ${{ runner.os }}-tests-
 
-      - run: rustup show
-
-      - name: Install Rust nightly
-        run: rustup install nightly-2023-12-16
-
       - name: Run unit and integration tests
         run: python scripts/run-tests.py --detector=${{ matrix.detector }}
 

From fc971b1d6580f8067a0e01e98384d73799ca3c54 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 11 Apr 2024 11:20:10 -0300
Subject: [PATCH 89/93] Delete apps, clippy-utils and scout-internal

---
 apps/cargo-scout-audit/Cargo.lock             | 3275 -----------------
 apps/cargo-scout-audit/Cargo.toml             |   48 -
 apps/cargo-scout-audit/src/detectors.rs       |   90 -
 .../src/detectors/builder.rs                  |  161 -
 .../src/detectors/configuration.rs            |   42 -
 .../src/detectors/library.rs                  |   95 -
 .../src/detectors/source/git.rs               |   64 -
 .../src/detectors/source/mod.rs               |    3 -
 apps/cargo-scout-audit/src/lib.rs             |    3 -
 apps/cargo-scout-audit/src/main.rs            |   11 -
 apps/cargo-scout-audit/src/startup.rs         |  260 --
 apps/cargo-scout-audit/src/utils/cargo.rs     |   51 -
 .../src/utils/cargo_package.rs                |   10 -
 apps/cargo-scout-audit/src/utils/command.rs   |  129 -
 apps/cargo-scout-audit/src/utils/detectors.rs |   60 -
 apps/cargo-scout-audit/src/utils/env.rs       |   31 -
 apps/cargo-scout-audit/src/utils/mod.rs       |    7 -
 apps/cargo-scout-audit/src/utils/output.rs    |  201 -
 apps/cargo-scout-audit/src/utils/rustup.rs    |   23 -
 apps/cargo-scout-audit/tests/README.md        |   39 -
 .../tests/integration_tests/detectors.rs      |  148 -
 .../detectors/configuration.rs                |  111 -
 .../integration_tests/detectors/utils.rs      |   14 -
 .../tests/integration_tests/main.rs           |    1 -
 apps/scout-extension/.eslintrc.cjs            |   31 -
 apps/scout-extension/.gitignore               |    2 -
 apps/scout-extension/.npmrc                   |    1 -
 apps/scout-extension/.prettierignore          |    2 -
 apps/scout-extension/.vscodeignore            |   10 -
 apps/scout-extension/CHANGELOG.md             |    9 -
 apps/scout-extension/LICENSE                  |   21 -
 apps/scout-extension/README.md                |   43 -
 apps/scout-extension/images/icon.png          |  Bin 13073 -> 0 bytes
 apps/scout-extension/package.json             |   58 -
 apps/scout-extension/pnpm-lock.yaml           | 1656 ---------
 apps/scout-extension/src/extension.ts         |   85 -
 apps/scout-extension/src/test/runTest.ts      |   26 -
 .../src/test/suite/extension.test.ts          |   15 -
 apps/scout-extension/src/test/suite/index.ts  |   38 -
 apps/scout-extension/tsconfig.json            |   18 -
 scout-audit-clippy-utils/Cargo.lock           |   46 -
 scout-audit-clippy-utils/Cargo.toml           |   21 -
 scout-audit-clippy-utils/README.md            |    9 -
 scout-audit-clippy-utils/rust-toolchain       |    3 -
 scout-audit-clippy-utils/src/ast_utils.rs     |  786 ----
 .../src/ast_utils/ident_iter.rs               |   45 -
 scout-audit-clippy-utils/src/attrs.rs         |  158 -
 .../src/check_proc_macro.rs                   |  434 ---
 scout-audit-clippy-utils/src/comparisons.rs   |   36 -
 scout-audit-clippy-utils/src/consts.rs        |  733 ----
 scout-audit-clippy-utils/src/diagnostics.rs   |  238 --
 scout-audit-clippy-utils/src/eager_or_lazy.rs |  274 --
 scout-audit-clippy-utils/src/higher.rs        |  469 ---
 scout-audit-clippy-utils/src/hir_utils.rs     | 1158 ------
 scout-audit-clippy-utils/src/lib.rs           | 2915 ---------------
 scout-audit-clippy-utils/src/macros.rs        |  538 ---
 scout-audit-clippy-utils/src/mir/mod.rs       |  195 -
 .../src/mir/possible_borrower.rs              |  243 --
 .../src/mir/possible_origin.rs                |   59 -
 .../src/mir/transitive_relation.rs            |   29 -
 scout-audit-clippy-utils/src/msrvs.rs         |  148 -
 .../src/numeric_literal.rs                    |  247 --
 scout-audit-clippy-utils/src/paths.rs         |  167 -
 scout-audit-clippy-utils/src/ptr.rs           |   52 -
 .../src/qualify_min_const_fn.rs               |  429 ---
 scout-audit-clippy-utils/src/source.rs        |  598 ---
 scout-audit-clippy-utils/src/str_utils.rs     |  325 --
 scout-audit-clippy-utils/src/sugg.rs          | 1111 ------
 scout-audit-clippy-utils/src/sym_helper.rs    |    7 -
 scout-audit-clippy-utils/src/ty.rs            | 1268 -------
 .../src/ty/type_certainty/certainty.rs        |  122 -
 .../src/ty/type_certainty/mod.rs              |  321 --
 scout-audit-clippy-utils/src/usage.rs         |  210 --
 scout-audit-clippy-utils/src/visitors.rs      |  750 ----
 scout-audit-internal/Cargo.toml               |   31 -
 scout-audit-internal/rust-toolchain           |    3 -
 scout-audit-internal/src/detector.rs          |  126 -
 .../src/detector/lint_message.rs              |   19 -
 scout-audit-internal/src/lib.rs               |   11 -
 79 files changed, 21226 deletions(-)
 delete mode 100644 apps/cargo-scout-audit/Cargo.lock
 delete mode 100644 apps/cargo-scout-audit/Cargo.toml
 delete mode 100644 apps/cargo-scout-audit/src/detectors.rs
 delete mode 100644 apps/cargo-scout-audit/src/detectors/builder.rs
 delete mode 100644 apps/cargo-scout-audit/src/detectors/configuration.rs
 delete mode 100644 apps/cargo-scout-audit/src/detectors/library.rs
 delete mode 100644 apps/cargo-scout-audit/src/detectors/source/git.rs
 delete mode 100644 apps/cargo-scout-audit/src/detectors/source/mod.rs
 delete mode 100644 apps/cargo-scout-audit/src/lib.rs
 delete mode 100644 apps/cargo-scout-audit/src/main.rs
 delete mode 100644 apps/cargo-scout-audit/src/startup.rs
 delete mode 100644 apps/cargo-scout-audit/src/utils/cargo.rs
 delete mode 100644 apps/cargo-scout-audit/src/utils/cargo_package.rs
 delete mode 100644 apps/cargo-scout-audit/src/utils/command.rs
 delete mode 100644 apps/cargo-scout-audit/src/utils/detectors.rs
 delete mode 100644 apps/cargo-scout-audit/src/utils/env.rs
 delete mode 100644 apps/cargo-scout-audit/src/utils/mod.rs
 delete mode 100644 apps/cargo-scout-audit/src/utils/output.rs
 delete mode 100644 apps/cargo-scout-audit/src/utils/rustup.rs
 delete mode 100644 apps/cargo-scout-audit/tests/README.md
 delete mode 100644 apps/cargo-scout-audit/tests/integration_tests/detectors.rs
 delete mode 100644 apps/cargo-scout-audit/tests/integration_tests/detectors/configuration.rs
 delete mode 100644 apps/cargo-scout-audit/tests/integration_tests/detectors/utils.rs
 delete mode 100644 apps/cargo-scout-audit/tests/integration_tests/main.rs
 delete mode 100644 apps/scout-extension/.eslintrc.cjs
 delete mode 100644 apps/scout-extension/.gitignore
 delete mode 100644 apps/scout-extension/.npmrc
 delete mode 100644 apps/scout-extension/.prettierignore
 delete mode 100644 apps/scout-extension/.vscodeignore
 delete mode 100644 apps/scout-extension/CHANGELOG.md
 delete mode 100644 apps/scout-extension/LICENSE
 delete mode 100644 apps/scout-extension/README.md
 delete mode 100644 apps/scout-extension/images/icon.png
 delete mode 100644 apps/scout-extension/package.json
 delete mode 100644 apps/scout-extension/pnpm-lock.yaml
 delete mode 100644 apps/scout-extension/src/extension.ts
 delete mode 100644 apps/scout-extension/src/test/runTest.ts
 delete mode 100644 apps/scout-extension/src/test/suite/extension.test.ts
 delete mode 100644 apps/scout-extension/src/test/suite/index.ts
 delete mode 100644 apps/scout-extension/tsconfig.json
 delete mode 100644 scout-audit-clippy-utils/Cargo.lock
 delete mode 100644 scout-audit-clippy-utils/Cargo.toml
 delete mode 100644 scout-audit-clippy-utils/README.md
 delete mode 100644 scout-audit-clippy-utils/rust-toolchain
 delete mode 100644 scout-audit-clippy-utils/src/ast_utils.rs
 delete mode 100644 scout-audit-clippy-utils/src/ast_utils/ident_iter.rs
 delete mode 100644 scout-audit-clippy-utils/src/attrs.rs
 delete mode 100644 scout-audit-clippy-utils/src/check_proc_macro.rs
 delete mode 100644 scout-audit-clippy-utils/src/comparisons.rs
 delete mode 100644 scout-audit-clippy-utils/src/consts.rs
 delete mode 100644 scout-audit-clippy-utils/src/diagnostics.rs
 delete mode 100644 scout-audit-clippy-utils/src/eager_or_lazy.rs
 delete mode 100644 scout-audit-clippy-utils/src/higher.rs
 delete mode 100644 scout-audit-clippy-utils/src/hir_utils.rs
 delete mode 100644 scout-audit-clippy-utils/src/lib.rs
 delete mode 100644 scout-audit-clippy-utils/src/macros.rs
 delete mode 100644 scout-audit-clippy-utils/src/mir/mod.rs
 delete mode 100644 scout-audit-clippy-utils/src/mir/possible_borrower.rs
 delete mode 100644 scout-audit-clippy-utils/src/mir/possible_origin.rs
 delete mode 100644 scout-audit-clippy-utils/src/mir/transitive_relation.rs
 delete mode 100644 scout-audit-clippy-utils/src/msrvs.rs
 delete mode 100644 scout-audit-clippy-utils/src/numeric_literal.rs
 delete mode 100644 scout-audit-clippy-utils/src/paths.rs
 delete mode 100644 scout-audit-clippy-utils/src/ptr.rs
 delete mode 100644 scout-audit-clippy-utils/src/qualify_min_const_fn.rs
 delete mode 100644 scout-audit-clippy-utils/src/source.rs
 delete mode 100644 scout-audit-clippy-utils/src/str_utils.rs
 delete mode 100644 scout-audit-clippy-utils/src/sugg.rs
 delete mode 100644 scout-audit-clippy-utils/src/sym_helper.rs
 delete mode 100644 scout-audit-clippy-utils/src/ty.rs
 delete mode 100644 scout-audit-clippy-utils/src/ty/type_certainty/certainty.rs
 delete mode 100644 scout-audit-clippy-utils/src/ty/type_certainty/mod.rs
 delete mode 100644 scout-audit-clippy-utils/src/usage.rs
 delete mode 100644 scout-audit-clippy-utils/src/visitors.rs
 delete mode 100644 scout-audit-internal/Cargo.toml
 delete mode 100644 scout-audit-internal/rust-toolchain
 delete mode 100644 scout-audit-internal/src/detector.rs
 delete mode 100644 scout-audit-internal/src/detector/lint_message.rs
 delete mode 100644 scout-audit-internal/src/lib.rs

diff --git a/apps/cargo-scout-audit/Cargo.lock b/apps/cargo-scout-audit/Cargo.lock
deleted file mode 100644
index cf8e213b..00000000
--- a/apps/cargo-scout-audit/Cargo.lock
+++ /dev/null
@@ -1,3275 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "adler"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
-
-[[package]]
-name = "ahash"
-version = "0.7.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
-dependencies = [
- "getrandom",
- "once_cell",
- "version_check",
-]
-
-[[package]]
-name = "ahash"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
-dependencies = [
- "cfg-if",
- "getrandom",
- "once_cell",
- "version_check",
-]
-
-[[package]]
-name = "aho-corasick"
-version = "1.0.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c378d78423fdad8089616f827526ee33c19f2fddbd5de1629152c9593ba4783"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "ansi_term"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d52a9bb7ec0cf484c551830a7ce27bd20d67eac647e1befb56b0be4ee39a55d2"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "anstream"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1f58811cfac344940f1a400b6e6231ce35171f614f26439e80f8c1465c5cc0c"
-dependencies = [
- "anstyle",
- "anstyle-parse",
- "anstyle-query",
- "anstyle-wincon",
- "colorchoice",
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15c4c2c83f81532e5845a733998b6971faca23490340a418e9b72a3ec9de12ea"
-
-[[package]]
-name = "anstyle-parse"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "938874ff5980b03a87c5524b3ae5b59cf99b1d6bc836848df7bc5ada9643c333"
-dependencies = [
- "utf8parse",
-]
-
-[[package]]
-name = "anstyle-query"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ca11d4be1bab0c8bc8734a9aa7bf4ee8316d462a08c6ac5052f888fef5b494b"
-dependencies = [
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "anstyle-wincon"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "58f54d10c6dfa51283a066ceab3ec1ab78d13fae00aa49243a45e4571fb79dfd"
-dependencies = [
- "anstyle",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "anyhow"
-version = "1.0.75"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
-
-[[package]]
-name = "arc-swap"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6"
-
-[[package]]
-name = "arrayvec"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
-
-[[package]]
-name = "async-trait"
-version = "0.1.73"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc00ceb34980c03614e35a3a4e218276a0a824e911d07651cd0d858a51e8c0f0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.31",
-]
-
-[[package]]
-name = "autocfg"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
-
-[[package]]
-name = "base16ct"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf"
-
-[[package]]
-name = "base64"
-version = "0.13.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
-
-[[package]]
-name = "base64"
-version = "0.21.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "414dcefbc63d77c526a76b3afcf6fbb9b5e2791c19c3aa2297733208750c6e53"
-
-[[package]]
-name = "base64ct"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b"
-
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
-[[package]]
-name = "bitflags"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
-
-[[package]]
-name = "bitmaps"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2"
-dependencies = [
- "typenum",
-]
-
-[[package]]
-name = "block-buffer"
-version = "0.10.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
-dependencies = [
- "generic-array",
-]
-
-[[package]]
-name = "bstr"
-version = "1.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c2f7349907b712260e64b0afe2f84692af14a454be26187d9df565c7f69266a"
-dependencies = [
- "memchr",
- "regex-automata",
- "serde",
-]
-
-[[package]]
-name = "btoi"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd6407f73a9b8b6162d8a2ef999fe6afd7cc15902ebf42c5cd296addf17e0ad"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "bumpalo"
-version = "3.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
-
-[[package]]
-name = "bytes"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
-
-[[package]]
-name = "bytesize"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e368af43e418a04d52505cf3dbc23dda4e3407ae2fa99fd0e4f308ce546acc"
-
-[[package]]
-name = "camino"
-version = "1.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c59e92b5a388f549b863a7bea62612c09f24c8393560709a54558a9abdfb3b9c"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "cargo"
-version = "0.72.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "171aca76a3199e771ea0b94ec260984ed9cba62af8e478142974dbaa594d583b"
-dependencies = [
- "anyhow",
- "base64 0.21.3",
- "bytesize",
- "cargo-platform",
- "cargo-util",
- "clap",
- "crates-io",
- "curl",
- "curl-sys",
- "env_logger",
- "filetime",
- "flate2",
- "fwdansi",
- "git2",
- "git2-curl",
- "gix",
- "gix-features",
- "glob",
- "hex",
- "hmac",
- "home",
- "http-auth",
- "humantime",
- "ignore",
- "im-rc",
- "indexmap 1.9.3",
- "is-terminal",
- "itertools 0.10.5",
- "jobserver",
- "lazy_static",
- "lazycell",
- "libc",
- "libgit2-sys",
- "log",
- "memchr",
- "opener",
- "os_info",
- "pasetors",
- "pathdiff",
- "rand",
- "rustfix",
- "semver",
- "serde",
- "serde-value",
- "serde_ignored",
- "serde_json",
- "sha1",
- "shell-escape",
- "strip-ansi-escapes",
- "tar",
- "tempfile",
- "termcolor",
- "time",
- "toml 0.7.7",
- "toml_edit",
- "unicode-width",
- "unicode-xid",
- "url",
- "walkdir",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "cargo-platform"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cfa25e60aea747ec7e1124f238816749faa93759c6ff5b31f1ccdda137f4479"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "cargo-scout-audit"
-version = "0.2.1"
-dependencies = [
- "ansi_term",
- "anyhow",
- "cargo",
- "cargo_metadata",
- "clap",
- "colored",
- "config",
- "dunce",
- "dylint",
- "env_logger",
- "home",
- "itertools 0.11.0",
- "log",
- "regex",
- "scout-audit-internal",
- "serde",
- "serde_json",
- "tempfile",
-]
-
-[[package]]
-name = "cargo-util"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd54c8b94a0c851d687924460637361c355afafa72d973fe8644499fbdee8fae"
-dependencies = [
- "anyhow",
- "core-foundation",
- "filetime",
- "hex",
- "jobserver",
- "libc",
- "log",
- "miow",
- "same-file",
- "sha2",
- "shell-escape",
- "tempfile",
- "walkdir",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "cargo_metadata"
-version = "0.17.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7daec1a2a2129eeba1644b220b4647ec537b0b5d4bfd6876fcc5a540056b592"
-dependencies = [
- "camino",
- "cargo-platform",
- "semver",
- "serde",
- "serde_json",
- "thiserror",
-]
-
-[[package]]
-name = "cc"
-version = "1.0.83"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
-dependencies = [
- "jobserver",
- "libc",
-]
-
-[[package]]
-name = "cfg-if"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
-
-[[package]]
-name = "clap"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a13b88d2c62ff462f88e4a121f17a82c1af05693a2f192b5c38d14de73c19f6"
-dependencies = [
- "clap_builder",
- "clap_derive",
-]
-
-[[package]]
-name = "clap_builder"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2bb9faaa7c2ef94b2743a21f5a29e6f0010dff4caa69ac8e9d6cf8b6fa74da08"
-dependencies = [
- "anstream",
- "anstyle",
- "clap_lex",
- "strsim",
- "terminal_size",
-]
-
-[[package]]
-name = "clap_derive"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0862016ff20d69b84ef8247369fabf5c008a7417002411897d40ee1f4532b873"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn 2.0.31",
-]
-
-[[package]]
-name = "clap_lex"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cd7cc57abe963c6d3b9d8be5b06ba7c8957a930305ca90304f24ef040aa6f961"
-
-[[package]]
-name = "clru"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b8191fa7302e03607ff0e237d4246cc043ff5b3cb9409d995172ba3bea16b807"
-
-[[package]]
-name = "colorchoice"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "acbf1af155f9b9ef647e42cdc158db4b64a1b61f743629225fde6f3e0be2a7c7"
-
-[[package]]
-name = "colored"
-version = "2.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2674ec482fbc38012cf31e6c42ba0177b431a0cb6f15fe40efa5aab1bda516f6"
-dependencies = [
- "is-terminal",
- "lazy_static",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "config"
-version = "0.13.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d379af7f68bfc21714c6c7dea883544201741d2ce8274bb12fa54f89507f52a7"
-dependencies = [
- "async-trait",
- "json5",
- "lazy_static",
- "nom",
- "pathdiff",
- "ron",
- "rust-ini",
- "serde",
- "serde_json",
- "toml 0.5.11",
- "yaml-rust",
-]
-
-[[package]]
-name = "const-oid"
-version = "0.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "28c122c3980598d243d63d9a704629a2d748d101f278052ff068be5a4423ab6f"
-
-[[package]]
-name = "core-foundation"
-version = "0.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
-dependencies = [
- "core-foundation-sys",
- "libc",
-]
-
-[[package]]
-name = "core-foundation-sys"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
-
-[[package]]
-name = "cpufeatures"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a17b76ff3a4162b0b27f354a0c87015ddad39d35f9c0c36607a3bdd175dde1f1"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "crates-io"
-version = "0.37.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "876aa69b4afca5f2eb5e23daa3445930faf829bcb67075a20ffa884f11f8c57c"
-dependencies = [
- "anyhow",
- "curl",
- "percent-encoding",
- "serde",
- "serde_json",
- "url",
-]
-
-[[package]]
-name = "crc32fast"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "crossbeam-channel"
-version = "0.5.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a33c2bf77f2df06183c3aa30d1e96c0695a313d4f9c453cc3762a6db39f99200"
-dependencies = [
- "cfg-if",
- "crossbeam-utils",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a22b2d63d4d1dc0b7f1b6b2747dd0088008a9be28b6ddf0b1e7d335e3037294"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "crypto-bigint"
-version = "0.5.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "740fe28e594155f10cfc383984cbefd529d7396050557148f79cb0f621204124"
-dependencies = [
- "generic-array",
- "rand_core",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "crypto-common"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
-dependencies = [
- "generic-array",
- "typenum",
-]
-
-[[package]]
-name = "ct-codecs"
-version = "1.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3b7eb4404b8195a9abb6356f4ac07d8ba267045c8d6d220ac4dc992e6cc75df"
-
-[[package]]
-name = "curl"
-version = "0.4.44"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "509bd11746c7ac09ebd19f0b17782eae80aadee26237658a6b4808afb5c11a22"
-dependencies = [
- "curl-sys",
- "libc",
- "openssl-probe",
- "openssl-sys",
- "schannel",
- "socket2",
- "winapi",
-]
-
-[[package]]
-name = "curl-sys"
-version = "0.4.65+curl-8.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "961ba061c9ef2fe34bbd12b807152d96f0badd2bebe7b90ce6c8c8b7572a0986"
-dependencies = [
- "cc",
- "libc",
- "libnghttp2-sys",
- "libz-sys",
- "openssl-sys",
- "pkg-config",
- "vcpkg",
- "winapi",
-]
-
-[[package]]
-name = "der"
-version = "0.7.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c"
-dependencies = [
- "const-oid",
- "pem-rfc7468",
- "zeroize",
-]
-
-[[package]]
-name = "deranged"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f2696e8a945f658fd14dc3b87242e6b80cd0f36ff04ea560fa39082368847946"
-
-[[package]]
-name = "digest"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
-dependencies = [
- "block-buffer",
- "const-oid",
- "crypto-common",
- "subtle",
-]
-
-[[package]]
-name = "dirs"
-version = "5.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44c45a9d03d6676652bcb5e724c7e988de1acad23a711b5217ab9cbecbec2225"
-dependencies = [
- "dirs-sys",
-]
-
-[[package]]
-name = "dirs-sys"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "520f05a5cbd335fae5a99ff7a6ab8627577660ee5cfd6a94a6a929b52ff0321c"
-dependencies = [
- "libc",
- "option-ext",
- "redox_users",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "dlv-list"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"
-
-[[package]]
-name = "dunce"
-version = "1.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56ce8c6da7551ec6c462cbaf3bfbc75131ebbfa1c944aeaa9dab51ca1c5f0c3b"
-
-[[package]]
-name = "dylint"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01428e3fad655202ec50df7b66015d59f7a66d76c9d0eba7148fc057c1008b08"
-dependencies = [
- "ansi_term",
- "anyhow",
- "cargo",
- "cargo-platform",
- "cargo-util",
- "cargo_metadata",
- "dirs",
- "dylint_internal",
- "glob",
- "heck",
- "if_chain",
- "is-terminal",
- "log",
- "once_cell",
- "semver",
- "serde",
- "serde_json",
- "tempfile",
- "toml 0.7.7",
- "walkdir",
-]
-
-[[package]]
-name = "dylint_internal"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "510bc05a42055d62ed89ee9561d974f338d30bf786917da7c033146a860ceac1"
-dependencies = [
- "ansi_term",
- "anyhow",
- "cargo_metadata",
- "git2",
- "home",
- "if_chain",
- "is-terminal",
- "log",
- "rust-embed",
- "sedregex",
-]
-
-[[package]]
-name = "ecdsa"
-version = "0.16.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a4b1e0c257a9e9f25f90ff76d7a68360ed497ee519c8e428d1825ef0000799d4"
-dependencies = [
- "der",
- "digest",
- "elliptic-curve",
- "rfc6979",
- "signature",
- "spki",
-]
-
-[[package]]
-name = "ed25519-compact"
-version = "2.0.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6a3d382e8464107391c8706b4c14b087808ecb909f6c15c34114bc42e53a9e4c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "either"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
-
-[[package]]
-name = "elliptic-curve"
-version = "0.13.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "968405c8fdc9b3bf4df0a6638858cc0b52462836ab6b1c87377785dd09cf1c0b"
-dependencies = [
- "base16ct",
- "crypto-bigint",
- "digest",
- "ff",
- "generic-array",
- "group",
- "hkdf",
- "pem-rfc7468",
- "pkcs8",
- "rand_core",
- "sec1",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "env_logger"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85cdab6a89accf66733ad5a1693a4dcced6aeff64602b634530dd73c1f3ee9f0"
-dependencies = [
- "humantime",
- "is-terminal",
- "log",
- "regex",
- "termcolor",
-]
-
-[[package]]
-name = "equivalent"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
-
-[[package]]
-name = "errno"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "136526188508e25c6fef639d7927dfb3e0e3084488bf202267829cf7fc23dbdd"
-dependencies = [
- "errno-dragonfly",
- "libc",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "errno-dragonfly"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "faster-hex"
-version = "0.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "239f7bfb930f820ab16a9cd95afc26f88264cf6905c960b340a615384aa3338a"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "fastrand"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6999dc1837253364c2ebb0704ba97994bd874e8f195d665c50b7548f6ea92764"
-
-[[package]]
-name = "ff"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449"
-dependencies = [
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "fiat-crypto"
-version = "0.1.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e825f6987101665dea6ec934c09ec6d721de7bc1bf92248e1d5810c8cd636b77"
-
-[[package]]
-name = "filetime"
-version = "0.2.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d4029edd3e734da6fe05b6cd7bd2960760a616bd2ddd0d59a0124746d6272af0"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall 0.3.5",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "flate2"
-version = "1.0.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6c98ee8095e9d1dcbf2fcc6d95acccb90d1c81db1e44725c6a984b1dbdfb010"
-dependencies = [
- "crc32fast",
- "libz-sys",
- "miniz_oxide",
-]
-
-[[package]]
-name = "fnv"
-version = "1.0.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
-
-[[package]]
-name = "form_urlencoded"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"
-dependencies = [
- "percent-encoding",
-]
-
-[[package]]
-name = "fwdansi"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08c1f5787fe85505d1f7777268db5103d80a7a374d2316a7ce262e57baf8f208"
-dependencies = [
- "memchr",
- "termcolor",
-]
-
-[[package]]
-name = "generic-array"
-version = "0.14.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
-dependencies = [
- "typenum",
- "version_check",
- "zeroize",
-]
-
-[[package]]
-name = "getrandom"
-version = "0.2.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
-dependencies = [
- "cfg-if",
- "js-sys",
- "libc",
- "wasi",
- "wasm-bindgen",
-]
-
-[[package]]
-name = "git2"
-version = "0.17.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7b989d6a7ca95a362cf2cfc5ad688b3a467be1f87e480b8dad07fee8c79b0044"
-dependencies = [
- "bitflags 1.3.2",
- "libc",
- "libgit2-sys",
- "log",
- "openssl-probe",
- "openssl-sys",
- "url",
-]
-
-[[package]]
-name = "git2-curl"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8f8b7432b72928cff76f69e59ed5327f94a52763731e71274960dee72fe5f8c"
-dependencies = [
- "curl",
- "git2",
- "log",
- "url",
-]
-
-[[package]]
-name = "gix"
-version = "0.44.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6bf41b61f7df395284f7a579c0fa1a7e012c5aede655174d4e91299ef1cac643"
-dependencies = [
- "gix-actor",
- "gix-attributes",
- "gix-config",
- "gix-credentials",
- "gix-date",
- "gix-diff",
- "gix-discover",
- "gix-features",
- "gix-fs",
- "gix-glob",
- "gix-hash",
- "gix-hashtable",
- "gix-ignore",
- "gix-index",
- "gix-lock",
- "gix-mailmap",
- "gix-object",
- "gix-odb",
- "gix-pack",
- "gix-path",
- "gix-prompt",
- "gix-protocol",
- "gix-ref",
- "gix-refspec",
- "gix-revision",
- "gix-sec",
- "gix-tempfile",
- "gix-transport",
- "gix-traverse",
- "gix-url",
- "gix-utils",
- "gix-validate",
- "gix-worktree",
- "log",
- "once_cell",
- "prodash",
- "signal-hook",
- "smallvec",
- "thiserror",
- "unicode-normalization",
-]
-
-[[package]]
-name = "gix-actor"
-version = "0.20.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "848efa0f1210cea8638f95691c82a46f98a74b9e3524f01d4955ebc25a8f84f3"
-dependencies = [
- "bstr",
- "btoi",
- "gix-date",
- "itoa",
- "nom",
- "thiserror",
-]
-
-[[package]]
-name = "gix-attributes"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3015baa01ad2122fbcaab7863c857a603eb7b7ec12ac8141207c42c6439805e2"
-dependencies = [
- "bstr",
- "gix-glob",
- "gix-path",
- "gix-quote",
- "kstring",
- "log",
- "smallvec",
- "thiserror",
- "unicode-bom",
-]
-
-[[package]]
-name = "gix-bitmap"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0ccab4bc576844ddb51b78d81b4a42d73e6229660fa614dfc3d3999c874d1959"
-dependencies = [
- "thiserror",
-]
-
-[[package]]
-name = "gix-chunk"
-version = "0.4.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b42ea64420f7994000130328f3c7a2038f639120518870436d31b8bde704493"
-dependencies = [
- "thiserror",
-]
-
-[[package]]
-name = "gix-command"
-version = "0.2.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f28f654184b5f725c5737c7e4f466cbd8f0102ac352d5257eeab19647ee4256"
-dependencies = [
- "bstr",
-]
-
-[[package]]
-name = "gix-config"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1d252a0eddb6df74600d3d8872dc9fe98835a7da43110411d705b682f49d4ac1"
-dependencies = [
- "bstr",
- "gix-config-value",
- "gix-features",
- "gix-glob",
- "gix-path",
- "gix-ref",
- "gix-sec",
- "log",
- "memchr",
- "nom",
- "once_cell",
- "smallvec",
- "thiserror",
- "unicode-bom",
-]
-
-[[package]]
-name = "gix-config-value"
-version = "0.12.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6e874f41437441c02991dcea76990b9058fadfc54b02ab4dd06ab2218af43897"
-dependencies = [
- "bitflags 2.4.0",
- "bstr",
- "gix-path",
- "libc",
- "thiserror",
-]
-
-[[package]]
-name = "gix-credentials"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4874a4fc11ffa844a3c2b87a66957bda30a73b577ef1acf15ac34df5745de5ff"
-dependencies = [
- "bstr",
- "gix-command",
- "gix-config-value",
- "gix-path",
- "gix-prompt",
- "gix-sec",
- "gix-url",
- "thiserror",
-]
-
-[[package]]
-name = "gix-date"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc164145670e9130a60a21670d9b6f0f4f8de04e5dd256c51fa5a0340c625902"
-dependencies = [
- "bstr",
- "itoa",
- "thiserror",
- "time",
-]
-
-[[package]]
-name = "gix-diff"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "644a0f2768bc42d7a69289ada80c9e15c589caefc6a315d2307202df83ed1186"
-dependencies = [
- "gix-hash",
- "gix-object",
- "imara-diff",
- "thiserror",
-]
-
-[[package]]
-name = "gix-discover"
-version = "0.18.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a6b61363e63e7cdaa3e6f96acb0257ebdb3d8883e21eba5930c99f07f0a5fc0"
-dependencies = [
- "bstr",
- "dunce",
- "gix-hash",
- "gix-path",
- "gix-ref",
- "gix-sec",
- "thiserror",
-]
-
-[[package]]
-name = "gix-features"
-version = "0.29.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf69b0f5c701cc3ae22d3204b671907668f6437ca88862d355eaf9bc47a4f897"
-dependencies = [
- "bytes",
- "crc32fast",
- "crossbeam-channel",
- "flate2",
- "gix-hash",
- "libc",
- "once_cell",
- "parking_lot",
- "prodash",
- "sha1_smol",
- "thiserror",
- "walkdir",
-]
-
-[[package]]
-name = "gix-fs"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b37a1832f691fdc09910bd267f9a2e413737c1f9ec68c6e31f9e802616278a9"
-dependencies = [
- "gix-features",
-]
-
-[[package]]
-name = "gix-glob"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c07c98204529ac3f24b34754540a852593d2a4c7349008df389240266627a72a"
-dependencies = [
- "bitflags 2.4.0",
- "bstr",
- "gix-features",
- "gix-path",
-]
-
-[[package]]
-name = "gix-hash"
-version = "0.11.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b422ff2ad9a0628baaad6da468cf05385bf3f5ab495ad5a33cce99b9f41092f"
-dependencies = [
- "hex",
- "thiserror",
-]
-
-[[package]]
-name = "gix-hashtable"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "385f4ce6ecf3692d313ca3aa9bd3b3d8490de53368d6d94bedff3af8b6d9c58d"
-dependencies = [
- "gix-hash",
- "hashbrown 0.14.0",
- "parking_lot",
-]
-
-[[package]]
-name = "gix-ignore"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba205b6df563e2906768bb22834c82eb46c5fdfcd86ba2c347270bc8309a05b2"
-dependencies = [
- "bstr",
- "gix-glob",
- "gix-path",
- "unicode-bom",
-]
-
-[[package]]
-name = "gix-index"
-version = "0.16.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f39c1ccc8f1912cbbd5191efc28dbc5f0d0598042aa56bc09427b7c34efab3ba"
-dependencies = [
- "bitflags 2.4.0",
- "bstr",
- "btoi",
- "filetime",
- "gix-bitmap",
- "gix-features",
- "gix-hash",
- "gix-lock",
- "gix-object",
- "gix-traverse",
- "itoa",
- "memmap2",
- "smallvec",
- "thiserror",
-]
-
-[[package]]
-name = "gix-lock"
-version = "5.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c693d7f05730fa74a7c467150adc7cea393518410c65f0672f80226b8111555"
-dependencies = [
- "gix-tempfile",
- "gix-utils",
- "thiserror",
-]
-
-[[package]]
-name = "gix-mailmap"
-version = "0.12.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8856cec3bdc3610c06970d28b6cb20a0c6621621cf9a8ec48cbd23f2630f362"
-dependencies = [
- "bstr",
- "gix-actor",
- "thiserror",
-]
-
-[[package]]
-name = "gix-object"
-version = "0.29.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2d96bd620fd08accdd37f70b2183cfa0b001b4f1c6ade8b7f6e15cb3d9e261ce"
-dependencies = [
- "bstr",
- "btoi",
- "gix-actor",
- "gix-features",
- "gix-hash",
- "gix-validate",
- "hex",
- "itoa",
- "nom",
- "smallvec",
- "thiserror",
-]
-
-[[package]]
-name = "gix-odb"
-version = "0.45.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bca2f324aa67672b6d0f2c0fa93f96eb6a7029d260e4c1df5dce3c015f5e5add"
-dependencies = [
- "arc-swap",
- "gix-features",
- "gix-hash",
- "gix-object",
- "gix-pack",
- "gix-path",
- "gix-quote",
- "parking_lot",
- "tempfile",
- "thiserror",
-]
-
-[[package]]
-name = "gix-pack"
-version = "0.35.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "164a515900a83257ae4aa80e741655bee7a2e39113fb535d7a5ac623b445ff20"
-dependencies = [
- "clru",
- "gix-chunk",
- "gix-diff",
- "gix-features",
- "gix-hash",
- "gix-hashtable",
- "gix-object",
- "gix-path",
- "gix-tempfile",
- "gix-traverse",
- "memmap2",
- "parking_lot",
- "smallvec",
- "thiserror",
-]
-
-[[package]]
-name = "gix-packetline"
-version = "0.16.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a374cb5eba089e3c123df4d996eb00da411bb90ec92cb35bffeeb2d22ee106a"
-dependencies = [
- "bstr",
- "faster-hex",
- "thiserror",
-]
-
-[[package]]
-name = "gix-path"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18609c8cbec8508ea97c64938c33cd305b75dfc04a78d0c3b78b8b3fd618a77c"
-dependencies = [
- "bstr",
- "gix-trace",
- "home",
- "once_cell",
- "thiserror",
-]
-
-[[package]]
-name = "gix-prompt"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c22decaf4a063ccae2b2108820c8630c01bd6756656df3fe464b32b8958a5ea"
-dependencies = [
- "gix-command",
- "gix-config-value",
- "parking_lot",
- "rustix 0.38.11",
- "thiserror",
-]
-
-[[package]]
-name = "gix-protocol"
-version = "0.32.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877e49417f1730f4dbc2f7d9a2ab0f8b2f49ef08f97270691403ecde3d961e3a"
-dependencies = [
- "bstr",
- "btoi",
- "gix-credentials",
- "gix-features",
- "gix-hash",
- "gix-transport",
- "maybe-async",
- "nom",
- "thiserror",
-]
-
-[[package]]
-name = "gix-quote"
-version = "0.4.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "475c86a97dd0127ba4465fbb239abac9ea10e68301470c9791a6dd5351cdc905"
-dependencies = [
- "bstr",
- "btoi",
- "thiserror",
-]
-
-[[package]]
-name = "gix-ref"
-version = "0.29.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e03989e9d49954368e1b526578230fc7189d1634acdfbe79e9ba1de717e15d5"
-dependencies = [
- "gix-actor",
- "gix-features",
- "gix-fs",
- "gix-hash",
- "gix-lock",
- "gix-object",
- "gix-path",
- "gix-tempfile",
- "gix-validate",
- "memmap2",
- "nom",
- "thiserror",
-]
-
-[[package]]
-name = "gix-refspec"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0a6ea733820df67e4cd7797deb12727905824d8f5b7c59d943c456d314475892"
-dependencies = [
- "bstr",
- "gix-hash",
- "gix-revision",
- "gix-validate",
- "smallvec",
- "thiserror",
-]
-
-[[package]]
-name = "gix-revision"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "810f35e9afeccca999d5d348b239f9c162353127d2e13ff3240e31b919e35476"
-dependencies = [
- "bstr",
- "gix-date",
- "gix-hash",
- "gix-hashtable",
- "gix-object",
- "thiserror",
-]
-
-[[package]]
-name = "gix-sec"
-version = "0.8.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9615cbd6b456898aeb942cd75e5810c382fbfc48dbbff2fa23ebd2d33dcbe9c7"
-dependencies = [
- "bitflags 2.4.0",
- "gix-path",
- "libc",
- "windows",
-]
-
-[[package]]
-name = "gix-tempfile"
-version = "5.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71a0d32f34e71e86586124225caefd78dabc605d0486de580d717653addf182"
-dependencies = [
- "gix-fs",
- "libc",
- "once_cell",
- "parking_lot",
- "signal-hook",
- "signal-hook-registry",
- "tempfile",
-]
-
-[[package]]
-name = "gix-trace"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96b6d623a1152c3facb79067d6e2ecdae48130030cf27d6eb21109f13bd7b836"
-
-[[package]]
-name = "gix-transport"
-version = "0.31.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f01c2bf7b989c679695ef635fc7d9e80072e08101be4b53193c8e8b649900102"
-dependencies = [
- "base64 0.21.3",
- "bstr",
- "curl",
- "gix-command",
- "gix-credentials",
- "gix-features",
- "gix-packetline",
- "gix-quote",
- "gix-sec",
- "gix-url",
- "thiserror",
-]
-
-[[package]]
-name = "gix-traverse"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5be1e807f288c33bb005075111886cceb43ed8a167b3182a0f62c186e2a0dd1"
-dependencies = [
- "gix-hash",
- "gix-hashtable",
- "gix-object",
- "thiserror",
-]
-
-[[package]]
-name = "gix-url"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfc77f89054297cc81491e31f1bab4027e554b5ef742a44bd7035db9a0f78b76"
-dependencies = [
- "bstr",
- "gix-features",
- "gix-path",
- "home",
- "thiserror",
- "url",
-]
-
-[[package]]
-name = "gix-utils"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b85d89dc728613e26e0ed952a19583744e7f5240fcd4aa30d6c824ffd8b52f0f"
-dependencies = [
- "fastrand",
-]
-
-[[package]]
-name = "gix-validate"
-version = "0.7.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba9b3737b2cef3dcd014633485f0034b0f1a931ee54aeb7d8f87f177f3c89040"
-dependencies = [
- "bstr",
- "thiserror",
-]
-
-[[package]]
-name = "gix-worktree"
-version = "0.17.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a69eaff0ae973a9d37c40f02ae5ae50fa726c8fc2fd3ab79d0a19eb61975aafa"
-dependencies = [
- "bstr",
- "filetime",
- "gix-attributes",
- "gix-features",
- "gix-fs",
- "gix-glob",
- "gix-hash",
- "gix-ignore",
- "gix-index",
- "gix-object",
- "gix-path",
- "io-close",
- "thiserror",
-]
-
-[[package]]
-name = "glob"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
-
-[[package]]
-name = "globset"
-version = "0.4.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "759c97c1e17c55525b57192c06a267cda0ac5210b222d6b82189a2338fa1c13d"
-dependencies = [
- "aho-corasick",
- "bstr",
- "fnv",
- "log",
- "regex",
-]
-
-[[package]]
-name = "group"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63"
-dependencies = [
- "ff",
- "rand_core",
- "subtle",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
-dependencies = [
- "ahash 0.7.6",
-]
-
-[[package]]
-name = "hashbrown"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
-
-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-
-[[package]]
-name = "hermit-abi"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
-
-[[package]]
-name = "hex"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
-
-[[package]]
-name = "hkdf"
-version = "0.12.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "791a029f6b9fc27657f6f188ec6e5e43f6911f6f878e0dc5501396e09809d437"
-dependencies = [
- "hmac",
-]
-
-[[package]]
-name = "hmac"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
-dependencies = [
- "digest",
-]
-
-[[package]]
-name = "home"
-version = "0.5.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5444c27eef6923071f7ebcc33e3444508466a76f7a2b93da00ed6e19f30c1ddb"
-dependencies = [
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "http-auth"
-version = "0.1.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5430cacd7a1f9a02fbeb350dfc81a0e5ed42d81f3398cb0ba184017f85bdcfbc"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "humantime"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
-
-[[package]]
-name = "idna"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "if_chain"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
-
-[[package]]
-name = "ignore"
-version = "0.4.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbe7873dab538a9a44ad79ede1faf5f30d49f9a5c883ddbab48bce81b64b7492"
-dependencies = [
- "globset",
- "lazy_static",
- "log",
- "memchr",
- "regex",
- "same-file",
- "thread_local",
- "walkdir",
- "winapi-util",
-]
-
-[[package]]
-name = "im-rc"
-version = "15.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe"
-dependencies = [
- "bitmaps",
- "rand_core",
- "rand_xoshiro",
- "sized-chunks",
- "typenum",
- "version_check",
-]
-
-[[package]]
-name = "imara-diff"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e98c1d0ad70fc91b8b9654b1f33db55e59579d3b3de2bffdced0fdb810570cb8"
-dependencies = [
- "ahash 0.8.3",
- "hashbrown 0.12.3",
-]
-
-[[package]]
-name = "indexmap"
-version = "1.9.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
-dependencies = [
- "autocfg",
- "hashbrown 0.12.3",
-]
-
-[[package]]
-name = "indexmap"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
-dependencies = [
- "equivalent",
- "hashbrown 0.14.0",
-]
-
-[[package]]
-name = "io-close"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9cadcf447f06744f8ce713d2d6239bb5bde2c357a452397a9ed90c625da390bc"
-dependencies = [
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "io-lifetimes"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eae7b9aee968036d54dce06cebaefd919e4472e753296daccd6d344e3e2df0c2"
-dependencies = [
- "hermit-abi",
- "libc",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "is-terminal"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb0889898416213fab133e1d33a0e5858a48177452750691bde3666d0fdbaf8b"
-dependencies = [
- "hermit-abi",
- "rustix 0.38.11",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itertools"
-version = "0.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b1c173a5686ce8bfa551b3563d0c2170bf24ca44da99c7ca4bfdab5418c3fe57"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "itoa"
-version = "1.0.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
-
-[[package]]
-name = "jobserver"
-version = "0.1.26"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "936cfd212a0155903bcbc060e316fb6cc7cbf2e1907329391ebadc1fe0ce77c2"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "js-sys"
-version = "0.3.64"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
-dependencies = [
- "wasm-bindgen",
-]
-
-[[package]]
-name = "json5"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1"
-dependencies = [
- "pest",
- "pest_derive",
- "serde",
-]
-
-[[package]]
-name = "kstring"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec3066350882a1cd6d950d055997f379ac37fd39f81cd4d8ed186032eb3c5747"
-dependencies = [
- "static_assertions",
-]
-
-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
-[[package]]
-name = "libc"
-version = "0.2.147"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
-
-[[package]]
-name = "libgit2-sys"
-version = "0.15.2+1.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a80df2e11fb4a61f4ba2ab42dbe7f74468da143f1a75c74e11dee7c813f694fa"
-dependencies = [
- "cc",
- "libc",
- "libssh2-sys",
- "libz-sys",
- "openssl-sys",
- "pkg-config",
-]
-
-[[package]]
-name = "libnghttp2-sys"
-version = "0.1.8+1.55.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4fae956c192dadcdb5dace96db71fa0b827333cce7c7b38dc71446f024d8a340"
-dependencies = [
- "cc",
- "libc",
-]
-
-[[package]]
-name = "libssh2-sys"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dc8a030b787e2119a731f1951d6a773e2280c660f8ec4b0f5e1505a386e71ee"
-dependencies = [
- "cc",
- "libc",
- "libz-sys",
- "openssl-sys",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "libz-sys"
-version = "1.1.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d97137b25e321a73eef1418d1d5d2eda4d77e12813f8e6dead84bc52c5870a7b"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "linked-hash-map"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ef53942eb7bf7ff43a617b3e2c1c4a5ecf5944a7c1bc12d7ee39bbb15e5c1519"
-
-[[package]]
-name = "linux-raw-sys"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57bcfdad1b858c2db7c38303a6d2ad4dfaf5eb53dfeb0910128b2c26d6158503"
-
-[[package]]
-name = "lock_api"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
-[[package]]
-name = "log"
-version = "0.4.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
-
-[[package]]
-name = "maybe-async"
-version = "0.2.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f1b8c13cb1f814b634a96b2c725449fe7ed464a7b8781de8688be5ffbd3f305"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
-[[package]]
-name = "memchr"
-version = "2.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"
-
-[[package]]
-name = "memmap2"
-version = "0.5.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "minimal-lexical"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
-
-[[package]]
-name = "miniz_oxide"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
-dependencies = [
- "adler",
-]
-
-[[package]]
-name = "miow"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52ffbca2f655e33c08be35d87278e5b18b89550a37dbd598c20db92f6a471123"
-dependencies = [
- "windows-sys 0.42.0",
-]
-
-[[package]]
-name = "nom"
-version = "7.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
-dependencies = [
- "memchr",
- "minimal-lexical",
-]
-
-[[package]]
-name = "num-traits"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
-dependencies = [
- "autocfg",
-]
-
-[[package]]
-name = "num_threads"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2819ce041d2ee131036f4fc9d6ae7ae125a3a40e97ba64d04fe799ad9dabbb44"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "once_cell"
-version = "1.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
-
-[[package]]
-name = "opener"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "293c15678e37254c15bd2f092314abb4e51d7fdde05c2021279c12631b54f005"
-dependencies = [
- "bstr",
- "winapi",
-]
-
-[[package]]
-name = "openssl-probe"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
-
-[[package]]
-name = "openssl-sys"
-version = "0.9.93"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db4d56a4c0478783083cfafcc42493dd4a981d41669da64b4572a2a089b51b1d"
-dependencies = [
- "cc",
- "libc",
- "pkg-config",
- "vcpkg",
-]
-
-[[package]]
-name = "option-ext"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04744f49eae99ab78e0d5c0b603ab218f515ea8cfe5a456d7629ad883a3b6e7d"
-
-[[package]]
-name = "ordered-float"
-version = "2.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7940cf2ca942593318d07fcf2596cdca60a85c9e7fab408a5e21a4f9dcd40d87"
-dependencies = [
- "num-traits",
-]
-
-[[package]]
-name = "ordered-multimap"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ccd746e37177e1711c20dd619a1620f34f5c8b569c53590a72dedd5344d8924a"
-dependencies = [
- "dlv-list",
- "hashbrown 0.12.3",
-]
-
-[[package]]
-name = "orion"
-version = "0.17.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b11468cc6afd61a126fe3f91cc4cc8a0dbe7917d0a4b5e8357ba91cc47444462"
-dependencies = [
- "fiat-crypto",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "os_info"
-version = "3.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "006e42d5b888366f1880eda20371fedde764ed2213dc8496f49622fa0c99cd5e"
-dependencies = [
- "log",
- "serde",
- "winapi",
-]
-
-[[package]]
-name = "p384"
-version = "0.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70786f51bcc69f6a4c0360e063a4cac5419ef7c5cd5b3c99ad70f3be5ba79209"
-dependencies = [
- "ecdsa",
- "elliptic-curve",
- "primeorder",
- "sha2",
-]
-
-[[package]]
-name = "parking_lot"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall 0.3.5",
- "smallvec",
- "windows-targets",
-]
-
-[[package]]
-name = "pasetors"
-version = "0.6.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba765699a309908d55950919a3445e9491453e89b2587b1b2abe4143a48894c0"
-dependencies = [
- "ct-codecs",
- "ed25519-compact",
- "getrandom",
- "orion",
- "p384",
- "rand_core",
- "regex",
- "serde",
- "serde_json",
- "sha2",
- "subtle",
- "time",
- "zeroize",
-]
-
-[[package]]
-name = "pathdiff"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
-
-[[package]]
-name = "pem-rfc7468"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88b39c9bfcfc231068454382784bb460aae594343fb030d46e9f50a645418412"
-dependencies = [
- "base64ct",
-]
-
-[[package]]
-name = "percent-encoding"
-version = "2.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
-
-[[package]]
-name = "pest"
-version = "2.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d7a4d085fd991ac8d5b05a147b437791b4260b76326baf0fc60cf7c9c27ecd33"
-dependencies = [
- "memchr",
- "thiserror",
- "ucd-trie",
-]
-
-[[package]]
-name = "pest_derive"
-version = "2.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2bee7be22ce7918f641a33f08e3f43388c7656772244e2bbb2477f44cc9021a"
-dependencies = [
- "pest",
- "pest_generator",
-]
-
-[[package]]
-name = "pest_generator"
-version = "2.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d1511785c5e98d79a05e8a6bc34b4ac2168a0e3e92161862030ad84daa223141"
-dependencies = [
- "pest",
- "pest_meta",
- "proc-macro2",
- "quote",
- "syn 2.0.31",
-]
-
-[[package]]
-name = "pest_meta"
-version = "2.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42f0394d3123e33353ca5e1e89092e533d2cc490389f2bd6131c43c634ebc5f"
-dependencies = [
- "once_cell",
- "pest",
- "sha2",
-]
-
-[[package]]
-name = "pkcs8"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7"
-dependencies = [
- "der",
- "spki",
-]
-
-[[package]]
-name = "pkg-config"
-version = "0.3.27"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
-
-[[package]]
-name = "ppv-lite86"
-version = "0.2.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
-
-[[package]]
-name = "primeorder"
-version = "0.13.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c2fcef82c0ec6eefcc179b978446c399b3cdf73c392c35604e399eee6df1ee3"
-dependencies = [
- "elliptic-curve",
-]
-
-[[package]]
-name = "proc-macro2"
-version = "1.0.66"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
-dependencies = [
- "unicode-ident",
-]
-
-[[package]]
-name = "prodash"
-version = "23.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9516b775656bc3e8985e19cd4b8c0c0de045095074e453d2c0a513b5f978392d"
-dependencies = [
- "parking_lot",
-]
-
-[[package]]
-name = "quote"
-version = "1.0.33"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
-dependencies = [
- "proc-macro2",
-]
-
-[[package]]
-name = "rand"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
-dependencies = [
- "libc",
- "rand_chacha",
- "rand_core",
-]
-
-[[package]]
-name = "rand_chacha"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
-dependencies = [
- "ppv-lite86",
- "rand_core",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
-dependencies = [
- "getrandom",
-]
-
-[[package]]
-name = "rand_xoshiro"
-version = "0.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
-dependencies = [
- "rand_core",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "redox_syscall"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
-dependencies = [
- "bitflags 1.3.2",
-]
-
-[[package]]
-name = "redox_users"
-version = "0.4.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b033d837a7cf162d7993aded9304e30a83213c648b6e389db233191f891e5c2b"
-dependencies = [
- "getrandom",
- "redox_syscall 0.2.16",
- "thiserror",
-]
-
-[[package]]
-name = "regex"
-version = "1.9.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-automata",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-automata"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
-dependencies = [
- "aho-corasick",
- "memchr",
- "regex-syntax",
-]
-
-[[package]]
-name = "regex-syntax"
-version = "0.7.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
-
-[[package]]
-name = "rfc6979"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2"
-dependencies = [
- "hmac",
- "subtle",
-]
-
-[[package]]
-name = "ron"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88073939a61e5b7680558e6be56b419e208420c2adb92be54921fa6b72283f1a"
-dependencies = [
- "base64 0.13.1",
- "bitflags 1.3.2",
- "serde",
-]
-
-[[package]]
-name = "rust-embed"
-version = "6.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a36224c3276f8c4ebc8c20f158eca7ca4359c8db89991c4925132aaaf6702661"
-dependencies = [
- "rust-embed-impl",
- "rust-embed-utils",
- "walkdir",
-]
-
-[[package]]
-name = "rust-embed-impl"
-version = "6.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49b94b81e5b2c284684141a2fb9e2a31be90638caf040bf9afbc5a0416afe1ac"
-dependencies = [
- "proc-macro2",
- "quote",
- "rust-embed-utils",
- "syn 2.0.31",
- "walkdir",
-]
-
-[[package]]
-name = "rust-embed-utils"
-version = "7.8.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d38ff6bf570dc3bb7100fce9f7b60c33fa71d80e88da3f2580df4ff2bdded74"
-dependencies = [
- "globset",
- "sha2",
- "walkdir",
-]
-
-[[package]]
-name = "rust-ini"
-version = "0.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f6d5f2436026b4f6e79dc829837d467cc7e9a55ee40e750d716713540715a2df"
-dependencies = [
- "cfg-if",
- "ordered-multimap",
-]
-
-[[package]]
-name = "rustfix"
-version = "0.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecd2853d9e26988467753bd9912c3a126f642d05d229a4b53f5752ee36c56481"
-dependencies = [
- "anyhow",
- "log",
- "serde",
- "serde_json",
-]
-
-[[package]]
-name = "rustix"
-version = "0.37.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4d69718bf81c6127a49dc64e44a742e8bb9213c0ff8869a22c308f84c1d4ab06"
-dependencies = [
- "bitflags 1.3.2",
- "errno",
- "io-lifetimes",
- "libc",
- "linux-raw-sys 0.3.8",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "rustix"
-version = "0.38.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0c3dde1fc030af041adc40e79c0e7fbcf431dd24870053d187d7c66e4b87453"
-dependencies = [
- "bitflags 2.4.0",
- "errno",
- "libc",
- "linux-raw-sys 0.4.5",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "rustversion"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
-
-[[package]]
-name = "ryu"
-version = "1.0.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
-
-[[package]]
-name = "same-file"
-version = "1.0.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "schannel"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0c3733bf4cf7ea0880754e19cb5a462007c4a8c1914bff372ccc95b464f1df88"
-dependencies = [
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "scopeguard"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
-
-[[package]]
-name = "scout-audit-internal"
-version = "0.2.1"
-dependencies = [
- "strum",
-]
-
-[[package]]
-name = "sec1"
-version = "0.7.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc"
-dependencies = [
- "base16ct",
- "der",
- "generic-array",
- "pkcs8",
- "subtle",
- "zeroize",
-]
-
-[[package]]
-name = "sedregex"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "19411e23596093f03bbd11dc45603b6329bb4bfec77b9fd13e2b9fc9b02efe3e"
-dependencies = [
- "regex",
-]
-
-[[package]]
-name = "semver"
-version = "1.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0293b4b29daaf487284529cc2f5675b8e57c61f70167ba415a463651fd6a918"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde"
-version = "1.0.188"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
-dependencies = [
- "serde_derive",
-]
-
-[[package]]
-name = "serde-value"
-version = "0.7.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3a1a3341211875ef120e117ea7fd5228530ae7e7036a779fdc9117be6b3282c"
-dependencies = [
- "ordered-float",
- "serde",
-]
-
-[[package]]
-name = "serde_derive"
-version = "1.0.188"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.31",
-]
-
-[[package]]
-name = "serde_ignored"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80c31d5c53fd39f208e770f5a20a0bb214dee2a8d0d8adba18e19ad95a482ca5"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "serde_json"
-version = "1.0.105"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
-[[package]]
-name = "serde_spanned"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96426c9936fd7a0124915f9185ea1d20aa9445cc9821142f0a73bc9207a2e186"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "sha1"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f04293dc80c3993519f2d7f6f511707ee7094fe0c6d3406feb330cdb3540eba3"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "sha1_smol"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae1a47186c03a32177042e55dbc5fd5aee900b8e0069a8d70fba96a9375cd012"
-
-[[package]]
-name = "sha2"
-version = "0.10.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "479fb9d862239e610720565ca91403019f2f00410f1864c5aa7479b950a76ed8"
-dependencies = [
- "cfg-if",
- "cpufeatures",
- "digest",
-]
-
-[[package]]
-name = "shell-escape"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45bb67a18fa91266cc7807181f62f9178a6873bfad7dc788c42e6430db40184f"
-
-[[package]]
-name = "signal-hook"
-version = "0.3.17"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
-dependencies = [
- "libc",
- "signal-hook-registry",
-]
-
-[[package]]
-name = "signal-hook-registry"
-version = "1.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
-dependencies = [
- "libc",
-]
-
-[[package]]
-name = "signature"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e1788eed21689f9cf370582dfc467ef36ed9c707f073528ddafa8d83e3b8500"
-dependencies = [
- "digest",
- "rand_core",
-]
-
-[[package]]
-name = "sized-chunks"
-version = "0.6.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e"
-dependencies = [
- "bitmaps",
- "typenum",
-]
-
-[[package]]
-name = "smallvec"
-version = "1.11.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
-
-[[package]]
-name = "socket2"
-version = "0.4.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
-dependencies = [
- "libc",
- "winapi",
-]
-
-[[package]]
-name = "spki"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d1e996ef02c474957d681f1b05213dfb0abab947b446a62d37770b23500184a"
-dependencies = [
- "base64ct",
- "der",
-]
-
-[[package]]
-name = "static_assertions"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
-
-[[package]]
-name = "strip-ansi-escapes"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "011cbb39cf7c1f62871aea3cc46e5817b0937b49e9447370c93cacbe93a766d8"
-dependencies = [
- "vte",
-]
-
-[[package]]
-name = "strsim"
-version = "0.10.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
-
-[[package]]
-name = "strum"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
-dependencies = [
- "strum_macros",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.25.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad8d03b598d3d0fff69bf533ee3ef19b8eeb342729596df84bcc7e1f96ec4059"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn 2.0.31",
-]
-
-[[package]]
-name = "subtle"
-version = "2.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc"
-
-[[package]]
-name = "syn"
-version = "1.0.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "syn"
-version = "2.0.31"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "718fa2415bcb8d8bd775917a1bf12a7931b6dfa890753378538118181e0cb398"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
-]
-
-[[package]]
-name = "tar"
-version = "0.4.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b16afcea1f22891c49a00c751c7b63b2233284064f11a200fc624137c51e2ddb"
-dependencies = [
- "filetime",
- "libc",
-]
-
-[[package]]
-name = "tempfile"
-version = "3.8.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef"
-dependencies = [
- "cfg-if",
- "fastrand",
- "redox_syscall 0.3.5",
- "rustix 0.38.11",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "termcolor"
-version = "1.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
-dependencies = [
- "winapi-util",
-]
-
-[[package]]
-name = "terminal_size"
-version = "0.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e6bf6f19e9f8ed8d4048dc22981458ebcf406d67e94cd422e5ecd73d63b3237"
-dependencies = [
- "rustix 0.37.23",
- "windows-sys 0.48.0",
-]
-
-[[package]]
-name = "thiserror"
-version = "1.0.48"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d6d7a740b8a666a7e828dd00da9c0dc290dff53154ea77ac109281de90589b7"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.48"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49922ecae66cc8a249b77e68d1d0623c1b2c514f0060c27cdc68bd62a1219d35"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.31",
-]
-
-[[package]]
-name = "thread_local"
-version = "1.1.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152"
-dependencies = [
- "cfg-if",
- "once_cell",
-]
-
-[[package]]
-name = "time"
-version = "0.3.28"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17f6bb557fd245c28e6411aa56b6403c689ad95061f50e4be16c274e70a17e48"
-dependencies = [
- "deranged",
- "itoa",
- "libc",
- "num_threads",
- "serde",
- "time-core",
- "time-macros",
-]
-
-[[package]]
-name = "time-core"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7300fbefb4dadc1af235a9cef3737cea692a9d97e1b9cbcd4ebdae6f8868e6fb"
-
-[[package]]
-name = "time-macros"
-version = "0.2.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a942f44339478ef67935ab2bbaec2fb0322496cf3cbe84b261e06ac3814c572"
-dependencies = [
- "time-core",
-]
-
-[[package]]
-name = "tinyvec"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
-[[package]]
-name = "toml"
-version = "0.5.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml"
-version = "0.7.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de0a3ab2091e52d7299a39d098e200114a972df0a7724add02a273aa9aada592"
-dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
-]
-
-[[package]]
-name = "toml_datetime"
-version = "0.6.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7cda73e2f1397b1262d6dfdcef8aafae14d1de7748d66822d3bfeeb6d03e5e4b"
-dependencies = [
- "serde",
-]
-
-[[package]]
-name = "toml_edit"
-version = "0.19.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
-dependencies = [
- "indexmap 2.0.0",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow",
-]
-
-[[package]]
-name = "typenum"
-version = "1.16.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
-
-[[package]]
-name = "ucd-trie"
-version = "0.1.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
-
-[[package]]
-name = "unicode-bom"
-version = "2.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "98e90c70c9f0d4d1ee6d0a7d04aa06cb9bbd53d8cfbdd62a0269a7c2eb640552"
-
-[[package]]
-name = "unicode-ident"
-version = "1.0.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
-
-[[package]]
-name = "unicode-normalization"
-version = "0.1.22"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
-dependencies = [
- "tinyvec",
-]
-
-[[package]]
-name = "unicode-width"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
-
-[[package]]
-name = "unicode-xid"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
-
-[[package]]
-name = "url"
-version = "2.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5"
-dependencies = [
- "form_urlencoded",
- "idna",
- "percent-encoding",
-]
-
-[[package]]
-name = "utf8parse"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
-
-[[package]]
-name = "vcpkg"
-version = "0.2.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
-
-[[package]]
-name = "version_check"
-version = "0.9.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
-
-[[package]]
-name = "vte"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6cbce692ab4ca2f1f3047fcf732430249c0e971bfdd2b234cf2c47ad93af5983"
-dependencies = [
- "arrayvec",
- "utf8parse",
- "vte_generate_state_changes",
-]
-
-[[package]]
-name = "vte_generate_state_changes"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d257817081c7dffcdbab24b9e62d2def62e2ff7d00b1c20062551e6cccc145ff"
-dependencies = [
- "proc-macro2",
- "quote",
-]
-
-[[package]]
-name = "walkdir"
-version = "2.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee"
-dependencies = [
- "same-file",
- "winapi-util",
-]
-
-[[package]]
-name = "wasi"
-version = "0.11.0+wasi-snapshot-preview1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
-
-[[package]]
-name = "wasm-bindgen"
-version = "0.2.87"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
-dependencies = [
- "cfg-if",
- "wasm-bindgen-macro",
-]
-
-[[package]]
-name = "wasm-bindgen-backend"
-version = "0.2.87"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
-dependencies = [
- "bumpalo",
- "log",
- "once_cell",
- "proc-macro2",
- "quote",
- "syn 2.0.31",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-macro"
-version = "0.2.87"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
-dependencies = [
- "quote",
- "wasm-bindgen-macro-support",
-]
-
-[[package]]
-name = "wasm-bindgen-macro-support"
-version = "0.2.87"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 2.0.31",
- "wasm-bindgen-backend",
- "wasm-bindgen-shared",
-]
-
-[[package]]
-name = "wasm-bindgen-shared"
-version = "0.2.87"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
-
-[[package]]
-name = "winapi"
-version = "0.3.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
-dependencies = [
- "winapi-i686-pc-windows-gnu",
- "winapi-x86_64-pc-windows-gnu",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-
-[[package]]
-name = "winapi-util"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
-dependencies = [
- "winapi",
-]
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-
-[[package]]
-name = "windows"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
-dependencies = [
- "windows-targets",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.42.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
-dependencies = [
- "windows_aarch64_gnullvm 0.42.2",
- "windows_aarch64_msvc 0.42.2",
- "windows_i686_gnu 0.42.2",
- "windows_i686_msvc 0.42.2",
- "windows_x86_64_gnu 0.42.2",
- "windows_x86_64_gnullvm 0.42.2",
- "windows_x86_64_msvc 0.42.2",
-]
-
-[[package]]
-name = "windows-sys"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
-dependencies = [
- "windows-targets",
-]
-
-[[package]]
-name = "windows-targets"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
-dependencies = [
- "windows_aarch64_gnullvm 0.48.5",
- "windows_aarch64_msvc 0.48.5",
- "windows_i686_gnu 0.48.5",
- "windows_i686_msvc 0.48.5",
- "windows_x86_64_gnu 0.48.5",
- "windows_x86_64_gnullvm 0.48.5",
- "windows_x86_64_msvc 0.48.5",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.42.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
-
-[[package]]
-name = "winnow"
-version = "0.5.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c2e3184b9c4e92ad5167ca73039d0c42476302ab603e2fec4487511f38ccefc"
-dependencies = [
- "memchr",
-]
-
-[[package]]
-name = "yaml-rust"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
-dependencies = [
- "linked-hash-map",
-]
-
-[[package]]
-name = "zeroize"
-version = "1.6.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
diff --git a/apps/cargo-scout-audit/Cargo.toml b/apps/cargo-scout-audit/Cargo.toml
deleted file mode 100644
index 2f203142..00000000
--- a/apps/cargo-scout-audit/Cargo.toml
+++ /dev/null
@@ -1,48 +0,0 @@
-[package]
-name = "cargo-scout-audit"
-version = "0.2.1"
-edition = "2021"
-authors = [
-    "Agustin Aon <agustin.aon@coinfabrik.com>",
-    "Arturo Beccar-Varela <arturo.beccar@coinfabrik.com>",
-    "José García Crosta <jose.garcia.crosta@coinfabrik.com>",
-    "Facundo Lerena <facundo.lerena@coinfabrik.com>",
-    "Agustin Losiggio <agustin.losiggio@coinfabrik.com>",
-    "Federico Pinho <federico.pinho@coinfabrik.com>",
-    "Ariel Waissbein <ariel.waissbein@coinfabrik.com",
-]
-license = "MIT"
-description = "Scout is an extensible open-source tool intended to assist Soroban smart contract developers and auditors detect common security issues and deviations from best practices."
-readme = "../../README.md"
-keywords = ["auditor", "rust", "security", "soroban", "smart-contracts"]
-categories = ["development-tools", "command-line-utilities"]
-
-[lib]
-path = "src/lib.rs"
-
-[[bin]]
-path = "src/main.rs"
-name = "cargo-scout-audit"
-
-[dependencies]
-ansi_term = "0.12.1"
-anyhow = "1"
-cargo = "0.72.2"
-cargo_metadata = "0.17"
-clap = { version = "4.3.0", features = ["derive"] }
-dunce = "1.0.4"
-dylint = { version = "2.3.0"}
-env_logger = "0.10"
-home = { version = "0.5.5" }
-itertools = "0.11"
-log = "0.4"
-tempfile = "3.8"
-regex = { version = "1.5", features = ["unicode"] }
-serde_json = "1.0"
-
-scout-audit-internal = { version = "=0.2.1", path = "../../scout-audit-internal", features = ["detector"] }
-
-[dev-dependencies]
-colored = "2.0.0"
-config = "0.13.3"
-serde = { version = "1.0.163", features = ["derive"] }
diff --git a/apps/cargo-scout-audit/src/detectors.rs b/apps/cargo-scout-audit/src/detectors.rs
deleted file mode 100644
index f47688f6..00000000
--- a/apps/cargo-scout-audit/src/detectors.rs
+++ /dev/null
@@ -1,90 +0,0 @@
-use std::path::PathBuf;
-
-use anyhow::{Ok, Result};
-use cargo::Config;
-use itertools::Itertools;
-
-use self::{
-    builder::DetectorBuilder,
-    configuration::{DetectorConfiguration, DetectorsConfigurationList},
-};
-
-mod builder;
-mod configuration;
-mod library;
-mod source;
-
-use cargo_metadata::Metadata;
-pub use configuration::{get_detectors_configuration, get_local_detectors_configuration};
-
-#[derive(Debug)]
-pub struct Detectors {
-    cargo_config: Config,
-    detectors_configs: DetectorsConfigurationList,
-    metadata: Metadata,
-    verbose: bool,
-}
-
-impl Detectors {
-    /// Creates a new instance of `Detectors`
-    pub fn new(
-        cargo_config: Config,
-        detectors_configs: DetectorsConfigurationList,
-        metadata: Metadata,
-        verbose: bool,
-    ) -> Self {
-        Self {
-            cargo_config,
-            detectors_configs,
-            metadata,
-            verbose,
-        }
-    }
-
-    /// Builds detectors and returns the paths to the built libraries
-    pub fn build(self, used_detectors: Vec<String>) -> Result<Vec<PathBuf>> {
-        let detectors_paths = self
-            .detectors_configs
-            .iter()
-            .map(|detectors_config| {
-                self.build_detectors(detectors_config.clone(), used_detectors.clone())
-            })
-            .flatten_ok()
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(detectors_paths)
-    }
-
-    pub fn get_detector_names(&self) -> Result<Vec<String>> {
-        let detectors_names = self
-            .detectors_configs
-            .iter()
-            .map(|detectors_config| {
-                let builder = DetectorBuilder::new(
-                    &self.cargo_config,
-                    detectors_config.clone(),
-                    self.metadata.clone(),
-                    self.verbose,
-                );
-                builder.get_detector_names()
-            })
-            .flatten_ok()
-            .collect::<Result<Vec<_>>>()?;
-
-        Ok(detectors_names)
-    }
-
-    fn build_detectors(
-        &self,
-        detectors_config: DetectorConfiguration,
-        used_detectors: Vec<String>,
-    ) -> Result<Vec<PathBuf>> {
-        let builder = DetectorBuilder::new(
-            &self.cargo_config,
-            detectors_config,
-            self.metadata.clone(),
-            self.verbose,
-        );
-        builder.build(used_detectors)
-    }
-}
diff --git a/apps/cargo-scout-audit/src/detectors/builder.rs b/apps/cargo-scout-audit/src/detectors/builder.rs
deleted file mode 100644
index fcb4b755..00000000
--- a/apps/cargo-scout-audit/src/detectors/builder.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-use std::path::PathBuf;
-
-use anyhow::{bail, ensure, Context, Ok, Result};
-use cargo::Config;
-use cargo_metadata::Metadata;
-use itertools::Itertools;
-
-use super::{configuration::DetectorConfiguration, library::Library, source::download_git_repo};
-use crate::utils::{cargo_package, rustup};
-
-pub struct DetectorBuilder<'a> {
-    cargo_config: &'a Config,
-    detectors_config: DetectorConfiguration,
-    root_metadata: Metadata,
-    verbose: bool,
-}
-
-impl<'a> DetectorBuilder<'a> {
-    /// Creates a new instance of `DetectorsBuilder`.
-    pub fn new(
-        cargo_config: &'a Config,
-        detectors_config: DetectorConfiguration,
-        root_metadata: Metadata,
-        verbose: bool,
-    ) -> Self {
-        Self {
-            cargo_config,
-            detectors_config,
-            root_metadata,
-            verbose,
-        }
-    }
-
-    /// Compiles detector library and returns its path.
-    pub fn build(self, used_detectors: Vec<String>) -> Result<Vec<PathBuf>> {
-        let detector_root = self.download_detector()?;
-        let workspace_path = self.parse_library_path(&detector_root)?;
-        let library = self.get_library(workspace_path)?;
-        let library_paths = self.build_detectors(library)?;
-        let filtered_paths = self.filter_detectors(library_paths, used_detectors)?;
-
-        Ok(filtered_paths)
-    }
-
-    /// Returns list of detector names.
-    pub fn get_detector_names(self) -> Result<Vec<String>> {
-        let detector_root = self.download_detector()?;
-        let workspace_path = self.parse_library_path(&detector_root)?;
-        let library = self.get_library(workspace_path)?;
-        let detector_names = library
-            .metadata
-            .packages
-            .into_iter()
-            .map(|p| p.name)
-            .collect_vec();
-        Ok(detector_names)
-    }
-
-    /// Downloads and returns detector root from supported sources.
-    fn download_detector(&self) -> Result<PathBuf> {
-        if self.detectors_config.dependency.source_id().is_git() {
-            download_git_repo(&self.detectors_config.dependency, self.cargo_config)
-        } else if self.detectors_config.dependency.source_id().is_path() {
-            if let Some(path) = self.detectors_config.dependency.source_id().local_path() {
-                Ok(path)
-            } else {
-                bail!(
-                    "Path source should have a local path: {}",
-                    self.detectors_config.dependency.source_id()
-                )
-            }
-        } else {
-            bail!(format!(
-                "Unsupported source id: {}",
-                self.detectors_config.dependency.source_id()
-            ));
-        }
-    }
-
-    /// Parse dependency root with given library path.
-    fn parse_library_path(&self, dependency_root: &PathBuf) -> Result<PathBuf> {
-        let path = match &self.detectors_config.path {
-            Some(path) => dependency_root.join(path),
-            None => dependency_root.clone(),
-        };
-        let path = dunce::canonicalize(&path)
-            .with_context(|| format!("Could not canonicalize {path:?}"))?;
-        let dependency_root = dunce::canonicalize(dependency_root)
-            .with_context(|| format!("Could not canonicalize {dependency_root:?}"))?;
-        ensure!(
-            path.starts_with(&dependency_root),
-            "Path could refer to `{}`, which is outside of `{}`",
-            path.to_string_lossy(),
-            dependency_root.to_string_lossy()
-        );
-        Ok(path)
-    }
-
-    /// Parse workspace path into library.
-    fn get_library(&self, workspace_path: PathBuf) -> Result<Library> {
-        // Dylint annotation
-        // smoelius: Collecting the package ids before building reveals missing/unparsable `Cargo.toml`
-        // files sooner.
-
-        // smoelius: Why are we doing this complicated dance at all? Because we want to leverage Cargo's
-        // download cache. But we also want to support git repositories with libraries that use
-        // different compiler versions. And we have to work around the fact that "all projects within a
-        // workspace are intended to be built with the same version of the compiler"
-        // (https://github.com/rust-lang/rustup/issues/1399#issuecomment-383376082).
-        ensure!(
-            workspace_path.is_dir(),
-            "Not a directory: {}",
-            workspace_path.to_string_lossy()
-        );
-
-        let package_metadata = cargo_package::package_metadata(&workspace_path)?;
-        let toolchain = rustup::active_toolchain(&workspace_path)?;
-        let library = Library::new(
-            workspace_path,
-            toolchain,
-            self.root_metadata
-                .target_directory
-                .clone()
-                .into_std_path_buf(),
-            package_metadata,
-        );
-        Ok(library)
-    }
-
-    /// Builds detectors returning their compiled paths.
-    fn build_detectors(&self, library: Library) -> Result<Vec<PathBuf>> {
-        let library_paths = library.build(self.verbose)?;
-        Ok(library_paths)
-    }
-
-    fn filter_detectors(
-        &self,
-        detector_paths: Vec<PathBuf>,
-        used_detectors: Vec<String>,
-    ) -> Result<Vec<PathBuf>> {
-        let mut filtered_paths = Vec::new();
-
-        for path in detector_paths {
-            let detector_name = path.file_name().unwrap().to_str().unwrap().to_string();
-
-            #[cfg(not(windows))]
-            let detector_name = detector_name.split("lib").collect::<Vec<_>>()[1];
-
-            let detector_name = detector_name.split('@').collect::<Vec<_>>()[0]
-                .to_string()
-                .replace('_', "-");
-            if used_detectors.contains(&detector_name) {
-                filtered_paths.push(path)
-            } else {
-                std::fs::remove_file(path)?;
-            }
-        }
-
-        Ok(filtered_paths)
-    }
-}
diff --git a/apps/cargo-scout-audit/src/detectors/configuration.rs b/apps/cargo-scout-audit/src/detectors/configuration.rs
deleted file mode 100644
index 171c256d..00000000
--- a/apps/cargo-scout-audit/src/detectors/configuration.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-use std::path::Path;
-
-use anyhow::Result;
-use cargo::{
-    core::{Dependency, GitReference, SourceId},
-    util::IntoUrl,
-};
-
-#[derive(Debug, Clone)]
-pub struct DetectorConfiguration {
-    pub dependency: Dependency,
-    pub path: Option<String>,
-}
-
-pub type DetectorsConfigurationList = Vec<DetectorConfiguration>;
-
-/// Returns list of detectors.
-pub fn get_detectors_configuration() -> Result<DetectorsConfigurationList> {
-    let detectors = vec![DetectorConfiguration {
-        dependency: Dependency::parse(
-            "library",
-            None,
-            SourceId::for_git(
-                &"https://github.com/CoinFabrik/scout".into_url()?,
-                GitReference::DefaultBranch,
-            )?,
-        )?,
-        path: Some("detectors".into()),
-    }];
-
-    Ok(detectors)
-}
-
-/// Returns local detectors configuration from custom path.
-pub fn get_local_detectors_configuration(path: &Path) -> Result<DetectorsConfigurationList> {
-    let detectors = vec![DetectorConfiguration {
-        dependency: Dependency::parse("library", None, SourceId::for_path(path)?)?,
-        path: None,
-    }];
-
-    Ok(detectors)
-}
diff --git a/apps/cargo-scout-audit/src/detectors/library.rs b/apps/cargo-scout-audit/src/detectors/library.rs
deleted file mode 100644
index d8c5b546..00000000
--- a/apps/cargo-scout-audit/src/detectors/library.rs
+++ /dev/null
@@ -1,95 +0,0 @@
-use std::{env::consts, path::PathBuf};
-
-use anyhow::Result;
-use cargo_metadata::Metadata;
-use itertools::Itertools;
-
-use crate::utils::{cargo, env};
-
-/// Represents a Rust library.
-#[derive(Debug, Clone)]
-pub struct Library {
-    pub root: PathBuf,
-    pub toolchain: String,
-    pub target_dir: PathBuf,
-    pub metadata: Metadata,
-}
-
-impl Library {
-    /// Creates a new instance of `Library`.
-    pub fn new(root: PathBuf, toolchain: String, target_dir: PathBuf, metadata: Metadata) -> Self {
-        Self {
-            root,
-            toolchain,
-            target_dir,
-            metadata,
-        }
-    }
-
-    /// Builds the library and returns its path.
-    pub fn build(&self, verbose: bool) -> Result<Vec<PathBuf>> {
-        // Build entire workspace
-        cargo::build("detectors", !verbose)
-            .sanitize_environment()
-            .env_remove(env::RUSTFLAGS)
-            .current_dir(&self.root)
-            .args(["--release"])
-            .success()?;
-
-        // Verify all libraries were built
-        let compiled_library_paths = self
-            .metadata
-            .packages
-            .clone()
-            .into_iter()
-            .map(|p| self.path(p.name))
-            .collect_vec();
-
-        let unexistant_libraries = compiled_library_paths
-            .clone()
-            .into_iter()
-            .filter(|p| !p.exists())
-            .collect_vec();
-        if !unexistant_libraries.is_empty() {
-            anyhow::bail!("Could not determine if {:?} exist", unexistant_libraries);
-        }
-
-        // Copy libraries to target directory
-        let target_dir = self.target_directory();
-        if !target_dir.exists() {
-            std::fs::create_dir_all(&target_dir)?;
-        }
-
-        let target_compiled_library_paths = compiled_library_paths
-            .into_iter()
-            .map(|p| {
-                let target_path = target_dir.join(p.file_name().unwrap());
-                std::fs::copy(&p, &target_path)?;
-                Ok(target_path)
-            })
-            .collect::<Result<Vec<PathBuf>>>()?;
-
-        Ok(target_compiled_library_paths)
-    }
-
-    pub fn target_directory(&self) -> PathBuf {
-        self.target_dir
-            .join("scout/libraries")
-            .join(&self.toolchain)
-    }
-
-    pub fn path(&self, library_name: String) -> PathBuf {
-        self.metadata
-            .target_directory
-            .clone()
-            .into_std_path_buf()
-            .join("release")
-            .join(format!(
-                "{}{}@{}{}",
-                consts::DLL_PREFIX,
-                library_name.replace('-', "_"),
-                self.toolchain,
-                consts::DLL_SUFFIX
-            ))
-    }
-}
diff --git a/apps/cargo-scout-audit/src/detectors/source/git.rs b/apps/cargo-scout-audit/src/detectors/source/git.rs
deleted file mode 100644
index c6892d80..00000000
--- a/apps/cargo-scout-audit/src/detectors/source/git.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-use std::path::PathBuf;
-
-use anyhow::{anyhow, bail, ensure, Result};
-use cargo::{
-    core::{source::MaybePackage, Dependency, Package, PackageId, QueryKind, Source},
-    Config,
-};
-
-/// Downloads git repo using cargo native cache and returns its path.
-pub fn download_git_repo(dependency: &Dependency, config: &Config) -> Result<PathBuf> {
-    let _lock = config.acquire_package_cache_lock()?;
-    let mut source = dependency.source_id().load(config, &Default::default())?;
-    let package_id = sample_package_id(dependency, &mut *source)?;
-
-    if let MaybePackage::Ready(package) = source.download(package_id)? {
-        git_dependency_root_from_package(config, &*source, &package)
-    } else {
-        bail!(format!("`{}` is not ready", package_id.name()))
-    }
-}
-
-fn sample_package_id(dep: &Dependency, source: &mut dyn Source) -> anyhow::Result<PackageId> {
-    let mut package_id: Option<PackageId> = None;
-
-    while {
-        let poll = source.query(dep, QueryKind::Fuzzy, &mut |summary| {
-            if package_id.is_none() {
-                package_id = Some(summary.package_id());
-            }
-        })?;
-        if poll.is_pending() {
-            source.block_until_ready()?;
-            package_id.is_none()
-        } else {
-            false
-        }
-    } {}
-
-    package_id.ok_or_else(|| anyhow!("Found no packages in `{}`", dep.source_id()))
-}
-
-fn git_dependency_root_from_package<'a>(
-    config: &'a Config,
-    source: &(dyn Source + 'a),
-    package: &Package,
-) -> anyhow::Result<PathBuf> {
-    let package_root = package.root();
-
-    if source.source_id().is_git() {
-        let git_path = config.git_path();
-        let git_path = config.assert_package_cache_locked(&git_path);
-        ensure!(
-            package_root.starts_with(git_path.join("checkouts")),
-            "Unexpected path: {}",
-            package_root.to_string_lossy()
-        );
-        let n = git_path.components().count() + 3;
-        Ok(package_root.components().take(n).collect())
-    } else if source.source_id().is_path() {
-        unreachable!()
-    } else {
-        unimplemented!()
-    }
-}
diff --git a/apps/cargo-scout-audit/src/detectors/source/mod.rs b/apps/cargo-scout-audit/src/detectors/source/mod.rs
deleted file mode 100644
index c6709e47..00000000
--- a/apps/cargo-scout-audit/src/detectors/source/mod.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-mod git;
-
-pub use git::download_git_repo;
diff --git a/apps/cargo-scout-audit/src/lib.rs b/apps/cargo-scout-audit/src/lib.rs
deleted file mode 100644
index 55e0bf7f..00000000
--- a/apps/cargo-scout-audit/src/lib.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-pub mod detectors;
-pub mod startup;
-pub mod utils;
diff --git a/apps/cargo-scout-audit/src/main.rs b/apps/cargo-scout-audit/src/main.rs
deleted file mode 100644
index 3f2652a3..00000000
--- a/apps/cargo-scout-audit/src/main.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-use cargo_scout_audit::startup::{run_scout, CargoSubCommand, Cli};
-use clap::Parser;
-
-fn main() {
-    env_logger::init();
-
-    let cli = Cli::parse();
-    match cli.subcmd {
-        CargoSubCommand::ScoutAudit(opts) => run_scout(opts).unwrap(),
-    }
-}
diff --git a/apps/cargo-scout-audit/src/startup.rs b/apps/cargo-scout-audit/src/startup.rs
deleted file mode 100644
index ac1a4ae8..00000000
--- a/apps/cargo-scout-audit/src/startup.rs
+++ /dev/null
@@ -1,260 +0,0 @@
-use core::panic;
-use std::{fs, path::PathBuf};
-
-use anyhow::{bail, Context, Result};
-use cargo::Config;
-use cargo_metadata::MetadataCommand;
-use clap::{Parser, Subcommand, ValueEnum};
-use dylint::Dylint;
-
-use crate::{
-    detectors::{get_detectors_configuration, get_local_detectors_configuration, Detectors},
-    utils::{
-        detectors::{get_excluded_detectors, get_filtered_detectors, list_detectors},
-        output::{format_into_html, format_into_json, format_into_sarif},
-    },
-};
-
-#[derive(Debug, Parser)]
-#[clap(display_name = "cargo")]
-pub struct Cli {
-    #[clap(subcommand)]
-    pub subcmd: CargoSubCommand,
-}
-
-#[derive(Debug, Subcommand)]
-pub enum CargoSubCommand {
-    ScoutAudit(Scout),
-}
-#[derive(Debug, Default, Clone, ValueEnum, PartialEq)]
-pub enum OutputFormat {
-    #[default]
-    Text,
-    Json,
-    Html,
-    Sarif,
-}
-
-#[derive(Clone, Debug, Default, Parser)]
-#[command(author, version, about, long_about = None)]
-pub struct Scout {
-    #[clap(short, long, value_name = "path", help = "Path to Cargo.toml.")]
-    pub manifest_path: Option<PathBuf>,
-
-    // Exlude detectors
-    #[clap(
-        short,
-        long,
-        value_name = "detector/s",
-        help = "Exclude the given detectors, separated by commas."
-    )]
-    pub exclude: Option<String>,
-
-    // Filter by detectors
-    #[clap(
-        short,
-        long,
-        value_name = "detector/s",
-        help = "Filter by the given detectors, separated by commas."
-    )]
-    pub filter: Option<String>,
-
-    // List all the available detectors
-    #[clap(short, long, help = "List all the available detectors")]
-    pub list_detectors: bool,
-
-    #[clap(last = true, help = "Arguments for `cargo check`.")]
-    pub args: Vec<String>,
-
-    #[clap(
-        short,
-        long,
-        value_name = "type",
-        help = "Sets the output type",
-        default_value = "text"
-    )]
-    pub output_format: OutputFormat,
-
-    #[clap(long, value_name = "path", help = "Path to the output file.")]
-    pub output_path: Option<PathBuf>,
-
-    #[clap(long, value_name = "path", help = "Path to detectors workspace.")]
-    pub local_detectors: Option<PathBuf>,
-
-    #[clap(
-        short,
-        long,
-        help = "Prints verbose information.",
-        default_value_t = false
-    )]
-    pub verbose: bool,
-}
-
-pub fn run_scout(opts: Scout) -> Result<()> {
-    // Validations
-    if opts.filter.is_some() && opts.exclude.is_some() {
-        panic!("You can't use `--exclude` and `--filter` at the same time.");
-    }
-
-    if let Some(path) = &opts.output_path {
-        if path.is_dir() {
-            bail!("The output path can't be a directory.");
-        }
-    }
-
-    // Prepare configurations
-    let mut metadata = MetadataCommand::new();
-    if let Some(manifest_path) = &opts.manifest_path {
-        metadata.manifest_path(manifest_path);
-    }
-    let metadata = metadata.exec().context("Failed to get metadata")?;
-
-    let cargo_config = Config::default().context("Failed to get config")?;
-    cargo_config.shell().set_verbosity(if opts.verbose {
-        cargo::core::Verbosity::Verbose
-    } else {
-        cargo::core::Verbosity::Quiet
-    });
-    let detectors_config = match &opts.local_detectors {
-        Some(path) => get_local_detectors_configuration(&PathBuf::from(path))
-            .context("Failed to get local detectors configuration")?,
-        None => get_detectors_configuration().context("Failed to get detectors configuration")?,
-    };
-
-    // Misc configurations
-    // If there is a need to exclude or filter by detector, the dylint tool needs to be recompiled.
-    // TODO: improve detector system so that doing this isn't necessary.
-    if opts.exclude.is_some() || opts.filter.is_some() {
-        remove_target_dylint(&opts.manifest_path)?;
-    }
-
-    // Instantiate detectors
-    let detectors = Detectors::new(cargo_config, detectors_config, metadata, opts.verbose);
-    let detectors_names = detectors
-        .get_detector_names()
-        .context("Failed to build detectors")?;
-
-    if opts.list_detectors {
-        list_detectors(detectors_names);
-        return Ok(());
-    }
-
-    let used_detectors = if let Some(filter) = &opts.filter {
-        get_filtered_detectors(filter.to_string(), detectors_names)?
-    } else if let Some(excluded) = &opts.exclude {
-        get_excluded_detectors(excluded.to_string(), detectors_names)?
-    } else {
-        detectors_names
-    };
-
-    let detectors_paths = detectors
-        .build(used_detectors)
-        .context("Failed to build detectors")?;
-
-    // Run dylint
-    run_dylint(detectors_paths, opts).context("Failed to run dylint")?;
-
-    Ok(())
-}
-
-fn run_dylint(detectors_paths: Vec<PathBuf>, opts: Scout) -> Result<()> {
-    // Convert detectors paths to string
-    let detectors_paths: Vec<String> = detectors_paths
-        .iter()
-        .map(|path| path.to_string_lossy().to_string())
-        .collect();
-
-    // Initialize options
-    let stderr_temp_file = tempfile::NamedTempFile::new()?;
-    let stdout_temp_file = tempfile::NamedTempFile::new()?;
-
-    let is_output_stdout = opts.output_format == OutputFormat::Text && opts.output_path.is_none();
-
-    let pipe_stdout = Some(stdout_temp_file.path().to_string_lossy().to_string());
-    let pipe_stderr = if is_output_stdout {
-        None
-    } else {
-        Some(stderr_temp_file.path().to_string_lossy().to_string())
-    };
-
-    let options = Dylint {
-        paths: detectors_paths,
-        args: opts.args,
-        manifest_path: opts.manifest_path.map(|p| p.to_string_lossy().to_string()),
-        pipe_stdout,
-        pipe_stderr,
-        quiet: !opts.verbose,
-        ..Default::default()
-    };
-
-    dylint::run(&options)?;
-
-    // Format output and write to file (if necessary)
-    if is_output_stdout {
-        return Ok(());
-    }
-
-    let mut stderr_file = fs::File::open(stderr_temp_file.path())?;
-    let stdout_file = fs::File::open(stdout_temp_file.path())?;
-
-    match opts.output_format {
-        OutputFormat::Json => {
-            let mut json_file = match &opts.output_path {
-                Some(path) => fs::File::create(path)?,
-                None => fs::File::create("report.json")?,
-            };
-            std::io::Write::write_all(
-                &mut json_file,
-                format_into_json(stderr_file, stdout_file)?.as_bytes(),
-            )?;
-        }
-        OutputFormat::Html => {
-            let mut html_file = match &opts.output_path {
-                Some(path) => fs::File::create(path)?,
-                None => fs::File::create("report.html")?,
-            };
-            std::io::Write::write_all(
-                &mut html_file,
-                format_into_html(stderr_file, stdout_file)?.as_bytes(),
-            )?;
-        }
-        OutputFormat::Text => {
-            // If the output path is not set, dylint prints the report to stdout
-            if let Some(output_file) = opts.output_path {
-                let mut txt_file = fs::File::create(output_file)?;
-                std::io::copy(&mut stderr_file, &mut txt_file)?;
-            }
-        }
-        OutputFormat::Sarif => {
-            let mut sarif_file = match &opts.output_path {
-                Some(path) => fs::File::create(path)?,
-                None => fs::File::create("report.sarif")?,
-            };
-            std::io::Write::write_all(
-                &mut sarif_file,
-                format_into_sarif(stderr_file, stdout_file)?.as_bytes(),
-            )?;
-        }
-    }
-
-    stderr_temp_file.close()?;
-    stdout_temp_file.close()?;
-
-    Ok(())
-}
-
-fn remove_target_dylint(manifest_path: &Option<PathBuf>) -> Result<()> {
-    let target_dylint_path = match manifest_path {
-        Some(manifest_path) => {
-            let manifest_path_parent = manifest_path
-                .parent()
-                .context("Error getting manifest path parent")?;
-            manifest_path_parent.join("target").join("dylint")
-        }
-        None => std::env::current_dir()?.join("target").join("dylint"),
-    };
-    if target_dylint_path.exists() {
-        fs::remove_dir_all(target_dylint_path)?;
-    }
-    Ok(())
-}
diff --git a/apps/cargo-scout-audit/src/utils/cargo.rs b/apps/cargo-scout-audit/src/utils/cargo.rs
deleted file mode 100644
index 9f78a6e6..00000000
--- a/apps/cargo-scout-audit/src/utils/cargo.rs
+++ /dev/null
@@ -1,51 +0,0 @@
-#[cfg(windows)]
-use std::path::Path;
-use std::{
-    io::{IsTerminal, Write},
-    process::Stdio,
-};
-
-use ansi_term::Style;
-
-use super::command::Command;
-
-#[must_use]
-pub fn build(description: &str, quiet: bool) -> Command {
-    cargo("build", "Building", description, quiet)
-}
-fn cargo(subcommand: &str, verb: &str, description: &str, quiet: bool) -> Command {
-    if !quiet {
-        // smoelius: Writing directly to `stderr` avoids capture by `libtest`.
-        let message = format!("{verb} {description}");
-        std::io::stderr()
-            .write_fmt(format_args!(
-                "{}\n",
-                if std::io::stdout().is_terminal() {
-                    Style::new().bold()
-                } else {
-                    Style::new()
-                }
-                .paint(message)
-            ))
-            .expect("Could not write to stderr");
-    }
-    let mut command = Command::new("cargo");
-    #[cfg(windows)]
-    {
-        // Dylint annotation
-        // smoelius: Work around: https://github.com/rust-lang/rustup/pull/2978
-        let cargo_home = home::cargo_home().unwrap();
-        let old_path = std::env::var("PATH").unwrap();
-        let new_path = std::env::join_paths(
-            std::iter::once(Path::new(&cargo_home).join("bin"))
-                .chain(std::env::split_paths(&old_path)),
-        )
-        .unwrap();
-        command.envs(vec![("PATH", new_path)]);
-    }
-    command.args([subcommand]);
-    if quiet {
-        command.stderr(Stdio::null());
-    }
-    command
-}
diff --git a/apps/cargo-scout-audit/src/utils/cargo_package.rs b/apps/cargo-scout-audit/src/utils/cargo_package.rs
deleted file mode 100644
index fe631239..00000000
--- a/apps/cargo-scout-audit/src/utils/cargo_package.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-use std::path::Path;
-
-use cargo_metadata::{Metadata, MetadataCommand};
-
-pub fn package_metadata(package_root: &Path) -> Result<Metadata, cargo_metadata::Error> {
-    MetadataCommand::new()
-        .current_dir(package_root)
-        .no_deps()
-        .exec()
-}
diff --git a/apps/cargo-scout-audit/src/utils/command.rs b/apps/cargo-scout-audit/src/utils/command.rs
deleted file mode 100644
index 6421d871..00000000
--- a/apps/cargo-scout-audit/src/utils/command.rs
+++ /dev/null
@@ -1,129 +0,0 @@
-use std::{
-    ffi::OsStr,
-    path::Path,
-    process::{Command as StdCommand, Output, Stdio},
-};
-
-use anyhow::{ensure, Context, Result};
-
-use super::env;
-
-pub struct Command {
-    command: StdCommand,
-}
-
-impl Command {
-    pub fn new<S: AsRef<OsStr>>(program: S) -> Self {
-        Self {
-            command: StdCommand::new(program),
-        }
-    }
-
-    pub fn args<I, S>(&mut self, args: I) -> &mut Self
-    where
-        I: IntoIterator<Item = S>,
-        S: AsRef<OsStr>,
-    {
-        self.command.args(args);
-        self
-    }
-
-    #[allow(dead_code)]
-    pub fn envs<I, K, V>(&mut self, vars: I) -> &mut Self
-    where
-        I: IntoIterator<Item = (K, V)>,
-        K: AsRef<OsStr>,
-        V: AsRef<OsStr>,
-    {
-        self.command.envs(vars);
-        self
-    }
-
-    pub fn env_remove<K: AsRef<OsStr>>(&mut self, key: K) -> &mut Self {
-        self.command.env_remove(key);
-        self
-    }
-
-    pub fn current_dir<P: AsRef<Path>>(&mut self, dir: P) -> &mut Self {
-        self.command.current_dir(dir);
-        self
-    }
-
-    #[allow(dead_code)]
-    pub fn stdout<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self {
-        self.command.stdout(cfg);
-        self
-    }
-
-    pub fn stderr<T: Into<Stdio>>(&mut self, cfg: T) -> &mut Self {
-        self.command.stderr(cfg);
-        self
-    }
-
-    pub fn sanitize_environment(&mut self) -> &mut Self {
-        self.env_remove(env::RUSTC);
-        self.env_remove(env::RUSTUP_TOOLCHAIN);
-        self
-    }
-
-    pub fn output(&mut self) -> Result<Output> {
-        log::debug!("{:?}", self.command.get_envs().collect::<Vec<_>>());
-        log::debug!("{:?}", self.command.get_current_dir());
-        log::debug!("{:?}", self.command);
-
-        let output = self
-            .command
-            .output()
-            .with_context(|| format!("Could not get output of `{:?}`", self.command))?;
-
-        ensure!(
-            output.status.success(),
-            "command failed: {:?}\nstdout: {:?}\nstderr: {:?}",
-            self.command,
-            std::str::from_utf8(&output.stdout).unwrap_or_default(),
-            std::str::from_utf8(&output.stderr).unwrap_or_default()
-        );
-
-        Ok(output)
-    }
-
-    pub fn success(&mut self) -> Result<()> {
-        log::debug!("{:?}", self.command.get_envs().collect::<Vec<_>>());
-        log::debug!("{:?}", self.command.get_current_dir());
-        log::debug!("{:?}", self.command);
-
-        let status = self
-            .command
-            .status()
-            .with_context(|| format!("Could not get status of `{:?}`", self.command))?;
-
-        ensure!(status.success(), "command failed: {:?}", self.command);
-
-        Ok(())
-    }
-}
-
-#[allow(unused_variables)]
-#[allow(dead_code)]
-pub fn driver(toolchain: &str, driver: &Path) -> Result<Command> {
-    #[allow(unused_mut)]
-    let mut command = Command::new(driver);
-    #[cfg(windows)]
-    {
-        // MinerSebas: To succesfully determine the dylint driver Version on Windows,
-        // it is neccesary to add some Libraries to the Path.
-        let rustup_home = std::env::var("RUSTUP_HOME")?;
-        let old_path = std::env::var("PATH")?;
-        let new_path = std::env::join_paths(
-            std::iter::once(
-                Path::new(&rustup_home)
-                    .join("toolchains")
-                    .join(toolchain)
-                    .join("bin"),
-            )
-            .chain(std::env::split_paths(&old_path)),
-        )?;
-        command.envs(vec![("PATH", new_path)]);
-    }
-    Ok(command)
-}
diff --git a/apps/cargo-scout-audit/src/utils/detectors.rs b/apps/cargo-scout-audit/src/utils/detectors.rs
deleted file mode 100644
index df3be387..00000000
--- a/apps/cargo-scout-audit/src/utils/detectors.rs
+++ /dev/null
@@ -1,60 +0,0 @@
-use anyhow::bail;
-use anyhow::Result;
-
-fn get_parsed_detectors(detectors: String) -> Vec<String> {
-    detectors
-        .to_lowercase()
-        .trim()
-        .replace('_', "-")
-        .split(',')
-        .map(|detector| detector.trim().to_string())
-        .collect::<Vec<String>>()
-}
-
-pub fn get_filtered_detectors(filter: String, detectors_names: Vec<String>) -> Result<Vec<String>> {
-    let mut used_detectors: Vec<String> = Vec::new();
-    let parsed_detectors = get_parsed_detectors(filter);
-    for detector in parsed_detectors {
-        if detectors_names.contains(&detector.to_string()) {
-            used_detectors.push(detector.to_string());
-        } else {
-            bail!("The detector '{}' doesn't exist", detector);
-        }
-    }
-    Ok(used_detectors)
-}
-
-pub fn get_excluded_detectors(
-    excluded: String,
-    detectors_names: Vec<String>,
-) -> Result<Vec<String>> {
-    let mut used_detectors = detectors_names.clone();
-    let parsed_detectors = get_parsed_detectors(excluded);
-    for detector in parsed_detectors {
-        if detectors_names.contains(&detector.to_string()) {
-            let index = used_detectors.iter().position(|x| x == &detector).unwrap();
-            used_detectors.remove(index);
-        } else {
-            bail!("The detector '{}' doesn't exist", detector);
-        }
-    }
-    Ok(used_detectors)
-}
-
-pub fn list_detectors(detectors_names: Vec<String>) {
-    let separator = "─".repeat(48);
-    let upper_border = format!("┌{}┐", separator);
-    let lower_border = format!("└{}┘", separator);
-    let empty_line = format!("│{:48}│", "");
-
-    println!("{}", upper_border);
-    println!("│{:^47}│", "🔍 Available detectors:");
-    println!("{}", empty_line);
-
-    for (index, detector_name) in detectors_names.iter().enumerate() {
-        println!("│ {:>2}. {:<43}│", index + 1, detector_name);
-    }
-
-    println!("{}", empty_line);
-    println!("{}", lower_border);
-}
diff --git a/apps/cargo-scout-audit/src/utils/env.rs b/apps/cargo-scout-audit/src/utils/env.rs
deleted file mode 100644
index 06aa920f..00000000
--- a/apps/cargo-scout-audit/src/utils/env.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-#![allow(dead_code)]
-
-macro_rules! declare_const {
-    ($var: ident) => {
-        pub const $var: &str = stringify!($var);
-    };
-}
-
-declare_const!(CARGO_HOME);
-declare_const!(CARGO_MANIFEST_DIR);
-declare_const!(CARGO_PKG_NAME);
-declare_const!(CARGO_TARGET_DIR);
-declare_const!(CARGO_TERM_COLOR);
-declare_const!(CLIPPY_DISABLE_DOCS_LINKS);
-declare_const!(CLIPPY_DRIVER_PATH);
-declare_const!(DOCS_RS);
-declare_const!(DYLINT_DRIVER_PATH);
-declare_const!(DYLINT_LIBRARY_PATH);
-declare_const!(DYLINT_LIBS);
-declare_const!(DYLINT_LIST);
-declare_const!(DYLINT_RUSTFLAGS);
-declare_const!(DYLINT_TOML);
-declare_const!(OUT_DIR);
-declare_const!(PATH);
-declare_const!(RUSTC);
-declare_const!(RUSTC_WORKSPACE_WRAPPER);
-declare_const!(RUSTFLAGS);
-declare_const!(RUSTUP_HOME);
-declare_const!(RUSTUP_TOOLCHAIN);
-declare_const!(RUST_BACKTRACE);
-declare_const!(TARGET);
diff --git a/apps/cargo-scout-audit/src/utils/mod.rs b/apps/cargo-scout-audit/src/utils/mod.rs
deleted file mode 100644
index 5fa76e9c..00000000
--- a/apps/cargo-scout-audit/src/utils/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-pub mod cargo;
-pub mod cargo_package;
-pub mod command;
-pub mod detectors;
-pub mod env;
-pub mod output;
-pub mod rustup;
diff --git a/apps/cargo-scout-audit/src/utils/output.rs b/apps/cargo-scout-audit/src/utils/output.rs
deleted file mode 100644
index dfbb366e..00000000
--- a/apps/cargo-scout-audit/src/utils/output.rs
+++ /dev/null
@@ -1,201 +0,0 @@
-use std::collections::HashMap;
-use std::fs::File;
-use std::io::BufRead;
-use std::vec;
-
-use anyhow::Context;
-use regex::RegexBuilder;
-use scout_audit_internal::{Detector, IntoEnumIterator};
-use serde_json::{json, Value};
-
-pub fn format_into_json(scout_output: File, internals: File) -> anyhow::Result<String> {
-    let json_errors = jsonify(scout_output, internals)?;
-    Ok(serde_json::to_string_pretty(&json_errors)?)
-}
-
-fn jsonify(scout_output: File, internals: File) -> anyhow::Result<serde_json::Value> {
-    let json_errors: serde_json::Value = get_errors_from_output(scout_output, internals)?
-        .iter()
-        .filter(|(_, (spans, _))| !spans.is_empty())
-        .map(|(name, (spans, error))| {
-            (
-                name,
-                json!({
-                    "error_msg": error,
-                    "spans": spans
-                }),
-            )
-        })
-        .collect();
-
-    Ok(json_errors)
-}
-
-fn get_errors_from_output(
-    mut scout_output: File,
-    mut scout_internals: File,
-) -> anyhow::Result<HashMap<String, (Vec<String>, String)>> {
-    let regex = RegexBuilder::new(r"warning:.*")
-        .multi_line(true)
-        .case_insensitive(true)
-        .build()?;
-
-    let mut stderr_string = String::new();
-    std::io::Read::read_to_string(&mut scout_output, &mut stderr_string)?;
-
-    let mut scout_internals_spans: Vec<String> = vec![];
-
-    for line in std::io::BufReader::new(&mut scout_internals).lines() {
-        let line = line?;
-        let span = line.split('@').collect::<Vec<&str>>()[1];
-        scout_internals_spans.push(span.to_string());
-    }
-
-    let msg_to_name: HashMap<String, String> = Detector::iter()
-        .map(|e| (e.get_lint_message().to_string(), e.to_string()))
-        .collect();
-
-    let mut errors: HashMap<String, (Vec<String>, String)> = Detector::iter()
-        .map(|e| (e.to_string(), (vec![], "".to_string())))
-        .collect();
-
-    for (i, elem) in regex.find_iter(&stderr_string).enumerate() {
-        let parts = elem.as_str().split('\n').collect::<Vec<&str>>();
-
-        for err in Detector::iter().map(|e| e.get_lint_message()) {
-            if parts[0].contains(err) {
-                let name = msg_to_name.get(err).with_context(|| {
-                    format!("Error making json: {} not found in the error map", err)
-                })?;
-
-                if let Some((spans, error)) = errors.get_mut(name) {
-                    spans.push(scout_internals_spans[i].to_string());
-                    *error = err.to_string();
-                }
-            }
-        }
-    }
-    Ok(errors)
-}
-
-pub fn format_into_html(scout_output: File, internals: File) -> anyhow::Result<String> {
-    let json = jsonify(scout_output, internals)?;
-    let mut html = String::new();
-    html.push_str(
-        r#"
-    <!DOCTYPE html>
-    <html>
-    <head>
-    <style>
-    body {
-      font-family: monospace;
-      font-size: 1rem;
-    }
-    table {
-      border-collapse: collapse;
-    }
-    td, th {
-      border: 1px solid #999;
-      padding: 0.5rem;
-    }
-    th {
-      background-color: #eee;
-    }
-    </style>
-    </head>
-    <body>
-    <table>
-    <tr>
-    <th>Error</th>
-    <th>Spans</th>
-    <th>Message</th>
-    </tr>
-    "#,
-    );
-
-    for (key, value) in json.as_object().unwrap() {
-        let error_msg = value["error_msg"].as_str().unwrap();
-        let spans = value["spans"].as_array().unwrap();
-        let mut spans_html = String::new();
-        for span in spans {
-            spans_html.push_str(&format!("<li>{}</li>", span.as_str().unwrap()));
-        }
-        html.push_str(&format!(
-            r#"
-        <tr>
-        <td>{}</td>
-        <td><ul>{}</ul></td>
-        <td>{}</td>
-        </tr>
-        "#,
-            key, spans_html, error_msg
-        ));
-    }
-
-    Ok(html)
-}
-
-fn serify(scout_output: File, scout_internals: File) -> anyhow::Result<serde_json::Value> {
-    let errors: HashMap<String, (Vec<String>, String)> =
-        get_errors_from_output(scout_output, scout_internals)?;
-
-    let sarif_output = json!({
-        "$schema": "https://json.schemastore.org/sarif-2.1.0",
-        "version": "2.1.0",
-        "runs": [
-            {
-                "tool": {
-                    "driver": {
-                        "name": env!("CARGO_PKG_NAME"),
-                        "version": env!("CARGO_PKG_VERSION"),
-                        "rules": Detector::iter().filter(|e| {
-                            errors.contains_key(&e.to_string()) && !errors.get(&e.to_string()).unwrap().0.is_empty()
-                        }).map(|e| {
-                            json!({
-                                "id": e.to_string(),
-                                "shortDescription": {
-                                    "text": e.get_lint_message()
-                                }})
-
-                        }).collect::<Vec<serde_json::Value>>(),
-                        "informationUri": "https://coinfabrik.github.io/scout/",
-                    }
-                },
-                "results": build_sarif_results(&errors)?,
-            }
-        ]
-    });
-    let json_errors = serde_json::to_value(sarif_output)?;
-    Ok(json_errors)
-}
-
-pub fn format_into_sarif(scout_output: File, scout_internals: File) -> anyhow::Result<String> {
-    Ok(serify(scout_output, scout_internals)?.to_string())
-}
-
-fn build_sarif_results(
-    errors: &HashMap<String, (Vec<String>, String)>,
-) -> anyhow::Result<Vec<serde_json::Value>> {
-    let runs: Vec<Value> = errors
-        .iter()
-        .flat_map(|(name, (spans, msg))| {
-            spans.iter().filter_map(move |span| {
-                let span: Result<serde_json::Value, _> = serde_json::from_str(span);
-                if let Ok(span_value) = span {
-                    Some(json!({
-                        "ruleId": name,
-                        "level": "error",
-                        "message": {
-                            "text": msg
-                        },
-                        "locations": [span_value],
-                    }))
-                } else {
-                    None
-                }
-            })
-        })
-        .collect();
-
-    Ok(runs)
-}
diff --git a/apps/cargo-scout-audit/src/utils/rustup.rs b/apps/cargo-scout-audit/src/utils/rustup.rs
deleted file mode 100644
index 929a4089..00000000
--- a/apps/cargo-scout-audit/src/utils/rustup.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-use std::path::Path;
-
-use anyhow::{anyhow, Result};
-
-use super::command::Command;
-
-/// Returns `rustup` active toolchain
-///
-/// Dylint annotation
-/// smoelius: Consider carefully whether you need to call this function! In most cases, the toolchain
-/// you want is not the one returned by rustup.
-pub fn active_toolchain(path: &Path) -> Result<String> {
-    let output = Command::new("rustup")
-        .sanitize_environment()
-        .current_dir(path)
-        .args(["show", "active-toolchain"])
-        .output()?;
-    let stdout = std::str::from_utf8(&output.stdout)?;
-    stdout
-        .split_once(' ')
-        .map(|(s, _)| s.to_owned())
-        .ok_or_else(|| anyhow!("Could not determine active toolchain"))
-}
diff --git a/apps/cargo-scout-audit/tests/README.md b/apps/cargo-scout-audit/tests/README.md
deleted file mode 100644
index 272ce747..00000000
--- a/apps/cargo-scout-audit/tests/README.md
+++ /dev/null
@@ -1,39 +0,0 @@
-# Acceptance Criteria for Tests in Rust
-
-This document provides the acceptance criteria for writing and executing tests in Rust. The examples are drawn from the provided files: `test.rs` (which contains the logic to perform the tests) and `test-configuration.yaml` (which contains the paths and configurations for the tests).
-
-## Acceptance Criteria for Adding Examples and Ensuring Tests Work
-
-### 1. Valid YAML Structure
-
-The `test-configuration.yaml` file must be a valid YAML file that follows the specific structure of `detectors`. Each `detector` should have a unique name and include a `DetectorConfig` object.
-
-### 2. Warning Message
-
-Each `DetectorConfig` must include a `warning_message`. This message is expected to appear in the output when a test against a vulnerable path is executed. The `warning_message` should be specific and unique to the vulnerability that the detector is designed to identify.
-
-### 3. Examples
-
-Each `DetectorConfig` must also include at least one `Example` object. An `Example` consists of a `vulnerable_path` and a `remediated_path`.
-
-### 4. Path Specification
-
-The `vulnerable_path` and `remediated_path` in each `Example` must point to valid `Cargo.toml` files in the project. These paths are relative to the directory where the tests are executed from.
-
-- `vulnerable_path`: This is the path to the project file of the code that is expected to contain the vulnerability.
-- `remediated_path`: This is the path to the project file of the code that has been remediated and is expected to be free of the vulnerability.
-
-### 5. Path Validation
-
-All paths specified in the `vulnerable_path` and `remediated_path` must be valid and the referenced `Cargo.toml` files should exist. If a path is invalid or the referenced file does not exist, the test will fail.
-
-### 6. Successful Command Execution
-
-Each `Example` will be tested by executing the `cargo scout-audit` command with the provided paths. The test must be able to execute this command successfully. If the command execution fails, the test will fail.
-
-### 7. Proper Linter Output Validation
-
-Each `Example` will be tested by running our Rust linter using the `cargo scout-audit` command. The output generated by this linter is then compared against the `warning_message` specified in the `DetectorConfig`.
-
-- If the `Example` is a `vulnerable_path`, the linter output (specifically, the `stderr` or error stream) should contain the `warning_message`. If the linter output does not contain the expected warning, the test will fail.
-- If the `Example` is a `remediated_path`, the linter output should not contain the `warning_message`. If the linter output still contains the warning, indicating a detected vulnerability, the test will fail.
diff --git a/apps/cargo-scout-audit/tests/integration_tests/detectors.rs b/apps/cargo-scout-audit/tests/integration_tests/detectors.rs
deleted file mode 100644
index a3f8e616..00000000
--- a/apps/cargo-scout-audit/tests/integration_tests/detectors.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-use std::collections::HashMap;
-use std::io::Read;
-use std::path::PathBuf;
-
-use cargo_scout_audit::startup::{run_scout, OutputFormat, Scout};
-use colored::Colorize;
-use configuration::Configuration;
-use serde::{Deserialize, Serialize};
-
-mod configuration;
-mod utils;
-
-#[derive(Debug, Serialize, Deserialize)]
-pub struct Detectors {
-    detectors: HashMap<String, DetectorConfig>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct DetectorConfig {
-    warning_message: String,
-    testcases: Vec<Testcase>,
-}
-
-#[derive(Debug, Serialize, Deserialize)]
-struct Testcase {
-    vulnerable_path: Option<String>,
-    remediated_path: Option<String>,
-}
-
-/// Test that all detectors run successfully on testcases and
-/// that lint messages match the expected ones.
-///
-/// The following environment variable can be used:
-///
-/// - `INTEGRATION_TESTS_TO_RUN`: comma separated list of integration tests to run.
-///  If not set, all integration tests are run.
-#[test]
-fn test() {
-    // Get environment variable to determine integration tests to run
-    let integration_tests_to_run = std::env::var("INTEGRATION_TESTS_TO_RUN")
-        .ok()
-        .map(|e| e.split(',').map(|s| s.to_string()).collect::<Vec<String>>());
-    let mut ran_integration_tests =
-        vec![false; integration_tests_to_run.as_ref().map_or(0, |v| v.len())];
-
-    // Get the configuration
-    let detectors_config = Configuration::build()
-        .unwrap_or_else(|_| panic!("{}", "Failed to get the configuration".red().to_string()));
-
-    // Run all integration tests
-    for detector_config in detectors_config.detectors.iter() {
-        let detector_name = detector_config.detector.to_string();
-        let lint_message = detector_config.detector.get_lint_message();
-
-        if let Some(integration_tests_to_run) = &integration_tests_to_run {
-            let integration_tests_to_run_i = integration_tests_to_run
-                .iter()
-                .position(|t| t == &detector_name);
-            match integration_tests_to_run_i {
-                Some(i) => ran_integration_tests[i] = true,
-                None => continue,
-            };
-        }
-
-        println!("\n{} {}", "Testing detector:".bright_cyan(), detector_name);
-        for example in detector_config.testcases.iter() {
-            if let Some(vulnerable_path) = &example.vulnerable_path {
-                execute_and_validate_testcase(&detector_name, lint_message, vulnerable_path, true);
-            }
-            if let Some(remediated_path) = &example.remediated_path {
-                execute_and_validate_testcase(&detector_name, lint_message, remediated_path, false);
-            }
-        }
-    }
-
-    // If integration tests to run were specified, check that all of them were run
-    if let Some(integration_tests_to_run) = &integration_tests_to_run {
-        let panic_exit = ran_integration_tests.iter().any(|t| !t);
-        for (i, ran_integration_test) in ran_integration_tests.iter().enumerate() {
-            if !ran_integration_test {
-                println!(
-                    "{} {}",
-                    "Error: integration test not found:".bright_red(),
-                    integration_tests_to_run[i]
-                );
-            }
-        }
-        if panic_exit {
-            panic!();
-        }
-    }
-}
-
-fn execute_and_validate_testcase(
-    detector_name: &str,
-    lint_message: &str,
-    path: &str,
-    is_vulnerable: bool,
-) {
-    print!("{} {}", "Running testcase:".green(), path);
-    let start_time = std::time::Instant::now();
-
-    // Create tempfile for storing the output
-    let mut tempfile = tempfile::NamedTempFile::new().expect("Failed to create tempfile");
-
-    // Run scout
-    let scout_config = Scout {
-        output_format: OutputFormat::Text,
-        output_path: Some(PathBuf::from(tempfile.path())),
-        local_detectors: Some(get_detectors_path()),
-        manifest_path: Some(PathBuf::from(path.to_string())),
-        filter: Some(detector_name.to_string()),
-        verbose: true,
-        ..Default::default()
-    };
-    run_scout(scout_config).unwrap();
-
-    // Read output
-    let mut output = String::new();
-    tempfile
-        .read_to_string(&mut output)
-        .expect("Failed to read tempfile");
-
-    let end_time = std::time::Instant::now();
-
-    assert!(
-        output.contains(lint_message) == is_vulnerable,
-        "\n\n{}\n\n{}\n\n",
-        if is_vulnerable {
-            "Error: vulnerability not found on a vulnerable path".red()
-        } else {
-            "Error: vulnerability found on a non vulnerable path".red()
-        },
-        output
-    );
-
-    println!(
-        " - {} {} secs.",
-        "Elapsed time:".bright_purple(),
-        end_time.duration_since(start_time).as_millis() as f64 / 1000.0
-    );
-}
-
-fn get_detectors_path() -> PathBuf {
-    utils::get_repository_root_path()
-        .expect("Failed to get detectors path")
-        .join("detectors")
-}
diff --git a/apps/cargo-scout-audit/tests/integration_tests/detectors/configuration.rs b/apps/cargo-scout-audit/tests/integration_tests/detectors/configuration.rs
deleted file mode 100644
index dfab0317..00000000
--- a/apps/cargo-scout-audit/tests/integration_tests/detectors/configuration.rs
+++ /dev/null
@@ -1,111 +0,0 @@
-use std::path::{Path, PathBuf};
-
-use anyhow::{anyhow, bail};
-use itertools::Itertools;
-use scout_audit_internal::{Detector, IntoEnumIterator};
-
-use super::utils;
-
-#[derive(Debug)]
-pub struct Configuration {
-    pub detectors: Vec<DetectorConfiguration>,
-}
-
-#[derive(Debug)]
-pub struct DetectorConfiguration {
-    pub detector: Detector,
-    pub testcases: Vec<Testcase>,
-}
-
-#[derive(Debug)]
-pub struct Testcase {
-    pub vulnerable_path: Option<String>,
-    pub remediated_path: Option<String>,
-}
-
-impl Configuration {
-    pub fn build() -> anyhow::Result<Self> {
-        // Get all testcases folders
-        let cargo_scout_audit_path = utils::get_cargo_scout_audit_path()?;
-        let testcases_root_path = cargo_scout_audit_path
-            .parent()
-            .ok_or(anyhow!("Failed to find testcases path"))?
-            .parent()
-            .ok_or(anyhow!("Failed to find testcases path"))?
-            .join("test-cases");
-        let testcases_paths: Vec<PathBuf> = std::fs::read_dir(&testcases_root_path)?
-            .filter_map(|r| r.ok().map(|f| f.path()))
-            .filter(|r| r.is_dir())
-            .collect();
-
-        Self::validate_all_detectors_found(testcases_paths)?;
-
-        // Find all testcases for each detector
-        let mut detectors_config = Vec::new();
-        for detector in Detector::iter() {
-            let detector_name = detector.to_string();
-            let testcases_root_path = testcases_root_path.join(detector_name);
-            let testcases_paths: Vec<PathBuf> = std::fs::read_dir(testcases_root_path)?
-                .filter_map(|r| r.ok().map(|f| f.path()))
-                .filter(|r| r.is_dir())
-                .collect();
-
-            let mut testcases = Vec::new();
-            for testcase_path in testcases_paths {
-                let vulnerable_path = testcase_path.join("vulnerable-example");
-                let remediated_path = testcase_path.join("remediated-example");
-
-                let testcase = Testcase {
-                    vulnerable_path: if vulnerable_path.exists() {
-                        Some(
-                            vulnerable_path
-                                .join("Cargo.toml")
-                                .to_string_lossy()
-                                .to_string(),
-                        )
-                    } else {
-                        None
-                    },
-                    remediated_path: if Path::new(&remediated_path).exists() {
-                        Some(
-                            remediated_path
-                                .join("Cargo.toml")
-                                .to_string_lossy()
-                                .to_string(),
-                        )
-                    } else {
-                        None
-                    },
-                };
-                testcases.push(testcase);
-            }
-
-            detectors_config.push(DetectorConfiguration {
-                detector,
-                testcases,
-            });
-        }
-
-        Ok(Configuration {
-            detectors: detectors_config,
-        })
-    }
-
-    fn validate_all_detectors_found<T>(testcases_paths: T) -> anyhow::Result<()>
-    where
-        T: IntoIterator<Item = PathBuf>,
-    {
-        let count = testcases_paths
-            .into_iter()
-            .sorted()
-            .zip(Detector::iter().map(|d| d.to_string()).sorted())
-            .filter(|(p, d)| p.file_name().unwrap().to_string_lossy() != *d)
-            .count();
-
-        if count > 0 {
-            bail!("Testcases don't match detectors defined in scout-audit-internal.")
-        }
-
-        Ok(())
-    }
-}
diff --git a/apps/cargo-scout-audit/tests/integration_tests/detectors/utils.rs b/apps/cargo-scout-audit/tests/integration_tests/detectors/utils.rs
deleted file mode 100644
index f5365a3b..00000000
--- a/apps/cargo-scout-audit/tests/integration_tests/detectors/utils.rs
+++ /dev/null
@@ -1,14 +0,0 @@
-use std::path::PathBuf;
-
-use cargo_metadata::MetadataCommand;
-
-pub fn get_cargo_scout_audit_path() -> cargo_metadata::Result<PathBuf> {
-    Ok(MetadataCommand::new().exec()?.workspace_root.into())
-}
-
-pub fn get_repository_root_path() -> cargo_metadata::Result<PathBuf> {
-    let mut path = get_cargo_scout_audit_path()?;
-    path.pop();
-    path.pop();
-    Ok(path)
-}
diff --git a/apps/cargo-scout-audit/tests/integration_tests/main.rs b/apps/cargo-scout-audit/tests/integration_tests/main.rs
deleted file mode 100644
index 4235583f..00000000
--- a/apps/cargo-scout-audit/tests/integration_tests/main.rs
+++ /dev/null
@@ -1 +0,0 @@
-mod detectors;
diff --git a/apps/scout-extension/.eslintrc.cjs b/apps/scout-extension/.eslintrc.cjs
deleted file mode 100644
index bc580155..00000000
--- a/apps/scout-extension/.eslintrc.cjs
+++ /dev/null
@@ -1,31 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const path = require("path");
-
-/** @type {import("eslint").Linter.Config} */
-const config = {
-  root: true,
-  parser: "@typescript-eslint/parser",
-  parserOptions: {
-    ecmaVersion: 6,
-    sourceType: "module",
-    project: path.join(__dirname, "tsconfig.json"),
-  },
-  plugins: ["@typescript-eslint"],
-  extends: [
-    "plugin:@typescript-eslint/recommended",
-    "plugin:@typescript-eslint/recommended-requiring-type-checking",
-  ],
-  rules: {
-    "@typescript-eslint/consistent-type-imports": [
-      "warn",
-      {
-        prefer: "type-imports",
-        fixStyle: "inline-type-imports",
-      },
-    ],
-    "@typescript-eslint/no-unused-vars": ["warn", { argsIgnorePattern: "^_" }],
-  },
-  ignorePatterns: ["out", "dist", "**/*.d.ts"],
-};
-
-module.exports = config;
diff --git a/apps/scout-extension/.gitignore b/apps/scout-extension/.gitignore
deleted file mode 100644
index 808e1d34..00000000
--- a/apps/scout-extension/.gitignore
+++ /dev/null
@@ -1,2 +0,0 @@
-out/
-*.vsix
diff --git a/apps/scout-extension/.npmrc b/apps/scout-extension/.npmrc
deleted file mode 100644
index 37d1b604..00000000
--- a/apps/scout-extension/.npmrc
+++ /dev/null
@@ -1 +0,0 @@
-enable-pre-post-scripts = true
\ No newline at end of file
diff --git a/apps/scout-extension/.prettierignore b/apps/scout-extension/.prettierignore
deleted file mode 100644
index 9209ef5b..00000000
--- a/apps/scout-extension/.prettierignore
+++ /dev/null
@@ -1,2 +0,0 @@
-node_modules
-out
diff --git a/apps/scout-extension/.vscodeignore b/apps/scout-extension/.vscodeignore
deleted file mode 100644
index 38999676..00000000
--- a/apps/scout-extension/.vscodeignore
+++ /dev/null
@@ -1,10 +0,0 @@
-.vscode/**
-.vscode-test/**
-src/**
-.gitignore
-.yarnrc
-vsc-extension-quickstart.md
-**/tsconfig.json
-**/.eslintrc.json
-**/*.map
-**/*.ts
diff --git a/apps/scout-extension/CHANGELOG.md b/apps/scout-extension/CHANGELOG.md
deleted file mode 100644
index d72aae61..00000000
--- a/apps/scout-extension/CHANGELOG.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Change Log
-
-All notable changes to the "scout-extension" extension will be documented in this file.
-
-Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how to structure this file.
-
-## [Unreleased]
-
-- Initial release
\ No newline at end of file
diff --git a/apps/scout-extension/LICENSE b/apps/scout-extension/LICENSE
deleted file mode 100644
index 80d9abbe..00000000
--- a/apps/scout-extension/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 CoinFabrik
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/apps/scout-extension/README.md b/apps/scout-extension/README.md
deleted file mode 100644
index 9ba6ef09..00000000
--- a/apps/scout-extension/README.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# Scout: Security Analysis Tool
-
-<p align="center">
-  <img src="assets/scout.png" alt="Scout in a Dark Forest" width="300" center  />
-</p>
-
-Scout is an extensible open-source tool intended to assist Soroban smart contract developers and auditors detect common security issues and deviations from best practices. This is the vscode extension for Scout.
-
-
-## Features
-
-- Detection of common security issues and deviations from best practices.
-- Line squiggles and hover messages to highlight issues.
-
-## Requirements
-
-Before installing the extension, make sure you have the following requirements:
-
-- [rust-analyzer](https://marketplace.visualstudio.com/items?itemName=rust-lang.rust-analyzer) extension installed.
-- [cargo-scout-audit](https://github.com/CoinFabrik/scout-soroban) installed.
-- Rust components installed.
-
-## Release Notes
-
-### 0.1.1
-
-Fix icon.
-
-### 0.1.0
-
-We're excited to announce the initial release of Scout, the vscode extension. This release lays the groundwork for smart contract developers and auditors, to efficiently identify common security issues and deviations from best practices within their soroban smart contracts.
-
-We include in this release [detectors and vulnerablity classes with multiple test-cases](https://github.com/CoinFabrik/scout-soroban).
-
-## About CoinFabrik
-
-We - [CoinFabrik](https://www.coinfabrik.com/) - are a research and development company specialized in Web3, with a strong background in cybersecurity. Founded in 2014, we have worked on over 180 blockchain-related projects, EVM based and also for Solana, Algorand, and Polkadot. Beyond development, we offer security audits through a dedicated in-house team of senior cybersecurity professionals, currently working on code in Substrate, Solidity, Clarity, Rust, TEAL and Stellar Soroban.
-
-Our team has an academic background in computer science and mathematics, with work experience focused on cybersecurity and software development, including academic publications, patents turned into products, and conference presentations. Furthermore, we have an ongoing collaboration on knowledge transfer and open-source projects with the University of Buenos Aires.
-
-## License
-
-Scout is licensed and distributed under a MIT license. [Contact us](https://www.coinfabrik.com/) if you're looking for an exception to the terms.
diff --git a/apps/scout-extension/images/icon.png b/apps/scout-extension/images/icon.png
deleted file mode 100644
index 504381529f2c20cb7f195101c8f1c52c75e2a158..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 13073
zcmd73WmFtp6EzA01lI(6aJS&WEd)uh5Ii^p3o^st7BmEcySuvto52b0?hLNMB|z}o
zy!ZaUKfjN)X0f`@>FFa?r*`dK6Y}Zfdt9vlu#k|Da1}ntsv{vG!=FDGFMvBjgXgut
zKTPNcT_+?Y?3d3UWTez|GT<h%lluF2NR^|Me}D^AD`^#JB&1(a*!QMrNJxBz3bN9g
z?#M^W_TdI|9;;`&h-RgVdd<4frCvunhv|Q+wzNCYf;!L$Q!w{Fy&sC29|~LniR+@%
z<t1uv>MJ<|T7#<}ORtdYZ1!odu;Wm_6sZ{eEL~n4px|uf(Ee(7JT6T&?~t9d@!1he
zf9Qi!h3ih{l+*Drmz&keeY@Mv<BgBsWo&INBd6L$n$zfo_<K}fl>c}BS?8d3d>&5V
zaI*J^s8uYf;VXUpMe%rjHc9BvH&Q^&vWu*C!^80?qN=I_!!L&r+Cerv%AF3&;_6?1
zdob{G`ml(&;(!!Z$~}wP@fJgv*3@-dyVUEq5+8`dH3?JHgeMc}Lp&}Fn~(nPqw~Z?
zVOD!p3sfHI?+-r|q9S%86beVCqk-DsT~#hjzszsQ(aBv=nZ@%DJr_h(gA(|O(^niY
zZPd5#%h&u+$ty+`LE*{R!9#-L$j-7I$RVLtUVNcf(@b-ov`F-X(6{e8j|MEO^yv{P
zh=w_LbtGB(HNQZ{dWps?y;n#v!031fz^ccOc&@}kPKW;pk)cS)=!~>~js{x4ao^CQ
z)%*koWddWNN#dQ5SNjT*rCsxrE&ioKc_y2H+JTHpNx(1U<!G=J7fCpRh4=Gq2QshM
zkZm~FYtq`N6(ySr8NGX0!=@Z1CSn5z@8`P?WCwor7+%K;kn$U3JYXnf0!t{p_DbMY
zZlo(Z;L@72$Q&fT>4b+~_k77FkWy&78Bt~PvL6eC_cJagq&$D`2g>u4$#qx~%<6}x
z;qj;)lE66PdNs|&%Y+y>u6&bviWiT~6otQ|ED}K9Du-(`k)xAZio*H8EmK4<GVF>m
zD=7Wnq!A%Gh_G++vShZe5P0*BUs^Ska!WEH;e7&`FjiiVkhz#5a91J;OV|pM1l!L#
ziIJ=Ek<r7~PVWbp7<K}bld(lB4vLO!Dw&bqp;GcN>Impw2h6$BR9l%|`5pzAkXzU&
zw%}H%jMQd<F(6;J+eoGn8dk$OOB6E+5k~EO%S%lU>i^p16T*v>6sOb6(lx&vE~K$9
zJ;m;J&ZOgI&X*fiVIhI=$h66zxiqBK2%PwqhI*feS=!aR#5v)EP?>K9kj1x%WE*9z
zJIvOP?JJ2`k+;lnl@4STU_DSsc`8+C#~q!EawpJ|X#Q~=<q&5sSYMXQ>PRl`mZr{k
zIC1dtx(a-yxsYAf&MawUnO`jutQDx`wIc(`Np~PK%xjoz+>X;LU4q{lUWq&PpiNC*
z<@Ed;JJfrCmXiBbtkx}-R+nRb`UK2AJEf1Bqds6?LBZ{5Aqcn8ERZrZR8lw_zjk}m
z;_SZGH14uNGh9EZU^V^Z?%4HvDiRuCtq;(3W=F|01O6J*aNUM94y}rS<u8P*{V4wD
zCpx|H5~>M@3kFU~nk9}fV~+9P0?1gQekfNMWrS7@JBwk$h4oL$%h-%KiGh{fyz(}S
z&W9FDCF9}*pWXB^j~i&<eJ@J(QO|$!3upHP=??_WHyx&zu?bCoHpUBBTU;4m;2h9#
z>@8F;IAFJ7H6^yF_2lCjYf&@QCqzPFSo2GSjbyn`zO1Lbkt21LFCF9`tG_O5>{v=%
zi$Cw|;J~MHuaI}h`x`n@Y7<`ysi>;y!N3XeL(yw`VIW4~epPPQbFsBZVZ7Sj>Bu2X
z;r@QPF2<-`*+j>tQp9Uq-T|o<@XjIcsMqNe@|g*y^Bq&Y2A2|z3)Joo&<f0{%Ri1?
z$qc2s2I`B~OU)avcq!Vng^a5zjUsLZItMtWmY6W_p+8FMN`5_ri0AdA{@6{euUAvu
zSA(EbuiEPP66eWT?vfq~=9RNf=oEebv-=`LxaOs-=;=qc=4I=ygK)c{^oN3;B@a~_
zy!%IrE3*YsUyIeMO*AXUmfrUnB}!|ZN5?Q$2d&gT)P6Q?C~LVkk~r8G&KlylYuy{M
zT)GGz($93<wX>8V7qF6<d6Cq(`a);m#b~;B`Io$+>1%E<OaVnrNzBRxQc%=TM137E
zI(2bNO+{%2VLA`@lcB3`VBl8Jw(o?Xr6Dxhx9wGR^6M23geVP_0(R4!@^IW=Oh)?2
ztmkjz!Eyqvz%^g4*^e62%4R7|>gUdqa9A?RzZ$mpf9Br8L=Jvut#a;b6!gYz)wJ>H
z)cbr~Y?bc1nPw@9mD~4e=JeudZZ$f|*h5b6aJO!AQgaJej+ymUUaQjNZc7CNz9cIP
zHRsU8b?bYd+lLcenWO&iC()+x?7JPeHrwwf#ElkRRX1kWH{48|ht12eRfWq9N7l%W
ze#DemX0AS_6FyDTe-0onS5qfmRrdzlf%h9@4|aVsx(MxdwFIfBE91er!`*uOa@BA3
zLKP3_!bvjJ1W?xSg_}5T7tz|=8RLH*H(PyU5uDRa4*u8MyE@xL9A%CN2|5;tc)_AS
zQUB{62(hwnH`lRkZ~vRd_p^No5=b+8y)wUeT~8zShS;a&;50mZ5Nz?dvime2v~v5e
z^W&eM5&IUXoL@M@+9wQGuSu{9m%R6pzVRc2M{(CeD)ui@<5sYgpj~t;)9UR6#kt$1
zi4ejQ^E>1!^YjAU=bIpo#Ptn|l#lQ?JA$mINu4eHw!bqxheQo69%h$p$b7)=9M}KX
zWE^&zx)gh#mhe=6!b@uDdwY)G6?Fn`V^YABIq}!^IHbCUN#5EHIO!*6J<$jrw%rpe
z1Q2@Pj7E@-Vn#b?s?lHTZI;q|pL(AxUpvA0?&h=Z8^dMbqW8a#PGum1G+u`+$4OCb
zyDXj6UUTbS^zHWRF^>PvIIa+<FO{;eV7#08;p~{vD5#W<V`Lr%F7sv3f+w#=&VGeO
zT=7N<*JFl3^wlTo#>e0+Y#5i+Ws1_TjER&6>Cv~^9-yssT$o}}RsD7S!?G)_^?Jau
zkkP-$^nWM5%<aFfGEQ-LLT#=84O%_b-cP>w(cZ|e5pBcyD$_wXXK<PC?D5;REW4Gt
zH6U!G^iBIe9jR*RYhTe98TuiQk3FmLtB;q)abyJ0el!qXqh+0E%hDW;=kE7ApT`Os
zuwv>Zmgw9V>HGc>N--bV=WU9%R~%e!`vwiGX+M8baFV|MC3REy?W|c!_*8(@F;B1@
zU7nhNb`wK*E72Bz&y_`Qx_ZmLHSw4jVFWpt%$R7LF=#fmvOG>E$s(rYi}I6!p!t0I
zb9Grv;$L3Ac6B?|{<!Yn2Z<6MQ@;@<-Gv^5K1-VtLi;(vTbi&c-&5~D+&q7R)50eq
z(}~FZU%1n;6QO7lbjR13-sbBbzFxNl3uf3d#!-QGz*vnXMpqZT)+VRvd468S7_Z)6
z?dhDds>uY$HGi5#8)_geSEb)NJkc%n^7OXyT4ZIz#0v3~@o^FHb&AX{AMpANLChI(
z_l=)|hoL!Zoff+d&Tj4h11Y`5#E`K*hbfU7U<zFIx2sKqdSP!_AkYgVSQ|~3Y#epj
z>c@Q}sOb}T-sn*B8>>hn2s{kvil!HN<@xcB+<*jIIsJ-rFv$!9Zd#ZEpNXSv`DJ<x
zZM;s45T1Tm)9u9d0;bJmp;@prw*+I!cwLWiIAdgfK5`Q7^TKKbckyt!&2uTI^|(jU
zAz8xp+_8$&`V~HMuz|Y7ix*OV*B*}s${R2a4Jw;-C^>|!qAgGG%3z<WgedZ`x>QnX
zL3Qhb$Xg%XNf@N(_!;$3J;k=l@?2tUq{fb1nI@`tJzDFq6cG*P^zD*0QN)yvMZ7b6
zHvvhrB*<=Oe}ZW|y;jFmbLC8gOZDrw3=p-PCtl|3;kYv{ow&=@0W!yMP@K^TVsepw
z?buJuSdu7m-Scc_spi{-cAu?dI`BT%ze|Tlo$_hNJydO^5DlXk!a9hhl$lPTmB21|
z4+S|G0l+s;36=^@kQmd`iKsXOjrW+c`$7qJ6Zhjx*?G^&Be-w(1b+GO4^(M<h1;|6
zk#z8wFH_(8=tVkq8LTDfK~n3NmGidt<z^6WRViV~f^)@@xR9MFY$@I4B}A<GCikr|
zV5U)G7k|#^lYxnm+8rSp3hsn`|9&8I&AJO~U%=hU$5Kx9OhN?jnv@RREFE(*Z7*br
z7|r^-4QlL%<CcZ)rV=V&go(AMmj&8c7T7#J=9Ea7hJ2x0i<T<vBNkzU5dK5J9+?rj
z-+*HQ?;H4}bQBG-`?%qyP>=C<1VXNT>zUiEC2=~}Rbi%WLiQ4HLOy-T6-4ho{Rk)M
zI8*3)eRRVhx-lT`N-K3U;K)t#?;}c7Ut@qRgzD<s?2pexL-XK)(<CJmNWQwaRsg*(
zFs0DlJ0^*>EA#*KQH`EYsLj4dJ4MO+W7tyl9lC2;%{4Se-+?5h_!uQ=S@=yJdNSn~
znPJw}FLkAhPW7qU(k{J}O|5E%3-fnx+$3QI0eNk)at;#CHr;<1^<F~J<T~hdKxUEb
ze~iwe3-nPDgN{~OyA7;kG~TQ@O~stUaNu6GIjP_ga$VO8t&<%aGwnl)$TGqCN=Suq
z`^@8Z#ZP<d2cJ1T8b|w^ZnW(m{G7o}DJJ^ED$;a-$&<n=X7h5n%U~FXh_$0{e~WxJ
zI&=-w0Xz7Q=;~Fatj`3PMZO|2!j8-=5r1HsKcmxuz^&Al6g+OUp#6JFQQ;&YvDNog
zvrV~9Rc!zVE3l-KloK=FQGEC?3^;LySk@8+6gUdpm>~Y7cojw=x2d?lh@15)4?Rqn
z2<q$V+y1L;Iqu&>U`+}f&$*n!y;u1@!9@fKs<5yC4<7w1S!FHt{cdF^(Ok{zOo2!O
znyJR6nHh4sm_cDnYBhun>kcw8fziQc=PCz~48FscDP4bSEqV-Jb{st-iq#DRV)u+x
zTr<E2Ciy##<`jUb?-d2`mC9u=<ww7<wI_7HNzh?*Rb*ctT^B4XOR~T?UQLilYo7Mu
z9D8J?Xcdh+8u$VnZWK0yY5YxhPUqjkI)vI^K9LkmH6`4Aks8a$F#c>;j~AaWkkY*q
zkDZb>$S+_qosKK$<{jz10+nNUz+%bG9tR9XUW%Xf!ZWM`z#bS<v1^d+hBA028pFEg
zOH8hMRpwt=%fV$$l(tcBRqUU(XkeJMLbqwsjlN-%TFjOczb{~@4J;?A2hJ&fj9eBP
z{0nVj=__Vf001oG^Vi{I9*Afw-cn<SH~IlE3}@(L+xfdW_FfgQmHNiV`e3;s5gj!)
zHWQsJCHpjEVJQutaz<845Z;Zc<`{p*-N}-aw^SG>=;IwHNTCj+4qMz~5qxv$naLr(
zU|=jJQSlIbq{=-MxIo%i<ZXXj;I&K2Md;kqNlxjQf4!Ylhk-MeVeP^pj9K>C`^oxR
zzUya+U`ubpNL5uvGwfS#p?E#xOUtMGuuLJtUsB&bf5IqVi^i@X@vqF)L#?rS%?Tnj
z_^mL_-hWvavMaUvnw{5zlv%!P_o(y_)8;_X!)R*0ANHR=l8=?NG{8az*b?qtQo;tU
ztKNjC_Gh_n+7bTbvC@$qI|)pufQ#G09_wPPm~szS(Lz~l8na&9JDer>wr3Oke~<2Z
zWIcA$oZL0)V?NA|-OCKbIy7L&I^=AR*4b5)!xZBzRrM{0$+Fgm(4;%)NN=qPp^}#i
zO6Xi@58L?n=I&;$+To3Iv~GK09C(1an<zh#TKF8!JuUkak6Eeu(w<|bzDa!>h7_#;
z01#=9hbV7Hn33;(ZPwCtvOe*{obTiB{-xR}OCnBCqbW`;8+M?dj3gO(G2ii&@xR>r
z-%0H?C%kSsUr9zcnJ4I@Ntu~u(#h~acqwx>lGN_dllF&<RS78d^~CiXZXy+q>s?zZ
zZc3f7x71__k(eC+>#37;6pQmaqpR@(t`A0bc-)gI!D(E*WszcPzsR|!a{m_22}-dF
z{}NUM@Db)lQWDS%_yyeetO}nbBcE*xF<T-=bHD9-KZ;^}H*F;;G)v+izBJzmrtDe6
zj+Tb#Px|gQOS$g-X0Wg@z)vsjkM=q3q8V6yJPkgN8SHH9>#BHLu+^huKa>yWRM1(!
z(YRjqTC;s#_JJQy=ep9q;W1US#@;vWm{{NaWOf3tBRy_?m1=+g8)jW^$ZH(2GGCuC
zyQ9w1>~GXcTZ+8bk$QkM_N}&0)STTOIIg=%F=X8yT1Y>|Pdxp4+&7-uGNeVN<g>bE
zSvBOP&x%g2@adu&Q<mH^*t|K(ynm0rh)g**{m@<YKyh<kFYwz0H054;wtxNgoQnWh
zSN?~!m_9~>#-1wu{>Jlr+f`qc*bN_iA&Lvq)u%Oot+dSsMpCJp6YE3jAl@0FvN>P<
zPpk$>--p#QOUNr2*~IjHv+k4HTTae)K2(X^{JVG(nhjGotj>_~%-@9bz-;ciCw;&E
z;10^24$X#s{!QmpxazPK@DRV3z`~^rX+LYauibodUfuM40tat(;kOzBfdqWxYd>r8
zN{mBLr{d2jBKNR-u}#BEmq$FWC$qiv9xR>1cr8fwq2utrGxxz+p?8ZR;pKTsfhsi|
z6QSF7Q}bHKejwYkVm^JQsw((<j&6OAnLc{o{>;IB*K0Ch(hlyATd{;r(!GZ{Zf!Dc
z=L=R_{onDa|1APJL~PW<fRGnNw~5DTDXlW8VyQ(*hwcw^`M1X*W8!YBi(d9B7qsqn
zXY<a(UvWutDYblbTw9M*RZollMvYX)_s95$p~th3@kRot>jv+C%l0t+RNtyy6*R7S
zpA&4~*IAEU+>>xBeg^esC$mda>2(6=hgOB)C8MnSe;fWAaa0h2YXA@j?OGot#k#($
zW{UFT-~!>52$p~cAWdN1t1$kCGrF}<AVAoR{EuqOOpJd{n~LuTx$nQNO79LnNIex)
z%|}%Ya(XWG2K~Q}PgC|0w=lBpYC8e%5xFVIx?4aoc3O(^eLOlDOw!ig_N^=@w0Zfi
zgP0UKSTi+4%DQVLo{_;|+<R*pGo|^Y?evz4)Xu;xj#^WV<mJ<3jOgaEi_9Y$Gb^~l
zn5M;=Fs0WU`hhN?G?&QS*klX&fAdP%+2<6~kLwSTX%l6CK60&{6#bH|^McwgsTP3X
zZlReg6R)PMh~ry@_0vyg@bq2aKejH4B6|8Yq^(RfJ2etQ<luNU0pu@*vWiaISado(
zsFdnGWL;2s#xKu28EZTnvU)dbZLVxaj44@dZiK<5tTA?ci|aME&j3GPk$B1cZhY4}
z5~h|kZpwD^r(nwy5P+E2ulGtgT)02iNF7S~*;S+ECN=;e)WyAbG;GmH41YK=DhXwK
zwaRYIBa@w+fr<EPwS;IrNwuv=>1s+q+LWghyTs|_J_Os97&bi@SO3~xTPG`)tg$wg
zlbF(Fy(qqP{^<jIpb;KxEBq#cv=Zal(f8qg*2|3J5}HI9u#bq)u}b8@^`0`pzo-i`
z9mIIRn(x<#*6N4Wiyg!@f|zi`1TM>Qn`3FkFyNgzp+qIq2i%1ux^}*HJHPrAj~V_r
zo{sEa?$@1t3{%tmX89Ad1y?!;fWxJAT%s;8%-62pVr`j{CwCc7mz_iNuIwFj!{Ib1
zFVYAbzkRq<1#9XMd8uK;)Dw)Xn38b)V+Ln$+2xqg-gVFs-(oc&lk+OMLCOu|QK`7H
zipf+ZxIai72Xat1u=1*L%>zsdSAD1=36uO_n^{sI0N?aYZxxyC2p~N&G?dI6r+F;w
zi^VJl%w&}%Vp_wY-ISw0lXz?BpZDKvI{=^(e}64uY?XpcyBkf1r^R+!`j)cg0gxxy
zuj}(6t|0kKGg!f`htd4JL@hB%@jri|qHvgg`DC)qw5w0c<wjV2@ks@TA)c>L{!DM3
zvJ?v|<%%1<n%Hk<%WuCMy5v8q-28r-=Ibi)de@B;_3_HN=kc`Ia5*8>Es&hl5~Yr~
zxKyohhg~EA&hgn`O2}=#Af>Fh74XIMY$%2>W3E8Nmi4+F*2{*9?`D_#E}kUVKiL(#
zA+A2_--xtgI(YCr9(ASZZb04L3HNtWH^){-_)?})mZ%?s`wFSW9h=Vvhq$q@esC&w
zcUCTv9I?Qd2By99Cwl9yXg)gD;7$f}Duy3E^QL!yVhJDsjf-oxRhs<yzdySx=l|Jh
zk>DT)#|%@8c`W>Fq<uRK(vWhs^1ciixvY|~tJ94oWa|=mFDKJs`jrdOc{kzr4{WD(
zaz(XLQfa8Um`-giP!#AI89=wj^QxJ%Q5jAr?Zn>~NwaY0mv*<%R9MU`^NF5GI)?yC
zmMrE}yA-R66-}$^5q1;>n1oFpz*GM4>w0?(WLP*>5HfVPJTG@IPYP1UFaN3bXCov6
zSYLtgyq&xui^WA~WG^>w#^isbH)|Qzi8G<_gi_3h1^LOWrjo`wdI|KhhzniZUuts<
zN~X=sSp0FyZpd?ym>9B;0r=_L4S?#}<5d2+MAGi&vtF?9Ub3#Lx@6UBrA~17TH7L*
zEZIDu4XzLS;U|L?2$N-P-3oEjr|@X#ixaBjRkGKf%OrdS_)I2Zzd}Hqy#Iv|n%saE
zjB{YH0uDcYC9wc4!{E`S$ep=)E1;b!b*a=A6MRHBq}HrTPLc!nx{Y@~_L#9g%Ut?w
zb!<LC2;EZ|SQs|^3|{@cBqdbKJ2m_u7P~z8Afi^flpiB<l!D#>F=(H;ZM^%Y;>R_g
zE2~oxrequ!&I8b_)2hwjlIj)%6$y^e!Ld5baLtBUoolrCC9KuNUfu1I0=(4*!o6GG
z2FeNUQq~ErH7i@MNr(pLNefbw5nG{AeiR3hHNH@v0JJ$J?kaeQs?B9oXDSJG?<I0@
zWnD}klZ?2<RYo(MRK?=2h_nrSrJ-y4Wx_|}tl2i~#t6JsgFjcT9Y&~>p8b!+43H1@
z?p0*!GG6<!OOKJadhTo`iIFM`@@(=wIozm}qN4Z3UPbA@E;u&jNZ2X)+9(cWwG0*E
zS^&|oCtNL-u0B~3vQ)XTX#XElE&+6}|7$|YkwRbQNqUGU0<85P?@++>r`%CDy&jRN
zUa7f1_iy$KkpWpFm}{DRAQ`eN7W_9p&GI)pm&6WW%2X$>4qbf)j}Uw4$iW{*Fpn2r
zSDiS^Z;rZt?kNbfYHA0_)1nyt1RzaZ+Q$c6Pxj*eaAkJ6V6w74R7UUbOHD=ksz&P%
zd9UA+0%PyLBKZW<O8+b3PrW$-POI6roc`V`^eQ!*1B8eErmB~B!N(0@L0lBRZdCn>
z{7QU;Op7QR8))0IfIAjx8Ms%<{8I2_{c~$Mn3-0i-t`GXm~tzKV^{jRgft1QWR2ap
zIirhB?Nyu!D=H-(pL$IC9^d6gA+3O*Mf3C@+ujcfesl!T`67{4#`mJ-8-?{_dzG(J
zNZL0A^VLgVUBXS%$R&VwmT^Z-M|rQEjzrtfDr^Y8Xp+G>!v?xM?9BL`RhlM-wQ5yr
z7FpJ_QQ54sWMb)30dzdsG9{>z9~Xx3;gq!)>*h`alkm)AHlfDL`~b|B{v-J#k0McT
z)mG0|_UDCI+`723-KKh-u9o{5IX_T)V%IuzpJ#BW`c~c^mD07o;mlDtmP#w6NL(9g
zO_;pqdS|x2+V_#TRq>anj4IFry!{68j&P*AFsGzbDWv$Qx8p<{O1lQq|LgD9#bw-p
zJ@bj8pAN)@D{3cX!w~ge%Fsstpll9x@3~oEds}cVo;Ofe&jkU|oFI-5HC@;PxS(9x
zHFb8I=3gGvl*><+I<84*&&<j@o_!N(g^339spmFcV(&SMr8qLw=LSb8#p^Nsnv{w4
z`-&-9sylfLT|Y@e=={uA<r&7J@DL2)uK3%K1L)&U2)mpF#CcN$`Bt_ghkzdT8|OM)
zC3S)dOFsAbXKh()#eSH;bDQa$vJp0~sNHuLJtmWHqAEPUyau;_?oQqX`2+hhlU|+G
z9)0k)vtPn2PRQ&Y<@($uwRmbgb%O{8$U!I)n*D&r<f-42x-}D?8uh9Yx93y1K^$g)
zpmU{hlRCCHI4IW6v*T3lY)SUg&}8GT;Ja!;BgJ=MN3(EI2jcKFxX;BuiynZ?@ER~!
zyY_Jb*`zuu@mp)ObE@Y=NetPhndl)2t6BjHz6}JwV-47D{sKpr_lxpHC8Y9Yv9uY}
zzc;cXXA++``Kkon2eQKECI;huhmYt^!HYAe*F!z*wNUXx1{TSxtVumCy$)-hvl=)G
z!VoXI+~wXlE!9rMLIp#U382EX+{CtqcZIJcpm6|ls`!#+=u&mTRMe3T82vbSJC5nE
zN`dim)k*ub=D<SnE*ik3n!E+fp2w5@4h5_dW%DUdF<@Zo@g{?YI#a6Ad~B6nP4$_#
z1L6Gi>p~uJf)6KIXt*Sy4aT2j7`t1$K5i+=5C4c9<EI8wk&yxZF7I53zLc7-Vm`p{
zMl$DAs%&n-G!7gUAM{iW328aw<Cn12{fq#o$AYn4NIXSx4%?*wVre?D2@>G!lY{22
zY3k%NE=ogW4Lr5I{QKcZD70(i6B4>Bh2e0lKClCTeP55p({QjQ)aFdeW#>D>zva@u
z&B73No^C1QsGW&_4tysReOlKbodUOk>%zGNvIbWEepVOhXG7bgYgSoR^vGza+X*ke
z2sr#z1_z>0w=U)FyN;Zsv{<z(%F4;B@s%fT%`J<Bv&3b=S|q@~_dcShfd4h@+9h~P
zU9-L(z|r|_D+-AkyRo^A{a-tKw2ZD~S?ZF0{5W9As0-QoqJYp!B{NE#4xcc3-rFV{
z!>l-6f0kjMVOj>yQDPAnY!RVF+lFBeN>PApu~o!j$gC-LA-AcDemSO}$w{-j$_t3s
z{q;t;s~?J5cZ($6K}OvlYhPv1VgV#9zv7X$(nl2m#enj8H=jk$Ekw1YF_mYcZo=31
z05LzE>FW2^i8_gCF;2tFcg2ONNV)MCO%=O3m?%3e#j#)u(BflF<?}6{3aeNdD$ml~
zZWey=0-Q(MOP6Cuj{2s_vF1;<PcNAEHz<VK8W{Zmkcr=BXC+C1AW6i9$<ZNdn9pDM
zOK>#m-OU+TY%lGQCaZrZ0D_nJDmNw%ovWOy<i1^ne*Xe#eG&N}POzVh4z5`w1`i$N
zvh_$HGaTT=8uj`T(u<1AfrH_gen$jkHe*e^>x|hbGM46(IXDPVP~!=qa2;H-+QwO}
z_c5YB()Ax)?j*NpwBq+{Tz!6HM1%Y*rCPMSf6e|maIN0~fejZ!LjbjCwYahZ11p&L
zIr6chUw()(62gEdq~q4IEYj@8PH)h!jT1&pd?0rF{x)jApDhH=n;Uf^BdLNp?q4)b
zZu*^wZA06vR?11-?q0jXe;Dvm5~p?vZmu~M0*^2+TlT@wY#@xtVvX@De<Gw+K@jY8
zxb52At$2A<re`mu@diOiiS*-tn&TgEfVO@Rfhzrg-Wr{9v1I8nnkz_E;REL*f60iD
zgHaGy`QACD7~|ZWLsN^sCQja$$U?LWl8(CS-I>c;Xg|8hDe<yJNWSwdzFr2P9^$5v
zV-A)zI+92VS%i%b7?^HqhbrzITDfU-&vf+9kZ-O!^RqAGuIjaDWZJAyo5q(=Pfn>W
z6TZTYSP?dPcGoN7d`3C*;ZSesa<)9hTr!Q>uwTed0MuOnXbez_UuBMCyN7?`&QQ3?
z5dZAN!n+$DT_Vk=4@xs6M5VWS&X<nFUunk*o=|aM(zE3yHF<m2HhJExm|;hi?bxu(
z--}7xr~fu>4<Jc$mmdXJR2ePZeHJF~+H;B(7<m_Ek+-dE5}<w|!>*Thp%!=jp6~;-
zV$Mn2EHegP@44m&na}O!a&x6Ks_iTOus9aIxS(}p8|y!$zU-RAYk5PR(lqIVeFe0B
zG-^<)5?<-Ivs?M>ot?$f`#ARLpl4(sTL*P7fKw5%eWR*4L8jHJVR+<_xT!6{-0H1)
zh2R0`*IJNwZQoQ;gj-u>K%Yf-2QS|TCBK?6fiu+f#Gycn+utNi?@Vp|`g33X)IUSD
zybF=cOlc!>(!nv)$sC!yub(<vDq9XL6Jug{@>TDhzV&rYUvEfl1)C|OatH^8&i}WD
z#n@!nUIP$<CA`NwY1P4YEaI-AY?>pPC1AKuWrm~s_1<{F33Jc@wf9xx5B=3Vh-#CQ
zT;5o%V;3!k@S8F;rqA&p2Rg^1F;XQ82+Z8zaPV;SR&S1YFfn|m?LEopSN>a%<O7L=
zU5~|!j}bLm<~oZy_~cIrd6xuhMluZK;LeH_#B9FcWt&%Vyw%~pwK4~sR~b>gegzNj
zf8alK(|6v}XVWVayp|7S2IGA9;}CW$DOtYNiw8|ymH*1B7@&&i)f~A7k)v~dPq)Pd
ztI1E7J%O`Kd)t1jlccYd8(DRe1j)xJ{3bu@k+h(nse6sD9?c8sWo!;`T8iVNhj~(*
zzP4MdkOL1Btp}+QLeX3S?nOO@`CXt^oH`Bsk9(Pjz5}ITEZ(Yc0}HxdtB7TFsEQ8N
zt)&a+;|>%6`8uB}tGj=)O)u!TYsJNVL2;KO5?buZ>P;^DuFdz6;wi+3r5J9_v7CDB
zFHHbN)4Kk9p-x+A!*|5ABj|Tmsz{mWt-&v3)72yxQDpwMvcS~o!4`k%Xx&MWE>Fj)
zxBMqw<S$2=bXGn#+Gc@9yU;h~v;Doaz^f+54EogG6#i#Hp7Y-{m@2Xc<oZ47sAvds
zZK8zs{+pZG_cxG_Lpge|i7y@181MjxU5Fq8OCWY=#7g;M*1W&cB=(X2g<d3Hv&H5p
z_p^TB5PtwW4s)U@;k=TTtd`TIt$=bEj4c&giSm!|S`P5-)G#VX@ThcW7}pHGn*}DL
z)(v%fQTZ>7M_`6kAs~pgnI@D-K(iy_U<|!Gf^#t7CnC|#sLFAn?XQ;Mng988?A8aT
zOTk<0T0R>{vNYwx(~HgGOq?e?I~)NGCuLtrS_rCvw6g8fXT!g2*Jju6inKm0>$SJJ
z^=>%TUSKQ5GRUV`g!l_ODiY<pG+~<@K0OVA%n6Wn2)yvF80ue~?kL)6NXN%B<@gF#
zdYc-c@yOsstbDlGBF&~4T_XrJ>y*1i6(Coe7ZV(Q-6I*{bV>5nSMJ4|%pE6Ma#Ttz
zj|J=YeIuUp!`_ebM;sKIPFtUSU&^_byfV7N`U}XRx!fCZugE;!$|v>TEPXUi3C|$^
zsuwC~1E}`&YbGTIf<CGqMwILEAO5M9Rw-LwAZW+%m7)62tyn;QZpvFFgyk+D@#<qm
znT34YP17>t?w2-zo`^vno!K|g{f@)1hE?uyRd~L1Uy;xEECa|W=AJUQsC=6QBg^07
z>M$qKPGP`7wO00|=RP#)Cn`}j5C7c(@>b;`fb^@JgaN606WD4Sa66}~ckDn9HX;{?
zF62l-M<69AMrWk99l4Cn9|sstKUl>kFEjG~3;%Q?ilMK&llP1kT`wQ5dBBckB$X6B
zN~o6?Uu4c0ubE2_!Yoz+xpiBB`dT&tsF=#JjBhKgYv<!!aiTbIE4!;pP8Axy?|h{;
z=v4NrP3hdw$;~i8E+j_qaw?X2(C))1^BmF<Flx_>-bMcFL{b|_)3@yZIKcdD*Jtsf
zahIg;1lBlb9j?(Ln{&jtuD~h^e$NZB|Iwx1N=g$R%PTF%H&%voZg)56BiQgs$dbuI
zKMuvg7afj{r`tnLDT;M39;olcL^K+IC^IigICrSfd`XeqE26-Vr}!Wa)@Zo%q>h#c
zP@CdyYO=#(Vs_ONx2snTJ?{i_ntq%Y)%lDXG9Mt-SRJP(r}G%KKlq%zX=^SW5Gu2M
znJlotJ!Om?c;<NFhSVd|k;6a5v}PbC9dx^O%l1a(elJAPAmXH?ELFUC%x`Ecjq+J|
z{s7cb9sl6Gl^ZVx7%;cnEiR=Ota+YopD2I|K%8EWkUu=P5>YtYUx}kO=++1nR6Gnj
zN5on+bgjCl8L{KpFVFHr!&!-InZ4%!vwJs$aK0G9ixxqpq({@kBO$H(q2D{~qTkr<
zQugjYOO-1=!1-|h-n&;)fqH=|55}1*uGI=<Q0;@P7o1IvY2ari(@EtuSoSze4d~uG
z0y)t}?WYCd#USG2GH8OAAca1n2TUhZ8}CQ+!^^HmDpnX#>`ZXq$m*3O--7&k8P*5}
zGAoWMr{gg*_sAgZVw>slRSd@Sn|t0vllv-Z{`LyVVg|0ng>M@Opg)~=dl%)NW2cT_
znn(MLNDv^tm#+jBwBEmY$P-SM3yHi<(Me${1W5kVvxy*8NLVAA$gF7a(4n%*tCt+Y
zv_bm=o<Z7;u6G`5cV~y}FuqSul+hqmN_l>h-|xQEy$-{RY%H^WantbGs4imQnglYW
zZ^V!&?`~p%Aso(5j7(Z=vXDU>q%$?29ru%>Or_gQ|Lp#Te}+`p&KCU$)c+qK3-OrY
zEw9`-e14UOB82T|eCj?(i9v7N@E%{dpr$^6qUJoo71<mY0Iy%|-@4Hi)p>k5G4sE&
zIa-}_U|c|Q*6vL>BJ<Ht0XhK)7vY)L)KKHaOuFLpshtV)lim!YMi6%?Z>Fb#UpVa=
z&wmM#GfG8Y2;G=>J#P?4=n5)dCfLQSpcTF!yQ=geN-&}c0WHcDpo>?}Y=J~JmXd%f
zd9A@*)~u9waRf;*!77r9rey>v`MJC>rfN%I;Ag)+{fqo~H+est=kI3_P(W*El;OdZ
zI3I-AK6uhwc`2OAMl=LCwFjvI(u+S(Z1FFXYk;6|`;!Wm#a}<OQp}nFzpi3+HItm+
z*WUJ-Be=$B){LAS^DC)2=3g2!nvds73T5{Rp=1Lqwl2&Akk$nA4~4XO4ItmYw*IbU
zGE+j6QGQ(?;)|WrrO3%WEpquZccieujJ;Y(I)t>_z)o~4DG9TNSR8P!Zlp1l$ST%h
z(;fl0^Qr$?FRY|dT%pY+JL80ZoV2@f7m2j>zdDx);$~O|dYC`wj`3tyXgVG@_`+xR
z|EijJsmm<$|3eNY%Qqw09RGozm%duC)s&q{G~ZeO)S?8+2NF86<b=n}#6ypa*xxL6
zZ(zsrSS5C-21Hs>>0b2D<55<M;`5@gd&c37ZMS|83pI>ZYX=5(yBV>B1+DV{D?DJ}
zu!*ID`hgdO$8b@PIJ|NJ4^JL5`cfIhpyGOFgcZrth!F#)zxwc3t=K@G2~=zO4pZ~v
z6@foI6Wy6p(<|kb615i>rwvEuMOm+}?qu&a3_{Hgj-#vOsZG)u8JK?&Tf+1y{S*L)
zN-9&sXU|Joq^aeGm&_O9+|wrVGfLd!E|}%WCNR?R?|ibX#CmrI_|uQcosQW&{Z_EH
zG2HRA@m543T5bQG)Yug7WjkBktxt8g_OQZAEqXX`fW7VnE7rCfb`<X==)qO2&E;Zq
z^ZCC18u-wjp?GZ|&l$4Z^bt-sgCX4AmmGHIQ%XUlV^ez6`0GjS_Hz%~qH&D-a0LG+
z^qDe@uV2x~)gun+*9g)^_V>3l5>l2j5f$m-<Lt@`$FD1+v<#fEl*Co`ziZn^YQX5T
zV^{&T<oSzjfXu+zB;T?BU!SLho8BGi5=>w-U&5ti&MACvh$yP(P0}!n+Ps-_z|!zr
z9N+<nt@ov#R1f;G$l#vSBnylkAy{|_s>?EQj_AK0&Dv|yA~*XzglHfY=VWu)?bR!{
zXGXM#iOtN&hW+pZ@LF;)^iFw5<3W6`o^pC_4$_2_A-H0FH@=;@%3xC>5XqsQj>awc
ziS&enI~*aL885w}{P(fvb1U5ghOlzFM6<r&;_FMFmE}Z~=G!vx%4Z2Hm<UZGwX~J^
z(*neJZqOhh`Ku~dflHZVw9w0C_)OaDrEFNBpD>_`{Scd}4>Ob*mBn{nA$8V6U|EQK
ztMn#Z@rdMG9@;vY&~S*vPg~NK9;<CvaIj|<=Tr@^G5n)FxeRDYb)P`_KbJP96eYmM
za!Pk?CNj28-bZze=2!Eb7er=KX_Gt7WuCkVh~%0kQuxI{Ph0!I@(a_yH^n>Nv=M+z
zsbvI|m*S4i;bn#~H6Il*&c?dw{7%^^9c<+=t{AzglmL&+oI0B9_hAT`55yy})lRf9
z-T$@oFjX_?a=o+RLY5y63U!d_(t<*~B3O>_HN3TFZmk}a56o6)q#&b=dGKfpJ2m=C
z%Sg`jRNluCMq@ieG5<1nygL|9OhkvQ{DMO`KhqX_J~ohC>*Lzd3PRs#v%F6GJyLHN
zzwoO}F%BgglNu{co4XCa7NDllJ)$JY7FD&7R#xG)+bA*_C4l{>^gb#$?p%>TkjQ92
zct465mxUZr$nb!g_GL446Z+?BeEowtdrZGyK!q<O7YZ7W11cr0qXyBJt>bYkq)oYw
zoKw(I)rWWSyybZQm~_Bf^dZ!F3Wp$75MDB%9!I-#ODw-H`E1XIG%f{PE-R^;8H26=
z_$;vdZ4p5I0_S?|=HG-q*rWx`&Y^b5LJje%-<Jz{QD`g!l@-iL%mKud)qQnmV<Bn+
zA>Vn2Kqg->giY|>x-J1>D~i%lFHxwB+kg=1Wfut(foY`y+e|{kQbHl)_en<&Aldwg
zr2GnqXzy&9+=jo_PG1X=FN`myvmpGOP0-N)5>)Om7SGQhbnmj17anz{TD&{p4Iqt|
v1==769oVc+N%H^6UtRqFyjyth2}R>;wh422TEp`XLlopb%2vKJ3HW~i+PDIU

diff --git a/apps/scout-extension/package.json b/apps/scout-extension/package.json
deleted file mode 100644
index 9cc67d55..00000000
--- a/apps/scout-extension/package.json
+++ /dev/null
@@ -1,58 +0,0 @@
-{
-  "name": "scout-audit",
-  "displayName": "Scout Audit",
-  "description": "Soroban smart contract linter",
-  "version": "0.1.1",
-  "repository": "https://github.com/CoinFabrik/scout",
-  "engines": {
-    "vscode": "^1.78.0"
-  },
-  "publisher": "CoinFabrik",
-  "icon": "images/icon.png",
-  "keywords": [
-    "rust"
-  ],
-  "categories": [
-    "Programming Languages"
-  ],
-  "activationEvents": [
-    "onLanguage:rust",
-    "workspaceContains:*/Cargo.toml",
-    "workspaceContains:*/rust-project.json"
-  ],
-  "main": "./out/extension.js",
-  "scripts": {
-    "vscode:prepublish": "npm run esbuild-base -- --minify",
-    "esbuild-base": "esbuild ./src/extension.ts --bundle --outfile=out/extension.js --external:vscode --format=cjs --platform=node",
-    "esbuild": "npm run esbuild-base -- --sourcemap",
-    "esbuild-watch": "npm run esbuild-base -- --sourcemap --watch",
-    "package": "pnpm vsce package --no-dependencies",
-    "publish": "pnpm vsce publish --no-dependencies",
-    "test-compile": "tsc -p ./",
-    "watch": "tsc -watch -p ./",
-    "pretest": "pnpm run test-compile && pnpm run lint",
-    "lint": "eslint src --ext ts",
-    "format": "prettier --write src/**/*.ts",
-    "test": "node ./out/test/runTest.js"
-  },
-  "dependencies": {
-    "command-exists": "^1.2.9",
-    "toml": "^3.0.0"
-  },
-  "devDependencies": {
-    "@types/command-exists": "^1.2.0",
-    "@types/glob": "^8.1.0",
-    "@types/mocha": "^10.0.1",
-    "@types/node": "16.x",
-    "@types/vscode": "^1.78.0",
-    "@typescript-eslint/eslint-plugin": "^5.59.1",
-    "@typescript-eslint/parser": "^5.59.1",
-    "@vscode/test-electron": "^2.3.0",
-    "esbuild": "^0.17.19",
-    "eslint": "^8.39.0",
-    "glob": "^8.1.0",
-    "mocha": "^10.2.0",
-    "prettier": "^2.8.8",
-    "typescript": "^5.0.4"
-  }
-}
diff --git a/apps/scout-extension/pnpm-lock.yaml b/apps/scout-extension/pnpm-lock.yaml
deleted file mode 100644
index 186d0125..00000000
--- a/apps/scout-extension/pnpm-lock.yaml
+++ /dev/null
@@ -1,1656 +0,0 @@
-lockfileVersion: '6.1'
-
-settings:
-  autoInstallPeers: true
-  excludeLinksFromLockfile: false
-
-dependencies:
-  command-exists:
-    specifier: ^1.2.9
-    version: 1.2.9
-  toml:
-    specifier: ^3.0.0
-    version: 3.0.0
-
-devDependencies:
-  '@types/command-exists':
-    specifier: ^1.2.0
-    version: 1.2.0
-  '@types/glob':
-    specifier: ^8.1.0
-    version: 8.1.0
-  '@types/mocha':
-    specifier: ^10.0.1
-    version: 10.0.1
-  '@types/node':
-    specifier: 16.x
-    version: 16.0.0
-  '@types/vscode':
-    specifier: ^1.78.0
-    version: 1.78.0
-  '@typescript-eslint/eslint-plugin':
-    specifier: ^5.59.1
-    version: 5.59.1(@typescript-eslint/parser@5.59.1)(eslint@8.39.0)(typescript@5.0.4)
-  '@typescript-eslint/parser':
-    specifier: ^5.59.1
-    version: 5.59.1(eslint@8.39.0)(typescript@5.0.4)
-  '@vscode/test-electron':
-    specifier: ^2.3.0
-    version: 2.3.0
-  esbuild:
-    specifier: ^0.17.19
-    version: 0.17.19
-  eslint:
-    specifier: ^8.39.0
-    version: 8.39.0
-  glob:
-    specifier: ^8.1.0
-    version: 8.1.0
-  mocha:
-    specifier: ^10.2.0
-    version: 10.2.0
-  prettier:
-    specifier: ^2.8.8
-    version: 2.8.8
-  typescript:
-    specifier: ^5.0.4
-    version: 5.0.4
-
-packages:
-
-  /@esbuild/android-arm64@0.17.19:
-    resolution: {integrity: sha512-KBMWvEZooR7+kzY0BtbTQn0OAYY7CsiydT63pVEaPtVYF0hXbUaOyZog37DKxK7NF3XacBJOpYT4adIJh+avxA==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [android]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/android-arm@0.17.19:
-    resolution: {integrity: sha512-rIKddzqhmav7MSmoFCmDIb6e2W57geRsM94gV2l38fzhXMwq7hZoClug9USI2pFRGL06f4IOPHHpFNOkWieR8A==}
-    engines: {node: '>=12'}
-    cpu: [arm]
-    os: [android]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/android-x64@0.17.19:
-    resolution: {integrity: sha512-uUTTc4xGNDT7YSArp/zbtmbhO0uEEK9/ETW29Wk1thYUJBz3IVnvgEiEwEa9IeLyvnpKrWK64Utw2bgUmDveww==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [android]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/darwin-arm64@0.17.19:
-    resolution: {integrity: sha512-80wEoCfF/hFKM6WE1FyBHc9SfUblloAWx6FJkFWTWiCoht9Mc0ARGEM47e67W9rI09YoUxJL68WHfDRYEAvOhg==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/darwin-x64@0.17.19:
-    resolution: {integrity: sha512-IJM4JJsLhRYr9xdtLytPLSH9k/oxR3boaUIYiHkAawtwNOXKE8KoU8tMvryogdcT8AU+Bflmh81Xn6Q0vTZbQw==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/freebsd-arm64@0.17.19:
-    resolution: {integrity: sha512-pBwbc7DufluUeGdjSU5Si+P3SoMF5DQ/F/UmTSb8HXO80ZEAJmrykPyzo1IfNbAoaqw48YRpv8shwd1NoI0jcQ==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [freebsd]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/freebsd-x64@0.17.19:
-    resolution: {integrity: sha512-4lu+n8Wk0XlajEhbEffdy2xy53dpR06SlzvhGByyg36qJw6Kpfk7cp45DR/62aPH9mtJRmIyrXAS5UWBrJT6TQ==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [freebsd]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-arm64@0.17.19:
-    resolution: {integrity: sha512-ct1Tg3WGwd3P+oZYqic+YZF4snNl2bsnMKRkb3ozHmnM0dGWuxcPTTntAF6bOP0Sp4x0PjSF+4uHQ1xvxfRKqg==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-arm@0.17.19:
-    resolution: {integrity: sha512-cdmT3KxjlOQ/gZ2cjfrQOtmhG4HJs6hhvm3mWSRDPtZ/lP5oe8FWceS10JaSJC13GBd4eH/haHnqf7hhGNLerA==}
-    engines: {node: '>=12'}
-    cpu: [arm]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-ia32@0.17.19:
-    resolution: {integrity: sha512-w4IRhSy1VbsNxHRQpeGCHEmibqdTUx61Vc38APcsRbuVgK0OPEnQ0YD39Brymn96mOx48Y2laBQGqgZ0j9w6SQ==}
-    engines: {node: '>=12'}
-    cpu: [ia32]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-loong64@0.17.19:
-    resolution: {integrity: sha512-2iAngUbBPMq439a+z//gE+9WBldoMp1s5GWsUSgqHLzLJ9WoZLZhpwWuym0u0u/4XmZ3gpHmzV84PonE+9IIdQ==}
-    engines: {node: '>=12'}
-    cpu: [loong64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-mips64el@0.17.19:
-    resolution: {integrity: sha512-LKJltc4LVdMKHsrFe4MGNPp0hqDFA1Wpt3jE1gEyM3nKUvOiO//9PheZZHfYRfYl6AwdTH4aTcXSqBerX0ml4A==}
-    engines: {node: '>=12'}
-    cpu: [mips64el]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-ppc64@0.17.19:
-    resolution: {integrity: sha512-/c/DGybs95WXNS8y3Ti/ytqETiW7EU44MEKuCAcpPto3YjQbyK3IQVKfF6nbghD7EcLUGl0NbiL5Rt5DMhn5tg==}
-    engines: {node: '>=12'}
-    cpu: [ppc64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-riscv64@0.17.19:
-    resolution: {integrity: sha512-FC3nUAWhvFoutlhAkgHf8f5HwFWUL6bYdvLc/TTuxKlvLi3+pPzdZiFKSWz/PF30TB1K19SuCxDTI5KcqASJqA==}
-    engines: {node: '>=12'}
-    cpu: [riscv64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-s390x@0.17.19:
-    resolution: {integrity: sha512-IbFsFbxMWLuKEbH+7sTkKzL6NJmG2vRyy6K7JJo55w+8xDk7RElYn6xvXtDW8HCfoKBFK69f3pgBJSUSQPr+4Q==}
-    engines: {node: '>=12'}
-    cpu: [s390x]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/linux-x64@0.17.19:
-    resolution: {integrity: sha512-68ngA9lg2H6zkZcyp22tsVt38mlhWde8l3eJLWkyLrp4HwMUr3c1s/M2t7+kHIhvMjglIBrFpncX1SzMckomGw==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [linux]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/netbsd-x64@0.17.19:
-    resolution: {integrity: sha512-CwFq42rXCR8TYIjIfpXCbRX0rp1jo6cPIUPSaWwzbVI4aOfX96OXY8M6KNmtPcg7QjYeDmN+DD0Wp3LaBOLf4Q==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [netbsd]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/openbsd-x64@0.17.19:
-    resolution: {integrity: sha512-cnq5brJYrSZ2CF6c35eCmviIN3k3RczmHz8eYaVlNasVqsNY+JKohZU5MKmaOI+KkllCdzOKKdPs762VCPC20g==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [openbsd]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/sunos-x64@0.17.19:
-    resolution: {integrity: sha512-vCRT7yP3zX+bKWFeP/zdS6SqdWB8OIpaRq/mbXQxTGHnIxspRtigpkUcDMlSCOejlHowLqII7K2JKevwyRP2rg==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [sunos]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/win32-arm64@0.17.19:
-    resolution: {integrity: sha512-yYx+8jwowUstVdorcMdNlzklLYhPxjniHWFKgRqH7IFlUEa0Umu3KuYplf1HUZZ422e3NU9F4LGb+4O0Kdcaag==}
-    engines: {node: '>=12'}
-    cpu: [arm64]
-    os: [win32]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/win32-ia32@0.17.19:
-    resolution: {integrity: sha512-eggDKanJszUtCdlVs0RB+h35wNlb5v4TWEkq4vZcmVt5u/HiDZrTXe2bWFQUez3RgNHwx/x4sk5++4NSSicKkw==}
-    engines: {node: '>=12'}
-    cpu: [ia32]
-    os: [win32]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@esbuild/win32-x64@0.17.19:
-    resolution: {integrity: sha512-lAhycmKnVOuRYNtRtatQR1LPQf2oYCkRGkSFnseDAKPl8lu5SOsK/e1sXe5a0Pc5kHIHe6P2I/ilntNv2xf3cA==}
-    engines: {node: '>=12'}
-    cpu: [x64]
-    os: [win32]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /@eslint-community/eslint-utils@4.4.0(eslint@8.39.0):
-    resolution: {integrity: sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || >=8.0.0
-    dependencies:
-      eslint: 8.39.0
-      eslint-visitor-keys: 3.4.1
-    dev: true
-
-  /@eslint-community/regexpp@4.5.1:
-    resolution: {integrity: sha512-Z5ba73P98O1KUYCCJTUeVpja9RcGoMdncZ6T49FCUl2lN38JtCJ+3WgIDBv0AuY4WChU5PmtJmOCTlN6FZTFKQ==}
-    engines: {node: ^12.0.0 || ^14.0.0 || >=16.0.0}
-    dev: true
-
-  /@eslint/eslintrc@2.0.3:
-    resolution: {integrity: sha512-+5gy6OQfk+xx3q0d6jGZZC3f3KzAkXc/IanVxd1is/VIIziRqqt3ongQz0FiTUXqTk0c7aDB3OaFuKnuSoJicQ==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      ajv: 6.12.6
-      debug: 4.3.4(supports-color@8.1.1)
-      espree: 9.5.2
-      globals: 13.20.0
-      ignore: 5.2.4
-      import-fresh: 3.3.0
-      js-yaml: 4.1.0
-      minimatch: 3.1.2
-      strip-json-comments: 3.1.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@eslint/js@8.39.0:
-    resolution: {integrity: sha512-kf9RB0Fg7NZfap83B3QOqOGg9QmD9yBudqQXzzOtn3i4y7ZUXe5ONeW34Gwi+TxhH4mvj72R1Zc300KUMa9Bng==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dev: true
-
-  /@humanwhocodes/config-array@0.11.8:
-    resolution: {integrity: sha512-UybHIJzJnR5Qc/MsD9Kr+RpO2h+/P1GhOwdiLPXK5TWk5sgTdu88bTD9UP+CKbPPh5Rni1u0GjAdYQLemG8g+g==}
-    engines: {node: '>=10.10.0'}
-    dependencies:
-      '@humanwhocodes/object-schema': 1.2.1
-      debug: 4.3.4(supports-color@8.1.1)
-      minimatch: 3.1.2
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@humanwhocodes/module-importer@1.0.1:
-    resolution: {integrity: sha512-bxveV4V8v5Yb4ncFTT3rPSgZBOpCkjfK0y4oVVVJwIuDVBRMDXrPyXRL988i5ap9m9bnyEEjWfm5WkBmtffLfA==}
-    engines: {node: '>=12.22'}
-    dev: true
-
-  /@humanwhocodes/object-schema@1.2.1:
-    resolution: {integrity: sha512-ZnQMnLV4e7hDlUvw8H+U8ASL02SS2Gn6+9Ac3wGGLIe7+je2AeAOxPY+izIPJDfFDb7eDjev0Us8MO1iFRN8hA==}
-    dev: true
-
-  /@nodelib/fs.scandir@2.1.5:
-    resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
-    engines: {node: '>= 8'}
-    dependencies:
-      '@nodelib/fs.stat': 2.0.5
-      run-parallel: 1.2.0
-    dev: true
-
-  /@nodelib/fs.stat@2.0.5:
-    resolution: {integrity: sha512-RkhPPp2zrqDAQA/2jNhnztcPAlv64XdhIp7a7454A5ovI7Bukxgt7MX7udwAu3zg1DcpPU0rz3VV1SeaqvY4+A==}
-    engines: {node: '>= 8'}
-    dev: true
-
-  /@nodelib/fs.walk@1.2.8:
-    resolution: {integrity: sha512-oGB+UxlgWcgQkgwo8GcEGwemoTFt3FIO9ababBmaGwXIoBKZ+GTy0pP185beGg7Llih/NSHSV2XAs1lnznocSg==}
-    engines: {node: '>= 8'}
-    dependencies:
-      '@nodelib/fs.scandir': 2.1.5
-      fastq: 1.15.0
-    dev: true
-
-  /@tootallnate/once@1.1.2:
-    resolution: {integrity: sha512-RbzJvlNzmRq5c3O09UipeuXno4tA1FE6ikOjxZK0tuxVv3412l64l5t1W5pj4+rJq9vpkm/kwiR07aZXnsKPxw==}
-    engines: {node: '>= 6'}
-    dev: true
-
-  /@types/command-exists@1.2.0:
-    resolution: {integrity: sha512-ugsxEJfsCuqMLSuCD4PIJkp5Uk2z6TCMRCgYVuhRo5cYQY3+1xXTQkSlPtkpGHuvWMjS2KTeVQXxkXRACMbM6A==}
-    dev: true
-
-  /@types/glob@8.1.0:
-    resolution: {integrity: sha512-IO+MJPVhoqz+28h1qLAcBEH2+xHMK6MTyHJc7MTnnYb6wsoLR29POVGJ7LycmVXIqyy/4/2ShP5sUwTXuOwb/w==}
-    dependencies:
-      '@types/minimatch': 5.1.2
-      '@types/node': 16.0.0
-    dev: true
-
-  /@types/json-schema@7.0.12:
-    resolution: {integrity: sha512-Hr5Jfhc9eYOQNPYO5WLDq/n4jqijdHNlDXjuAQkkt+mWdQR+XJToOHrsD4cPaMXpn6KO7y2+wM8AZEs8VpBLVA==}
-    dev: true
-
-  /@types/minimatch@5.1.2:
-    resolution: {integrity: sha512-K0VQKziLUWkVKiRVrx4a40iPaxTUefQmjtkQofBkYRcoaaL/8rhwDWww9qWbrgicNOgnpIsMxyNIUM4+n6dUIA==}
-    dev: true
-
-  /@types/mocha@10.0.1:
-    resolution: {integrity: sha512-/fvYntiO1GeICvqbQ3doGDIP97vWmvFt83GKguJ6prmQM2iXZfFcq6YE8KteFyRtX2/h5Hf91BYvPodJKFYv5Q==}
-    dev: true
-
-  /@types/node@16.0.0:
-    resolution: {integrity: sha512-TmCW5HoZ2o2/z2EYi109jLqIaPIi9y/lc2LmDCWzuCi35bcaQ+OtUh6nwBiFK7SOu25FAU5+YKdqFZUwtqGSdg==}
-    dev: true
-
-  /@types/semver@7.5.0:
-    resolution: {integrity: sha512-G8hZ6XJiHnuhQKR7ZmysCeJWE08o8T0AXtk5darsCaTVsYZhhgUrq53jizaR2FvsoeCwJhlmwTjkXBY5Pn/ZHw==}
-    dev: true
-
-  /@types/vscode@1.78.0:
-    resolution: {integrity: sha512-LJZIJpPvKJ0HVQDqfOy6W4sNKUBBwyDu1Bs8chHBZOe9MNuKTJtidgZ2bqjhmmWpUb0TIIqv47BFUcVmAsgaVA==}
-    dev: true
-
-  /@typescript-eslint/eslint-plugin@5.59.1(@typescript-eslint/parser@5.59.1)(eslint@8.39.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-AVi0uazY5quFB9hlp2Xv+ogpfpk77xzsgsIEWyVS7uK/c7MZ5tw7ZPbapa0SbfkqE0fsAMkz5UwtgMLVk2BQAg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      '@typescript-eslint/parser': ^5.0.0
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@eslint-community/regexpp': 4.5.1
-      '@typescript-eslint/parser': 5.59.1(eslint@8.39.0)(typescript@5.0.4)
-      '@typescript-eslint/scope-manager': 5.59.1
-      '@typescript-eslint/type-utils': 5.59.1(eslint@8.39.0)(typescript@5.0.4)
-      '@typescript-eslint/utils': 5.59.1(eslint@8.39.0)(typescript@5.0.4)
-      debug: 4.3.4(supports-color@8.1.1)
-      eslint: 8.39.0
-      grapheme-splitter: 1.0.4
-      ignore: 5.2.4
-      natural-compare-lite: 1.4.0
-      semver: 7.5.1
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/parser@5.59.1(eslint@8.39.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-nzjFAN8WEu6yPRDizIFyzAfgK7nybPodMNFGNH0M9tei2gYnYszRDqVA0xlnRjkl7Hkx2vYrEdb6fP2a21cG1g==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/scope-manager': 5.59.1
-      '@typescript-eslint/types': 5.59.1
-      '@typescript-eslint/typescript-estree': 5.59.1(typescript@5.0.4)
-      debug: 4.3.4(supports-color@8.1.1)
-      eslint: 8.39.0
-      typescript: 5.0.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/scope-manager@5.59.1:
-    resolution: {integrity: sha512-mau0waO5frJctPuAzcxiNWqJR5Z8V0190FTSqRw1Q4Euop6+zTwHAf8YIXNwDOT29tyUDrQ65jSg9aTU/H0omA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      '@typescript-eslint/types': 5.59.1
-      '@typescript-eslint/visitor-keys': 5.59.1
-    dev: true
-
-  /@typescript-eslint/type-utils@5.59.1(eslint@8.39.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-ZMWQ+Oh82jWqWzvM3xU+9y5U7MEMVv6GLioM3R5NJk6uvP47kZ7YvlgSHJ7ERD6bOY7Q4uxWm25c76HKEwIjZw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: '*'
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/typescript-estree': 5.59.1(typescript@5.0.4)
-      '@typescript-eslint/utils': 5.59.1(eslint@8.39.0)(typescript@5.0.4)
-      debug: 4.3.4(supports-color@8.1.1)
-      eslint: 8.39.0
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/types@5.59.1:
-    resolution: {integrity: sha512-dg0ICB+RZwHlysIy/Dh1SP+gnXNzwd/KS0JprD3Lmgmdq+dJAJnUPe1gNG34p0U19HvRlGX733d/KqscrGC1Pg==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dev: true
-
-  /@typescript-eslint/typescript-estree@5.59.1(typescript@5.0.4):
-    resolution: {integrity: sha512-lYLBBOCsFltFy7XVqzX0Ju+Lh3WPIAWxYpmH/Q7ZoqzbscLiCW00LeYCdsUnnfnj29/s1WovXKh2gwCoinHNGA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      typescript: '*'
-    peerDependenciesMeta:
-      typescript:
-        optional: true
-    dependencies:
-      '@typescript-eslint/types': 5.59.1
-      '@typescript-eslint/visitor-keys': 5.59.1
-      debug: 4.3.4(supports-color@8.1.1)
-      globby: 11.1.0
-      is-glob: 4.0.3
-      semver: 7.5.1
-      tsutils: 3.21.0(typescript@5.0.4)
-      typescript: 5.0.4
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /@typescript-eslint/utils@5.59.1(eslint@8.39.0)(typescript@5.0.4):
-    resolution: {integrity: sha512-MkTe7FE+K1/GxZkP5gRj3rCztg45bEhsd8HYjczBuYm+qFHP5vtZmjx3B0yUCDotceQ4sHgTyz60Ycl225njmA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    peerDependencies:
-      eslint: ^6.0.0 || ^7.0.0 || ^8.0.0
-    dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.39.0)
-      '@types/json-schema': 7.0.12
-      '@types/semver': 7.5.0
-      '@typescript-eslint/scope-manager': 5.59.1
-      '@typescript-eslint/types': 5.59.1
-      '@typescript-eslint/typescript-estree': 5.59.1(typescript@5.0.4)
-      eslint: 8.39.0
-      eslint-scope: 5.1.1
-      semver: 7.5.1
-    transitivePeerDependencies:
-      - supports-color
-      - typescript
-    dev: true
-
-  /@typescript-eslint/visitor-keys@5.59.1:
-    resolution: {integrity: sha512-6waEYwBTCWryx0VJmP7JaM4FpipLsFl9CvYf2foAE8Qh/Y0s+bxWysciwOs0LTBED4JCaNxTZ5rGadB14M6dwA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      '@typescript-eslint/types': 5.59.1
-      eslint-visitor-keys: 3.4.1
-    dev: true
-
-  /@vscode/test-electron@2.3.0:
-    resolution: {integrity: sha512-fwzA9RtazH1GT/sckYlbxu6t5e4VaMXwCVtyLv4UAG0hP6NTfnMaaG25XCfWqlVwFhBMcQXHBCy5dmz2eLUnkw==}
-    engines: {node: '>=16'}
-    dependencies:
-      http-proxy-agent: 4.0.1
-      https-proxy-agent: 5.0.1
-      jszip: 3.10.1
-      semver: 7.5.1
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /acorn-jsx@5.3.2(acorn@8.8.2):
-    resolution: {integrity: sha512-rq9s+JNhf0IChjtDXxllJ7g41oZk5SlXtp0LHwyA5cejwn7vKmKp4pPri6YEePv2PU65sAsegbXtIinmDFDXgQ==}
-    peerDependencies:
-      acorn: ^6.0.0 || ^7.0.0 || ^8.0.0
-    dependencies:
-      acorn: 8.8.2
-    dev: true
-
-  /acorn@8.8.2:
-    resolution: {integrity: sha512-xjIYgE8HBrkpd/sJqOGNspf8uHG+NOHGOw6a/Urj8taM2EXfdNAH2oFcPeIFfsv3+kz/mJrS5VuMqbNLjCa2vw==}
-    engines: {node: '>=0.4.0'}
-    hasBin: true
-    dev: true
-
-  /agent-base@6.0.2:
-    resolution: {integrity: sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ==}
-    engines: {node: '>= 6.0.0'}
-    dependencies:
-      debug: 4.3.4(supports-color@8.1.1)
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /ajv@6.12.6:
-    resolution: {integrity: sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==}
-    dependencies:
-      fast-deep-equal: 3.1.3
-      fast-json-stable-stringify: 2.1.0
-      json-schema-traverse: 0.4.1
-      uri-js: 4.4.1
-    dev: true
-
-  /ansi-colors@4.1.1:
-    resolution: {integrity: sha512-JoX0apGbHaUJBNl6yF+p6JAFYZ666/hhCGKN5t9QFjbJQKUU/g8MNbFDbvfrgKXvI1QpZplPOnwIo99lX/AAmA==}
-    engines: {node: '>=6'}
-    dev: true
-
-  /ansi-regex@5.0.1:
-    resolution: {integrity: sha512-quJQXlTSUGL2LH9SUXo8VwsY4soanhgo6LNSm84E1LBcE8s3O0wpdiRzyR9z/ZZJMlMWv37qOOb9pdJlMUEKFQ==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /ansi-styles@4.3.0:
-    resolution: {integrity: sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==}
-    engines: {node: '>=8'}
-    dependencies:
-      color-convert: 2.0.1
-    dev: true
-
-  /anymatch@3.1.3:
-    resolution: {integrity: sha512-KMReFUr0B4t+D+OBkjR3KYqvocp2XaSzO55UcB6mgQMd3KbcE+mWTyvVV7D/zsdEbNnV6acZUutkiHQXvTr1Rw==}
-    engines: {node: '>= 8'}
-    dependencies:
-      normalize-path: 3.0.0
-      picomatch: 2.3.1
-    dev: true
-
-  /argparse@2.0.1:
-    resolution: {integrity: sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==}
-    dev: true
-
-  /array-union@2.1.0:
-    resolution: {integrity: sha512-HGyxoOTYUyCM6stUe6EJgnd4EoewAI7zMdfqO+kGjnlZmBDz/cR5pf8r/cR4Wq60sL/p0IkcjUEEPwS3GFrIyw==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /balanced-match@1.0.2:
-    resolution: {integrity: sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==}
-    dev: true
-
-  /binary-extensions@2.2.0:
-    resolution: {integrity: sha512-jDctJ/IVQbZoJykoeHbhXpOlNBqGNcwXJKJog42E5HDPUwQTSdjCHdihjj0DlnheQ7blbT6dHOafNAiS8ooQKA==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /brace-expansion@1.1.11:
-    resolution: {integrity: sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==}
-    dependencies:
-      balanced-match: 1.0.2
-      concat-map: 0.0.1
-    dev: true
-
-  /brace-expansion@2.0.1:
-    resolution: {integrity: sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==}
-    dependencies:
-      balanced-match: 1.0.2
-    dev: true
-
-  /braces@3.0.2:
-    resolution: {integrity: sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==}
-    engines: {node: '>=8'}
-    dependencies:
-      fill-range: 7.0.1
-    dev: true
-
-  /browser-stdout@1.3.1:
-    resolution: {integrity: sha512-qhAVI1+Av2X7qelOfAIYwXONood6XlZE/fXaBSmW/T5SzLAmCgzi+eiWE7fUvbHaeNBQH13UftjpXxsfLkMpgw==}
-    dev: true
-
-  /callsites@3.1.0:
-    resolution: {integrity: sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==}
-    engines: {node: '>=6'}
-    dev: true
-
-  /camelcase@6.3.0:
-    resolution: {integrity: sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /chalk@4.1.2:
-    resolution: {integrity: sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==}
-    engines: {node: '>=10'}
-    dependencies:
-      ansi-styles: 4.3.0
-      supports-color: 7.2.0
-    dev: true
-
-  /chokidar@3.5.3:
-    resolution: {integrity: sha512-Dr3sfKRP6oTcjf2JmUmFJfeVMvXBdegxB0iVQ5eb2V10uFJUCAS8OByZdVAyVb8xXNz3GjjTgj9kLWsZTqE6kw==}
-    engines: {node: '>= 8.10.0'}
-    dependencies:
-      anymatch: 3.1.3
-      braces: 3.0.2
-      glob-parent: 5.1.2
-      is-binary-path: 2.1.0
-      is-glob: 4.0.3
-      normalize-path: 3.0.0
-      readdirp: 3.6.0
-    optionalDependencies:
-      fsevents: 2.3.2
-    dev: true
-
-  /cliui@7.0.4:
-    resolution: {integrity: sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==}
-    dependencies:
-      string-width: 4.2.3
-      strip-ansi: 6.0.1
-      wrap-ansi: 7.0.0
-    dev: true
-
-  /color-convert@2.0.1:
-    resolution: {integrity: sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==}
-    engines: {node: '>=7.0.0'}
-    dependencies:
-      color-name: 1.1.4
-    dev: true
-
-  /color-name@1.1.4:
-    resolution: {integrity: sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==}
-    dev: true
-
-  /command-exists@1.2.9:
-    resolution: {integrity: sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==}
-    dev: false
-
-  /concat-map@0.0.1:
-    resolution: {integrity: sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==}
-    dev: true
-
-  /core-util-is@1.0.3:
-    resolution: {integrity: sha512-ZQBvi1DcpJ4GDqanjucZ2Hj3wEO5pZDS89BWbkcrvdxksJorwUDDZamX9ldFkp9aw2lmBDLgkObEA4DWNJ9FYQ==}
-    dev: true
-
-  /cross-spawn@7.0.3:
-    resolution: {integrity: sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==}
-    engines: {node: '>= 8'}
-    dependencies:
-      path-key: 3.1.1
-      shebang-command: 2.0.0
-      which: 2.0.2
-    dev: true
-
-  /debug@4.3.4(supports-color@8.1.1):
-    resolution: {integrity: sha512-PRWFHuSU3eDtQJPvnNY7Jcket1j0t5OuOsFzPPzsekD52Zl8qUfFIPEiswXqIvHWGVHOgX+7G/vCNNhehwxfkQ==}
-    engines: {node: '>=6.0'}
-    peerDependencies:
-      supports-color: '*'
-    peerDependenciesMeta:
-      supports-color:
-        optional: true
-    dependencies:
-      ms: 2.1.2
-      supports-color: 8.1.1
-    dev: true
-
-  /decamelize@4.0.0:
-    resolution: {integrity: sha512-9iE1PgSik9HeIIw2JO94IidnE3eBoQrFJ3w7sFuzSX4DpmZ3v5sZpUiV5Swcf6mQEF+Y0ru8Neo+p+nyh2J+hQ==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /deep-is@0.1.4:
-    resolution: {integrity: sha512-oIPzksmTg4/MriiaYGO+okXDT7ztn/w3Eptv/+gSIdMdKsJo0u4CfYNFJPy+4SKMuCqGw2wxnA+URMg3t8a/bQ==}
-    dev: true
-
-  /diff@5.0.0:
-    resolution: {integrity: sha512-/VTCrvm5Z0JGty/BWHljh+BAiw3IK+2j87NGMu8Nwc/f48WoDAC395uomO9ZD117ZOBaHmkX1oyLvkVM/aIT3w==}
-    engines: {node: '>=0.3.1'}
-    dev: true
-
-  /dir-glob@3.0.1:
-    resolution: {integrity: sha512-WkrWp9GR4KXfKGYzOLmTuGVi1UWFfws377n9cc55/tb6DuqyF6pcQ5AbiHEshaDpY9v6oaSr2XCDidGmMwdzIA==}
-    engines: {node: '>=8'}
-    dependencies:
-      path-type: 4.0.0
-    dev: true
-
-  /doctrine@3.0.0:
-    resolution: {integrity: sha512-yS+Q5i3hBf7GBkd4KG8a7eBNNWNGLTaEwwYWUijIYM7zrlYDM0BFXHjjPWlWZ1Rg7UaddZeIDmi9jF3HmqiQ2w==}
-    engines: {node: '>=6.0.0'}
-    dependencies:
-      esutils: 2.0.3
-    dev: true
-
-  /emoji-regex@8.0.0:
-    resolution: {integrity: sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==}
-    dev: true
-
-  /esbuild@0.17.19:
-    resolution: {integrity: sha512-XQ0jAPFkK/u3LcVRcvVHQcTIqD6E2H1fvZMA5dQPSOWb3suUbWbfbRf94pjc0bNzRYLfIrDRQXr7X+LHIm5oHw==}
-    engines: {node: '>=12'}
-    hasBin: true
-    requiresBuild: true
-    optionalDependencies:
-      '@esbuild/android-arm': 0.17.19
-      '@esbuild/android-arm64': 0.17.19
-      '@esbuild/android-x64': 0.17.19
-      '@esbuild/darwin-arm64': 0.17.19
-      '@esbuild/darwin-x64': 0.17.19
-      '@esbuild/freebsd-arm64': 0.17.19
-      '@esbuild/freebsd-x64': 0.17.19
-      '@esbuild/linux-arm': 0.17.19
-      '@esbuild/linux-arm64': 0.17.19
-      '@esbuild/linux-ia32': 0.17.19
-      '@esbuild/linux-loong64': 0.17.19
-      '@esbuild/linux-mips64el': 0.17.19
-      '@esbuild/linux-ppc64': 0.17.19
-      '@esbuild/linux-riscv64': 0.17.19
-      '@esbuild/linux-s390x': 0.17.19
-      '@esbuild/linux-x64': 0.17.19
-      '@esbuild/netbsd-x64': 0.17.19
-      '@esbuild/openbsd-x64': 0.17.19
-      '@esbuild/sunos-x64': 0.17.19
-      '@esbuild/win32-arm64': 0.17.19
-      '@esbuild/win32-ia32': 0.17.19
-      '@esbuild/win32-x64': 0.17.19
-    dev: true
-
-  /escalade@3.1.1:
-    resolution: {integrity: sha512-k0er2gUkLf8O0zKJiAhmkTnJlTvINGv7ygDNPbeIsX/TJjGJZHuh9B2UxbsaEkmlEo9MfhrSzmhIlhRlI2GXnw==}
-    engines: {node: '>=6'}
-    dev: true
-
-  /escape-string-regexp@4.0.0:
-    resolution: {integrity: sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /eslint-scope@5.1.1:
-    resolution: {integrity: sha512-2NxwbF/hZ0KpepYN0cNbo+FN6XoK7GaHlQhgx/hIZl6Va0bF45RQOOwhLIy8lQDbuCiadSLCBnH2CFYquit5bw==}
-    engines: {node: '>=8.0.0'}
-    dependencies:
-      esrecurse: 4.3.0
-      estraverse: 4.3.0
-    dev: true
-
-  /eslint-scope@7.2.0:
-    resolution: {integrity: sha512-DYj5deGlHBfMt15J7rdtyKNq/Nqlv5KfU4iodrQ019XESsRnwXH9KAE0y3cwtUHDo2ob7CypAnCqefh6vioWRw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      esrecurse: 4.3.0
-      estraverse: 5.3.0
-    dev: true
-
-  /eslint-visitor-keys@3.4.1:
-    resolution: {integrity: sha512-pZnmmLwYzf+kWaM/Qgrvpen51upAktaaiI01nsJD/Yr3lMOdNtq0cxkrrg16w64VtisN6okbs7Q8AfGqj4c9fA==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dev: true
-
-  /eslint@8.39.0:
-    resolution: {integrity: sha512-mwiok6cy7KTW7rBpo05k6+p4YVZByLNjAZ/ACB9DRCu4YDRwjXI01tWHp6KAUWelsBetTxKK/2sHB0vdS8Z2Og==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    hasBin: true
-    dependencies:
-      '@eslint-community/eslint-utils': 4.4.0(eslint@8.39.0)
-      '@eslint-community/regexpp': 4.5.1
-      '@eslint/eslintrc': 2.0.3
-      '@eslint/js': 8.39.0
-      '@humanwhocodes/config-array': 0.11.8
-      '@humanwhocodes/module-importer': 1.0.1
-      '@nodelib/fs.walk': 1.2.8
-      ajv: 6.12.6
-      chalk: 4.1.2
-      cross-spawn: 7.0.3
-      debug: 4.3.4(supports-color@8.1.1)
-      doctrine: 3.0.0
-      escape-string-regexp: 4.0.0
-      eslint-scope: 7.2.0
-      eslint-visitor-keys: 3.4.1
-      espree: 9.5.2
-      esquery: 1.5.0
-      esutils: 2.0.3
-      fast-deep-equal: 3.1.3
-      file-entry-cache: 6.0.1
-      find-up: 5.0.0
-      glob-parent: 6.0.2
-      globals: 13.20.0
-      grapheme-splitter: 1.0.4
-      ignore: 5.2.4
-      import-fresh: 3.3.0
-      imurmurhash: 0.1.4
-      is-glob: 4.0.3
-      is-path-inside: 3.0.3
-      js-sdsl: 4.4.0
-      js-yaml: 4.1.0
-      json-stable-stringify-without-jsonify: 1.0.1
-      levn: 0.4.1
-      lodash.merge: 4.6.2
-      minimatch: 3.1.2
-      natural-compare: 1.4.0
-      optionator: 0.9.1
-      strip-ansi: 6.0.1
-      strip-json-comments: 3.1.1
-      text-table: 0.2.0
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /espree@9.5.2:
-    resolution: {integrity: sha512-7OASN1Wma5fum5SrNhFMAMJxOUAbhyfQ8dQ//PJaJbNw0URTPWqIghHWt1MmAANKhHZIYOHruW4Kw4ruUWOdGw==}
-    engines: {node: ^12.22.0 || ^14.17.0 || >=16.0.0}
-    dependencies:
-      acorn: 8.8.2
-      acorn-jsx: 5.3.2(acorn@8.8.2)
-      eslint-visitor-keys: 3.4.1
-    dev: true
-
-  /esquery@1.5.0:
-    resolution: {integrity: sha512-YQLXUplAwJgCydQ78IMJywZCceoqk1oH01OERdSAJc/7U2AylwjhSCLDEtqwg811idIS/9fIU5GjG73IgjKMVg==}
-    engines: {node: '>=0.10'}
-    dependencies:
-      estraverse: 5.3.0
-    dev: true
-
-  /esrecurse@4.3.0:
-    resolution: {integrity: sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==}
-    engines: {node: '>=4.0'}
-    dependencies:
-      estraverse: 5.3.0
-    dev: true
-
-  /estraverse@4.3.0:
-    resolution: {integrity: sha512-39nnKffWz8xN1BU/2c79n9nB9HDzo0niYUqx6xyqUnyoAnQyyWpOTdZEeiCch8BBu515t4wp9ZmgVfVhn9EBpw==}
-    engines: {node: '>=4.0'}
-    dev: true
-
-  /estraverse@5.3.0:
-    resolution: {integrity: sha512-MMdARuVEQziNTeJD8DgMqmhwR11BRQ/cBP+pLtYdSTnf3MIO8fFeiINEbX36ZdNlfU/7A9f3gUw49B3oQsvwBA==}
-    engines: {node: '>=4.0'}
-    dev: true
-
-  /esutils@2.0.3:
-    resolution: {integrity: sha512-kVscqXk4OCp68SZ0dkgEKVi6/8ij300KBWTJq32P/dYeWTSwK41WyTxalN1eRmA5Z9UU/LX9D7FWSmV9SAYx6g==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /fast-deep-equal@3.1.3:
-    resolution: {integrity: sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==}
-    dev: true
-
-  /fast-glob@3.2.12:
-    resolution: {integrity: sha512-DVj4CQIYYow0BlaelwK1pHl5n5cRSJfM60UA0zK891sVInoPri2Ekj7+e1CT3/3qxXenpI+nBBmQAcJPJgaj4w==}
-    engines: {node: '>=8.6.0'}
-    dependencies:
-      '@nodelib/fs.stat': 2.0.5
-      '@nodelib/fs.walk': 1.2.8
-      glob-parent: 5.1.2
-      merge2: 1.4.1
-      micromatch: 4.0.5
-    dev: true
-
-  /fast-json-stable-stringify@2.1.0:
-    resolution: {integrity: sha512-lhd/wF+Lk98HZoTCtlVraHtfh5XYijIjalXck7saUtuanSDyLMxnHhSXEDJqHxD7msR8D0uCmqlkwjCV8xvwHw==}
-    dev: true
-
-  /fast-levenshtein@2.0.6:
-    resolution: {integrity: sha512-DCXu6Ifhqcks7TZKY3Hxp3y6qphY5SJZmrWMDrKcERSOXWQdMhU9Ig/PYrzyw/ul9jOIyh0N4M0tbC5hodg8dw==}
-    dev: true
-
-  /fastq@1.15.0:
-    resolution: {integrity: sha512-wBrocU2LCXXa+lWBt8RoIRD89Fi8OdABODa/kEnyeyjS5aZO5/GNvI5sEINADqP/h8M29UHTHUb53sUu5Ihqdw==}
-    dependencies:
-      reusify: 1.0.4
-    dev: true
-
-  /file-entry-cache@6.0.1:
-    resolution: {integrity: sha512-7Gps/XWymbLk2QLYK4NzpMOrYjMhdIxXuIvy2QBsLE6ljuodKvdkWs/cpyJJ3CVIVpH0Oi1Hvg1ovbMzLdFBBg==}
-    engines: {node: ^10.12.0 || >=12.0.0}
-    dependencies:
-      flat-cache: 3.0.4
-    dev: true
-
-  /fill-range@7.0.1:
-    resolution: {integrity: sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==}
-    engines: {node: '>=8'}
-    dependencies:
-      to-regex-range: 5.0.1
-    dev: true
-
-  /find-up@5.0.0:
-    resolution: {integrity: sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==}
-    engines: {node: '>=10'}
-    dependencies:
-      locate-path: 6.0.0
-      path-exists: 4.0.0
-    dev: true
-
-  /flat-cache@3.0.4:
-    resolution: {integrity: sha512-dm9s5Pw7Jc0GvMYbshN6zchCA9RgQlzzEZX3vylR9IqFfS8XciblUXOKfW6SiuJ0e13eDYZoZV5wdrev7P3Nwg==}
-    engines: {node: ^10.12.0 || >=12.0.0}
-    dependencies:
-      flatted: 3.2.7
-      rimraf: 3.0.2
-    dev: true
-
-  /flat@5.0.2:
-    resolution: {integrity: sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==}
-    hasBin: true
-    dev: true
-
-  /flatted@3.2.7:
-    resolution: {integrity: sha512-5nqDSxl8nn5BSNxyR3n4I6eDmbolI6WT+QqR547RwxQapgjQBmtktdP+HTBb/a/zLsbzERTONyUB5pefh5TtjQ==}
-    dev: true
-
-  /fs.realpath@1.0.0:
-    resolution: {integrity: sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==}
-    dev: true
-
-  /fsevents@2.3.2:
-    resolution: {integrity: sha512-xiqMQR4xAeHTuB9uWm+fFRcIOgKBMiOBP+eXiyT7jsgVCq1bkVygt00oASowB7EdtpOHaaPgKt812P9ab+DDKA==}
-    engines: {node: ^8.16.0 || ^10.6.0 || >=11.0.0}
-    os: [darwin]
-    requiresBuild: true
-    dev: true
-    optional: true
-
-  /get-caller-file@2.0.5:
-    resolution: {integrity: sha512-DyFP3BM/3YHTQOCUL/w0OZHR0lpKeGrxotcHWcqNEdnltqFwXVfhEBQ94eIo34AfQpo0rGki4cyIiftY06h2Fg==}
-    engines: {node: 6.* || 8.* || >= 10.*}
-    dev: true
-
-  /glob-parent@5.1.2:
-    resolution: {integrity: sha512-AOIgSQCepiJYwP3ARnGx+5VnTu2HBYdzbGP45eLw1vr3zB3vZLeyed1sC9hnbcOc9/SrMyM5RPQrkGz4aS9Zow==}
-    engines: {node: '>= 6'}
-    dependencies:
-      is-glob: 4.0.3
-    dev: true
-
-  /glob-parent@6.0.2:
-    resolution: {integrity: sha512-XxwI8EOhVQgWp6iDL+3b0r86f4d6AX6zSU55HfB4ydCEuXLXc5FcYeOu+nnGftS4TEju/11rt4KJPTMgbfmv4A==}
-    engines: {node: '>=10.13.0'}
-    dependencies:
-      is-glob: 4.0.3
-    dev: true
-
-  /glob@7.2.0:
-    resolution: {integrity: sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==}
-    dependencies:
-      fs.realpath: 1.0.0
-      inflight: 1.0.6
-      inherits: 2.0.4
-      minimatch: 3.1.2
-      once: 1.4.0
-      path-is-absolute: 1.0.1
-    dev: true
-
-  /glob@8.1.0:
-    resolution: {integrity: sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==}
-    engines: {node: '>=12'}
-    dependencies:
-      fs.realpath: 1.0.0
-      inflight: 1.0.6
-      inherits: 2.0.4
-      minimatch: 5.1.6
-      once: 1.4.0
-    dev: true
-
-  /globals@13.20.0:
-    resolution: {integrity: sha512-Qg5QtVkCy/kv3FUSlu4ukeZDVf9ee0iXLAUYX13gbR17bnejFTzr4iS9bY7kwCf1NztRNm1t91fjOiyx4CSwPQ==}
-    engines: {node: '>=8'}
-    dependencies:
-      type-fest: 0.20.2
-    dev: true
-
-  /globby@11.1.0:
-    resolution: {integrity: sha512-jhIXaOzy1sb8IyocaruWSn1TjmnBVs8Ayhcy83rmxNJ8q2uWKCAj3CnJY+KpGSXCueAPc0i05kVvVKtP1t9S3g==}
-    engines: {node: '>=10'}
-    dependencies:
-      array-union: 2.1.0
-      dir-glob: 3.0.1
-      fast-glob: 3.2.12
-      ignore: 5.2.4
-      merge2: 1.4.1
-      slash: 3.0.0
-    dev: true
-
-  /grapheme-splitter@1.0.4:
-    resolution: {integrity: sha512-bzh50DW9kTPM00T8y4o8vQg89Di9oLJVLW/KaOGIXJWP/iqCN6WKYkbNOF04vFLJhwcpYUh9ydh/+5vpOqV4YQ==}
-    dev: true
-
-  /has-flag@4.0.0:
-    resolution: {integrity: sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /he@1.2.0:
-    resolution: {integrity: sha512-F/1DnUGPopORZi0ni+CvrCgHQ5FyEAHRLSApuYWMmrbSwoN2Mn/7k+Gl38gJnR7yyDZk6WLXwiGod1JOWNDKGw==}
-    hasBin: true
-    dev: true
-
-  /http-proxy-agent@4.0.1:
-    resolution: {integrity: sha512-k0zdNgqWTGA6aeIRVpvfVob4fL52dTfaehylg0Y4UvSySvOq/Y+BOyPrgpUrA7HylqvU8vIZGsRuXmspskV0Tg==}
-    engines: {node: '>= 6'}
-    dependencies:
-      '@tootallnate/once': 1.1.2
-      agent-base: 6.0.2
-      debug: 4.3.4(supports-color@8.1.1)
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /https-proxy-agent@5.0.1:
-    resolution: {integrity: sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA==}
-    engines: {node: '>= 6'}
-    dependencies:
-      agent-base: 6.0.2
-      debug: 4.3.4(supports-color@8.1.1)
-    transitivePeerDependencies:
-      - supports-color
-    dev: true
-
-  /ignore@5.2.4:
-    resolution: {integrity: sha512-MAb38BcSbH0eHNBxn7ql2NH/kX33OkB3lZ1BNdh7ENeRChHTYsTvWrMubiIAMNS2llXEEgZ1MUOBtXChP3kaFQ==}
-    engines: {node: '>= 4'}
-    dev: true
-
-  /immediate@3.0.6:
-    resolution: {integrity: sha512-XXOFtyqDjNDAQxVfYxuF7g9Il/IbWmmlQg2MYKOH8ExIT1qg6xc4zyS3HaEEATgs1btfzxq15ciUiY7gjSXRGQ==}
-    dev: true
-
-  /import-fresh@3.3.0:
-    resolution: {integrity: sha512-veYYhQa+D1QBKznvhUHxb8faxlrwUnxseDAbAp457E0wLNio2bOSKnjYDhMj+YiAq61xrMGhQk9iXVk5FzgQMw==}
-    engines: {node: '>=6'}
-    dependencies:
-      parent-module: 1.0.1
-      resolve-from: 4.0.0
-    dev: true
-
-  /imurmurhash@0.1.4:
-    resolution: {integrity: sha512-JmXMZ6wuvDmLiHEml9ykzqO6lwFbof0GG4IkcGaENdCRDDmMVnny7s5HsIgHCbaq0w2MyPhDqkhTUgS2LU2PHA==}
-    engines: {node: '>=0.8.19'}
-    dev: true
-
-  /inflight@1.0.6:
-    resolution: {integrity: sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==}
-    dependencies:
-      once: 1.4.0
-      wrappy: 1.0.2
-    dev: true
-
-  /inherits@2.0.4:
-    resolution: {integrity: sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==}
-    dev: true
-
-  /is-binary-path@2.1.0:
-    resolution: {integrity: sha512-ZMERYes6pDydyuGidse7OsHxtbI7WVeUEozgR/g7rd0xUimYNlvZRE/K2MgZTjWy725IfelLeVcEM97mmtRGXw==}
-    engines: {node: '>=8'}
-    dependencies:
-      binary-extensions: 2.2.0
-    dev: true
-
-  /is-extglob@2.1.1:
-    resolution: {integrity: sha512-SbKbANkN603Vi4jEZv49LeVJMn4yGwsbzZworEoyEiutsN3nJYdbO36zfhGJ6QEDpOZIFkDtnq5JRxmvl3jsoQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /is-fullwidth-code-point@3.0.0:
-    resolution: {integrity: sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /is-glob@4.0.3:
-    resolution: {integrity: sha512-xelSayHH36ZgE7ZWhli7pW34hNbNl8Ojv5KVmkJD4hBdD3th8Tfk9vYasLM+mXWOZhFkgZfxhLSnrwRr4elSSg==}
-    engines: {node: '>=0.10.0'}
-    dependencies:
-      is-extglob: 2.1.1
-    dev: true
-
-  /is-number@7.0.0:
-    resolution: {integrity: sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==}
-    engines: {node: '>=0.12.0'}
-    dev: true
-
-  /is-path-inside@3.0.3:
-    resolution: {integrity: sha512-Fd4gABb+ycGAmKou8eMftCupSir5lRxqf4aD/vd0cD2qc4HL07OjCeuHMr8Ro4CoMaeCKDB0/ECBOVWjTwUvPQ==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /is-plain-obj@2.1.0:
-    resolution: {integrity: sha512-YWnfyRwxL/+SsrWYfOpUtz5b3YD+nyfkHvjbcanzk8zgyO4ASD67uVMRt8k5bM4lLMDnXfriRhOpemw+NfT1eA==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /is-unicode-supported@0.1.0:
-    resolution: {integrity: sha512-knxG2q4UC3u8stRGyAVJCOdxFmv5DZiRcdlIaAQXAbSfJya+OhopNotLQrstBhququ4ZpuKbDc/8S6mgXgPFPw==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /isarray@1.0.0:
-    resolution: {integrity: sha512-VLghIWNM6ELQzo7zwmcg0NmTVyWKYjvIeM83yjp0wRDTmUnrM678fQbcKBo6n2CJEF0szoG//ytg+TKla89ALQ==}
-    dev: true
-
-  /isexe@2.0.0:
-    resolution: {integrity: sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==}
-    dev: true
-
-  /js-sdsl@4.4.0:
-    resolution: {integrity: sha512-FfVSdx6pJ41Oa+CF7RDaFmTnCaFhua+SNYQX74riGOpl96x+2jQCqEfQ2bnXu/5DPCqlRuiqyvTJM0Qjz26IVg==}
-    dev: true
-
-  /js-yaml@4.1.0:
-    resolution: {integrity: sha512-wpxZs9NoxZaJESJGIZTyDEaYpl0FKSA+FB9aJiyemKhMwkxQg63h4T1KJgUGHpTqPDNRcmmYLugrRjJlBtWvRA==}
-    hasBin: true
-    dependencies:
-      argparse: 2.0.1
-    dev: true
-
-  /json-schema-traverse@0.4.1:
-    resolution: {integrity: sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==}
-    dev: true
-
-  /json-stable-stringify-without-jsonify@1.0.1:
-    resolution: {integrity: sha512-Bdboy+l7tA3OGW6FjyFHWkP5LuByj1Tk33Ljyq0axyzdk9//JSi2u3fP1QSmd1KNwq6VOKYGlAu87CisVir6Pw==}
-    dev: true
-
-  /jszip@3.10.1:
-    resolution: {integrity: sha512-xXDvecyTpGLrqFrvkrUSoxxfJI5AH7U8zxxtVclpsUtMCq4JQ290LY8AW5c7Ggnr/Y/oK+bQMbqK2qmtk3pN4g==}
-    dependencies:
-      lie: 3.3.0
-      pako: 1.0.11
-      readable-stream: 2.3.8
-      setimmediate: 1.0.5
-    dev: true
-
-  /levn@0.4.1:
-    resolution: {integrity: sha512-+bT2uH4E5LGE7h/n3evcS/sQlJXCpIp6ym8OWJ5eV6+67Dsql/LaaT7qJBAt2rzfoa/5QBGBhxDix1dMt2kQKQ==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      prelude-ls: 1.2.1
-      type-check: 0.4.0
-    dev: true
-
-  /lie@3.3.0:
-    resolution: {integrity: sha512-UaiMJzeWRlEujzAuw5LokY1L5ecNQYZKfmyZ9L7wDHb/p5etKaxXhohBcrw0EYby+G/NA52vRSN4N39dxHAIwQ==}
-    dependencies:
-      immediate: 3.0.6
-    dev: true
-
-  /locate-path@6.0.0:
-    resolution: {integrity: sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==}
-    engines: {node: '>=10'}
-    dependencies:
-      p-locate: 5.0.0
-    dev: true
-
-  /lodash.merge@4.6.2:
-    resolution: {integrity: sha512-0KpjqXRVvrYyCsX1swR/XTK0va6VQkQM6MNo7PqW77ByjAhoARA8EfrP1N4+KlKj8YS0ZUCtRT/YUuhyYDujIQ==}
-    dev: true
-
-  /log-symbols@4.1.0:
-    resolution: {integrity: sha512-8XPvpAA8uyhfteu8pIvQxpJZ7SYYdpUivZpGy6sFsBuKRY/7rQGavedeB8aK+Zkyq6upMFVL/9AW6vOYzfRyLg==}
-    engines: {node: '>=10'}
-    dependencies:
-      chalk: 4.1.2
-      is-unicode-supported: 0.1.0
-    dev: true
-
-  /lru-cache@6.0.0:
-    resolution: {integrity: sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==}
-    engines: {node: '>=10'}
-    dependencies:
-      yallist: 4.0.0
-    dev: true
-
-  /merge2@1.4.1:
-    resolution: {integrity: sha512-8q7VEgMJW4J8tcfVPy8g09NcQwZdbwFEqhe/WZkoIzjn/3TGDwtOCYtXGxA3O8tPzpczCCDgv+P2P5y00ZJOOg==}
-    engines: {node: '>= 8'}
-    dev: true
-
-  /micromatch@4.0.5:
-    resolution: {integrity: sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==}
-    engines: {node: '>=8.6'}
-    dependencies:
-      braces: 3.0.2
-      picomatch: 2.3.1
-    dev: true
-
-  /minimatch@3.1.2:
-    resolution: {integrity: sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==}
-    dependencies:
-      brace-expansion: 1.1.11
-    dev: true
-
-  /minimatch@5.0.1:
-    resolution: {integrity: sha512-nLDxIFRyhDblz3qMuq+SoRZED4+miJ/G+tdDrjkkkRnjAsBexeGpgjLEQ0blJy7rHhR2b93rhQY4SvyWu9v03g==}
-    engines: {node: '>=10'}
-    dependencies:
-      brace-expansion: 2.0.1
-    dev: true
-
-  /minimatch@5.1.6:
-    resolution: {integrity: sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==}
-    engines: {node: '>=10'}
-    dependencies:
-      brace-expansion: 2.0.1
-    dev: true
-
-  /mocha@10.2.0:
-    resolution: {integrity: sha512-IDY7fl/BecMwFHzoqF2sg/SHHANeBoMMXFlS9r0OXKDssYE1M5O43wUY/9BVPeIvfH2zmEbBfseqN9gBQZzXkg==}
-    engines: {node: '>= 14.0.0'}
-    hasBin: true
-    dependencies:
-      ansi-colors: 4.1.1
-      browser-stdout: 1.3.1
-      chokidar: 3.5.3
-      debug: 4.3.4(supports-color@8.1.1)
-      diff: 5.0.0
-      escape-string-regexp: 4.0.0
-      find-up: 5.0.0
-      glob: 7.2.0
-      he: 1.2.0
-      js-yaml: 4.1.0
-      log-symbols: 4.1.0
-      minimatch: 5.0.1
-      ms: 2.1.3
-      nanoid: 3.3.3
-      serialize-javascript: 6.0.0
-      strip-json-comments: 3.1.1
-      supports-color: 8.1.1
-      workerpool: 6.2.1
-      yargs: 16.2.0
-      yargs-parser: 20.2.4
-      yargs-unparser: 2.0.0
-    dev: true
-
-  /ms@2.1.2:
-    resolution: {integrity: sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==}
-    dev: true
-
-  /ms@2.1.3:
-    resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==}
-    dev: true
-
-  /nanoid@3.3.3:
-    resolution: {integrity: sha512-p1sjXuopFs0xg+fPASzQ28agW1oHD7xDsd9Xkf3T15H3c/cifrFHVwrh74PdoklAPi+i7MdRsE47vm2r6JoB+w==}
-    engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1}
-    hasBin: true
-    dev: true
-
-  /natural-compare-lite@1.4.0:
-    resolution: {integrity: sha512-Tj+HTDSJJKaZnfiuw+iaF9skdPpTo2GtEly5JHnWV/hfv2Qj/9RKsGISQtLh2ox3l5EAGw487hnBee0sIJ6v2g==}
-    dev: true
-
-  /natural-compare@1.4.0:
-    resolution: {integrity: sha512-OWND8ei3VtNC9h7V60qff3SVobHr996CTwgxubgyQYEpg290h9J0buyECNNJexkFm5sOajh5G116RYA1c8ZMSw==}
-    dev: true
-
-  /normalize-path@3.0.0:
-    resolution: {integrity: sha512-6eZs5Ls3WtCisHWp9S2GUy8dqkpGi4BVSz3GaqiE6ezub0512ESztXUwUB6C6IKbQkY2Pnb/mD4WYojCRwcwLA==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /once@1.4.0:
-    resolution: {integrity: sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==}
-    dependencies:
-      wrappy: 1.0.2
-    dev: true
-
-  /optionator@0.9.1:
-    resolution: {integrity: sha512-74RlY5FCnhq4jRxVUPKDaRwrVNXMqsGsiW6AJw4XK8hmtm10wC0ypZBLw5IIp85NZMr91+qd1RvvENwg7jjRFw==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      deep-is: 0.1.4
-      fast-levenshtein: 2.0.6
-      levn: 0.4.1
-      prelude-ls: 1.2.1
-      type-check: 0.4.0
-      word-wrap: 1.2.3
-    dev: true
-
-  /p-limit@3.1.0:
-    resolution: {integrity: sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==}
-    engines: {node: '>=10'}
-    dependencies:
-      yocto-queue: 0.1.0
-    dev: true
-
-  /p-locate@5.0.0:
-    resolution: {integrity: sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==}
-    engines: {node: '>=10'}
-    dependencies:
-      p-limit: 3.1.0
-    dev: true
-
-  /pako@1.0.11:
-    resolution: {integrity: sha512-4hLB8Py4zZce5s4yd9XzopqwVv/yGNhV1Bl8NTmCq1763HeK2+EwVTv+leGeL13Dnh2wfbqowVPXCIO0z4taYw==}
-    dev: true
-
-  /parent-module@1.0.1:
-    resolution: {integrity: sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==}
-    engines: {node: '>=6'}
-    dependencies:
-      callsites: 3.1.0
-    dev: true
-
-  /path-exists@4.0.0:
-    resolution: {integrity: sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /path-is-absolute@1.0.1:
-    resolution: {integrity: sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /path-key@3.1.1:
-    resolution: {integrity: sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /path-type@4.0.0:
-    resolution: {integrity: sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /picomatch@2.3.1:
-    resolution: {integrity: sha512-JU3teHTNjmE2VCGFzuY8EXzCDVwEqB2a8fsIvwaStHhAWJEeVd1o1QD80CU6+ZdEXXSLbSsuLwJjkCBWqRQUVA==}
-    engines: {node: '>=8.6'}
-    dev: true
-
-  /prelude-ls@1.2.1:
-    resolution: {integrity: sha512-vkcDPrRZo1QZLbn5RLGPpg/WmIQ65qoWWhcGKf/b5eplkkarX0m9z8ppCat4mlOqUsWpyNuYgO3VRyrYHSzX5g==}
-    engines: {node: '>= 0.8.0'}
-    dev: true
-
-  /prettier@2.8.8:
-    resolution: {integrity: sha512-tdN8qQGvNjw4CHbY+XXk0JgCXn9QiF21a55rBe5LJAU+kDyC4WQn4+awm2Xfk2lQMk5fKup9XgzTZtGkjBdP9Q==}
-    engines: {node: '>=10.13.0'}
-    hasBin: true
-    dev: true
-
-  /process-nextick-args@2.0.1:
-    resolution: {integrity: sha512-3ouUOpQhtgrbOa17J7+uxOTpITYWaGP7/AhoR3+A+/1e9skrzelGi/dXzEYyvbxubEF6Wn2ypscTKiKJFFn1ag==}
-    dev: true
-
-  /punycode@2.3.0:
-    resolution: {integrity: sha512-rRV+zQD8tVFys26lAGR9WUuS4iUAngJScM+ZRSKtvl5tKeZ2t5bvdNFdNHBW9FWR4guGHlgmsZ1G7BSm2wTbuA==}
-    engines: {node: '>=6'}
-    dev: true
-
-  /queue-microtask@1.2.3:
-    resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
-    dev: true
-
-  /randombytes@2.1.0:
-    resolution: {integrity: sha512-vYl3iOX+4CKUWuxGi9Ukhie6fsqXqS9FE2Zaic4tNFD2N2QQaXOMFbuKK4QmDHC0JO6B1Zp41J0LpT0oR68amQ==}
-    dependencies:
-      safe-buffer: 5.2.1
-    dev: true
-
-  /readable-stream@2.3.8:
-    resolution: {integrity: sha512-8p0AUk4XODgIewSi0l8Epjs+EVnWiK7NoDIEGU0HhE7+ZyY8D1IMY7odu5lRrFXGg71L15KG8QrPmum45RTtdA==}
-    dependencies:
-      core-util-is: 1.0.3
-      inherits: 2.0.4
-      isarray: 1.0.0
-      process-nextick-args: 2.0.1
-      safe-buffer: 5.1.2
-      string_decoder: 1.1.1
-      util-deprecate: 1.0.2
-    dev: true
-
-  /readdirp@3.6.0:
-    resolution: {integrity: sha512-hOS089on8RduqdbhvQ5Z37A0ESjsqz6qnRcffsMU3495FuTdqSm+7bhJ29JvIOsBDEEnan5DPu9t3To9VRlMzA==}
-    engines: {node: '>=8.10.0'}
-    dependencies:
-      picomatch: 2.3.1
-    dev: true
-
-  /require-directory@2.1.1:
-    resolution: {integrity: sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /resolve-from@4.0.0:
-    resolution: {integrity: sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==}
-    engines: {node: '>=4'}
-    dev: true
-
-  /reusify@1.0.4:
-    resolution: {integrity: sha512-U9nH88a3fc/ekCF1l0/UP1IosiuIjyTh7hBvXVMHYgVcfGvt897Xguj2UOLDeI5BG2m7/uwyaLVT6fbtCwTyzw==}
-    engines: {iojs: '>=1.0.0', node: '>=0.10.0'}
-    dev: true
-
-  /rimraf@3.0.2:
-    resolution: {integrity: sha512-JZkJMZkAGFFPP2YqXZXPbMlMBgsxzE8ILs4lMIX/2o0L9UBw9O/Y3o6wFw/i9YLapcUJWwqbi3kdxIPdC62TIA==}
-    hasBin: true
-    dependencies:
-      glob: 7.2.0
-    dev: true
-
-  /run-parallel@1.2.0:
-    resolution: {integrity: sha512-5l4VyZR86LZ/lDxZTR6jqL8AFE2S0IFLMP26AbjsLVADxHdhB/c0GUsH+y39UfCi3dzz8OlQuPmnaJOMoDHQBA==}
-    dependencies:
-      queue-microtask: 1.2.3
-    dev: true
-
-  /safe-buffer@5.1.2:
-    resolution: {integrity: sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==}
-    dev: true
-
-  /safe-buffer@5.2.1:
-    resolution: {integrity: sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==}
-    dev: true
-
-  /semver@7.5.1:
-    resolution: {integrity: sha512-Wvss5ivl8TMRZXXESstBA4uR5iXgEN/VC5/sOcuXdVLzcdkz4HWetIoRfG5gb5X+ij/G9rw9YoGn3QoQ8OCSpw==}
-    engines: {node: '>=10'}
-    hasBin: true
-    dependencies:
-      lru-cache: 6.0.0
-    dev: true
-
-  /serialize-javascript@6.0.0:
-    resolution: {integrity: sha512-Qr3TosvguFt8ePWqsvRfrKyQXIiW+nGbYpy8XK24NQHE83caxWt+mIymTT19DGFbNWNLfEwsrkSmN64lVWB9ag==}
-    dependencies:
-      randombytes: 2.1.0
-    dev: true
-
-  /setimmediate@1.0.5:
-    resolution: {integrity: sha512-MATJdZp8sLqDl/68LfQmbP8zKPLQNV6BIZoIgrscFDQ+RsvK/BxeDQOgyxKKoh0y/8h3BqVFnCqQ/gd+reiIXA==}
-    dev: true
-
-  /shebang-command@2.0.0:
-    resolution: {integrity: sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==}
-    engines: {node: '>=8'}
-    dependencies:
-      shebang-regex: 3.0.0
-    dev: true
-
-  /shebang-regex@3.0.0:
-    resolution: {integrity: sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /slash@3.0.0:
-    resolution: {integrity: sha512-g9Q1haeby36OSStwb4ntCGGGaKsaVSjQ68fBxoQcutl5fS1vuY18H3wSt3jFyFtrkx+Kz0V1G85A4MyAdDMi2Q==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /string-width@4.2.3:
-    resolution: {integrity: sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==}
-    engines: {node: '>=8'}
-    dependencies:
-      emoji-regex: 8.0.0
-      is-fullwidth-code-point: 3.0.0
-      strip-ansi: 6.0.1
-    dev: true
-
-  /string_decoder@1.1.1:
-    resolution: {integrity: sha512-n/ShnvDi6FHbbVfviro+WojiFzv+s8MPMHBczVePfUpDJLwoLT0ht1l4YwBCbi8pJAveEEdnkHyPyTP/mzRfwg==}
-    dependencies:
-      safe-buffer: 5.1.2
-    dev: true
-
-  /strip-ansi@6.0.1:
-    resolution: {integrity: sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==}
-    engines: {node: '>=8'}
-    dependencies:
-      ansi-regex: 5.0.1
-    dev: true
-
-  /strip-json-comments@3.1.1:
-    resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
-    engines: {node: '>=8'}
-    dev: true
-
-  /supports-color@7.2.0:
-    resolution: {integrity: sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==}
-    engines: {node: '>=8'}
-    dependencies:
-      has-flag: 4.0.0
-    dev: true
-
-  /supports-color@8.1.1:
-    resolution: {integrity: sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==}
-    engines: {node: '>=10'}
-    dependencies:
-      has-flag: 4.0.0
-    dev: true
-
-  /text-table@0.2.0:
-    resolution: {integrity: sha512-N+8UisAXDGk8PFXP4HAzVR9nbfmVJ3zYLAWiTIoqC5v5isinhr+r5uaO8+7r3BMfuNIufIsA7RdpVgacC2cSpw==}
-    dev: true
-
-  /to-regex-range@5.0.1:
-    resolution: {integrity: sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==}
-    engines: {node: '>=8.0'}
-    dependencies:
-      is-number: 7.0.0
-    dev: true
-
-  /toml@3.0.0:
-    resolution: {integrity: sha512-y/mWCZinnvxjTKYhJ+pYxwD0mRLVvOtdS2Awbgxln6iEnt4rk0yBxeSBHkGJcPucRiG0e55mwWp+g/05rsrd6w==}
-    dev: false
-
-  /tslib@1.14.1:
-    resolution: {integrity: sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==}
-    dev: true
-
-  /tsutils@3.21.0(typescript@5.0.4):
-    resolution: {integrity: sha512-mHKK3iUXL+3UF6xL5k0PEhKRUBKPBCv/+RkEOpjRWxxx27KKRBmmA60A9pgOUvMi8GKhRMPEmjBRPzs2W7O1OA==}
-    engines: {node: '>= 6'}
-    peerDependencies:
-      typescript: '>=2.8.0 || >= 3.2.0-dev || >= 3.3.0-dev || >= 3.4.0-dev || >= 3.5.0-dev || >= 3.6.0-dev || >= 3.6.0-beta || >= 3.7.0-dev || >= 3.7.0-beta'
-    dependencies:
-      tslib: 1.14.1
-      typescript: 5.0.4
-    dev: true
-
-  /type-check@0.4.0:
-    resolution: {integrity: sha512-XleUoc9uwGXqjWwXaUTZAmzMcFZ5858QA2vvx1Ur5xIcixXIP+8LnFDgRplU30us6teqdlskFfu+ae4K79Ooew==}
-    engines: {node: '>= 0.8.0'}
-    dependencies:
-      prelude-ls: 1.2.1
-    dev: true
-
-  /type-fest@0.20.2:
-    resolution: {integrity: sha512-Ne+eE4r0/iWnpAxD852z3A+N0Bt5RN//NjJwRd2VFHEmrywxf5vsZlh4R6lixl6B+wz/8d+maTSAkN1FIkI3LQ==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /typescript@5.0.4:
-    resolution: {integrity: sha512-cW9T5W9xY37cc+jfEnaUvX91foxtHkza3Nw3wkoF4sSlKn0MONdkdEndig/qPBWXNkmplh3NzayQzCiHM4/hqw==}
-    engines: {node: '>=12.20'}
-    hasBin: true
-    dev: true
-
-  /uri-js@4.4.1:
-    resolution: {integrity: sha512-7rKUyy33Q1yc98pQ1DAmLtwX109F7TIfWlW1Ydo8Wl1ii1SeHieeh0HHfPeL2fMXK6z0s8ecKs9frCuLJvndBg==}
-    dependencies:
-      punycode: 2.3.0
-    dev: true
-
-  /util-deprecate@1.0.2:
-    resolution: {integrity: sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==}
-    dev: true
-
-  /which@2.0.2:
-    resolution: {integrity: sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==}
-    engines: {node: '>= 8'}
-    hasBin: true
-    dependencies:
-      isexe: 2.0.0
-    dev: true
-
-  /word-wrap@1.2.3:
-    resolution: {integrity: sha512-Hz/mrNwitNRh/HUAtM/VT/5VH+ygD6DV7mYKZAtHOrbs8U7lvPS6xf7EJKMF0uW1KJCl0H701g3ZGus+muE5vQ==}
-    engines: {node: '>=0.10.0'}
-    dev: true
-
-  /workerpool@6.2.1:
-    resolution: {integrity: sha512-ILEIE97kDZvF9Wb9f6h5aXK4swSlKGUcOEGiIYb2OOu/IrDU9iwj0fD//SsA6E5ibwJxpEvhullJY4Sl4GcpAw==}
-    dev: true
-
-  /wrap-ansi@7.0.0:
-    resolution: {integrity: sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q==}
-    engines: {node: '>=10'}
-    dependencies:
-      ansi-styles: 4.3.0
-      string-width: 4.2.3
-      strip-ansi: 6.0.1
-    dev: true
-
-  /wrappy@1.0.2:
-    resolution: {integrity: sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==}
-    dev: true
-
-  /y18n@5.0.8:
-    resolution: {integrity: sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /yallist@4.0.0:
-    resolution: {integrity: sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==}
-    dev: true
-
-  /yargs-parser@20.2.4:
-    resolution: {integrity: sha512-WOkpgNhPTlE73h4VFAFsOnomJVaovO8VqLDzy5saChRBFQFBoMYirowyW+Q9HB4HFF4Z7VZTiG3iSzJJA29yRA==}
-    engines: {node: '>=10'}
-    dev: true
-
-  /yargs-unparser@2.0.0:
-    resolution: {integrity: sha512-7pRTIA9Qc1caZ0bZ6RYRGbHJthJWuakf+WmHK0rVeLkNrrGhfoabBNdue6kdINI6r4if7ocq9aD/n7xwKOdzOA==}
-    engines: {node: '>=10'}
-    dependencies:
-      camelcase: 6.3.0
-      decamelize: 4.0.0
-      flat: 5.0.2
-      is-plain-obj: 2.1.0
-    dev: true
-
-  /yargs@16.2.0:
-    resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==}
-    engines: {node: '>=10'}
-    dependencies:
-      cliui: 7.0.4
-      escalade: 3.1.1
-      get-caller-file: 2.0.5
-      require-directory: 2.1.1
-      string-width: 4.2.3
-      y18n: 5.0.8
-      yargs-parser: 20.2.4
-    dev: true
-
-  /yocto-queue@0.1.0:
-    resolution: {integrity: sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==}
-    engines: {node: '>=10'}
-    dev: true
diff --git a/apps/scout-extension/src/extension.ts b/apps/scout-extension/src/extension.ts
deleted file mode 100644
index adee6f04..00000000
--- a/apps/scout-extension/src/extension.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import * as vscode from "vscode";
-import commandExists from "command-exists";
-import toml from "toml";
-import fs from "fs";
-import path from "path";
-
-const RUST_ANALYZER_CONFIG = "rust-analyzer.check.overrideCommand";
-
-export async function activate(_context: vscode.ExtensionContext) {
-  // Check workspace is an soroban project
-  if (!isProjectSoroban()) return;
-
-  const config = vscode.workspace.getConfiguration();
-
-  // Check rust-analyzer is installed
-  if (!config.has(RUST_ANALYZER_CONFIG)) {
-    console.error("rust-analyzer is not installed");
-    await vscode.window.showErrorMessage(
-      "rust-analyzer must be installed in order for scout to work"
-    );
-  }
-
-  // Check scout is installed
-  try {
-    await commandExists("cargo-scout-audit");
-  } catch (err) {
-    console.error("cargo-scout-audit is not installed");
-    await vscode.window.showErrorMessage(
-      "cargo-scout-audit must be installed in order for scout to work"
-    );
-    return;
-  }
-
-  // Update settings to change rust-analyzer config
-  await config.update(RUST_ANALYZER_CONFIG, [
-    "cargo",
-    "scout-audit",
-    "--",
-    "--message-format=json",
-  ]);
-}
-
-export function deactivate() {
-  // unused
-}
-
-function isProjectSoroban(): boolean {
-  const workspaceFolders = vscode.workspace.workspaceFolders;
-  if (!workspaceFolders) {
-    console.log("No workspace is opened.");
-    return false;
-  }
-
-  // Get the path of the first workspace folder
-  const cargoTomlPath = path.join(workspaceFolders[0].uri.fsPath, "Cargo.toml");
-  if (!fs.existsSync(cargoTomlPath)) {
-    console.log("Cargo.toml does not exist in the workspace root.");
-    return false;
-  }
-
-  // Read and parse the Cargo.toml file
-  const cargoToml = fs.readFileSync(cargoTomlPath, "utf-8");
-  let cargoTomlParsed;
-  try {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    cargoTomlParsed = toml.parse(cargoToml);
-  } catch (error) {
-    console.error("Error parsing Cargo.toml:", error);
-    return false;
-  }
-
-  // Check if soroban-sdk is a direct dependency
-  if (
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    !cargoTomlParsed.dependencies ||
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    !cargoTomlParsed.dependencies["soroban-sdk"]
-  ) {
-    console.log("soroban-sdk crate is not a direct dependency in Cargo.toml.");
-    return false;
-  }
-
-  console.log("soroban-sdk crate is a direct dependency in Cargo.toml.")
-  return true;
-}
diff --git a/apps/scout-extension/src/test/runTest.ts b/apps/scout-extension/src/test/runTest.ts
deleted file mode 100644
index 80111913..00000000
--- a/apps/scout-extension/src/test/runTest.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import * as path from "path";
-
-import { runTests } from "@vscode/test-electron";
-
-async function main() {
-  try {
-    // The folder containing the Extension Manifest package.json
-    // Passed to `--extensionDevelopmentPath`
-    const extensionDevelopmentPath = path.resolve(__dirname, "../../");
-
-    // The path to test runner
-    // Passed to --extensionTestsPath
-    const extensionTestsPath = path.resolve(__dirname, "./suite/index");
-
-    // Download VS Code, unzip it and run the integration test
-    await runTests({ extensionDevelopmentPath, extensionTestsPath });
-  } catch (err) {
-    console.error("Failed to run tests", err);
-    process.exit(1);
-  }
-}
-
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
diff --git a/apps/scout-extension/src/test/suite/extension.test.ts b/apps/scout-extension/src/test/suite/extension.test.ts
deleted file mode 100644
index eb6dc2c4..00000000
--- a/apps/scout-extension/src/test/suite/extension.test.ts
+++ /dev/null
@@ -1,15 +0,0 @@
-import * as assert from "assert";
-
-// You can import and use all API from the 'vscode' module
-// as well as import your extension to test it
-import * as vscode from "vscode";
-// import * as myExtension from '../../extension';
-
-suite("Extension Test Suite", () => {
-  void vscode.window.showInformationMessage("Start all tests.");
-
-  test("Sample test", () => {
-    assert.strictEqual(-1, [1, 2, 3].indexOf(5));
-    assert.strictEqual(-1, [1, 2, 3].indexOf(0));
-  });
-});
diff --git a/apps/scout-extension/src/test/suite/index.ts b/apps/scout-extension/src/test/suite/index.ts
deleted file mode 100644
index 07c757ca..00000000
--- a/apps/scout-extension/src/test/suite/index.ts
+++ /dev/null
@@ -1,38 +0,0 @@
-import path from "path";
-import Mocha from "mocha";
-import glob from "glob";
-
-export function run(): Promise<void> {
-  // Create the mocha test
-  const mocha = new Mocha({
-    ui: "tdd",
-    color: true,
-  });
-
-  const testsRoot = path.resolve(__dirname, "..");
-
-  return new Promise((c, e) => {
-    glob("**/**.test.js", { cwd: testsRoot }, (err, files) => {
-      if (err) {
-        return e(err);
-      }
-
-      // Add files to the test suite
-      files.forEach((f) => mocha.addFile(path.resolve(testsRoot, f)));
-
-      try {
-        // Run the mocha test
-        mocha.run((failures) => {
-          if (failures > 0) {
-            e(new Error(`${failures} tests failed.`));
-          } else {
-            c();
-          }
-        });
-      } catch (err) {
-        console.error(err);
-        e(err);
-      }
-    });
-  });
-}
diff --git a/apps/scout-extension/tsconfig.json b/apps/scout-extension/tsconfig.json
deleted file mode 100644
index 7c0f8c19..00000000
--- a/apps/scout-extension/tsconfig.json
+++ /dev/null
@@ -1,18 +0,0 @@
-{
-	"compilerOptions": {
-		"module": "commonjs",
-		"target": "ES2020",
-		"outDir": "out",
-		"lib": [
-			"ES2020"
-		],
-		"sourceMap": true,
-		"rootDir": "src",
-		"strict": true   /* enable all strict type-checking options */,
-        "esModuleInterop": true
-		/* Additional Checks */
-		// "noImplicitReturns": true, /* Report error when not all code paths in function return a value. */
-		// "noFallthroughCasesInSwitch": true, /* Report errors for fallthrough cases in switch statement. */
-		// "noUnusedParameters": true,  /* Report errors on unused parameters. */
-	}
-}
diff --git a/scout-audit-clippy-utils/Cargo.lock b/scout-audit-clippy-utils/Cargo.lock
deleted file mode 100644
index b3fddfea..00000000
--- a/scout-audit-clippy-utils/Cargo.lock
+++ /dev/null
@@ -1,46 +0,0 @@
-# This file is automatically @generated by Cargo.
-# It is not intended for manual editing.
-version = 3
-
-[[package]]
-name = "arrayvec"
-version = "0.7.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
-
-[[package]]
-name = "either"
-version = "1.9.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
-
-[[package]]
-name = "if_chain"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb56e1aa765b4b4f3aadfab769793b7087bb03a4ea4920644a6d238e2df5b9ed"
-
-[[package]]
-name = "itertools"
-version = "0.10.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
-dependencies = [
- "either",
-]
-
-[[package]]
-name = "rustc-semver"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5be1bdc7edf596692617627bbfeaba522131b18e06ca4df2b6b689e3c5d5ce84"
-
-[[package]]
-name = "scout-audit-clippy-utils"
-version = "0.2.0"
-dependencies = [
- "arrayvec",
- "if_chain",
- "itertools",
- "rustc-semver",
-]
diff --git a/scout-audit-clippy-utils/Cargo.toml b/scout-audit-clippy-utils/Cargo.toml
deleted file mode 100644
index 149d6772..00000000
--- a/scout-audit-clippy-utils/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-name = "scout-audit-clippy-utils"
-version = "0.2.1"
-edition = "2021"
-license = "MIT"
-repository = "https://github.com/rust-lang/rust-clippy"
-description = "For internal usage by cargo-scout-audit."
-
-[dependencies]
-arrayvec = { version = "0.7", default-features = false }
-if_chain = "1.0"
-itertools = "0.10.1"
-rustc-semver = "1.1"
-
-[features]
-deny-warnings = []
-internal = []
-
-[package.metadata.rust-analyzer]
-# This crate uses #[feature(rustc_private)]
-rustc_private = true
diff --git a/scout-audit-clippy-utils/README.md b/scout-audit-clippy-utils/README.md
deleted file mode 100644
index 8aca32ce..00000000
--- a/scout-audit-clippy-utils/README.md
+++ /dev/null
@@ -1,9 +0,0 @@
-# Scout Audit Clippy Utils
-
-This crate is a copy of `clippy_utils` crate found on the [rust-clippy](https://github.com/rust-lang/rust-clippy/tree/master) repository.
-
-This crate is used to allow publishing `scout-audit-internal` to crates.io given `clippy_utils` itself is not published.
-
-## Version
-
-Commit `7671c283a50b5d1168841f3014b14000f01dd204`.
diff --git a/scout-audit-clippy-utils/rust-toolchain b/scout-audit-clippy-utils/rust-toolchain
deleted file mode 100644
index d575da6d..00000000
--- a/scout-audit-clippy-utils/rust-toolchain
+++ /dev/null
@@ -1,3 +0,0 @@
-[toolchain]
-channel = "nightly-2023-12-16"
-components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
diff --git a/scout-audit-clippy-utils/src/ast_utils.rs b/scout-audit-clippy-utils/src/ast_utils.rs
deleted file mode 100644
index a78ff020..00000000
--- a/scout-audit-clippy-utils/src/ast_utils.rs
+++ /dev/null
@@ -1,786 +0,0 @@
-//! Utilities for manipulating and extracting information from `rustc_ast::ast`.
-//!
-//! - The `eq_foobar` functions test for semantic equality but ignores `NodeId`s and `Span`s.
-
-#![allow(clippy::similar_names, clippy::wildcard_imports, clippy::enum_glob_use)]
-
-use crate::{both, over};
-use rustc_ast::ptr::P;
-use rustc_ast::{self as ast, *};
-use rustc_span::symbol::Ident;
-use std::mem;
-
-pub mod ident_iter;
-pub use ident_iter::IdentIter;
-
-pub fn is_useless_with_eq_exprs(kind: BinOpKind) -> bool {
-    use BinOpKind::*;
-    matches!(
-        kind,
-        Sub | Div | Eq | Lt | Le | Gt | Ge | Ne | And | Or | BitXor | BitAnd | BitOr
-    )
-}
-
-/// Checks if each element in the first slice is contained within the latter as per `eq_fn`.
-pub fn unordered_over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
-    left.len() == right.len() && left.iter().all(|l| right.iter().any(|r| eq_fn(l, r)))
-}
-
-pub fn eq_id(l: Ident, r: Ident) -> bool {
-    l.name == r.name
-}
-
-pub fn eq_pat(l: &Pat, r: &Pat) -> bool {
-    use PatKind::*;
-    match (&l.kind, &r.kind) {
-        (Paren(l), _) => eq_pat(l, r),
-        (_, Paren(r)) => eq_pat(l, r),
-        (Wild, Wild) | (Rest, Rest) => true,
-        (Lit(l), Lit(r)) => eq_expr(l, r),
-        (Ident(b1, i1, s1), Ident(b2, i2, s2)) => b1 == b2 && eq_id(*i1, *i2) && both(s1, s2, |l, r| eq_pat(l, r)),
-        (Range(lf, lt, le), Range(rf, rt, re)) => {
-            eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt) && eq_range_end(&le.node, &re.node)
-        },
-        (Box(l), Box(r))
-        | (Ref(l, Mutability::Not), Ref(r, Mutability::Not))
-        | (Ref(l, Mutability::Mut), Ref(r, Mutability::Mut)) => eq_pat(l, r),
-        (Tuple(l), Tuple(r)) | (Slice(l), Slice(r)) => over(l, r, |l, r| eq_pat(l, r)),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, eq_qself) && eq_path(lp, rp),
-        (TupleStruct(lqself, lp, lfs), TupleStruct(rqself, rp, rfs)) => {
-            eq_maybe_qself(lqself, rqself) && eq_path(lp, rp) && over(lfs, rfs, |l, r| eq_pat(l, r))
-        },
-        (Struct(lqself, lp, lfs, lr), Struct(rqself, rp, rfs, rr)) => {
-            lr == rr && eq_maybe_qself(lqself, rqself) && eq_path(lp, rp) && unordered_over(lfs, rfs, eq_field_pat)
-        },
-        (Or(ls), Or(rs)) => unordered_over(ls, rs, |l, r| eq_pat(l, r)),
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_range_end(l: &RangeEnd, r: &RangeEnd) -> bool {
-    match (l, r) {
-        (RangeEnd::Excluded, RangeEnd::Excluded) => true,
-        (RangeEnd::Included(l), RangeEnd::Included(r)) => {
-            matches!(l, RangeSyntax::DotDotEq) == matches!(r, RangeSyntax::DotDotEq)
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_field_pat(l: &PatField, r: &PatField) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && eq_id(l.ident, r.ident)
-        && eq_pat(&l.pat, &r.pat)
-        && over(&l.attrs, &r.attrs, eq_attr)
-}
-
-pub fn eq_qself(l: &P<QSelf>, r: &P<QSelf>) -> bool {
-    l.position == r.position && eq_ty(&l.ty, &r.ty)
-}
-
-pub fn eq_maybe_qself(l: &Option<P<QSelf>>, r: &Option<P<QSelf>>) -> bool {
-    match (l, r) {
-        (Some(l), Some(r)) => eq_qself(l, r),
-        (None, None) => true,
-        _ => false,
-    }
-}
-
-pub fn eq_path(l: &Path, r: &Path) -> bool {
-    over(&l.segments, &r.segments, eq_path_seg)
-}
-
-pub fn eq_path_seg(l: &PathSegment, r: &PathSegment) -> bool {
-    eq_id(l.ident, r.ident) && both(&l.args, &r.args, |l, r| eq_generic_args(l, r))
-}
-
-pub fn eq_generic_args(l: &GenericArgs, r: &GenericArgs) -> bool {
-    match (l, r) {
-        (GenericArgs::AngleBracketed(l), GenericArgs::AngleBracketed(r)) => over(&l.args, &r.args, eq_angle_arg),
-        (GenericArgs::Parenthesized(l), GenericArgs::Parenthesized(r)) => {
-            over(&l.inputs, &r.inputs, |l, r| eq_ty(l, r)) && eq_fn_ret_ty(&l.output, &r.output)
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_angle_arg(l: &AngleBracketedArg, r: &AngleBracketedArg) -> bool {
-    match (l, r) {
-        (AngleBracketedArg::Arg(l), AngleBracketedArg::Arg(r)) => eq_generic_arg(l, r),
-        (AngleBracketedArg::Constraint(l), AngleBracketedArg::Constraint(r)) => eq_assoc_constraint(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_generic_arg(l: &GenericArg, r: &GenericArg) -> bool {
-    match (l, r) {
-        (GenericArg::Lifetime(l), GenericArg::Lifetime(r)) => eq_id(l.ident, r.ident),
-        (GenericArg::Type(l), GenericArg::Type(r)) => eq_ty(l, r),
-        (GenericArg::Const(l), GenericArg::Const(r)) => eq_expr(&l.value, &r.value),
-        _ => false,
-    }
-}
-
-pub fn eq_expr_opt(l: &Option<P<Expr>>, r: &Option<P<Expr>>) -> bool {
-    both(l, r, |l, r| eq_expr(l, r))
-}
-
-pub fn eq_struct_rest(l: &StructRest, r: &StructRest) -> bool {
-    match (l, r) {
-        (StructRest::Base(lb), StructRest::Base(rb)) => eq_expr(lb, rb),
-        (StructRest::Rest(_), StructRest::Rest(_)) | (StructRest::None, StructRest::None) => true,
-        _ => false,
-    }
-}
-
-pub fn eq_expr(l: &Expr, r: &Expr) -> bool {
-    use ExprKind::*;
-    if !over(&l.attrs, &r.attrs, eq_attr) {
-        return false;
-    }
-    match (&l.kind, &r.kind) {
-        (Paren(l), _) => eq_expr(l, r),
-        (_, Paren(r)) => eq_expr(l, r),
-        (Err, Err) => true,
-        (Try(l), Try(r)) | (Await(l, _), Await(r, _)) => eq_expr(l, r),
-        (Array(l), Array(r)) => over(l, r, |l, r| eq_expr(l, r)),
-        (Tup(l), Tup(r)) => over(l, r, |l, r| eq_expr(l, r)),
-        (Repeat(le, ls), Repeat(re, rs)) => eq_expr(le, re) && eq_expr(&ls.value, &rs.value),
-        (Call(lc, la), Call(rc, ra)) => eq_expr(lc, rc) && over(la, ra, |l, r| eq_expr(l, r)),
-        (
-            MethodCall(box ast::MethodCall {
-                seg: ls,
-                receiver: lr,
-                args: la,
-                ..
-            }),
-            MethodCall(box ast::MethodCall {
-                seg: rs,
-                receiver: rr,
-                args: ra,
-                ..
-            }),
-        ) => eq_path_seg(ls, rs) && eq_expr(lr, rr) && over(la, ra, |l, r| eq_expr(l, r)),
-        (Binary(lo, ll, lr), Binary(ro, rl, rr)) => lo.node == ro.node && eq_expr(ll, rl) && eq_expr(lr, rr),
-        (Unary(lo, l), Unary(ro, r)) => mem::discriminant(lo) == mem::discriminant(ro) && eq_expr(l, r),
-        (Lit(l), Lit(r)) => l == r,
-        (Cast(l, lt), Cast(r, rt)) | (Type(l, lt), Type(r, rt)) => eq_expr(l, r) && eq_ty(lt, rt),
-        (Let(lp, le, _, _), Let(rp, re, _, _)) => eq_pat(lp, rp) && eq_expr(le, re),
-        (If(lc, lt, le), If(rc, rt, re)) => eq_expr(lc, rc) && eq_block(lt, rt) && eq_expr_opt(le, re),
-        (While(lc, lt, ll), While(rc, rt, rl)) => eq_label(ll, rl) && eq_expr(lc, rc) && eq_block(lt, rt),
-        (ForLoop(lp, li, lt, ll), ForLoop(rp, ri, rt, rl)) => {
-            eq_label(ll, rl) && eq_pat(lp, rp) && eq_expr(li, ri) && eq_block(lt, rt)
-        },
-        (Loop(lt, ll, _), Loop(rt, rl, _)) => eq_label(ll, rl) && eq_block(lt, rt),
-        (Block(lb, ll), Block(rb, rl)) => eq_label(ll, rl) && eq_block(lb, rb),
-        (TryBlock(l), TryBlock(r)) => eq_block(l, r),
-        (Yield(l), Yield(r)) | (Ret(l), Ret(r)) => eq_expr_opt(l, r),
-        (Break(ll, le), Break(rl, re)) => eq_label(ll, rl) && eq_expr_opt(le, re),
-        (Continue(ll), Continue(rl)) => eq_label(ll, rl),
-        (Assign(l1, l2, _), Assign(r1, r2, _)) | (Index(l1, l2, _), Index(r1, r2, _)) => {
-            eq_expr(l1, r1) && eq_expr(l2, r2)
-        },
-        (AssignOp(lo, lp, lv), AssignOp(ro, rp, rv)) => lo.node == ro.node && eq_expr(lp, rp) && eq_expr(lv, rv),
-        (Field(lp, lf), Field(rp, rf)) => eq_id(*lf, *rf) && eq_expr(lp, rp),
-        (Match(ls, la), Match(rs, ra)) => eq_expr(ls, rs) && over(la, ra, eq_arm),
-        (
-            Closure(box ast::Closure {
-                binder: lb,
-                capture_clause: lc,
-                asyncness: la,
-                movability: lm,
-                fn_decl: lf,
-                body: le,
-                ..
-            }),
-            Closure(box ast::Closure {
-                binder: rb,
-                capture_clause: rc,
-                asyncness: ra,
-                movability: rm,
-                fn_decl: rf,
-                body: re,
-                ..
-            }),
-        ) => {
-            eq_closure_binder(lb, rb)
-                && lc == rc
-                && la.is_async() == ra.is_async()
-                && lm == rm
-                && eq_fn_decl(lf, rf)
-                && eq_expr(le, re)
-        },
-        (Async(lc, lb), Async(rc, rb)) => lc == rc && eq_block(lb, rb),
-        (Range(lf, lt, ll), Range(rf, rt, rl)) => ll == rl && eq_expr_opt(lf, rf) && eq_expr_opt(lt, rt),
-        (AddrOf(lbk, lm, le), AddrOf(rbk, rm, re)) => lbk == rbk && lm == rm && eq_expr(le, re),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, eq_qself) && eq_path(lp, rp),
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        (Struct(lse), Struct(rse)) => {
-            eq_maybe_qself(&lse.qself, &rse.qself)
-                && eq_path(&lse.path, &rse.path)
-                && eq_struct_rest(&lse.rest, &rse.rest)
-                && unordered_over(&lse.fields, &rse.fields, eq_field)
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_field(l: &ExprField, r: &ExprField) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && eq_id(l.ident, r.ident)
-        && eq_expr(&l.expr, &r.expr)
-        && over(&l.attrs, &r.attrs, eq_attr)
-}
-
-pub fn eq_arm(l: &Arm, r: &Arm) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && eq_pat(&l.pat, &r.pat)
-        && eq_expr(&l.body, &r.body)
-        && eq_expr_opt(&l.guard, &r.guard)
-        && over(&l.attrs, &r.attrs, eq_attr)
-}
-
-pub fn eq_label(l: &Option<Label>, r: &Option<Label>) -> bool {
-    both(l, r, |l, r| eq_id(l.ident, r.ident))
-}
-
-pub fn eq_block(l: &Block, r: &Block) -> bool {
-    l.rules == r.rules && over(&l.stmts, &r.stmts, eq_stmt)
-}
-
-pub fn eq_stmt(l: &Stmt, r: &Stmt) -> bool {
-    use StmtKind::*;
-    match (&l.kind, &r.kind) {
-        (Local(l), Local(r)) => {
-            eq_pat(&l.pat, &r.pat)
-                && both(&l.ty, &r.ty, |l, r| eq_ty(l, r))
-                && eq_local_kind(&l.kind, &r.kind)
-                && over(&l.attrs, &r.attrs, eq_attr)
-        },
-        (Item(l), Item(r)) => eq_item(l, r, eq_item_kind),
-        (Expr(l), Expr(r)) | (Semi(l), Semi(r)) => eq_expr(l, r),
-        (Empty, Empty) => true,
-        (MacCall(l), MacCall(r)) => {
-            l.style == r.style && eq_mac_call(&l.mac, &r.mac) && over(&l.attrs, &r.attrs, eq_attr)
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_local_kind(l: &LocalKind, r: &LocalKind) -> bool {
-    use LocalKind::*;
-    match (l, r) {
-        (Decl, Decl) => true,
-        (Init(l), Init(r)) => eq_expr(l, r),
-        (InitElse(li, le), InitElse(ri, re)) => eq_expr(li, ri) && eq_block(le, re),
-        _ => false,
-    }
-}
-
-pub fn eq_item<K>(l: &Item<K>, r: &Item<K>, mut eq_kind: impl FnMut(&K, &K) -> bool) -> bool {
-    eq_id(l.ident, r.ident) && over(&l.attrs, &r.attrs, eq_attr) && eq_vis(&l.vis, &r.vis) && eq_kind(&l.kind, &r.kind)
-}
-
-#[expect(clippy::too_many_lines)] // Just a big match statement
-pub fn eq_item_kind(l: &ItemKind, r: &ItemKind) -> bool {
-    use ItemKind::*;
-    match (l, r) {
-        (ExternCrate(l), ExternCrate(r)) => l == r,
-        (Use(l), Use(r)) => eq_use_tree(l, r),
-        (
-            Static(box ast::StaticItem {
-                ty: lt,
-                mutability: lm,
-                expr: le,
-            }),
-            Static(box ast::StaticItem {
-                ty: rt,
-                mutability: rm,
-                expr: re,
-            }),
-        ) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
-        (
-            Const(box ast::ConstItem {
-                defaultness: ld,
-                generics: lg,
-                ty: lt,
-                expr: le,
-            }),
-            Const(box ast::ConstItem {
-                defaultness: rd,
-                generics: rg,
-                ty: rt,
-                expr: re,
-            }),
-        ) => eq_defaultness(*ld, *rd) && eq_generics(lg, rg) && eq_ty(lt, rt) && eq_expr_opt(le, re),
-        (
-            Fn(box ast::Fn {
-                defaultness: ld,
-                sig: lf,
-                generics: lg,
-                body: lb,
-            }),
-            Fn(box ast::Fn {
-                defaultness: rd,
-                sig: rf,
-                generics: rg,
-                body: rb,
-            }),
-        ) => {
-            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
-        },
-        (Mod(lu, lmk), Mod(ru, rmk)) => {
-            lu == ru
-                && match (lmk, rmk) {
-                    (ModKind::Loaded(litems, linline, _), ModKind::Loaded(ritems, rinline, _)) => {
-                        linline == rinline && over(litems, ritems, |l, r| eq_item(l, r, eq_item_kind))
-                    },
-                    (ModKind::Unloaded, ModKind::Unloaded) => true,
-                    _ => false,
-                }
-        },
-        (ForeignMod(l), ForeignMod(r)) => {
-            both(&l.abi, &r.abi, eq_str_lit) && over(&l.items, &r.items, |l, r| eq_item(l, r, eq_foreign_item_kind))
-        },
-        (
-            TyAlias(box ast::TyAlias {
-                defaultness: ld,
-                generics: lg,
-                bounds: lb,
-                ty: lt,
-                ..
-            }),
-            TyAlias(box ast::TyAlias {
-                defaultness: rd,
-                generics: rg,
-                bounds: rb,
-                ty: rt,
-                ..
-            }),
-        ) => {
-            eq_defaultness(*ld, *rd)
-                && eq_generics(lg, rg)
-                && over(lb, rb, eq_generic_bound)
-                && both(lt, rt, |l, r| eq_ty(l, r))
-        },
-        (Enum(le, lg), Enum(re, rg)) => over(&le.variants, &re.variants, eq_variant) && eq_generics(lg, rg),
-        (Struct(lv, lg), Struct(rv, rg)) | (Union(lv, lg), Union(rv, rg)) => {
-            eq_variant_data(lv, rv) && eq_generics(lg, rg)
-        },
-        (
-            Trait(box ast::Trait {
-                is_auto: la,
-                unsafety: lu,
-                generics: lg,
-                bounds: lb,
-                items: li,
-            }),
-            Trait(box ast::Trait {
-                is_auto: ra,
-                unsafety: ru,
-                generics: rg,
-                bounds: rb,
-                items: ri,
-            }),
-        ) => {
-            la == ra
-                && matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
-                && eq_generics(lg, rg)
-                && over(lb, rb, eq_generic_bound)
-                && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
-        },
-        (TraitAlias(lg, lb), TraitAlias(rg, rb)) => eq_generics(lg, rg) && over(lb, rb, eq_generic_bound),
-        (
-            Impl(box ast::Impl {
-                unsafety: lu,
-                polarity: lp,
-                defaultness: ld,
-                constness: lc,
-                generics: lg,
-                of_trait: lot,
-                self_ty: lst,
-                items: li,
-            }),
-            Impl(box ast::Impl {
-                unsafety: ru,
-                polarity: rp,
-                defaultness: rd,
-                constness: rc,
-                generics: rg,
-                of_trait: rot,
-                self_ty: rst,
-                items: ri,
-            }),
-        ) => {
-            matches!(lu, Unsafe::No) == matches!(ru, Unsafe::No)
-                && matches!(lp, ImplPolarity::Positive) == matches!(rp, ImplPolarity::Positive)
-                && eq_defaultness(*ld, *rd)
-                && matches!(lc, ast::Const::No) == matches!(rc, ast::Const::No)
-                && eq_generics(lg, rg)
-                && both(lot, rot, |l, r| eq_path(&l.path, &r.path))
-                && eq_ty(lst, rst)
-                && over(li, ri, |l, r| eq_item(l, r, eq_assoc_item_kind))
-        },
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        (MacroDef(l), MacroDef(r)) => l.macro_rules == r.macro_rules && eq_delim_args(&l.body, &r.body),
-        _ => false,
-    }
-}
-
-pub fn eq_foreign_item_kind(l: &ForeignItemKind, r: &ForeignItemKind) -> bool {
-    use ForeignItemKind::*;
-    match (l, r) {
-        (Static(lt, lm, le), Static(rt, rm, re)) => lm == rm && eq_ty(lt, rt) && eq_expr_opt(le, re),
-        (
-            Fn(box ast::Fn {
-                defaultness: ld,
-                sig: lf,
-                generics: lg,
-                body: lb,
-            }),
-            Fn(box ast::Fn {
-                defaultness: rd,
-                sig: rf,
-                generics: rg,
-                body: rb,
-            }),
-        ) => {
-            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
-        },
-        (
-            TyAlias(box ast::TyAlias {
-                defaultness: ld,
-                generics: lg,
-                bounds: lb,
-                ty: lt,
-                ..
-            }),
-            TyAlias(box ast::TyAlias {
-                defaultness: rd,
-                generics: rg,
-                bounds: rb,
-                ty: rt,
-                ..
-            }),
-        ) => {
-            eq_defaultness(*ld, *rd)
-                && eq_generics(lg, rg)
-                && over(lb, rb, eq_generic_bound)
-                && both(lt, rt, |l, r| eq_ty(l, r))
-        },
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_assoc_item_kind(l: &AssocItemKind, r: &AssocItemKind) -> bool {
-    use AssocItemKind::*;
-    match (l, r) {
-        (
-            Const(box ast::ConstItem {
-                defaultness: ld,
-                generics: lg,
-                ty: lt,
-                expr: le,
-            }),
-            Const(box ast::ConstItem {
-                defaultness: rd,
-                generics: rg,
-                ty: rt,
-                expr: re,
-            }),
-        ) => eq_defaultness(*ld, *rd) && eq_generics(lg, rg) && eq_ty(lt, rt) && eq_expr_opt(le, re),
-        (
-            Fn(box ast::Fn {
-                defaultness: ld,
-                sig: lf,
-                generics: lg,
-                body: lb,
-            }),
-            Fn(box ast::Fn {
-                defaultness: rd,
-                sig: rf,
-                generics: rg,
-                body: rb,
-            }),
-        ) => {
-            eq_defaultness(*ld, *rd) && eq_fn_sig(lf, rf) && eq_generics(lg, rg) && both(lb, rb, |l, r| eq_block(l, r))
-        },
-        (
-            Type(box ast::TyAlias {
-                defaultness: ld,
-                generics: lg,
-                bounds: lb,
-                ty: lt,
-                ..
-            }),
-            Type(box ast::TyAlias {
-                defaultness: rd,
-                generics: rg,
-                bounds: rb,
-                ty: rt,
-                ..
-            }),
-        ) => {
-            eq_defaultness(*ld, *rd)
-                && eq_generics(lg, rg)
-                && over(lb, rb, eq_generic_bound)
-                && both(lt, rt, |l, r| eq_ty(l, r))
-        },
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_variant(l: &Variant, r: &Variant) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && over(&l.attrs, &r.attrs, eq_attr)
-        && eq_vis(&l.vis, &r.vis)
-        && eq_id(l.ident, r.ident)
-        && eq_variant_data(&l.data, &r.data)
-        && both(&l.disr_expr, &r.disr_expr, |l, r| eq_expr(&l.value, &r.value))
-}
-
-pub fn eq_variant_data(l: &VariantData, r: &VariantData) -> bool {
-    use VariantData::*;
-    match (l, r) {
-        (Unit(_), Unit(_)) => true,
-        (Struct(l, _), Struct(r, _)) | (Tuple(l, _), Tuple(r, _)) => over(l, r, eq_struct_field),
-        _ => false,
-    }
-}
-
-pub fn eq_struct_field(l: &FieldDef, r: &FieldDef) -> bool {
-    l.is_placeholder == r.is_placeholder
-        && over(&l.attrs, &r.attrs, eq_attr)
-        && eq_vis(&l.vis, &r.vis)
-        && both(&l.ident, &r.ident, |l, r| eq_id(*l, *r))
-        && eq_ty(&l.ty, &r.ty)
-}
-
-pub fn eq_fn_sig(l: &FnSig, r: &FnSig) -> bool {
-    eq_fn_decl(&l.decl, &r.decl) && eq_fn_header(&l.header, &r.header)
-}
-
-pub fn eq_fn_header(l: &FnHeader, r: &FnHeader) -> bool {
-    matches!(l.unsafety, Unsafe::No) == matches!(r.unsafety, Unsafe::No)
-        && l.asyncness.is_async() == r.asyncness.is_async()
-        && matches!(l.constness, Const::No) == matches!(r.constness, Const::No)
-        && eq_ext(&l.ext, &r.ext)
-}
-
-pub fn eq_generics(l: &Generics, r: &Generics) -> bool {
-    over(&l.params, &r.params, eq_generic_param)
-        && over(&l.where_clause.predicates, &r.where_clause.predicates, |l, r| {
-            eq_where_predicate(l, r)
-        })
-}
-
-pub fn eq_where_predicate(l: &WherePredicate, r: &WherePredicate) -> bool {
-    use WherePredicate::*;
-    match (l, r) {
-        (BoundPredicate(l), BoundPredicate(r)) => {
-            over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
-                eq_generic_param(l, r)
-            }) && eq_ty(&l.bounded_ty, &r.bounded_ty)
-                && over(&l.bounds, &r.bounds, eq_generic_bound)
-        },
-        (RegionPredicate(l), RegionPredicate(r)) => {
-            eq_id(l.lifetime.ident, r.lifetime.ident) && over(&l.bounds, &r.bounds, eq_generic_bound)
-        },
-        (EqPredicate(l), EqPredicate(r)) => eq_ty(&l.lhs_ty, &r.lhs_ty) && eq_ty(&l.rhs_ty, &r.rhs_ty),
-        _ => false,
-    }
-}
-
-pub fn eq_use_tree(l: &UseTree, r: &UseTree) -> bool {
-    eq_path(&l.prefix, &r.prefix) && eq_use_tree_kind(&l.kind, &r.kind)
-}
-
-pub fn eq_anon_const(l: &AnonConst, r: &AnonConst) -> bool {
-    eq_expr(&l.value, &r.value)
-}
-
-pub fn eq_use_tree_kind(l: &UseTreeKind, r: &UseTreeKind) -> bool {
-    use UseTreeKind::*;
-    match (l, r) {
-        (Glob, Glob) => true,
-        (Simple(l), Simple(r)) => both(l, r, |l, r| eq_id(*l, *r)),
-        (Nested(l), Nested(r)) => over(l, r, |(l, _), (r, _)| eq_use_tree(l, r)),
-        _ => false,
-    }
-}
-
-pub fn eq_defaultness(l: Defaultness, r: Defaultness) -> bool {
-    matches!(
-        (l, r),
-        (Defaultness::Final, Defaultness::Final) | (Defaultness::Default(_), Defaultness::Default(_))
-    )
-}
-
-pub fn eq_vis(l: &Visibility, r: &Visibility) -> bool {
-    use VisibilityKind::*;
-    match (&l.kind, &r.kind) {
-        (Public, Public) | (Inherited, Inherited) => true,
-        (Restricted { path: l, .. }, Restricted { path: r, .. }) => eq_path(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_fn_decl(l: &FnDecl, r: &FnDecl) -> bool {
-    eq_fn_ret_ty(&l.output, &r.output)
-        && over(&l.inputs, &r.inputs, |l, r| {
-            l.is_placeholder == r.is_placeholder
-                && eq_pat(&l.pat, &r.pat)
-                && eq_ty(&l.ty, &r.ty)
-                && over(&l.attrs, &r.attrs, eq_attr)
-        })
-}
-
-pub fn eq_closure_binder(l: &ClosureBinder, r: &ClosureBinder) -> bool {
-    match (l, r) {
-        (ClosureBinder::NotPresent, ClosureBinder::NotPresent) => true,
-        (ClosureBinder::For { generic_params: lp, .. }, ClosureBinder::For { generic_params: rp, .. }) => {
-            lp.len() == rp.len() && std::iter::zip(lp.iter(), rp.iter()).all(|(l, r)| eq_generic_param(l, r))
-        },
-        _ => false,
-    }
-}
-
-pub fn eq_fn_ret_ty(l: &FnRetTy, r: &FnRetTy) -> bool {
-    match (l, r) {
-        (FnRetTy::Default(_), FnRetTy::Default(_)) => true,
-        (FnRetTy::Ty(l), FnRetTy::Ty(r)) => eq_ty(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_ty(l: &Ty, r: &Ty) -> bool {
-    use TyKind::*;
-    match (&l.kind, &r.kind) {
-        (Paren(l), _) => eq_ty(l, r),
-        (_, Paren(r)) => eq_ty(l, r),
-        (Never, Never) | (Infer, Infer) | (ImplicitSelf, ImplicitSelf) | (Err, Err) | (CVarArgs, CVarArgs) => true,
-        (Slice(l), Slice(r)) => eq_ty(l, r),
-        (Array(le, ls), Array(re, rs)) => eq_ty(le, re) && eq_expr(&ls.value, &rs.value),
-        (Ptr(l), Ptr(r)) => l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty),
-        (Ref(ll, l), Ref(rl, r)) => {
-            both(ll, rl, |l, r| eq_id(l.ident, r.ident)) && l.mutbl == r.mutbl && eq_ty(&l.ty, &r.ty)
-        },
-        (BareFn(l), BareFn(r)) => {
-            l.unsafety == r.unsafety
-                && eq_ext(&l.ext, &r.ext)
-                && over(&l.generic_params, &r.generic_params, eq_generic_param)
-                && eq_fn_decl(&l.decl, &r.decl)
-        },
-        (Tup(l), Tup(r)) => over(l, r, |l, r| eq_ty(l, r)),
-        (Path(lq, lp), Path(rq, rp)) => both(lq, rq, eq_qself) && eq_path(lp, rp),
-        (TraitObject(lg, ls), TraitObject(rg, rs)) => ls == rs && over(lg, rg, eq_generic_bound),
-        (ImplTrait(_, lg), ImplTrait(_, rg)) => over(lg, rg, eq_generic_bound),
-        (Typeof(l), Typeof(r)) => eq_expr(&l.value, &r.value),
-        (MacCall(l), MacCall(r)) => eq_mac_call(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_ext(l: &Extern, r: &Extern) -> bool {
-    use Extern::*;
-    match (l, r) {
-        (None, None) | (Implicit(_), Implicit(_)) => true,
-        (Explicit(l, _), Explicit(r, _)) => eq_str_lit(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_str_lit(l: &StrLit, r: &StrLit) -> bool {
-    l.style == r.style && l.symbol == r.symbol && l.suffix == r.suffix
-}
-
-pub fn eq_poly_ref_trait(l: &PolyTraitRef, r: &PolyTraitRef) -> bool {
-    eq_path(&l.trait_ref.path, &r.trait_ref.path)
-        && over(&l.bound_generic_params, &r.bound_generic_params, |l, r| {
-            eq_generic_param(l, r)
-        })
-}
-
-pub fn eq_generic_param(l: &GenericParam, r: &GenericParam) -> bool {
-    use GenericParamKind::*;
-    l.is_placeholder == r.is_placeholder
-        && eq_id(l.ident, r.ident)
-        && over(&l.bounds, &r.bounds, eq_generic_bound)
-        && match (&l.kind, &r.kind) {
-            (Lifetime, Lifetime) => true,
-            (Type { default: l }, Type { default: r }) => both(l, r, |l, r| eq_ty(l, r)),
-            (
-                Const {
-                    ty: lt,
-                    kw_span: _,
-                    default: ld,
-                },
-                Const {
-                    ty: rt,
-                    kw_span: _,
-                    default: rd,
-                },
-            ) => eq_ty(lt, rt) && both(ld, rd, eq_anon_const),
-            _ => false,
-        }
-        && over(&l.attrs, &r.attrs, eq_attr)
-}
-
-pub fn eq_generic_bound(l: &GenericBound, r: &GenericBound) -> bool {
-    use GenericBound::*;
-    match (l, r) {
-        (Trait(ptr1, tbm1), Trait(ptr2, tbm2)) => tbm1 == tbm2 && eq_poly_ref_trait(ptr1, ptr2),
-        (Outlives(l), Outlives(r)) => eq_id(l.ident, r.ident),
-        _ => false,
-    }
-}
-
-fn eq_term(l: &Term, r: &Term) -> bool {
-    match (l, r) {
-        (Term::Ty(l), Term::Ty(r)) => eq_ty(l, r),
-        (Term::Const(l), Term::Const(r)) => eq_anon_const(l, r),
-        _ => false,
-    }
-}
-
-pub fn eq_assoc_constraint(l: &AssocConstraint, r: &AssocConstraint) -> bool {
-    use AssocConstraintKind::*;
-    eq_id(l.ident, r.ident)
-        && match (&l.kind, &r.kind) {
-            (Equality { term: l }, Equality { term: r }) => eq_term(l, r),
-            (Bound { bounds: l }, Bound { bounds: r }) => over(l, r, eq_generic_bound),
-            _ => false,
-        }
-}
-
-pub fn eq_mac_call(l: &MacCall, r: &MacCall) -> bool {
-    eq_path(&l.path, &r.path) && eq_delim_args(&l.args, &r.args)
-}
-
-pub fn eq_attr(l: &Attribute, r: &Attribute) -> bool {
-    use AttrKind::*;
-    l.style == r.style
-        && match (&l.kind, &r.kind) {
-            (DocComment(l1, l2), DocComment(r1, r2)) => l1 == r1 && l2 == r2,
-            (Normal(l), Normal(r)) => eq_path(&l.item.path, &r.item.path) && eq_attr_args(&l.item.args, &r.item.args),
-            _ => false,
-        }
-}
-
-pub fn eq_attr_args(l: &AttrArgs, r: &AttrArgs) -> bool {
-    use AttrArgs::*;
-    match (l, r) {
-        (Empty, Empty) => true,
-        (Delimited(la), Delimited(ra)) => eq_delim_args(la, ra),
-        (Eq(_, AttrArgsEq::Ast(le)), Eq(_, AttrArgsEq::Ast(re))) => eq_expr(le, re),
-        (Eq(_, AttrArgsEq::Hir(ll)), Eq(_, AttrArgsEq::Hir(rl))) => ll.kind == rl.kind,
-        _ => false,
-    }
-}
-
-pub fn eq_delim_args(l: &DelimArgs, r: &DelimArgs) -> bool {
-    l.delim == r.delim && l.tokens.eq_unspanned(&r.tokens)
-}
diff --git a/scout-audit-clippy-utils/src/ast_utils/ident_iter.rs b/scout-audit-clippy-utils/src/ast_utils/ident_iter.rs
deleted file mode 100644
index eefcbabd..00000000
--- a/scout-audit-clippy-utils/src/ast_utils/ident_iter.rs
+++ /dev/null
@@ -1,45 +0,0 @@
-use core::iter::FusedIterator;
-use rustc_ast::visit::{walk_attribute, walk_expr, Visitor};
-use rustc_ast::{Attribute, Expr};
-use rustc_span::symbol::Ident;
-
-pub struct IdentIter(std::vec::IntoIter<Ident>);
-
-impl Iterator for IdentIter {
-    type Item = Ident;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.0.next()
-    }
-}
-
-impl FusedIterator for IdentIter {}
-
-impl From<&Expr> for IdentIter {
-    fn from(expr: &Expr) -> Self {
-        let mut visitor = IdentCollector::default();
-
-        walk_expr(&mut visitor, expr);
-
-        IdentIter(visitor.0.into_iter())
-    }
-}
-
-impl From<&Attribute> for IdentIter {
-    fn from(attr: &Attribute) -> Self {
-        let mut visitor = IdentCollector::default();
-
-        walk_attribute(&mut visitor, attr);
-
-        IdentIter(visitor.0.into_iter())
-    }
-}
-
-#[derive(Default)]
-struct IdentCollector(Vec<Ident>);
-
-impl Visitor<'_> for IdentCollector {
-    fn visit_ident(&mut self, ident: Ident) {
-        self.0.push(ident);
-    }
-}
diff --git a/scout-audit-clippy-utils/src/attrs.rs b/scout-audit-clippy-utils/src/attrs.rs
deleted file mode 100644
index 51771f78..00000000
--- a/scout-audit-clippy-utils/src/attrs.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-use rustc_ast::{ast, attr};
-use rustc_errors::Applicability;
-use rustc_session::Session;
-use rustc_span::sym;
-use std::str::FromStr;
-
-/// Deprecation status of attributes known by Clippy.
-pub enum DeprecationStatus {
-    /// Attribute is deprecated
-    Deprecated,
-    /// Attribute is deprecated and was replaced by the named attribute
-    Replaced(&'static str),
-    None,
-}
-
-#[rustfmt::skip]
-pub const BUILTIN_ATTRIBUTES: &[(&str, DeprecationStatus)] = &[
-    ("author",                DeprecationStatus::None),
-    ("version",               DeprecationStatus::None),
-    ("cognitive_complexity",  DeprecationStatus::None),
-    ("cyclomatic_complexity", DeprecationStatus::Replaced("cognitive_complexity")),
-    ("dump",                  DeprecationStatus::None),
-    ("msrv",                  DeprecationStatus::None),
-    ("has_significant_drop",  DeprecationStatus::None),
-];
-
-pub struct LimitStack {
-    stack: Vec<u64>,
-}
-
-impl Drop for LimitStack {
-    fn drop(&mut self) {
-        assert_eq!(self.stack.len(), 1);
-    }
-}
-
-impl LimitStack {
-    #[must_use]
-    pub fn new(limit: u64) -> Self {
-        Self { stack: vec![limit] }
-    }
-    pub fn limit(&self) -> u64 {
-        *self.stack.last().expect("there should always be a value in the stack")
-    }
-    pub fn push_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
-        let stack = &mut self.stack;
-        parse_attrs(sess, attrs, name, |val| stack.push(val));
-    }
-    pub fn pop_attrs(&mut self, sess: &Session, attrs: &[ast::Attribute], name: &'static str) {
-        let stack = &mut self.stack;
-        parse_attrs(sess, attrs, name, |val| assert_eq!(stack.pop(), Some(val)));
-    }
-}
-
-pub fn get_attr<'a>(
-    sess: &'a Session,
-    attrs: &'a [ast::Attribute],
-    name: &'static str,
-) -> impl Iterator<Item = &'a ast::Attribute> {
-    attrs.iter().filter(move |attr| {
-        let attr = if let ast::AttrKind::Normal(ref normal) = attr.kind {
-            &normal.item
-        } else {
-            return false;
-        };
-        let attr_segments = &attr.path.segments;
-        if attr_segments.len() == 2 && attr_segments[0].ident.name == sym::clippy {
-            BUILTIN_ATTRIBUTES
-                .iter()
-                .find_map(|&(builtin_name, ref deprecation_status)| {
-                    if attr_segments[1].ident.name.as_str() == builtin_name {
-                        Some(deprecation_status)
-                    } else {
-                        None
-                    }
-                })
-                .map_or_else(
-                    || {
-                        sess.span_err(attr_segments[1].ident.span, "usage of unknown attribute");
-                        false
-                    },
-                    |deprecation_status| {
-                        let mut diag =
-                            sess.struct_span_err(attr_segments[1].ident.span, "usage of deprecated attribute");
-                        match *deprecation_status {
-                            DeprecationStatus::Deprecated => {
-                                diag.emit();
-                                false
-                            },
-                            DeprecationStatus::Replaced(new_name) => {
-                                diag.span_suggestion(
-                                    attr_segments[1].ident.span,
-                                    "consider using",
-                                    new_name,
-                                    Applicability::MachineApplicable,
-                                );
-                                diag.emit();
-                                false
-                            },
-                            DeprecationStatus::None => {
-                                diag.cancel();
-                                attr_segments[1].ident.name.as_str() == name
-                            },
-                        }
-                    },
-                )
-        } else {
-            false
-        }
-    })
-}
-
-fn parse_attrs<F: FnMut(u64)>(sess: &Session, attrs: &[ast::Attribute], name: &'static str, mut f: F) {
-    for attr in get_attr(sess, attrs, name) {
-        if let Some(ref value) = attr.value_str() {
-            if let Ok(value) = FromStr::from_str(value.as_str()) {
-                f(value);
-            } else {
-                sess.span_err(attr.span, "not a number");
-            }
-        } else {
-            sess.span_err(attr.span, "bad clippy attribute");
-        }
-    }
-}
-
-pub fn get_unique_attr<'a>(
-    sess: &'a Session,
-    attrs: &'a [ast::Attribute],
-    name: &'static str,
-) -> Option<&'a ast::Attribute> {
-    let mut unique_attr: Option<&ast::Attribute> = None;
-    for attr in get_attr(sess, attrs, name) {
-        if let Some(duplicate) = unique_attr {
-            sess.struct_span_err(attr.span, format!("`{name}` is defined multiple times"))
-                .span_note(duplicate.span, "first definition found here")
-                .emit();
-        } else {
-            unique_attr = Some(attr);
-        }
-    }
-    unique_attr
-}
-
-/// Returns true if the attributes contain any of `proc_macro`,
-/// `proc_macro_derive` or `proc_macro_attribute`, false otherwise
-pub fn is_proc_macro(attrs: &[ast::Attribute]) -> bool {
-    attrs.iter().any(rustc_ast::Attribute::is_proc_macro_attr)
-}
-
-/// Returns true if the attributes contain `#[doc(hidden)]`
-pub fn is_doc_hidden(attrs: &[ast::Attribute]) -> bool {
-    attrs
-        .iter()
-        .filter(|attr| attr.has_name(sym::doc))
-        .filter_map(ast::Attribute::meta_item_list)
-        .any(|l| attr::list_contains_name(&l, sym::hidden))
-}
diff --git a/scout-audit-clippy-utils/src/check_proc_macro.rs b/scout-audit-clippy-utils/src/check_proc_macro.rs
deleted file mode 100644
index 6be8b8bb..00000000
--- a/scout-audit-clippy-utils/src/check_proc_macro.rs
+++ /dev/null
@@ -1,434 +0,0 @@
-//! This module handles checking if the span given is from a proc-macro or not.
-//!
-//! Proc-macros are capable of setting the span of every token they output to a few possible spans.
-//! This includes spans we can detect easily as coming from a proc-macro (e.g. the call site
-//! or the def site), and spans we can't easily detect as such (e.g. the span of any token
-//! passed into the proc macro). This capability means proc-macros are capable of generating code
-//! with a span that looks like it was written by the user, but which should not be linted by clippy
-//! as it was generated by an external macro.
-//!
-//! That brings us to this module. The current approach is to determine a small bit of text which
-//! must exist at both the start and the end of an item (e.g. an expression or a path) assuming the
-//! code was written, and check if the span contains that text. Note this will only work correctly
-//! if the span is not from a `macro_rules` based macro.
-
-use rustc_ast::ast::{AttrKind, Attribute, IntTy, LitIntType, LitKind, StrStyle, UintTy};
-use rustc_ast::token::CommentKind;
-use rustc_ast::AttrStyle;
-use rustc_hir::intravisit::FnKind;
-use rustc_hir::{
-    Block, BlockCheckMode, Body, Closure, Destination, Expr, ExprKind, FieldDef, FnHeader, HirId, Impl, ImplItem,
-    ImplItemKind, IsAuto, Item, ItemKind, LoopSource, MatchSource, MutTy, Node, QPath, TraitItem, TraitItemKind, Ty,
-    TyKind, UnOp, UnsafeSource, Unsafety, Variant, VariantData, YieldSource,
-};
-use rustc_lint::{LateContext, LintContext};
-use rustc_middle::ty::TyCtxt;
-use rustc_session::Session;
-use rustc_span::symbol::Ident;
-use rustc_span::{Span, Symbol};
-use rustc_target::spec::abi::Abi;
-
-/// The search pattern to look for. Used by `span_matches_pat`
-#[derive(Clone)]
-pub enum Pat {
-    /// A single string.
-    Str(&'static str),
-    /// A single string.
-    OwnedStr(String),
-    /// Any of the given strings.
-    MultiStr(&'static [&'static str]),
-    /// Any of the given strings.
-    OwnedMultiStr(Vec<String>),
-    /// The string representation of the symbol.
-    Sym(Symbol),
-    /// Any decimal or hexadecimal digit depending on the location.
-    Num,
-}
-
-/// Checks if the start and the end of the span's text matches the patterns. This will return false
-/// if the span crosses multiple files or if source is not available.
-fn span_matches_pat(sess: &Session, span: Span, start_pat: Pat, end_pat: Pat) -> bool {
-    let pos = sess.source_map().lookup_byte_offset(span.lo());
-    let Some(ref src) = pos.sf.src else {
-        return false;
-    };
-    let end = span.hi() - pos.sf.start_pos;
-    src.get(pos.pos.0 as usize..end.0 as usize).map_or(false, |s| {
-        // Spans can be wrapped in a mixture or parenthesis, whitespace, and trailing commas.
-        let start_str = s.trim_start_matches(|c: char| c.is_whitespace() || c == '(');
-        let end_str = s.trim_end_matches(|c: char| c.is_whitespace() || c == ')' || c == ',');
-        (match start_pat {
-            Pat::Str(text) => start_str.starts_with(text),
-            Pat::OwnedStr(text) => start_str.starts_with(&text),
-            Pat::MultiStr(texts) => texts.iter().any(|s| start_str.starts_with(s)),
-            Pat::OwnedMultiStr(texts) => texts.iter().any(|s| start_str.starts_with(s)),
-            Pat::Sym(sym) => start_str.starts_with(sym.as_str()),
-            Pat::Num => start_str.as_bytes().first().map_or(false, u8::is_ascii_digit),
-        } && match end_pat {
-            Pat::Str(text) => end_str.ends_with(text),
-            Pat::OwnedStr(text) => end_str.starts_with(&text),
-            Pat::MultiStr(texts) => texts.iter().any(|s| start_str.ends_with(s)),
-            Pat::OwnedMultiStr(texts) => texts.iter().any(|s| start_str.starts_with(s)),
-            Pat::Sym(sym) => end_str.ends_with(sym.as_str()),
-            Pat::Num => end_str.as_bytes().last().map_or(false, u8::is_ascii_hexdigit),
-        })
-    })
-}
-
-/// Get the search patterns to use for the given literal
-fn lit_search_pat(lit: &LitKind) -> (Pat, Pat) {
-    match lit {
-        LitKind::Str(_, StrStyle::Cooked) => (Pat::Str("\""), Pat::Str("\"")),
-        LitKind::Str(_, StrStyle::Raw(0)) => (Pat::Str("r"), Pat::Str("\"")),
-        LitKind::Str(_, StrStyle::Raw(_)) => (Pat::Str("r#"), Pat::Str("#")),
-        LitKind::ByteStr(_, StrStyle::Cooked) => (Pat::Str("b\""), Pat::Str("\"")),
-        LitKind::ByteStr(_, StrStyle::Raw(0)) => (Pat::Str("br\""), Pat::Str("\"")),
-        LitKind::ByteStr(_, StrStyle::Raw(_)) => (Pat::Str("br#\""), Pat::Str("#")),
-        LitKind::Byte(_) => (Pat::Str("b'"), Pat::Str("'")),
-        LitKind::Char(_) => (Pat::Str("'"), Pat::Str("'")),
-        LitKind::Int(_, LitIntType::Signed(IntTy::Isize)) => (Pat::Num, Pat::Str("isize")),
-        LitKind::Int(_, LitIntType::Unsigned(UintTy::Usize)) => (Pat::Num, Pat::Str("usize")),
-        LitKind::Int(..) => (Pat::Num, Pat::Num),
-        LitKind::Float(..) => (Pat::Num, Pat::Str("")),
-        LitKind::Bool(true) => (Pat::Str("true"), Pat::Str("true")),
-        LitKind::Bool(false) => (Pat::Str("false"), Pat::Str("false")),
-        _ => (Pat::Str(""), Pat::Str("")),
-    }
-}
-
-/// Get the search patterns to use for the given path
-fn qpath_search_pat(path: &QPath<'_>) -> (Pat, Pat) {
-    match path {
-        QPath::Resolved(ty, path) => {
-            let start = if ty.is_some() {
-                Pat::Str("<")
-            } else {
-                path.segments
-                    .first()
-                    .map_or(Pat::Str(""), |seg| Pat::Sym(seg.ident.name))
-            };
-            let end = path.segments.last().map_or(Pat::Str(""), |seg| {
-                if seg.args.is_some() {
-                    Pat::Str(">")
-                } else {
-                    Pat::Sym(seg.ident.name)
-                }
-            });
-            (start, end)
-        },
-        QPath::TypeRelative(_, name) => (Pat::Str(""), Pat::Sym(name.ident.name)),
-        QPath::LangItem(..) => (Pat::Str(""), Pat::Str("")),
-    }
-}
-
-/// Get the search patterns to use for the given expression
-fn expr_search_pat(tcx: TyCtxt<'_>, e: &Expr<'_>) -> (Pat, Pat) {
-    match e.kind {
-        ExprKind::ConstBlock(_) => (Pat::Str("const"), Pat::Str("}")),
-        ExprKind::Tup([]) => (Pat::Str(")"), Pat::Str("(")),
-        ExprKind::Unary(UnOp::Deref, e) => (Pat::Str("*"), expr_search_pat(tcx, e).1),
-        ExprKind::Unary(UnOp::Not, e) => (Pat::Str("!"), expr_search_pat(tcx, e).1),
-        ExprKind::Unary(UnOp::Neg, e) => (Pat::Str("-"), expr_search_pat(tcx, e).1),
-        ExprKind::Lit(lit) => lit_search_pat(&lit.node),
-        ExprKind::Array(_) | ExprKind::Repeat(..) => (Pat::Str("["), Pat::Str("]")),
-        ExprKind::Call(e, []) | ExprKind::MethodCall(_, e, [], _) => (expr_search_pat(tcx, e).0, Pat::Str("(")),
-        ExprKind::Call(first, [.., last])
-        | ExprKind::MethodCall(_, first, [.., last], _)
-        | ExprKind::Binary(_, first, last)
-        | ExprKind::Tup([first, .., last])
-        | ExprKind::Assign(first, last, _)
-        | ExprKind::AssignOp(_, first, last) => (expr_search_pat(tcx, first).0, expr_search_pat(tcx, last).1),
-        ExprKind::Tup([e]) | ExprKind::DropTemps(e) => expr_search_pat(tcx, e),
-        ExprKind::Cast(e, _) | ExprKind::Type(e, _) => (expr_search_pat(tcx, e).0, Pat::Str("")),
-        ExprKind::Let(let_expr) => (Pat::Str("let"), expr_search_pat(tcx, let_expr.init).1),
-        ExprKind::If(..) => (Pat::Str("if"), Pat::Str("}")),
-        ExprKind::Loop(_, Some(_), _, _) | ExprKind::Block(_, Some(_)) => (Pat::Str("'"), Pat::Str("}")),
-        ExprKind::Loop(_, None, LoopSource::Loop, _) => (Pat::Str("loop"), Pat::Str("}")),
-        ExprKind::Loop(_, None, LoopSource::While, _) => (Pat::Str("while"), Pat::Str("}")),
-        ExprKind::Loop(_, None, LoopSource::ForLoop, _) | ExprKind::Match(_, _, MatchSource::ForLoopDesugar) => {
-            (Pat::Str("for"), Pat::Str("}"))
-        },
-        ExprKind::Match(_, _, MatchSource::Normal) => (Pat::Str("match"), Pat::Str("}")),
-        ExprKind::Match(e, _, MatchSource::TryDesugar(_)) => (expr_search_pat(tcx, e).0, Pat::Str("?")),
-        ExprKind::Match(e, _, MatchSource::AwaitDesugar) | ExprKind::Yield(e, YieldSource::Await { .. }) => {
-            (expr_search_pat(tcx, e).0, Pat::Str("await"))
-        },
-        ExprKind::Closure(&Closure { body, .. }) => (Pat::Str(""), expr_search_pat(tcx, tcx.hir().body(body).value).1),
-        ExprKind::Block(
-            Block {
-                rules: BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided),
-                ..
-            },
-            None,
-        ) => (Pat::Str("unsafe"), Pat::Str("}")),
-        ExprKind::Block(_, None) => (Pat::Str("{"), Pat::Str("}")),
-        ExprKind::Field(e, name) => (expr_search_pat(tcx, e).0, Pat::Sym(name.name)),
-        ExprKind::Index(e, _, _) => (expr_search_pat(tcx, e).0, Pat::Str("]")),
-        ExprKind::Path(ref path) => qpath_search_pat(path),
-        ExprKind::AddrOf(_, _, e) => (Pat::Str("&"), expr_search_pat(tcx, e).1),
-        ExprKind::Break(Destination { label: None, .. }, None) => (Pat::Str("break"), Pat::Str("break")),
-        ExprKind::Break(Destination { label: Some(name), .. }, None) => (Pat::Str("break"), Pat::Sym(name.ident.name)),
-        ExprKind::Break(_, Some(e)) => (Pat::Str("break"), expr_search_pat(tcx, e).1),
-        ExprKind::Continue(Destination { label: None, .. }) => (Pat::Str("continue"), Pat::Str("continue")),
-        ExprKind::Continue(Destination { label: Some(name), .. }) => (Pat::Str("continue"), Pat::Sym(name.ident.name)),
-        ExprKind::Ret(None) => (Pat::Str("return"), Pat::Str("return")),
-        ExprKind::Ret(Some(e)) => (Pat::Str("return"), expr_search_pat(tcx, e).1),
-        ExprKind::Struct(path, _, _) => (qpath_search_pat(path).0, Pat::Str("}")),
-        ExprKind::Yield(e, YieldSource::Yield) => (Pat::Str("yield"), expr_search_pat(tcx, e).1),
-        _ => (Pat::Str(""), Pat::Str("")),
-    }
-}
-
-fn fn_header_search_pat(header: FnHeader) -> Pat {
-    if header.is_async() {
-        Pat::Str("async")
-    } else if header.is_const() {
-        Pat::Str("const")
-    } else if header.is_unsafe() {
-        Pat::Str("unsafe")
-    } else if header.abi != Abi::Rust {
-        Pat::Str("extern")
-    } else {
-        Pat::MultiStr(&["fn", "extern"])
-    }
-}
-
-fn item_search_pat(item: &Item<'_>) -> (Pat, Pat) {
-    let (start_pat, end_pat) = match &item.kind {
-        ItemKind::ExternCrate(_) => (Pat::Str("extern"), Pat::Str(";")),
-        ItemKind::Static(..) => (Pat::Str("static"), Pat::Str(";")),
-        ItemKind::Const(..) => (Pat::Str("const"), Pat::Str(";")),
-        ItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
-        ItemKind::ForeignMod { .. } => (Pat::Str("extern"), Pat::Str("}")),
-        ItemKind::TyAlias(..) | ItemKind::OpaqueTy(_) => (Pat::Str("type"), Pat::Str(";")),
-        ItemKind::Enum(..) => (Pat::Str("enum"), Pat::Str("}")),
-        ItemKind::Struct(VariantData::Struct(..), _) => (Pat::Str("struct"), Pat::Str("}")),
-        ItemKind::Struct(..) => (Pat::Str("struct"), Pat::Str(";")),
-        ItemKind::Union(..) => (Pat::Str("union"), Pat::Str("}")),
-        ItemKind::Trait(_, Unsafety::Unsafe, ..)
-        | ItemKind::Impl(Impl {
-            unsafety: Unsafety::Unsafe,
-            ..
-        }) => (Pat::Str("unsafe"), Pat::Str("}")),
-        ItemKind::Trait(IsAuto::Yes, ..) => (Pat::Str("auto"), Pat::Str("}")),
-        ItemKind::Trait(..) => (Pat::Str("trait"), Pat::Str("}")),
-        ItemKind::Impl(_) => (Pat::Str("impl"), Pat::Str("}")),
-        _ => return (Pat::Str(""), Pat::Str("")),
-    };
-    if item.vis_span.is_empty() {
-        (start_pat, end_pat)
-    } else {
-        (Pat::Str("pub"), end_pat)
-    }
-}
-
-fn trait_item_search_pat(item: &TraitItem<'_>) -> (Pat, Pat) {
-    match &item.kind {
-        TraitItemKind::Const(..) => (Pat::Str("const"), Pat::Str(";")),
-        TraitItemKind::Type(..) => (Pat::Str("type"), Pat::Str(";")),
-        TraitItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
-    }
-}
-
-fn impl_item_search_pat(item: &ImplItem<'_>) -> (Pat, Pat) {
-    let (start_pat, end_pat) = match &item.kind {
-        ImplItemKind::Const(..) => (Pat::Str("const"), Pat::Str(";")),
-        ImplItemKind::Type(..) => (Pat::Str("type"), Pat::Str(";")),
-        ImplItemKind::Fn(sig, ..) => (fn_header_search_pat(sig.header), Pat::Str("")),
-    };
-    if item.vis_span.is_empty() {
-        (start_pat, end_pat)
-    } else {
-        (Pat::Str("pub"), end_pat)
-    }
-}
-
-fn field_def_search_pat(def: &FieldDef<'_>) -> (Pat, Pat) {
-    if def.vis_span.is_empty() {
-        if def.is_positional() {
-            (Pat::Str(""), Pat::Str(""))
-        } else {
-            (Pat::Sym(def.ident.name), Pat::Str(""))
-        }
-    } else {
-        (Pat::Str("pub"), Pat::Str(""))
-    }
-}
-
-fn variant_search_pat(v: &Variant<'_>) -> (Pat, Pat) {
-    match v.data {
-        VariantData::Struct(..) => (Pat::Sym(v.ident.name), Pat::Str("}")),
-        VariantData::Tuple(..) => (Pat::Sym(v.ident.name), Pat::Str("")),
-        VariantData::Unit(..) => (Pat::Sym(v.ident.name), Pat::Sym(v.ident.name)),
-    }
-}
-
-fn fn_kind_pat(tcx: TyCtxt<'_>, kind: &FnKind<'_>, body: &Body<'_>, hir_id: HirId) -> (Pat, Pat) {
-    let (start_pat, end_pat) = match kind {
-        FnKind::ItemFn(.., header) => (fn_header_search_pat(*header), Pat::Str("")),
-        FnKind::Method(.., sig) => (fn_header_search_pat(sig.header), Pat::Str("")),
-        FnKind::Closure => return (Pat::Str(""), expr_search_pat(tcx, body.value).1),
-    };
-    let start_pat = match tcx.hir().get(hir_id) {
-        Node::Item(Item { vis_span, .. }) | Node::ImplItem(ImplItem { vis_span, .. }) => {
-            if vis_span.is_empty() {
-                start_pat
-            } else {
-                Pat::Str("pub")
-            }
-        },
-        Node::TraitItem(_) => start_pat,
-        _ => Pat::Str(""),
-    };
-    (start_pat, end_pat)
-}
-
-fn attr_search_pat(attr: &Attribute) -> (Pat, Pat) {
-    match attr.kind {
-        AttrKind::Normal(..) => {
-            let mut pat = if matches!(attr.style, AttrStyle::Outer) {
-                (Pat::Str("#["), Pat::Str("]"))
-            } else {
-                (Pat::Str("#!["), Pat::Str("]"))
-            };
-
-            if let Some(ident) = attr.ident() && let Pat::Str(old_pat) = pat.0 {
-                // TODO: I feel like it's likely we can use `Cow` instead but this will require quite a bit of
-                // refactoring
-                // NOTE: This will likely have false positives, like `allow = 1`
-                pat.0 = Pat::OwnedMultiStr(vec![ident.to_string(), old_pat.to_owned()]);
-                pat.1 = Pat::Str("");
-            }
-
-            pat
-        },
-        AttrKind::DocComment(_kind @ CommentKind::Line, ..) => {
-            if matches!(attr.style, AttrStyle::Outer) {
-                (Pat::Str("///"), Pat::Str(""))
-            } else {
-                (Pat::Str("//!"), Pat::Str(""))
-            }
-        },
-        AttrKind::DocComment(_kind @ CommentKind::Block, ..) => {
-            if matches!(attr.style, AttrStyle::Outer) {
-                (Pat::Str("/**"), Pat::Str("*/"))
-            } else {
-                (Pat::Str("/*!"), Pat::Str("*/"))
-            }
-        },
-    }
-}
-
-fn ty_search_pat(ty: &Ty<'_>) -> (Pat, Pat) {
-    match ty.kind {
-        TyKind::Slice(..) | TyKind::Array(..) => (Pat::Str("["), Pat::Str("]")),
-        TyKind::Ptr(MutTy { mutbl, ty }) => (
-            if mutbl.is_mut() {
-                Pat::Str("*const")
-            } else {
-                Pat::Str("*mut")
-            },
-            ty_search_pat(ty).1,
-        ),
-        TyKind::Ref(_, MutTy { ty, .. }) => (Pat::Str("&"), ty_search_pat(ty).1),
-        TyKind::BareFn(bare_fn) => (
-            Pat::OwnedStr(format!("{}{} fn", bare_fn.unsafety.prefix_str(), bare_fn.abi.name())),
-            ty_search_pat(ty).1,
-        ),
-        TyKind::Never => (Pat::Str("!"), Pat::Str("")),
-        TyKind::Tup(..) => (Pat::Str("("), Pat::Str(")")),
-        TyKind::OpaqueDef(..) => (Pat::Str("impl"), Pat::Str("")),
-        TyKind::Path(qpath) => qpath_search_pat(&qpath),
-        // NOTE: This is missing `TraitObject`. It will always return true then.
-        _ => (Pat::Str(""), Pat::Str("")),
-    }
-}
-
-fn ident_search_pat(ident: Ident) -> (Pat, Pat) {
-    (Pat::OwnedStr(ident.name.as_str().to_owned()), Pat::Str(""))
-}
-
-pub trait WithSearchPat<'cx> {
-    type Context: LintContext;
-    fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat);
-    fn span(&self) -> Span;
-}
-macro_rules! impl_with_search_pat {
-    ($cx:ident: $ty:ident with $fn:ident $(($tcx:ident))?) => {
-        impl<'cx> WithSearchPat<'cx> for $ty<'cx> {
-            type Context = $cx<'cx>;
-            #[allow(unused_variables)]
-            fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat) {
-                $(let $tcx = cx.tcx;)?
-                $fn($($tcx,)? self)
-            }
-            fn span(&self) -> Span {
-                self.span
-            }
-        }
-    };
-}
-impl_with_search_pat!(LateContext: Expr with expr_search_pat(tcx));
-impl_with_search_pat!(LateContext: Item with item_search_pat);
-impl_with_search_pat!(LateContext: TraitItem with trait_item_search_pat);
-impl_with_search_pat!(LateContext: ImplItem with impl_item_search_pat);
-impl_with_search_pat!(LateContext: FieldDef with field_def_search_pat);
-impl_with_search_pat!(LateContext: Variant with variant_search_pat);
-impl_with_search_pat!(LateContext: Ty with ty_search_pat);
-
-impl<'cx> WithSearchPat<'cx> for (&FnKind<'cx>, &Body<'cx>, HirId, Span) {
-    type Context = LateContext<'cx>;
-
-    fn search_pat(&self, cx: &Self::Context) -> (Pat, Pat) {
-        fn_kind_pat(cx.tcx, self.0, self.1, self.2)
-    }
-
-    fn span(&self) -> Span {
-        self.3
-    }
-}
-
-// `Attribute` does not have the `hir` associated lifetime, so we cannot use the macro
-impl<'cx> WithSearchPat<'cx> for &'cx Attribute {
-    type Context = LateContext<'cx>;
-
-    fn search_pat(&self, _cx: &Self::Context) -> (Pat, Pat) {
-        attr_search_pat(self)
-    }
-
-    fn span(&self) -> Span {
-        self.span
-    }
-}
-
-// `Ident` does not have the `hir` associated lifetime, so we cannot use the macro
-impl<'cx> WithSearchPat<'cx> for Ident {
-    type Context = LateContext<'cx>;
-
-    fn search_pat(&self, _cx: &Self::Context) -> (Pat, Pat) {
-        ident_search_pat(*self)
-    }
-
-    fn span(&self) -> Span {
-        self.span
-    }
-}
-
-/// Checks if the item likely came from a proc-macro.
-///
-/// This should be called after `in_external_macro` and the initial pattern matching of the ast as
-/// it is significantly slower than both of those.
-pub fn is_from_proc_macro<'cx, T: WithSearchPat<'cx>>(cx: &T::Context, item: &T) -> bool {
-    let (start_pat, end_pat) = item.search_pat(cx);
-    !span_matches_pat(cx.sess(), item.span(), start_pat, end_pat)
-}
-
-/// Checks if the span actually refers to a match expression
-pub fn is_span_match(cx: &impl LintContext, span: Span) -> bool {
-    span_matches_pat(cx.sess(), span, Pat::Str("match"), Pat::Str("}"))
-}
-
-/// Checks if the span actually refers to an if expression
-pub fn is_span_if(cx: &impl LintContext, span: Span) -> bool {
-    span_matches_pat(cx.sess(), span, Pat::Str("if"), Pat::Str("}"))
-}
diff --git a/scout-audit-clippy-utils/src/comparisons.rs b/scout-audit-clippy-utils/src/comparisons.rs
deleted file mode 100644
index 5e6bf227..00000000
--- a/scout-audit-clippy-utils/src/comparisons.rs
+++ /dev/null
@@ -1,36 +0,0 @@
-//! Utility functions for comparison operators.
-
-#![deny(clippy::missing_docs_in_private_items)]
-
-use rustc_hir::{BinOpKind, Expr};
-
-#[derive(PartialEq, Eq, Debug, Copy, Clone)]
-/// Represents a normalized comparison operator.
-pub enum Rel {
-    /// `<`
-    Lt,
-    /// `<=`
-    Le,
-    /// `==`
-    Eq,
-    /// `!=`
-    Ne,
-}
-
-/// Put the expression in the form  `lhs < rhs`, `lhs <= rhs`, `lhs == rhs` or
-/// `lhs != rhs`.
-pub fn normalize_comparison<'a>(
-    op: BinOpKind,
-    lhs: &'a Expr<'a>,
-    rhs: &'a Expr<'a>,
-) -> Option<(Rel, &'a Expr<'a>, &'a Expr<'a>)> {
-    match op {
-        BinOpKind::Lt => Some((Rel::Lt, lhs, rhs)),
-        BinOpKind::Le => Some((Rel::Le, lhs, rhs)),
-        BinOpKind::Gt => Some((Rel::Lt, rhs, lhs)),
-        BinOpKind::Ge => Some((Rel::Le, rhs, lhs)),
-        BinOpKind::Eq => Some((Rel::Eq, rhs, lhs)),
-        BinOpKind::Ne => Some((Rel::Ne, rhs, lhs)),
-        _ => None,
-    }
-}
diff --git a/scout-audit-clippy-utils/src/consts.rs b/scout-audit-clippy-utils/src/consts.rs
deleted file mode 100644
index d596eed4..00000000
--- a/scout-audit-clippy-utils/src/consts.rs
+++ /dev/null
@@ -1,733 +0,0 @@
-#![allow(clippy::float_cmp)]
-
-use crate::source::{get_source_text, walk_span_to_context};
-use crate::{clip, is_direct_expn_of, sext, unsext};
-use if_chain::if_chain;
-use rustc_ast::ast::{self, LitFloatType, LitKind};
-use rustc_data_structures::sync::Lrc;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::{BinOp, BinOpKind, Block, ConstBlock, Expr, ExprKind, HirId, Item, ItemKind, Node, QPath, UnOp};
-use rustc_lexer::tokenize;
-use rustc_lint::LateContext;
-use rustc_middle::mir::interpret::Scalar;
-use rustc_middle::ty::{self, EarlyBinder, FloatTy, GenericArgsRef, List, ScalarInt, Ty, TyCtxt};
-use rustc_middle::{bug, mir, span_bug};
-use rustc_span::symbol::{Ident, Symbol};
-use rustc_span::SyntaxContext;
-use std::cmp::Ordering::{self, Equal};
-use std::hash::{Hash, Hasher};
-use std::iter;
-
-/// A `LitKind`-like enum to fold constant `Expr`s into.
-#[derive(Debug, Clone)]
-pub enum Constant<'tcx> {
-    Adt(rustc_middle::mir::Const<'tcx>),
-    /// A `String` (e.g., "abc").
-    Str(String),
-    /// A binary string (e.g., `b"abc"`).
-    Binary(Lrc<[u8]>),
-    /// A single `char` (e.g., `'a'`).
-    Char(char),
-    /// An integer's bit representation.
-    Int(u128),
-    /// An `f32`.
-    F32(f32),
-    /// An `f64`.
-    F64(f64),
-    /// `true` or `false`.
-    Bool(bool),
-    /// An array of constants.
-    Vec(Vec<Constant<'tcx>>),
-    /// Also an array, but with only one constant, repeated N times.
-    Repeat(Box<Constant<'tcx>>, u64),
-    /// A tuple of constants.
-    Tuple(Vec<Constant<'tcx>>),
-    /// A raw pointer.
-    RawPtr(u128),
-    /// A reference
-    Ref(Box<Constant<'tcx>>),
-    /// A literal with syntax error.
-    Err,
-}
-
-impl<'tcx> PartialEq for Constant<'tcx> {
-    fn eq(&self, other: &Self) -> bool {
-        match (self, other) {
-            (Self::Str(ls), Self::Str(rs)) => ls == rs,
-            (Self::Binary(l), Self::Binary(r)) => l == r,
-            (&Self::Char(l), &Self::Char(r)) => l == r,
-            (&Self::Int(l), &Self::Int(r)) => l == r,
-            (&Self::F64(l), &Self::F64(r)) => {
-                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
-                // `Fw32 == Fw64`, so don’t compare them.
-                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
-                l.to_bits() == r.to_bits()
-            },
-            (&Self::F32(l), &Self::F32(r)) => {
-                // We want `Fw32 == FwAny` and `FwAny == Fw64`, and by transitivity we must have
-                // `Fw32 == Fw64`, so don’t compare them.
-                // `to_bits` is required to catch non-matching 0.0, -0.0, and NaNs.
-                f64::from(l).to_bits() == f64::from(r).to_bits()
-            },
-            (&Self::Bool(l), &Self::Bool(r)) => l == r,
-            (&Self::Vec(ref l), &Self::Vec(ref r)) | (&Self::Tuple(ref l), &Self::Tuple(ref r)) => l == r,
-            (Self::Repeat(lv, ls), Self::Repeat(rv, rs)) => ls == rs && lv == rv,
-            (Self::Ref(lb), Self::Ref(rb)) => *lb == *rb,
-            // TODO: are there inter-type equalities?
-            _ => false,
-        }
-    }
-}
-
-impl<'tcx> Hash for Constant<'tcx> {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        std::mem::discriminant(self).hash(state);
-        match *self {
-            Self::Adt(ref elem) => {
-                elem.hash(state);
-            },
-            Self::Str(ref s) => {
-                s.hash(state);
-            },
-            Self::Binary(ref b) => {
-                b.hash(state);
-            },
-            Self::Char(c) => {
-                c.hash(state);
-            },
-            Self::Int(i) => {
-                i.hash(state);
-            },
-            Self::F32(f) => {
-                f64::from(f).to_bits().hash(state);
-            },
-            Self::F64(f) => {
-                f.to_bits().hash(state);
-            },
-            Self::Bool(b) => {
-                b.hash(state);
-            },
-            Self::Vec(ref v) | Self::Tuple(ref v) => {
-                v.hash(state);
-            },
-            Self::Repeat(ref c, l) => {
-                c.hash(state);
-                l.hash(state);
-            },
-            Self::RawPtr(u) => {
-                u.hash(state);
-            },
-            Self::Ref(ref r) => {
-                r.hash(state);
-            },
-            Self::Err => {},
-        }
-    }
-}
-
-impl<'tcx> Constant<'tcx> {
-    pub fn partial_cmp(tcx: TyCtxt<'_>, cmp_type: Ty<'_>, left: &Self, right: &Self) -> Option<Ordering> {
-        match (left, right) {
-            (Self::Str(ls), Self::Str(rs)) => Some(ls.cmp(rs)),
-            (Self::Char(l), Self::Char(r)) => Some(l.cmp(r)),
-            (&Self::Int(l), &Self::Int(r)) => match *cmp_type.kind() {
-                ty::Int(int_ty) => Some(sext(tcx, l, int_ty).cmp(&sext(tcx, r, int_ty))),
-                ty::Uint(_) => Some(l.cmp(&r)),
-                _ => bug!("Not an int type"),
-            },
-            (&Self::F64(l), &Self::F64(r)) => l.partial_cmp(&r),
-            (&Self::F32(l), &Self::F32(r)) => l.partial_cmp(&r),
-            (Self::Bool(l), Self::Bool(r)) => Some(l.cmp(r)),
-            (Self::Tuple(l), Self::Tuple(r)) if l.len() == r.len() => match *cmp_type.kind() {
-                ty::Tuple(tys) if tys.len() == l.len() => l
-                    .iter()
-                    .zip(r)
-                    .zip(tys)
-                    .map(|((li, ri), cmp_type)| Self::partial_cmp(tcx, cmp_type, li, ri))
-                    .find(|r| r.map_or(true, |o| o != Ordering::Equal))
-                    .unwrap_or_else(|| Some(l.len().cmp(&r.len()))),
-                _ => None,
-            },
-            (Self::Vec(l), Self::Vec(r)) => {
-                let (ty::Array(cmp_type, _) | ty::Slice(cmp_type)) = *cmp_type.kind() else {
-                    return None;
-                };
-                iter::zip(l, r)
-                    .map(|(li, ri)| Self::partial_cmp(tcx, cmp_type, li, ri))
-                    .find(|r| r.map_or(true, |o| o != Ordering::Equal))
-                    .unwrap_or_else(|| Some(l.len().cmp(&r.len())))
-            },
-            (Self::Repeat(lv, ls), Self::Repeat(rv, rs)) => {
-                match Self::partial_cmp(
-                    tcx,
-                    match *cmp_type.kind() {
-                        ty::Array(ty, _) => ty,
-                        _ => return None,
-                    },
-                    lv,
-                    rv,
-                ) {
-                    Some(Equal) => Some(ls.cmp(rs)),
-                    x => x,
-                }
-            },
-            (Self::Ref(lb), Self::Ref(rb)) => Self::partial_cmp(
-                tcx,
-                match *cmp_type.kind() {
-                    ty::Ref(_, ty, _) => ty,
-                    _ => return None,
-                },
-                lb,
-                rb,
-            ),
-            // TODO: are there any useful inter-type orderings?
-            _ => None,
-        }
-    }
-
-    /// Returns the integer value or `None` if `self` or `val_type` is not integer type.
-    pub fn int_value(&self, cx: &LateContext<'_>, val_type: Ty<'_>) -> Option<FullInt> {
-        if let Constant::Int(const_int) = *self {
-            match *val_type.kind() {
-                ty::Int(ity) => Some(FullInt::S(sext(cx.tcx, const_int, ity))),
-                ty::Uint(_) => Some(FullInt::U(const_int)),
-                _ => None,
-            }
-        } else {
-            None
-        }
-    }
-
-    #[must_use]
-    pub fn peel_refs(mut self) -> Self {
-        while let Constant::Ref(r) = self {
-            self = *r;
-        }
-        self
-    }
-}
-
-/// Parses a `LitKind` to a `Constant`.
-pub fn lit_to_mir_constant<'tcx>(lit: &LitKind, ty: Option<Ty<'tcx>>) -> Constant<'tcx> {
-    match *lit {
-        LitKind::Str(ref is, _) => Constant::Str(is.to_string()),
-        LitKind::Byte(b) => Constant::Int(u128::from(b)),
-        LitKind::ByteStr(ref s, _) | LitKind::CStr(ref s, _) => Constant::Binary(Lrc::clone(s)),
-        LitKind::Char(c) => Constant::Char(c),
-        LitKind::Int(n, _) => Constant::Int(n),
-        LitKind::Float(ref is, LitFloatType::Suffixed(fty)) => match fty {
-            ast::FloatTy::F32 => Constant::F32(is.as_str().parse().unwrap()),
-            ast::FloatTy::F64 => Constant::F64(is.as_str().parse().unwrap()),
-        },
-        LitKind::Float(ref is, LitFloatType::Unsuffixed) => match ty.expect("type of float is known").kind() {
-            ty::Float(FloatTy::F32) => Constant::F32(is.as_str().parse().unwrap()),
-            ty::Float(FloatTy::F64) => Constant::F64(is.as_str().parse().unwrap()),
-            _ => bug!(),
-        },
-        LitKind::Bool(b) => Constant::Bool(b),
-        LitKind::Err => Constant::Err,
-    }
-}
-
-/// The source of a constant value.
-pub enum ConstantSource {
-    /// The value is determined solely from the expression.
-    Local,
-    /// The value is dependent on a defined constant.
-    Constant,
-}
-impl ConstantSource {
-    pub fn is_local(&self) -> bool {
-        matches!(self, Self::Local)
-    }
-}
-
-/// Attempts to evaluate the expression as a constant.
-pub fn constant<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<Constant<'tcx>> {
-    ConstEvalLateContext::new(lcx, typeck_results).expr(e)
-}
-
-/// Attempts to evaluate the expression as a constant.
-pub fn constant_with_source<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<(Constant<'tcx>, ConstantSource)> {
-    let mut ctxt = ConstEvalLateContext::new(lcx, typeck_results);
-    let res = ctxt.expr(e);
-    res.map(|x| (x, ctxt.source))
-}
-
-/// Attempts to evaluate an expression only if its value is not dependent on other items.
-pub fn constant_simple<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<Constant<'tcx>> {
-    constant_with_source(lcx, typeck_results, e).and_then(|(c, s)| s.is_local().then_some(c))
-}
-
-pub fn constant_full_int<'tcx>(
-    lcx: &LateContext<'tcx>,
-    typeck_results: &ty::TypeckResults<'tcx>,
-    e: &Expr<'_>,
-) -> Option<FullInt> {
-    constant_simple(lcx, typeck_results, e)?.int_value(lcx, typeck_results.expr_ty(e))
-}
-
-#[derive(Copy, Clone, Debug, Eq)]
-pub enum FullInt {
-    S(i128),
-    U(u128),
-}
-
-impl PartialEq for FullInt {
-    #[must_use]
-    fn eq(&self, other: &Self) -> bool {
-        self.cmp(other) == Ordering::Equal
-    }
-}
-
-impl PartialOrd for FullInt {
-    #[must_use]
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for FullInt {
-    #[must_use]
-    fn cmp(&self, other: &Self) -> Ordering {
-        use FullInt::{S, U};
-
-        fn cmp_s_u(s: i128, u: u128) -> Ordering {
-            u128::try_from(s).map_or(Ordering::Less, |x| x.cmp(&u))
-        }
-
-        match (*self, *other) {
-            (S(s), S(o)) => s.cmp(&o),
-            (U(s), U(o)) => s.cmp(&o),
-            (S(s), U(o)) => cmp_s_u(s, o),
-            (U(s), S(o)) => cmp_s_u(o, s).reverse(),
-        }
-    }
-}
-
-pub struct ConstEvalLateContext<'a, 'tcx> {
-    lcx: &'a LateContext<'tcx>,
-    typeck_results: &'a ty::TypeckResults<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    source: ConstantSource,
-    args: GenericArgsRef<'tcx>,
-}
-
-impl<'a, 'tcx> ConstEvalLateContext<'a, 'tcx> {
-    pub fn new(lcx: &'a LateContext<'tcx>, typeck_results: &'a ty::TypeckResults<'tcx>) -> Self {
-        Self {
-            lcx,
-            typeck_results,
-            param_env: lcx.param_env,
-            source: ConstantSource::Local,
-            args: List::empty(),
-        }
-    }
-
-    /// Simple constant folding: Insert an expression, get a constant or none.
-    pub fn expr(&mut self, e: &Expr<'_>) -> Option<Constant<'tcx>> {
-        match e.kind {
-            ExprKind::ConstBlock(ConstBlock { body, .. }) => self.expr(self.lcx.tcx.hir().body(body).value),
-            ExprKind::DropTemps(e) => self.expr(e),
-            ExprKind::Path(ref qpath) => self.fetch_path(qpath, e.hir_id, self.typeck_results.expr_ty(e)),
-            ExprKind::Block(block, _) => self.block(block),
-            ExprKind::Lit(lit) => {
-                if is_direct_expn_of(e.span, "cfg").is_some() {
-                    None
-                } else {
-                    Some(lit_to_mir_constant(&lit.node, self.typeck_results.expr_ty_opt(e)))
-                }
-            },
-            ExprKind::Array(vec) => self.multi(vec).map(Constant::Vec),
-            ExprKind::Tup(tup) => self.multi(tup).map(Constant::Tuple),
-            ExprKind::Repeat(value, _) => {
-                let n = match self.typeck_results.expr_ty(e).kind() {
-                    ty::Array(_, n) => n.try_eval_target_usize(self.lcx.tcx, self.lcx.param_env)?,
-                    _ => span_bug!(e.span, "typeck error"),
-                };
-                self.expr(value).map(|v| Constant::Repeat(Box::new(v), n))
-            },
-            ExprKind::Unary(op, operand) => self.expr(operand).and_then(|o| match op {
-                UnOp::Not => self.constant_not(&o, self.typeck_results.expr_ty(e)),
-                UnOp::Neg => self.constant_negate(&o, self.typeck_results.expr_ty(e)),
-                UnOp::Deref => Some(if let Constant::Ref(r) = o { *r } else { o }),
-            }),
-            ExprKind::If(cond, then, ref otherwise) => self.ifthenelse(cond, then, *otherwise),
-            ExprKind::Binary(op, left, right) => self.binop(op, left, right),
-            ExprKind::Call(callee, args) => {
-                // We only handle a few const functions for now.
-                if_chain! {
-                    if args.is_empty();
-                    if let ExprKind::Path(qpath) = &callee.kind;
-                    let res = self.typeck_results.qpath_res(qpath, callee.hir_id);
-                    if let Some(def_id) = res.opt_def_id();
-                    let def_path = self.lcx.get_def_path(def_id);
-                    let def_path: Vec<&str> = def_path.iter().take(4).map(Symbol::as_str).collect();
-                    if let ["core", "num", int_impl, "max_value"] = *def_path;
-                    then {
-                        let value = match int_impl {
-                            "<impl i8>" => i8::MAX as u128,
-                            "<impl i16>" => i16::MAX as u128,
-                            "<impl i32>" => i32::MAX as u128,
-                            "<impl i64>" => i64::MAX as u128,
-                            "<impl i128>" => i128::MAX as u128,
-                            _ => return None,
-                        };
-                        Some(Constant::Int(value))
-                    } else {
-                        None
-                    }
-                }
-            },
-            ExprKind::Index(arr, index, _) => self.index(arr, index),
-            ExprKind::AddrOf(_, _, inner) => self.expr(inner).map(|r| Constant::Ref(Box::new(r))),
-            ExprKind::Field(local_expr, ref field) => {
-                let result = self.expr(local_expr);
-                if let Some(Constant::Adt(constant)) = &self.expr(local_expr)
-                    && let ty::Adt(adt_def, _) = constant.ty().kind()
-                    && adt_def.is_struct()
-                    && let Some(desired_field) = field_of_struct(*adt_def, self.lcx, *constant, field)
-                {
-                    miri_to_const(self.lcx, desired_field)
-                }
-                else {
-                    result
-                }
-            },
-            _ => None,
-        }
-    }
-
-    #[expect(clippy::cast_possible_wrap)]
-    fn constant_not(&self, o: &Constant<'tcx>, ty: Ty<'_>) -> Option<Constant<'tcx>> {
-        use self::Constant::{Bool, Int};
-        match *o {
-            Bool(b) => Some(Bool(!b)),
-            Int(value) => {
-                let value = !value;
-                match *ty.kind() {
-                    ty::Int(ity) => Some(Int(unsext(self.lcx.tcx, value as i128, ity))),
-                    ty::Uint(ity) => Some(Int(clip(self.lcx.tcx, value, ity))),
-                    _ => None,
-                }
-            },
-            _ => None,
-        }
-    }
-
-    fn constant_negate(&self, o: &Constant<'tcx>, ty: Ty<'_>) -> Option<Constant<'tcx>> {
-        use self::Constant::{Int, F32, F64};
-        match *o {
-            Int(value) => {
-                let ty::Int(ity) = *ty.kind() else { return None };
-                // sign extend
-                let value = sext(self.lcx.tcx, value, ity);
-                let value = value.checked_neg()?;
-                // clear unused bits
-                Some(Int(unsext(self.lcx.tcx, value, ity)))
-            },
-            F32(f) => Some(F32(-f)),
-            F64(f) => Some(F64(-f)),
-            _ => None,
-        }
-    }
-
-    /// Create `Some(Vec![..])` of all constants, unless there is any
-    /// non-constant part.
-    fn multi(&mut self, vec: &[Expr<'_>]) -> Option<Vec<Constant<'tcx>>> {
-        vec.iter().map(|elem| self.expr(elem)).collect::<Option<_>>()
-    }
-
-    /// Lookup a possibly constant expression from an `ExprKind::Path`.
-    fn fetch_path(&mut self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>) -> Option<Constant<'tcx>> {
-        let res = self.typeck_results.qpath_res(qpath, id);
-        match res {
-            Res::Def(DefKind::Const | DefKind::AssocConst, def_id) => {
-                // Check if this constant is based on `cfg!(..)`,
-                // which is NOT constant for our purposes.
-                if let Some(node) = self.lcx.tcx.hir().get_if_local(def_id)
-                    && let Node::Item(Item { kind: ItemKind::Const(.., body_id), .. }) = node
-                    && let Node::Expr(Expr { kind: ExprKind::Lit(_), span, .. }) = self.lcx
-                        .tcx
-                        .hir()
-                        .get(body_id.hir_id)
-                    && is_direct_expn_of(*span, "cfg").is_some()
-                {
-                    return None;
-                }
-
-                let args = self.typeck_results.node_args(id);
-                let args = if self.args.is_empty() {
-                    args
-                } else {
-                    EarlyBinder::bind(args).instantiate(self.lcx.tcx, self.args)
-                };
-                let result = self
-                    .lcx
-                    .tcx
-                    .const_eval_resolve(self.param_env, mir::UnevaluatedConst::new(def_id, args), None)
-                    .ok()
-                    .map(|val| rustc_middle::mir::Const::from_value(val, ty))?;
-                let result = miri_to_const(self.lcx, result)?;
-                self.source = ConstantSource::Constant;
-                Some(result)
-            },
-            _ => None,
-        }
-    }
-
-    fn index(&mut self, lhs: &'_ Expr<'_>, index: &'_ Expr<'_>) -> Option<Constant<'tcx>> {
-        let lhs = self.expr(lhs);
-        let index = self.expr(index);
-
-        match (lhs, index) {
-            (Some(Constant::Vec(vec)), Some(Constant::Int(index))) => match vec.get(index as usize) {
-                Some(Constant::F32(x)) => Some(Constant::F32(*x)),
-                Some(Constant::F64(x)) => Some(Constant::F64(*x)),
-                _ => None,
-            },
-            (Some(Constant::Vec(vec)), _) => {
-                if !vec.is_empty() && vec.iter().all(|x| *x == vec[0]) {
-                    match vec.get(0) {
-                        Some(Constant::F32(x)) => Some(Constant::F32(*x)),
-                        Some(Constant::F64(x)) => Some(Constant::F64(*x)),
-                        _ => None,
-                    }
-                } else {
-                    None
-                }
-            },
-            _ => None,
-        }
-    }
-
-    /// A block can only yield a constant if it only has one constant expression.
-    fn block(&mut self, block: &Block<'_>) -> Option<Constant<'tcx>> {
-        if block.stmts.is_empty()
-            && let Some(expr) = block.expr
-        {
-            // Try to detect any `cfg`ed statements or empty macro expansions.
-            let span = block.span.data();
-            if span.ctxt == SyntaxContext::root() {
-                if let Some(expr_span) = walk_span_to_context(expr.span, span.ctxt)
-                    && let expr_lo = expr_span.lo()
-                    && expr_lo >= span.lo
-                    && let Some(src) = get_source_text(self.lcx, span.lo..expr_lo)
-                    && let Some(src) = src.as_str()
-                {
-                    use rustc_lexer::TokenKind::{Whitespace, LineComment, BlockComment, Semi, OpenBrace};
-                    if !tokenize(src)
-                        .map(|t| t.kind)
-                        .filter(|t| !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi))
-                        .eq([OpenBrace])
-                    {
-                        self.source = ConstantSource::Constant;
-                    }
-                } else {
-                    // Unable to access the source. Assume a non-local dependency.
-                    self.source = ConstantSource::Constant;
-                }
-            }
-
-            self.expr(expr)
-        } else {
-            None
-        }
-    }
-
-    fn ifthenelse(&mut self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>) -> Option<Constant<'tcx>> {
-        if let Some(Constant::Bool(b)) = self.expr(cond) {
-            if b {
-                self.expr(then)
-            } else {
-                otherwise.as_ref().and_then(|expr| self.expr(expr))
-            }
-        } else {
-            None
-        }
-    }
-
-    fn binop(&mut self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>) -> Option<Constant<'tcx>> {
-        let l = self.expr(left)?;
-        let r = self.expr(right);
-        match (l, r) {
-            (Constant::Int(l), Some(Constant::Int(r))) => match *self.typeck_results.expr_ty_opt(left)?.kind() {
-                ty::Int(ity) => {
-                    let l = sext(self.lcx.tcx, l, ity);
-                    let r = sext(self.lcx.tcx, r, ity);
-                    let zext = |n: i128| Constant::Int(unsext(self.lcx.tcx, n, ity));
-                    match op.node {
-                        BinOpKind::Add => l.checked_add(r).map(zext),
-                        BinOpKind::Sub => l.checked_sub(r).map(zext),
-                        BinOpKind::Mul => l.checked_mul(r).map(zext),
-                        BinOpKind::Div if r != 0 => l.checked_div(r).map(zext),
-                        BinOpKind::Rem if r != 0 => l.checked_rem(r).map(zext),
-                        BinOpKind::Shr => l.checked_shr(r.try_into().ok()?).map(zext),
-                        BinOpKind::Shl => l.checked_shl(r.try_into().ok()?).map(zext),
-                        BinOpKind::BitXor => Some(zext(l ^ r)),
-                        BinOpKind::BitOr => Some(zext(l | r)),
-                        BinOpKind::BitAnd => Some(zext(l & r)),
-                        BinOpKind::Eq => Some(Constant::Bool(l == r)),
-                        BinOpKind::Ne => Some(Constant::Bool(l != r)),
-                        BinOpKind::Lt => Some(Constant::Bool(l < r)),
-                        BinOpKind::Le => Some(Constant::Bool(l <= r)),
-                        BinOpKind::Ge => Some(Constant::Bool(l >= r)),
-                        BinOpKind::Gt => Some(Constant::Bool(l > r)),
-                        _ => None,
-                    }
-                },
-                ty::Uint(_) => match op.node {
-                    BinOpKind::Add => l.checked_add(r).map(Constant::Int),
-                    BinOpKind::Sub => l.checked_sub(r).map(Constant::Int),
-                    BinOpKind::Mul => l.checked_mul(r).map(Constant::Int),
-                    BinOpKind::Div => l.checked_div(r).map(Constant::Int),
-                    BinOpKind::Rem => l.checked_rem(r).map(Constant::Int),
-                    BinOpKind::Shr => l.checked_shr(r.try_into().ok()?).map(Constant::Int),
-                    BinOpKind::Shl => l.checked_shl(r.try_into().ok()?).map(Constant::Int),
-                    BinOpKind::BitXor => Some(Constant::Int(l ^ r)),
-                    BinOpKind::BitOr => Some(Constant::Int(l | r)),
-                    BinOpKind::BitAnd => Some(Constant::Int(l & r)),
-                    BinOpKind::Eq => Some(Constant::Bool(l == r)),
-                    BinOpKind::Ne => Some(Constant::Bool(l != r)),
-                    BinOpKind::Lt => Some(Constant::Bool(l < r)),
-                    BinOpKind::Le => Some(Constant::Bool(l <= r)),
-                    BinOpKind::Ge => Some(Constant::Bool(l >= r)),
-                    BinOpKind::Gt => Some(Constant::Bool(l > r)),
-                    _ => None,
-                },
-                _ => None,
-            },
-            (Constant::F32(l), Some(Constant::F32(r))) => match op.node {
-                BinOpKind::Add => Some(Constant::F32(l + r)),
-                BinOpKind::Sub => Some(Constant::F32(l - r)),
-                BinOpKind::Mul => Some(Constant::F32(l * r)),
-                BinOpKind::Div => Some(Constant::F32(l / r)),
-                BinOpKind::Rem => Some(Constant::F32(l % r)),
-                BinOpKind::Eq => Some(Constant::Bool(l == r)),
-                BinOpKind::Ne => Some(Constant::Bool(l != r)),
-                BinOpKind::Lt => Some(Constant::Bool(l < r)),
-                BinOpKind::Le => Some(Constant::Bool(l <= r)),
-                BinOpKind::Ge => Some(Constant::Bool(l >= r)),
-                BinOpKind::Gt => Some(Constant::Bool(l > r)),
-                _ => None,
-            },
-            (Constant::F64(l), Some(Constant::F64(r))) => match op.node {
-                BinOpKind::Add => Some(Constant::F64(l + r)),
-                BinOpKind::Sub => Some(Constant::F64(l - r)),
-                BinOpKind::Mul => Some(Constant::F64(l * r)),
-                BinOpKind::Div => Some(Constant::F64(l / r)),
-                BinOpKind::Rem => Some(Constant::F64(l % r)),
-                BinOpKind::Eq => Some(Constant::Bool(l == r)),
-                BinOpKind::Ne => Some(Constant::Bool(l != r)),
-                BinOpKind::Lt => Some(Constant::Bool(l < r)),
-                BinOpKind::Le => Some(Constant::Bool(l <= r)),
-                BinOpKind::Ge => Some(Constant::Bool(l >= r)),
-                BinOpKind::Gt => Some(Constant::Bool(l > r)),
-                _ => None,
-            },
-            (l, r) => match (op.node, l, r) {
-                (BinOpKind::And, Constant::Bool(false), _) => Some(Constant::Bool(false)),
-                (BinOpKind::Or, Constant::Bool(true), _) => Some(Constant::Bool(true)),
-                (BinOpKind::And, Constant::Bool(true), Some(r)) | (BinOpKind::Or, Constant::Bool(false), Some(r)) => {
-                    Some(r)
-                },
-                (BinOpKind::BitXor, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l ^ r)),
-                (BinOpKind::BitAnd, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l & r)),
-                (BinOpKind::BitOr, Constant::Bool(l), Some(Constant::Bool(r))) => Some(Constant::Bool(l | r)),
-                _ => None,
-            },
-        }
-    }
-}
-
-pub fn miri_to_const<'tcx>(lcx: &LateContext<'tcx>, result: mir::Const<'tcx>) -> Option<Constant<'tcx>> {
-    use rustc_middle::mir::ConstValue;
-    match result {
-        mir::Const::Val(ConstValue::Scalar(Scalar::Int(int)), _) => match result.ty().kind() {
-            ty::Adt(adt_def, _) if adt_def.is_struct() => Some(Constant::Adt(result)),
-            ty::Bool => Some(Constant::Bool(int == ScalarInt::TRUE)),
-            ty::Uint(_) | ty::Int(_) => Some(Constant::Int(int.assert_bits(int.size()))),
-            ty::Float(FloatTy::F32) => Some(Constant::F32(f32::from_bits(
-                int.try_into().expect("invalid f32 bit representation"),
-            ))),
-            ty::Float(FloatTy::F64) => Some(Constant::F64(f64::from_bits(
-                int.try_into().expect("invalid f64 bit representation"),
-            ))),
-            ty::RawPtr(_) => Some(Constant::RawPtr(int.assert_bits(int.size()))),
-            _ => None,
-        },
-        mir::Const::Val(cv, _) if matches!(result.ty().kind(), ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), ty::Str)) =>
-        {
-            let data = cv.try_get_slice_bytes_for_diagnostics(lcx.tcx)?;
-            String::from_utf8(data.to_owned()).ok().map(Constant::Str)
-        },
-        mir::Const::Val(ConstValue::Indirect { alloc_id, offset: _ }, _) => {
-            let alloc = lcx.tcx.global_alloc(alloc_id).unwrap_memory();
-            match result.ty().kind() {
-                ty::Adt(adt_def, _) if adt_def.is_struct() => Some(Constant::Adt(result)),
-                ty::Array(sub_type, len) => match sub_type.kind() {
-                    ty::Float(FloatTy::F32) => match len.try_to_target_usize(lcx.tcx) {
-                        Some(len) => alloc
-                            .inner()
-                            .inspect_with_uninit_and_ptr_outside_interpreter(0..(4 * usize::try_from(len).unwrap()))
-                            .to_owned()
-                            .array_chunks::<4>()
-                            .map(|&chunk| Some(Constant::F32(f32::from_le_bytes(chunk))))
-                            .collect::<Option<Vec<Constant<'tcx>>>>()
-                            .map(Constant::Vec),
-                        _ => None,
-                    },
-                    ty::Float(FloatTy::F64) => match len.try_to_target_usize(lcx.tcx) {
-                        Some(len) => alloc
-                            .inner()
-                            .inspect_with_uninit_and_ptr_outside_interpreter(0..(8 * usize::try_from(len).unwrap()))
-                            .to_owned()
-                            .array_chunks::<8>()
-                            .map(|&chunk| Some(Constant::F64(f64::from_le_bytes(chunk))))
-                            .collect::<Option<Vec<Constant<'tcx>>>>()
-                            .map(Constant::Vec),
-                        _ => None,
-                    },
-                    _ => None,
-                },
-                _ => None,
-            }
-        },
-        _ => None,
-    }
-}
-
-fn field_of_struct<'tcx>(
-    adt_def: ty::AdtDef<'tcx>,
-    lcx: &LateContext<'tcx>,
-    result: mir::Const<'tcx>,
-    field: &Ident,
-) -> Option<mir::Const<'tcx>> {
-    if let mir::Const::Val(result, ty) = result
-        && let Some(dc) = lcx.tcx.try_destructure_mir_constant_for_diagnostics(result, ty)
-        && let Some(dc_variant) = dc.variant
-        && let Some(variant) = adt_def.variants().get(dc_variant)
-        && let Some(field_idx) = variant.fields.iter().position(|el| el.name == field.name)
-        && let Some(&(val, ty)) = dc.fields.get(field_idx)
-    {
-        Some(mir::Const::Val(val, ty))
-    }
-    else {
-        None
-    }
-}
diff --git a/scout-audit-clippy-utils/src/diagnostics.rs b/scout-audit-clippy-utils/src/diagnostics.rs
deleted file mode 100644
index 210957a9..00000000
--- a/scout-audit-clippy-utils/src/diagnostics.rs
+++ /dev/null
@@ -1,238 +0,0 @@
-//! Clippy wrappers around rustc's diagnostic functions.
-//!
-//! These functions are used by the `INTERNAL_METADATA_COLLECTOR` lint to collect the corresponding
-//! lint applicability. Please make sure that you update the `LINT_EMISSION_FUNCTIONS` variable in
-//! `clippy_lints::utils::internal_lints::metadata_collector` when a new function is added
-//! or renamed.
-//!
-//! Thank you!
-//! ~The `INTERNAL_METADATA_COLLECTOR` lint
-
-use rustc_errors::{Applicability, Diagnostic, MultiSpan};
-use rustc_hir::HirId;
-use rustc_lint::{LateContext, Lint, LintContext};
-use rustc_span::source_map::Span;
-use std::env;
-
-fn docs_link(diag: &mut Diagnostic, lint: &'static Lint) {
-    if env::var("CLIPPY_DISABLE_DOCS_LINKS").is_err() {
-        if let Some(lint) = lint.name_lower().strip_prefix("clippy::") {
-            diag.help(format!(
-                "for further information visit https://rust-lang.github.io/rust-clippy/{}/index.html#{lint}",
-                &option_env!("RUST_RELEASE_NUM").map_or("master".to_string(), |n| {
-                    // extract just major + minor version and ignore patch versions
-                    format!("rust-{}", n.rsplit_once('.').unwrap().1)
-                })
-            ));
-        }
-    }
-}
-
-/// Emit a basic lint message with a `msg` and a `span`.
-///
-/// This is the most primitive of our lint emission methods and can
-/// be a good way to get a new lint started.
-///
-/// Usually it's nicer to provide more context for lint messages.
-/// Be sure the output is understandable when you use this method.
-///
-/// # Example
-///
-/// ```ignore
-/// error: usage of mem::forget on Drop type
-///   --> $DIR/mem_forget.rs:17:5
-///    |
-/// 17 |     std::mem::forget(seven);
-///    |     ^^^^^^^^^^^^^^^^^^^^^^^
-/// ```
-pub fn span_lint<T: LintContext>(cx: &T, lint: &'static Lint, sp: impl Into<MultiSpan>, msg: &str) {
-    cx.struct_span_lint(lint, sp, msg.to_string(), |diag| {
-        docs_link(diag, lint);
-        diag
-    });
-}
-
-/// Same as `span_lint` but with an extra `help` message.
-///
-/// Use this if you want to provide some general help but
-/// can't provide a specific machine applicable suggestion.
-///
-/// The `help` message can be optionally attached to a `Span`.
-///
-/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-///
-/// # Example
-///
-/// ```text
-/// error: constant division of 0.0 with 0.0 will always result in NaN
-///   --> $DIR/zero_div_zero.rs:6:25
-///    |
-/// 6  |     let other_f64_nan = 0.0f64 / 0.0;
-///    |                         ^^^^^^^^^^^^
-///    |
-///    = help: consider using `f64::NAN` if you would like a constant representing NaN
-/// ```
-pub fn span_lint_and_help<T: LintContext>(
-    cx: &T,
-    lint: &'static Lint,
-    span: impl Into<MultiSpan>,
-    msg: &str,
-    help_span: Option<Span>,
-    help: &str,
-) {
-    cx.struct_span_lint(lint, span, msg.to_string(), |diag| {
-        let help = help.to_string();
-        if let Some(help_span) = help_span {
-            diag.span_help(help_span, help);
-        } else {
-            diag.help(help);
-        }
-        docs_link(diag, lint);
-        diag
-    });
-}
-
-/// Like `span_lint` but with a `note` section instead of a `help` message.
-///
-/// The `note` message is presented separately from the main lint message
-/// and is attached to a specific span:
-///
-/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-///
-/// # Example
-///
-/// ```text
-/// error: calls to `std::mem::forget` with a reference instead of an owned value. Forgetting a reference does nothing.
-///   --> $DIR/drop_forget_ref.rs:10:5
-///    |
-/// 10 |     forget(&SomeStruct);
-///    |     ^^^^^^^^^^^^^^^^^^^
-///    |
-///    = note: `-D clippy::forget-ref` implied by `-D warnings`
-/// note: argument has type &SomeStruct
-///   --> $DIR/drop_forget_ref.rs:10:12
-///    |
-/// 10 |     forget(&SomeStruct);
-///    |            ^^^^^^^^^^^
-/// ```
-pub fn span_lint_and_note<T: LintContext>(
-    cx: &T,
-    lint: &'static Lint,
-    span: impl Into<MultiSpan>,
-    msg: &str,
-    note_span: Option<Span>,
-    note: &str,
-) {
-    cx.struct_span_lint(lint, span, msg.to_string(), |diag| {
-        let note = note.to_string();
-        if let Some(note_span) = note_span {
-            diag.span_note(note_span, note);
-        } else {
-            diag.note(note);
-        }
-        docs_link(diag, lint);
-        diag
-    });
-}
-
-/// Like `span_lint` but allows to add notes, help and suggestions using a closure.
-///
-/// If you need to customize your lint output a lot, use this function.
-/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-pub fn span_lint_and_then<C, S, F>(cx: &C, lint: &'static Lint, sp: S, msg: &str, f: F)
-where
-    C: LintContext,
-    S: Into<MultiSpan>,
-    F: FnOnce(&mut Diagnostic),
-{
-    cx.struct_span_lint(lint, sp, msg.to_string(), |diag| {
-        f(diag);
-        docs_link(diag, lint);
-        diag
-    });
-}
-
-pub fn span_lint_hir(cx: &LateContext<'_>, lint: &'static Lint, hir_id: HirId, sp: Span, msg: &str) {
-    cx.tcx.struct_span_lint_hir(lint, hir_id, sp, msg.to_string(), |diag| {
-        docs_link(diag, lint);
-        diag
-    });
-}
-
-pub fn span_lint_hir_and_then(
-    cx: &LateContext<'_>,
-    lint: &'static Lint,
-    hir_id: HirId,
-    sp: impl Into<MultiSpan>,
-    msg: &str,
-    f: impl FnOnce(&mut Diagnostic),
-) {
-    cx.tcx.struct_span_lint_hir(lint, hir_id, sp, msg.to_string(), |diag| {
-        f(diag);
-        docs_link(diag, lint);
-        diag
-    });
-}
-
-/// Add a span lint with a suggestion on how to fix it.
-///
-/// These suggestions can be parsed by rustfix to allow it to automatically fix your code.
-/// In the example below, `help` is `"try"` and `sugg` is the suggested replacement `".any(|x| x >
-/// 2)"`.
-///
-/// If you change the signature, remember to update the internal lint `CollapsibleCalls`
-///
-/// # Example
-///
-/// ```text
-/// error: This `.fold` can be more succinctly expressed as `.any`
-/// --> $DIR/methods.rs:390:13
-///     |
-/// 390 |     let _ = (0..3).fold(false, |acc, x| acc || x > 2);
-///     |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.any(|x| x > 2)`
-///     |
-///     = note: `-D fold-any` implied by `-D warnings`
-/// ```
-#[cfg_attr(feature = "internal", allow(clippy::collapsible_span_lint_calls))]
-pub fn span_lint_and_sugg<T: LintContext>(
-    cx: &T,
-    lint: &'static Lint,
-    sp: Span,
-    msg: &str,
-    help: &str,
-    sugg: String,
-    applicability: Applicability,
-) {
-    span_lint_and_then(cx, lint, sp, msg, |diag| {
-        diag.span_suggestion(sp, help.to_string(), sugg, applicability);
-    });
-}
-
-/// Create a suggestion made from several `span → replacement`.
-///
-/// Note: in the JSON format (used by `compiletest_rs`), the help message will
-/// appear once per
-/// replacement. In human-readable format though, it only appears once before
-/// the whole suggestion.
-pub fn multispan_sugg<I>(diag: &mut Diagnostic, help_msg: &str, sugg: I)
-where
-    I: IntoIterator<Item = (Span, String)>,
-{
-    multispan_sugg_with_applicability(diag, help_msg, Applicability::Unspecified, sugg);
-}
-
-/// Create a suggestion made from several `span → replacement`.
-///
-/// rustfix currently doesn't support the automatic application of suggestions with
-/// multiple spans. This is tracked in issue [rustfix#141](https://github.com/rust-lang/rustfix/issues/141).
-/// Suggestions with multiple spans will be silently ignored.
-pub fn multispan_sugg_with_applicability<I>(
-    diag: &mut Diagnostic,
-    help_msg: &str,
-    applicability: Applicability,
-    sugg: I,
-) where
-    I: IntoIterator<Item = (Span, String)>,
-{
-    diag.multipart_suggestion(help_msg.to_string(), sugg.into_iter().collect(), applicability);
-}
diff --git a/scout-audit-clippy-utils/src/eager_or_lazy.rs b/scout-audit-clippy-utils/src/eager_or_lazy.rs
deleted file mode 100644
index 0bcefba7..00000000
--- a/scout-audit-clippy-utils/src/eager_or_lazy.rs
+++ /dev/null
@@ -1,274 +0,0 @@
-//! Utilities for evaluating whether eagerly evaluated expressions can be made lazy and vice versa.
-//!
-//! Things to consider:
-//!  - does the expression have side-effects?
-//!  - is the expression computationally expensive?
-//!
-//! See lints:
-//!  - unnecessary-lazy-evaluations
-//!  - or-fun-call
-//!  - option-if-let-else
-
-use crate::ty::{all_predicates_of, is_copy};
-use crate::visitors::is_const_evaluatable;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::DefId;
-use rustc_hir::intravisit::{walk_expr, Visitor};
-use rustc_hir::{Block, Expr, ExprKind, QPath, UnOp};
-use rustc_lint::LateContext;
-use rustc_middle::ty;
-use rustc_middle::ty::adjustment::Adjust;
-use rustc_span::{sym, Symbol};
-use std::{cmp, ops};
-
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-enum EagernessSuggestion {
-    // The expression is cheap and should be evaluated eagerly
-    Eager,
-    // The expression may be cheap, so don't suggested lazy evaluation; or the expression may not be safe to switch to
-    // eager evaluation.
-    NoChange,
-    // The expression is likely expensive and should be evaluated lazily.
-    Lazy,
-    // The expression cannot be placed into a closure.
-    ForceNoChange,
-}
-impl ops::BitOr for EagernessSuggestion {
-    type Output = Self;
-    fn bitor(self, rhs: Self) -> Self {
-        cmp::max(self, rhs)
-    }
-}
-impl ops::BitOrAssign for EagernessSuggestion {
-    fn bitor_assign(&mut self, rhs: Self) {
-        *self = *self | rhs;
-    }
-}
-
-/// Determine the eagerness of the given function call.
-fn fn_eagerness(cx: &LateContext<'_>, fn_id: DefId, name: Symbol, have_one_arg: bool) -> EagernessSuggestion {
-    use EagernessSuggestion::{Eager, Lazy, NoChange};
-    let name = name.as_str();
-
-    let ty = match cx.tcx.impl_of_method(fn_id) {
-        Some(id) => cx.tcx.type_of(id).instantiate_identity(),
-        None => return Lazy,
-    };
-
-    if (name.starts_with("as_") || name == "len" || name == "is_empty") && have_one_arg {
-        if matches!(
-            cx.tcx.crate_name(fn_id.krate),
-            sym::std | sym::core | sym::alloc | sym::proc_macro
-        ) {
-            Eager
-        } else {
-            NoChange
-        }
-    } else if let ty::Adt(def, subs) = ty.kind() {
-        // Types where the only fields are generic types (or references to) with no trait bounds other
-        // than marker traits.
-        // Due to the limited operations on these types functions should be fairly cheap.
-        if def.variants().iter().flat_map(|v| v.fields.iter()).any(|x| {
-            matches!(
-                cx.tcx.type_of(x.did).instantiate_identity().peel_refs().kind(),
-                ty::Param(_)
-            )
-        }) && all_predicates_of(cx.tcx, fn_id).all(|(pred, _)| match pred.kind().skip_binder() {
-            ty::ClauseKind::Trait(pred) => cx.tcx.trait_def(pred.trait_ref.def_id).is_marker,
-            _ => true,
-        }) && subs.types().all(|x| matches!(x.peel_refs().kind(), ty::Param(_)))
-        {
-            // Limit the function to either `(self) -> bool` or `(&self) -> bool`
-            match &**cx
-                .tcx
-                .fn_sig(fn_id)
-                .instantiate_identity()
-                .skip_binder()
-                .inputs_and_output
-            {
-                [arg, res] if !arg.is_mutable_ptr() && arg.peel_refs() == ty && res.is_bool() => NoChange,
-                _ => Lazy,
-            }
-        } else {
-            Lazy
-        }
-    } else {
-        Lazy
-    }
-}
-
-fn res_has_significant_drop(res: Res, cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    if let Res::Def(DefKind::Ctor(..) | DefKind::Variant, _) | Res::SelfCtor(_) = res {
-        cx.typeck_results()
-            .expr_ty(e)
-            .has_significant_drop(cx.tcx, cx.param_env)
-    } else {
-        false
-    }
-}
-
-#[expect(clippy::too_many_lines)]
-fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessSuggestion {
-    struct V<'cx, 'tcx> {
-        cx: &'cx LateContext<'tcx>,
-        eagerness: EagernessSuggestion,
-    }
-
-    impl<'cx, 'tcx> Visitor<'tcx> for V<'cx, 'tcx> {
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            use EagernessSuggestion::{ForceNoChange, Lazy, NoChange};
-            if self.eagerness == ForceNoChange {
-                return;
-            }
-
-            // Autoderef through a user-defined `Deref` impl can have side-effects,
-            // so don't suggest changing it.
-            if self
-                .cx
-                .typeck_results()
-                .expr_adjustments(e)
-                .iter()
-                .any(|adj| matches!(adj.kind, Adjust::Deref(Some(_))))
-            {
-                self.eagerness |= NoChange;
-                return;
-            }
-
-            match e.kind {
-                ExprKind::Call(
-                    &Expr {
-                        kind: ExprKind::Path(ref path),
-                        hir_id,
-                        ..
-                    },
-                    args,
-                ) => match self.cx.qpath_res(path, hir_id) {
-                    res @ (Res::Def(DefKind::Ctor(..) | DefKind::Variant, _) | Res::SelfCtor(_)) => {
-                        if res_has_significant_drop(res, self.cx, e) {
-                            self.eagerness = ForceNoChange;
-                            return;
-                        }
-                    },
-                    Res::Def(_, id) if self.cx.tcx.is_promotable_const_fn(id) => (),
-                    // No need to walk the arguments here, `is_const_evaluatable` already did
-                    Res::Def(..) if is_const_evaluatable(self.cx, e) => {
-                        self.eagerness |= NoChange;
-                        return;
-                    },
-                    Res::Def(_, id) => match path {
-                        QPath::Resolved(_, p) => {
-                            self.eagerness |=
-                                fn_eagerness(self.cx, id, p.segments.last().unwrap().ident.name, !args.is_empty());
-                        },
-                        QPath::TypeRelative(_, name) => {
-                            self.eagerness |= fn_eagerness(self.cx, id, name.ident.name, !args.is_empty());
-                        },
-                        QPath::LangItem(..) => self.eagerness = Lazy,
-                    },
-                    _ => self.eagerness = Lazy,
-                },
-                // No need to walk the arguments here, `is_const_evaluatable` already did
-                ExprKind::MethodCall(..) if is_const_evaluatable(self.cx, e) => {
-                    self.eagerness |= NoChange;
-                    return;
-                },
-                ExprKind::Path(ref path) => {
-                    if res_has_significant_drop(self.cx.qpath_res(path, e.hir_id), self.cx, e) {
-                        self.eagerness = ForceNoChange;
-                        return;
-                    }
-                },
-                ExprKind::MethodCall(name, ..) => {
-                    self.eagerness |= self
-                        .cx
-                        .typeck_results()
-                        .type_dependent_def_id(e.hir_id)
-                        .map_or(Lazy, |id| fn_eagerness(self.cx, id, name.ident.name, true));
-                },
-                ExprKind::Index(_, e, _) => {
-                    let ty = self.cx.typeck_results().expr_ty_adjusted(e);
-                    if is_copy(self.cx, ty) && !ty.is_ref() {
-                        self.eagerness |= NoChange;
-                    } else {
-                        self.eagerness = Lazy;
-                    }
-                },
-                // Custom `Deref` impl might have side effects
-                ExprKind::Unary(UnOp::Deref, e)
-                    if self.cx.typeck_results().expr_ty(e).builtin_deref(true).is_none() =>
-                {
-                    self.eagerness |= NoChange;
-                },
-                // Dereferences should be cheap, but dereferencing a raw pointer earlier may not be safe.
-                ExprKind::Unary(UnOp::Deref, e) if !self.cx.typeck_results().expr_ty(e).is_unsafe_ptr() => (),
-                ExprKind::Unary(UnOp::Deref, _) => self.eagerness |= NoChange,
-                ExprKind::Unary(_, e)
-                    if matches!(
-                        self.cx.typeck_results().expr_ty(e).kind(),
-                        ty::Bool | ty::Int(_) | ty::Uint(_),
-                    ) => {},
-                ExprKind::Binary(_, lhs, rhs)
-                    if self.cx.typeck_results().expr_ty(lhs).is_primitive()
-                        && self.cx.typeck_results().expr_ty(rhs).is_primitive() => {},
-
-                // Can't be moved into a closure
-                ExprKind::Break(..)
-                | ExprKind::Continue(_)
-                | ExprKind::Ret(_)
-                | ExprKind::Become(_)
-                | ExprKind::InlineAsm(_)
-                | ExprKind::Yield(..)
-                | ExprKind::Err(_) => {
-                    self.eagerness = ForceNoChange;
-                    return;
-                },
-
-                // Memory allocation, custom operator, loop, or call to an unknown function
-                ExprKind::Unary(..) | ExprKind::Binary(..) | ExprKind::Loop(..) | ExprKind::Call(..) => {
-                    self.eagerness = Lazy;
-                },
-
-                ExprKind::ConstBlock(_)
-                | ExprKind::Array(_)
-                | ExprKind::Tup(_)
-                | ExprKind::Lit(_)
-                | ExprKind::Cast(..)
-                | ExprKind::Type(..)
-                | ExprKind::DropTemps(_)
-                | ExprKind::Let(..)
-                | ExprKind::If(..)
-                | ExprKind::Match(..)
-                | ExprKind::Closure { .. }
-                | ExprKind::Field(..)
-                | ExprKind::AddrOf(..)
-                | ExprKind::Struct(..)
-                | ExprKind::Repeat(..)
-                | ExprKind::Block(Block { stmts: [], .. }, _)
-                | ExprKind::OffsetOf(..) => (),
-
-                // Assignment might be to a local defined earlier, so don't eagerly evaluate.
-                // Blocks with multiple statements might be expensive, so don't eagerly evaluate.
-                // TODO: Actually check if either of these are true here.
-                ExprKind::Assign(..) | ExprKind::AssignOp(..) | ExprKind::Block(..) => self.eagerness |= NoChange,
-            }
-            walk_expr(self, e);
-        }
-    }
-
-    let mut v = V {
-        cx,
-        eagerness: EagernessSuggestion::Eager,
-    };
-    v.visit_expr(e);
-    v.eagerness
-}
-
-/// Whether the given expression should be changed to evaluate eagerly
-pub fn switch_to_eager_eval<'tcx>(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    expr_eagerness(cx, expr) == EagernessSuggestion::Eager
-}
-
-/// Whether the given expression should be changed to evaluate lazily
-pub fn switch_to_lazy_eval<'tcx>(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> bool {
-    expr_eagerness(cx, expr) == EagernessSuggestion::Lazy
-}
diff --git a/scout-audit-clippy-utils/src/higher.rs b/scout-audit-clippy-utils/src/higher.rs
deleted file mode 100644
index 802adbd4..00000000
--- a/scout-audit-clippy-utils/src/higher.rs
+++ /dev/null
@@ -1,469 +0,0 @@
-//! This module contains functions that retrieve specific elements.
-
-#![deny(clippy::missing_docs_in_private_items)]
-
-use crate::consts::{constant_simple, Constant};
-use crate::ty::is_type_diagnostic_item;
-use crate::{is_expn_of, match_def_path, paths};
-use if_chain::if_chain;
-use rustc_ast::ast;
-use rustc_hir as hir;
-use rustc_hir::{Arm, Block, Expr, ExprKind, HirId, LoopSource, MatchSource, Node, Pat, QPath};
-use rustc_lint::LateContext;
-use rustc_span::{sym, symbol, Span};
-
-/// The essential nodes of a desugared for loop as well as the entire span:
-/// `for pat in arg { body }` becomes `(pat, arg, body)`. Returns `(pat, arg, body, span)`.
-pub struct ForLoop<'tcx> {
-    /// `for` loop item
-    pub pat: &'tcx hir::Pat<'tcx>,
-    /// `IntoIterator` argument
-    pub arg: &'tcx hir::Expr<'tcx>,
-    /// `for` loop body
-    pub body: &'tcx hir::Expr<'tcx>,
-    /// Compare this against `hir::Destination.target`
-    pub loop_id: HirId,
-    /// entire `for` loop span
-    pub span: Span,
-}
-
-impl<'tcx> ForLoop<'tcx> {
-    /// Parses a desugared `for` loop
-    pub fn hir(expr: &Expr<'tcx>) -> Option<Self> {
-        if_chain! {
-            if let hir::ExprKind::DropTemps(e) = expr.kind;
-            if let hir::ExprKind::Match(iterexpr, [arm], hir::MatchSource::ForLoopDesugar) = e.kind;
-            if let hir::ExprKind::Call(_, [arg]) = iterexpr.kind;
-            if let hir::ExprKind::Loop(block, ..) = arm.body.kind;
-            if let [stmt] = block.stmts;
-            if let hir::StmtKind::Expr(e) = stmt.kind;
-            if let hir::ExprKind::Match(_, [_, some_arm], _) = e.kind;
-            if let hir::PatKind::Struct(_, [field], _) = some_arm.pat.kind;
-            then {
-                return Some(Self {
-                    pat: field.pat,
-                    arg,
-                    body: some_arm.body,
-                    loop_id: arm.body.hir_id,
-                    span: expr.span.ctxt().outer_expn_data().call_site,
-                });
-            }
-        }
-        None
-    }
-}
-
-/// An `if` expression without `DropTemps`
-pub struct If<'hir> {
-    /// `if` condition
-    pub cond: &'hir Expr<'hir>,
-    /// `if` then expression
-    pub then: &'hir Expr<'hir>,
-    /// `else` expression
-    pub r#else: Option<&'hir Expr<'hir>>,
-}
-
-impl<'hir> If<'hir> {
-    #[inline]
-    /// Parses an `if` expression
-    pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
-        if let ExprKind::If(
-            Expr {
-                kind: ExprKind::DropTemps(cond),
-                ..
-            },
-            then,
-            r#else,
-        ) = expr.kind
-        {
-            Some(Self { cond, then, r#else })
-        } else {
-            None
-        }
-    }
-}
-
-/// An `if let` expression
-pub struct IfLet<'hir> {
-    /// `if let` pattern
-    pub let_pat: &'hir Pat<'hir>,
-    /// `if let` scrutinee
-    pub let_expr: &'hir Expr<'hir>,
-    /// `if let` then expression
-    pub if_then: &'hir Expr<'hir>,
-    /// `if let` else expression
-    pub if_else: Option<&'hir Expr<'hir>>,
-}
-
-impl<'hir> IfLet<'hir> {
-    /// Parses an `if let` expression
-    pub fn hir(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
-        if let ExprKind::If(
-            Expr {
-                kind:
-                    ExprKind::Let(hir::Let {
-                        pat: let_pat,
-                        init: let_expr,
-                        ..
-                    }),
-                ..
-            },
-            if_then,
-            if_else,
-        ) = expr.kind
-        {
-            let mut iter = cx.tcx.hir().parent_iter(expr.hir_id);
-            if let Some((_, Node::Block(Block { stmts: [], .. }))) = iter.next() {
-                if let Some((
-                    _,
-                    Node::Expr(Expr {
-                        kind: ExprKind::Loop(_, _, LoopSource::While, _),
-                        ..
-                    }),
-                )) = iter.next()
-                {
-                    // while loop desugar
-                    return None;
-                }
-            }
-            return Some(Self {
-                let_pat,
-                let_expr,
-                if_then,
-                if_else,
-            });
-        }
-        None
-    }
-}
-
-/// An `if let` or `match` expression. Useful for lints that trigger on one or the other.
-#[derive(Debug)]
-pub enum IfLetOrMatch<'hir> {
-    /// Any `match` expression
-    Match(&'hir Expr<'hir>, &'hir [Arm<'hir>], MatchSource),
-    /// scrutinee, pattern, then block, else block
-    IfLet(
-        &'hir Expr<'hir>,
-        &'hir Pat<'hir>,
-        &'hir Expr<'hir>,
-        Option<&'hir Expr<'hir>>,
-    ),
-}
-
-impl<'hir> IfLetOrMatch<'hir> {
-    /// Parses an `if let` or `match` expression
-    pub fn parse(cx: &LateContext<'_>, expr: &Expr<'hir>) -> Option<Self> {
-        match expr.kind {
-            ExprKind::Match(expr, arms, source) => Some(Self::Match(expr, arms, source)),
-            _ => IfLet::hir(cx, expr).map(
-                |IfLet {
-                     let_expr,
-                     let_pat,
-                     if_then,
-                     if_else,
-                 }| { Self::IfLet(let_expr, let_pat, if_then, if_else) },
-            ),
-        }
-    }
-}
-
-/// An `if` or `if let` expression
-pub struct IfOrIfLet<'hir> {
-    /// `if` condition that is maybe a `let` expression
-    pub cond: &'hir Expr<'hir>,
-    /// `if` then expression
-    pub then: &'hir Expr<'hir>,
-    /// `else` expression
-    pub r#else: Option<&'hir Expr<'hir>>,
-}
-
-impl<'hir> IfOrIfLet<'hir> {
-    #[inline]
-    /// Parses an `if` or `if let` expression
-    pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
-        if let ExprKind::If(cond, then, r#else) = expr.kind {
-            if let ExprKind::DropTemps(new_cond) = cond.kind {
-                return Some(Self {
-                    cond: new_cond,
-                    r#else,
-                    then,
-                });
-            }
-            if let ExprKind::Let(..) = cond.kind {
-                return Some(Self { cond, then, r#else });
-            }
-        }
-        None
-    }
-}
-
-/// Represent a range akin to `ast::ExprKind::Range`.
-#[derive(Debug, Copy, Clone)]
-pub struct Range<'a> {
-    /// The lower bound of the range, or `None` for ranges such as `..X`.
-    pub start: Option<&'a hir::Expr<'a>>,
-    /// The upper bound of the range, or `None` for ranges such as `X..`.
-    pub end: Option<&'a hir::Expr<'a>>,
-    /// Whether the interval is open or closed.
-    pub limits: ast::RangeLimits,
-}
-
-impl<'a> Range<'a> {
-    /// Higher a `hir` range to something similar to `ast::ExprKind::Range`.
-    pub fn hir(expr: &'a hir::Expr<'_>) -> Option<Range<'a>> {
-        /// Finds the field named `name` in the field. Always return `Some` for
-        /// convenience.
-        fn get_field<'c>(name: &str, fields: &'c [hir::ExprField<'_>]) -> Option<&'c hir::Expr<'c>> {
-            let expr = &fields.iter().find(|field| field.ident.name.as_str() == name)?.expr;
-            Some(expr)
-        }
-
-        match expr.kind {
-            hir::ExprKind::Call(path, args)
-                if matches!(
-                    path.kind,
-                    hir::ExprKind::Path(hir::QPath::LangItem(hir::LangItem::RangeInclusiveNew, ..))
-                ) =>
-            {
-                Some(Range {
-                    start: Some(&args[0]),
-                    end: Some(&args[1]),
-                    limits: ast::RangeLimits::Closed,
-                })
-            },
-            hir::ExprKind::Struct(path, fields, None) => match &path {
-                hir::QPath::LangItem(hir::LangItem::RangeFull, ..) => Some(Range {
-                    start: None,
-                    end: None,
-                    limits: ast::RangeLimits::HalfOpen,
-                }),
-                hir::QPath::LangItem(hir::LangItem::RangeFrom, ..) => Some(Range {
-                    start: Some(get_field("start", fields)?),
-                    end: None,
-                    limits: ast::RangeLimits::HalfOpen,
-                }),
-                hir::QPath::LangItem(hir::LangItem::Range, ..) => Some(Range {
-                    start: Some(get_field("start", fields)?),
-                    end: Some(get_field("end", fields)?),
-                    limits: ast::RangeLimits::HalfOpen,
-                }),
-                hir::QPath::LangItem(hir::LangItem::RangeToInclusive, ..) => Some(Range {
-                    start: None,
-                    end: Some(get_field("end", fields)?),
-                    limits: ast::RangeLimits::Closed,
-                }),
-                hir::QPath::LangItem(hir::LangItem::RangeTo, ..) => Some(Range {
-                    start: None,
-                    end: Some(get_field("end", fields)?),
-                    limits: ast::RangeLimits::HalfOpen,
-                }),
-                _ => None,
-            },
-            _ => None,
-        }
-    }
-}
-
-/// Represents the pre-expansion arguments of a `vec!` invocation.
-pub enum VecArgs<'a> {
-    /// `vec![elem; len]`
-    Repeat(&'a hir::Expr<'a>, &'a hir::Expr<'a>),
-    /// `vec![a, b, c]`
-    Vec(&'a [hir::Expr<'a>]),
-}
-
-impl<'a> VecArgs<'a> {
-    /// Returns the arguments of the `vec!` macro if this expression was expanded
-    /// from `vec!`.
-    pub fn hir(cx: &LateContext<'_>, expr: &'a hir::Expr<'_>) -> Option<VecArgs<'a>> {
-        if_chain! {
-            if let hir::ExprKind::Call(fun, args) = expr.kind;
-            if let hir::ExprKind::Path(ref qpath) = fun.kind;
-            if is_expn_of(fun.span, "vec").is_some();
-            if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-            then {
-                return if match_def_path(cx, fun_def_id, &paths::VEC_FROM_ELEM) && args.len() == 2 {
-                    // `vec![elem; size]` case
-                    Some(VecArgs::Repeat(&args[0], &args[1]))
-                } else if match_def_path(cx, fun_def_id, &paths::SLICE_INTO_VEC) && args.len() == 1 {
-                    // `vec![a, b, c]` case
-                    if let hir::ExprKind::Call(_, [arg]) = &args[0].kind
-                        && let hir::ExprKind::Array(args) = arg.kind {
-                        Some(VecArgs::Vec(args))
-                    } else {
-                        None
-                    }
-                } else if match_def_path(cx, fun_def_id, &paths::VEC_NEW) && args.is_empty() {
-                    Some(VecArgs::Vec(&[]))
-                } else {
-                    None
-                };
-            }
-        }
-
-        None
-    }
-}
-
-/// A desugared `while` loop
-pub struct While<'hir> {
-    /// `while` loop condition
-    pub condition: &'hir Expr<'hir>,
-    /// `while` loop body
-    pub body: &'hir Expr<'hir>,
-    /// Span of the loop header
-    pub span: Span,
-}
-
-impl<'hir> While<'hir> {
-    #[inline]
-    /// Parses a desugared `while` loop
-    pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
-        if let ExprKind::Loop(
-            Block {
-                expr:
-                    Some(Expr {
-                        kind:
-                            ExprKind::If(
-                                Expr {
-                                    kind: ExprKind::DropTemps(condition),
-                                    ..
-                                },
-                                body,
-                                _,
-                            ),
-                        ..
-                    }),
-                ..
-            },
-            _,
-            LoopSource::While,
-            span,
-        ) = expr.kind
-        {
-            return Some(Self { condition, body, span });
-        }
-        None
-    }
-}
-
-/// A desugared `while let` loop
-pub struct WhileLet<'hir> {
-    /// `while let` loop item pattern
-    pub let_pat: &'hir Pat<'hir>,
-    /// `while let` loop scrutinee
-    pub let_expr: &'hir Expr<'hir>,
-    /// `while let` loop body
-    pub if_then: &'hir Expr<'hir>,
-}
-
-impl<'hir> WhileLet<'hir> {
-    #[inline]
-    /// Parses a desugared `while let` loop
-    pub const fn hir(expr: &Expr<'hir>) -> Option<Self> {
-        if let ExprKind::Loop(
-            Block {
-                expr:
-                    Some(Expr {
-                        kind:
-                            ExprKind::If(
-                                Expr {
-                                    kind:
-                                        ExprKind::Let(hir::Let {
-                                            pat: let_pat,
-                                            init: let_expr,
-                                            ..
-                                        }),
-                                    ..
-                                },
-                                if_then,
-                                _,
-                            ),
-                        ..
-                    }),
-                ..
-            },
-            _,
-            LoopSource::While,
-            _,
-        ) = expr.kind
-        {
-            return Some(Self {
-                let_pat,
-                let_expr,
-                if_then,
-            });
-        }
-        None
-    }
-}
-
-/// Converts a `hir` binary operator to the corresponding `ast` type.
-#[must_use]
-pub fn binop(op: hir::BinOpKind) -> ast::BinOpKind {
-    match op {
-        hir::BinOpKind::Eq => ast::BinOpKind::Eq,
-        hir::BinOpKind::Ge => ast::BinOpKind::Ge,
-        hir::BinOpKind::Gt => ast::BinOpKind::Gt,
-        hir::BinOpKind::Le => ast::BinOpKind::Le,
-        hir::BinOpKind::Lt => ast::BinOpKind::Lt,
-        hir::BinOpKind::Ne => ast::BinOpKind::Ne,
-        hir::BinOpKind::Or => ast::BinOpKind::Or,
-        hir::BinOpKind::Add => ast::BinOpKind::Add,
-        hir::BinOpKind::And => ast::BinOpKind::And,
-        hir::BinOpKind::BitAnd => ast::BinOpKind::BitAnd,
-        hir::BinOpKind::BitOr => ast::BinOpKind::BitOr,
-        hir::BinOpKind::BitXor => ast::BinOpKind::BitXor,
-        hir::BinOpKind::Div => ast::BinOpKind::Div,
-        hir::BinOpKind::Mul => ast::BinOpKind::Mul,
-        hir::BinOpKind::Rem => ast::BinOpKind::Rem,
-        hir::BinOpKind::Shl => ast::BinOpKind::Shl,
-        hir::BinOpKind::Shr => ast::BinOpKind::Shr,
-        hir::BinOpKind::Sub => ast::BinOpKind::Sub,
-    }
-}
-
-/// A parsed `Vec` initialization expression
-#[derive(Clone, Copy)]
-pub enum VecInitKind {
-    /// `Vec::new()`
-    New,
-    /// `Vec::default()` or `Default::default()`
-    Default,
-    /// `Vec::with_capacity(123)`
-    WithConstCapacity(u128),
-    /// `Vec::with_capacity(slice.len())`
-    WithExprCapacity(HirId),
-}
-
-/// Checks if the given expression is an initialization of `Vec` and returns its kind.
-pub fn get_vec_init_kind<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) -> Option<VecInitKind> {
-    if let ExprKind::Call(func, args) = expr.kind {
-        match func.kind {
-            ExprKind::Path(QPath::TypeRelative(ty, name))
-                if is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::Vec) =>
-            {
-                if name.ident.name == sym::new {
-                    return Some(VecInitKind::New);
-                } else if name.ident.name == symbol::kw::Default {
-                    return Some(VecInitKind::Default);
-                } else if name.ident.name.as_str() == "with_capacity" {
-                    let arg = args.get(0)?;
-                    return match constant_simple(cx, cx.typeck_results(), arg) {
-                        Some(Constant::Int(num)) => Some(VecInitKind::WithConstCapacity(num)),
-                        _ => Some(VecInitKind::WithExprCapacity(arg.hir_id)),
-                    };
-                };
-            },
-            ExprKind::Path(QPath::Resolved(_, path))
-                if match_def_path(cx, path.res.opt_def_id()?, &paths::DEFAULT_TRAIT_METHOD)
-                    && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(expr), sym::Vec) =>
-            {
-                return Some(VecInitKind::Default);
-            },
-            _ => (),
-        }
-    }
-    None
-}
diff --git a/scout-audit-clippy-utils/src/hir_utils.rs b/scout-audit-clippy-utils/src/hir_utils.rs
deleted file mode 100644
index 52214e73..00000000
--- a/scout-audit-clippy-utils/src/hir_utils.rs
+++ /dev/null
@@ -1,1158 +0,0 @@
-use crate::consts::constant_simple;
-use crate::macros::macro_backtrace;
-use crate::source::{get_source_text, snippet_opt, walk_span_to_context, SpanRange};
-use crate::tokenize_with_text;
-use rustc_ast::ast::InlineAsmTemplatePiece;
-use rustc_data_structures::fx::FxHasher;
-use rustc_hir::def::Res;
-use rustc_hir::MatchSource::TryDesugar;
-use rustc_hir::{
-    ArrayLen, BinOpKind, BindingAnnotation, Block, BodyId, Closure, Expr, ExprField, ExprKind, FnRetTy, GenericArg,
-    GenericArgs, Guard, HirId, HirIdMap, InlineAsmOperand, Let, Lifetime, LifetimeName, Pat, PatField, PatKind, Path,
-    PathSegment, PrimTy, QPath, Stmt, StmtKind, Ty, TyKind, TypeBinding,
-};
-use rustc_lexer::{tokenize, TokenKind};
-use rustc_lint::LateContext;
-use rustc_middle::ty::TypeckResults;
-use rustc_span::{sym, BytePos, ExpnKind, MacroKind, Symbol, SyntaxContext};
-use std::hash::{Hash, Hasher};
-use std::ops::Range;
-
-/// Callback that is called when two expressions are not equal in the sense of `SpanlessEq`, but
-/// other conditions would make them equal.
-type SpanlessEqCallback<'a> = dyn FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a;
-
-/// Type used to check whether two ast are the same. This is different from the
-/// operator `==` on ast types as this operator would compare true equality with
-/// ID and span.
-///
-/// Note that some expressions kinds are not considered but could be added.
-pub struct SpanlessEq<'a, 'tcx> {
-    /// Context used to evaluate constant expressions.
-    cx: &'a LateContext<'tcx>,
-    maybe_typeck_results: Option<(&'tcx TypeckResults<'tcx>, &'tcx TypeckResults<'tcx>)>,
-    allow_side_effects: bool,
-    expr_fallback: Option<Box<SpanlessEqCallback<'a>>>,
-}
-
-impl<'a, 'tcx> SpanlessEq<'a, 'tcx> {
-    pub fn new(cx: &'a LateContext<'tcx>) -> Self {
-        Self {
-            cx,
-            maybe_typeck_results: cx.maybe_typeck_results().map(|x| (x, x)),
-            allow_side_effects: true,
-            expr_fallback: None,
-        }
-    }
-
-    /// Consider expressions containing potential side effects as not equal.
-    #[must_use]
-    pub fn deny_side_effects(self) -> Self {
-        Self {
-            allow_side_effects: false,
-            ..self
-        }
-    }
-
-    #[must_use]
-    pub fn expr_fallback(self, expr_fallback: impl FnMut(&Expr<'_>, &Expr<'_>) -> bool + 'a) -> Self {
-        Self {
-            expr_fallback: Some(Box::new(expr_fallback)),
-            ..self
-        }
-    }
-
-    /// Use this method to wrap comparisons that may involve inter-expression context.
-    /// See `self.locals`.
-    pub fn inter_expr(&mut self) -> HirEqInterExpr<'_, 'a, 'tcx> {
-        HirEqInterExpr {
-            inner: self,
-            left_ctxt: SyntaxContext::root(),
-            right_ctxt: SyntaxContext::root(),
-            locals: HirIdMap::default(),
-        }
-    }
-
-    pub fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
-        self.inter_expr().eq_block(left, right)
-    }
-
-    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-        self.inter_expr().eq_expr(left, right)
-    }
-
-    pub fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
-        self.inter_expr().eq_path(left, right)
-    }
-
-    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
-        self.inter_expr().eq_path_segment(left, right)
-    }
-
-    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
-        self.inter_expr().eq_path_segments(left, right)
-    }
-}
-
-pub struct HirEqInterExpr<'a, 'b, 'tcx> {
-    inner: &'a mut SpanlessEq<'b, 'tcx>,
-    left_ctxt: SyntaxContext,
-    right_ctxt: SyntaxContext,
-
-    // When binding are declared, the binding ID in the left expression is mapped to the one on the
-    // right. For example, when comparing `{ let x = 1; x + 2 }` and `{ let y = 1; y + 2 }`,
-    // these blocks are considered equal since `x` is mapped to `y`.
-    pub locals: HirIdMap<HirId>,
-}
-
-impl HirEqInterExpr<'_, '_, '_> {
-    pub fn eq_stmt(&mut self, left: &Stmt<'_>, right: &Stmt<'_>) -> bool {
-        match (&left.kind, &right.kind) {
-            (&StmtKind::Local(l), &StmtKind::Local(r)) => {
-                // This additional check ensures that the type of the locals are equivalent even if the init
-                // expression or type have some inferred parts.
-                if let Some((typeck_lhs, typeck_rhs)) = self.inner.maybe_typeck_results {
-                    let l_ty = typeck_lhs.pat_ty(l.pat);
-                    let r_ty = typeck_rhs.pat_ty(r.pat);
-                    if l_ty != r_ty {
-                        return false;
-                    }
-                }
-
-                // eq_pat adds the HirIds to the locals map. We therefore call it last to make sure that
-                // these only get added if the init and type is equal.
-                both(&l.init, &r.init, |l, r| self.eq_expr(l, r))
-                    && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r))
-                    && both(&l.els, &r.els, |l, r| self.eq_block(l, r))
-                    && self.eq_pat(l.pat, r.pat)
-            },
-            (&StmtKind::Expr(l), &StmtKind::Expr(r)) | (&StmtKind::Semi(l), &StmtKind::Semi(r)) => self.eq_expr(l, r),
-            _ => false,
-        }
-    }
-
-    /// Checks whether two blocks are the same.
-    #[expect(clippy::similar_names)]
-    fn eq_block(&mut self, left: &Block<'_>, right: &Block<'_>) -> bool {
-        use TokenKind::{BlockComment, LineComment, Semi, Whitespace};
-        if left.stmts.len() != right.stmts.len() {
-            return false;
-        }
-        let lspan = left.span.data();
-        let rspan = right.span.data();
-        if lspan.ctxt != SyntaxContext::root() && rspan.ctxt != SyntaxContext::root() {
-            // Don't try to check in between statements inside macros.
-            return over(left.stmts, right.stmts, |left, right| self.eq_stmt(left, right))
-                && both(&left.expr, &right.expr, |left, right| self.eq_expr(left, right));
-        }
-        if lspan.ctxt != rspan.ctxt {
-            return false;
-        }
-
-        let mut lstart = lspan.lo;
-        let mut rstart = rspan.lo;
-
-        for (left, right) in left.stmts.iter().zip(right.stmts) {
-            if !self.eq_stmt(left, right) {
-                return false;
-            }
-
-            // Try to detect any `cfg`ed statements or empty macro expansions.
-            let Some(lstmt_span) = walk_span_to_context(left.span, lspan.ctxt) else {
-                return false;
-            };
-            let Some(rstmt_span) = walk_span_to_context(right.span, rspan.ctxt) else {
-                return false;
-            };
-            let lstmt_span = lstmt_span.data();
-            let rstmt_span = rstmt_span.data();
-
-            if lstmt_span.lo < lstart && rstmt_span.lo < rstart {
-                // Can happen when macros expand to multiple statements, or rearrange statements.
-                // Nothing in between the statements to check in this case.
-                continue;
-            }
-            if lstmt_span.lo < lstart || rstmt_span.lo < rstart {
-                // Only one of the blocks had a weird macro.
-                return false;
-            }
-            if !eq_span_tokens(self.inner.cx, lstart..lstmt_span.lo, rstart..rstmt_span.lo, |t| {
-                !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi)
-            }) {
-                return false;
-            }
-
-            lstart = lstmt_span.hi;
-            rstart = rstmt_span.hi;
-        }
-
-        let (lend, rend) = match (left.expr, right.expr) {
-            (Some(left), Some(right)) => {
-                if !self.eq_expr(left, right) {
-                    return false;
-                }
-                let Some(lexpr_span) = walk_span_to_context(left.span, lspan.ctxt) else {
-                    return false;
-                };
-                let Some(rexpr_span) = walk_span_to_context(right.span, rspan.ctxt) else {
-                    return false;
-                };
-                (lexpr_span.lo(), rexpr_span.lo())
-            },
-            (None, None) => (lspan.hi, rspan.hi),
-            (Some(_), None) | (None, Some(_)) => return false,
-        };
-
-        if lend < lstart && rend < rstart {
-            // Can happen when macros rearrange the input.
-            // Nothing in between the statements to check in this case.
-            return true;
-        } else if lend < lstart || rend < rstart {
-            // Only one of the blocks had a weird macro
-            return false;
-        }
-        eq_span_tokens(self.inner.cx, lstart..lend, rstart..rend, |t| {
-            !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. } | Semi)
-        })
-    }
-
-    fn should_ignore(&mut self, expr: &Expr<'_>) -> bool {
-        macro_backtrace(expr.span).last().map_or(false, |macro_call| {
-            matches!(
-                &self.inner.cx.tcx.get_diagnostic_name(macro_call.def_id),
-                Some(sym::todo_macro | sym::unimplemented_macro)
-            )
-        })
-    }
-
-    pub fn eq_array_length(&mut self, left: ArrayLen, right: ArrayLen) -> bool {
-        match (left, right) {
-            (ArrayLen::Infer(..), ArrayLen::Infer(..)) => true,
-            (ArrayLen::Body(l_ct), ArrayLen::Body(r_ct)) => self.eq_body(l_ct.body, r_ct.body),
-            (_, _) => false,
-        }
-    }
-
-    pub fn eq_body(&mut self, left: BodyId, right: BodyId) -> bool {
-        // swap out TypeckResults when hashing a body
-        let old_maybe_typeck_results = self.inner.maybe_typeck_results.replace((
-            self.inner.cx.tcx.typeck_body(left),
-            self.inner.cx.tcx.typeck_body(right),
-        ));
-        let res = self.eq_expr(
-            self.inner.cx.tcx.hir().body(left).value,
-            self.inner.cx.tcx.hir().body(right).value,
-        );
-        self.inner.maybe_typeck_results = old_maybe_typeck_results;
-        res
-    }
-
-    #[expect(clippy::similar_names)]
-    pub fn eq_expr(&mut self, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-        if !self.check_ctxt(left.span.ctxt(), right.span.ctxt()) {
-            return false;
-        }
-
-        if let Some((typeck_lhs, typeck_rhs)) = self.inner.maybe_typeck_results
-            && typeck_lhs.expr_ty(left) == typeck_rhs.expr_ty(right)
-            && let (Some(l), Some(r)) = (
-                constant_simple(self.inner.cx, typeck_lhs, left),
-                constant_simple(self.inner.cx, typeck_rhs, right),
-            )
-            && l == r
-        {
-            return true;
-        }
-
-        let is_eq = match (
-            reduce_exprkind(self.inner.cx, &left.kind),
-            reduce_exprkind(self.inner.cx, &right.kind),
-        ) {
-            (&ExprKind::AddrOf(lb, l_mut, le), &ExprKind::AddrOf(rb, r_mut, re)) => {
-                lb == rb && l_mut == r_mut && self.eq_expr(le, re)
-            },
-            (&ExprKind::Continue(li), &ExprKind::Continue(ri)) => {
-                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
-            },
-            (&ExprKind::Assign(ll, lr, _), &ExprKind::Assign(rl, rr, _)) => {
-                self.inner.allow_side_effects && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-            },
-            (&ExprKind::AssignOp(ref lo, ll, lr), &ExprKind::AssignOp(ref ro, rl, rr)) => {
-                self.inner.allow_side_effects && lo.node == ro.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-            },
-            (&ExprKind::Block(l, _), &ExprKind::Block(r, _)) => self.eq_block(l, r),
-            (&ExprKind::Binary(l_op, ll, lr), &ExprKind::Binary(r_op, rl, rr)) => {
-                l_op.node == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-                    || swap_binop(l_op.node, ll, lr).map_or(false, |(l_op, ll, lr)| {
-                        l_op == r_op.node && self.eq_expr(ll, rl) && self.eq_expr(lr, rr)
-                    })
-            },
-            (&ExprKind::Break(li, ref le), &ExprKind::Break(ri, ref re)) => {
-                both(&li.label, &ri.label, |l, r| l.ident.name == r.ident.name)
-                    && both(le, re, |l, r| self.eq_expr(l, r))
-            },
-            (&ExprKind::Call(l_fun, l_args), &ExprKind::Call(r_fun, r_args)) => {
-                self.inner.allow_side_effects && self.eq_expr(l_fun, r_fun) && self.eq_exprs(l_args, r_args)
-            },
-            (&ExprKind::Cast(lx, lt), &ExprKind::Cast(rx, rt)) | (&ExprKind::Type(lx, lt), &ExprKind::Type(rx, rt)) => {
-                self.eq_expr(lx, rx) && self.eq_ty(lt, rt)
-            },
-            (&ExprKind::Field(l_f_exp, ref l_f_ident), &ExprKind::Field(r_f_exp, ref r_f_ident)) => {
-                l_f_ident.name == r_f_ident.name && self.eq_expr(l_f_exp, r_f_exp)
-            },
-            (&ExprKind::Index(la, li, _), &ExprKind::Index(ra, ri, _)) => self.eq_expr(la, ra) && self.eq_expr(li, ri),
-            (&ExprKind::If(lc, lt, ref le), &ExprKind::If(rc, rt, ref re)) => {
-                self.eq_expr(lc, rc) && self.eq_expr(lt, rt) && both(le, re, |l, r| self.eq_expr(l, r))
-            },
-            (&ExprKind::Let(l), &ExprKind::Let(r)) => {
-                self.eq_pat(l.pat, r.pat) && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && self.eq_expr(l.init, r.init)
-            },
-            (ExprKind::Lit(l), ExprKind::Lit(r)) => l.node == r.node,
-            (&ExprKind::Loop(lb, ref ll, ref lls, _), &ExprKind::Loop(rb, ref rl, ref rls, _)) => {
-                lls == rls && self.eq_block(lb, rb) && both(ll, rl, |l, r| l.ident.name == r.ident.name)
-            },
-            (&ExprKind::Match(le, la, ref ls), &ExprKind::Match(re, ra, ref rs)) => {
-                (ls == rs || (matches!((ls, rs), (TryDesugar(_), TryDesugar(_)))))
-                    && self.eq_expr(le, re)
-                    && over(la, ra, |l, r| {
-                        self.eq_pat(l.pat, r.pat)
-                            && both(&l.guard, &r.guard, |l, r| self.eq_guard(l, r))
-                            && self.eq_expr(l.body, r.body)
-                    })
-            },
-            (
-                &ExprKind::MethodCall(l_path, l_receiver, l_args, _),
-                &ExprKind::MethodCall(r_path, r_receiver, r_args, _),
-            ) => {
-                self.inner.allow_side_effects
-                    && self.eq_path_segment(l_path, r_path)
-                    && self.eq_expr(l_receiver, r_receiver)
-                    && self.eq_exprs(l_args, r_args)
-            },
-            (&ExprKind::Repeat(le, ll), &ExprKind::Repeat(re, rl)) => {
-                self.eq_expr(le, re) && self.eq_array_length(ll, rl)
-            },
-            (ExprKind::Ret(l), ExprKind::Ret(r)) => both(l, r, |l, r| self.eq_expr(l, r)),
-            (ExprKind::Path(l), ExprKind::Path(r)) => self.eq_qpath(l, r),
-            (&ExprKind::Struct(l_path, lf, ref lo), &ExprKind::Struct(r_path, rf, ref ro)) => {
-                self.eq_qpath(l_path, r_path)
-                    && both(lo, ro, |l, r| self.eq_expr(l, r))
-                    && over(lf, rf, |l, r| self.eq_expr_field(l, r))
-            },
-            (&ExprKind::Tup(l_tup), &ExprKind::Tup(r_tup)) => self.eq_exprs(l_tup, r_tup),
-            (&ExprKind::Unary(l_op, le), &ExprKind::Unary(r_op, re)) => l_op == r_op && self.eq_expr(le, re),
-            (&ExprKind::Array(l), &ExprKind::Array(r)) => self.eq_exprs(l, r),
-            (&ExprKind::DropTemps(le), &ExprKind::DropTemps(re)) => self.eq_expr(le, re),
-            (&ExprKind::OffsetOf(l_container, l_fields), &ExprKind::OffsetOf(r_container, r_fields)) => {
-                self.eq_ty(l_container, r_container) && over(l_fields, r_fields, |l, r| l.name == r.name)
-            },
-            _ => false,
-        };
-        (is_eq && (!self.should_ignore(left) || !self.should_ignore(right)))
-            || self.inner.expr_fallback.as_mut().map_or(false, |f| f(left, right))
-    }
-
-    fn eq_exprs(&mut self, left: &[Expr<'_>], right: &[Expr<'_>]) -> bool {
-        over(left, right, |l, r| self.eq_expr(l, r))
-    }
-
-    fn eq_expr_field(&mut self, left: &ExprField<'_>, right: &ExprField<'_>) -> bool {
-        left.ident.name == right.ident.name && self.eq_expr(left.expr, right.expr)
-    }
-
-    fn eq_guard(&mut self, left: &Guard<'_>, right: &Guard<'_>) -> bool {
-        match (left, right) {
-            (Guard::If(l), Guard::If(r)) => self.eq_expr(l, r),
-            (Guard::IfLet(l), Guard::IfLet(r)) => {
-                self.eq_pat(l.pat, r.pat) && both(&l.ty, &r.ty, |l, r| self.eq_ty(l, r)) && self.eq_expr(l.init, r.init)
-            },
-            _ => false,
-        }
-    }
-
-    fn eq_generic_arg(&mut self, left: &GenericArg<'_>, right: &GenericArg<'_>) -> bool {
-        match (left, right) {
-            (GenericArg::Const(l), GenericArg::Const(r)) => self.eq_body(l.value.body, r.value.body),
-            (GenericArg::Lifetime(l_lt), GenericArg::Lifetime(r_lt)) => Self::eq_lifetime(l_lt, r_lt),
-            (GenericArg::Type(l_ty), GenericArg::Type(r_ty)) => self.eq_ty(l_ty, r_ty),
-            (GenericArg::Infer(l_inf), GenericArg::Infer(r_inf)) => self.eq_ty(&l_inf.to_ty(), &r_inf.to_ty()),
-            _ => false,
-        }
-    }
-
-    fn eq_lifetime(left: &Lifetime, right: &Lifetime) -> bool {
-        left.res == right.res
-    }
-
-    fn eq_pat_field(&mut self, left: &PatField<'_>, right: &PatField<'_>) -> bool {
-        let (PatField { ident: li, pat: lp, .. }, PatField { ident: ri, pat: rp, .. }) = (&left, &right);
-        li.name == ri.name && self.eq_pat(lp, rp)
-    }
-
-    /// Checks whether two patterns are the same.
-    fn eq_pat(&mut self, left: &Pat<'_>, right: &Pat<'_>) -> bool {
-        match (&left.kind, &right.kind) {
-            (&PatKind::Box(l), &PatKind::Box(r)) => self.eq_pat(l, r),
-            (&PatKind::Struct(ref lp, la, ..), &PatKind::Struct(ref rp, ra, ..)) => {
-                self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat_field(l, r))
-            },
-            (&PatKind::TupleStruct(ref lp, la, ls), &PatKind::TupleStruct(ref rp, ra, rs)) => {
-                self.eq_qpath(lp, rp) && over(la, ra, |l, r| self.eq_pat(l, r)) && ls == rs
-            },
-            (&PatKind::Binding(lb, li, _, ref lp), &PatKind::Binding(rb, ri, _, ref rp)) => {
-                let eq = lb == rb && both(lp, rp, |l, r| self.eq_pat(l, r));
-                if eq {
-                    self.locals.insert(li, ri);
-                }
-                eq
-            },
-            (PatKind::Path(l), PatKind::Path(r)) => self.eq_qpath(l, r),
-            (&PatKind::Lit(l), &PatKind::Lit(r)) => self.eq_expr(l, r),
-            (&PatKind::Tuple(l, ls), &PatKind::Tuple(r, rs)) => ls == rs && over(l, r, |l, r| self.eq_pat(l, r)),
-            (&PatKind::Range(ref ls, ref le, li), &PatKind::Range(ref rs, ref re, ri)) => {
-                both(ls, rs, |a, b| self.eq_expr(a, b)) && both(le, re, |a, b| self.eq_expr(a, b)) && (li == ri)
-            },
-            (&PatKind::Ref(le, ref lm), &PatKind::Ref(re, ref rm)) => lm == rm && self.eq_pat(le, re),
-            (&PatKind::Slice(ls, ref li, le), &PatKind::Slice(rs, ref ri, re)) => {
-                over(ls, rs, |l, r| self.eq_pat(l, r))
-                    && over(le, re, |l, r| self.eq_pat(l, r))
-                    && both(li, ri, |l, r| self.eq_pat(l, r))
-            },
-            (&PatKind::Wild, &PatKind::Wild) => true,
-            _ => false,
-        }
-    }
-
-    #[expect(clippy::similar_names)]
-    fn eq_qpath(&mut self, left: &QPath<'_>, right: &QPath<'_>) -> bool {
-        match (left, right) {
-            (&QPath::Resolved(ref lty, lpath), &QPath::Resolved(ref rty, rpath)) => {
-                both(lty, rty, |l, r| self.eq_ty(l, r)) && self.eq_path(lpath, rpath)
-            },
-            (&QPath::TypeRelative(lty, lseg), &QPath::TypeRelative(rty, rseg)) => {
-                self.eq_ty(lty, rty) && self.eq_path_segment(lseg, rseg)
-            },
-            (&QPath::LangItem(llang_item, ..), &QPath::LangItem(rlang_item, ..)) => llang_item == rlang_item,
-            _ => false,
-        }
-    }
-
-    pub fn eq_path(&mut self, left: &Path<'_>, right: &Path<'_>) -> bool {
-        match (left.res, right.res) {
-            (Res::Local(l), Res::Local(r)) => l == r || self.locals.get(&l) == Some(&r),
-            (Res::Local(_), _) | (_, Res::Local(_)) => false,
-            _ => over(left.segments, right.segments, |l, r| self.eq_path_segment(l, r)),
-        }
-    }
-
-    fn eq_path_parameters(&mut self, left: &GenericArgs<'_>, right: &GenericArgs<'_>) -> bool {
-        if left.parenthesized == right.parenthesized {
-            over(left.args, right.args, |l, r| self.eq_generic_arg(l, r)) // FIXME(flip1995): may not work
-                && over(left.bindings, right.bindings, |l, r| self.eq_type_binding(l, r))
-        } else {
-            false
-        }
-    }
-
-    pub fn eq_path_segments(&mut self, left: &[PathSegment<'_>], right: &[PathSegment<'_>]) -> bool {
-        left.len() == right.len() && left.iter().zip(right).all(|(l, r)| self.eq_path_segment(l, r))
-    }
-
-    pub fn eq_path_segment(&mut self, left: &PathSegment<'_>, right: &PathSegment<'_>) -> bool {
-        // The == of idents doesn't work with different contexts,
-        // we have to be explicit about hygiene
-        left.ident.name == right.ident.name && both(&left.args, &right.args, |l, r| self.eq_path_parameters(l, r))
-    }
-
-    pub fn eq_ty(&mut self, left: &Ty<'_>, right: &Ty<'_>) -> bool {
-        match (&left.kind, &right.kind) {
-            (&TyKind::Slice(l_vec), &TyKind::Slice(r_vec)) => self.eq_ty(l_vec, r_vec),
-            (&TyKind::Array(lt, ll), &TyKind::Array(rt, rl)) => self.eq_ty(lt, rt) && self.eq_array_length(ll, rl),
-            (TyKind::Ptr(l_mut), TyKind::Ptr(r_mut)) => l_mut.mutbl == r_mut.mutbl && self.eq_ty(l_mut.ty, r_mut.ty),
-            (TyKind::Ref(_, l_rmut), TyKind::Ref(_, r_rmut)) => {
-                l_rmut.mutbl == r_rmut.mutbl && self.eq_ty(l_rmut.ty, r_rmut.ty)
-            },
-            (TyKind::Path(l), TyKind::Path(r)) => self.eq_qpath(l, r),
-            (&TyKind::Tup(l), &TyKind::Tup(r)) => over(l, r, |l, r| self.eq_ty(l, r)),
-            (&TyKind::Infer, &TyKind::Infer) => true,
-            _ => false,
-        }
-    }
-
-    fn eq_type_binding(&mut self, left: &TypeBinding<'_>, right: &TypeBinding<'_>) -> bool {
-        left.ident.name == right.ident.name && self.eq_ty(left.ty(), right.ty())
-    }
-
-    fn check_ctxt(&mut self, left: SyntaxContext, right: SyntaxContext) -> bool {
-        if self.left_ctxt == left && self.right_ctxt == right {
-            return true;
-        } else if self.left_ctxt == left || self.right_ctxt == right {
-            // Only one context has changed. This can only happen if the two nodes are written differently.
-            return false;
-        } else if left != SyntaxContext::root() {
-            let mut left_data = left.outer_expn_data();
-            let mut right_data = right.outer_expn_data();
-            loop {
-                use TokenKind::{BlockComment, LineComment, Whitespace};
-                if left_data.macro_def_id != right_data.macro_def_id
-                    || (matches!(
-                        left_data.kind,
-                        ExpnKind::Macro(MacroKind::Bang, name)
-                        if name == sym::cfg || name == sym::option_env
-                    ) && !eq_span_tokens(self.inner.cx, left_data.call_site, right_data.call_site, |t| {
-                        !matches!(t, Whitespace | LineComment { .. } | BlockComment { .. })
-                    }))
-                {
-                    // Either a different chain of macro calls, or different arguments to the `cfg` macro.
-                    return false;
-                }
-                let left_ctxt = left_data.call_site.ctxt();
-                let right_ctxt = right_data.call_site.ctxt();
-                if left_ctxt == SyntaxContext::root() && right_ctxt == SyntaxContext::root() {
-                    break;
-                }
-                if left_ctxt == SyntaxContext::root() || right_ctxt == SyntaxContext::root() {
-                    // Different lengths for the expansion stack. This can only happen if nodes are written differently,
-                    // or shouldn't be compared to start with.
-                    return false;
-                }
-                left_data = left_ctxt.outer_expn_data();
-                right_data = right_ctxt.outer_expn_data();
-            }
-        }
-        self.left_ctxt = left;
-        self.right_ctxt = right;
-        true
-    }
-}
-
-/// Some simple reductions like `{ return }` => `return`
-fn reduce_exprkind<'hir>(cx: &LateContext<'_>, kind: &'hir ExprKind<'hir>) -> &'hir ExprKind<'hir> {
-    if let ExprKind::Block(block, _) = kind {
-        match (block.stmts, block.expr) {
-            // From an `if let` expression without an `else` block. The arm for the implicit wild pattern is an empty
-            // block with an empty span.
-            ([], None) if block.span.is_empty() => &ExprKind::Tup(&[]),
-            // `{}` => `()`
-            ([], None) => match snippet_opt(cx, block.span) {
-                // Don't reduce if there are any tokens contained in the braces
-                Some(snip)
-                    if tokenize(&snip)
-                        .map(|t| t.kind)
-                        .filter(|t| {
-                            !matches!(
-                                t,
-                                TokenKind::LineComment { .. } | TokenKind::BlockComment { .. } | TokenKind::Whitespace
-                            )
-                        })
-                        .ne([TokenKind::OpenBrace, TokenKind::CloseBrace].iter().copied()) =>
-                {
-                    kind
-                },
-                _ => &ExprKind::Tup(&[]),
-            },
-            ([], Some(expr)) => match expr.kind {
-                // `{ return .. }` => `return ..`
-                ExprKind::Ret(..) => &expr.kind,
-                _ => kind,
-            },
-            ([stmt], None) => match stmt.kind {
-                StmtKind::Expr(expr) | StmtKind::Semi(expr) => match expr.kind {
-                    // `{ return ..; }` => `return ..`
-                    ExprKind::Ret(..) => &expr.kind,
-                    _ => kind,
-                },
-                _ => kind,
-            },
-            _ => kind,
-        }
-    } else {
-        kind
-    }
-}
-
-fn swap_binop<'a>(
-    binop: BinOpKind,
-    lhs: &'a Expr<'a>,
-    rhs: &'a Expr<'a>,
-) -> Option<(BinOpKind, &'a Expr<'a>, &'a Expr<'a>)> {
-    match binop {
-        BinOpKind::Add | BinOpKind::Eq | BinOpKind::Ne | BinOpKind::BitAnd | BinOpKind::BitXor | BinOpKind::BitOr => {
-            Some((binop, rhs, lhs))
-        },
-        BinOpKind::Lt => Some((BinOpKind::Gt, rhs, lhs)),
-        BinOpKind::Le => Some((BinOpKind::Ge, rhs, lhs)),
-        BinOpKind::Ge => Some((BinOpKind::Le, rhs, lhs)),
-        BinOpKind::Gt => Some((BinOpKind::Lt, rhs, lhs)),
-        BinOpKind::Mul // Not always commutative, e.g. with matrices. See issue #5698
-        | BinOpKind::Shl
-        | BinOpKind::Shr
-        | BinOpKind::Rem
-        | BinOpKind::Sub
-        | BinOpKind::Div
-        | BinOpKind::And
-        | BinOpKind::Or => None,
-    }
-}
-
-/// Checks if the two `Option`s are both `None` or some equal values as per
-/// `eq_fn`.
-pub fn both<X>(l: &Option<X>, r: &Option<X>, mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
-    l.as_ref()
-        .map_or_else(|| r.is_none(), |x| r.as_ref().map_or(false, |y| eq_fn(x, y)))
-}
-
-/// Checks if two slices are equal as per `eq_fn`.
-pub fn over<X>(left: &[X], right: &[X], mut eq_fn: impl FnMut(&X, &X) -> bool) -> bool {
-    left.len() == right.len() && left.iter().zip(right).all(|(x, y)| eq_fn(x, y))
-}
-
-/// Counts how many elements of the slices are equal as per `eq_fn`.
-pub fn count_eq<X: Sized>(
-    left: &mut dyn Iterator<Item = X>,
-    right: &mut dyn Iterator<Item = X>,
-    mut eq_fn: impl FnMut(&X, &X) -> bool,
-) -> usize {
-    left.zip(right).take_while(|(l, r)| eq_fn(l, r)).count()
-}
-
-/// Checks if two expressions evaluate to the same value, and don't contain any side effects.
-pub fn eq_expr_value(cx: &LateContext<'_>, left: &Expr<'_>, right: &Expr<'_>) -> bool {
-    SpanlessEq::new(cx).deny_side_effects().eq_expr(left, right)
-}
-
-/// Type used to hash an ast element. This is different from the `Hash` trait
-/// on ast types as this
-/// trait would consider IDs and spans.
-///
-/// All expressions kind are hashed, but some might have a weaker hash.
-pub struct SpanlessHash<'a, 'tcx> {
-    /// Context used to evaluate constant expressions.
-    cx: &'a LateContext<'tcx>,
-    maybe_typeck_results: Option<&'tcx TypeckResults<'tcx>>,
-    s: FxHasher,
-}
-
-impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
-    pub fn new(cx: &'a LateContext<'tcx>) -> Self {
-        Self {
-            cx,
-            maybe_typeck_results: cx.maybe_typeck_results(),
-            s: FxHasher::default(),
-        }
-    }
-
-    pub fn finish(self) -> u64 {
-        self.s.finish()
-    }
-
-    pub fn hash_block(&mut self, b: &Block<'_>) {
-        for s in b.stmts {
-            self.hash_stmt(s);
-        }
-
-        if let Some(e) = b.expr {
-            self.hash_expr(e);
-        }
-
-        std::mem::discriminant(&b.rules).hash(&mut self.s);
-    }
-
-    #[expect(clippy::too_many_lines)]
-    pub fn hash_expr(&mut self, e: &Expr<'_>) {
-        let simple_const = self
-            .maybe_typeck_results
-            .and_then(|typeck_results| constant_simple(self.cx, typeck_results, e));
-
-        // const hashing may result in the same hash as some unrelated node, so add a sort of
-        // discriminant depending on which path we're choosing next
-        simple_const.hash(&mut self.s);
-        if simple_const.is_some() {
-            return;
-        }
-
-        std::mem::discriminant(&e.kind).hash(&mut self.s);
-
-        match e.kind {
-            ExprKind::AddrOf(kind, m, e) => {
-                std::mem::discriminant(&kind).hash(&mut self.s);
-                m.hash(&mut self.s);
-                self.hash_expr(e);
-            },
-            ExprKind::Continue(i) => {
-                if let Some(i) = i.label {
-                    self.hash_name(i.ident.name);
-                }
-            },
-            ExprKind::Assign(l, r, _) => {
-                self.hash_expr(l);
-                self.hash_expr(r);
-            },
-            ExprKind::AssignOp(ref o, l, r) => {
-                std::mem::discriminant(&o.node).hash(&mut self.s);
-                self.hash_expr(l);
-                self.hash_expr(r);
-            },
-            ExprKind::Block(b, _) => {
-                self.hash_block(b);
-            },
-            ExprKind::Binary(op, l, r) => {
-                std::mem::discriminant(&op.node).hash(&mut self.s);
-                self.hash_expr(l);
-                self.hash_expr(r);
-            },
-            ExprKind::Break(i, ref j) => {
-                if let Some(i) = i.label {
-                    self.hash_name(i.ident.name);
-                }
-                if let Some(j) = *j {
-                    self.hash_expr(j);
-                }
-            },
-            ExprKind::DropTemps(e) | ExprKind::Yield(e, _) => {
-                self.hash_expr(e);
-            },
-            ExprKind::Call(fun, args) => {
-                self.hash_expr(fun);
-                self.hash_exprs(args);
-            },
-            ExprKind::Cast(e, ty) | ExprKind::Type(e, ty) => {
-                self.hash_expr(e);
-                self.hash_ty(ty);
-            },
-            ExprKind::Closure(&Closure {
-                capture_clause, body, ..
-            }) => {
-                std::mem::discriminant(&capture_clause).hash(&mut self.s);
-                // closures inherit TypeckResults
-                self.hash_expr(self.cx.tcx.hir().body(body).value);
-            },
-            ExprKind::Field(e, ref f) => {
-                self.hash_expr(e);
-                self.hash_name(f.name);
-            },
-            ExprKind::Index(a, i, _) => {
-                self.hash_expr(a);
-                self.hash_expr(i);
-            },
-            ExprKind::InlineAsm(asm) => {
-                for piece in asm.template {
-                    match piece {
-                        InlineAsmTemplatePiece::String(s) => s.hash(&mut self.s),
-                        InlineAsmTemplatePiece::Placeholder {
-                            operand_idx,
-                            modifier,
-                            span: _,
-                        } => {
-                            operand_idx.hash(&mut self.s);
-                            modifier.hash(&mut self.s);
-                        },
-                    }
-                }
-                asm.options.hash(&mut self.s);
-                for (op, _op_sp) in asm.operands {
-                    match op {
-                        InlineAsmOperand::In { reg, expr } => {
-                            reg.hash(&mut self.s);
-                            self.hash_expr(expr);
-                        },
-                        InlineAsmOperand::Out { reg, late, expr } => {
-                            reg.hash(&mut self.s);
-                            late.hash(&mut self.s);
-                            if let Some(expr) = expr {
-                                self.hash_expr(expr);
-                            }
-                        },
-                        InlineAsmOperand::InOut { reg, late, expr } => {
-                            reg.hash(&mut self.s);
-                            late.hash(&mut self.s);
-                            self.hash_expr(expr);
-                        },
-                        InlineAsmOperand::SplitInOut {
-                            reg,
-                            late,
-                            in_expr,
-                            out_expr,
-                        } => {
-                            reg.hash(&mut self.s);
-                            late.hash(&mut self.s);
-                            self.hash_expr(in_expr);
-                            if let Some(out_expr) = out_expr {
-                                self.hash_expr(out_expr);
-                            }
-                        },
-                        InlineAsmOperand::Const { anon_const } | InlineAsmOperand::SymFn { anon_const } => {
-                            self.hash_body(anon_const.body);
-                        },
-                        InlineAsmOperand::SymStatic { path, def_id: _ } => self.hash_qpath(path),
-                    }
-                }
-            },
-            ExprKind::OffsetOf(container, fields) => {
-                self.hash_ty(container);
-                for field in fields {
-                    self.hash_name(field.name);
-                }
-            },
-            ExprKind::Let(Let { pat, init, ty, .. }) => {
-                self.hash_expr(init);
-                if let Some(ty) = ty {
-                    self.hash_ty(ty);
-                }
-                self.hash_pat(pat);
-            },
-            ExprKind::Err(_) => {},
-            ExprKind::Lit(l) => {
-                l.node.hash(&mut self.s);
-            },
-            ExprKind::Loop(b, ref i, ..) => {
-                self.hash_block(b);
-                if let Some(i) = *i {
-                    self.hash_name(i.ident.name);
-                }
-            },
-            ExprKind::If(cond, then, ref else_opt) => {
-                self.hash_expr(cond);
-                self.hash_expr(then);
-                if let Some(e) = *else_opt {
-                    self.hash_expr(e);
-                }
-            },
-            ExprKind::Match(e, arms, ref s) => {
-                self.hash_expr(e);
-
-                for arm in arms {
-                    self.hash_pat(arm.pat);
-                    if let Some(ref e) = arm.guard {
-                        self.hash_guard(e);
-                    }
-                    self.hash_expr(arm.body);
-                }
-
-                s.hash(&mut self.s);
-            },
-            ExprKind::MethodCall(path, receiver, args, ref _fn_span) => {
-                self.hash_name(path.ident.name);
-                self.hash_expr(receiver);
-                self.hash_exprs(args);
-            },
-            ExprKind::ConstBlock(ref l_id) => {
-                self.hash_body(l_id.body);
-            },
-            ExprKind::Repeat(e, len) => {
-                self.hash_expr(e);
-                self.hash_array_length(len);
-            },
-            ExprKind::Ret(ref e) => {
-                if let Some(e) = *e {
-                    self.hash_expr(e);
-                }
-            },
-            ExprKind::Become(f) => {
-                self.hash_expr(f);
-            },
-            ExprKind::Path(ref qpath) => {
-                self.hash_qpath(qpath);
-            },
-            ExprKind::Struct(path, fields, ref expr) => {
-                self.hash_qpath(path);
-
-                for f in fields {
-                    self.hash_name(f.ident.name);
-                    self.hash_expr(f.expr);
-                }
-
-                if let Some(e) = *expr {
-                    self.hash_expr(e);
-                }
-            },
-            ExprKind::Tup(tup) => {
-                self.hash_exprs(tup);
-            },
-            ExprKind::Array(v) => {
-                self.hash_exprs(v);
-            },
-            ExprKind::Unary(lop, le) => {
-                std::mem::discriminant(&lop).hash(&mut self.s);
-                self.hash_expr(le);
-            },
-        }
-    }
-
-    pub fn hash_exprs(&mut self, e: &[Expr<'_>]) {
-        for e in e {
-            self.hash_expr(e);
-        }
-    }
-
-    pub fn hash_name(&mut self, n: Symbol) {
-        n.hash(&mut self.s);
-    }
-
-    pub fn hash_qpath(&mut self, p: &QPath<'_>) {
-        match *p {
-            QPath::Resolved(_, path) => {
-                self.hash_path(path);
-            },
-            QPath::TypeRelative(_, path) => {
-                self.hash_name(path.ident.name);
-            },
-            QPath::LangItem(lang_item, ..) => {
-                std::mem::discriminant(&lang_item).hash(&mut self.s);
-            },
-        }
-        // self.maybe_typeck_results.unwrap().qpath_res(p, id).hash(&mut self.s);
-    }
-
-    pub fn hash_pat(&mut self, pat: &Pat<'_>) {
-        std::mem::discriminant(&pat.kind).hash(&mut self.s);
-        match pat.kind {
-            PatKind::Binding(BindingAnnotation(by_ref, mutability), _, _, pat) => {
-                std::mem::discriminant(&by_ref).hash(&mut self.s);
-                std::mem::discriminant(&mutability).hash(&mut self.s);
-                if let Some(pat) = pat {
-                    self.hash_pat(pat);
-                }
-            },
-            PatKind::Box(pat) => self.hash_pat(pat),
-            PatKind::Lit(expr) => self.hash_expr(expr),
-            PatKind::Or(pats) => {
-                for pat in pats {
-                    self.hash_pat(pat);
-                }
-            },
-            PatKind::Path(ref qpath) => self.hash_qpath(qpath),
-            PatKind::Range(s, e, i) => {
-                if let Some(s) = s {
-                    self.hash_expr(s);
-                }
-                if let Some(e) = e {
-                    self.hash_expr(e);
-                }
-                std::mem::discriminant(&i).hash(&mut self.s);
-            },
-            PatKind::Ref(pat, mu) => {
-                self.hash_pat(pat);
-                std::mem::discriminant(&mu).hash(&mut self.s);
-            },
-            PatKind::Slice(l, m, r) => {
-                for pat in l {
-                    self.hash_pat(pat);
-                }
-                if let Some(pat) = m {
-                    self.hash_pat(pat);
-                }
-                for pat in r {
-                    self.hash_pat(pat);
-                }
-            },
-            PatKind::Struct(ref qpath, fields, e) => {
-                self.hash_qpath(qpath);
-                for f in fields {
-                    self.hash_name(f.ident.name);
-                    self.hash_pat(f.pat);
-                }
-                e.hash(&mut self.s);
-            },
-            PatKind::Tuple(pats, e) => {
-                for pat in pats {
-                    self.hash_pat(pat);
-                }
-                e.hash(&mut self.s);
-            },
-            PatKind::TupleStruct(ref qpath, pats, e) => {
-                self.hash_qpath(qpath);
-                for pat in pats {
-                    self.hash_pat(pat);
-                }
-                e.hash(&mut self.s);
-            },
-            PatKind::Wild => {},
-        }
-    }
-
-    pub fn hash_path(&mut self, path: &Path<'_>) {
-        match path.res {
-            // constant hash since equality is dependant on inter-expression context
-            // e.g. The expressions `if let Some(x) = foo() {}` and `if let Some(y) = foo() {}` are considered equal
-            // even though the binding names are different and they have different `HirId`s.
-            Res::Local(_) => 1_usize.hash(&mut self.s),
-            _ => {
-                for seg in path.segments {
-                    self.hash_name(seg.ident.name);
-                    self.hash_generic_args(seg.args().args);
-                }
-            },
-        }
-    }
-
-    pub fn hash_stmt(&mut self, b: &Stmt<'_>) {
-        std::mem::discriminant(&b.kind).hash(&mut self.s);
-
-        match &b.kind {
-            StmtKind::Local(local) => {
-                self.hash_pat(local.pat);
-                if let Some(init) = local.init {
-                    self.hash_expr(init);
-                }
-                if let Some(els) = local.els {
-                    self.hash_block(els);
-                }
-            },
-            StmtKind::Item(..) => {},
-            StmtKind::Expr(expr) | StmtKind::Semi(expr) => {
-                self.hash_expr(expr);
-            },
-        }
-    }
-
-    pub fn hash_guard(&mut self, g: &Guard<'_>) {
-        match g {
-            Guard::If(expr) | Guard::IfLet(Let { init: expr, .. }) => {
-                self.hash_expr(expr);
-            },
-        }
-    }
-
-    pub fn hash_lifetime(&mut self, lifetime: &Lifetime) {
-        lifetime.ident.name.hash(&mut self.s);
-        std::mem::discriminant(&lifetime.res).hash(&mut self.s);
-        if let LifetimeName::Param(param_id) = lifetime.res {
-            param_id.hash(&mut self.s);
-        }
-    }
-
-    pub fn hash_ty(&mut self, ty: &Ty<'_>) {
-        std::mem::discriminant(&ty.kind).hash(&mut self.s);
-        self.hash_tykind(&ty.kind);
-    }
-
-    pub fn hash_tykind(&mut self, ty: &TyKind<'_>) {
-        match ty {
-            TyKind::Slice(ty) => {
-                self.hash_ty(ty);
-            },
-            &TyKind::Array(ty, len) => {
-                self.hash_ty(ty);
-                self.hash_array_length(len);
-            },
-            TyKind::Ptr(ref mut_ty) => {
-                self.hash_ty(mut_ty.ty);
-                mut_ty.mutbl.hash(&mut self.s);
-            },
-            TyKind::Ref(lifetime, ref mut_ty) => {
-                self.hash_lifetime(lifetime);
-                self.hash_ty(mut_ty.ty);
-                mut_ty.mutbl.hash(&mut self.s);
-            },
-            TyKind::BareFn(bfn) => {
-                bfn.unsafety.hash(&mut self.s);
-                bfn.abi.hash(&mut self.s);
-                for arg in bfn.decl.inputs {
-                    self.hash_ty(arg);
-                }
-                std::mem::discriminant(&bfn.decl.output).hash(&mut self.s);
-                match bfn.decl.output {
-                    FnRetTy::DefaultReturn(_) => {},
-                    FnRetTy::Return(ty) => {
-                        self.hash_ty(ty);
-                    },
-                }
-                bfn.decl.c_variadic.hash(&mut self.s);
-            },
-            TyKind::Tup(ty_list) => {
-                for ty in *ty_list {
-                    self.hash_ty(ty);
-                }
-            },
-            TyKind::Path(ref qpath) => self.hash_qpath(qpath),
-            TyKind::OpaqueDef(_, arg_list, in_trait) => {
-                self.hash_generic_args(arg_list);
-                in_trait.hash(&mut self.s);
-            },
-            TyKind::TraitObject(_, lifetime, _) => {
-                self.hash_lifetime(lifetime);
-            },
-            TyKind::Typeof(anon_const) => {
-                self.hash_body(anon_const.body);
-            },
-            TyKind::Err(_) | TyKind::Infer | TyKind::Never => {},
-        }
-    }
-
-    pub fn hash_array_length(&mut self, length: ArrayLen) {
-        match length {
-            ArrayLen::Infer(..) => {},
-            ArrayLen::Body(anon_const) => self.hash_body(anon_const.body),
-        }
-    }
-
-    pub fn hash_body(&mut self, body_id: BodyId) {
-        // swap out TypeckResults when hashing a body
-        let old_maybe_typeck_results = self.maybe_typeck_results.replace(self.cx.tcx.typeck_body(body_id));
-        self.hash_expr(self.cx.tcx.hir().body(body_id).value);
-        self.maybe_typeck_results = old_maybe_typeck_results;
-    }
-
-    fn hash_generic_args(&mut self, arg_list: &[GenericArg<'_>]) {
-        for arg in arg_list {
-            match *arg {
-                GenericArg::Lifetime(l) => self.hash_lifetime(l),
-                GenericArg::Type(ty) => self.hash_ty(ty),
-                GenericArg::Const(ref ca) => self.hash_body(ca.value.body),
-                GenericArg::Infer(ref inf) => self.hash_ty(&inf.to_ty()),
-            }
-        }
-    }
-}
-
-pub fn hash_stmt(cx: &LateContext<'_>, s: &Stmt<'_>) -> u64 {
-    let mut h = SpanlessHash::new(cx);
-    h.hash_stmt(s);
-    h.finish()
-}
-
-pub fn is_bool(ty: &Ty<'_>) -> bool {
-    if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
-        matches!(path.res, Res::PrimTy(PrimTy::Bool))
-    } else {
-        false
-    }
-}
-
-pub fn hash_expr(cx: &LateContext<'_>, e: &Expr<'_>) -> u64 {
-    let mut h = SpanlessHash::new(cx);
-    h.hash_expr(e);
-    h.finish()
-}
-
-#[expect(clippy::similar_names)]
-fn eq_span_tokens(
-    cx: &LateContext<'_>,
-    left: impl SpanRange,
-    right: impl SpanRange,
-    pred: impl Fn(TokenKind) -> bool,
-) -> bool {
-    fn f(cx: &LateContext<'_>, left: Range<BytePos>, right: Range<BytePos>, pred: impl Fn(TokenKind) -> bool) -> bool {
-        if let Some(lsrc) = get_source_text(cx, left)
-            && let Some(lsrc) = lsrc.as_str()
-            && let Some(rsrc) = get_source_text(cx, right)
-            && let Some(rsrc) = rsrc.as_str()
-        {
-            let pred = |t: &(_, _)| pred(t.0);
-            let map = |(_, x)| x;
-
-            let ltok = tokenize_with_text(lsrc)
-                .filter(pred)
-                .map(map);
-            let rtok = tokenize_with_text(rsrc)
-                .filter(pred)
-                .map(map);
-            ltok.eq(rtok)
-        } else {
-            // Unable to access the source. Conservatively assume the blocks aren't equal.
-            false
-        }
-    }
-    f(cx, left.into_range(), right.into_range(), pred)
-}
diff --git a/scout-audit-clippy-utils/src/lib.rs b/scout-audit-clippy-utils/src/lib.rs
deleted file mode 100644
index 0f7bc04c..00000000
--- a/scout-audit-clippy-utils/src/lib.rs
+++ /dev/null
@@ -1,2915 +0,0 @@
-#![feature(array_chunks)]
-#![feature(box_patterns)]
-#![feature(if_let_guard)]
-#![feature(let_chains)]
-#![feature(lint_reasons)]
-#![feature(never_type)]
-#![feature(rustc_private)]
-#![feature(assert_matches)]
-#![recursion_limit = "512"]
-#![cfg_attr(feature = "deny-warnings", deny(warnings))]
-#![allow(clippy::missing_errors_doc, clippy::missing_panics_doc, clippy::must_use_candidate)]
-// warn on the same lints as `clippy_lints`
-#![warn(trivial_casts, trivial_numeric_casts)]
-// warn on lints, that are included in `rust-lang/rust`s bootstrap
-#![warn(rust_2018_idioms, unused_lifetimes)]
-// warn on rustc internal lints
-#![warn(rustc::internal)]
-
-// FIXME: switch to something more ergonomic here, once available.
-// (Currently there is no way to opt into sysroot crates without `extern crate`.)
-extern crate rustc_ast;
-extern crate rustc_ast_pretty;
-extern crate rustc_attr;
-extern crate rustc_const_eval;
-extern crate rustc_data_structures;
-// The `rustc_driver` crate seems to be required in order to use the `rust_ast` crate.
-#[allow(unused_extern_crates)]
-extern crate rustc_driver;
-extern crate rustc_errors;
-extern crate rustc_hir;
-extern crate rustc_hir_typeck;
-extern crate rustc_index;
-extern crate rustc_infer;
-extern crate rustc_lexer;
-extern crate rustc_lint;
-extern crate rustc_middle;
-extern crate rustc_mir_dataflow;
-extern crate rustc_session;
-extern crate rustc_span;
-extern crate rustc_target;
-extern crate rustc_trait_selection;
-
-#[macro_use]
-pub mod sym_helper;
-
-pub mod ast_utils;
-pub mod attrs;
-mod check_proc_macro;
-pub mod comparisons;
-pub mod consts;
-pub mod diagnostics;
-pub mod eager_or_lazy;
-pub mod higher;
-mod hir_utils;
-pub mod macros;
-pub mod mir;
-pub mod msrvs;
-pub mod numeric_literal;
-pub mod paths;
-pub mod ptr;
-pub mod qualify_min_const_fn;
-pub mod source;
-pub mod str_utils;
-pub mod sugg;
-pub mod ty;
-pub mod usage;
-pub mod visitors;
-
-pub use self::attrs::*;
-pub use self::check_proc_macro::{is_from_proc_macro, is_span_if, is_span_match};
-pub use self::hir_utils::{
-    both, count_eq, eq_expr_value, hash_expr, hash_stmt, is_bool, over, HirEqInterExpr, SpanlessEq, SpanlessHash,
-};
-
-use core::ops::ControlFlow;
-use std::collections::hash_map::Entry;
-use std::hash::BuildHasherDefault;
-use std::sync::{Mutex, MutexGuard, OnceLock};
-
-use if_chain::if_chain;
-use itertools::Itertools;
-use rustc_ast::ast::{self, LitKind, RangeLimits};
-use rustc_ast::Attribute;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_data_structures::unhash::UnhashMap;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LocalModDefId, LOCAL_CRATE};
-use rustc_hir::hir_id::{HirIdMap, HirIdSet};
-use rustc_hir::intravisit::{walk_expr, FnKind, Visitor};
-use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr, ResultOk};
-use rustc_hir::{
-    self as hir, def, Arm, ArrayLen, BindingAnnotation, Block, BlockCheckMode, Body, Closure, Destination, Expr,
-    ExprField, ExprKind, FnDecl, FnRetTy, GenericArgs, HirId, Impl, ImplItem, ImplItemKind, ImplItemRef, Item,
-    ItemKind, LangItem, Local, MatchSource, Mutability, Node, OwnerId, Param, Pat, PatKind, Path, PathSegment, PrimTy,
-    QPath, Stmt, StmtKind, TraitItem, TraitItemKind, TraitItemRef, TraitRef, TyKind, UnOp,
-};
-use rustc_lexer::{tokenize, TokenKind};
-use rustc_lint::{LateContext, Level, Lint, LintContext};
-use rustc_middle::hir::place::PlaceBase;
-use rustc_middle::mir::Const;
-use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
-use rustc_middle::ty::binding::BindingMode;
-use rustc_middle::ty::fast_reject::SimplifiedType;
-use rustc_middle::ty::layout::IntegerExt;
-use rustc_middle::ty::{
-    self as rustc_ty, Binder, BorrowKind, ClosureKind, FloatTy, IntTy, ParamEnv, ParamEnvAnd, Ty, TyCtxt, TypeAndMut,
-    TypeVisitableExt, UintTy, UpvarCapture,
-};
-use rustc_span::hygiene::{ExpnKind, MacroKind};
-use rustc_span::source_map::SourceMap;
-use rustc_span::symbol::{kw, Ident, Symbol};
-use rustc_span::{sym, Span};
-use rustc_target::abi::Integer;
-use visitors::Visitable;
-
-use crate::consts::{constant, miri_to_const, Constant};
-use crate::higher::Range;
-use crate::ty::{
-    adt_and_variant_of_res, can_partially_move_ty, expr_sig, is_copy, is_recursively_primitive_type,
-    ty_is_fn_once_param,
-};
-use crate::visitors::for_each_expr;
-
-use rustc_middle::hir::nested_filter;
-
-#[macro_export]
-macro_rules! extract_msrv_attr {
-    ($context:ident) => {
-        fn enter_lint_attrs(&mut self, cx: &rustc_lint::$context<'_>, attrs: &[rustc_ast::ast::Attribute]) {
-            let sess = rustc_lint::LintContext::sess(cx);
-            self.msrv.enter_lint_attrs(sess, attrs);
-        }
-
-        fn exit_lint_attrs(&mut self, cx: &rustc_lint::$context<'_>, attrs: &[rustc_ast::ast::Attribute]) {
-            let sess = rustc_lint::LintContext::sess(cx);
-            self.msrv.exit_lint_attrs(sess, attrs);
-        }
-    };
-}
-
-/// If the given expression is a local binding, find the initializer expression.
-/// If that initializer expression is another local binding, find its initializer again.
-/// This process repeats as long as possible (but usually no more than once). Initializer
-/// expressions with adjustments are ignored. If this is not desired, use [`find_binding_init`]
-/// instead.
-///
-/// Examples:
-/// ```
-/// let abc = 1;
-/// //        ^ output
-/// let def = abc;
-/// dbg!(def);
-/// //   ^^^ input
-///
-/// // or...
-/// let abc = 1;
-/// let def = abc + 2;
-/// //        ^^^^^^^ output
-/// dbg!(def);
-/// //   ^^^ input
-/// ```
-pub fn expr_or_init<'a, 'b, 'tcx: 'b>(cx: &LateContext<'tcx>, mut expr: &'a Expr<'b>) -> &'a Expr<'b> {
-    while let Some(init) = path_to_local(expr)
-        .and_then(|id| find_binding_init(cx, id))
-        .filter(|init| cx.typeck_results().expr_adjustments(init).is_empty())
-    {
-        expr = init;
-    }
-    expr
-}
-
-/// Finds the initializer expression for a local binding. Returns `None` if the binding is mutable.
-/// By only considering immutable bindings, we guarantee that the returned expression represents the
-/// value of the binding wherever it is referenced.
-///
-/// Example: For `let x = 1`, if the `HirId` of `x` is provided, the `Expr` `1` is returned.
-/// Note: If you have an expression that references a binding `x`, use `path_to_local` to get the
-/// canonical binding `HirId`.
-pub fn find_binding_init<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Expr<'tcx>> {
-    let hir = cx.tcx.hir();
-    if_chain! {
-        if let Some(Node::Pat(pat)) = hir.find(hir_id);
-        if matches!(pat.kind, PatKind::Binding(BindingAnnotation::NONE, ..));
-        let parent = hir.parent_id(hir_id);
-        if let Some(Node::Local(local)) = hir.find(parent);
-        then {
-            return local.init;
-        }
-    }
-    None
-}
-
-/// Returns `true` if the given `NodeId` is inside a constant context
-///
-/// # Example
-///
-/// ```rust,ignore
-/// if in_constant(cx, expr.hir_id) {
-///     // Do something
-/// }
-/// ```
-pub fn in_constant(cx: &LateContext<'_>, id: HirId) -> bool {
-    cx.tcx.hir().is_inside_const_context(id)
-}
-
-/// Checks if a `Res` refers to a constructor of a `LangItem`
-/// For example, use this to check whether a function call or a pattern is `Some(..)`.
-pub fn is_res_lang_ctor(cx: &LateContext<'_>, res: Res, lang_item: LangItem) -> bool {
-    if let Res::Def(DefKind::Ctor(..), id) = res
-        && let Some(lang_id) = cx.tcx.lang_items().get(lang_item)
-        && let Some(id) = cx.tcx.opt_parent(id)
-    {
-        id == lang_id
-    } else {
-        false
-    }
-}
-
-pub fn is_res_diagnostic_ctor(cx: &LateContext<'_>, res: Res, diag_item: Symbol) -> bool {
-    if let Res::Def(DefKind::Ctor(..), id) = res
-        && let Some(id) = cx.tcx.opt_parent(id)
-    {
-        cx.tcx.is_diagnostic_item(diag_item, id)
-    } else {
-        false
-    }
-}
-
-/// Checks if a `QPath` resolves to a constructor of a diagnostic item.
-pub fn is_diagnostic_ctor(cx: &LateContext<'_>, qpath: &QPath<'_>, diagnostic_item: Symbol) -> bool {
-    if let QPath::Resolved(_, path) = qpath {
-        if let Res::Def(DefKind::Ctor(..), ctor_id) = path.res {
-            return cx.tcx.is_diagnostic_item(diagnostic_item, cx.tcx.parent(ctor_id));
-        }
-    }
-    false
-}
-
-/// Checks if the `DefId` matches the given diagnostic item or it's constructor.
-pub fn is_diagnostic_item_or_ctor(cx: &LateContext<'_>, did: DefId, item: Symbol) -> bool {
-    let did = match cx.tcx.def_kind(did) {
-        DefKind::Ctor(..) => cx.tcx.parent(did),
-        // Constructors for types in external crates seem to have `DefKind::Variant`
-        DefKind::Variant => match cx.tcx.opt_parent(did) {
-            Some(did) if matches!(cx.tcx.def_kind(did), DefKind::Variant) => did,
-            _ => did,
-        },
-        _ => did,
-    };
-
-    cx.tcx.is_diagnostic_item(item, did)
-}
-
-/// Checks if the `DefId` matches the given `LangItem` or it's constructor.
-pub fn is_lang_item_or_ctor(cx: &LateContext<'_>, did: DefId, item: LangItem) -> bool {
-    let did = match cx.tcx.def_kind(did) {
-        DefKind::Ctor(..) => cx.tcx.parent(did),
-        // Constructors for types in external crates seem to have `DefKind::Variant`
-        DefKind::Variant => match cx.tcx.opt_parent(did) {
-            Some(did) if matches!(cx.tcx.def_kind(did), DefKind::Variant) => did,
-            _ => did,
-        },
-        _ => did,
-    };
-
-    cx.tcx.lang_items().get(item) == Some(did)
-}
-
-pub fn is_unit_expr(expr: &Expr<'_>) -> bool {
-    matches!(
-        expr.kind,
-        ExprKind::Block(
-            Block {
-                stmts: [],
-                expr: None,
-                ..
-            },
-            _
-        ) | ExprKind::Tup([])
-    )
-}
-
-/// Checks if given pattern is a wildcard (`_`)
-pub fn is_wild(pat: &Pat<'_>) -> bool {
-    matches!(pat.kind, PatKind::Wild)
-}
-
-/// Checks if the given `QPath` belongs to a type alias.
-pub fn is_ty_alias(qpath: &QPath<'_>) -> bool {
-    match *qpath {
-        QPath::Resolved(_, path) => matches!(path.res, Res::Def(DefKind::TyAlias { .. } | DefKind::AssocTy, ..)),
-        QPath::TypeRelative(ty, _) if let TyKind::Path(qpath) = ty.kind => { is_ty_alias(&qpath) },
-        _ => false,
-    }
-}
-
-/// Checks if the method call given in `expr` belongs to the given trait.
-/// This is a deprecated function, consider using [`is_trait_method`].
-pub fn match_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, path: &[&str]) -> bool {
-    let def_id = cx.typeck_results().type_dependent_def_id(expr.hir_id).unwrap();
-    let trt_id = cx.tcx.trait_of_item(def_id);
-    trt_id.map_or(false, |trt_id| match_def_path(cx, trt_id, path))
-}
-
-/// Checks if a method is defined in an impl of a diagnostic item
-pub fn is_diag_item_method(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
-    if let Some(impl_did) = cx.tcx.impl_of_method(def_id) {
-        if let Some(adt) = cx.tcx.type_of(impl_did).instantiate_identity().ty_adt_def() {
-            return cx.tcx.is_diagnostic_item(diag_item, adt.did());
-        }
-    }
-    false
-}
-
-/// Checks if a method is in a diagnostic item trait
-pub fn is_diag_trait_item(cx: &LateContext<'_>, def_id: DefId, diag_item: Symbol) -> bool {
-    if let Some(trait_did) = cx.tcx.trait_of_item(def_id) {
-        return cx.tcx.is_diagnostic_item(diag_item, trait_did);
-    }
-    false
-}
-
-/// Checks if the method call given in `expr` belongs to the given trait.
-pub fn is_trait_method(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
-    cx.typeck_results()
-        .type_dependent_def_id(expr.hir_id)
-        .map_or(false, |did| is_diag_trait_item(cx, did, diag_item))
-}
-
-/// Checks if the `def_id` belongs to a function that is part of a trait impl.
-pub fn is_def_id_trait_method(cx: &LateContext<'_>, def_id: LocalDefId) -> bool {
-    if let Some(hir_id) = cx.tcx.opt_local_def_id_to_hir_id(def_id)
-        && let Node::Item(item) = cx.tcx.hir().get_parent(hir_id)
-        && let ItemKind::Impl(imp) = item.kind
-    {
-        imp.of_trait.is_some()
-    } else {
-        false
-    }
-}
-
-/// Checks if the given expression is a path referring an item on the trait
-/// that is marked with the given diagnostic item.
-///
-/// For checking method call expressions instead of path expressions, use
-/// [`is_trait_method`].
-///
-/// For example, this can be used to find if an expression like `u64::default`
-/// refers to an item of the trait `Default`, which is associated with the
-/// `diag_item` of `sym::Default`.
-pub fn is_trait_item(cx: &LateContext<'_>, expr: &Expr<'_>, diag_item: Symbol) -> bool {
-    if let hir::ExprKind::Path(ref qpath) = expr.kind {
-        cx.qpath_res(qpath, expr.hir_id)
-            .opt_def_id()
-            .map_or(false, |def_id| is_diag_trait_item(cx, def_id, diag_item))
-    } else {
-        false
-    }
-}
-
-pub fn last_path_segment<'tcx>(path: &QPath<'tcx>) -> &'tcx PathSegment<'tcx> {
-    match *path {
-        QPath::Resolved(_, path) => path.segments.last().expect("A path must have at least one segment"),
-        QPath::TypeRelative(_, seg) => seg,
-        QPath::LangItem(..) => panic!("last_path_segment: lang item has no path segments"),
-    }
-}
-
-pub fn qpath_generic_tys<'tcx>(qpath: &QPath<'tcx>) -> impl Iterator<Item = &'tcx hir::Ty<'tcx>> {
-    last_path_segment(qpath)
-        .args
-        .map_or(&[][..], |a| a.args)
-        .iter()
-        .filter_map(|a| match a {
-            hir::GenericArg::Type(ty) => Some(*ty),
-            _ => None,
-        })
-}
-
-/// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
-/// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
-/// `QPath::Resolved.1.res.opt_def_id()`.
-///
-/// Matches a `QPath` against a slice of segment string literals.
-///
-/// There is also `match_path` if you are dealing with a `rustc_hir::Path` instead of a
-/// `rustc_hir::QPath`.
-///
-/// # Examples
-/// ```rust,ignore
-/// match_qpath(path, &["std", "rt", "begin_unwind"])
-/// ```
-pub fn match_qpath(path: &QPath<'_>, segments: &[&str]) -> bool {
-    match *path {
-        QPath::Resolved(_, path) => match_path(path, segments),
-        QPath::TypeRelative(ty, segment) => match ty.kind {
-            TyKind::Path(ref inner_path) => {
-                if let [prefix @ .., end] = segments {
-                    if match_qpath(inner_path, prefix) {
-                        return segment.ident.name.as_str() == *end;
-                    }
-                }
-                false
-            },
-            _ => false,
-        },
-        QPath::LangItem(..) => false,
-    }
-}
-
-/// If the expression is a path, resolves it to a `DefId` and checks if it matches the given path.
-///
-/// Please use `is_path_diagnostic_item` if the target is a diagnostic item.
-pub fn is_expr_path_def_path(cx: &LateContext<'_>, expr: &Expr<'_>, segments: &[&str]) -> bool {
-    path_def_id(cx, expr).map_or(false, |id| match_def_path(cx, id, segments))
-}
-
-/// If `maybe_path` is a path node which resolves to an item, resolves it to a `DefId` and checks if
-/// it matches the given lang item.
-pub fn is_path_lang_item<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>, lang_item: LangItem) -> bool {
-    path_def_id(cx, maybe_path).map_or(false, |id| cx.tcx.lang_items().get(lang_item) == Some(id))
-}
-
-/// If `maybe_path` is a path node which resolves to an item, resolves it to a `DefId` and checks if
-/// it matches the given diagnostic item.
-pub fn is_path_diagnostic_item<'tcx>(
-    cx: &LateContext<'_>,
-    maybe_path: &impl MaybePath<'tcx>,
-    diag_item: Symbol,
-) -> bool {
-    path_def_id(cx, maybe_path).map_or(false, |id| cx.tcx.is_diagnostic_item(diag_item, id))
-}
-
-/// THIS METHOD IS DEPRECATED and will eventually be removed since it does not match against the
-/// entire path or resolved `DefId`. Prefer using `match_def_path`. Consider getting a `DefId` from
-/// `QPath::Resolved.1.res.opt_def_id()`.
-///
-/// Matches a `Path` against a slice of segment string literals.
-///
-/// There is also `match_qpath` if you are dealing with a `rustc_hir::QPath` instead of a
-/// `rustc_hir::Path`.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// if match_path(&trait_ref.path, &paths::HASH) {
-///     // This is the `std::hash::Hash` trait.
-/// }
-///
-/// if match_path(ty_path, &["rustc", "lint", "Lint"]) {
-///     // This is a `rustc_middle::lint::Lint`.
-/// }
-/// ```
-pub fn match_path(path: &Path<'_>, segments: &[&str]) -> bool {
-    path.segments
-        .iter()
-        .rev()
-        .zip(segments.iter().rev())
-        .all(|(a, b)| a.ident.name.as_str() == *b)
-}
-
-/// If the expression is a path to a local, returns the canonical `HirId` of the local.
-pub fn path_to_local(expr: &Expr<'_>) -> Option<HirId> {
-    if let ExprKind::Path(QPath::Resolved(None, path)) = expr.kind {
-        if let Res::Local(id) = path.res {
-            return Some(id);
-        }
-    }
-    None
-}
-
-/// Returns true if the expression is a path to a local with the specified `HirId`.
-/// Use this function to see if an expression matches a function argument or a match binding.
-pub fn path_to_local_id(expr: &Expr<'_>, id: HirId) -> bool {
-    path_to_local(expr) == Some(id)
-}
-
-pub trait MaybePath<'hir> {
-    fn hir_id(&self) -> HirId;
-    fn qpath_opt(&self) -> Option<&QPath<'hir>>;
-}
-
-macro_rules! maybe_path {
-    ($ty:ident, $kind:ident) => {
-        impl<'hir> MaybePath<'hir> for hir::$ty<'hir> {
-            fn hir_id(&self) -> HirId {
-                self.hir_id
-            }
-            fn qpath_opt(&self) -> Option<&QPath<'hir>> {
-                match &self.kind {
-                    hir::$kind::Path(qpath) => Some(qpath),
-                    _ => None,
-                }
-            }
-        }
-    };
-}
-maybe_path!(Expr, ExprKind);
-maybe_path!(Pat, PatKind);
-maybe_path!(Ty, TyKind);
-
-/// If `maybe_path` is a path node, resolves it, otherwise returns `Res::Err`
-pub fn path_res<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>) -> Res {
-    match maybe_path.qpath_opt() {
-        None => Res::Err,
-        Some(qpath) => cx.qpath_res(qpath, maybe_path.hir_id()),
-    }
-}
-
-/// If `maybe_path` is a path node which resolves to an item, retrieves the item ID
-pub fn path_def_id<'tcx>(cx: &LateContext<'_>, maybe_path: &impl MaybePath<'tcx>) -> Option<DefId> {
-    path_res(cx, maybe_path).opt_def_id()
-}
-
-fn find_primitive_impls<'tcx>(tcx: TyCtxt<'tcx>, name: &str) -> impl Iterator<Item = DefId> + 'tcx {
-    let ty = match name {
-        "bool" => SimplifiedType::Bool,
-        "char" => SimplifiedType::Char,
-        "str" => SimplifiedType::Str,
-        "array" => SimplifiedType::Array,
-        "slice" => SimplifiedType::Slice,
-        // FIXME: rustdoc documents these two using just `pointer`.
-        //
-        // Maybe this is something we should do here too.
-        "const_ptr" => SimplifiedType::Ptr(Mutability::Not),
-        "mut_ptr" => SimplifiedType::Ptr(Mutability::Mut),
-        "isize" => SimplifiedType::Int(IntTy::Isize),
-        "i8" => SimplifiedType::Int(IntTy::I8),
-        "i16" => SimplifiedType::Int(IntTy::I16),
-        "i32" => SimplifiedType::Int(IntTy::I32),
-        "i64" => SimplifiedType::Int(IntTy::I64),
-        "i128" => SimplifiedType::Int(IntTy::I128),
-        "usize" => SimplifiedType::Uint(UintTy::Usize),
-        "u8" => SimplifiedType::Uint(UintTy::U8),
-        "u16" => SimplifiedType::Uint(UintTy::U16),
-        "u32" => SimplifiedType::Uint(UintTy::U32),
-        "u64" => SimplifiedType::Uint(UintTy::U64),
-        "u128" => SimplifiedType::Uint(UintTy::U128),
-        "f32" => SimplifiedType::Float(FloatTy::F32),
-        "f64" => SimplifiedType::Float(FloatTy::F64),
-        _ => return [].iter().copied(),
-    };
-
-    tcx.incoherent_impls(ty).iter().copied()
-}
-
-fn non_local_item_children_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: Symbol) -> Vec<Res> {
-    match tcx.def_kind(def_id) {
-        DefKind::Mod | DefKind::Enum | DefKind::Trait => tcx
-            .module_children(def_id)
-            .iter()
-            .filter(|item| item.ident.name == name)
-            .map(|child| child.res.expect_non_local())
-            .collect(),
-        DefKind::Impl { .. } => tcx
-            .associated_item_def_ids(def_id)
-            .iter()
-            .copied()
-            .filter(|assoc_def_id| tcx.item_name(*assoc_def_id) == name)
-            .map(|assoc_def_id| Res::Def(tcx.def_kind(assoc_def_id), assoc_def_id))
-            .collect(),
-        _ => Vec::new(),
-    }
-}
-
-fn local_item_children_by_name(tcx: TyCtxt<'_>, local_id: LocalDefId, name: Symbol) -> Vec<Res> {
-    let hir = tcx.hir();
-
-    let root_mod;
-    let item_kind = match hir.find_by_def_id(local_id) {
-        Some(Node::Crate(r#mod)) => {
-            root_mod = ItemKind::Mod(r#mod);
-            &root_mod
-        },
-        Some(Node::Item(item)) => &item.kind,
-        _ => return Vec::new(),
-    };
-
-    let res = |ident: Ident, owner_id: OwnerId| {
-        if ident.name == name {
-            let def_id = owner_id.to_def_id();
-            Some(Res::Def(tcx.def_kind(def_id), def_id))
-        } else {
-            None
-        }
-    };
-
-    match item_kind {
-        ItemKind::Mod(r#mod) => r#mod
-            .item_ids
-            .iter()
-            .filter_map(|&item_id| res(hir.item(item_id).ident, item_id.owner_id))
-            .collect(),
-        ItemKind::Impl(r#impl) => r#impl
-            .items
-            .iter()
-            .filter_map(|&ImplItemRef { ident, id, .. }| res(ident, id.owner_id))
-            .collect(),
-        ItemKind::Trait(.., trait_item_refs) => trait_item_refs
-            .iter()
-            .filter_map(|&TraitItemRef { ident, id, .. }| res(ident, id.owner_id))
-            .collect(),
-        _ => Vec::new(),
-    }
-}
-
-fn item_children_by_name(tcx: TyCtxt<'_>, def_id: DefId, name: Symbol) -> Vec<Res> {
-    if let Some(local_id) = def_id.as_local() {
-        local_item_children_by_name(tcx, local_id, name)
-    } else {
-        non_local_item_children_by_name(tcx, def_id, name)
-    }
-}
-
-/// Resolves a def path like `std::vec::Vec`.
-///
-/// Can return multiple resolutions when there are multiple versions of the same crate, e.g.
-/// `memchr::memchr` could return the functions from both memchr 1.0 and memchr 2.0.
-///
-/// Also returns multiple results when there are multiple paths under the same name e.g. `std::vec`
-/// would have both a [`DefKind::Mod`] and [`DefKind::Macro`].
-///
-/// This function is expensive and should be used sparingly.
-pub fn def_path_res(cx: &LateContext<'_>, path: &[&str]) -> Vec<Res> {
-    fn find_crates(tcx: TyCtxt<'_>, name: Symbol) -> impl Iterator<Item = DefId> + '_ {
-        tcx.crates(())
-            .iter()
-            .copied()
-            .filter(move |&num| tcx.crate_name(num) == name)
-            .map(CrateNum::as_def_id)
-    }
-
-    let tcx = cx.tcx;
-
-    let (base, mut path) = match *path {
-        [primitive] => {
-            return vec![PrimTy::from_name(Symbol::intern(primitive)).map_or(Res::Err, Res::PrimTy)];
-        },
-        [base, ref path @ ..] => (base, path),
-        _ => return Vec::new(),
-    };
-
-    let base_sym = Symbol::intern(base);
-
-    let local_crate = if tcx.crate_name(LOCAL_CRATE) == base_sym {
-        Some(LOCAL_CRATE.as_def_id())
-    } else {
-        None
-    };
-
-    let starts = find_primitive_impls(tcx, base)
-        .chain(find_crates(tcx, base_sym))
-        .chain(local_crate)
-        .map(|id| Res::Def(tcx.def_kind(id), id));
-
-    let mut resolutions: Vec<Res> = starts.collect();
-
-    while let [segment, rest @ ..] = path {
-        path = rest;
-        let segment = Symbol::intern(segment);
-
-        resolutions = resolutions
-            .into_iter()
-            .filter_map(|res| res.opt_def_id())
-            .flat_map(|def_id| {
-                // When the current def_id is e.g. `struct S`, check the impl items in
-                // `impl S { ... }`
-                let inherent_impl_children = tcx
-                    .inherent_impls(def_id)
-                    .iter()
-                    .flat_map(|&impl_def_id| item_children_by_name(tcx, impl_def_id, segment));
-
-                let direct_children = item_children_by_name(tcx, def_id, segment);
-
-                inherent_impl_children.chain(direct_children)
-            })
-            .collect();
-    }
-
-    resolutions
-}
-
-/// Resolves a def path like `std::vec::Vec` to its [`DefId`]s, see [`def_path_res`].
-pub fn def_path_def_ids(cx: &LateContext<'_>, path: &[&str]) -> impl Iterator<Item = DefId> {
-    def_path_res(cx, path).into_iter().filter_map(|res| res.opt_def_id())
-}
-
-/// Convenience function to get the `DefId` of a trait by path.
-/// It could be a trait or trait alias.
-///
-/// This function is expensive and should be used sparingly.
-pub fn get_trait_def_id(cx: &LateContext<'_>, path: &[&str]) -> Option<DefId> {
-    def_path_res(cx, path).into_iter().find_map(|res| match res {
-        Res::Def(DefKind::Trait | DefKind::TraitAlias, trait_id) => Some(trait_id),
-        _ => None,
-    })
-}
-
-/// Gets the `hir::TraitRef` of the trait the given method is implemented for.
-///
-/// Use this if you want to find the `TraitRef` of the `Add` trait in this example:
-///
-/// ```rust
-/// struct Point(isize, isize);
-///
-/// impl std::ops::Add for Point {
-///     type Output = Self;
-///
-///     fn add(self, other: Self) -> Self {
-///         Point(0, 0)
-///     }
-/// }
-/// ```
-pub fn trait_ref_of_method<'tcx>(cx: &LateContext<'tcx>, def_id: LocalDefId) -> Option<&'tcx TraitRef<'tcx>> {
-    // Get the implemented trait for the current function
-    let hir_id = cx.tcx.hir().local_def_id_to_hir_id(def_id);
-    let parent_impl = cx.tcx.hir().get_parent_item(hir_id);
-    if_chain! {
-        if parent_impl != hir::CRATE_OWNER_ID;
-        if let hir::Node::Item(item) = cx.tcx.hir().get_by_def_id(parent_impl.def_id);
-        if let hir::ItemKind::Impl(impl_) = &item.kind;
-        then {
-            return impl_.of_trait.as_ref();
-        }
-    }
-    None
-}
-
-/// This method will return tuple of projection stack and root of the expression,
-/// used in `can_mut_borrow_both`.
-///
-/// For example, if `e` represents the `v[0].a.b[x]`
-/// this method will return a tuple, composed of a `Vec`
-/// containing the `Expr`s for `v[0], v[0].a, v[0].a.b, v[0].a.b[x]`
-/// and an `Expr` for root of them, `v`
-fn projection_stack<'a, 'hir>(mut e: &'a Expr<'hir>) -> (Vec<&'a Expr<'hir>>, &'a Expr<'hir>) {
-    let mut result = vec![];
-    let root = loop {
-        match e.kind {
-            ExprKind::Index(ep, _, _) | ExprKind::Field(ep, _) => {
-                result.push(e);
-                e = ep;
-            },
-            _ => break e,
-        };
-    };
-    result.reverse();
-    (result, root)
-}
-
-/// Gets the mutability of the custom deref adjustment, if any.
-pub fn expr_custom_deref_adjustment(cx: &LateContext<'_>, e: &Expr<'_>) -> Option<Mutability> {
-    cx.typeck_results()
-        .expr_adjustments(e)
-        .iter()
-        .find_map(|a| match a.kind {
-            Adjust::Deref(Some(d)) => Some(Some(d.mutbl)),
-            Adjust::Deref(None) => None,
-            _ => Some(None),
-        })
-        .and_then(|x| x)
-}
-
-/// Checks if two expressions can be mutably borrowed simultaneously
-/// and they aren't dependent on borrowing same thing twice
-pub fn can_mut_borrow_both(cx: &LateContext<'_>, e1: &Expr<'_>, e2: &Expr<'_>) -> bool {
-    let (s1, r1) = projection_stack(e1);
-    let (s2, r2) = projection_stack(e2);
-    if !eq_expr_value(cx, r1, r2) {
-        return true;
-    }
-    if expr_custom_deref_adjustment(cx, r1).is_some() || expr_custom_deref_adjustment(cx, r2).is_some() {
-        return false;
-    }
-
-    for (x1, x2) in s1.iter().zip(s2.iter()) {
-        if expr_custom_deref_adjustment(cx, x1).is_some() || expr_custom_deref_adjustment(cx, x2).is_some() {
-            return false;
-        }
-
-        match (&x1.kind, &x2.kind) {
-            (ExprKind::Field(_, i1), ExprKind::Field(_, i2)) => {
-                if i1 != i2 {
-                    return true;
-                }
-            },
-            (ExprKind::Index(_, i1, _), ExprKind::Index(_, i2, _)) => {
-                if !eq_expr_value(cx, i1, i2) {
-                    return false;
-                }
-            },
-            _ => return false,
-        }
-    }
-    false
-}
-
-/// Returns true if the `def_id` associated with the `path` is recognized as a "default-equivalent"
-/// constructor from the std library
-fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<'_>) -> bool {
-    let std_types_symbols = &[
-        sym::Vec,
-        sym::VecDeque,
-        sym::LinkedList,
-        sym::HashMap,
-        sym::BTreeMap,
-        sym::HashSet,
-        sym::BTreeSet,
-        sym::BinaryHeap,
-    ];
-
-    if let QPath::TypeRelative(_, method) = path {
-        if method.ident.name == sym::new {
-            if let Some(impl_did) = cx.tcx.impl_of_method(def_id) {
-                if let Some(adt) = cx.tcx.type_of(impl_did).instantiate_identity().ty_adt_def() {
-                    return std_types_symbols.iter().any(|&symbol| {
-                        cx.tcx.is_diagnostic_item(symbol, adt.did()) || Some(adt.did()) == cx.tcx.lang_items().string()
-                    });
-                }
-            }
-        }
-    }
-    false
-}
-
-/// Returns true if the expr is equal to `Default::default` when evaluated.
-pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) -> bool {
-    if_chain! {
-        if let hir::ExprKind::Path(ref repl_func_qpath) = repl_func.kind;
-        if let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id();
-        if is_diag_trait_item(cx, repl_def_id, sym::Default)
-            || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath);
-        then { true } else { false }
-    }
-}
-
-/// Returns true if the expr is equal to `Default::default()` of it's type when evaluated.
-/// It doesn't cover all cases, for example indirect function calls (some of std
-/// functions are supported) but it is the best we have.
-pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    match &e.kind {
-        ExprKind::Lit(lit) => match lit.node {
-            LitKind::Bool(false) | LitKind::Int(0, _) => true,
-            LitKind::Str(s, _) => s.is_empty(),
-            _ => false,
-        },
-        ExprKind::Tup(items) | ExprKind::Array(items) => items.iter().all(|x| is_default_equivalent(cx, x)),
-        ExprKind::Repeat(x, ArrayLen::Body(len)) => if_chain! {
-            if let ExprKind::Lit(const_lit) = cx.tcx.hir().body(len.body).value.kind;
-            if let LitKind::Int(v, _) = const_lit.node;
-            if v <= 32 && is_default_equivalent(cx, x);
-            then {
-                true
-            }
-            else {
-                false
-            }
-        },
-        ExprKind::Call(repl_func, []) => is_default_equivalent_call(cx, repl_func),
-        ExprKind::Call(from_func, [ref arg]) => is_default_equivalent_from(cx, from_func, arg),
-        ExprKind::Path(qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, e.hir_id), OptionNone),
-        ExprKind::AddrOf(rustc_hir::BorrowKind::Ref, _, expr) => matches!(expr.kind, ExprKind::Array([])),
-        _ => false,
-    }
-}
-
-fn is_default_equivalent_from(cx: &LateContext<'_>, from_func: &Expr<'_>, arg: &Expr<'_>) -> bool {
-    if let ExprKind::Path(QPath::TypeRelative(ty, seg)) = from_func.kind &&
-        seg.ident.name == sym::from
-    {
-        match arg.kind {
-            ExprKind::Lit(hir::Lit {
-                node: LitKind::Str(ref sym, _),
-                ..
-            }) => return sym.is_empty() && is_path_lang_item(cx, ty, LangItem::String),
-            ExprKind::Array([]) => return is_path_diagnostic_item(cx, ty, sym::Vec),
-            ExprKind::Repeat(_, ArrayLen::Body(len)) => {
-                if let ExprKind::Lit(const_lit) = cx.tcx.hir().body(len.body).value.kind &&
-                    let LitKind::Int(v, _) = const_lit.node
-                {
-                        return v == 0 && is_path_diagnostic_item(cx, ty, sym::Vec);
-                }
-            }
-            _ => (),
-        }
-    }
-    false
-}
-
-/// Checks if the top level expression can be moved into a closure as is.
-/// Currently checks for:
-/// * Break/Continue outside the given loop HIR ids.
-/// * Yield/Return statements.
-/// * Inline assembly.
-/// * Usages of a field of a local where the type of the local can be partially moved.
-///
-/// For example, given the following function:
-///
-/// ```
-/// fn f<'a>(iter: &mut impl Iterator<Item = (usize, &'a mut String)>) {
-///     for item in iter {
-///         let s = item.1;
-///         if item.0 > 10 {
-///             continue;
-///         } else {
-///             s.clear();
-///         }
-///     }
-/// }
-/// ```
-///
-/// When called on the expression `item.0` this will return false unless the local `item` is in the
-/// `ignore_locals` set. The type `(usize, &mut String)` can have the second element moved, so it
-/// isn't always safe to move into a closure when only a single field is needed.
-///
-/// When called on the `continue` expression this will return false unless the outer loop expression
-/// is in the `loop_ids` set.
-///
-/// Note that this check is not recursive, so passing the `if` expression will always return true
-/// even though sub-expressions might return false.
-pub fn can_move_expr_to_closure_no_visit<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    loop_ids: &[HirId],
-    ignore_locals: &HirIdSet,
-) -> bool {
-    match expr.kind {
-        ExprKind::Break(Destination { target_id: Ok(id), .. }, _)
-        | ExprKind::Continue(Destination { target_id: Ok(id), .. })
-            if loop_ids.contains(&id) =>
-        {
-            true
-        },
-        ExprKind::Break(..)
-        | ExprKind::Continue(_)
-        | ExprKind::Ret(_)
-        | ExprKind::Yield(..)
-        | ExprKind::InlineAsm(_) => false,
-        // Accessing a field of a local value can only be done if the type isn't
-        // partially moved.
-        ExprKind::Field(
-            &Expr {
-                hir_id,
-                kind:
-                    ExprKind::Path(QPath::Resolved(
-                        _,
-                        Path {
-                            res: Res::Local(local_id),
-                            ..
-                        },
-                    )),
-                ..
-            },
-            _,
-        ) if !ignore_locals.contains(local_id) && can_partially_move_ty(cx, cx.typeck_results().node_type(hir_id)) => {
-            // TODO: check if the local has been partially moved. Assume it has for now.
-            false
-        },
-        _ => true,
-    }
-}
-
-/// How a local is captured by a closure
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum CaptureKind {
-    Value,
-    Ref(Mutability),
-}
-impl CaptureKind {
-    pub fn is_imm_ref(self) -> bool {
-        self == Self::Ref(Mutability::Not)
-    }
-}
-impl std::ops::BitOr for CaptureKind {
-    type Output = Self;
-    fn bitor(self, rhs: Self) -> Self::Output {
-        match (self, rhs) {
-            (CaptureKind::Value, _) | (_, CaptureKind::Value) => CaptureKind::Value,
-            (CaptureKind::Ref(Mutability::Mut), CaptureKind::Ref(_))
-            | (CaptureKind::Ref(_), CaptureKind::Ref(Mutability::Mut)) => CaptureKind::Ref(Mutability::Mut),
-            (CaptureKind::Ref(Mutability::Not), CaptureKind::Ref(Mutability::Not)) => CaptureKind::Ref(Mutability::Not),
-        }
-    }
-}
-impl std::ops::BitOrAssign for CaptureKind {
-    fn bitor_assign(&mut self, rhs: Self) {
-        *self = *self | rhs;
-    }
-}
-
-/// Given an expression referencing a local, determines how it would be captured in a closure.
-/// Note as this will walk up to parent expressions until the capture can be determined it should
-/// only be used while making a closure somewhere a value is consumed. e.g. a block, match arm, or
-/// function argument (other than a receiver).
-pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind {
-    fn pat_capture_kind(cx: &LateContext<'_>, pat: &Pat<'_>) -> CaptureKind {
-        let mut capture = CaptureKind::Ref(Mutability::Not);
-        pat.each_binding_or_first(&mut |_, id, span, _| match cx
-            .typeck_results()
-            .extract_binding_mode(cx.sess(), id, span)
-            .unwrap()
-        {
-            BindingMode::BindByValue(_) if !is_copy(cx, cx.typeck_results().node_type(id)) => {
-                capture = CaptureKind::Value;
-            },
-            BindingMode::BindByReference(Mutability::Mut) if capture != CaptureKind::Value => {
-                capture = CaptureKind::Ref(Mutability::Mut);
-            },
-            _ => (),
-        });
-        capture
-    }
-
-    debug_assert!(matches!(
-        e.kind,
-        ExprKind::Path(QPath::Resolved(None, Path { res: Res::Local(_), .. }))
-    ));
-
-    let mut child_id = e.hir_id;
-    let mut capture = CaptureKind::Value;
-    let mut capture_expr_ty = e;
-
-    for (parent_id, parent) in cx.tcx.hir().parent_iter(e.hir_id) {
-        if let [
-            Adjustment {
-                kind: Adjust::Deref(_) | Adjust::Borrow(AutoBorrow::Ref(..)),
-                target,
-            },
-            ref adjust @ ..,
-        ] = *cx
-            .typeck_results()
-            .adjustments()
-            .get(child_id)
-            .map_or(&[][..], |x| &**x)
-        {
-            if let rustc_ty::RawPtr(TypeAndMut { mutbl: mutability, .. }) | rustc_ty::Ref(_, _, mutability) =
-                *adjust.last().map_or(target, |a| a.target).kind()
-            {
-                return CaptureKind::Ref(mutability);
-            }
-        }
-
-        match parent {
-            Node::Expr(e) => match e.kind {
-                ExprKind::AddrOf(_, mutability, _) => return CaptureKind::Ref(mutability),
-                ExprKind::Index(..) | ExprKind::Unary(UnOp::Deref, _) => capture = CaptureKind::Ref(Mutability::Not),
-                ExprKind::Assign(lhs, ..) | ExprKind::AssignOp(_, lhs, _) if lhs.hir_id == child_id => {
-                    return CaptureKind::Ref(Mutability::Mut);
-                },
-                ExprKind::Field(..) => {
-                    if capture == CaptureKind::Value {
-                        capture_expr_ty = e;
-                    }
-                },
-                ExprKind::Let(let_expr) => {
-                    let mutability = match pat_capture_kind(cx, let_expr.pat) {
-                        CaptureKind::Value => Mutability::Not,
-                        CaptureKind::Ref(m) => m,
-                    };
-                    return CaptureKind::Ref(mutability);
-                },
-                ExprKind::Match(_, arms, _) => {
-                    let mut mutability = Mutability::Not;
-                    for capture in arms.iter().map(|arm| pat_capture_kind(cx, arm.pat)) {
-                        match capture {
-                            CaptureKind::Value => break,
-                            CaptureKind::Ref(Mutability::Mut) => mutability = Mutability::Mut,
-                            CaptureKind::Ref(Mutability::Not) => (),
-                        }
-                    }
-                    return CaptureKind::Ref(mutability);
-                },
-                _ => break,
-            },
-            Node::Local(l) => match pat_capture_kind(cx, l.pat) {
-                CaptureKind::Value => break,
-                capture @ CaptureKind::Ref(_) => return capture,
-            },
-            _ => break,
-        }
-
-        child_id = parent_id;
-    }
-
-    if capture == CaptureKind::Value && is_copy(cx, cx.typeck_results().expr_ty(capture_expr_ty)) {
-        // Copy types are never automatically captured by value.
-        CaptureKind::Ref(Mutability::Not)
-    } else {
-        capture
-    }
-}
-
-/// Checks if the expression can be moved into a closure as is. This will return a list of captures
-/// if so, otherwise, `None`.
-pub fn can_move_expr_to_closure<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<HirIdMap<CaptureKind>> {
-    struct V<'cx, 'tcx> {
-        cx: &'cx LateContext<'tcx>,
-        // Stack of potential break targets contained in the expression.
-        loops: Vec<HirId>,
-        /// Local variables created in the expression. These don't need to be captured.
-        locals: HirIdSet,
-        /// Whether this expression can be turned into a closure.
-        allow_closure: bool,
-        /// Locals which need to be captured, and whether they need to be by value, reference, or
-        /// mutable reference.
-        captures: HirIdMap<CaptureKind>,
-    }
-    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            if !self.allow_closure {
-                return;
-            }
-
-            match e.kind {
-                ExprKind::Path(QPath::Resolved(None, &Path { res: Res::Local(l), .. })) => {
-                    if !self.locals.contains(&l) {
-                        let cap = capture_local_usage(self.cx, e);
-                        self.captures.entry(l).and_modify(|e| *e |= cap).or_insert(cap);
-                    }
-                },
-                ExprKind::Closure(closure) => {
-                    for capture in self.cx.typeck_results().closure_min_captures_flattened(closure.def_id) {
-                        let local_id = match capture.place.base {
-                            PlaceBase::Local(id) => id,
-                            PlaceBase::Upvar(var) => var.var_path.hir_id,
-                            _ => continue,
-                        };
-                        if !self.locals.contains(&local_id) {
-                            let capture = match capture.info.capture_kind {
-                                UpvarCapture::ByValue => CaptureKind::Value,
-                                UpvarCapture::ByRef(kind) => match kind {
-                                    BorrowKind::ImmBorrow => CaptureKind::Ref(Mutability::Not),
-                                    BorrowKind::UniqueImmBorrow | BorrowKind::MutBorrow => {
-                                        CaptureKind::Ref(Mutability::Mut)
-                                    },
-                                },
-                            };
-                            self.captures
-                                .entry(local_id)
-                                .and_modify(|e| *e |= capture)
-                                .or_insert(capture);
-                        }
-                    }
-                },
-                ExprKind::Loop(b, ..) => {
-                    self.loops.push(e.hir_id);
-                    self.visit_block(b);
-                    self.loops.pop();
-                },
-                _ => {
-                    self.allow_closure &= can_move_expr_to_closure_no_visit(self.cx, e, &self.loops, &self.locals);
-                    walk_expr(self, e);
-                },
-            }
-        }
-
-        fn visit_pat(&mut self, p: &'tcx Pat<'tcx>) {
-            p.each_binding_or_first(&mut |_, id, _, _| {
-                self.locals.insert(id);
-            });
-        }
-    }
-
-    let mut v = V {
-        cx,
-        allow_closure: true,
-        loops: Vec::new(),
-        locals: HirIdSet::default(),
-        captures: HirIdMap::default(),
-    };
-    v.visit_expr(expr);
-    v.allow_closure.then_some(v.captures)
-}
-
-/// Arguments of a method: the receiver and all the additional arguments.
-pub type MethodArguments<'tcx> = Vec<(&'tcx Expr<'tcx>, &'tcx [Expr<'tcx>])>;
-
-/// Returns the method names and argument list of nested method call expressions that make up
-/// `expr`. method/span lists are sorted with the most recent call first.
-pub fn method_calls<'tcx>(expr: &'tcx Expr<'tcx>, max_depth: usize) -> (Vec<Symbol>, MethodArguments<'tcx>, Vec<Span>) {
-    let mut method_names = Vec::with_capacity(max_depth);
-    let mut arg_lists = Vec::with_capacity(max_depth);
-    let mut spans = Vec::with_capacity(max_depth);
-
-    let mut current = expr;
-    for _ in 0..max_depth {
-        if let ExprKind::MethodCall(path, receiver, args, _) = &current.kind {
-            if receiver.span.from_expansion() || args.iter().any(|e| e.span.from_expansion()) {
-                break;
-            }
-            method_names.push(path.ident.name);
-            arg_lists.push((*receiver, &**args));
-            spans.push(path.ident.span);
-            current = receiver;
-        } else {
-            break;
-        }
-    }
-
-    (method_names, arg_lists, spans)
-}
-
-/// Matches an `Expr` against a chain of methods, and return the matched `Expr`s.
-///
-/// For example, if `expr` represents the `.baz()` in `foo.bar().baz()`,
-/// `method_chain_args(expr, &["bar", "baz"])` will return a `Vec`
-/// containing the `Expr`s for
-/// `.bar()` and `.baz()`
-pub fn method_chain_args<'a>(expr: &'a Expr<'_>, methods: &[&str]) -> Option<Vec<(&'a Expr<'a>, &'a [Expr<'a>])>> {
-    let mut current = expr;
-    let mut matched = Vec::with_capacity(methods.len());
-    for method_name in methods.iter().rev() {
-        // method chains are stored last -> first
-        if let ExprKind::MethodCall(path, receiver, args, _) = current.kind {
-            if path.ident.name.as_str() == *method_name {
-                if receiver.span.from_expansion() || args.iter().any(|e| e.span.from_expansion()) {
-                    return None;
-                }
-                matched.push((receiver, args)); // build up `matched` backwards
-                current = receiver; // go to parent expression
-            } else {
-                return None;
-            }
-        } else {
-            return None;
-        }
-    }
-    // Reverse `matched` so that it is in the same order as `methods`.
-    matched.reverse();
-    Some(matched)
-}
-
-/// Returns `true` if the provided `def_id` is an entrypoint to a program.
-pub fn is_entrypoint_fn(cx: &LateContext<'_>, def_id: DefId) -> bool {
-    cx.tcx
-        .entry_fn(())
-        .map_or(false, |(entry_fn_def_id, _)| def_id == entry_fn_def_id)
-}
-
-/// Returns `true` if the expression is in the program's `#[panic_handler]`.
-pub fn is_in_panic_handler(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    let parent = cx.tcx.hir().get_parent_item(e.hir_id);
-    Some(parent.to_def_id()) == cx.tcx.lang_items().panic_impl()
-}
-
-/// Gets the name of the item the expression is in, if available.
-pub fn get_item_name(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<Symbol> {
-    let parent_id = cx.tcx.hir().get_parent_item(expr.hir_id).def_id;
-    match cx.tcx.hir().find_by_def_id(parent_id) {
-        Some(
-            Node::Item(Item { ident, .. })
-            | Node::TraitItem(TraitItem { ident, .. })
-            | Node::ImplItem(ImplItem { ident, .. }),
-        ) => Some(ident.name),
-        _ => None,
-    }
-}
-
-pub struct ContainsName<'a, 'tcx> {
-    pub cx: &'a LateContext<'tcx>,
-    pub name: Symbol,
-    pub result: bool,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for ContainsName<'a, 'tcx> {
-    type NestedFilter = nested_filter::OnlyBodies;
-
-    fn visit_name(&mut self, name: Symbol) {
-        if self.name == name {
-            self.result = true;
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-}
-
-/// Checks if an `Expr` contains a certain name.
-pub fn contains_name<'tcx>(name: Symbol, expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> bool {
-    let mut cn = ContainsName {
-        name,
-        result: false,
-        cx,
-    };
-    cn.visit_expr(expr);
-    cn.result
-}
-
-/// Returns `true` if `expr` contains a return expression
-pub fn contains_return<'tcx>(expr: impl Visitable<'tcx>) -> bool {
-    for_each_expr(expr, |e| {
-        if matches!(e.kind, hir::ExprKind::Ret(..)) {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
-
-/// Gets the parent node, if any.
-pub fn get_parent_node(tcx: TyCtxt<'_>, id: HirId) -> Option<Node<'_>> {
-    tcx.hir().find_parent(id)
-}
-
-/// Gets the parent expression, if any –- this is useful to constrain a lint.
-pub fn get_parent_expr<'tcx>(cx: &LateContext<'tcx>, e: &Expr<'_>) -> Option<&'tcx Expr<'tcx>> {
-    get_parent_expr_for_hir(cx, e.hir_id)
-}
-
-/// This retrieves the parent for the given `HirId` if it's an expression. This is useful for
-/// constraint lints
-pub fn get_parent_expr_for_hir<'tcx>(cx: &LateContext<'tcx>, hir_id: hir::HirId) -> Option<&'tcx Expr<'tcx>> {
-    match get_parent_node(cx.tcx, hir_id) {
-        Some(Node::Expr(parent)) => Some(parent),
-        _ => None,
-    }
-}
-
-/// Gets the enclosing block, if any.
-pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Option<&'tcx Block<'tcx>> {
-    let map = &cx.tcx.hir();
-    let enclosing_node = map
-        .get_enclosing_scope(hir_id)
-        .and_then(|enclosing_id| map.find(enclosing_id));
-    enclosing_node.and_then(|node| match node {
-        Node::Block(block) => Some(block),
-        Node::Item(&Item {
-            kind: ItemKind::Fn(_, _, eid),
-            ..
-        })
-        | Node::ImplItem(&ImplItem {
-            kind: ImplItemKind::Fn(_, eid),
-            ..
-        }) => match cx.tcx.hir().body(eid).value.kind {
-            ExprKind::Block(block, _) => Some(block),
-            _ => None,
-        },
-        _ => None,
-    })
-}
-
-/// Gets the loop or closure enclosing the given expression, if any.
-pub fn get_enclosing_loop_or_multi_call_closure<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &Expr<'_>,
-) -> Option<&'tcx Expr<'tcx>> {
-    for (_, node) in cx.tcx.hir().parent_iter(expr.hir_id) {
-        match node {
-            Node::Expr(e) => match e.kind {
-                ExprKind::Closure { .. } => {
-                    if let rustc_ty::Closure(_, subs) = cx.typeck_results().expr_ty(e).kind()
-                        && subs.as_closure().kind() == ClosureKind::FnOnce
-                    {
-                        continue;
-                    }
-                    let is_once = walk_to_expr_usage(cx, e, |node, id| {
-                        let Node::Expr(e) = node else {
-                            return None;
-                        };
-                        match e.kind {
-                            ExprKind::Call(f, _) if f.hir_id == id => Some(()),
-                            ExprKind::Call(f, args) => {
-                                let i = args.iter().position(|arg| arg.hir_id == id)?;
-                                let sig = expr_sig(cx, f)?;
-                                let predicates = sig
-                                    .predicates_id()
-                                    .map_or(cx.param_env, |id| cx.tcx.param_env(id))
-                                    .caller_bounds();
-                                sig.input(i).and_then(|ty| {
-                                    ty_is_fn_once_param(cx.tcx, ty.skip_binder(), predicates).then_some(())
-                                })
-                            },
-                            ExprKind::MethodCall(_, receiver, args, _) => {
-                                let i = std::iter::once(receiver)
-                                    .chain(args.iter())
-                                    .position(|arg| arg.hir_id == id)?;
-                                let id = cx.typeck_results().type_dependent_def_id(e.hir_id)?;
-                                let ty = cx.tcx.fn_sig(id).instantiate_identity().skip_binder().inputs()[i];
-                                ty_is_fn_once_param(cx.tcx, ty, cx.tcx.param_env(id).caller_bounds()).then_some(())
-                            },
-                            _ => None,
-                        }
-                    })
-                    .is_some();
-                    if !is_once {
-                        return Some(e);
-                    }
-                },
-                ExprKind::Loop(..) => return Some(e),
-                _ => (),
-            },
-            Node::Stmt(_) | Node::Block(_) | Node::Local(_) | Node::Arm(_) => (),
-            _ => break,
-        }
-    }
-    None
-}
-
-/// Gets the parent node if it's an impl block.
-pub fn get_parent_as_impl(tcx: TyCtxt<'_>, id: HirId) -> Option<&Impl<'_>> {
-    match tcx.hir().parent_iter(id).next() {
-        Some((
-            _,
-            Node::Item(Item {
-                kind: ItemKind::Impl(imp),
-                ..
-            }),
-        )) => Some(imp),
-        _ => None,
-    }
-}
-
-/// Removes blocks around an expression, only if the block contains just one expression
-/// and no statements. Unsafe blocks are not removed.
-///
-/// Examples:
-///  * `{}`               -> `{}`
-///  * `{ x }`            -> `x`
-///  * `{{ x }}`          -> `x`
-///  * `{ x; }`           -> `{ x; }`
-///  * `{ x; y }`         -> `{ x; y }`
-///  * `{ unsafe { x } }` -> `unsafe { x }`
-pub fn peel_blocks<'a>(mut expr: &'a Expr<'a>) -> &'a Expr<'a> {
-    while let ExprKind::Block(
-        Block {
-            stmts: [],
-            expr: Some(inner),
-            rules: BlockCheckMode::DefaultBlock,
-            ..
-        },
-        _,
-    ) = expr.kind
-    {
-        expr = inner;
-    }
-    expr
-}
-
-/// Removes blocks around an expression, only if the block contains just one expression
-/// or just one expression statement with a semicolon. Unsafe blocks are not removed.
-///
-/// Examples:
-///  * `{}`               -> `{}`
-///  * `{ x }`            -> `x`
-///  * `{ x; }`           -> `x`
-///  * `{{ x; }}`         -> `x`
-///  * `{ x; y }`         -> `{ x; y }`
-///  * `{ unsafe { x } }` -> `unsafe { x }`
-pub fn peel_blocks_with_stmt<'a>(mut expr: &'a Expr<'a>) -> &'a Expr<'a> {
-    while let ExprKind::Block(
-        Block {
-            stmts: [],
-            expr: Some(inner),
-            rules: BlockCheckMode::DefaultBlock,
-            ..
-        }
-        | Block {
-            stmts:
-                [
-                    Stmt {
-                        kind: StmtKind::Expr(inner) | StmtKind::Semi(inner),
-                        ..
-                    },
-                ],
-            expr: None,
-            rules: BlockCheckMode::DefaultBlock,
-            ..
-        },
-        _,
-    ) = expr.kind
-    {
-        expr = inner;
-    }
-    expr
-}
-
-/// Checks if the given expression is the else clause of either an `if` or `if let` expression.
-pub fn is_else_clause(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
-    let mut iter = tcx.hir().parent_iter(expr.hir_id);
-    match iter.next() {
-        Some((
-            _,
-            Node::Expr(Expr {
-                kind: ExprKind::If(_, _, Some(else_expr)),
-                ..
-            }),
-        )) => else_expr.hir_id == expr.hir_id,
-        _ => false,
-    }
-}
-
-/// Checks whether the given `Expr` is a range equivalent to a `RangeFull`.
-/// For the lower bound, this means that:
-/// - either there is none
-/// - or it is the smallest value that can be represented by the range's integer type
-/// For the upper bound, this means that:
-/// - either there is none
-/// - or it is the largest value that can be represented by the range's integer type and is
-///   inclusive
-/// - or it is a call to some container's `len` method and is exclusive, and the range is passed to
-///   a method call on that same container (e.g. `v.drain(..v.len())`)
-/// If the given `Expr` is not some kind of range, the function returns `false`.
-pub fn is_range_full(cx: &LateContext<'_>, expr: &Expr<'_>, container_path: Option<&Path<'_>>) -> bool {
-    let ty = cx.typeck_results().expr_ty(expr);
-    if let Some(Range { start, end, limits }) = Range::hir(expr) {
-        let start_is_none_or_min = start.map_or(true, |start| {
-            if let rustc_ty::Adt(_, subst) = ty.kind()
-                && let bnd_ty = subst.type_at(0)
-                && let Some(min_val) = bnd_ty.numeric_min_val(cx.tcx)
-                && let const_val = cx.tcx.valtree_to_const_val((bnd_ty, min_val.to_valtree()))
-                && let min_const_kind = Const::from_value(const_val, bnd_ty)
-                && let Some(min_const) = miri_to_const(cx, min_const_kind)
-                && let Some(start_const) = constant(cx, cx.typeck_results(), start)
-            {
-                start_const == min_const
-            } else {
-                false
-            }
-        });
-        let end_is_none_or_max = end.map_or(true, |end| {
-            match limits {
-                RangeLimits::Closed => {
-                    if let rustc_ty::Adt(_, subst) = ty.kind()
-                        && let bnd_ty = subst.type_at(0)
-                        && let Some(max_val) = bnd_ty.numeric_max_val(cx.tcx)
-                        && let const_val = cx.tcx.valtree_to_const_val((bnd_ty, max_val.to_valtree()))
-                        && let max_const_kind = Const::from_value(const_val, bnd_ty)
-                        && let Some(max_const) = miri_to_const(cx, max_const_kind)
-                        && let Some(end_const) = constant(cx, cx.typeck_results(), end)
-                    {
-                        end_const == max_const
-                    } else {
-                        false
-                    }
-                },
-                RangeLimits::HalfOpen => {
-                    if let Some(container_path) = container_path
-                        && let ExprKind::MethodCall(name, self_arg, [], _) = end.kind
-                        && name.ident.name == sym::len
-                        && let ExprKind::Path(QPath::Resolved(None, path)) = self_arg.kind
-                    {
-                        container_path.res == path.res
-                    } else {
-                        false
-                    }
-                },
-            }
-        });
-        return start_is_none_or_min && end_is_none_or_max;
-    }
-    false
-}
-
-/// Checks whether the given expression is a constant integer of the given value.
-/// unlike `is_integer_literal`, this version does const folding
-pub fn is_integer_const(cx: &LateContext<'_>, e: &Expr<'_>, value: u128) -> bool {
-    if is_integer_literal(e, value) {
-        return true;
-    }
-    let enclosing_body = cx.tcx.hir().enclosing_body_owner(e.hir_id);
-    if let Some(Constant::Int(v)) = constant(cx, cx.tcx.typeck(enclosing_body), e) {
-        return value == v;
-    }
-    false
-}
-
-/// Checks whether the given expression is a constant literal of the given value.
-pub fn is_integer_literal(expr: &Expr<'_>, value: u128) -> bool {
-    // FIXME: use constant folding
-    if let ExprKind::Lit(spanned) = expr.kind {
-        if let LitKind::Int(v, _) = spanned.node {
-            return v == value;
-        }
-    }
-    false
-}
-
-/// Returns `true` if the given `Expr` has been coerced before.
-///
-/// Examples of coercions can be found in the Nomicon at
-/// <https://doc.rust-lang.org/nomicon/coercions.html>.
-///
-/// See `rustc_middle::ty::adjustment::Adjustment` and `rustc_hir_analysis::check::coercion` for
-/// more information on adjustments and coercions.
-pub fn is_adjusted(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
-    cx.typeck_results().adjustments().get(e.hir_id).is_some()
-}
-
-/// Returns the pre-expansion span if this comes from an expansion of the
-/// macro `name`.
-/// See also [`is_direct_expn_of`].
-#[must_use]
-pub fn is_expn_of(mut span: Span, name: &str) -> Option<Span> {
-    loop {
-        if span.from_expansion() {
-            let data = span.ctxt().outer_expn_data();
-            let new_span = data.call_site;
-
-            if let ExpnKind::Macro(MacroKind::Bang, mac_name) = data.kind {
-                if mac_name.as_str() == name {
-                    return Some(new_span);
-                }
-            }
-
-            span = new_span;
-        } else {
-            return None;
-        }
-    }
-}
-
-/// Returns the pre-expansion span if the span directly comes from an expansion
-/// of the macro `name`.
-/// The difference with [`is_expn_of`] is that in
-/// ```rust
-/// # macro_rules! foo { ($name:tt!$args:tt) => { $name!$args } }
-/// # macro_rules! bar { ($e:expr) => { $e } }
-/// foo!(bar!(42));
-/// ```
-/// `42` is considered expanded from `foo!` and `bar!` by `is_expn_of` but only
-/// from `bar!` by `is_direct_expn_of`.
-#[must_use]
-pub fn is_direct_expn_of(span: Span, name: &str) -> Option<Span> {
-    if span.from_expansion() {
-        let data = span.ctxt().outer_expn_data();
-        let new_span = data.call_site;
-
-        if let ExpnKind::Macro(MacroKind::Bang, mac_name) = data.kind {
-            if mac_name.as_str() == name {
-                return Some(new_span);
-            }
-        }
-    }
-
-    None
-}
-
-/// Convenience function to get the return type of a function.
-pub fn return_ty<'tcx>(cx: &LateContext<'tcx>, fn_def_id: hir::OwnerId) -> Ty<'tcx> {
-    let ret_ty = cx.tcx.fn_sig(fn_def_id).instantiate_identity().output();
-    cx.tcx.erase_late_bound_regions(ret_ty)
-}
-
-/// Convenience function to get the nth argument type of a function.
-pub fn nth_arg<'tcx>(cx: &LateContext<'tcx>, fn_def_id: hir::OwnerId, nth: usize) -> Ty<'tcx> {
-    let arg = cx.tcx.fn_sig(fn_def_id).instantiate_identity().input(nth);
-    cx.tcx.erase_late_bound_regions(arg)
-}
-
-/// Checks if an expression is constructing a tuple-like enum variant or struct
-pub fn is_ctor_or_promotable_const_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let ExprKind::Call(fun, _) = expr.kind {
-        if let ExprKind::Path(ref qp) = fun.kind {
-            let res = cx.qpath_res(qp, fun.hir_id);
-            return match res {
-                def::Res::Def(DefKind::Variant | DefKind::Ctor(..), ..) => true,
-                def::Res::Def(_, def_id) => cx.tcx.is_promotable_const_fn(def_id),
-                _ => false,
-            };
-        }
-    }
-    false
-}
-
-/// Returns `true` if a pattern is refutable.
-// TODO: should be implemented using rustc/mir_build/thir machinery
-pub fn is_refutable(cx: &LateContext<'_>, pat: &Pat<'_>) -> bool {
-    fn is_enum_variant(cx: &LateContext<'_>, qpath: &QPath<'_>, id: HirId) -> bool {
-        matches!(
-            cx.qpath_res(qpath, id),
-            def::Res::Def(DefKind::Variant, ..) | Res::Def(DefKind::Ctor(def::CtorOf::Variant, _), _)
-        )
-    }
-
-    fn are_refutable<'a, I: IntoIterator<Item = &'a Pat<'a>>>(cx: &LateContext<'_>, i: I) -> bool {
-        i.into_iter().any(|pat| is_refutable(cx, pat))
-    }
-
-    match pat.kind {
-        PatKind::Wild => false,
-        PatKind::Binding(_, _, _, pat) => pat.map_or(false, |pat| is_refutable(cx, pat)),
-        PatKind::Box(pat) | PatKind::Ref(pat, _) => is_refutable(cx, pat),
-        PatKind::Lit(..) | PatKind::Range(..) => true,
-        PatKind::Path(ref qpath) => is_enum_variant(cx, qpath, pat.hir_id),
-        PatKind::Or(pats) => {
-            // TODO: should be the honest check, that pats is exhaustive set
-            are_refutable(cx, pats)
-        },
-        PatKind::Tuple(pats, _) => are_refutable(cx, pats),
-        PatKind::Struct(ref qpath, fields, _) => {
-            is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, fields.iter().map(|field| field.pat))
-        },
-        PatKind::TupleStruct(ref qpath, pats, _) => is_enum_variant(cx, qpath, pat.hir_id) || are_refutable(cx, pats),
-        PatKind::Slice(head, middle, tail) => {
-            match &cx.typeck_results().node_type(pat.hir_id).kind() {
-                rustc_ty::Slice(..) => {
-                    // [..] is the only irrefutable slice pattern.
-                    !head.is_empty() || middle.is_none() || !tail.is_empty()
-                },
-                rustc_ty::Array(..) => are_refutable(cx, head.iter().chain(middle).chain(tail.iter())),
-                _ => {
-                    // unreachable!()
-                    true
-                },
-            }
-        },
-    }
-}
-
-/// If the pattern is an `or` pattern, call the function once for each sub pattern. Otherwise, call
-/// the function once on the given pattern.
-pub fn recurse_or_patterns<'tcx, F: FnMut(&'tcx Pat<'tcx>)>(pat: &'tcx Pat<'tcx>, mut f: F) {
-    if let PatKind::Or(pats) = pat.kind {
-        pats.iter().for_each(f);
-    } else {
-        f(pat);
-    }
-}
-
-pub fn is_self(slf: &Param<'_>) -> bool {
-    if let PatKind::Binding(.., name, _) = slf.pat.kind {
-        name.name == kw::SelfLower
-    } else {
-        false
-    }
-}
-
-pub fn is_self_ty(slf: &hir::Ty<'_>) -> bool {
-    if let TyKind::Path(QPath::Resolved(None, path)) = slf.kind {
-        if let Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } = path.res {
-            return true;
-        }
-    }
-    false
-}
-
-pub fn iter_input_pats<'tcx>(decl: &FnDecl<'_>, body: &'tcx Body<'_>) -> impl Iterator<Item = &'tcx Param<'tcx>> {
-    (0..decl.inputs.len()).map(move |i| &body.params[i])
-}
-
-/// Checks if a given expression is a match expression expanded from the `?`
-/// operator or the `try` macro.
-pub fn is_try<'tcx>(cx: &LateContext<'_>, expr: &'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>> {
-    fn is_ok(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-        if_chain! {
-            if let PatKind::TupleStruct(ref path, pat, ddpos) = arm.pat.kind;
-            if ddpos.as_opt_usize().is_none();
-            if is_res_lang_ctor(cx, cx.qpath_res(path, arm.pat.hir_id), ResultOk);
-            if let PatKind::Binding(_, hir_id, _, None) = pat[0].kind;
-            if path_to_local_id(arm.body, hir_id);
-            then {
-                return true;
-            }
-        }
-        false
-    }
-
-    fn is_err(cx: &LateContext<'_>, arm: &Arm<'_>) -> bool {
-        if let PatKind::TupleStruct(ref path, _, _) = arm.pat.kind {
-            is_res_lang_ctor(cx, cx.qpath_res(path, arm.pat.hir_id), ResultErr)
-        } else {
-            false
-        }
-    }
-
-    if let ExprKind::Match(_, arms, ref source) = expr.kind {
-        // desugared from a `?` operator
-        if let MatchSource::TryDesugar(_) = *source {
-            return Some(expr);
-        }
-
-        if_chain! {
-            if arms.len() == 2;
-            if arms[0].guard.is_none();
-            if arms[1].guard.is_none();
-            if (is_ok(cx, &arms[0]) && is_err(cx, &arms[1])) || (is_ok(cx, &arms[1]) && is_err(cx, &arms[0]));
-            then {
-                return Some(expr);
-            }
-        }
-    }
-
-    None
-}
-
-/// Returns `true` if the lint is `#[allow]`ed or `#[expect]`ed at any of the `ids`, fulfilling all
-/// of the expectations in `ids`
-///
-/// This should only be used when the lint would otherwise be emitted, for a way to check if a lint
-/// is allowed early to skip work see [`is_lint_allowed`]
-///
-/// To emit at a lint at a different context than the one current see
-/// [`span_lint_hir`](diagnostics::span_lint_hir) or
-/// [`span_lint_hir_and_then`](diagnostics::span_lint_hir_and_then)
-pub fn fulfill_or_allowed(cx: &LateContext<'_>, lint: &'static Lint, ids: impl IntoIterator<Item = HirId>) -> bool {
-    let mut suppress_lint = false;
-
-    for id in ids {
-        let (level, _) = cx.tcx.lint_level_at_node(lint, id);
-        if let Some(expectation) = level.get_expectation_id() {
-            cx.fulfill_expectation(expectation);
-        }
-
-        match level {
-            Level::Allow | Level::Expect(_) => suppress_lint = true,
-            Level::Warn | Level::ForceWarn(_) | Level::Deny | Level::Forbid => {},
-        }
-    }
-
-    suppress_lint
-}
-
-/// Returns `true` if the lint is allowed in the current context. This is useful for
-/// skipping long running code when it's unnecessary
-///
-/// This function should check the lint level for the same node, that the lint will
-/// be emitted at. If the information is buffered to be emitted at a later point, please
-/// make sure to use `span_lint_hir` functions to emit the lint. This ensures that
-/// expectations at the checked nodes will be fulfilled.
-pub fn is_lint_allowed(cx: &LateContext<'_>, lint: &'static Lint, id: HirId) -> bool {
-    cx.tcx.lint_level_at_node(lint, id).0 == Level::Allow
-}
-
-pub fn strip_pat_refs<'hir>(mut pat: &'hir Pat<'hir>) -> &'hir Pat<'hir> {
-    while let PatKind::Ref(subpat, _) = pat.kind {
-        pat = subpat;
-    }
-    pat
-}
-
-pub fn int_bits(tcx: TyCtxt<'_>, ity: rustc_ty::IntTy) -> u64 {
-    Integer::from_int_ty(&tcx, ity).size().bits()
-}
-
-#[expect(clippy::cast_possible_wrap)]
-/// Turn a constant int byte representation into an i128
-pub fn sext(tcx: TyCtxt<'_>, u: u128, ity: rustc_ty::IntTy) -> i128 {
-    let amt = 128 - int_bits(tcx, ity);
-    ((u as i128) << amt) >> amt
-}
-
-#[expect(clippy::cast_sign_loss)]
-/// clip unused bytes
-pub fn unsext(tcx: TyCtxt<'_>, u: i128, ity: rustc_ty::IntTy) -> u128 {
-    let amt = 128 - int_bits(tcx, ity);
-    ((u as u128) << amt) >> amt
-}
-
-/// clip unused bytes
-pub fn clip(tcx: TyCtxt<'_>, u: u128, ity: rustc_ty::UintTy) -> u128 {
-    let bits = Integer::from_uint_ty(&tcx, ity).size().bits();
-    let amt = 128 - bits;
-    (u << amt) >> amt
-}
-
-pub fn has_attr(attrs: &[ast::Attribute], symbol: Symbol) -> bool {
-    attrs.iter().any(|attr| attr.has_name(symbol))
-}
-
-pub fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
-    has_attr(cx.tcx.hir().attrs(hir_id), sym::repr)
-}
-
-pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool {
-    let map = &tcx.hir();
-    let mut prev_enclosing_node = None;
-    let mut enclosing_node = node;
-    while Some(enclosing_node) != prev_enclosing_node {
-        if has_attr(map.attrs(enclosing_node), symbol) {
-            return true;
-        }
-        prev_enclosing_node = Some(enclosing_node);
-        enclosing_node = map.get_parent_item(enclosing_node).into();
-    }
-
-    false
-}
-
-pub fn any_parent_is_automatically_derived(tcx: TyCtxt<'_>, node: HirId) -> bool {
-    any_parent_has_attr(tcx, node, sym::automatically_derived)
-}
-
-/// Matches a function call with the given path and returns the arguments.
-///
-/// Usage:
-///
-/// ```rust,ignore
-/// if let Some(args) = match_function_call(cx, cmp_max_call, &paths::CMP_MAX);
-/// ```
-/// This function is deprecated. Use [`match_function_call_with_def_id`].
-pub fn match_function_call<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    path: &[&str],
-) -> Option<&'tcx [Expr<'tcx>]> {
-    if_chain! {
-        if let ExprKind::Call(fun, args) = expr.kind;
-        if let ExprKind::Path(ref qpath) = fun.kind;
-        if let Some(fun_def_id) = cx.qpath_res(qpath, fun.hir_id).opt_def_id();
-        if match_def_path(cx, fun_def_id, path);
-        then {
-            return Some(args);
-        }
-    };
-    None
-}
-
-pub fn match_function_call_with_def_id<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'_>,
-    fun_def_id: DefId,
-) -> Option<&'tcx [Expr<'tcx>]> {
-    if_chain! {
-        if let ExprKind::Call(fun, args) = expr.kind;
-        if let ExprKind::Path(ref qpath) = fun.kind;
-        if cx.qpath_res(qpath, fun.hir_id).opt_def_id() == Some(fun_def_id);
-        then {
-            return Some(args);
-        }
-    };
-    None
-}
-
-/// Checks if the given `DefId` matches any of the paths. Returns the index of matching path, if
-/// any.
-///
-/// Please use `tcx.get_diagnostic_name` if the targets are all diagnostic items.
-pub fn match_any_def_paths(cx: &LateContext<'_>, did: DefId, paths: &[&[&str]]) -> Option<usize> {
-    let search_path = cx.get_def_path(did);
-    paths
-        .iter()
-        .position(|p| p.iter().map(|x| Symbol::intern(x)).eq(search_path.iter().copied()))
-}
-
-/// Checks if the given `DefId` matches the path.
-pub fn match_def_path(cx: &LateContext<'_>, did: DefId, syms: &[&str]) -> bool {
-    // We should probably move to Symbols in Clippy as well rather than interning every time.
-    let path = cx.get_def_path(did);
-    syms.iter().map(|x| Symbol::intern(x)).eq(path.iter().copied())
-}
-
-/// Checks if the given `DefId` matches the `libc` item.
-pub fn match_libc_symbol(cx: &LateContext<'_>, did: DefId, name: &str) -> bool {
-    let path = cx.get_def_path(did);
-    // libc is meant to be used as a flat list of names, but they're all actually defined in different
-    // modules based on the target platform. Ignore everything but crate name and the item name.
-    path.first().map_or(false, |s| s.as_str() == "libc") && path.last().map_or(false, |s| s.as_str() == name)
-}
-
-/// Returns the list of condition expressions and the list of blocks in a
-/// sequence of `if/else`.
-/// E.g., this returns `([a, b], [c, d, e])` for the expression
-/// `if a { c } else if b { d } else { e }`.
-pub fn if_sequence<'tcx>(mut expr: &'tcx Expr<'tcx>) -> (Vec<&'tcx Expr<'tcx>>, Vec<&'tcx Block<'tcx>>) {
-    let mut conds = Vec::new();
-    let mut blocks: Vec<&Block<'_>> = Vec::new();
-
-    while let Some(higher::IfOrIfLet { cond, then, r#else }) = higher::IfOrIfLet::hir(expr) {
-        conds.push(cond);
-        if let ExprKind::Block(block, _) = then.kind {
-            blocks.push(block);
-        } else {
-            panic!("ExprKind::If node is not an ExprKind::Block");
-        }
-
-        if let Some(else_expr) = r#else {
-            expr = else_expr;
-        } else {
-            break;
-        }
-    }
-
-    // final `else {..}`
-    if !blocks.is_empty() {
-        if let ExprKind::Block(block, _) = expr.kind {
-            blocks.push(block);
-        }
-    }
-
-    (conds, blocks)
-}
-
-/// Checks if the given function kind is an async function.
-pub fn is_async_fn(kind: FnKind<'_>) -> bool {
-    match kind {
-        FnKind::ItemFn(_, _, header) => header.asyncness.is_async(),
-        FnKind::Method(_, sig) => sig.header.asyncness.is_async(),
-        FnKind::Closure => false,
-    }
-}
-
-/// Peels away all the compiler generated code surrounding the body of an async function,
-pub fn get_async_fn_body<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'_>) -> Option<&'tcx Expr<'tcx>> {
-    if let ExprKind::Closure(&Closure { body, .. }) = body.value.kind {
-        if let ExprKind::Block(
-            Block {
-                stmts: [],
-                expr:
-                    Some(Expr {
-                        kind: ExprKind::DropTemps(expr),
-                        ..
-                    }),
-                ..
-            },
-            _,
-        ) = tcx.hir().body(body).value.kind
-        {
-            return Some(expr);
-        }
-    };
-    None
-}
-
-// check if expr is calling method or function with #[must_use] attribute
-pub fn is_must_use_func_call(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let did = match expr.kind {
-        ExprKind::Call(path, _) => if_chain! {
-            if let ExprKind::Path(ref qpath) = path.kind;
-            if let def::Res::Def(_, did) = cx.qpath_res(qpath, path.hir_id);
-            then {
-                Some(did)
-            } else {
-                None
-            }
-        },
-        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
-        _ => None,
-    };
-
-    did.map_or(false, |did| cx.tcx.has_attr(did, sym::must_use))
-}
-
-/// Checks if an expression represents the identity function
-/// Only examines closures and `std::convert::identity`
-pub fn is_expr_identity_function(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    /// Checks if a function's body represents the identity function. Looks for bodies of the form:
-    /// * `|x| x`
-    /// * `|x| return x`
-    /// * `|x| { return x }`
-    /// * `|x| { return x; }`
-    fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
-        let id = if_chain! {
-            if let [param] = func.params;
-            if let PatKind::Binding(_, id, _, _) = param.pat.kind;
-            then {
-                id
-            } else {
-                return false;
-            }
-        };
-
-        let mut expr = func.value;
-        loop {
-            match expr.kind {
-                #[rustfmt::skip]
-                ExprKind::Block(&Block { stmts: [], expr: Some(e), .. }, _, )
-                | ExprKind::Ret(Some(e)) => expr = e,
-                #[rustfmt::skip]
-                ExprKind::Block(&Block { stmts: [stmt], expr: None, .. }, _) => {
-                    if_chain! {
-                        if let StmtKind::Semi(e) | StmtKind::Expr(e) = stmt.kind;
-                        if let ExprKind::Ret(Some(ret_val)) = e.kind;
-                        then {
-                            expr = ret_val;
-                        } else {
-                            return false;
-                        }
-                    }
-                },
-                _ => return path_to_local_id(expr, id) && cx.typeck_results().expr_adjustments(expr).is_empty(),
-            }
-        }
-    }
-
-    match expr.kind {
-        ExprKind::Closure(&Closure { body, .. }) => is_body_identity_function(cx, cx.tcx.hir().body(body)),
-        _ => path_def_id(cx, expr).map_or(false, |id| match_def_path(cx, id, &paths::CONVERT_IDENTITY)),
-    }
-}
-
-/// Gets the node where an expression is either used, or it's type is unified with another branch.
-/// Returns both the node and the `HirId` of the closest child node.
-pub fn get_expr_use_or_unification_node<'tcx>(tcx: TyCtxt<'tcx>, expr: &Expr<'_>) -> Option<(Node<'tcx>, HirId)> {
-    let mut child_id = expr.hir_id;
-    let mut iter = tcx.hir().parent_iter(child_id);
-    loop {
-        match iter.next() {
-            None => break None,
-            Some((id, Node::Block(_))) => child_id = id,
-            Some((id, Node::Arm(arm))) if arm.body.hir_id == child_id => child_id = id,
-            Some((_, Node::Expr(expr))) => match expr.kind {
-                ExprKind::Match(_, [arm], _) if arm.hir_id == child_id => child_id = expr.hir_id,
-                ExprKind::Block(..) | ExprKind::DropTemps(_) => child_id = expr.hir_id,
-                ExprKind::If(_, then_expr, None) if then_expr.hir_id == child_id => break None,
-                _ => break Some((Node::Expr(expr), child_id)),
-            },
-            Some((_, node)) => break Some((node, child_id)),
-        }
-    }
-}
-
-/// Checks if the result of an expression is used, or it's type is unified with another branch.
-pub fn is_expr_used_or_unified(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
-    !matches!(
-        get_expr_use_or_unification_node(tcx, expr),
-        None | Some((
-            Node::Stmt(Stmt {
-                kind: StmtKind::Expr(_)
-                    | StmtKind::Semi(_)
-                    | StmtKind::Local(Local {
-                        pat: Pat {
-                            kind: PatKind::Wild,
-                            ..
-                        },
-                        ..
-                    }),
-                ..
-            }),
-            _
-        ))
-    )
-}
-
-/// Checks if the expression is the final expression returned from a block.
-pub fn is_expr_final_block_expr(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> bool {
-    matches!(get_parent_node(tcx, expr.hir_id), Some(Node::Block(..)))
-}
-
-pub fn std_or_core(cx: &LateContext<'_>) -> Option<&'static str> {
-    if !is_no_std_crate(cx) {
-        Some("std")
-    } else if !is_no_core_crate(cx) {
-        Some("core")
-    } else {
-        None
-    }
-}
-
-pub fn is_no_std_crate(cx: &LateContext<'_>) -> bool {
-    cx.tcx.hir().attrs(hir::CRATE_HIR_ID).iter().any(|attr| {
-        if let ast::AttrKind::Normal(ref normal) = attr.kind {
-            normal.item.path == sym::no_std
-        } else {
-            false
-        }
-    })
-}
-
-pub fn is_no_core_crate(cx: &LateContext<'_>) -> bool {
-    cx.tcx.hir().attrs(hir::CRATE_HIR_ID).iter().any(|attr| {
-        if let ast::AttrKind::Normal(ref normal) = attr.kind {
-            normal.item.path == sym::no_core
-        } else {
-            false
-        }
-    })
-}
-
-/// Check if parent of a hir node is a trait implementation block.
-/// For example, `f` in
-/// ```rust
-/// # struct S;
-/// # trait Trait { fn f(); }
-/// impl Trait for S {
-///     fn f() {}
-/// }
-/// ```
-pub fn is_trait_impl_item(cx: &LateContext<'_>, hir_id: HirId) -> bool {
-    if let Some(Node::Item(item)) = cx.tcx.hir().find_parent(hir_id) {
-        matches!(item.kind, ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }))
-    } else {
-        false
-    }
-}
-
-/// Check if it's even possible to satisfy the `where` clause for the item.
-///
-/// `trivial_bounds` feature allows functions with unsatisfiable bounds, for example:
-///
-/// ```ignore
-/// fn foo() where i32: Iterator {
-///     for _ in 2i32 {}
-/// }
-/// ```
-pub fn fn_has_unsatisfiable_preds(cx: &LateContext<'_>, did: DefId) -> bool {
-    use rustc_trait_selection::traits;
-    let predicates = cx
-        .tcx
-        .predicates_of(did)
-        .predicates
-        .iter()
-        .filter_map(|(p, _)| if p.is_global() { Some(*p) } else { None });
-    traits::impossible_predicates(cx.tcx, traits::elaborate(cx.tcx, predicates).collect::<Vec<_>>())
-}
-
-/// Returns the `DefId` of the callee if the given expression is a function or method call.
-pub fn fn_def_id(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<DefId> {
-    match &expr.kind {
-        ExprKind::MethodCall(..) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
-        ExprKind::Call(
-            Expr {
-                kind: ExprKind::Path(qpath),
-                hir_id: path_hir_id,
-                ..
-            },
-            ..,
-        ) => {
-            // Only return Fn-like DefIds, not the DefIds of statics/consts/etc that contain or
-            // deref to fn pointers, dyn Fn, impl Fn - #8850
-            if let Res::Def(DefKind::Fn | DefKind::Ctor(..) | DefKind::AssocFn, id) =
-                cx.typeck_results().qpath_res(qpath, *path_hir_id)
-            {
-                Some(id)
-            } else {
-                None
-            }
-        },
-        _ => None,
-    }
-}
-
-/// Returns `Option<String>` where String is a textual representation of the type encapsulated in
-/// the slice iff the given expression is a slice of primitives (as defined in the
-/// `is_recursively_primitive_type` function) and `None` otherwise.
-pub fn is_slice_of_primitives(cx: &LateContext<'_>, expr: &Expr<'_>) -> Option<String> {
-    let expr_type = cx.typeck_results().expr_ty_adjusted(expr);
-    let expr_kind = expr_type.kind();
-    let is_primitive = match expr_kind {
-        rustc_ty::Slice(element_type) => is_recursively_primitive_type(*element_type),
-        rustc_ty::Ref(_, inner_ty, _) if matches!(inner_ty.kind(), &rustc_ty::Slice(_)) => {
-            if let rustc_ty::Slice(element_type) = inner_ty.kind() {
-                is_recursively_primitive_type(*element_type)
-            } else {
-                unreachable!()
-            }
-        },
-        _ => false,
-    };
-
-    if is_primitive {
-        // if we have wrappers like Array, Slice or Tuple, print these
-        // and get the type enclosed in the slice ref
-        match expr_type.peel_refs().walk().nth(1).unwrap().expect_ty().kind() {
-            rustc_ty::Slice(..) => return Some("slice".into()),
-            rustc_ty::Array(..) => return Some("array".into()),
-            rustc_ty::Tuple(..) => return Some("tuple".into()),
-            _ => {
-                // is_recursively_primitive_type() should have taken care
-                // of the rest and we can rely on the type that is found
-                let refs_peeled = expr_type.peel_refs();
-                return Some(refs_peeled.walk().last().unwrap().to_string());
-            },
-        }
-    }
-    None
-}
-
-/// Returns list of all pairs `(a, b)` where `eq(a, b) == true`
-/// and `a` is before `b` in `exprs` for all `a` and `b` in
-/// `exprs`
-///
-/// Given functions `eq` and `hash` such that `eq(a, b) == true`
-/// implies `hash(a) == hash(b)`
-pub fn search_same<T, Hash, Eq>(exprs: &[T], hash: Hash, eq: Eq) -> Vec<(&T, &T)>
-where
-    Hash: Fn(&T) -> u64,
-    Eq: Fn(&T, &T) -> bool,
-{
-    match exprs {
-        [a, b] if eq(a, b) => return vec![(a, b)],
-        _ if exprs.len() <= 2 => return vec![],
-        _ => {},
-    }
-
-    let mut match_expr_list: Vec<(&T, &T)> = Vec::new();
-
-    let mut map: UnhashMap<u64, Vec<&_>> =
-        UnhashMap::with_capacity_and_hasher(exprs.len(), BuildHasherDefault::default());
-
-    for expr in exprs {
-        match map.entry(hash(expr)) {
-            Entry::Occupied(mut o) => {
-                for o in o.get() {
-                    if eq(o, expr) {
-                        match_expr_list.push((o, expr));
-                    }
-                }
-                o.get_mut().push(expr);
-            },
-            Entry::Vacant(v) => {
-                v.insert(vec![expr]);
-            },
-        }
-    }
-
-    match_expr_list
-}
-
-/// Peels off all references on the pattern. Returns the underlying pattern and the number of
-/// references removed.
-pub fn peel_hir_pat_refs<'a>(pat: &'a Pat<'a>) -> (&'a Pat<'a>, usize) {
-    fn peel<'a>(pat: &'a Pat<'a>, count: usize) -> (&'a Pat<'a>, usize) {
-        if let PatKind::Ref(pat, _) = pat.kind {
-            peel(pat, count + 1)
-        } else {
-            (pat, count)
-        }
-    }
-    peel(pat, 0)
-}
-
-/// Peels of expressions while the given closure returns `Some`.
-pub fn peel_hir_expr_while<'tcx>(
-    mut expr: &'tcx Expr<'tcx>,
-    mut f: impl FnMut(&'tcx Expr<'tcx>) -> Option<&'tcx Expr<'tcx>>,
-) -> &'tcx Expr<'tcx> {
-    while let Some(e) = f(expr) {
-        expr = e;
-    }
-    expr
-}
-
-/// Peels off up to the given number of references on the expression. Returns the underlying
-/// expression and the number of references removed.
-pub fn peel_n_hir_expr_refs<'a>(expr: &'a Expr<'a>, count: usize) -> (&'a Expr<'a>, usize) {
-    let mut remaining = count;
-    let e = peel_hir_expr_while(expr, |e| match e.kind {
-        ExprKind::AddrOf(ast::BorrowKind::Ref, _, e) if remaining != 0 => {
-            remaining -= 1;
-            Some(e)
-        },
-        _ => None,
-    });
-    (e, count - remaining)
-}
-
-/// Peels off all unary operators of an expression. Returns the underlying expression and the number
-/// of operators removed.
-pub fn peel_hir_expr_unary<'a>(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
-    let mut count: usize = 0;
-    let mut curr_expr = expr;
-    while let ExprKind::Unary(_, local_expr) = curr_expr.kind {
-        count = count.wrapping_add(1);
-        curr_expr = local_expr;
-    }
-    (curr_expr, count)
-}
-
-/// Peels off all references on the expression. Returns the underlying expression and the number of
-/// references removed.
-pub fn peel_hir_expr_refs<'a>(expr: &'a Expr<'a>) -> (&'a Expr<'a>, usize) {
-    let mut count = 0;
-    let e = peel_hir_expr_while(expr, |e| match e.kind {
-        ExprKind::AddrOf(ast::BorrowKind::Ref, _, e) => {
-            count += 1;
-            Some(e)
-        },
-        _ => None,
-    });
-    (e, count)
-}
-
-/// Peels off all references on the type. Returns the underlying type and the number of references
-/// removed.
-pub fn peel_hir_ty_refs<'a>(mut ty: &'a hir::Ty<'a>) -> (&'a hir::Ty<'a>, usize) {
-    let mut count = 0;
-    loop {
-        match &ty.kind {
-            TyKind::Ref(_, ref_ty) => {
-                ty = ref_ty.ty;
-                count += 1;
-            },
-            _ => break (ty, count),
-        }
-    }
-}
-
-/// Removes `AddrOf` operators (`&`) or deref operators (`*`), but only if a reference type is
-/// dereferenced. An overloaded deref such as `Vec` to slice would not be removed.
-pub fn peel_ref_operators<'hir>(cx: &LateContext<'_>, mut expr: &'hir Expr<'hir>) -> &'hir Expr<'hir> {
-    loop {
-        match expr.kind {
-            ExprKind::AddrOf(_, _, e) => expr = e,
-            ExprKind::Unary(UnOp::Deref, e) if cx.typeck_results().expr_ty(e).is_ref() => expr = e,
-            _ => break,
-        }
-    }
-    expr
-}
-
-pub fn is_hir_ty_cfg_dependant(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> bool {
-    if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
-        if let Res::Def(_, def_id) = path.res {
-            return cx.tcx.has_attr(def_id, sym::cfg) || cx.tcx.has_attr(def_id, sym::cfg_attr);
-        }
-    }
-    false
-}
-
-static TEST_ITEM_NAMES_CACHE: OnceLock<Mutex<FxHashMap<LocalModDefId, Vec<Symbol>>>> = OnceLock::new();
-
-fn with_test_item_names(tcx: TyCtxt<'_>, module: LocalModDefId, f: impl Fn(&[Symbol]) -> bool) -> bool {
-    let cache = TEST_ITEM_NAMES_CACHE.get_or_init(|| Mutex::new(FxHashMap::default()));
-    let mut map: MutexGuard<'_, FxHashMap<LocalModDefId, Vec<Symbol>>> = cache.lock().unwrap();
-    let value = map.entry(module);
-    match value {
-        Entry::Occupied(entry) => f(entry.get()),
-        Entry::Vacant(entry) => {
-            let mut names = Vec::new();
-            for id in tcx.hir().module_items(module) {
-                if matches!(tcx.def_kind(id.owner_id), DefKind::Const)
-                    && let item = tcx.hir().item(id)
-                    && let ItemKind::Const(ty, _generics, _body) = item.kind {
-                    if let TyKind::Path(QPath::Resolved(_, path)) = ty.kind {
-                        // We could also check for the type name `test::TestDescAndFn`
-                        if let Res::Def(DefKind::Struct, _) = path.res {
-                            let has_test_marker = tcx
-                                .hir()
-                                .attrs(item.hir_id())
-                                .iter()
-                                .any(|a| a.has_name(sym::rustc_test_marker));
-                            if has_test_marker {
-                                names.push(item.ident.name);
-                            }
-                        }
-                    }
-                }
-            }
-            names.sort_unstable();
-            f(entry.insert(names))
-        },
-    }
-}
-
-/// Checks if the function containing the given `HirId` is a `#[test]` function
-///
-/// Note: Add `//@compile-flags: --test` to UI tests with a `#[test]` function
-pub fn is_in_test_function(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
-    with_test_item_names(tcx, tcx.parent_module(id), |names| {
-        tcx.hir()
-            .parent_iter(id)
-            // Since you can nest functions we need to collect all until we leave
-            // function scope
-            .any(|(_id, node)| {
-                if let Node::Item(item) = node {
-                    if let ItemKind::Fn(_, _, _) = item.kind {
-                        // Note that we have sorted the item names in the visitor,
-                        // so the binary_search gets the same as `contains`, but faster.
-                        return names.binary_search(&item.ident.name).is_ok();
-                    }
-                }
-                false
-            })
-    })
-}
-
-/// Checks if the item containing the given `HirId` has `#[cfg(test)]` attribute applied
-///
-/// Note: Add `//@compile-flags: --test` to UI tests with a `#[cfg(test)]` function
-pub fn is_in_cfg_test(tcx: TyCtxt<'_>, id: hir::HirId) -> bool {
-    fn is_cfg_test(attr: &Attribute) -> bool {
-        if attr.has_name(sym::cfg)
-            && let Some(items) = attr.meta_item_list()
-            && let [item] = &*items
-            && item.has_name(sym::test)
-        {
-            true
-        } else {
-            false
-        }
-    }
-    tcx.hir()
-        .parent_iter(id)
-        .flat_map(|(parent_id, _)| tcx.hir().attrs(parent_id))
-        .any(is_cfg_test)
-}
-
-/// Checks if the item of any of its parents has `#[cfg(...)]` attribute applied.
-pub fn inherits_cfg(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
-    let hir = tcx.hir();
-
-    tcx.has_attr(def_id, sym::cfg)
-        || hir
-            .parent_iter(hir.local_def_id_to_hir_id(def_id))
-            .flat_map(|(parent_id, _)| hir.attrs(parent_id))
-            .any(|attr| attr.has_name(sym::cfg))
-}
-
-/// Checks whether item either has `test` attribute applied, or
-/// is a module with `test` in its name.
-///
-/// Note: Add `//@compile-flags: --test` to UI tests with a `#[test]` function
-pub fn is_test_module_or_function(tcx: TyCtxt<'_>, item: &Item<'_>) -> bool {
-    is_in_test_function(tcx, item.hir_id())
-        || matches!(item.kind, ItemKind::Mod(..))
-            && item.ident.name.as_str().split('_').any(|a| a == "test" || a == "tests")
-}
-
-/// Walks the HIR tree from the given expression, up to the node where the value produced by the
-/// expression is consumed. Calls the function for every node encountered this way until it returns
-/// `Some`.
-///
-/// This allows walking through `if`, `match`, `break`, block expressions to find where the value
-/// produced by the expression is consumed.
-pub fn walk_to_expr_usage<'tcx, T>(
-    cx: &LateContext<'tcx>,
-    e: &Expr<'tcx>,
-    mut f: impl FnMut(Node<'tcx>, HirId) -> Option<T>,
-) -> Option<T> {
-    let map = cx.tcx.hir();
-    let mut iter = map.parent_iter(e.hir_id);
-    let mut child_id = e.hir_id;
-
-    while let Some((parent_id, parent)) = iter.next() {
-        if let Some(x) = f(parent, child_id) {
-            return Some(x);
-        }
-        let parent = match parent {
-            Node::Expr(e) => e,
-            Node::Block(Block { expr: Some(body), .. }) | Node::Arm(Arm { body, .. }) if body.hir_id == child_id => {
-                child_id = parent_id;
-                continue;
-            },
-            Node::Arm(a) if a.body.hir_id == child_id => {
-                child_id = parent_id;
-                continue;
-            },
-            _ => return None,
-        };
-        match parent.kind {
-            ExprKind::If(child, ..) | ExprKind::Match(child, ..) if child.hir_id != child_id => child_id = parent_id,
-            ExprKind::Break(Destination { target_id: Ok(id), .. }, _) => {
-                child_id = id;
-                iter = map.parent_iter(id);
-            },
-            ExprKind::Block(..) => child_id = parent_id,
-            _ => return None,
-        }
-    }
-    None
-}
-
-/// A type definition as it would be viewed from within a function.
-#[derive(Clone, Copy)]
-pub enum DefinedTy<'tcx> {
-    // Used for locals and closures defined within the function.
-    Hir(&'tcx hir::Ty<'tcx>),
-    /// Used for function signatures, and constant and static values. This includes the `ParamEnv`
-    /// from the definition site.
-    Mir(ParamEnvAnd<'tcx, Binder<'tcx, Ty<'tcx>>>),
-}
-
-/// The context an expressions value is used in.
-pub struct ExprUseCtxt<'tcx> {
-    /// The parent node which consumes the value.
-    pub node: ExprUseNode<'tcx>,
-    /// Any adjustments applied to the type.
-    pub adjustments: &'tcx [Adjustment<'tcx>],
-    /// Whether or not the type must unify with another code path.
-    pub is_ty_unified: bool,
-    /// Whether or not the value will be moved before it's used.
-    pub moved_before_use: bool,
-}
-
-/// The node which consumes a value.
-pub enum ExprUseNode<'tcx> {
-    /// Assignment to, or initializer for, a local
-    Local(&'tcx Local<'tcx>),
-    /// Initializer for a const or static item.
-    ConstStatic(OwnerId),
-    /// Implicit or explicit return from a function.
-    Return(OwnerId),
-    /// Initialization of a struct field.
-    Field(&'tcx ExprField<'tcx>),
-    /// An argument to a function.
-    FnArg(&'tcx Expr<'tcx>, usize),
-    /// An argument to a method.
-    MethodArg(HirId, Option<&'tcx GenericArgs<'tcx>>, usize),
-    /// The callee of a function call.
-    Callee,
-    /// Access of a field.
-    FieldAccess(Ident),
-}
-impl<'tcx> ExprUseNode<'tcx> {
-    /// Checks if the value is returned from the function.
-    pub fn is_return(&self) -> bool {
-        matches!(self, Self::Return(_))
-    }
-
-    /// Checks if the value is used as a method call receiver.
-    pub fn is_recv(&self) -> bool {
-        matches!(self, Self::MethodArg(_, _, 0))
-    }
-
-    /// Gets the needed type as it's defined without any type inference.
-    pub fn defined_ty(&self, cx: &LateContext<'tcx>) -> Option<DefinedTy<'tcx>> {
-        match *self {
-            Self::Local(Local { ty: Some(ty), .. }) => Some(DefinedTy::Hir(ty)),
-            Self::ConstStatic(id) => Some(DefinedTy::Mir(
-                cx.param_env
-                    .and(Binder::dummy(cx.tcx.type_of(id).instantiate_identity())),
-            )),
-            Self::Return(id) => {
-                let hir_id = cx.tcx.hir().local_def_id_to_hir_id(id.def_id);
-                if let Some(Node::Expr(Expr {
-                    kind: ExprKind::Closure(c),
-                    ..
-                })) = cx.tcx.hir().find(hir_id)
-                {
-                    match c.fn_decl.output {
-                        FnRetTy::DefaultReturn(_) => None,
-                        FnRetTy::Return(ty) => Some(DefinedTy::Hir(ty)),
-                    }
-                } else {
-                    Some(DefinedTy::Mir(
-                        cx.param_env.and(cx.tcx.fn_sig(id).instantiate_identity().output()),
-                    ))
-                }
-            },
-            Self::Field(field) => match get_parent_expr_for_hir(cx, field.hir_id) {
-                Some(Expr {
-                    hir_id,
-                    kind: ExprKind::Struct(path, ..),
-                    ..
-                }) => adt_and_variant_of_res(cx, cx.qpath_res(path, *hir_id))
-                    .and_then(|(adt, variant)| {
-                        variant
-                            .fields
-                            .iter()
-                            .find(|f| f.name == field.ident.name)
-                            .map(|f| (adt, f))
-                    })
-                    .map(|(adt, field_def)| {
-                        DefinedTy::Mir(
-                            cx.tcx
-                                .param_env(adt.did())
-                                .and(Binder::dummy(cx.tcx.type_of(field_def.did).instantiate_identity())),
-                        )
-                    }),
-                _ => None,
-            },
-            Self::FnArg(callee, i) => {
-                let sig = expr_sig(cx, callee)?;
-                let (hir_ty, ty) = sig.input_with_hir(i)?;
-                Some(match hir_ty {
-                    Some(hir_ty) => DefinedTy::Hir(hir_ty),
-                    None => DefinedTy::Mir(
-                        sig.predicates_id()
-                            .map_or(ParamEnv::empty(), |id| cx.tcx.param_env(id))
-                            .and(ty),
-                    ),
-                })
-            },
-            Self::MethodArg(id, _, i) => {
-                let id = cx.typeck_results().type_dependent_def_id(id)?;
-                let sig = cx.tcx.fn_sig(id).skip_binder();
-                Some(DefinedTy::Mir(cx.tcx.param_env(id).and(sig.input(i))))
-            },
-            Self::Local(_) | Self::FieldAccess(..) | Self::Callee => None,
-        }
-    }
-}
-
-/// Gets the context an expression's value is used in.
-#[expect(clippy::too_many_lines)]
-pub fn expr_use_ctxt<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> Option<ExprUseCtxt<'tcx>> {
-    let mut adjustments = [].as_slice();
-    let mut is_ty_unified = false;
-    let mut moved_before_use = false;
-    let ctxt = e.span.ctxt();
-    walk_to_expr_usage(cx, e, &mut |parent, child_id| {
-        // LocalTableInContext returns the wrong lifetime, so go use `expr_adjustments` instead.
-        if adjustments.is_empty() && let Node::Expr(e) = cx.tcx.hir().get(child_id) {
-            adjustments = cx.typeck_results().expr_adjustments(e);
-        }
-        match parent {
-            Node::Local(l) if l.span.ctxt() == ctxt => Some(ExprUseCtxt {
-                node: ExprUseNode::Local(l),
-                adjustments,
-                is_ty_unified,
-                moved_before_use,
-            }),
-            Node::Item(&Item {
-                kind: ItemKind::Static(..) | ItemKind::Const(..),
-                owner_id,
-                span,
-                ..
-            })
-            | Node::TraitItem(&TraitItem {
-                kind: TraitItemKind::Const(..),
-                owner_id,
-                span,
-                ..
-            })
-            | Node::ImplItem(&ImplItem {
-                kind: ImplItemKind::Const(..),
-                owner_id,
-                span,
-                ..
-            }) if span.ctxt() == ctxt => Some(ExprUseCtxt {
-                node: ExprUseNode::ConstStatic(owner_id),
-                adjustments,
-                is_ty_unified,
-                moved_before_use,
-            }),
-
-            Node::Item(&Item {
-                kind: ItemKind::Fn(..),
-                owner_id,
-                span,
-                ..
-            })
-            | Node::TraitItem(&TraitItem {
-                kind: TraitItemKind::Fn(..),
-                owner_id,
-                span,
-                ..
-            })
-            | Node::ImplItem(&ImplItem {
-                kind: ImplItemKind::Fn(..),
-                owner_id,
-                span,
-                ..
-            }) if span.ctxt() == ctxt => Some(ExprUseCtxt {
-                node: ExprUseNode::Return(owner_id),
-                adjustments,
-                is_ty_unified,
-                moved_before_use,
-            }),
-
-            Node::ExprField(field) if field.span.ctxt() == ctxt => Some(ExprUseCtxt {
-                node: ExprUseNode::Field(field),
-                adjustments,
-                is_ty_unified,
-                moved_before_use,
-            }),
-
-            Node::Expr(parent) if parent.span.ctxt() == ctxt => match parent.kind {
-                ExprKind::Ret(_) => Some(ExprUseCtxt {
-                    node: ExprUseNode::Return(OwnerId {
-                        def_id: cx.tcx.hir().body_owner_def_id(cx.enclosing_body.unwrap()),
-                    }),
-                    adjustments,
-                    is_ty_unified,
-                    moved_before_use,
-                }),
-                ExprKind::Closure(closure) => Some(ExprUseCtxt {
-                    node: ExprUseNode::Return(OwnerId { def_id: closure.def_id }),
-                    adjustments,
-                    is_ty_unified,
-                    moved_before_use,
-                }),
-                ExprKind::Call(func, args) => Some(ExprUseCtxt {
-                    node: match args.iter().position(|arg| arg.hir_id == child_id) {
-                        Some(i) => ExprUseNode::FnArg(func, i),
-                        None => ExprUseNode::Callee,
-                    },
-                    adjustments,
-                    is_ty_unified,
-                    moved_before_use,
-                }),
-                ExprKind::MethodCall(name, _, args, _) => Some(ExprUseCtxt {
-                    node: ExprUseNode::MethodArg(
-                        parent.hir_id,
-                        name.args,
-                        args.iter().position(|arg| arg.hir_id == child_id).map_or(0, |i| i + 1),
-                    ),
-                    adjustments,
-                    is_ty_unified,
-                    moved_before_use,
-                }),
-                ExprKind::Field(child, name) if child.hir_id == e.hir_id => Some(ExprUseCtxt {
-                    node: ExprUseNode::FieldAccess(name),
-                    adjustments,
-                    is_ty_unified,
-                    moved_before_use,
-                }),
-                ExprKind::If(e, _, _) | ExprKind::Match(e, _, _) if e.hir_id != child_id => {
-                    is_ty_unified = true;
-                    moved_before_use = true;
-                    None
-                },
-                ExprKind::Block(_, Some(_)) | ExprKind::Break(..) => {
-                    is_ty_unified = true;
-                    moved_before_use = true;
-                    None
-                },
-                ExprKind::Block(..) => {
-                    moved_before_use = true;
-                    None
-                },
-                _ => None,
-            },
-            _ => None,
-        }
-    })
-}
-
-/// Tokenizes the input while keeping the text associated with each token.
-pub fn tokenize_with_text(s: &str) -> impl Iterator<Item = (TokenKind, &str)> {
-    let mut pos = 0;
-    tokenize(s).map(move |t| {
-        let end = pos + t.len;
-        let range = pos as usize..end as usize;
-        pos = end;
-        (t.kind, s.get(range).unwrap_or_default())
-    })
-}
-
-/// Checks whether a given span has any comment token
-/// This checks for all types of comment: line "//", block "/**", doc "///" "//!"
-pub fn span_contains_comment(sm: &SourceMap, span: Span) -> bool {
-    let Ok(snippet) = sm.span_to_snippet(span) else {
-        return false;
-    };
-    return tokenize(&snippet).any(|token| {
-        matches!(
-            token.kind,
-            TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }
-        )
-    });
-}
-
-/// Returns all the comments a given span contains
-///
-/// Comments are returned wrapped with their relevant delimiters
-pub fn span_extract_comment(sm: &SourceMap, span: Span) -> String {
-    let snippet = sm.span_to_snippet(span).unwrap_or_default();
-    let res = tokenize_with_text(&snippet)
-        .filter(|(t, _)| matches!(t, TokenKind::BlockComment { .. } | TokenKind::LineComment { .. }))
-        .map(|(_, s)| s)
-        .join("\n");
-    res
-}
-
-pub fn span_find_starting_semi(sm: &SourceMap, span: Span) -> Span {
-    sm.span_take_while(span, |&ch| ch == ' ' || ch == ';')
-}
-
-/// Returns whether the given let pattern and else body can be turned into a question mark
-///
-/// For this example:
-/// ```ignore
-/// let FooBar { a, b } = if let Some(a) = ex { a } else { return None };
-/// ```
-/// We get as parameters:
-/// ```ignore
-/// pat: Some(a)
-/// else_body: return None
-/// ```
-
-/// And for this example:
-/// ```ignore
-/// let Some(FooBar { a, b }) = ex else { return None };
-/// ```
-/// We get as parameters:
-/// ```ignore
-/// pat: Some(FooBar { a, b })
-/// else_body: return None
-/// ```
-
-/// We output `Some(a)` in the first instance, and `Some(FooBar { a, b })` in the second, because
-/// the question mark operator is applicable here. Callers have to check whether we are in a
-/// constant or not.
-pub fn pat_and_expr_can_be_question_mark<'a, 'hir>(
-    cx: &LateContext<'_>,
-    pat: &'a Pat<'hir>,
-    else_body: &Expr<'_>,
-) -> Option<&'a Pat<'hir>> {
-    if let PatKind::TupleStruct(pat_path, [inner_pat], _) = pat.kind &&
-        is_res_lang_ctor(cx, cx.qpath_res(&pat_path, pat.hir_id), OptionSome) &&
-        !is_refutable(cx, inner_pat) &&
-        let else_body = peel_blocks(else_body) &&
-        let ExprKind::Ret(Some(ret_val)) = else_body.kind &&
-        let ExprKind::Path(ret_path) = ret_val.kind &&
-        is_res_lang_ctor(cx, cx.qpath_res(&ret_path, ret_val.hir_id), OptionNone)
-    {
-        Some(inner_pat)
-    } else {
-        None
-    }
-}
-
-macro_rules! op_utils {
-    ($($name:ident $assign:ident)*) => {
-        /// Binary operation traits like `LangItem::Add`
-        pub static BINOP_TRAITS: &[LangItem] = &[$(LangItem::$name,)*];
-
-        /// Operator-Assign traits like `LangItem::AddAssign`
-        pub static OP_ASSIGN_TRAITS: &[LangItem] = &[$(LangItem::$assign,)*];
-
-        /// Converts `BinOpKind::Add` to `(LangItem::Add, LangItem::AddAssign)`, for example
-        pub fn binop_traits(kind: hir::BinOpKind) -> Option<(LangItem, LangItem)> {
-            match kind {
-                $(hir::BinOpKind::$name => Some((LangItem::$name, LangItem::$assign)),)*
-                _ => None,
-            }
-        }
-    };
-}
-
-op_utils! {
-    Add    AddAssign
-    Sub    SubAssign
-    Mul    MulAssign
-    Div    DivAssign
-    Rem    RemAssign
-    BitXor BitXorAssign
-    BitAnd BitAndAssign
-    BitOr  BitOrAssign
-    Shl    ShlAssign
-    Shr    ShrAssign
-}
diff --git a/scout-audit-clippy-utils/src/macros.rs b/scout-audit-clippy-utils/src/macros.rs
deleted file mode 100644
index 82508bcd..00000000
--- a/scout-audit-clippy-utils/src/macros.rs
+++ /dev/null
@@ -1,538 +0,0 @@
-#![allow(clippy::similar_names)] // `expr` and `expn`
-
-use crate::visitors::{for_each_expr, Descend};
-
-use arrayvec::ArrayVec;
-use rustc_ast::{FormatArgs, FormatArgument, FormatPlaceholder};
-use rustc_data_structures::fx::FxHashMap;
-use rustc_hir::{self as hir, Expr, ExprKind, HirId, Node, QPath};
-use rustc_lint::LateContext;
-use rustc_span::def_id::DefId;
-use rustc_span::hygiene::{self, MacroKind, SyntaxContext};
-use rustc_span::{sym, BytePos, ExpnData, ExpnId, ExpnKind, Span, SpanData, Symbol};
-use std::cell::OnceCell;
-use std::ops::ControlFlow;
-use std::rc::Rc;
-use std::sync::atomic::{AtomicBool, Ordering};
-
-const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
-    sym::assert_eq_macro,
-    sym::assert_macro,
-    sym::assert_ne_macro,
-    sym::debug_assert_eq_macro,
-    sym::debug_assert_macro,
-    sym::debug_assert_ne_macro,
-    sym::eprint_macro,
-    sym::eprintln_macro,
-    sym::format_args_macro,
-    sym::format_macro,
-    sym::print_macro,
-    sym::println_macro,
-    sym::std_panic_macro,
-    sym::write_macro,
-    sym::writeln_macro,
-];
-
-/// Returns true if a given Macro `DefId` is a format macro (e.g. `println!`)
-pub fn is_format_macro(cx: &LateContext<'_>, macro_def_id: DefId) -> bool {
-    if let Some(name) = cx.tcx.get_diagnostic_name(macro_def_id) {
-        FORMAT_MACRO_DIAG_ITEMS.contains(&name)
-    } else {
-        false
-    }
-}
-
-/// A macro call, like `vec![1, 2, 3]`.
-///
-/// Use `tcx.item_name(macro_call.def_id)` to get the macro name.
-/// Even better is to check if it is a diagnostic item.
-///
-/// This structure is similar to `ExpnData` but it precludes desugaring expansions.
-#[derive(Debug)]
-pub struct MacroCall {
-    /// Macro `DefId`
-    pub def_id: DefId,
-    /// Kind of macro
-    pub kind: MacroKind,
-    /// The expansion produced by the macro call
-    pub expn: ExpnId,
-    /// Span of the macro call site
-    pub span: Span,
-}
-
-impl MacroCall {
-    pub fn is_local(&self) -> bool {
-        span_is_local(self.span)
-    }
-}
-
-/// Returns an iterator of expansions that created the given span
-pub fn expn_backtrace(mut span: Span) -> impl Iterator<Item = (ExpnId, ExpnData)> {
-    std::iter::from_fn(move || {
-        let ctxt = span.ctxt();
-        if ctxt == SyntaxContext::root() {
-            return None;
-        }
-        let expn = ctxt.outer_expn();
-        let data = expn.expn_data();
-        span = data.call_site;
-        Some((expn, data))
-    })
-}
-
-/// Checks whether the span is from the root expansion or a locally defined macro
-pub fn span_is_local(span: Span) -> bool {
-    !span.from_expansion() || expn_is_local(span.ctxt().outer_expn())
-}
-
-/// Checks whether the expansion is the root expansion or a locally defined macro
-pub fn expn_is_local(expn: ExpnId) -> bool {
-    if expn == ExpnId::root() {
-        return true;
-    }
-    let data = expn.expn_data();
-    let backtrace = expn_backtrace(data.call_site);
-    std::iter::once((expn, data))
-        .chain(backtrace)
-        .find_map(|(_, data)| data.macro_def_id)
-        .map_or(true, DefId::is_local)
-}
-
-/// Returns an iterator of macro expansions that created the given span.
-/// Note that desugaring expansions are skipped.
-pub fn macro_backtrace(span: Span) -> impl Iterator<Item = MacroCall> {
-    expn_backtrace(span).filter_map(|(expn, data)| match data {
-        ExpnData {
-            kind: ExpnKind::Macro(kind, _),
-            macro_def_id: Some(def_id),
-            call_site: span,
-            ..
-        } => Some(MacroCall {
-            def_id,
-            kind,
-            expn,
-            span,
-        }),
-        _ => None,
-    })
-}
-
-/// If the macro backtrace of `span` has a macro call at the root expansion
-/// (i.e. not a nested macro call), returns `Some` with the `MacroCall`
-pub fn root_macro_call(span: Span) -> Option<MacroCall> {
-    macro_backtrace(span).last()
-}
-
-/// Like [`root_macro_call`], but only returns `Some` if `node` is the "first node"
-/// produced by the macro call, as in [`first_node_in_macro`].
-pub fn root_macro_call_first_node(cx: &LateContext<'_>, node: &impl HirNode) -> Option<MacroCall> {
-    if first_node_in_macro(cx, node) != Some(ExpnId::root()) {
-        return None;
-    }
-    root_macro_call(node.span())
-}
-
-/// Like [`macro_backtrace`], but only returns macro calls where `node` is the "first node" of the
-/// macro call, as in [`first_node_in_macro`].
-pub fn first_node_macro_backtrace(cx: &LateContext<'_>, node: &impl HirNode) -> impl Iterator<Item = MacroCall> {
-    let span = node.span();
-    first_node_in_macro(cx, node)
-        .into_iter()
-        .flat_map(move |expn| macro_backtrace(span).take_while(move |macro_call| macro_call.expn != expn))
-}
-
-/// If `node` is the "first node" in a macro expansion, returns `Some` with the `ExpnId` of the
-/// macro call site (i.e. the parent of the macro expansion). This generally means that `node`
-/// is the outermost node of an entire macro expansion, but there are some caveats noted below.
-/// This is useful for finding macro calls while visiting the HIR without processing the macro call
-/// at every node within its expansion.
-///
-/// If you already have immediate access to the parent node, it is simpler to
-/// just check the context of that span directly (e.g. `parent.span.from_expansion()`).
-///
-/// If a macro call is in statement position, it expands to one or more statements.
-/// In that case, each statement *and* their immediate descendants will all yield `Some`
-/// with the `ExpnId` of the containing block.
-///
-/// A node may be the "first node" of multiple macro calls in a macro backtrace.
-/// The expansion of the outermost macro call site is returned in such cases.
-pub fn first_node_in_macro(cx: &LateContext<'_>, node: &impl HirNode) -> Option<ExpnId> {
-    // get the macro expansion or return `None` if not found
-    // `macro_backtrace` importantly ignores desugaring expansions
-    let expn = macro_backtrace(node.span()).next()?.expn;
-
-    // get the parent node, possibly skipping over a statement
-    // if the parent is not found, it is sensible to return `Some(root)`
-    let hir = cx.tcx.hir();
-    let mut parent_iter = hir.parent_iter(node.hir_id());
-    let (parent_id, _) = match parent_iter.next() {
-        None => return Some(ExpnId::root()),
-        Some((_, Node::Stmt(_))) => match parent_iter.next() {
-            None => return Some(ExpnId::root()),
-            Some(next) => next,
-        },
-        Some(next) => next,
-    };
-
-    // get the macro expansion of the parent node
-    let parent_span = hir.span(parent_id);
-    let Some(parent_macro_call) = macro_backtrace(parent_span).next() else {
-        // the parent node is not in a macro
-        return Some(ExpnId::root());
-    };
-
-    if parent_macro_call.expn.is_descendant_of(expn) {
-        // `node` is input to a macro call
-        return None;
-    }
-
-    Some(parent_macro_call.expn)
-}
-
-/* Specific Macro Utils */
-
-/// Is `def_id` of `std::panic`, `core::panic` or any inner implementation macros
-pub fn is_panic(cx: &LateContext<'_>, def_id: DefId) -> bool {
-    let Some(name) = cx.tcx.get_diagnostic_name(def_id) else {
-        return false;
-    };
-    matches!(
-        name,
-        sym::core_panic_macro
-            | sym::std_panic_macro
-            | sym::core_panic_2015_macro
-            | sym::std_panic_2015_macro
-            | sym::core_panic_2021_macro
-    )
-}
-
-/// Is `def_id` of `assert!` or `debug_assert!`
-pub fn is_assert_macro(cx: &LateContext<'_>, def_id: DefId) -> bool {
-    let Some(name) = cx.tcx.get_diagnostic_name(def_id) else {
-        return false;
-    };
-    matches!(name, sym::assert_macro | sym::debug_assert_macro)
-}
-
-#[derive(Debug)]
-pub enum PanicExpn<'a> {
-    /// No arguments - `panic!()`
-    Empty,
-    /// A string literal or any `&str` - `panic!("message")` or `panic!(message)`
-    Str(&'a Expr<'a>),
-    /// A single argument that implements `Display` - `panic!("{}", object)`
-    Display(&'a Expr<'a>),
-    /// Anything else - `panic!("error {}: {}", a, b)`
-    Format(&'a Expr<'a>),
-}
-
-impl<'a> PanicExpn<'a> {
-    pub fn parse(expr: &'a Expr<'a>) -> Option<Self> {
-        let ExprKind::Call(callee, [arg, rest @ ..]) = &expr.kind else {
-            return None;
-        };
-        let ExprKind::Path(QPath::Resolved(_, path)) = &callee.kind else {
-            return None;
-        };
-        let result = match path.segments.last().unwrap().ident.as_str() {
-            "panic" if arg.span.ctxt() == expr.span.ctxt() => Self::Empty,
-            "panic" | "panic_str" => Self::Str(arg),
-            "panic_display" => {
-                let ExprKind::AddrOf(_, _, e) = &arg.kind else {
-                    return None;
-                };
-                Self::Display(e)
-            },
-            "panic_fmt" => Self::Format(arg),
-            // Since Rust 1.52, `assert_{eq,ne}` macros expand to use:
-            // `core::panicking::assert_failed(.., left_val, right_val, None | Some(format_args!(..)));`
-            "assert_failed" => {
-                // It should have 4 arguments in total (we already matched with the first argument,
-                // so we're just checking for 3)
-                if rest.len() != 3 {
-                    return None;
-                }
-                // `msg_arg` is either `None` (no custom message) or `Some(format_args!(..))` (custom message)
-                let msg_arg = &rest[2];
-                match msg_arg.kind {
-                    ExprKind::Call(_, [fmt_arg]) => Self::Format(fmt_arg),
-                    _ => Self::Empty,
-                }
-            },
-            _ => return None,
-        };
-        Some(result)
-    }
-}
-
-/// Finds the arguments of an `assert!` or `debug_assert!` macro call within the macro expansion
-pub fn find_assert_args<'a>(
-    cx: &LateContext<'_>,
-    expr: &'a Expr<'a>,
-    expn: ExpnId,
-) -> Option<(&'a Expr<'a>, PanicExpn<'a>)> {
-    find_assert_args_inner(cx, expr, expn).map(|([e], mut p)| {
-        // `assert!(..)` expands to `core::panicking::panic("assertion failed: ...")` (which we map to
-        // `PanicExpn::Str(..)`) and `assert!(.., "..")` expands to
-        // `core::panicking::panic_fmt(format_args!(".."))` (which we map to `PanicExpn::Format(..)`).
-        // So even we got `PanicExpn::Str(..)` that means there is no custom message provided
-        if let PanicExpn::Str(_) = p {
-            p = PanicExpn::Empty;
-        }
-
-        (e, p)
-    })
-}
-
-/// Finds the arguments of an `assert_eq!` or `debug_assert_eq!` macro call within the macro
-/// expansion
-pub fn find_assert_eq_args<'a>(
-    cx: &LateContext<'_>,
-    expr: &'a Expr<'a>,
-    expn: ExpnId,
-) -> Option<(&'a Expr<'a>, &'a Expr<'a>, PanicExpn<'a>)> {
-    find_assert_args_inner(cx, expr, expn).map(|([a, b], p)| (a, b, p))
-}
-
-fn find_assert_args_inner<'a, const N: usize>(
-    cx: &LateContext<'_>,
-    expr: &'a Expr<'a>,
-    expn: ExpnId,
-) -> Option<([&'a Expr<'a>; N], PanicExpn<'a>)> {
-    let macro_id = expn.expn_data().macro_def_id?;
-    let (expr, expn) = match cx.tcx.item_name(macro_id).as_str().strip_prefix("debug_") {
-        None => (expr, expn),
-        Some(inner_name) => find_assert_within_debug_assert(cx, expr, expn, Symbol::intern(inner_name))?,
-    };
-    let mut args = ArrayVec::new();
-    let panic_expn = for_each_expr(expr, |e| {
-        if args.is_full() {
-            match PanicExpn::parse(e) {
-                Some(expn) => ControlFlow::Break(expn),
-                None => ControlFlow::Continue(Descend::Yes),
-            }
-        } else if is_assert_arg(cx, e, expn) {
-            args.push(e);
-            ControlFlow::Continue(Descend::No)
-        } else {
-            ControlFlow::Continue(Descend::Yes)
-        }
-    });
-    let args = args.into_inner().ok()?;
-    // if no `panic!(..)` is found, use `PanicExpn::Empty`
-    // to indicate that the default assertion message is used
-    let panic_expn = panic_expn.unwrap_or(PanicExpn::Empty);
-    Some((args, panic_expn))
-}
-
-fn find_assert_within_debug_assert<'a>(
-    cx: &LateContext<'_>,
-    expr: &'a Expr<'a>,
-    expn: ExpnId,
-    assert_name: Symbol,
-) -> Option<(&'a Expr<'a>, ExpnId)> {
-    for_each_expr(expr, |e| {
-        if !e.span.from_expansion() {
-            return ControlFlow::Continue(Descend::No);
-        }
-        let e_expn = e.span.ctxt().outer_expn();
-        if e_expn == expn {
-            ControlFlow::Continue(Descend::Yes)
-        } else if e_expn.expn_data().macro_def_id.map(|id| cx.tcx.item_name(id)) == Some(assert_name) {
-            ControlFlow::Break((e, e_expn))
-        } else {
-            ControlFlow::Continue(Descend::No)
-        }
-    })
-}
-
-fn is_assert_arg(cx: &LateContext<'_>, expr: &Expr<'_>, assert_expn: ExpnId) -> bool {
-    if !expr.span.from_expansion() {
-        return true;
-    }
-    let result = macro_backtrace(expr.span).try_for_each(|macro_call| {
-        if macro_call.expn == assert_expn {
-            ControlFlow::Break(false)
-        } else {
-            match cx.tcx.item_name(macro_call.def_id) {
-                // `cfg!(debug_assertions)` in `debug_assert!`
-                sym::cfg => ControlFlow::Continue(()),
-                // assert!(other_macro!(..))
-                _ => ControlFlow::Break(true),
-            }
-        }
-    });
-    match result {
-        ControlFlow::Break(is_assert_arg) => is_assert_arg,
-        ControlFlow::Continue(()) => true,
-    }
-}
-
-thread_local! {
-    /// We preserve the [`FormatArgs`] structs from the early pass for use in the late pass to be
-    /// able to access the many features of a [`LateContext`].
-    ///
-    /// A thread local is used because [`FormatArgs`] is `!Send` and `!Sync`, we are making an
-    /// assumption that the early pass that populates the map and the later late passes will all be
-    /// running on the same thread.
-    #[doc(hidden)]
-    pub static AST_FORMAT_ARGS: OnceCell<FxHashMap<Span, Rc<FormatArgs>>> = {
-        static CALLED: AtomicBool = AtomicBool::new(false);
-        debug_assert!(
-            !CALLED.swap(true, Ordering::SeqCst),
-            "incorrect assumption: `AST_FORMAT_ARGS` should only be accessed by a single thread",
-        );
-
-        OnceCell::new()
-    };
-}
-
-/// Returns an AST [`FormatArgs`] node if a `format_args` expansion is found as a descendant of
-/// `expn_id`
-pub fn find_format_args(cx: &LateContext<'_>, start: &Expr<'_>, expn_id: ExpnId) -> Option<Rc<FormatArgs>> {
-    let format_args_expr = for_each_expr(start, |expr| {
-        let ctxt = expr.span.ctxt();
-        if ctxt.outer_expn().is_descendant_of(expn_id) {
-            if macro_backtrace(expr.span)
-                .map(|macro_call| cx.tcx.item_name(macro_call.def_id))
-                .any(|name| matches!(name, sym::const_format_args | sym::format_args | sym::format_args_nl))
-            {
-                ControlFlow::Break(expr)
-            } else {
-                ControlFlow::Continue(Descend::Yes)
-            }
-        } else {
-            ControlFlow::Continue(Descend::No)
-        }
-    })?;
-
-    AST_FORMAT_ARGS.with(|ast_format_args| {
-        ast_format_args
-            .get()?
-            .get(&format_args_expr.span.with_parent(None))
-            .map(Rc::clone)
-    })
-}
-
-/// Attempt to find the [`rustc_hir::Expr`] that corresponds to the [`FormatArgument`]'s value, if
-/// it cannot be found it will return the [`rustc_ast::Expr`].
-pub fn find_format_arg_expr<'hir, 'ast>(
-    start: &'hir Expr<'hir>,
-    target: &'ast FormatArgument,
-) -> Result<&'hir rustc_hir::Expr<'hir>, &'ast rustc_ast::Expr> {
-    let SpanData {
-        lo,
-        hi,
-        ctxt,
-        parent: _,
-    } = target.expr.span.data();
-
-    for_each_expr(start, |expr| {
-        // When incremental compilation is enabled spans gain a parent during AST to HIR lowering,
-        // since we're comparing an AST span to a HIR one we need to ignore the parent field
-        let data = expr.span.data();
-        if data.lo == lo && data.hi == hi && data.ctxt == ctxt {
-            ControlFlow::Break(expr)
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .ok_or(&target.expr)
-}
-
-/// Span of the `:` and format specifiers
-///
-/// ```ignore
-/// format!("{:.}"), format!("{foo:.}")
-///           ^^                  ^^
-/// ```
-pub fn format_placeholder_format_span(placeholder: &FormatPlaceholder) -> Option<Span> {
-    let base = placeholder.span?.data();
-
-    // `base.hi` is `{...}|`, subtract 1 byte (the length of '}') so that it points before the closing
-    // brace `{...|}`
-    Some(Span::new(
-        placeholder.argument.span?.hi(),
-        base.hi - BytePos(1),
-        base.ctxt,
-        base.parent,
-    ))
-}
-
-/// Span covering the format string and values
-///
-/// ```ignore
-/// format("{}.{}", 10, 11)
-/// //     ^^^^^^^^^^^^^^^
-/// ```
-pub fn format_args_inputs_span(format_args: &FormatArgs) -> Span {
-    match format_args.arguments.explicit_args() {
-        [] => format_args.span,
-        [.., last] => format_args
-            .span
-            .to(hygiene::walk_chain(last.expr.span, format_args.span.ctxt())),
-    }
-}
-
-/// Returns the [`Span`] of the value at `index` extended to the previous comma, e.g. for the value
-/// `10`
-///
-/// ```ignore
-/// format("{}.{}", 10, 11)
-/// //            ^^^^
-/// ```
-pub fn format_arg_removal_span(format_args: &FormatArgs, index: usize) -> Option<Span> {
-    let ctxt = format_args.span.ctxt();
-
-    let current = hygiene::walk_chain(format_args.arguments.by_index(index)?.expr.span, ctxt);
-
-    let prev = if index == 0 {
-        format_args.span
-    } else {
-        hygiene::walk_chain(format_args.arguments.by_index(index - 1)?.expr.span, ctxt)
-    };
-
-    Some(current.with_lo(prev.hi()))
-}
-
-/// Where a format parameter is being used in the format string
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
-pub enum FormatParamUsage {
-    /// Appears as an argument, e.g. `format!("{}", foo)`
-    Argument,
-    /// Appears as a width, e.g. `format!("{:width$}", foo, width = 1)`
-    Width,
-    /// Appears as a precision, e.g. `format!("{:.precision$}", foo, precision = 1)`
-    Precision,
-}
-
-/// A node with a `HirId` and a `Span`
-pub trait HirNode {
-    fn hir_id(&self) -> HirId;
-    fn span(&self) -> Span;
-}
-
-macro_rules! impl_hir_node {
-    ($($t:ident),*) => {
-        $(impl HirNode for hir::$t<'_> {
-            fn hir_id(&self) -> HirId {
-                self.hir_id
-            }
-            fn span(&self) -> Span {
-                self.span
-            }
-        })*
-    };
-}
-
-impl_hir_node!(Expr, Pat);
-
-impl HirNode for hir::Item<'_> {
-    fn hir_id(&self) -> HirId {
-        self.hir_id()
-    }
-
-    fn span(&self) -> Span {
-        self.span
-    }
-}
diff --git a/scout-audit-clippy-utils/src/mir/mod.rs b/scout-audit-clippy-utils/src/mir/mod.rs
deleted file mode 100644
index f04467dc..00000000
--- a/scout-audit-clippy-utils/src/mir/mod.rs
+++ /dev/null
@@ -1,195 +0,0 @@
-use rustc_hir::{Expr, HirId};
-use rustc_index::bit_set::BitSet;
-use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
-use rustc_middle::mir::{
-    traversal, BasicBlock, Body, InlineAsmOperand, Local, Location, Place, StatementKind, TerminatorKind, START_BLOCK,
-};
-use rustc_middle::ty::TyCtxt;
-
-mod possible_borrower;
-pub use possible_borrower::PossibleBorrowerMap;
-
-mod possible_origin;
-
-mod transitive_relation;
-
-#[derive(Clone, Debug, Default)]
-pub struct LocalUsage {
-    /// The locations where the local is used, if any.
-    pub local_use_locs: Vec<Location>,
-    /// The locations where the local is consumed or mutated, if any.
-    pub local_consume_or_mutate_locs: Vec<Location>,
-}
-
-pub fn visit_local_usage(locals: &[Local], mir: &Body<'_>, location: Location) -> Option<Vec<LocalUsage>> {
-    let init = vec![
-        LocalUsage {
-            local_use_locs: Vec::new(),
-            local_consume_or_mutate_locs: Vec::new(),
-        };
-        locals.len()
-    ];
-
-    traversal::ReversePostorder::new(mir, location.block).try_fold(init, |usage, (tbb, tdata)| {
-        // Give up on loops
-        if tdata.terminator().successors().any(|s| s == location.block) {
-            return None;
-        }
-
-        let mut v = V {
-            locals,
-            location,
-            results: usage,
-        };
-        v.visit_basic_block_data(tbb, tdata);
-        Some(v.results)
-    })
-}
-
-struct V<'a> {
-    locals: &'a [Local],
-    location: Location,
-    results: Vec<LocalUsage>,
-}
-
-impl<'a, 'tcx> Visitor<'tcx> for V<'a> {
-    fn visit_place(&mut self, place: &Place<'tcx>, ctx: PlaceContext, loc: Location) {
-        if loc.block == self.location.block && loc.statement_index <= self.location.statement_index {
-            return;
-        }
-
-        let local = place.local;
-
-        for (i, self_local) in self.locals.iter().enumerate() {
-            if local == *self_local {
-                if !matches!(
-                    ctx,
-                    PlaceContext::MutatingUse(MutatingUseContext::Drop) | PlaceContext::NonUse(_)
-                ) {
-                    self.results[i].local_use_locs.push(loc);
-                }
-                if matches!(
-                    ctx,
-                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Move)
-                        | PlaceContext::MutatingUse(MutatingUseContext::Borrow)
-                ) {
-                    self.results[i].local_consume_or_mutate_locs.push(loc);
-                }
-            }
-        }
-    }
-}
-
-/// Checks if the block is part of a cycle
-pub fn block_in_cycle(body: &Body<'_>, block: BasicBlock) -> bool {
-    let mut seen = BitSet::new_empty(body.basic_blocks.len());
-    let mut to_visit = Vec::with_capacity(body.basic_blocks.len() / 2);
-
-    seen.insert(block);
-    let mut next = block;
-    loop {
-        for succ in body.basic_blocks[next].terminator().successors() {
-            if seen.insert(succ) {
-                to_visit.push(succ);
-            } else if succ == block {
-                return true;
-            }
-        }
-
-        if let Some(x) = to_visit.pop() {
-            next = x;
-        } else {
-            return false;
-        }
-    }
-}
-
-/// Convenience wrapper around `visit_local_usage`.
-pub fn used_exactly_once(mir: &Body<'_>, local: rustc_middle::mir::Local) -> Option<bool> {
-    visit_local_usage(
-        &[local],
-        mir,
-        Location {
-            block: START_BLOCK,
-            statement_index: 0,
-        },
-    )
-    .map(|mut vec| {
-        let LocalUsage { local_use_locs, .. } = vec.remove(0);
-        let mut locations = local_use_locs
-            .into_iter()
-            .filter(|&location| !is_local_assignment(mir, local, location));
-        if let Some(location) = locations.next() {
-            locations.next().is_none() && !block_in_cycle(mir, location.block)
-        } else {
-            false
-        }
-    })
-}
-
-/// Returns the `mir::Body` containing the node associated with `hir_id`.
-#[allow(clippy::module_name_repetitions)]
-pub fn enclosing_mir(tcx: TyCtxt<'_>, hir_id: HirId) -> Option<&Body<'_>> {
-    let body_owner_local_def_id = tcx.hir().enclosing_body_owner(hir_id);
-    if tcx.hir().body_owner_kind(body_owner_local_def_id).is_fn_or_closure() {
-        Some(tcx.optimized_mir(body_owner_local_def_id.to_def_id()))
-    } else {
-        None
-    }
-}
-
-/// Tries to determine the `Local` corresponding to `expr`, if any.
-/// This function is expensive and should be used sparingly.
-pub fn expr_local(tcx: TyCtxt<'_>, expr: &Expr<'_>) -> Option<Local> {
-    enclosing_mir(tcx, expr.hir_id).and_then(|mir| {
-        mir.local_decls.iter_enumerated().find_map(|(local, local_decl)| {
-            if local_decl.source_info.span == expr.span {
-                Some(local)
-            } else {
-                None
-            }
-        })
-    })
-}
-
-/// Returns a vector of `mir::Location` where `local` is assigned.
-pub fn local_assignments(mir: &Body<'_>, local: Local) -> Vec<Location> {
-    let mut locations = Vec::new();
-    for (block, data) in mir.basic_blocks.iter_enumerated() {
-        for statement_index in 0..=data.statements.len() {
-            let location = Location { block, statement_index };
-            if is_local_assignment(mir, local, location) {
-                locations.push(location);
-            }
-        }
-    }
-    locations
-}
-
-// `is_local_assignment` is based on `is_place_assignment`:
-// https://github.com/rust-lang/rust/blob/b7413511dc85ec01ef4b91785f86614589ac6103/compiler/rustc_middle/src/mir/visit.rs#L1350
-fn is_local_assignment(mir: &Body<'_>, local: Local, location: Location) -> bool {
-    let Location { block, statement_index } = location;
-    let basic_block = &mir.basic_blocks[block];
-    if statement_index < basic_block.statements.len() {
-        let statement = &basic_block.statements[statement_index];
-        if let StatementKind::Assign(box (place, _)) = statement.kind {
-            place.as_local() == Some(local)
-        } else {
-            false
-        }
-    } else {
-        let terminator = basic_block.terminator();
-        match &terminator.kind {
-            TerminatorKind::Call { destination, .. } => destination.as_local() == Some(local),
-            TerminatorKind::InlineAsm { operands, .. } => operands.iter().any(|operand| {
-                if let InlineAsmOperand::Out { place: Some(place), .. } = operand {
-                    place.as_local() == Some(local)
-                } else {
-                    false
-                }
-            }),
-            _ => false,
-        }
-    }
-}
diff --git a/scout-audit-clippy-utils/src/mir/possible_borrower.rs b/scout-audit-clippy-utils/src/mir/possible_borrower.rs
deleted file mode 100644
index 703985b9..00000000
--- a/scout-audit-clippy-utils/src/mir/possible_borrower.rs
+++ /dev/null
@@ -1,243 +0,0 @@
-use super::possible_origin::PossibleOriginVisitor;
-use super::transitive_relation::TransitiveRelation;
-use crate::ty::is_copy;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_index::bit_set::{BitSet, HybridBitSet};
-use rustc_lint::LateContext;
-use rustc_middle::mir::visit::Visitor as _;
-use rustc_middle::mir::{self, Mutability};
-use rustc_middle::ty::visit::TypeVisitor;
-use rustc_middle::ty::{self, TyCtxt};
-use rustc_mir_dataflow::impls::MaybeStorageLive;
-use rustc_mir_dataflow::{Analysis, ResultsCursor};
-use std::borrow::Cow;
-use std::ops::ControlFlow;
-
-/// Collects the possible borrowers of each local.
-/// For example, `b = &a; c = &a;` will make `b` and (transitively) `c`
-/// possible borrowers of `a`.
-#[allow(clippy::module_name_repetitions)]
-struct PossibleBorrowerVisitor<'a, 'b, 'tcx> {
-    possible_borrower: TransitiveRelation,
-    body: &'b mir::Body<'tcx>,
-    cx: &'a LateContext<'tcx>,
-    possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
-}
-
-impl<'a, 'b, 'tcx> PossibleBorrowerVisitor<'a, 'b, 'tcx> {
-    fn new(
-        cx: &'a LateContext<'tcx>,
-        body: &'b mir::Body<'tcx>,
-        possible_origin: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
-    ) -> Self {
-        Self {
-            possible_borrower: TransitiveRelation::default(),
-            cx,
-            body,
-            possible_origin,
-        }
-    }
-
-    fn into_map(
-        self,
-        cx: &'a LateContext<'tcx>,
-        maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive<'tcx>>,
-    ) -> PossibleBorrowerMap<'b, 'tcx> {
-        let mut map = FxHashMap::default();
-        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
-            if is_copy(cx, self.body.local_decls[row].ty) {
-                continue;
-            }
-
-            let mut borrowers = self.possible_borrower.reachable_from(row, self.body.local_decls.len());
-            borrowers.remove(mir::Local::from_usize(0));
-            if !borrowers.is_empty() {
-                map.insert(row, borrowers);
-            }
-        }
-
-        let bs = BitSet::new_empty(self.body.local_decls.len());
-        PossibleBorrowerMap {
-            map,
-            maybe_live,
-            bitset: (bs.clone(), bs),
-        }
-    }
-}
-
-impl<'a, 'b, 'tcx> mir::visit::Visitor<'tcx> for PossibleBorrowerVisitor<'a, 'b, 'tcx> {
-    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
-        let lhs = place.local;
-        match rvalue {
-            mir::Rvalue::Ref(_, _, borrowed) => {
-                self.possible_borrower.add(borrowed.local, lhs);
-            },
-            other => {
-                if ContainsRegion
-                    .visit_ty(place.ty(&self.body.local_decls, self.cx.tcx).ty)
-                    .is_continue()
-                {
-                    return;
-                }
-                rvalue_locals(other, |rhs| {
-                    if lhs != rhs {
-                        self.possible_borrower.add(rhs, lhs);
-                    }
-                });
-            },
-        }
-    }
-
-    fn visit_terminator(&mut self, terminator: &mir::Terminator<'_>, _loc: mir::Location) {
-        if let mir::TerminatorKind::Call {
-            args,
-            destination: mir::Place { local: dest, .. },
-            ..
-        } = &terminator.kind
-        {
-            // TODO add doc
-            // If the call returns something with lifetimes,
-            // let's conservatively assume the returned value contains lifetime of all the arguments.
-            // For example, given `let y: Foo<'a> = foo(x)`, `y` is considered to be a possible borrower of `x`.
-
-            let mut immutable_borrowers = vec![];
-            let mut mutable_borrowers = vec![];
-
-            for op in args {
-                match op {
-                    mir::Operand::Copy(p) | mir::Operand::Move(p) => {
-                        if let ty::Ref(_, _, Mutability::Mut) = self.body.local_decls[p.local].ty.kind() {
-                            mutable_borrowers.push(p.local);
-                        } else {
-                            immutable_borrowers.push(p.local);
-                        }
-                    },
-                    mir::Operand::Constant(..) => (),
-                }
-            }
-
-            let mut mutable_variables: Vec<mir::Local> = mutable_borrowers
-                .iter()
-                .filter_map(|r| self.possible_origin.get(r))
-                .flat_map(HybridBitSet::iter)
-                .collect();
-
-            if ContainsRegion.visit_ty(self.body.local_decls[*dest].ty).is_break() {
-                mutable_variables.push(*dest);
-            }
-
-            for y in mutable_variables {
-                for x in &immutable_borrowers {
-                    self.possible_borrower.add(*x, y);
-                }
-                for x in &mutable_borrowers {
-                    self.possible_borrower.add(*x, y);
-                }
-            }
-        }
-    }
-}
-
-struct ContainsRegion;
-
-impl TypeVisitor<TyCtxt<'_>> for ContainsRegion {
-    type BreakTy = ();
-
-    fn visit_region(&mut self, _: ty::Region<'_>) -> ControlFlow<Self::BreakTy> {
-        ControlFlow::Break(())
-    }
-}
-
-fn rvalue_locals(rvalue: &mir::Rvalue<'_>, mut visit: impl FnMut(mir::Local)) {
-    use rustc_middle::mir::Rvalue::{Aggregate, BinaryOp, Cast, CheckedBinaryOp, Repeat, UnaryOp, Use};
-
-    let mut visit_op = |op: &mir::Operand<'_>| match op {
-        mir::Operand::Copy(p) | mir::Operand::Move(p) => visit(p.local),
-        mir::Operand::Constant(..) => (),
-    };
-
-    match rvalue {
-        Use(op) | Repeat(op, _) | Cast(_, op, _) | UnaryOp(_, op) => visit_op(op),
-        Aggregate(_, ops) => ops.iter().for_each(visit_op),
-        BinaryOp(_, box (lhs, rhs)) | CheckedBinaryOp(_, box (lhs, rhs)) => {
-            visit_op(lhs);
-            visit_op(rhs);
-        },
-        _ => (),
-    }
-}
-
-/// Result of `PossibleBorrowerVisitor`.
-#[allow(clippy::module_name_repetitions)]
-pub struct PossibleBorrowerMap<'b, 'tcx> {
-    /// Mapping `Local -> its possible borrowers`
-    pub map: FxHashMap<mir::Local, HybridBitSet<mir::Local>>,
-    maybe_live: ResultsCursor<'b, 'tcx, MaybeStorageLive<'tcx>>,
-    // Caches to avoid allocation of `BitSet` on every query
-    pub bitset: (BitSet<mir::Local>, BitSet<mir::Local>),
-}
-
-impl<'a, 'b, 'tcx> PossibleBorrowerMap<'b, 'tcx> {
-    pub fn new(cx: &'a LateContext<'tcx>, mir: &'b mir::Body<'tcx>) -> Self {
-        let possible_origin = {
-            let mut vis = PossibleOriginVisitor::new(mir);
-            vis.visit_body(mir);
-            vis.into_map(cx)
-        };
-        let maybe_storage_live_result = MaybeStorageLive::new(Cow::Owned(BitSet::new_empty(mir.local_decls.len())))
-            .into_engine(cx.tcx, mir)
-            .pass_name("redundant_clone")
-            .iterate_to_fixpoint()
-            .into_results_cursor(mir);
-        let mut vis = PossibleBorrowerVisitor::new(cx, mir, possible_origin);
-        vis.visit_body(mir);
-        vis.into_map(cx, maybe_storage_live_result)
-    }
-
-    /// Returns true if the set of borrowers of `borrowed` living at `at` matches with `borrowers`.
-    pub fn only_borrowers(&mut self, borrowers: &[mir::Local], borrowed: mir::Local, at: mir::Location) -> bool {
-        self.bounded_borrowers(borrowers, borrowers, borrowed, at)
-    }
-
-    /// Returns true if the set of borrowers of `borrowed` living at `at` includes at least `below`
-    /// but no more than `above`.
-    pub fn bounded_borrowers(
-        &mut self,
-        below: &[mir::Local],
-        above: &[mir::Local],
-        borrowed: mir::Local,
-        at: mir::Location,
-    ) -> bool {
-        self.maybe_live.seek_after_primary_effect(at);
-
-        self.bitset.0.clear();
-        let maybe_live = &mut self.maybe_live;
-        if let Some(bitset) = self.map.get(&borrowed) {
-            for b in bitset.iter().filter(move |b| maybe_live.contains(*b)) {
-                self.bitset.0.insert(b);
-            }
-        } else {
-            return false;
-        }
-
-        self.bitset.1.clear();
-        for b in below {
-            self.bitset.1.insert(*b);
-        }
-
-        if !self.bitset.0.superset(&self.bitset.1) {
-            return false;
-        }
-
-        for b in above {
-            self.bitset.0.remove(*b);
-        }
-
-        self.bitset.0.is_empty()
-    }
-
-    pub fn local_is_alive_at(&mut self, local: mir::Local, at: mir::Location) -> bool {
-        self.maybe_live.seek_after_primary_effect(at);
-        self.maybe_live.contains(local)
-    }
-}
diff --git a/scout-audit-clippy-utils/src/mir/possible_origin.rs b/scout-audit-clippy-utils/src/mir/possible_origin.rs
deleted file mode 100644
index da042668..00000000
--- a/scout-audit-clippy-utils/src/mir/possible_origin.rs
+++ /dev/null
@@ -1,59 +0,0 @@
-use super::transitive_relation::TransitiveRelation;
-use crate::ty::is_copy;
-use rustc_data_structures::fx::FxHashMap;
-use rustc_index::bit_set::HybridBitSet;
-use rustc_lint::LateContext;
-use rustc_middle::mir;
-
-/// Collect possible borrowed for every `&mut` local.
-/// For example, `_1 = &mut _2` generate _1: {_2,...}
-/// Known Problems: not sure all borrowed are tracked
-#[allow(clippy::module_name_repetitions)]
-pub(super) struct PossibleOriginVisitor<'a, 'tcx> {
-    possible_origin: TransitiveRelation,
-    body: &'a mir::Body<'tcx>,
-}
-
-impl<'a, 'tcx> PossibleOriginVisitor<'a, 'tcx> {
-    pub fn new(body: &'a mir::Body<'tcx>) -> Self {
-        Self {
-            possible_origin: TransitiveRelation::default(),
-            body,
-        }
-    }
-
-    pub fn into_map(self, cx: &LateContext<'tcx>) -> FxHashMap<mir::Local, HybridBitSet<mir::Local>> {
-        let mut map = FxHashMap::default();
-        for row in (1..self.body.local_decls.len()).map(mir::Local::from_usize) {
-            if is_copy(cx, self.body.local_decls[row].ty) {
-                continue;
-            }
-
-            let mut borrowers = self.possible_origin.reachable_from(row, self.body.local_decls.len());
-            borrowers.remove(mir::Local::from_usize(0));
-            if !borrowers.is_empty() {
-                map.insert(row, borrowers);
-            }
-        }
-        map
-    }
-}
-
-impl<'a, 'tcx> mir::visit::Visitor<'tcx> for PossibleOriginVisitor<'a, 'tcx> {
-    fn visit_assign(&mut self, place: &mir::Place<'tcx>, rvalue: &mir::Rvalue<'_>, _location: mir::Location) {
-        let lhs = place.local;
-        match rvalue {
-            // Only consider `&mut`, which can modify origin place
-            mir::Rvalue::Ref(_, mir::BorrowKind::Mut { .. }, borrowed) |
-            // _2: &mut _;
-            // _3 = move _2
-            mir::Rvalue::Use(mir::Operand::Move(borrowed))  |
-            // _3 = move _2 as &mut _;
-            mir::Rvalue::Cast(_, mir::Operand::Move(borrowed), _)
-                => {
-                self.possible_origin.add(lhs, borrowed.local);
-            },
-            _ => {},
-        }
-    }
-}
diff --git a/scout-audit-clippy-utils/src/mir/transitive_relation.rs b/scout-audit-clippy-utils/src/mir/transitive_relation.rs
deleted file mode 100644
index 7fe29607..00000000
--- a/scout-audit-clippy-utils/src/mir/transitive_relation.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-use rustc_data_structures::fx::FxHashMap;
-use rustc_index::bit_set::HybridBitSet;
-use rustc_middle::mir;
-
-#[derive(Default)]
-pub(super) struct TransitiveRelation {
-    relations: FxHashMap<mir::Local, Vec<mir::Local>>,
-}
-
-impl TransitiveRelation {
-    pub fn add(&mut self, a: mir::Local, b: mir::Local) {
-        self.relations.entry(a).or_default().push(b);
-    }
-
-    pub fn reachable_from(&self, a: mir::Local, domain_size: usize) -> HybridBitSet<mir::Local> {
-        let mut seen = HybridBitSet::new_empty(domain_size);
-        let mut stack = vec![a];
-        while let Some(u) = stack.pop() {
-            if let Some(edges) = self.relations.get(&u) {
-                for &v in edges {
-                    if seen.insert(v) {
-                        stack.push(v);
-                    }
-                }
-            }
-        }
-        seen
-    }
-}
diff --git a/scout-audit-clippy-utils/src/msrvs.rs b/scout-audit-clippy-utils/src/msrvs.rs
deleted file mode 100644
index 0faff05e..00000000
--- a/scout-audit-clippy-utils/src/msrvs.rs
+++ /dev/null
@@ -1,148 +0,0 @@
-use std::sync::OnceLock;
-
-use rustc_ast::Attribute;
-use rustc_semver::RustcVersion;
-use rustc_session::Session;
-use rustc_span::Span;
-
-use crate::attrs::get_unique_attr;
-
-macro_rules! msrv_aliases {
-    ($($major:literal,$minor:literal,$patch:literal {
-        $($name:ident),* $(,)?
-    })*) => {
-        $($(
-        pub const $name: RustcVersion = RustcVersion::new($major, $minor, $patch);
-        )*)*
-    };
-}
-
-// names may refer to stabilized feature flags or library items
-msrv_aliases! {
-    1,71,0 { TUPLE_ARRAY_CONVERSIONS }
-    1,70,0 { OPTION_IS_SOME_AND, BINARY_HEAP_RETAIN }
-    1,68,0 { PATH_MAIN_SEPARATOR_STR }
-    1,65,0 { LET_ELSE, POINTER_CAST_CONSTNESS }
-    1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE }
-    1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY }
-    1,55,0 { SEEK_REWIND }
-    1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
-    1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
-    1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
-    1,50,0 { BOOL_THEN, CLAMP }
-    1,47,0 { TAU, IS_ASCII_DIGIT_CONST, ARRAY_IMPL_ANY_LEN }
-    1,46,0 { CONST_IF_MATCH }
-    1,45,0 { STR_STRIP_PREFIX }
-    1,43,0 { LOG2_10, LOG10_2 }
-    1,42,0 { MATCHES_MACRO, SLICE_PATTERNS, PTR_SLICE_RAW_PARTS }
-    1,41,0 { RE_REBALANCING_COHERENCE, RESULT_MAP_OR_ELSE }
-    1,40,0 { MEM_TAKE, NON_EXHAUSTIVE, OPTION_AS_DEREF }
-    1,38,0 { POINTER_CAST, REM_EUCLID }
-    1,37,0 { TYPE_ALIAS_ENUM_VARIANTS }
-    1,36,0 { ITERATOR_COPIED }
-    1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
-    1,34,0 { TRY_FROM }
-    1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
-    1,28,0 { FROM_BOOL }
-    1,27,0 { ITERATOR_TRY_FOLD }
-    1,26,0 { RANGE_INCLUSIVE, STRING_RETAIN }
-    1,24,0 { IS_ASCII_DIGIT }
-    1,18,0 { HASH_MAP_RETAIN, HASH_SET_RETAIN }
-    1,17,0 { FIELD_INIT_SHORTHAND, STATIC_IN_CONST, EXPECT_ERR }
-    1,16,0 { STR_REPEAT }
-    1,15,0 { MAYBE_BOUND_IN_WHERE }
-}
-
-fn parse_msrv(msrv: &str, sess: Option<&Session>, span: Option<Span>) -> Option<RustcVersion> {
-    if let Ok(version) = RustcVersion::parse(msrv) {
-        return Some(version);
-    } else if let Some(sess) = sess {
-        if let Some(span) = span {
-            sess.span_err(span, format!("`{msrv}` is not a valid Rust version"));
-        }
-    }
-    None
-}
-
-/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]`
-#[derive(Debug, Clone, Default)]
-pub struct Msrv {
-    stack: Vec<RustcVersion>,
-}
-
-impl Msrv {
-    fn new(initial: Option<RustcVersion>) -> Self {
-        Self {
-            stack: Vec::from_iter(initial),
-        }
-    }
-
-    fn read_inner(conf_msrv: &Option<String>, sess: &Session) -> Self {
-        let cargo_msrv = std::env::var("CARGO_PKG_RUST_VERSION")
-            .ok()
-            .and_then(|v| parse_msrv(&v, None, None));
-        let clippy_msrv = conf_msrv.as_ref().and_then(|s| {
-            parse_msrv(s, None, None).or_else(|| {
-                sess.err(format!(
-                    "error reading Clippy's configuration file. `{s}` is not a valid Rust version"
-                ));
-                None
-            })
-        });
-
-        // if both files have an msrv, let's compare them and emit a warning if they differ
-        if let Some(cargo_msrv) = cargo_msrv
-            && let Some(clippy_msrv) = clippy_msrv
-            && clippy_msrv != cargo_msrv
-        {
-            sess.warn(format!(
-                "the MSRV in `clippy.toml` and `Cargo.toml` differ; using `{clippy_msrv}` from `clippy.toml`"
-            ));
-        }
-
-        Self::new(clippy_msrv.or(cargo_msrv))
-    }
-
-    /// Set the initial MSRV from the Clippy config file or from Cargo due to the `rust-version`
-    /// field in `Cargo.toml`
-    ///
-    /// Returns a `&'static Msrv` as `Copy` types are more easily passed to the
-    /// `register_{late,early}_pass` callbacks
-    pub fn read(conf_msrv: &Option<String>, sess: &Session) -> &'static Self {
-        static PARSED: OnceLock<Msrv> = OnceLock::new();
-
-        PARSED.get_or_init(|| Self::read_inner(conf_msrv, sess))
-    }
-
-    pub fn current(&self) -> Option<RustcVersion> {
-        self.stack.last().copied()
-    }
-
-    pub fn meets(&self, required: RustcVersion) -> bool {
-        self.current().map_or(true, |version| version.meets(required))
-    }
-
-    fn parse_attr(sess: &Session, attrs: &[Attribute]) -> Option<RustcVersion> {
-        if let Some(msrv_attr) = get_unique_attr(sess, attrs, "msrv") {
-            if let Some(msrv) = msrv_attr.value_str() {
-                return parse_msrv(&msrv.to_string(), Some(sess), Some(msrv_attr.span));
-            }
-
-            sess.span_err(msrv_attr.span, "bad clippy attribute");
-        }
-
-        None
-    }
-
-    pub fn enter_lint_attrs(&mut self, sess: &Session, attrs: &[Attribute]) {
-        if let Some(version) = Self::parse_attr(sess, attrs) {
-            self.stack.push(version);
-        }
-    }
-
-    pub fn exit_lint_attrs(&mut self, sess: &Session, attrs: &[Attribute]) {
-        if Self::parse_attr(sess, attrs).is_some() {
-            self.stack.pop();
-        }
-    }
-}
diff --git a/scout-audit-clippy-utils/src/numeric_literal.rs b/scout-audit-clippy-utils/src/numeric_literal.rs
deleted file mode 100644
index bbe4149f..00000000
--- a/scout-audit-clippy-utils/src/numeric_literal.rs
+++ /dev/null
@@ -1,247 +0,0 @@
-use rustc_ast::ast::{LitFloatType, LitIntType, LitKind};
-use std::iter;
-
-#[derive(Debug, PartialEq, Eq, Copy, Clone)]
-pub enum Radix {
-    Binary,
-    Octal,
-    Decimal,
-    Hexadecimal,
-}
-
-impl Radix {
-    /// Returns a reasonable digit group size for this radix.
-    #[must_use]
-    fn suggest_grouping(self) -> usize {
-        match self {
-            Self::Binary | Self::Hexadecimal => 4,
-            Self::Octal | Self::Decimal => 3,
-        }
-    }
-}
-
-/// A helper method to format numeric literals with digit grouping.
-/// `lit` must be a valid numeric literal without suffix.
-pub fn format(lit: &str, type_suffix: Option<&str>, float: bool) -> String {
-    NumericLiteral::new(lit, type_suffix, float).format()
-}
-
-#[derive(Debug)]
-pub struct NumericLiteral<'a> {
-    /// Which radix the literal was represented in.
-    pub radix: Radix,
-    /// The radix prefix, if present.
-    pub prefix: Option<&'a str>,
-
-    /// The integer part of the number.
-    pub integer: &'a str,
-    /// The fraction part of the number.
-    pub fraction: Option<&'a str>,
-    /// The exponent separator (b'e' or b'E') including preceding underscore if present
-    /// and the exponent part.
-    pub exponent: Option<(&'a str, &'a str)>,
-
-    /// The type suffix, including preceding underscore if present.
-    pub suffix: Option<&'a str>,
-}
-
-impl<'a> NumericLiteral<'a> {
-    pub fn from_lit_kind(src: &'a str, lit_kind: &LitKind) -> Option<NumericLiteral<'a>> {
-        let unsigned_src = src.strip_prefix('-').map_or(src, |s| s);
-        if lit_kind.is_numeric()
-            && unsigned_src
-                .trim_start()
-                .chars()
-                .next()
-                .map_or(false, |c| c.is_ascii_digit())
-        {
-            let (unsuffixed, suffix) = split_suffix(src, lit_kind);
-            let float = matches!(lit_kind, LitKind::Float(..));
-            Some(NumericLiteral::new(unsuffixed, suffix, float))
-        } else {
-            None
-        }
-    }
-
-    #[must_use]
-    pub fn new(lit: &'a str, suffix: Option<&'a str>, float: bool) -> Self {
-        let unsigned_lit = lit.trim_start_matches('-');
-        // Determine delimiter for radix prefix, if present, and radix.
-        let radix = if unsigned_lit.starts_with("0x") {
-            Radix::Hexadecimal
-        } else if unsigned_lit.starts_with("0b") {
-            Radix::Binary
-        } else if unsigned_lit.starts_with("0o") {
-            Radix::Octal
-        } else {
-            Radix::Decimal
-        };
-
-        // Grab part of the literal after prefix, if present.
-        let (prefix, mut sans_prefix) = if radix == Radix::Decimal {
-            (None, lit)
-        } else {
-            let (p, s) = lit.split_at(2);
-            (Some(p), s)
-        };
-
-        if suffix.is_some() && sans_prefix.ends_with('_') {
-            // The '_' before the suffix isn't part of the digits
-            sans_prefix = &sans_prefix[..sans_prefix.len() - 1];
-        }
-
-        let (integer, fraction, exponent) = Self::split_digit_parts(sans_prefix, float);
-
-        Self {
-            radix,
-            prefix,
-            integer,
-            fraction,
-            exponent,
-            suffix,
-        }
-    }
-
-    pub fn is_decimal(&self) -> bool {
-        self.radix == Radix::Decimal
-    }
-
-    pub fn split_digit_parts(digits: &str, float: bool) -> (&str, Option<&str>, Option<(&str, &str)>) {
-        let mut integer = digits;
-        let mut fraction = None;
-        let mut exponent = None;
-
-        if float {
-            for (i, c) in digits.char_indices() {
-                match c {
-                    '.' => {
-                        integer = &digits[..i];
-                        fraction = Some(&digits[i + 1..]);
-                    },
-                    'e' | 'E' => {
-                        let exp_start = if digits[..i].ends_with('_') { i - 1 } else { i };
-
-                        if integer.len() > exp_start {
-                            integer = &digits[..exp_start];
-                        } else {
-                            fraction = Some(&digits[integer.len() + 1..exp_start]);
-                        };
-                        exponent = Some((&digits[exp_start..=i], &digits[i + 1..]));
-                        break;
-                    },
-                    _ => {},
-                }
-            }
-        }
-
-        (integer, fraction, exponent)
-    }
-
-    /// Returns literal formatted in a sensible way.
-    pub fn format(&self) -> String {
-        let mut output = String::new();
-
-        if let Some(prefix) = self.prefix {
-            output.push_str(prefix);
-        }
-
-        let group_size = self.radix.suggest_grouping();
-
-        Self::group_digits(
-            &mut output,
-            self.integer,
-            group_size,
-            true,
-            self.radix == Radix::Hexadecimal,
-        );
-
-        if let Some(fraction) = self.fraction {
-            output.push('.');
-            Self::group_digits(&mut output, fraction, group_size, false, false);
-        }
-
-        if let Some((separator, exponent)) = self.exponent {
-            if !exponent.is_empty() && exponent != "0" {
-                output.push_str(separator);
-                Self::group_digits(&mut output, exponent, group_size, true, false);
-            }
-        }
-
-        if let Some(suffix) = self.suffix {
-            if output.ends_with('.') {
-                output.push('0');
-            }
-            output.push('_');
-            output.push_str(suffix);
-        }
-
-        output
-    }
-
-    pub fn group_digits(output: &mut String, input: &str, group_size: usize, partial_group_first: bool, pad: bool) {
-        debug_assert!(group_size > 0);
-
-        let mut digits = input.chars().filter(|&c| c != '_');
-
-        // The exponent may have a sign, output it early, otherwise it will be
-        // treated as a digit
-        if digits.clone().next() == Some('-') {
-            let _: Option<char> = digits.next();
-            output.push('-');
-        }
-
-        let first_group_size;
-
-        if partial_group_first {
-            first_group_size = (digits.clone().count() - 1) % group_size + 1;
-            if pad {
-                for _ in 0..group_size - first_group_size {
-                    output.push('0');
-                }
-            }
-        } else {
-            first_group_size = group_size;
-        }
-
-        for _ in 0..first_group_size {
-            if let Some(digit) = digits.next() {
-                output.push(digit);
-            }
-        }
-
-        for (c, i) in iter::zip(digits, (0..group_size).cycle()) {
-            if i == 0 {
-                output.push('_');
-            }
-            output.push(c);
-        }
-    }
-}
-
-fn split_suffix<'a>(src: &'a str, lit_kind: &LitKind) -> (&'a str, Option<&'a str>) {
-    debug_assert!(lit_kind.is_numeric());
-    lit_suffix_length(lit_kind)
-        .and_then(|suffix_length| src.len().checked_sub(suffix_length))
-        .map_or((src, None), |split_pos| {
-            let (unsuffixed, suffix) = src.split_at(split_pos);
-            (unsuffixed, Some(suffix))
-        })
-}
-
-fn lit_suffix_length(lit_kind: &LitKind) -> Option<usize> {
-    debug_assert!(lit_kind.is_numeric());
-    let suffix = match lit_kind {
-        LitKind::Int(_, int_lit_kind) => match int_lit_kind {
-            LitIntType::Signed(int_ty) => Some(int_ty.name_str()),
-            LitIntType::Unsigned(uint_ty) => Some(uint_ty.name_str()),
-            LitIntType::Unsuffixed => None,
-        },
-        LitKind::Float(_, float_lit_kind) => match float_lit_kind {
-            LitFloatType::Suffixed(float_ty) => Some(float_ty.name_str()),
-            LitFloatType::Unsuffixed => None,
-        },
-        _ => None,
-    };
-
-    suffix.map(str::len)
-}
diff --git a/scout-audit-clippy-utils/src/paths.rs b/scout-audit-clippy-utils/src/paths.rs
deleted file mode 100644
index 2fb24b5c..00000000
--- a/scout-audit-clippy-utils/src/paths.rs
+++ /dev/null
@@ -1,167 +0,0 @@
-//! This module contains paths to types and functions Clippy needs to know
-//! about.
-//!
-//! Whenever possible, please consider diagnostic items over hardcoded paths.
-//! See <https://github.com/rust-lang/rust-clippy/issues/5393> for more information.
-
-#[cfg(feature = "internal")]
-pub const APPLICABILITY: [&str; 2] = ["rustc_lint_defs", "Applicability"];
-#[cfg(feature = "internal")]
-pub const APPLICABILITY_VALUES: [[&str; 3]; 4] = [
-    ["rustc_lint_defs", "Applicability", "Unspecified"],
-    ["rustc_lint_defs", "Applicability", "HasPlaceholders"],
-    ["rustc_lint_defs", "Applicability", "MaybeIncorrect"],
-    ["rustc_lint_defs", "Applicability", "MachineApplicable"],
-];
-#[cfg(feature = "internal")]
-pub const DIAGNOSTIC_BUILDER: [&str; 3] = ["rustc_errors", "diagnostic_builder", "DiagnosticBuilder"];
-pub const BINARYHEAP_ITER: [&str; 5] = ["alloc", "collections", "binary_heap", "BinaryHeap", "iter"];
-pub const BTREEMAP_CONTAINS_KEY: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "contains_key"];
-pub const BTREEMAP_INSERT: [&str; 6] = ["alloc", "collections", "btree", "map", "BTreeMap", "insert"];
-pub const BTREESET_ITER: [&str; 6] = ["alloc", "collections", "btree", "set", "BTreeSet", "iter"];
-pub const CLONE_TRAIT_METHOD: [&str; 4] = ["core", "clone", "Clone", "clone"];
-pub const CORE_ITER_CLONED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "cloned"];
-pub const CORE_ITER_COPIED: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "copied"];
-pub const CORE_ITER_FILTER: [&str; 6] = ["core", "iter", "traits", "iterator", "Iterator", "filter"];
-pub const CORE_RESULT_OK_METHOD: [&str; 4] = ["core", "result", "Result", "ok"];
-pub const CSTRING_AS_C_STR: [&str; 5] = ["alloc", "ffi", "c_str", "CString", "as_c_str"];
-pub const DEFAULT_TRAIT_METHOD: [&str; 4] = ["core", "default", "Default", "default"];
-pub const DEREF_MUT_TRAIT_METHOD: [&str; 5] = ["core", "ops", "deref", "DerefMut", "deref_mut"];
-#[cfg(feature = "internal")]
-pub const EARLY_CONTEXT: [&str; 2] = ["rustc_lint", "EarlyContext"];
-#[cfg(feature = "internal")]
-pub const EARLY_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "EarlyLintPass"];
-pub const EXIT: [&str; 3] = ["std", "process", "exit"];
-pub const F32_EPSILON: [&str; 4] = ["core", "f32", "<impl f32>", "EPSILON"];
-pub const F64_EPSILON: [&str; 4] = ["core", "f64", "<impl f64>", "EPSILON"];
-pub const FROM_ITERATOR_METHOD: [&str; 6] = ["core", "iter", "traits", "collect", "FromIterator", "from_iter"];
-pub const FROM_STR_METHOD: [&str; 5] = ["core", "str", "traits", "FromStr", "from_str"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
-pub const FUTURES_IO_ASYNCREADEXT: [&str; 3] = ["futures_util", "io", "AsyncReadExt"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
-pub const FUTURES_IO_ASYNCWRITEEXT: [&str; 3] = ["futures_util", "io", "AsyncWriteExt"];
-pub const HASHMAP_CONTAINS_KEY: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "contains_key"];
-pub const HASHMAP_INSERT: [&str; 6] = ["std", "collections", "hash", "map", "HashMap", "insert"];
-pub const HASHSET_ITER: [&str; 6] = ["std", "collections", "hash", "set", "HashSet", "iter"];
-#[cfg(feature = "internal")]
-pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
-#[cfg(feature = "internal")]
-pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
-pub const INSERT_STR: [&str; 4] = ["alloc", "string", "String", "insert_str"];
-pub const ITER_EMPTY: [&str; 5] = ["core", "iter", "sources", "empty", "Empty"];
-pub const ITER_ONCE: [&str; 5] = ["core", "iter", "sources", "once", "Once"];
-pub const ITERTOOLS_NEXT_TUPLE: [&str; 3] = ["itertools", "Itertools", "next_tuple"];
-#[cfg(feature = "internal")]
-pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
-#[cfg(feature = "internal")]
-pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
-#[cfg(feature = "internal")]
-pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
-#[cfg(feature = "internal")]
-pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
-pub const MEM_SWAP: [&str; 3] = ["core", "mem", "swap"];
-#[cfg(feature = "internal")]
-pub const MSRV: [&str; 3] = ["clippy_utils", "msrvs", "Msrv"];
-pub const OPEN_OPTIONS: [&str; 3] = ["std", "fs", "OpenOptions"];
-pub const OS_STRING_AS_OS_STR: [&str; 5] = ["std", "ffi", "os_str", "OsString", "as_os_str"];
-pub const OS_STR_TO_OS_STRING: [&str; 5] = ["std", "ffi", "os_str", "OsStr", "to_os_string"];
-pub const PARKING_LOT_MUTEX_GUARD: [&str; 3] = ["lock_api", "mutex", "MutexGuard"];
-pub const PARKING_LOT_RWLOCK_READ_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockReadGuard"];
-pub const PARKING_LOT_RWLOCK_WRITE_GUARD: [&str; 3] = ["lock_api", "rwlock", "RwLockWriteGuard"];
-pub const PATH_BUF_AS_PATH: [&str; 4] = ["std", "path", "PathBuf", "as_path"];
-pub const PATH_MAIN_SEPARATOR: [&str; 3] = ["std", "path", "MAIN_SEPARATOR"];
-pub const PATH_TO_PATH_BUF: [&str; 4] = ["std", "path", "Path", "to_path_buf"];
-pub const PEEKABLE: [&str; 5] = ["core", "iter", "adapters", "peekable", "Peekable"];
-pub const PERMISSIONS: [&str; 3] = ["std", "fs", "Permissions"];
-#[cfg_attr(not(unix), allow(clippy::invalid_paths))]
-pub const PERMISSIONS_FROM_MODE: [&str; 6] = ["std", "os", "unix", "fs", "PermissionsExt", "from_mode"];
-pub const PTR_COPY: [&str; 3] = ["core", "intrinsics", "copy"];
-pub const PTR_COPY_NONOVERLAPPING: [&str; 3] = ["core", "intrinsics", "copy_nonoverlapping"];
-pub const PTR_EQ: [&str; 3] = ["core", "ptr", "eq"];
-pub const PTR_SLICE_FROM_RAW_PARTS: [&str; 3] = ["core", "ptr", "slice_from_raw_parts"];
-pub const PTR_SLICE_FROM_RAW_PARTS_MUT: [&str; 3] = ["core", "ptr", "slice_from_raw_parts_mut"];
-pub const PTR_SWAP_NONOVERLAPPING: [&str; 3] = ["core", "ptr", "swap_nonoverlapping"];
-pub const PTR_READ: [&str; 3] = ["core", "ptr", "read"];
-pub const PTR_READ_UNALIGNED: [&str; 3] = ["core", "ptr", "read_unaligned"];
-pub const PTR_READ_VOLATILE: [&str; 3] = ["core", "ptr", "read_volatile"];
-pub const PTR_REPLACE: [&str; 3] = ["core", "ptr", "replace"];
-pub const PTR_SWAP: [&str; 3] = ["core", "ptr", "swap"];
-pub const PTR_UNALIGNED_VOLATILE_LOAD: [&str; 3] = ["core", "intrinsics", "unaligned_volatile_load"];
-pub const PTR_UNALIGNED_VOLATILE_STORE: [&str; 3] = ["core", "intrinsics", "unaligned_volatile_store"];
-pub const PTR_WRITE_BYTES: [&str; 3] = ["core", "intrinsics", "write_bytes"];
-pub const PUSH_STR: [&str; 4] = ["alloc", "string", "String", "push_str"];
-pub const RANGE_ARGUMENT_TRAIT: [&str; 3] = ["core", "ops", "RangeBounds"];
-pub const REFCELL_REF: [&str; 3] = ["core", "cell", "Ref"];
-pub const REFCELL_REFMUT: [&str; 3] = ["core", "cell", "RefMut"];
-pub const REGEX_BUILDER_NEW: [&str; 3] = ["regex", "RegexBuilder", "new"];
-pub const REGEX_BYTES_BUILDER_NEW: [&str; 4] = ["regex", "bytes", "RegexBuilder", "new"];
-pub const REGEX_BYTES_NEW: [&str; 4] = ["regex", "bytes", "Regex", "new"];
-pub const REGEX_BYTES_SET_NEW: [&str; 4] = ["regex", "bytes", "RegexSet", "new"];
-pub const REGEX_NEW: [&str; 3] = ["regex", "Regex", "new"];
-pub const REGEX_SET_NEW: [&str; 3] = ["regex", "RegexSet", "new"];
-pub const SERDE_DESERIALIZE: [&str; 3] = ["serde", "de", "Deserialize"];
-pub const SERDE_DE_VISITOR: [&str; 3] = ["serde", "de", "Visitor"];
-pub const SLICE_FROM_RAW_PARTS: [&str; 4] = ["core", "slice", "raw", "from_raw_parts"];
-pub const SLICE_FROM_RAW_PARTS_MUT: [&str; 4] = ["core", "slice", "raw", "from_raw_parts_mut"];
-pub const SLICE_GET: [&str; 4] = ["core", "slice", "<impl [T]>", "get"];
-pub const SLICE_INTO_VEC: [&str; 4] = ["alloc", "slice", "<impl [T]>", "into_vec"];
-pub const SLICE_INTO: [&str; 4] = ["core", "slice", "<impl [T]>", "iter"];
-pub const SLICE_ITER: [&str; 4] = ["core", "slice", "iter", "Iter"];
-pub const STDERR: [&str; 4] = ["std", "io", "stdio", "stderr"];
-pub const STDOUT: [&str; 4] = ["std", "io", "stdio", "stdout"];
-pub const CONVERT_IDENTITY: [&str; 3] = ["core", "convert", "identity"];
-pub const STD_FS_CREATE_DIR: [&str; 3] = ["std", "fs", "create_dir"];
-pub const STD_IO_LINES: [&str; 3] = ["std", "io", "Lines"];
-pub const STD_IO_SEEK: [&str; 3] = ["std", "io", "Seek"];
-pub const STD_IO_SEEK_FROM_CURRENT: [&str; 4] = ["std", "io", "SeekFrom", "Current"];
-pub const STD_IO_SEEKFROM_START: [&str; 4] = ["std", "io", "SeekFrom", "Start"];
-pub const STD_PROCESS_COMMAND: [&str; 3] = ["std", "process", "Command"];
-pub const STRING_AS_MUT_STR: [&str; 4] = ["alloc", "string", "String", "as_mut_str"];
-pub const STRING_AS_STR: [&str; 4] = ["alloc", "string", "String", "as_str"];
-pub const STRING_NEW: [&str; 4] = ["alloc", "string", "String", "new"];
-pub const STR_BYTES: [&str; 4] = ["core", "str", "<impl str>", "bytes"];
-pub const STR_CHARS: [&str; 4] = ["core", "str", "<impl str>", "chars"];
-pub const STR_ENDS_WITH: [&str; 4] = ["core", "str", "<impl str>", "ends_with"];
-pub const STR_LEN: [&str; 4] = ["core", "str", "<impl str>", "len"];
-pub const STR_STARTS_WITH: [&str; 4] = ["core", "str", "<impl str>", "starts_with"];
-#[cfg(feature = "internal")]
-pub const SYMBOL: [&str; 3] = ["rustc_span", "symbol", "Symbol"];
-#[cfg(feature = "internal")]
-pub const SYMBOL_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Symbol", "as_str"];
-#[cfg(feature = "internal")]
-pub const SYMBOL_INTERN: [&str; 4] = ["rustc_span", "symbol", "Symbol", "intern"];
-#[cfg(feature = "internal")]
-pub const SYMBOL_TO_IDENT_STRING: [&str; 4] = ["rustc_span", "symbol", "Symbol", "to_ident_string"];
-#[cfg(feature = "internal")]
-pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
-#[cfg(feature = "internal")]
-pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
-pub const TO_OWNED_METHOD: [&str; 4] = ["alloc", "borrow", "ToOwned", "to_owned"];
-pub const TO_STRING_METHOD: [&str; 4] = ["alloc", "string", "ToString", "to_string"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
-pub const TOKIO_IO_ASYNCREADEXT: [&str; 5] = ["tokio", "io", "util", "async_read_ext", "AsyncReadExt"];
-#[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
-pub const TOKIO_IO_ASYNCWRITEEXT: [&str; 5] = ["tokio", "io", "util", "async_write_ext", "AsyncWriteExt"];
-pub const TRY_FROM: [&str; 4] = ["core", "convert", "TryFrom", "try_from"];
-pub const VEC_AS_MUT_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_mut_slice"];
-pub const VEC_AS_SLICE: [&str; 4] = ["alloc", "vec", "Vec", "as_slice"];
-pub const VEC_DEQUE_ITER: [&str; 5] = ["alloc", "collections", "vec_deque", "VecDeque", "iter"];
-pub const VEC_FROM_ELEM: [&str; 3] = ["alloc", "vec", "from_elem"];
-pub const VEC_NEW: [&str; 4] = ["alloc", "vec", "Vec", "new"];
-pub const VEC_WITH_CAPACITY: [&str; 4] = ["alloc", "vec", "Vec", "with_capacity"];
-pub const VEC_RESIZE: [&str; 4] = ["alloc", "vec", "Vec", "resize"];
-pub const WEAK_ARC: [&str; 3] = ["alloc", "sync", "Weak"];
-pub const WEAK_RC: [&str; 3] = ["alloc", "rc", "Weak"];
-pub const PTR_NON_NULL: [&str; 4] = ["core", "ptr", "non_null", "NonNull"];
-pub const INSTANT_NOW: [&str; 4] = ["std", "time", "Instant", "now"];
-pub const INSTANT: [&str; 3] = ["std", "time", "Instant"];
-pub const VEC_IS_EMPTY: [&str; 4] = ["alloc", "vec", "Vec", "is_empty"];
-pub const VEC_POP: [&str; 4] = ["alloc", "vec", "Vec", "pop"];
-pub const OPTION_UNWRAP: [&str; 4] = ["core", "option", "Option", "unwrap"];
-pub const OPTION_EXPECT: [&str; 4] = ["core", "option", "Option", "expect"];
-pub const FORMATTER: [&str; 3] = ["core", "fmt", "Formatter"];
-pub const DEBUG_STRUCT: [&str; 4] = ["core", "fmt", "builders", "DebugStruct"];
-pub const ORD_CMP: [&str; 4] = ["core", "cmp", "Ord", "cmp"];
-#[expect(clippy::invalid_paths)] // not sure why it thinks this, it works so
-pub const BOOL_THEN: [&str; 4] = ["core", "bool", "<impl bool>", "then"];
-pub const ARRAY_INTO_ITER: [&str; 4] = ["core", "array", "iter", "IntoIter"];
diff --git a/scout-audit-clippy-utils/src/ptr.rs b/scout-audit-clippy-utils/src/ptr.rs
deleted file mode 100644
index 88837d8a..00000000
--- a/scout-audit-clippy-utils/src/ptr.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-use crate::source::snippet;
-use crate::visitors::{for_each_expr, Descend};
-use crate::{path_to_local_id, strip_pat_refs};
-use core::ops::ControlFlow;
-use rustc_hir::{Body, BodyId, ExprKind, HirId, PatKind};
-use rustc_lint::LateContext;
-use rustc_span::Span;
-use std::borrow::Cow;
-
-pub fn get_spans(
-    cx: &LateContext<'_>,
-    opt_body_id: Option<BodyId>,
-    idx: usize,
-    replacements: &[(&'static str, &'static str)],
-) -> Option<Vec<(Span, Cow<'static, str>)>> {
-    if let Some(body) = opt_body_id.map(|id| cx.tcx.hir().body(id)) {
-        if let PatKind::Binding(_, binding_id, _, _) = strip_pat_refs(body.params[idx].pat).kind {
-            extract_clone_suggestions(cx, binding_id, replacements, body)
-        } else {
-            Some(vec![])
-        }
-    } else {
-        Some(vec![])
-    }
-}
-
-fn extract_clone_suggestions<'tcx>(
-    cx: &LateContext<'tcx>,
-    id: HirId,
-    replace: &[(&'static str, &'static str)],
-    body: &'tcx Body<'_>,
-) -> Option<Vec<(Span, Cow<'static, str>)>> {
-    let mut spans = Vec::new();
-    for_each_expr(body, |e| {
-        if let ExprKind::MethodCall(seg, recv, [], _) = e.kind
-            && path_to_local_id(recv, id)
-        {
-            if seg.ident.as_str() == "capacity" {
-                return ControlFlow::Break(());
-            }
-            for &(fn_name, suffix) in replace {
-                if seg.ident.as_str() == fn_name {
-                    spans.push((e.span, snippet(cx, recv.span, "_") + suffix));
-                    return ControlFlow::Continue(Descend::No);
-                }
-            }
-        }
-        ControlFlow::Continue(Descend::Yes)
-    })
-    .is_none()
-    .then_some(spans)
-}
diff --git a/scout-audit-clippy-utils/src/qualify_min_const_fn.rs b/scout-audit-clippy-utils/src/qualify_min_const_fn.rs
deleted file mode 100644
index 17233058..00000000
--- a/scout-audit-clippy-utils/src/qualify_min_const_fn.rs
+++ /dev/null
@@ -1,429 +0,0 @@
-// This code used to be a part of `rustc` but moved to Clippy as a result of
-// https://github.com/rust-lang/rust/issues/76618. Because of that, it contains unused code and some
-// of terminologies might not be relevant in the context of Clippy. Note that its behavior might
-// differ from the time of `rustc` even if the name stays the same.
-
-use crate::msrvs::Msrv;
-use hir::LangItem;
-use rustc_const_eval::transform::check_consts::ConstCx;
-use rustc_hir as hir;
-use rustc_hir::def_id::DefId;
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_infer::traits::Obligation;
-use rustc_middle::mir::{
-    Body, CastKind, NonDivergingIntrinsic, NullOp, Operand, Place, ProjectionElem, Rvalue, Statement, StatementKind,
-    Terminator, TerminatorKind,
-};
-use rustc_middle::traits::{BuiltinImplSource, ImplSource, ObligationCause};
-use rustc_middle::ty::adjustment::PointerCoercion;
-use rustc_middle::ty::{self, GenericArgKind, TraitRef, Ty, TyCtxt};
-use rustc_semver::RustcVersion;
-use rustc_span::symbol::sym;
-use rustc_span::Span;
-use rustc_trait_selection::traits::{ObligationCtxt, SelectionContext};
-use std::borrow::Cow;
-
-type McfResult = Result<(), (Span, Cow<'static, str>)>;
-
-pub fn is_min_const_fn<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, msrv: &Msrv) -> McfResult {
-    let def_id = body.source.def_id();
-
-    for local in &body.local_decls {
-        check_ty(tcx, local.ty, local.source_info.span)?;
-    }
-    // impl trait is gone in MIR, so check the return type manually
-    check_ty(
-        tcx,
-        tcx.fn_sig(def_id).instantiate_identity().output().skip_binder(),
-        body.local_decls.iter().next().unwrap().source_info.span,
-    )?;
-
-    for bb in &*body.basic_blocks {
-        check_terminator(tcx, body, bb.terminator(), msrv)?;
-        for stmt in &bb.statements {
-            check_statement(tcx, body, def_id, stmt)?;
-        }
-    }
-    Ok(())
-}
-
-fn check_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span) -> McfResult {
-    for arg in ty.walk() {
-        let ty = match arg.unpack() {
-            GenericArgKind::Type(ty) => ty,
-
-            // No constraints on lifetimes or constants, except potentially
-            // constants' types, but `walk` will get to them as well.
-            GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => continue,
-        };
-
-        match ty.kind() {
-            ty::Ref(_, _, hir::Mutability::Mut) => {
-                return Err((span, "mutable references in const fn are unstable".into()));
-            },
-            ty::Alias(ty::Opaque, ..) => return Err((span, "`impl Trait` in const fn is unstable".into())),
-            ty::FnPtr(..) => {
-                return Err((span, "function pointers in const fn are unstable".into()));
-            },
-            ty::Dynamic(preds, _, _) => {
-                for pred in *preds {
-                    match pred.skip_binder() {
-                        ty::ExistentialPredicate::AutoTrait(_) | ty::ExistentialPredicate::Projection(_) => {
-                            return Err((
-                                span,
-                                "trait bounds other than `Sized` \
-                                 on const fn parameters are unstable"
-                                    .into(),
-                            ));
-                        },
-                        ty::ExistentialPredicate::Trait(trait_ref) => {
-                            if Some(trait_ref.def_id) != tcx.lang_items().sized_trait() {
-                                return Err((
-                                    span,
-                                    "trait bounds other than `Sized` \
-                                     on const fn parameters are unstable"
-                                        .into(),
-                                ));
-                            }
-                        },
-                    }
-                }
-            },
-            _ => {},
-        }
-    }
-    Ok(())
-}
-
-fn check_rvalue<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    body: &Body<'tcx>,
-    def_id: DefId,
-    rvalue: &Rvalue<'tcx>,
-    span: Span,
-) -> McfResult {
-    match rvalue {
-        Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
-        Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::AddressOf(_, place) => {
-            check_place(tcx, *place, span, body)
-        },
-        Rvalue::CopyForDeref(place) => check_place(tcx, *place, span, body),
-        Rvalue::Repeat(operand, _)
-        | Rvalue::Use(operand)
-        | Rvalue::Cast(
-            CastKind::PointerFromExposedAddress
-            | CastKind::IntToInt
-            | CastKind::FloatToInt
-            | CastKind::IntToFloat
-            | CastKind::FloatToFloat
-            | CastKind::FnPtrToPtr
-            | CastKind::PtrToPtr
-            | CastKind::PointerCoercion(PointerCoercion::MutToConstPointer | PointerCoercion::ArrayToPointer),
-            operand,
-            _,
-        ) => check_operand(tcx, operand, span, body),
-        Rvalue::Cast(
-            CastKind::PointerCoercion(
-                PointerCoercion::UnsafeFnPointer
-                | PointerCoercion::ClosureFnPointer(_)
-                | PointerCoercion::ReifyFnPointer,
-            ),
-            _,
-            _,
-        ) => Err((span, "function pointer casts are not allowed in const fn".into())),
-        Rvalue::Cast(CastKind::PointerCoercion(PointerCoercion::Unsize), op, cast_ty) => {
-            let pointee_ty = if let Some(deref_ty) = cast_ty.builtin_deref(true) {
-                deref_ty.ty
-            } else {
-                // We cannot allow this for now.
-                return Err((span, "unsizing casts are only allowed for references right now".into()));
-            };
-            let unsized_ty = tcx.struct_tail_erasing_lifetimes(pointee_ty, tcx.param_env(def_id));
-            if let ty::Slice(_) | ty::Str = unsized_ty.kind() {
-                check_operand(tcx, op, span, body)?;
-                // Casting/coercing things to slices is fine.
-                Ok(())
-            } else {
-                // We just can't allow trait objects until we have figured out trait method calls.
-                Err((span, "unsizing casts are not allowed in const fn".into()))
-            }
-        },
-        Rvalue::Cast(CastKind::PointerExposeAddress, _, _) => {
-            Err((span, "casting pointers to ints is unstable in const fn".into()))
-        },
-        Rvalue::Cast(CastKind::DynStar, _, _) => {
-            // FIXME(dyn-star)
-            unimplemented!()
-        },
-        Rvalue::Cast(CastKind::Transmute, _, _) => Err((
-            span,
-            "transmute can attempt to turn pointers into integers, so is unstable in const fn".into(),
-        )),
-        // binops are fine on integers
-        Rvalue::BinaryOp(_, box (lhs, rhs)) | Rvalue::CheckedBinaryOp(_, box (lhs, rhs)) => {
-            check_operand(tcx, lhs, span, body)?;
-            check_operand(tcx, rhs, span, body)?;
-            let ty = lhs.ty(body, tcx);
-            if ty.is_integral() || ty.is_bool() || ty.is_char() {
-                Ok(())
-            } else {
-                Err((
-                    span,
-                    "only int, `bool` and `char` operations are stable in const fn".into(),
-                ))
-            }
-        },
-        Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf | NullOp::OffsetOf(_), _) | Rvalue::ShallowInitBox(_, _) => {
-            Ok(())
-        },
-        Rvalue::UnaryOp(_, operand) => {
-            let ty = operand.ty(body, tcx);
-            if ty.is_integral() || ty.is_bool() {
-                check_operand(tcx, operand, span, body)
-            } else {
-                Err((span, "only int and `bool` operations are stable in const fn".into()))
-            }
-        },
-        Rvalue::Aggregate(_, operands) => {
-            for operand in operands {
-                check_operand(tcx, operand, span, body)?;
-            }
-            Ok(())
-        },
-    }
-}
-
-fn check_statement<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    body: &Body<'tcx>,
-    def_id: DefId,
-    statement: &Statement<'tcx>,
-) -> McfResult {
-    let span = statement.source_info.span;
-    match &statement.kind {
-        StatementKind::Assign(box (place, rval)) => {
-            check_place(tcx, *place, span, body)?;
-            check_rvalue(tcx, body, def_id, rval, span)
-        },
-
-        StatementKind::FakeRead(box (_, place)) => check_place(tcx, *place, span, body),
-        // just an assignment
-        StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
-            check_place(tcx, **place, span, body)
-        },
-
-        StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op)) => check_operand(tcx, op, span, body),
-
-        StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(
-            rustc_middle::mir::CopyNonOverlapping { dst, src, count },
-        )) => {
-            check_operand(tcx, dst, span, body)?;
-            check_operand(tcx, src, span, body)?;
-            check_operand(tcx, count, span, body)
-        },
-        // These are all NOPs
-        StatementKind::StorageLive(_)
-        | StatementKind::StorageDead(_)
-        | StatementKind::Retag { .. }
-        | StatementKind::AscribeUserType(..)
-        | StatementKind::PlaceMention(..)
-        | StatementKind::Coverage(..)
-        | StatementKind::ConstEvalCounter
-        | StatementKind::Nop => Ok(()),
-    }
-}
-
-fn check_operand<'tcx>(tcx: TyCtxt<'tcx>, operand: &Operand<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
-    match operand {
-        Operand::Move(place) => {
-            if !place.projection.as_ref().is_empty()
-                && !is_ty_const_destruct(tcx, place.ty(&body.local_decls, tcx).ty, body)
-            {
-                return Err((
-                    span,
-                    "cannot drop locals with a non constant destructor in const fn".into(),
-                ));
-            }
-
-            check_place(tcx, *place, span, body)
-        },
-        Operand::Copy(place) => check_place(tcx, *place, span, body),
-        Operand::Constant(c) => match c.check_static_ptr(tcx) {
-            Some(_) => Err((span, "cannot access `static` items in const fn".into())),
-            None => Ok(()),
-        },
-    }
-}
-
-fn check_place<'tcx>(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>) -> McfResult {
-    for (base, elem) in place.as_ref().iter_projections() {
-        match elem {
-            ProjectionElem::Field(..) => {
-                let base_ty = base.ty(body, tcx).ty;
-                if let Some(def) = base_ty.ty_adt_def() {
-                    // No union field accesses in `const fn`
-                    if def.is_union() {
-                        return Err((span, "accessing union fields is unstable".into()));
-                    }
-                }
-            },
-            ProjectionElem::ConstantIndex { .. }
-            | ProjectionElem::OpaqueCast(..)
-            | ProjectionElem::Downcast(..)
-            | ProjectionElem::Subslice { .. }
-            | ProjectionElem::Deref
-            | ProjectionElem::Index(_) => {},
-        }
-    }
-
-    Ok(())
-}
-
-fn check_terminator<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    body: &Body<'tcx>,
-    terminator: &Terminator<'tcx>,
-    msrv: &Msrv,
-) -> McfResult {
-    let span = terminator.source_info.span;
-    match &terminator.kind {
-        TerminatorKind::FalseEdge { .. }
-        | TerminatorKind::FalseUnwind { .. }
-        | TerminatorKind::Goto { .. }
-        | TerminatorKind::Return
-        | TerminatorKind::UnwindResume
-        | TerminatorKind::UnwindTerminate(_)
-        | TerminatorKind::Unreachable => Ok(()),
-        TerminatorKind::Drop { place, .. } => {
-            if !is_ty_const_destruct(tcx, place.ty(&body.local_decls, tcx).ty, body) {
-                return Err((
-                    span,
-                    "cannot drop locals with a non constant destructor in const fn".into(),
-                ));
-            }
-            Ok(())
-        },
-        TerminatorKind::SwitchInt { discr, targets: _ } => check_operand(tcx, discr, span, body),
-        TerminatorKind::GeneratorDrop | TerminatorKind::Yield { .. } => {
-            Err((span, "const fn generators are unstable".into()))
-        },
-        TerminatorKind::Call {
-            func,
-            args,
-            call_source: _,
-            destination: _,
-            target: _,
-            unwind: _,
-            fn_span: _,
-        } => {
-            let fn_ty = func.ty(body, tcx);
-            if let ty::FnDef(fn_def_id, _) = *fn_ty.kind() {
-                if !is_const_fn(tcx, fn_def_id, msrv) {
-                    return Err((
-                        span,
-                        format!(
-                            "can only call other `const fn` within a `const fn`, \
-                             but `{func:?}` is not stable as `const fn`",
-                        )
-                        .into(),
-                    ));
-                }
-
-                // HACK: This is to "unstabilize" the `transmute` intrinsic
-                // within const fns. `transmute` is allowed in all other const contexts.
-                // This won't really scale to more intrinsics or functions. Let's allow const
-                // transmutes in const fn before we add more hacks to this.
-                if tcx.is_intrinsic(fn_def_id) && tcx.item_name(fn_def_id) == sym::transmute {
-                    return Err((
-                        span,
-                        "can only call `transmute` from const items, not `const fn`".into(),
-                    ));
-                }
-
-                check_operand(tcx, func, span, body)?;
-
-                for arg in args {
-                    check_operand(tcx, arg, span, body)?;
-                }
-                Ok(())
-            } else {
-                Err((span, "can only call other const fns within const fn".into()))
-            }
-        },
-        TerminatorKind::Assert {
-            cond,
-            expected: _,
-            msg: _,
-            target: _,
-            unwind: _,
-        } => check_operand(tcx, cond, span, body),
-        TerminatorKind::InlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
-    }
-}
-
-fn is_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: &Msrv) -> bool {
-    tcx.is_const_fn(def_id)
-        && tcx.lookup_const_stability(def_id).map_or(true, |const_stab| {
-            if let rustc_attr::StabilityLevel::Stable { since, .. } = const_stab.level {
-                // Checking MSRV is manually necessary because `rustc` has no such concept. This entire
-                // function could be removed if `rustc` provided a MSRV-aware version of `is_const_fn`.
-                // as a part of an unimplemented MSRV check https://github.com/rust-lang/rust/issues/65262.
-
-                // HACK(nilstrieb): CURRENT_RUSTC_VERSION can return versions like 1.66.0-dev. `rustc-semver`
-                // doesn't accept the `-dev` version number so we have to strip it off.
-                let short_version = since
-                    .as_str()
-                    .split('-')
-                    .next()
-                    .expect("rustc_attr::StabilityLevel::Stable::since` is empty");
-
-                let since = rustc_span::Symbol::intern(short_version);
-
-                msrv.meets(RustcVersion::parse(since.as_str()).unwrap_or_else(|err| {
-                    panic!("`rustc_attr::StabilityLevel::Stable::since` is ill-formatted: `{since}`, {err:?}")
-                }))
-            } else {
-                // Unstable const fn with the feature enabled.
-                msrv.current().is_none()
-            }
-        })
-}
-
-#[expect(clippy::similar_names)] // bit too pedantic
-fn is_ty_const_destruct<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>) -> bool {
-    // FIXME(effects, fee1-dead) revert to const destruct once it works again
-    #[expect(unused)]
-    fn is_ty_const_destruct_unused<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, body: &Body<'tcx>) -> bool {
-        // Avoid selecting for simple cases, such as builtin types.
-        if ty::util::is_trivially_const_drop(ty) {
-            return true;
-        }
-
-        // FIXME(effects) constness
-        let obligation = Obligation::new(
-            tcx,
-            ObligationCause::dummy_with_span(body.span),
-            ConstCx::new(tcx, body).param_env,
-            TraitRef::from_lang_item(tcx, LangItem::Destruct, body.span, [ty]),
-        );
-
-        let infcx = tcx.infer_ctxt().build();
-        let mut selcx = SelectionContext::new(&infcx);
-        let Some(impl_src) = selcx.select(&obligation).ok().flatten() else {
-            return false;
-        };
-
-        if !matches!(
-            impl_src,
-            ImplSource::Builtin(BuiltinImplSource::Misc, _) | ImplSource::Param(_)
-        ) {
-            return false;
-        }
-
-        let ocx = ObligationCtxt::new(&infcx);
-        ocx.register_obligations(impl_src.nested_obligations());
-        ocx.select_all_or_error().is_empty()
-    }
-
-    !ty.needs_drop(tcx, ConstCx::new(tcx, body).param_env)
-}
diff --git a/scout-audit-clippy-utils/src/source.rs b/scout-audit-clippy-utils/src/source.rs
deleted file mode 100644
index bb9cdbbc..00000000
--- a/scout-audit-clippy-utils/src/source.rs
+++ /dev/null
@@ -1,598 +0,0 @@
-//! Utils for extracting, inspecting or transforming source code
-
-#![allow(clippy::module_name_repetitions)]
-
-use rustc_data_structures::sync::Lrc;
-use rustc_errors::Applicability;
-use rustc_hir::{BlockCheckMode, Expr, ExprKind, UnsafeSource};
-use rustc_lint::{LateContext, LintContext};
-use rustc_session::Session;
-use rustc_span::source_map::{original_sp, SourceMap};
-use rustc_span::{hygiene, BytePos, Pos, SourceFile, SourceFileAndLine, Span, SpanData, SyntaxContext, DUMMY_SP};
-use std::borrow::Cow;
-use std::ops::Range;
-
-/// A type which can be converted to the range portion of a `Span`.
-pub trait SpanRange {
-    fn into_range(self) -> Range<BytePos>;
-}
-impl SpanRange for Span {
-    fn into_range(self) -> Range<BytePos> {
-        let data = self.data();
-        data.lo..data.hi
-    }
-}
-impl SpanRange for SpanData {
-    fn into_range(self) -> Range<BytePos> {
-        self.lo..self.hi
-    }
-}
-impl SpanRange for Range<BytePos> {
-    fn into_range(self) -> Range<BytePos> {
-        self
-    }
-}
-
-pub struct SourceFileRange {
-    pub sf: Lrc<SourceFile>,
-    pub range: Range<usize>,
-}
-impl SourceFileRange {
-    /// Attempts to get the text from the source file. This can fail if the source text isn't
-    /// loaded.
-    pub fn as_str(&self) -> Option<&str> {
-        self.sf.src.as_ref().and_then(|x| x.get(self.range.clone()))
-    }
-}
-
-/// Gets the source file, and range in the file, of the given span. Returns `None` if the span
-/// extends through multiple files, or is malformed.
-pub fn get_source_text(cx: &impl LintContext, sp: impl SpanRange) -> Option<SourceFileRange> {
-    fn f(sm: &SourceMap, sp: Range<BytePos>) -> Option<SourceFileRange> {
-        let start = sm.lookup_byte_offset(sp.start);
-        let end = sm.lookup_byte_offset(sp.end);
-        if !Lrc::ptr_eq(&start.sf, &end.sf) || start.pos > end.pos {
-            return None;
-        }
-        let range = start.pos.to_usize()..end.pos.to_usize();
-        Some(SourceFileRange { sf: start.sf, range })
-    }
-    f(cx.sess().source_map(), sp.into_range())
-}
-
-/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
-pub fn expr_block<T: LintContext>(
-    cx: &T,
-    expr: &Expr<'_>,
-    outer: SyntaxContext,
-    default: &str,
-    indent_relative_to: Option<Span>,
-    app: &mut Applicability,
-) -> String {
-    let (code, from_macro) = snippet_block_with_context(cx, expr.span, outer, default, indent_relative_to, app);
-    if !from_macro &&
-        let ExprKind::Block(block, _) = expr.kind &&
-        block.rules != BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
-    {
-        format!("{code}")
-    } else {
-        // FIXME: add extra indent for the unsafe blocks:
-        //     original code:   unsafe { ... }
-        //     result code:     { unsafe { ... } }
-        //     desired code:    {\n  unsafe { ... }\n}
-        format!("{{ {code} }}")
-    }
-}
-
-/// Returns a new Span that extends the original Span to the first non-whitespace char of the first
-/// line.
-///
-/// ```rust,ignore
-///     let x = ();
-/// //          ^^
-/// // will be converted to
-///     let x = ();
-/// //  ^^^^^^^^^^
-/// ```
-pub fn first_line_of_span<T: LintContext>(cx: &T, span: Span) -> Span {
-    first_char_in_first_line(cx, span).map_or(span, |first_char_pos| span.with_lo(first_char_pos))
-}
-
-fn first_char_in_first_line<T: LintContext>(cx: &T, span: Span) -> Option<BytePos> {
-    let line_span = line_span(cx, span);
-    snippet_opt(cx, line_span).and_then(|snip| {
-        snip.find(|c: char| !c.is_whitespace())
-            .map(|pos| line_span.lo() + BytePos::from_usize(pos))
-    })
-}
-
-/// Extends the span to the beginning of the spans line, incl. whitespaces.
-///
-/// ```rust
-///        let x = ();
-/// //             ^^
-/// // will be converted to
-///        let x = ();
-/// // ^^^^^^^^^^^^^^
-/// ```
-fn line_span<T: LintContext>(cx: &T, span: Span) -> Span {
-    let span = original_sp(span, DUMMY_SP);
-    let SourceFileAndLine { sf, line } = cx.sess().source_map().lookup_line(span.lo()).unwrap();
-    let line_start = sf.lines()[line];
-    let line_start = sf.absolute_position(line_start);
-    span.with_lo(line_start)
-}
-
-/// Returns the indentation of the line of a span
-///
-/// ```rust,ignore
-/// let x = ();
-/// //      ^^ -- will return 0
-///     let x = ();
-/// //          ^^ -- will return 4
-/// ```
-pub fn indent_of<T: LintContext>(cx: &T, span: Span) -> Option<usize> {
-    snippet_opt(cx, line_span(cx, span)).and_then(|snip| snip.find(|c: char| !c.is_whitespace()))
-}
-
-/// Gets a snippet of the indentation of the line of a span
-pub fn snippet_indent<T: LintContext>(cx: &T, span: Span) -> Option<String> {
-    snippet_opt(cx, line_span(cx, span)).map(|mut s| {
-        let len = s.len() - s.trim_start().len();
-        s.truncate(len);
-        s
-    })
-}
-
-// If the snippet is empty, it's an attribute that was inserted during macro
-// expansion and we want to ignore those, because they could come from external
-// sources that the user has no control over.
-// For some reason these attributes don't have any expansion info on them, so
-// we have to check it this way until there is a better way.
-pub fn is_present_in_source<T: LintContext>(cx: &T, span: Span) -> bool {
-    if let Some(snippet) = snippet_opt(cx, span) {
-        if snippet.is_empty() {
-            return false;
-        }
-    }
-    true
-}
-
-/// Returns the position just before rarrow
-///
-/// ```rust,ignore
-/// fn into(self) -> () {}
-///              ^
-/// // in case of unformatted code
-/// fn into2(self)-> () {}
-///               ^
-/// fn into3(self)   -> () {}
-///               ^
-/// ```
-pub fn position_before_rarrow(s: &str) -> Option<usize> {
-    s.rfind("->").map(|rpos| {
-        let mut rpos = rpos;
-        let chars: Vec<char> = s.chars().collect();
-        while rpos > 1 {
-            if let Some(c) = chars.get(rpos - 1) {
-                if c.is_whitespace() {
-                    rpos -= 1;
-                    continue;
-                }
-            }
-            break;
-        }
-        rpos
-    })
-}
-
-/// Reindent a multiline string with possibility of ignoring the first line.
-#[expect(clippy::needless_pass_by_value)]
-pub fn reindent_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
-    let s_space = reindent_multiline_inner(&s, ignore_first, indent, ' ');
-    let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
-    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ').into()
-}
-
-fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>, ch: char) -> String {
-    let x = s
-        .lines()
-        .skip(usize::from(ignore_first))
-        .filter_map(|l| {
-            if l.is_empty() {
-                None
-            } else {
-                // ignore empty lines
-                Some(l.char_indices().find(|&(_, x)| x != ch).unwrap_or((l.len(), ch)).0)
-            }
-        })
-        .min()
-        .unwrap_or(0);
-    let indent = indent.unwrap_or(0);
-    s.lines()
-        .enumerate()
-        .map(|(i, l)| {
-            if (ignore_first && i == 0) || l.is_empty() {
-                l.to_owned()
-            } else if x > indent {
-                l.split_at(x - indent).1.to_owned()
-            } else {
-                " ".repeat(indent - x) + l
-            }
-        })
-        .collect::<Vec<String>>()
-        .join("\n")
-}
-
-/// Converts a span to a code snippet if available, otherwise returns the default.
-///
-/// This is useful if you want to provide suggestions for your lint or more generally, if you want
-/// to convert a given `Span` to a `str`. To create suggestions consider using
-/// [`snippet_with_applicability`] to ensure that the applicability stays correct.
-///
-/// # Example
-/// ```rust,ignore
-/// // Given two spans one for `value` and one for the `init` expression.
-/// let value = Vec::new();
-/// //  ^^^^^   ^^^^^^^^^^
-/// //  span1   span2
-///
-/// // The snipped call would return the corresponding code snippet
-/// snippet(cx, span1, "..") // -> "value"
-/// snippet(cx, span2, "..") // -> "Vec::new()"
-/// ```
-pub fn snippet<'a, T: LintContext>(cx: &T, span: Span, default: &'a str) -> Cow<'a, str> {
-    snippet_opt(cx, span).map_or_else(|| Cow::Borrowed(default), From::from)
-}
-
-/// Same as [`snippet`], but it adapts the applicability level by following rules:
-///
-/// - Applicability level `Unspecified` will never be changed.
-/// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
-/// - If the default value is used and the applicability level is `MachineApplicable`, change it to
-/// `HasPlaceholders`
-pub fn snippet_with_applicability<'a, T: LintContext>(
-    cx: &T,
-    span: Span,
-    default: &'a str,
-    applicability: &mut Applicability,
-) -> Cow<'a, str> {
-    snippet_with_applicability_sess(cx.sess(), span, default, applicability)
-}
-
-fn snippet_with_applicability_sess<'a>(
-    sess: &Session,
-    span: Span,
-    default: &'a str,
-    applicability: &mut Applicability,
-) -> Cow<'a, str> {
-    if *applicability != Applicability::Unspecified && span.from_expansion() {
-        *applicability = Applicability::MaybeIncorrect;
-    }
-    snippet_opt_sess(sess, span).map_or_else(
-        || {
-            if *applicability == Applicability::MachineApplicable {
-                *applicability = Applicability::HasPlaceholders;
-            }
-            Cow::Borrowed(default)
-        },
-        From::from,
-    )
-}
-
-/// Converts a span to a code snippet. Returns `None` if not available.
-pub fn snippet_opt(cx: &impl LintContext, span: Span) -> Option<String> {
-    snippet_opt_sess(cx.sess(), span)
-}
-
-fn snippet_opt_sess(sess: &Session, span: Span) -> Option<String> {
-    sess.source_map().span_to_snippet(span).ok()
-}
-
-/// Converts a span (from a block) to a code snippet if available, otherwise use default.
-///
-/// This trims the code of indentation, except for the first line. Use it for blocks or block-like
-/// things which need to be printed as such.
-///
-/// The `indent_relative_to` arg can be used, to provide a span, where the indentation of the
-/// resulting snippet of the given span.
-///
-/// # Example
-///
-/// ```rust,ignore
-/// snippet_block(cx, block.span, "..", None)
-/// // where, `block` is the block of the if expr
-///     if x {
-///         y;
-///     }
-/// // will return the snippet
-/// {
-///     y;
-/// }
-/// ```
-///
-/// ```rust,ignore
-/// snippet_block(cx, block.span, "..", Some(if_expr.span))
-/// // where, `block` is the block of the if expr
-///     if x {
-///         y;
-///     }
-/// // will return the snippet
-/// {
-///         y;
-///     } // aligned with `if`
-/// ```
-/// Note that the first line of the snippet always has 0 indentation.
-pub fn snippet_block<'a, T: LintContext>(
-    cx: &T,
-    span: Span,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
-    let snip = snippet(cx, span, default);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    reindent_multiline(snip, true, indent)
-}
-
-/// Same as `snippet_block`, but adapts the applicability level by the rules of
-/// `snippet_with_applicability`.
-pub fn snippet_block_with_applicability<'a>(
-    cx: &impl LintContext,
-    span: Span,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-    applicability: &mut Applicability,
-) -> Cow<'a, str> {
-    let snip = snippet_with_applicability(cx, span, default, applicability);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    reindent_multiline(snip, true, indent)
-}
-
-pub fn snippet_block_with_context<'a>(
-    cx: &impl LintContext,
-    span: Span,
-    outer: SyntaxContext,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-    app: &mut Applicability,
-) -> (Cow<'a, str>, bool) {
-    let (snip, from_macro) = snippet_with_context(cx, span, outer, default, app);
-    let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
-    (reindent_multiline(snip, true, indent), from_macro)
-}
-
-/// Same as `snippet_with_applicability`, but first walks the span up to the given context. This
-/// will result in the macro call, rather than the expansion, if the span is from a child context.
-/// If the span is not from a child context, it will be used directly instead.
-///
-/// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR node
-/// would result in `box []`. If given the context of the address of expression, this function will
-/// correctly get a snippet of `vec![]`.
-///
-/// This will also return whether or not the snippet is a macro call.
-pub fn snippet_with_context<'a>(
-    cx: &impl LintContext,
-    span: Span,
-    outer: SyntaxContext,
-    default: &'a str,
-    applicability: &mut Applicability,
-) -> (Cow<'a, str>, bool) {
-    snippet_with_context_sess(cx.sess(), span, outer, default, applicability)
-}
-
-fn snippet_with_context_sess<'a>(
-    sess: &Session,
-    span: Span,
-    outer: SyntaxContext,
-    default: &'a str,
-    applicability: &mut Applicability,
-) -> (Cow<'a, str>, bool) {
-    let (span, is_macro_call) = walk_span_to_context(span, outer).map_or_else(
-        || {
-            // The span is from a macro argument, and the outer context is the macro using the argument
-            if *applicability != Applicability::Unspecified {
-                *applicability = Applicability::MaybeIncorrect;
-            }
-            // TODO: get the argument span.
-            (span, false)
-        },
-        |outer_span| (outer_span, span.ctxt() != outer),
-    );
-
-    (
-        snippet_with_applicability_sess(sess, span, default, applicability),
-        is_macro_call,
-    )
-}
-
-/// Walks the span up to the target context, thereby returning the macro call site if the span is
-/// inside a macro expansion, or the original span if it is not. Note this will return `None` in the
-/// case of the span being in a macro expansion, but the target context is from expanding a macro
-/// argument.
-///
-/// Given the following
-///
-/// ```rust,ignore
-/// macro_rules! m { ($e:expr) => { f($e) }; }
-/// g(m!(0))
-/// ```
-///
-/// If called with a span of the call to `f` and a context of the call to `g` this will return a
-/// span containing `m!(0)`. However, if called with a span of the literal `0` this will give a span
-/// containing `0` as the context is the same as the outer context.
-///
-/// This will traverse through multiple macro calls. Given the following:
-///
-/// ```rust,ignore
-/// macro_rules! m { ($e:expr) => { n!($e, 0) }; }
-/// macro_rules! n { ($e:expr, $f:expr) => { f($e, $f) }; }
-/// g(m!(0))
-/// ```
-///
-/// If called with a span of the call to `f` and a context of the call to `g` this will return a
-/// span containing `m!(0)`.
-pub fn walk_span_to_context(span: Span, outer: SyntaxContext) -> Option<Span> {
-    let outer_span = hygiene::walk_chain(span, outer);
-    (outer_span.ctxt() == outer).then_some(outer_span)
-}
-
-/// Removes block comments from the given `Vec` of lines.
-///
-/// # Examples
-///
-/// ```rust,ignore
-/// without_block_comments(vec!["/*", "foo", "*/"]);
-/// // => vec![]
-///
-/// without_block_comments(vec!["bar", "/*", "foo", "*/"]);
-/// // => vec!["bar"]
-/// ```
-pub fn without_block_comments(lines: Vec<&str>) -> Vec<&str> {
-    let mut without = vec![];
-
-    let mut nest_level = 0;
-
-    for line in lines {
-        if line.contains("/*") {
-            nest_level += 1;
-            continue;
-        } else if line.contains("*/") {
-            nest_level -= 1;
-            continue;
-        }
-
-        if nest_level == 0 {
-            without.push(line);
-        }
-    }
-
-    without
-}
-
-/// Trims the whitespace from the start and the end of the span.
-pub fn trim_span(sm: &SourceMap, span: Span) -> Span {
-    let data = span.data();
-    let sf: &_ = &sm.lookup_source_file(data.lo);
-    let Some(src) = sf.src.as_deref() else {
-        return span;
-    };
-    let Some(snip) = &src.get((data.lo - sf.start_pos).to_usize()..(data.hi - sf.start_pos).to_usize()) else {
-        return span;
-    };
-    let trim_start = snip.len() - snip.trim_start().len();
-    let trim_end = snip.len() - snip.trim_end().len();
-    SpanData {
-        lo: data.lo + BytePos::from_usize(trim_start),
-        hi: data.hi - BytePos::from_usize(trim_end),
-        ctxt: data.ctxt,
-        parent: data.parent,
-    }
-    .span()
-}
-
-/// Expand a span to include a preceding comma
-/// ```rust,ignore
-/// writeln!(o, "")   ->   writeln!(o, "")
-///             ^^                   ^^^^
-/// ```
-pub fn expand_past_previous_comma(cx: &LateContext<'_>, span: Span) -> Span {
-    let extended = cx.sess().source_map().span_extend_to_prev_char(span, ',', true);
-    extended.with_lo(extended.lo() - BytePos(1))
-}
-
-#[cfg(test)]
-mod test {
-    use super::{reindent_multiline, without_block_comments};
-
-    #[test]
-    fn test_reindent_multiline_single_line() {
-        assert_eq!("", reindent_multiline("".into(), false, None));
-        assert_eq!("...", reindent_multiline("...".into(), false, None));
-        assert_eq!("...", reindent_multiline("    ...".into(), false, None));
-        assert_eq!("...", reindent_multiline("\t...".into(), false, None));
-        assert_eq!("...", reindent_multiline("\t\t...".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_block() {
-        assert_eq!("\
-    if x {
-        y
-    } else {
-        z
-    }", reindent_multiline("    if x {
-            y
-        } else {
-            z
-        }".into(), false, None));
-        assert_eq!("\
-    if x {
-    \ty
-    } else {
-    \tz
-    }", reindent_multiline("    if x {
-        \ty
-        } else {
-        \tz
-        }".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_empty_line() {
-        assert_eq!("\
-    if x {
-        y
-
-    } else {
-        z
-    }", reindent_multiline("    if x {
-            y
-
-        } else {
-            z
-        }".into(), false, None));
-    }
-
-    #[test]
-    #[rustfmt::skip]
-    fn test_reindent_multiline_lines_deeper() {
-        assert_eq!("\
-        if x {
-            y
-        } else {
-            z
-        }", reindent_multiline("\
-    if x {
-        y
-    } else {
-        z
-    }".into(), true, Some(8)));
-    }
-
-    #[test]
-    fn test_without_block_comments_lines_without_block_comments() {
-        let result = without_block_comments(vec!["/*", "", "*/"]);
-        println!("result: {result:?}");
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["", "/*", "", "*/", "#[crate_type = \"lib\"]", "/*", "", "*/", ""]);
-        assert_eq!(result, vec!["", "#[crate_type = \"lib\"]", ""]);
-
-        let result = without_block_comments(vec!["/* rust", "", "*/"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* one-line comment */"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* nested", "/* multi-line", "comment", "*/", "test", "*/"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["/* nested /* inline /* comment */ test */ */"]);
-        assert!(result.is_empty());
-
-        let result = without_block_comments(vec!["foo", "bar", "baz"]);
-        assert_eq!(result, vec!["foo", "bar", "baz"]);
-    }
-}
diff --git a/scout-audit-clippy-utils/src/str_utils.rs b/scout-audit-clippy-utils/src/str_utils.rs
deleted file mode 100644
index 03a9d3c2..00000000
--- a/scout-audit-clippy-utils/src/str_utils.rs
+++ /dev/null
@@ -1,325 +0,0 @@
-/// Dealing with sting indices can be hard, this struct ensures that both the
-/// character and byte index are provided for correct indexing.
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct StrIndex {
-    pub char_index: usize,
-    pub byte_index: usize,
-}
-
-impl StrIndex {
-    pub fn new(char_index: usize, byte_index: usize) -> Self {
-        Self { char_index, byte_index }
-    }
-}
-
-/// Returns the index of the character after the first camel-case component of `s`.
-///
-/// ```
-/// # use clippy_utils::str_utils::{camel_case_until, StrIndex};
-/// assert_eq!(camel_case_until("AbcDef"), StrIndex::new(6, 6));
-/// assert_eq!(camel_case_until("ABCD"), StrIndex::new(0, 0));
-/// assert_eq!(camel_case_until("AbcDD"), StrIndex::new(3, 3));
-/// assert_eq!(camel_case_until("Abc\u{f6}\u{f6}DD"), StrIndex::new(5, 7));
-/// ```
-#[must_use]
-pub fn camel_case_until(s: &str) -> StrIndex {
-    let mut iter = s.char_indices().enumerate();
-    if let Some((_char_index, (_, first))) = iter.next() {
-        if !first.is_uppercase() {
-            return StrIndex::new(0, 0);
-        }
-    } else {
-        return StrIndex::new(0, 0);
-    }
-    let mut up = true;
-    let mut last_index = StrIndex::new(0, 0);
-    for (char_index, (byte_index, c)) in iter {
-        if up {
-            if c.is_lowercase() {
-                up = false;
-            } else {
-                return last_index;
-            }
-        } else if c.is_uppercase() {
-            up = true;
-            last_index.byte_index = byte_index;
-            last_index.char_index = char_index;
-        } else if !c.is_lowercase() {
-            return StrIndex::new(char_index, byte_index);
-        }
-    }
-
-    if up {
-        last_index
-    } else {
-        StrIndex::new(s.chars().count(), s.len())
-    }
-}
-
-/// Returns index of the first camel-case component of `s`.
-///
-/// ```
-/// # use clippy_utils::str_utils::{camel_case_start, StrIndex};
-/// assert_eq!(camel_case_start("AbcDef"), StrIndex::new(0, 0));
-/// assert_eq!(camel_case_start("abcDef"), StrIndex::new(3, 3));
-/// assert_eq!(camel_case_start("ABCD"), StrIndex::new(4, 4));
-/// assert_eq!(camel_case_start("abcd"), StrIndex::new(4, 4));
-/// assert_eq!(camel_case_start("\u{f6}\u{f6}cd"), StrIndex::new(4, 6));
-/// ```
-#[must_use]
-pub fn camel_case_start(s: &str) -> StrIndex {
-    camel_case_start_from_idx(s, 0)
-}
-
-/// Returns `StrIndex` of the last camel-case component of `s[idx..]`.
-///
-/// ```
-/// # use clippy_utils::str_utils::{camel_case_start_from_idx, StrIndex};
-/// assert_eq!(camel_case_start_from_idx("AbcDef", 0), StrIndex::new(0, 0));
-/// assert_eq!(camel_case_start_from_idx("AbcDef", 1), StrIndex::new(3, 3));
-/// assert_eq!(camel_case_start_from_idx("AbcDefGhi", 0), StrIndex::new(0, 0));
-/// assert_eq!(camel_case_start_from_idx("AbcDefGhi", 1), StrIndex::new(3, 3));
-/// assert_eq!(camel_case_start_from_idx("Abcdefg", 1), StrIndex::new(7, 7));
-/// ```
-pub fn camel_case_start_from_idx(s: &str, start_idx: usize) -> StrIndex {
-    let char_count = s.chars().count();
-    let range = 0..char_count;
-    let mut iter = range.rev().zip(s.char_indices().rev());
-    if let Some((_, (_, first))) = iter.next() {
-        if !first.is_lowercase() {
-            return StrIndex::new(char_count, s.len());
-        }
-    } else {
-        return StrIndex::new(char_count, s.len());
-    }
-
-    let mut down = true;
-    let mut last_index = StrIndex::new(char_count, s.len());
-    for (char_index, (byte_index, c)) in iter {
-        if byte_index < start_idx {
-            break;
-        }
-        if down {
-            if c.is_uppercase() {
-                down = false;
-                last_index.byte_index = byte_index;
-                last_index.char_index = char_index;
-            } else if !c.is_lowercase() {
-                return last_index;
-            }
-        } else if c.is_lowercase() {
-            down = true;
-        } else if c.is_uppercase() {
-            last_index.byte_index = byte_index;
-            last_index.char_index = char_index;
-        } else {
-            return last_index;
-        }
-    }
-
-    last_index
-}
-
-/// Get the indexes of camel case components of a string `s`
-///
-/// ```
-/// # use clippy_utils::str_utils::{camel_case_indices, StrIndex};
-/// assert_eq!(
-///     camel_case_indices("AbcDef"),
-///     vec![StrIndex::new(0, 0), StrIndex::new(3, 3), StrIndex::new(6, 6)]
-/// );
-/// assert_eq!(
-///     camel_case_indices("abcDef"),
-///     vec![StrIndex::new(3, 3), StrIndex::new(6, 6)]
-/// );
-/// ```
-pub fn camel_case_indices(s: &str) -> Vec<StrIndex> {
-    let mut result = Vec::new();
-    let mut str_idx = camel_case_start(s);
-
-    while str_idx.byte_index < s.len() {
-        let next_idx = str_idx.byte_index + 1;
-        result.push(str_idx);
-        str_idx = camel_case_start_from_idx(s, next_idx);
-    }
-    result.push(str_idx);
-
-    result
-}
-
-/// Split camel case string into a vector of its components
-///
-/// ```
-/// # use clippy_utils::str_utils::{camel_case_split, StrIndex};
-/// assert_eq!(camel_case_split("AbcDef"), vec!["Abc", "Def"]);
-/// ```
-pub fn camel_case_split(s: &str) -> Vec<&str> {
-    let mut offsets = camel_case_indices(s)
-        .iter()
-        .map(|e| e.byte_index)
-        .collect::<Vec<usize>>();
-    if offsets[0] != 0 {
-        offsets.insert(0, 0);
-    }
-
-    offsets.windows(2).map(|w| &s[w[0]..w[1]]).collect()
-}
-
-/// Dealing with sting comparison can be complicated, this struct ensures that both the
-/// character and byte count are provided for correct indexing.
-#[derive(Debug, Default, PartialEq, Eq)]
-pub struct StrCount {
-    pub char_count: usize,
-    pub byte_count: usize,
-}
-
-impl StrCount {
-    pub fn new(char_count: usize, byte_count: usize) -> Self {
-        Self { char_count, byte_count }
-    }
-}
-
-/// Returns the number of chars that match from the start
-///
-/// ```
-/// # use clippy_utils::str_utils::{count_match_start, StrCount};
-/// assert_eq!(count_match_start("hello_mouse", "hello_penguin"), StrCount::new(6, 6));
-/// assert_eq!(count_match_start("hello_clippy", "bye_bugs"), StrCount::new(0, 0));
-/// assert_eq!(count_match_start("hello_world", "hello_world"), StrCount::new(11, 11));
-/// assert_eq!(count_match_start("T\u{f6}ffT\u{f6}ff", "T\u{f6}ff"), StrCount::new(4, 5));
-/// ```
-#[must_use]
-pub fn count_match_start(str1: &str, str2: &str) -> StrCount {
-    // (char_index, char1)
-    let char_count = str1.chars().count();
-    let iter1 = (0..=char_count).zip(str1.chars());
-    // (byte_index, char2)
-    let iter2 = str2.char_indices();
-
-    iter1
-        .zip(iter2)
-        .take_while(|((_, c1), (_, c2))| c1 == c2)
-        .last()
-        .map_or_else(StrCount::default, |((char_index, _), (byte_index, character))| {
-            StrCount::new(char_index + 1, byte_index + character.len_utf8())
-        })
-}
-
-/// Returns the number of chars and bytes that match from the end
-///
-/// ```
-/// # use clippy_utils::str_utils::{count_match_end, StrCount};
-/// assert_eq!(count_match_end("hello_cat", "bye_cat"), StrCount::new(4, 4));
-/// assert_eq!(count_match_end("if_item_thing", "enum_value"), StrCount::new(0, 0));
-/// assert_eq!(count_match_end("Clippy", "Clippy"), StrCount::new(6, 6));
-/// assert_eq!(count_match_end("MyT\u{f6}ff", "YourT\u{f6}ff"), StrCount::new(4, 5));
-/// ```
-#[must_use]
-pub fn count_match_end(str1: &str, str2: &str) -> StrCount {
-    let char_count = str1.chars().count();
-    if char_count == 0 {
-        return StrCount::default();
-    }
-
-    // (char_index, char1)
-    let iter1 = (0..char_count).rev().zip(str1.chars().rev());
-    // (byte_index, char2)
-    let byte_count = str2.len();
-    let iter2 = str2.char_indices().rev();
-
-    iter1
-        .zip(iter2)
-        .take_while(|((_, c1), (_, c2))| c1 == c2)
-        .last()
-        .map_or_else(StrCount::default, |((char_index, _), (byte_index, _))| {
-            StrCount::new(char_count - char_index, byte_count - byte_index)
-        })
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn camel_case_start_full() {
-        assert_eq!(camel_case_start("AbcDef"), StrIndex::new(0, 0));
-        assert_eq!(camel_case_start("Abc"), StrIndex::new(0, 0));
-        assert_eq!(camel_case_start("ABcd"), StrIndex::new(0, 0));
-        assert_eq!(camel_case_start("ABcdEf"), StrIndex::new(0, 0));
-        assert_eq!(camel_case_start("AabABcd"), StrIndex::new(0, 0));
-    }
-
-    #[test]
-    fn camel_case_start_partial() {
-        assert_eq!(camel_case_start("abcDef"), StrIndex::new(3, 3));
-        assert_eq!(camel_case_start("aDbc"), StrIndex::new(1, 1));
-        assert_eq!(camel_case_start("aabABcd"), StrIndex::new(3, 3));
-        assert_eq!(camel_case_start("\u{f6}\u{f6}AabABcd"), StrIndex::new(2, 4));
-    }
-
-    #[test]
-    fn camel_case_start_not() {
-        assert_eq!(camel_case_start("AbcDef_"), StrIndex::new(7, 7));
-        assert_eq!(camel_case_start("AbcDD"), StrIndex::new(5, 5));
-        assert_eq!(camel_case_start("all_small"), StrIndex::new(9, 9));
-        assert_eq!(camel_case_start("\u{f6}_all_small"), StrIndex::new(11, 12));
-    }
-
-    #[test]
-    fn camel_case_start_caps() {
-        assert_eq!(camel_case_start("ABCD"), StrIndex::new(4, 4));
-    }
-
-    #[test]
-    fn camel_case_until_full() {
-        assert_eq!(camel_case_until("AbcDef"), StrIndex::new(6, 6));
-        assert_eq!(camel_case_until("Abc"), StrIndex::new(3, 3));
-        assert_eq!(camel_case_until("Abc\u{f6}\u{f6}\u{f6}"), StrIndex::new(6, 9));
-    }
-
-    #[test]
-    fn camel_case_until_not() {
-        assert_eq!(camel_case_until("abcDef"), StrIndex::new(0, 0));
-        assert_eq!(camel_case_until("aDbc"), StrIndex::new(0, 0));
-    }
-
-    #[test]
-    fn camel_case_until_partial() {
-        assert_eq!(camel_case_until("AbcDef_"), StrIndex::new(6, 6));
-        assert_eq!(camel_case_until("CallTypeC"), StrIndex::new(8, 8));
-        assert_eq!(camel_case_until("AbcDD"), StrIndex::new(3, 3));
-        assert_eq!(camel_case_until("Abc\u{f6}\u{f6}DD"), StrIndex::new(5, 7));
-    }
-
-    #[test]
-    fn until_caps() {
-        assert_eq!(camel_case_until("ABCD"), StrIndex::new(0, 0));
-    }
-
-    #[test]
-    fn camel_case_start_from_idx_full() {
-        assert_eq!(camel_case_start_from_idx("AbcDef", 0), StrIndex::new(0, 0));
-        assert_eq!(camel_case_start_from_idx("AbcDef", 1), StrIndex::new(3, 3));
-        assert_eq!(camel_case_start_from_idx("AbcDef", 4), StrIndex::new(6, 6));
-        assert_eq!(camel_case_start_from_idx("AbcDefGhi", 0), StrIndex::new(0, 0));
-        assert_eq!(camel_case_start_from_idx("AbcDefGhi", 1), StrIndex::new(3, 3));
-        assert_eq!(camel_case_start_from_idx("Abcdefg", 1), StrIndex::new(7, 7));
-    }
-
-    #[test]
-    fn camel_case_indices_full() {
-        assert_eq!(camel_case_indices("Abc\u{f6}\u{f6}DD"), vec![StrIndex::new(7, 9)]);
-    }
-
-    #[test]
-    fn camel_case_split_full() {
-        assert_eq!(camel_case_split("A"), vec!["A"]);
-        assert_eq!(camel_case_split("AbcDef"), vec!["Abc", "Def"]);
-        assert_eq!(camel_case_split("Abc"), vec!["Abc"]);
-        assert_eq!(camel_case_split("abcDef"), vec!["abc", "Def"]);
-        assert_eq!(
-            camel_case_split("\u{f6}\u{f6}AabABcd"),
-            vec!["\u{f6}\u{f6}", "Aab", "A", "Bcd"]
-        );
-    }
-}
diff --git a/scout-audit-clippy-utils/src/sugg.rs b/scout-audit-clippy-utils/src/sugg.rs
deleted file mode 100644
index ae8ee371..00000000
--- a/scout-audit-clippy-utils/src/sugg.rs
+++ /dev/null
@@ -1,1111 +0,0 @@
-//! Contains utility functions to generate suggestions.
-#![deny(clippy::missing_docs_in_private_items)]
-
-use crate::source::{snippet, snippet_opt, snippet_with_applicability, snippet_with_context};
-use crate::ty::expr_sig;
-use crate::{get_parent_expr_for_hir, higher};
-use rustc_ast::util::parser::AssocOp;
-use rustc_ast::{ast, token};
-use rustc_ast_pretty::pprust::token_kind_to_string;
-use rustc_errors::Applicability;
-use rustc_hir as hir;
-use rustc_hir::{Closure, ExprKind, HirId, MutTy, TyKind};
-use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_lint::{EarlyContext, LateContext, LintContext};
-use rustc_middle::hir::place::ProjectionKind;
-use rustc_middle::mir::{FakeReadCause, Mutability};
-use rustc_middle::ty;
-use rustc_span::source_map::{BytePos, CharPos, Pos, Span, SyntaxContext};
-use std::borrow::Cow;
-use std::fmt::{self, Display, Write as _};
-use std::ops::{Add, Neg, Not, Sub};
-
-/// A helper type to build suggestion correctly handling parentheses.
-#[derive(Clone, Debug, PartialEq)]
-pub enum Sugg<'a> {
-    /// An expression that never needs parentheses such as `1337` or `[0; 42]`.
-    NonParen(Cow<'a, str>),
-    /// An expression that does not fit in other variants.
-    MaybeParen(Cow<'a, str>),
-    /// A binary operator expression, including `as`-casts and explicit type
-    /// coercion.
-    BinOp(AssocOp, Cow<'a, str>, Cow<'a, str>),
-}
-
-/// Literal constant `0`, for convenience.
-pub const ZERO: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("0"));
-/// Literal constant `1`, for convenience.
-pub const ONE: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("1"));
-/// a constant represents an empty string, for convenience.
-pub const EMPTY: Sugg<'static> = Sugg::NonParen(Cow::Borrowed(""));
-
-impl Display for Sugg<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        match *self {
-            Sugg::NonParen(ref s) | Sugg::MaybeParen(ref s) => s.fmt(f),
-            Sugg::BinOp(op, ref lhs, ref rhs) => binop_to_string(op, lhs, rhs).fmt(f),
-        }
-    }
-}
-
-#[expect(clippy::wrong_self_convention)] // ok, because of the function `as_ty` method
-impl<'a> Sugg<'a> {
-    /// Prepare a suggestion from an expression.
-    pub fn hir_opt(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> Option<Self> {
-        let get_snippet = |span| snippet(cx, span, "");
-        snippet_opt(cx, expr.span).map(|_| Self::hir_from_snippet(expr, get_snippet))
-    }
-
-    /// Convenience function around `hir_opt` for suggestions with a default
-    /// text.
-    pub fn hir(cx: &LateContext<'_>, expr: &hir::Expr<'_>, default: &'a str) -> Self {
-        Self::hir_opt(cx, expr).unwrap_or(Sugg::NonParen(Cow::Borrowed(default)))
-    }
-
-    /// Same as `hir`, but it adapts the applicability level by following rules:
-    ///
-    /// - Applicability level `Unspecified` will never be changed.
-    /// - If the span is inside a macro, change the applicability level to `MaybeIncorrect`.
-    /// - If the default value is used and the applicability level is `MachineApplicable`, change it
-    ///   to
-    /// `HasPlaceholders`
-    pub fn hir_with_applicability(
-        cx: &LateContext<'_>,
-        expr: &hir::Expr<'_>,
-        default: &'a str,
-        applicability: &mut Applicability,
-    ) -> Self {
-        if *applicability != Applicability::Unspecified && expr.span.from_expansion() {
-            *applicability = Applicability::MaybeIncorrect;
-        }
-        Self::hir_opt(cx, expr).unwrap_or_else(|| {
-            if *applicability == Applicability::MachineApplicable {
-                *applicability = Applicability::HasPlaceholders;
-            }
-            Sugg::NonParen(Cow::Borrowed(default))
-        })
-    }
-
-    /// Same as `hir`, but first walks the span up to the given context. This will result in the
-    /// macro call, rather than the expansion, if the span is from a child context. If the span is
-    /// not from a child context, it will be used directly instead.
-    ///
-    /// e.g. Given the expression `&vec![]`, getting a snippet from the span for `vec![]` as a HIR
-    /// node would result in `box []`. If given the context of the address of expression, this
-    /// function will correctly get a snippet of `vec![]`.
-    pub fn hir_with_context(
-        cx: &LateContext<'_>,
-        expr: &hir::Expr<'_>,
-        ctxt: SyntaxContext,
-        default: &'a str,
-        applicability: &mut Applicability,
-    ) -> Self {
-        if expr.span.ctxt() == ctxt {
-            Self::hir_from_snippet(expr, |span| snippet(cx, span, default))
-        } else {
-            let (snip, _) = snippet_with_context(cx, expr.span, ctxt, default, applicability);
-            Sugg::NonParen(snip)
-        }
-    }
-
-    /// Generate a suggestion for an expression with the given snippet. This is used by the `hir_*`
-    /// function variants of `Sugg`, since these use different snippet functions.
-    fn hir_from_snippet(expr: &hir::Expr<'_>, get_snippet: impl Fn(Span) -> Cow<'a, str>) -> Self {
-        if let Some(range) = higher::Range::hir(expr) {
-            let op = match range.limits {
-                ast::RangeLimits::HalfOpen => AssocOp::DotDot,
-                ast::RangeLimits::Closed => AssocOp::DotDotEq,
-            };
-            let start = range.start.map_or("".into(), |expr| get_snippet(expr.span));
-            let end = range.end.map_or("".into(), |expr| get_snippet(expr.span));
-
-            return Sugg::BinOp(op, start, end);
-        }
-
-        match expr.kind {
-            hir::ExprKind::AddrOf(..)
-            | hir::ExprKind::If(..)
-            | hir::ExprKind::Let(..)
-            | hir::ExprKind::Closure { .. }
-            | hir::ExprKind::Unary(..)
-            | hir::ExprKind::Match(..) => Sugg::MaybeParen(get_snippet(expr.span)),
-            hir::ExprKind::Continue(..)
-            | hir::ExprKind::Yield(..)
-            | hir::ExprKind::Array(..)
-            | hir::ExprKind::Block(..)
-            | hir::ExprKind::Break(..)
-            | hir::ExprKind::Call(..)
-            | hir::ExprKind::Field(..)
-            | hir::ExprKind::Index(..)
-            | hir::ExprKind::InlineAsm(..)
-            | hir::ExprKind::OffsetOf(..)
-            | hir::ExprKind::ConstBlock(..)
-            | hir::ExprKind::Lit(..)
-            | hir::ExprKind::Loop(..)
-            | hir::ExprKind::MethodCall(..)
-            | hir::ExprKind::Path(..)
-            | hir::ExprKind::Repeat(..)
-            | hir::ExprKind::Ret(..)
-            | hir::ExprKind::Become(..)
-            | hir::ExprKind::Struct(..)
-            | hir::ExprKind::Tup(..)
-            | hir::ExprKind::Err(_) => Sugg::NonParen(get_snippet(expr.span)),
-            hir::ExprKind::DropTemps(inner) => Self::hir_from_snippet(inner, get_snippet),
-            hir::ExprKind::Assign(lhs, rhs, _) => {
-                Sugg::BinOp(AssocOp::Assign, get_snippet(lhs.span), get_snippet(rhs.span))
-            },
-            hir::ExprKind::AssignOp(op, lhs, rhs) => {
-                Sugg::BinOp(hirbinop2assignop(op), get_snippet(lhs.span), get_snippet(rhs.span))
-            },
-            hir::ExprKind::Binary(op, lhs, rhs) => Sugg::BinOp(
-                AssocOp::from_ast_binop(op.node.into()),
-                get_snippet(lhs.span),
-                get_snippet(rhs.span),
-            ),
-            hir::ExprKind::Cast(lhs, ty) |
-            //FIXME(chenyukang), remove this after type ascription is removed from AST
-            hir::ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::As, get_snippet(lhs.span), get_snippet(ty.span)),
-        }
-    }
-
-    /// Prepare a suggestion from an expression.
-    pub fn ast(
-        cx: &EarlyContext<'_>,
-        expr: &ast::Expr,
-        default: &'a str,
-        ctxt: SyntaxContext,
-        app: &mut Applicability,
-    ) -> Self {
-        use rustc_ast::ast::RangeLimits;
-
-        match expr.kind {
-            _ if expr.span.ctxt() != ctxt => Sugg::NonParen(snippet_with_context(cx, expr.span, ctxt, default, app).0),
-            ast::ExprKind::AddrOf(..)
-            | ast::ExprKind::Closure { .. }
-            | ast::ExprKind::If(..)
-            | ast::ExprKind::Let(..)
-            | ast::ExprKind::Unary(..)
-            | ast::ExprKind::Match(..) => match snippet_with_context(cx, expr.span, ctxt, default, app) {
-                (snip, false) => Sugg::MaybeParen(snip),
-                (snip, true) => Sugg::NonParen(snip),
-            },
-            ast::ExprKind::Async(..)
-            | ast::ExprKind::Block(..)
-            | ast::ExprKind::Break(..)
-            | ast::ExprKind::Call(..)
-            | ast::ExprKind::Continue(..)
-            | ast::ExprKind::Yield(..)
-            | ast::ExprKind::Field(..)
-            | ast::ExprKind::ForLoop(..)
-            | ast::ExprKind::Index(..)
-            | ast::ExprKind::InlineAsm(..)
-            | ast::ExprKind::OffsetOf(..)
-            | ast::ExprKind::ConstBlock(..)
-            | ast::ExprKind::Lit(..)
-            | ast::ExprKind::IncludedBytes(..)
-            | ast::ExprKind::Loop(..)
-            | ast::ExprKind::MacCall(..)
-            | ast::ExprKind::MethodCall(..)
-            | ast::ExprKind::Paren(..)
-            | ast::ExprKind::Underscore
-            | ast::ExprKind::Path(..)
-            | ast::ExprKind::Repeat(..)
-            | ast::ExprKind::Ret(..)
-            | ast::ExprKind::Become(..)
-            | ast::ExprKind::Yeet(..)
-            | ast::ExprKind::FormatArgs(..)
-            | ast::ExprKind::Struct(..)
-            | ast::ExprKind::Try(..)
-            | ast::ExprKind::TryBlock(..)
-            | ast::ExprKind::Tup(..)
-            | ast::ExprKind::Array(..)
-            | ast::ExprKind::While(..)
-            | ast::ExprKind::Await(..)
-            | ast::ExprKind::Err => Sugg::NonParen(snippet_with_context(cx, expr.span, ctxt, default, app).0),
-            ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::HalfOpen) => Sugg::BinOp(
-                AssocOp::DotDot,
-                lhs.as_ref().map_or("".into(), |lhs| {
-                    snippet_with_context(cx, lhs.span, ctxt, default, app).0
-                }),
-                rhs.as_ref().map_or("".into(), |rhs| {
-                    snippet_with_context(cx, rhs.span, ctxt, default, app).0
-                }),
-            ),
-            ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::Closed) => Sugg::BinOp(
-                AssocOp::DotDotEq,
-                lhs.as_ref().map_or("".into(), |lhs| {
-                    snippet_with_context(cx, lhs.span, ctxt, default, app).0
-                }),
-                rhs.as_ref().map_or("".into(), |rhs| {
-                    snippet_with_context(cx, rhs.span, ctxt, default, app).0
-                }),
-            ),
-            ast::ExprKind::Assign(ref lhs, ref rhs, _) => Sugg::BinOp(
-                AssocOp::Assign,
-                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
-                snippet_with_context(cx, rhs.span, ctxt, default, app).0,
-            ),
-            ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => Sugg::BinOp(
-                astbinop2assignop(op),
-                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
-                snippet_with_context(cx, rhs.span, ctxt, default, app).0,
-            ),
-            ast::ExprKind::Binary(op, ref lhs, ref rhs) => Sugg::BinOp(
-                AssocOp::from_ast_binop(op.node),
-                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
-                snippet_with_context(cx, rhs.span, ctxt, default, app).0,
-            ),
-            ast::ExprKind::Cast(ref lhs, ref ty) |
-            //FIXME(chenyukang), remove this after type ascription is removed from AST
-            ast::ExprKind::Type(ref lhs, ref ty) => Sugg::BinOp(
-                AssocOp::As,
-                snippet_with_context(cx, lhs.span, ctxt, default, app).0,
-                snippet_with_context(cx, ty.span, ctxt, default, app).0,
-            ),
-        }
-    }
-
-    /// Convenience method to create the `<lhs> && <rhs>` suggestion.
-    pub fn and(self, rhs: &Self) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::And, &self, rhs)
-    }
-
-    /// Convenience method to create the `<lhs> & <rhs>` suggestion.
-    pub fn bit_and(self, rhs: &Self) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::BitAnd, &self, rhs)
-    }
-
-    /// Convenience method to create the `<lhs> as <rhs>` suggestion.
-    pub fn as_ty<R: Display>(self, rhs: R) -> Sugg<'static> {
-        make_assoc(AssocOp::As, &self, &Sugg::NonParen(rhs.to_string().into()))
-    }
-
-    /// Convenience method to create the `&<expr>` suggestion.
-    pub fn addr(self) -> Sugg<'static> {
-        make_unop("&", self)
-    }
-
-    /// Convenience method to create the `&mut <expr>` suggestion.
-    pub fn mut_addr(self) -> Sugg<'static> {
-        make_unop("&mut ", self)
-    }
-
-    /// Convenience method to create the `*<expr>` suggestion.
-    pub fn deref(self) -> Sugg<'static> {
-        make_unop("*", self)
-    }
-
-    /// Convenience method to create the `&*<expr>` suggestion. Currently this
-    /// is needed because `sugg.deref().addr()` produces an unnecessary set of
-    /// parentheses around the deref.
-    pub fn addr_deref(self) -> Sugg<'static> {
-        make_unop("&*", self)
-    }
-
-    /// Convenience method to create the `&mut *<expr>` suggestion. Currently
-    /// this is needed because `sugg.deref().mut_addr()` produces an unnecessary
-    /// set of parentheses around the deref.
-    pub fn mut_addr_deref(self) -> Sugg<'static> {
-        make_unop("&mut *", self)
-    }
-
-    /// Convenience method to transform suggestion into a return call
-    pub fn make_return(self) -> Sugg<'static> {
-        Sugg::NonParen(Cow::Owned(format!("return {self}")))
-    }
-
-    /// Convenience method to transform suggestion into a block
-    /// where the suggestion is a trailing expression
-    pub fn blockify(self) -> Sugg<'static> {
-        Sugg::NonParen(Cow::Owned(format!("{{ {self} }}")))
-    }
-
-    /// Convenience method to prefix the expression with the `async` keyword.
-    /// Can be used after `blockify` to create an async block.
-    pub fn asyncify(self) -> Sugg<'static> {
-        Sugg::NonParen(Cow::Owned(format!("async {self}")))
-    }
-
-    /// Convenience method to create the `<lhs>..<rhs>` or `<lhs>...<rhs>`
-    /// suggestion.
-    pub fn range(self, end: &Self, limit: ast::RangeLimits) -> Sugg<'static> {
-        match limit {
-            ast::RangeLimits::HalfOpen => make_assoc(AssocOp::DotDot, &self, end),
-            ast::RangeLimits::Closed => make_assoc(AssocOp::DotDotEq, &self, end),
-        }
-    }
-
-    /// Adds parentheses to any expression that might need them. Suitable to the
-    /// `self` argument of a method call
-    /// (e.g., to build `bar.foo()` or `(1 + 2).foo()`).
-    #[must_use]
-    pub fn maybe_par(self) -> Self {
-        match self {
-            Sugg::NonParen(..) => self,
-            // `(x)` and `(x).y()` both don't need additional parens.
-            Sugg::MaybeParen(sugg) => {
-                if has_enclosing_paren(&sugg) {
-                    Sugg::MaybeParen(sugg)
-                } else {
-                    Sugg::NonParen(format!("({sugg})").into())
-                }
-            },
-            Sugg::BinOp(op, lhs, rhs) => {
-                let sugg = binop_to_string(op, &lhs, &rhs);
-                Sugg::NonParen(format!("({sugg})").into())
-            },
-        }
-    }
-}
-
-/// Generates a string from the operator and both sides.
-fn binop_to_string(op: AssocOp, lhs: &str, rhs: &str) -> String {
-    match op {
-        AssocOp::Add
-        | AssocOp::Subtract
-        | AssocOp::Multiply
-        | AssocOp::Divide
-        | AssocOp::Modulus
-        | AssocOp::LAnd
-        | AssocOp::LOr
-        | AssocOp::BitXor
-        | AssocOp::BitAnd
-        | AssocOp::BitOr
-        | AssocOp::ShiftLeft
-        | AssocOp::ShiftRight
-        | AssocOp::Equal
-        | AssocOp::Less
-        | AssocOp::LessEqual
-        | AssocOp::NotEqual
-        | AssocOp::Greater
-        | AssocOp::GreaterEqual => {
-            format!(
-                "{lhs} {} {rhs}",
-                op.to_ast_binop().expect("Those are AST ops").to_string()
-            )
-        },
-        AssocOp::Assign => format!("{lhs} = {rhs}"),
-        AssocOp::AssignOp(op) => {
-            format!("{lhs} {}= {rhs}", token_kind_to_string(&token::BinOp(op)))
-        },
-        AssocOp::As => format!("{lhs} as {rhs}"),
-        AssocOp::DotDot => format!("{lhs}..{rhs}"),
-        AssocOp::DotDotEq => format!("{lhs}..={rhs}"),
-    }
-}
-
-/// Returns `true` if `sugg` is enclosed in parenthesis.
-pub fn has_enclosing_paren(sugg: impl AsRef<str>) -> bool {
-    let mut chars = sugg.as_ref().chars();
-    if chars.next() == Some('(') {
-        let mut depth = 1;
-        for c in &mut chars {
-            if c == '(' {
-                depth += 1;
-            } else if c == ')' {
-                depth -= 1;
-            }
-            if depth == 0 {
-                break;
-            }
-        }
-        chars.next().is_none()
-    } else {
-        false
-    }
-}
-
-/// Copied from the rust standard library, and then edited
-macro_rules! forward_binop_impls_to_ref {
-    (impl $imp:ident, $method:ident for $t:ty, type Output = $o:ty) => {
-        impl $imp<$t> for &$t {
-            type Output = $o;
-
-            fn $method(self, other: $t) -> $o {
-                $imp::$method(self, &other)
-            }
-        }
-
-        impl $imp<&$t> for $t {
-            type Output = $o;
-
-            fn $method(self, other: &$t) -> $o {
-                $imp::$method(&self, other)
-            }
-        }
-
-        impl $imp for $t {
-            type Output = $o;
-
-            fn $method(self, other: $t) -> $o {
-                $imp::$method(&self, &other)
-            }
-        }
-    };
-}
-
-impl Add for &Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn add(self, rhs: &Sugg<'_>) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::Add, self, rhs)
-    }
-}
-
-impl Sub for &Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn sub(self, rhs: &Sugg<'_>) -> Sugg<'static> {
-        make_binop(ast::BinOpKind::Sub, self, rhs)
-    }
-}
-
-forward_binop_impls_to_ref!(impl Add, add for Sugg<'_>, type Output = Sugg<'static>);
-forward_binop_impls_to_ref!(impl Sub, sub for Sugg<'_>, type Output = Sugg<'static>);
-
-impl Neg for Sugg<'_> {
-    type Output = Sugg<'static>;
-    fn neg(self) -> Sugg<'static> {
-        make_unop("-", self)
-    }
-}
-
-impl<'a> Not for Sugg<'a> {
-    type Output = Sugg<'a>;
-    fn not(self) -> Sugg<'a> {
-        use AssocOp::{Equal, Greater, GreaterEqual, Less, LessEqual, NotEqual};
-
-        if let Sugg::BinOp(op, lhs, rhs) = self {
-            let to_op = match op {
-                Equal => NotEqual,
-                NotEqual => Equal,
-                Less => GreaterEqual,
-                GreaterEqual => Less,
-                Greater => LessEqual,
-                LessEqual => Greater,
-                _ => return make_unop("!", Sugg::BinOp(op, lhs, rhs)),
-            };
-            Sugg::BinOp(to_op, lhs, rhs)
-        } else {
-            make_unop("!", self)
-        }
-    }
-}
-
-/// Helper type to display either `foo` or `(foo)`.
-struct ParenHelper<T> {
-    /// `true` if parentheses are needed.
-    paren: bool,
-    /// The main thing to display.
-    wrapped: T,
-}
-
-impl<T> ParenHelper<T> {
-    /// Builds a `ParenHelper`.
-    fn new(paren: bool, wrapped: T) -> Self {
-        Self { paren, wrapped }
-    }
-}
-
-impl<T: Display> Display for ParenHelper<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
-        if self.paren {
-            write!(f, "({})", self.wrapped)
-        } else {
-            self.wrapped.fmt(f)
-        }
-    }
-}
-
-/// Builds the string for `<op><expr>` adding parenthesis when necessary.
-///
-/// For convenience, the operator is taken as a string because all unary
-/// operators have the same
-/// precedence.
-pub fn make_unop(op: &str, expr: Sugg<'_>) -> Sugg<'static> {
-    Sugg::MaybeParen(format!("{op}{}", expr.maybe_par()).into())
-}
-
-/// Builds the string for `<lhs> <op> <rhs>` adding parenthesis when necessary.
-///
-/// Precedence of shift operator relative to other arithmetic operation is
-/// often confusing so
-/// parenthesis will always be added for a mix of these.
-pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
-    /// Returns `true` if the operator is a shift operator `<<` or `>>`.
-    fn is_shift(op: AssocOp) -> bool {
-        matches!(op, AssocOp::ShiftLeft | AssocOp::ShiftRight)
-    }
-
-    /// Returns `true` if the operator is an arithmetic operator
-    /// (i.e., `+`, `-`, `*`, `/`, `%`).
-    fn is_arith(op: AssocOp) -> bool {
-        matches!(
-            op,
-            AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | AssocOp::Modulus
-        )
-    }
-
-    /// Returns `true` if the operator `op` needs parenthesis with the operator
-    /// `other` in the direction `dir`.
-    fn needs_paren(op: AssocOp, other: AssocOp, dir: Associativity) -> bool {
-        other.precedence() < op.precedence()
-            || (other.precedence() == op.precedence()
-                && ((op != other && associativity(op) != dir)
-                    || (op == other && associativity(op) != Associativity::Both)))
-            || is_shift(op) && is_arith(other)
-            || is_shift(other) && is_arith(op)
-    }
-
-    let lhs_paren = if let Sugg::BinOp(lop, _, _) = *lhs {
-        needs_paren(op, lop, Associativity::Left)
-    } else {
-        false
-    };
-
-    let rhs_paren = if let Sugg::BinOp(rop, _, _) = *rhs {
-        needs_paren(op, rop, Associativity::Right)
-    } else {
-        false
-    };
-
-    let lhs = ParenHelper::new(lhs_paren, lhs).to_string();
-    let rhs = ParenHelper::new(rhs_paren, rhs).to_string();
-    Sugg::BinOp(op, lhs.into(), rhs.into())
-}
-
-/// Convenience wrapper around `make_assoc` and `AssocOp::from_ast_binop`.
-pub fn make_binop(op: ast::BinOpKind, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
-    make_assoc(AssocOp::from_ast_binop(op), lhs, rhs)
-}
-
-#[derive(PartialEq, Eq, Clone, Copy)]
-/// Operator associativity.
-enum Associativity {
-    /// The operator is both left-associative and right-associative.
-    Both,
-    /// The operator is left-associative.
-    Left,
-    /// The operator is not associative.
-    None,
-    /// The operator is right-associative.
-    Right,
-}
-
-/// Returns the associativity/fixity of an operator. The difference with
-/// `AssocOp::fixity` is that an operator can be both left and right associative
-/// (such as `+`: `a + b + c == (a + b) + c == a + (b + c)`.
-///
-/// Chained `as` and explicit `:` type coercion never need inner parenthesis so
-/// they are considered
-/// associative.
-#[must_use]
-fn associativity(op: AssocOp) -> Associativity {
-    use rustc_ast::util::parser::AssocOp::{
-        Add, As, Assign, AssignOp, BitAnd, BitOr, BitXor, Divide, DotDot, DotDotEq, Equal, Greater, GreaterEqual, LAnd,
-        LOr, Less, LessEqual, Modulus, Multiply, NotEqual, ShiftLeft, ShiftRight, Subtract,
-    };
-
-    match op {
-        Assign | AssignOp(_) => Associativity::Right,
-        Add | BitAnd | BitOr | BitXor | LAnd | LOr | Multiply | As => Associativity::Both,
-        Divide | Equal | Greater | GreaterEqual | Less | LessEqual | Modulus | NotEqual | ShiftLeft | ShiftRight
-        | Subtract => Associativity::Left,
-        DotDot | DotDotEq => Associativity::None,
-    }
-}
-
-/// Converts a `hir::BinOp` to the corresponding assigning binary operator.
-fn hirbinop2assignop(op: hir::BinOp) -> AssocOp {
-    use rustc_ast::token::BinOpToken::{And, Caret, Minus, Or, Percent, Plus, Shl, Shr, Slash, Star};
-
-    AssocOp::AssignOp(match op.node {
-        hir::BinOpKind::Add => Plus,
-        hir::BinOpKind::BitAnd => And,
-        hir::BinOpKind::BitOr => Or,
-        hir::BinOpKind::BitXor => Caret,
-        hir::BinOpKind::Div => Slash,
-        hir::BinOpKind::Mul => Star,
-        hir::BinOpKind::Rem => Percent,
-        hir::BinOpKind::Shl => Shl,
-        hir::BinOpKind::Shr => Shr,
-        hir::BinOpKind::Sub => Minus,
-
-        hir::BinOpKind::And
-        | hir::BinOpKind::Eq
-        | hir::BinOpKind::Ge
-        | hir::BinOpKind::Gt
-        | hir::BinOpKind::Le
-        | hir::BinOpKind::Lt
-        | hir::BinOpKind::Ne
-        | hir::BinOpKind::Or => panic!("This operator does not exist"),
-    })
-}
-
-/// Converts an `ast::BinOp` to the corresponding assigning binary operator.
-fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
-    use rustc_ast::ast::BinOpKind::{
-        Add, And, BitAnd, BitOr, BitXor, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Rem, Shl, Shr, Sub,
-    };
-    use rustc_ast::token::BinOpToken;
-
-    AssocOp::AssignOp(match op.node {
-        Add => BinOpToken::Plus,
-        BitAnd => BinOpToken::And,
-        BitOr => BinOpToken::Or,
-        BitXor => BinOpToken::Caret,
-        Div => BinOpToken::Slash,
-        Mul => BinOpToken::Star,
-        Rem => BinOpToken::Percent,
-        Shl => BinOpToken::Shl,
-        Shr => BinOpToken::Shr,
-        Sub => BinOpToken::Minus,
-        And | Eq | Ge | Gt | Le | Lt | Ne | Or => panic!("This operator does not exist"),
-    })
-}
-
-/// Returns the indentation before `span` if there are nothing but `[ \t]`
-/// before it on its line.
-fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
-    let lo = cx.sess().source_map().lookup_char_pos(span.lo());
-    lo.file
-        .get_line(lo.line - 1 /* line numbers in `Loc` are 1-based */)
-        .and_then(|line| {
-            if let Some((pos, _)) = line.char_indices().find(|&(_, c)| c != ' ' && c != '\t') {
-                // We can mix char and byte positions here because we only consider `[ \t]`.
-                if lo.col == CharPos(pos) {
-                    Some(line[..pos].into())
-                } else {
-                    None
-                }
-            } else {
-                None
-            }
-        })
-}
-
-/// Convenience extension trait for `Diagnostic`.
-pub trait DiagnosticExt<T: LintContext> {
-    /// Suggests to add an attribute to an item.
-    ///
-    /// Correctly handles indentation of the attribute and item.
-    ///
-    /// # Example
-    ///
-    /// ```rust,ignore
-    /// diag.suggest_item_with_attr(cx, item, "#[derive(Default)]");
-    /// ```
-    fn suggest_item_with_attr<D: Display + ?Sized>(
-        &mut self,
-        cx: &T,
-        item: Span,
-        msg: &str,
-        attr: &D,
-        applicability: Applicability,
-    );
-
-    /// Suggest to add an item before another.
-    ///
-    /// The item should not be indented (except for inner indentation).
-    ///
-    /// # Example
-    ///
-    /// ```rust,ignore
-    /// diag.suggest_prepend_item(cx, item,
-    /// "fn foo() {
-    ///     bar();
-    /// }");
-    /// ```
-    fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability);
-
-    /// Suggest to completely remove an item.
-    ///
-    /// This will remove an item and all following whitespace until the next non-whitespace
-    /// character. This should work correctly if item is on the same indentation level as the
-    /// following item.
-    ///
-    /// # Example
-    ///
-    /// ```rust,ignore
-    /// diag.suggest_remove_item(cx, item, "remove this")
-    /// ```
-    fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability);
-}
-
-impl<T: LintContext> DiagnosticExt<T> for rustc_errors::Diagnostic {
-    fn suggest_item_with_attr<D: Display + ?Sized>(
-        &mut self,
-        cx: &T,
-        item: Span,
-        msg: &str,
-        attr: &D,
-        applicability: Applicability,
-    ) {
-        if let Some(indent) = indentation(cx, item) {
-            let span = item.with_hi(item.lo());
-
-            self.span_suggestion(span, msg.to_string(), format!("{attr}\n{indent}"), applicability);
-        }
-    }
-
-    fn suggest_prepend_item(&mut self, cx: &T, item: Span, msg: &str, new_item: &str, applicability: Applicability) {
-        if let Some(indent) = indentation(cx, item) {
-            let span = item.with_hi(item.lo());
-
-            let mut first = true;
-            let new_item = new_item
-                .lines()
-                .map(|l| {
-                    if first {
-                        first = false;
-                        format!("{l}\n")
-                    } else {
-                        format!("{indent}{l}\n")
-                    }
-                })
-                .collect::<String>();
-
-            self.span_suggestion(span, msg.to_string(), format!("{new_item}\n{indent}"), applicability);
-        }
-    }
-
-    fn suggest_remove_item(&mut self, cx: &T, item: Span, msg: &str, applicability: Applicability) {
-        let mut remove_span = item;
-        let fmpos = cx.sess().source_map().lookup_byte_offset(remove_span.hi());
-
-        if let Some(ref src) = fmpos.sf.src {
-            let non_whitespace_offset = src[fmpos.pos.to_usize()..].find(|c| c != ' ' && c != '\t' && c != '\n');
-
-            if let Some(non_whitespace_offset) = non_whitespace_offset {
-                remove_span = remove_span
-                    .with_hi(remove_span.hi() + BytePos(non_whitespace_offset.try_into().expect("offset too large")));
-            }
-        }
-
-        self.span_suggestion(remove_span, msg.to_string(), "", applicability);
-    }
-}
-
-/// Suggestion results for handling closure
-/// args dereferencing and borrowing
-pub struct DerefClosure {
-    /// confidence on the built suggestion
-    pub applicability: Applicability,
-    /// gradually built suggestion
-    pub suggestion: String,
-}
-
-/// Build suggestion gradually by handling closure arg specific usages,
-/// such as explicit deref and borrowing cases.
-/// Returns `None` if no such use cases have been triggered in closure body
-///
-/// note: this only works on single line immutable closures with exactly one input parameter.
-pub fn deref_closure_args(cx: &LateContext<'_>, closure: &hir::Expr<'_>) -> Option<DerefClosure> {
-    if let hir::ExprKind::Closure(&Closure {
-        fn_decl, def_id, body, ..
-    }) = closure.kind
-    {
-        let closure_body = cx.tcx.hir().body(body);
-        // is closure arg a type annotated double reference (i.e.: `|x: &&i32| ...`)
-        // a type annotation is present if param `kind` is different from `TyKind::Infer`
-        let closure_arg_is_type_annotated_double_ref = if let TyKind::Ref(_, MutTy { ty, .. }) = fn_decl.inputs[0].kind
-        {
-            matches!(ty.kind, TyKind::Ref(_, MutTy { .. }))
-        } else {
-            false
-        };
-
-        let mut visitor = DerefDelegate {
-            cx,
-            closure_span: closure.span,
-            closure_arg_is_type_annotated_double_ref,
-            next_pos: closure.span.lo(),
-            suggestion_start: String::new(),
-            applicability: Applicability::MachineApplicable,
-        };
-
-        let infcx = cx.tcx.infer_ctxt().build();
-        ExprUseVisitor::new(&mut visitor, &infcx, def_id, cx.param_env, cx.typeck_results()).consume_body(closure_body);
-
-        if !visitor.suggestion_start.is_empty() {
-            return Some(DerefClosure {
-                applicability: visitor.applicability,
-                suggestion: visitor.finish(),
-            });
-        }
-    }
-    None
-}
-
-/// Visitor struct used for tracking down
-/// dereferencing and borrowing of closure's args
-struct DerefDelegate<'a, 'tcx> {
-    /// The late context of the lint
-    cx: &'a LateContext<'tcx>,
-    /// The span of the input closure to adapt
-    closure_span: Span,
-    /// Indicates if the arg of the closure is a type annotated double reference
-    closure_arg_is_type_annotated_double_ref: bool,
-    /// last position of the span to gradually build the suggestion
-    next_pos: BytePos,
-    /// starting part of the gradually built suggestion
-    suggestion_start: String,
-    /// confidence on the built suggestion
-    applicability: Applicability,
-}
-
-impl<'tcx> DerefDelegate<'_, 'tcx> {
-    /// build final suggestion:
-    /// - create the ending part of suggestion
-    /// - concatenate starting and ending parts
-    /// - potentially remove needless borrowing
-    pub fn finish(&mut self) -> String {
-        let end_span = Span::new(self.next_pos, self.closure_span.hi(), self.closure_span.ctxt(), None);
-        let end_snip = snippet_with_applicability(self.cx, end_span, "..", &mut self.applicability);
-        let sugg = format!("{}{end_snip}", self.suggestion_start);
-        if self.closure_arg_is_type_annotated_double_ref {
-            sugg.replacen('&', "", 1)
-        } else {
-            sugg
-        }
-    }
-
-    /// indicates whether the function from `parent_expr` takes its args by double reference
-    fn func_takes_arg_by_double_ref(&self, parent_expr: &'tcx hir::Expr<'_>, cmt_hir_id: HirId) -> bool {
-        let ty = match parent_expr.kind {
-            ExprKind::MethodCall(_, receiver, call_args, _) => {
-                if let Some(sig) = self
-                    .cx
-                    .typeck_results()
-                    .type_dependent_def_id(parent_expr.hir_id)
-                    .map(|did| self.cx.tcx.fn_sig(did).instantiate_identity().skip_binder())
-                {
-                    std::iter::once(receiver)
-                        .chain(call_args.iter())
-                        .position(|arg| arg.hir_id == cmt_hir_id)
-                        .map(|i| sig.inputs()[i])
-                } else {
-                    return false;
-                }
-            },
-            ExprKind::Call(func, call_args) => {
-                if let Some(sig) = expr_sig(self.cx, func) {
-                    call_args
-                        .iter()
-                        .position(|arg| arg.hir_id == cmt_hir_id)
-                        .and_then(|i| sig.input(i))
-                        .map(ty::Binder::skip_binder)
-                } else {
-                    return false;
-                }
-            },
-            _ => return false,
-        };
-
-        ty.map_or(false, |ty| matches!(ty.kind(), ty::Ref(_, inner, _) if inner.is_ref()))
-    }
-}
-
-impl<'tcx> Delegate<'tcx> for DerefDelegate<'_, 'tcx> {
-    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
-
-    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, _: ty::BorrowKind) {
-        if let PlaceBase::Local(id) = cmt.place.base {
-            let map = self.cx.tcx.hir();
-            let span = map.span(cmt.hir_id);
-            let start_span = Span::new(self.next_pos, span.lo(), span.ctxt(), None);
-            let mut start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
-
-            // identifier referring to the variable currently triggered (i.e.: `fp`)
-            let ident_str = map.name(id).to_string();
-            // full identifier that includes projection (i.e.: `fp.field`)
-            let ident_str_with_proj = snippet(self.cx, span, "..").to_string();
-
-            if cmt.place.projections.is_empty() {
-                // handle item without any projection, that needs an explicit borrowing
-                // i.e.: suggest `&x` instead of `x`
-                let _: fmt::Result = write!(self.suggestion_start, "{start_snip}&{ident_str}");
-            } else {
-                // cases where a parent `Call` or `MethodCall` is using the item
-                // i.e.: suggest `.contains(&x)` for `.find(|x| [1, 2, 3].contains(x)).is_none()`
-                //
-                // Note about method calls:
-                // - compiler automatically dereference references if the target type is a reference (works also for
-                //   function call)
-                // - `self` arguments in the case of `x.is_something()` are also automatically (de)referenced, and
-                //   no projection should be suggested
-                if let Some(parent_expr) = get_parent_expr_for_hir(self.cx, cmt.hir_id) {
-                    match &parent_expr.kind {
-                        // given expression is the self argument and will be handled completely by the compiler
-                        // i.e.: `|x| x.is_something()`
-                        ExprKind::MethodCall(_, self_expr, ..) if self_expr.hir_id == cmt.hir_id => {
-                            let _: fmt::Result = write!(self.suggestion_start, "{start_snip}{ident_str_with_proj}");
-                            self.next_pos = span.hi();
-                            return;
-                        },
-                        // item is used in a call
-                        // i.e.: `Call`: `|x| please(x)` or `MethodCall`: `|x| [1, 2, 3].contains(x)`
-                        ExprKind::Call(_, call_args) | ExprKind::MethodCall(_, _, call_args, _) => {
-                            let expr = self.cx.tcx.hir().expect_expr(cmt.hir_id);
-                            let arg_ty_kind = self.cx.typeck_results().expr_ty(expr).kind();
-
-                            if matches!(arg_ty_kind, ty::Ref(_, _, Mutability::Not)) {
-                                // suggest ampersand if call function is taking args by double reference
-                                let takes_arg_by_double_ref =
-                                    self.func_takes_arg_by_double_ref(parent_expr, cmt.hir_id);
-
-                                // compiler will automatically dereference field or index projection, so no need
-                                // to suggest ampersand, but full identifier that includes projection is required
-                                let has_field_or_index_projection =
-                                    cmt.place.projections.iter().any(|proj| {
-                                        matches!(proj.kind, ProjectionKind::Field(..) | ProjectionKind::Index)
-                                    });
-
-                                // no need to bind again if the function doesn't take arg by double ref
-                                // and if the item is already a double ref
-                                let ident_sugg = if !call_args.is_empty()
-                                    && !takes_arg_by_double_ref
-                                    && (self.closure_arg_is_type_annotated_double_ref || has_field_or_index_projection)
-                                {
-                                    let ident = if has_field_or_index_projection {
-                                        ident_str_with_proj
-                                    } else {
-                                        ident_str
-                                    };
-                                    format!("{start_snip}{ident}")
-                                } else {
-                                    format!("{start_snip}&{ident_str}")
-                                };
-                                self.suggestion_start.push_str(&ident_sugg);
-                                self.next_pos = span.hi();
-                                return;
-                            }
-
-                            self.applicability = Applicability::Unspecified;
-                        },
-                        _ => (),
-                    }
-                }
-
-                let mut replacement_str = ident_str;
-                let mut projections_handled = false;
-                cmt.place.projections.iter().enumerate().for_each(|(i, proj)| {
-                    match proj.kind {
-                        // Field projection like `|v| v.foo`
-                        // no adjustment needed here, as field projections are handled by the compiler
-                        ProjectionKind::Field(..) => match cmt.place.ty_before_projection(i).kind() {
-                            ty::Adt(..) | ty::Tuple(_) => {
-                                replacement_str = ident_str_with_proj.clone();
-                                projections_handled = true;
-                            },
-                            _ => (),
-                        },
-                        // Index projection like `|x| foo[x]`
-                        // the index is dropped so we can't get it to build the suggestion,
-                        // so the span is set-up again to get more code, using `span.hi()` (i.e.: `foo[x]`)
-                        // instead of `span.lo()` (i.e.: `foo`)
-                        ProjectionKind::Index => {
-                            let start_span = Span::new(self.next_pos, span.hi(), span.ctxt(), None);
-                            start_snip = snippet_with_applicability(self.cx, start_span, "..", &mut self.applicability);
-                            replacement_str.clear();
-                            projections_handled = true;
-                        },
-                        // note: unable to trigger `Subslice` kind in tests
-                        ProjectionKind::Subslice |
-                        // Doesn't have surface syntax. Only occurs in patterns.
-                        ProjectionKind::OpaqueCast => (),
-                        ProjectionKind::Deref => {
-                            // Explicit derefs are typically handled later on, but
-                            // some items do not need explicit deref, such as array accesses,
-                            // so we mark them as already processed
-                            // i.e.: don't suggest `*sub[1..4].len()` for `|sub| sub[1..4].len() == 3`
-                            if let ty::Ref(_, inner, _) = cmt.place.ty_before_projection(i).kind() {
-                                if matches!(inner.kind(), ty::Ref(_, innermost, _) if innermost.is_array()) {
-                                    projections_handled = true;
-                                }
-                            }
-                        },
-                    }
-                });
-
-                // handle `ProjectionKind::Deref` by removing one explicit deref
-                // if no special case was detected (i.e.: suggest `*x` instead of `**x`)
-                if !projections_handled {
-                    let last_deref = cmt
-                        .place
-                        .projections
-                        .iter()
-                        .rposition(|proj| proj.kind == ProjectionKind::Deref);
-
-                    if let Some(pos) = last_deref {
-                        let mut projections = cmt.place.projections.clone();
-                        projections.truncate(pos);
-
-                        for item in projections {
-                            if item.kind == ProjectionKind::Deref {
-                                replacement_str = format!("*{replacement_str}");
-                            }
-                        }
-                    }
-                }
-
-                let _: fmt::Result = write!(self.suggestion_start, "{start_snip}{replacement_str}");
-            }
-            self.next_pos = span.hi();
-        }
-    }
-
-    fn mutate(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
-
-    fn fake_read(&mut self, _: &PlaceWithHirId<'tcx>, _: FakeReadCause, _: HirId) {}
-}
-
-#[cfg(test)]
-mod test {
-    use super::Sugg;
-
-    use rustc_ast::util::parser::AssocOp;
-    use std::borrow::Cow;
-
-    const SUGGESTION: Sugg<'static> = Sugg::NonParen(Cow::Borrowed("function_call()"));
-
-    #[test]
-    fn make_return_transform_sugg_into_a_return_call() {
-        assert_eq!("return function_call()", SUGGESTION.make_return().to_string());
-    }
-
-    #[test]
-    fn blockify_transforms_sugg_into_a_block() {
-        assert_eq!("{ function_call() }", SUGGESTION.blockify().to_string());
-    }
-
-    #[test]
-    fn binop_maybe_par() {
-        let sugg = Sugg::BinOp(AssocOp::Add, "1".into(), "1".into());
-        assert_eq!("(1 + 1)", sugg.maybe_par().to_string());
-
-        let sugg = Sugg::BinOp(AssocOp::Add, "(1 + 1)".into(), "(1 + 1)".into());
-        assert_eq!("((1 + 1) + (1 + 1))", sugg.maybe_par().to_string());
-    }
-    #[test]
-    fn not_op() {
-        use AssocOp::{Add, Equal, Greater, GreaterEqual, LAnd, LOr, Less, LessEqual, NotEqual};
-
-        fn test_not(op: AssocOp, correct: &str) {
-            let sugg = Sugg::BinOp(op, "x".into(), "y".into());
-            assert_eq!((!sugg).to_string(), correct);
-        }
-
-        // Invert the comparison operator.
-        test_not(Equal, "x != y");
-        test_not(NotEqual, "x == y");
-        test_not(Less, "x >= y");
-        test_not(LessEqual, "x > y");
-        test_not(Greater, "x <= y");
-        test_not(GreaterEqual, "x < y");
-
-        // Other operators are inverted like !(..).
-        test_not(Add, "!(x + y)");
-        test_not(LAnd, "!(x && y)");
-        test_not(LOr, "!(x || y)");
-    }
-}
diff --git a/scout-audit-clippy-utils/src/sym_helper.rs b/scout-audit-clippy-utils/src/sym_helper.rs
deleted file mode 100644
index f47dc80e..00000000
--- a/scout-audit-clippy-utils/src/sym_helper.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-#[macro_export]
-/// Convenience wrapper around rustc's `Symbol::intern`
-macro_rules! sym {
-    ($tt:tt) => {
-        rustc_span::symbol::Symbol::intern(stringify!($tt))
-    };
-}
diff --git a/scout-audit-clippy-utils/src/ty.rs b/scout-audit-clippy-utils/src/ty.rs
deleted file mode 100644
index 604dc769..00000000
--- a/scout-audit-clippy-utils/src/ty.rs
+++ /dev/null
@@ -1,1268 +0,0 @@
-//! Util methods for [`rustc_middle::ty`]
-
-#![allow(clippy::module_name_repetitions)]
-
-use core::ops::ControlFlow;
-use itertools::Itertools;
-use rustc_ast::ast::Mutability;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
-use rustc_hir as hir;
-use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
-use rustc_hir::def_id::DefId;
-use rustc_hir::{Expr, FnDecl, LangItem, TyKind, Unsafety};
-use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind};
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_lint::LateContext;
-use rustc_middle::mir::interpret::Scalar;
-use rustc_middle::mir::ConstValue;
-use rustc_middle::traits::EvaluationResult;
-use rustc_middle::ty::layout::ValidityRequirement;
-use rustc_middle::ty::{
-    self, AdtDef, AliasTy, AssocKind, Binder, BoundRegion, FnSig, GenericArg, GenericArgKind, GenericArgsRef,
-    GenericParamDefKind, IntTy, List, ParamEnv, Region, RegionKind, ToPredicate, TraitRef, Ty, TyCtxt,
-    TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, UintTy, VariantDef, VariantDiscr,
-};
-use rustc_span::symbol::Ident;
-use rustc_span::{sym, Span, Symbol, DUMMY_SP};
-use rustc_target::abi::{Size, VariantIdx};
-use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
-use rustc_trait_selection::traits::query::normalize::QueryNormalizeExt;
-use rustc_trait_selection::traits::{Obligation, ObligationCause};
-use std::assert_matches::debug_assert_matches;
-use std::iter;
-
-use crate::{match_def_path, path_res, paths};
-
-mod type_certainty;
-pub use type_certainty::expr_type_is_certain;
-
-/// Checks if the given type implements copy.
-pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    ty.is_copy_modulo_regions(cx.tcx, cx.param_env)
-}
-
-/// This checks whether a given type is known to implement Debug.
-pub fn has_debug_impl<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    cx.tcx
-        .get_diagnostic_item(sym::Debug)
-        .map_or(false, |debug| implements_trait(cx, ty, debug, &[]))
-}
-
-/// Checks whether a type can be partially moved.
-pub fn can_partially_move_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    if has_drop(cx, ty) || is_copy(cx, ty) {
-        return false;
-    }
-    match ty.kind() {
-        ty::Param(_) => false,
-        ty::Adt(def, subs) => def.all_fields().any(|f| !is_copy(cx, f.ty(cx.tcx, subs))),
-        _ => true,
-    }
-}
-
-/// Walks into `ty` and returns `true` if any inner type is an instance of the given adt
-/// constructor.
-pub fn contains_adt_constructor<'tcx>(ty: Ty<'tcx>, adt: AdtDef<'tcx>) -> bool {
-    ty.walk().any(|inner| match inner.unpack() {
-        GenericArgKind::Type(inner_ty) => inner_ty.ty_adt_def() == Some(adt),
-        GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-    })
-}
-
-/// Walks into `ty` and returns `true` if any inner type is an instance of the given type, or adt
-/// constructor of the same type.
-///
-/// This method also recurses into opaque type predicates, so call it with `impl Trait<U>` and `U`
-/// will also return `true`.
-pub fn contains_ty_adt_constructor_opaque<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, needle: Ty<'tcx>) -> bool {
-    fn contains_ty_adt_constructor_opaque_inner<'tcx>(
-        cx: &LateContext<'tcx>,
-        ty: Ty<'tcx>,
-        needle: Ty<'tcx>,
-        seen: &mut FxHashSet<DefId>,
-    ) -> bool {
-        ty.walk().any(|inner| match inner.unpack() {
-            GenericArgKind::Type(inner_ty) => {
-                if inner_ty == needle {
-                    return true;
-                }
-
-                if inner_ty.ty_adt_def() == needle.ty_adt_def() {
-                    return true;
-                }
-
-                if let ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }) = *inner_ty.kind() {
-                    if !seen.insert(def_id) {
-                        return false;
-                    }
-
-                    for (predicate, _span) in cx.tcx.explicit_item_bounds(def_id).instantiate_identity_iter_copied() {
-                        match predicate.kind().skip_binder() {
-                            // For `impl Trait<U>`, it will register a predicate of `T: Trait<U>`, so we go through
-                            // and check substitutions to find `U`.
-                            ty::ClauseKind::Trait(trait_predicate) => {
-                                if trait_predicate
-                                    .trait_ref
-                                    .args
-                                    .types()
-                                    .skip(1) // Skip the implicit `Self` generic parameter
-                                    .any(|ty| contains_ty_adt_constructor_opaque_inner(cx, ty, needle, seen))
-                                {
-                                    return true;
-                                }
-                            },
-                            // For `impl Trait<Assoc=U>`, it will register a predicate of `<T as Trait>::Assoc = U`,
-                            // so we check the term for `U`.
-                            ty::ClauseKind::Projection(projection_predicate) => {
-                                if let ty::TermKind::Ty(ty) = projection_predicate.term.unpack() {
-                                    if contains_ty_adt_constructor_opaque_inner(cx, ty, needle, seen) {
-                                        return true;
-                                    }
-                                };
-                            },
-                            _ => (),
-                        }
-                    }
-                }
-
-                false
-            },
-            GenericArgKind::Lifetime(_) | GenericArgKind::Const(_) => false,
-        })
-    }
-
-    // A hash set to ensure that the same opaque type (`impl Trait` in RPIT or TAIT) is not
-    // visited twice.
-    let mut seen = FxHashSet::default();
-    contains_ty_adt_constructor_opaque_inner(cx, ty, needle, &mut seen)
-}
-
-/// Resolves `<T as Iterator>::Item` for `T`
-/// Do not invoke without first verifying that the type implements `Iterator`
-pub fn get_iterator_item_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-    cx.tcx
-        .get_diagnostic_item(sym::Iterator)
-        .and_then(|iter_did| cx.get_associated_type(ty, iter_did, "Item"))
-}
-
-/// Get the diagnostic name of a type, e.g. `sym::HashMap`. To check if a type
-/// implements a trait marked with a diagnostic item use [`implements_trait`].
-///
-/// For a further exploitation what diagnostic items are see [diagnostic items] in
-/// rustc-dev-guide.
-///
-/// [Diagnostic Items]: https://rustc-dev-guide.rust-lang.org/diagnostics/diagnostic-items.html
-pub fn get_type_diagnostic_name(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<Symbol> {
-    match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.get_diagnostic_name(adt.did()),
-        _ => None,
-    }
-}
-
-/// Returns true if ty has `iter` or `iter_mut` methods
-pub fn has_iter_method(cx: &LateContext<'_>, probably_ref_ty: Ty<'_>) -> Option<Symbol> {
-    // FIXME: instead of this hard-coded list, we should check if `<adt>::iter`
-    // exists and has the desired signature. Unfortunately FnCtxt is not exported
-    // so we can't use its `lookup_method` method.
-    let into_iter_collections: &[Symbol] = &[
-        sym::Vec,
-        sym::Option,
-        sym::Result,
-        sym::BTreeMap,
-        sym::BTreeSet,
-        sym::VecDeque,
-        sym::LinkedList,
-        sym::BinaryHeap,
-        sym::HashSet,
-        sym::HashMap,
-        sym::PathBuf,
-        sym::Path,
-        sym::Receiver,
-    ];
-
-    let ty_to_check = match probably_ref_ty.kind() {
-        ty::Ref(_, ty_to_check, _) => *ty_to_check,
-        _ => probably_ref_ty,
-    };
-
-    let def_id = match ty_to_check.kind() {
-        ty::Array(..) => return Some(sym::array),
-        ty::Slice(..) => return Some(sym::slice),
-        ty::Adt(adt, _) => adt.did(),
-        _ => return None,
-    };
-
-    for &name in into_iter_collections {
-        if cx.tcx.is_diagnostic_item(name, def_id) {
-            return Some(cx.tcx.item_name(def_id));
-        }
-    }
-    None
-}
-
-/// Checks whether a type implements a trait.
-/// The function returns false in case the type contains an inference variable.
-///
-/// See:
-/// * [`get_trait_def_id`](super::get_trait_def_id) to get a trait [`DefId`].
-/// * [Common tools for writing lints] for an example how to use this function and other options.
-///
-/// [Common tools for writing lints]: https://github.com/rust-lang/rust-clippy/blob/master/book/src/development/common_tools_writing_lints.md#checking-if-a-type-implements-a-specific-trait
-pub fn implements_trait<'tcx>(
-    cx: &LateContext<'tcx>,
-    ty: Ty<'tcx>,
-    trait_id: DefId,
-    args: &[GenericArg<'tcx>],
-) -> bool {
-    implements_trait_with_env_from_iter(cx.tcx, cx.param_env, ty, trait_id, args.iter().map(|&x| Some(x)))
-}
-
-/// Same as `implements_trait` but allows using a `ParamEnv` different from the lint context.
-pub fn implements_trait_with_env<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    param_env: ParamEnv<'tcx>,
-    ty: Ty<'tcx>,
-    trait_id: DefId,
-    args: &[GenericArg<'tcx>],
-) -> bool {
-    implements_trait_with_env_from_iter(tcx, param_env, ty, trait_id, args.iter().map(|&x| Some(x)))
-}
-
-/// Same as `implements_trait_from_env` but takes the arguments as an iterator.
-pub fn implements_trait_with_env_from_iter<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    param_env: ParamEnv<'tcx>,
-    ty: Ty<'tcx>,
-    trait_id: DefId,
-    args: impl IntoIterator<Item = impl Into<Option<GenericArg<'tcx>>>>,
-) -> bool {
-    // Clippy shouldn't have infer types
-    assert!(!ty.has_infer());
-
-    let ty = tcx.erase_regions(ty);
-    if ty.has_escaping_bound_vars() {
-        return false;
-    }
-
-    let infcx = tcx.infer_ctxt().build();
-    let trait_ref = TraitRef::new(
-        tcx,
-        trait_id,
-        Some(GenericArg::from(ty))
-            .into_iter()
-            .chain(args.into_iter().map(|arg| {
-                arg.into().unwrap_or_else(|| {
-                    let orig = TypeVariableOrigin {
-                        kind: TypeVariableOriginKind::MiscVariable,
-                        span: DUMMY_SP,
-                    };
-                    infcx.next_ty_var(orig).into()
-                })
-            })),
-    );
-
-    debug_assert_matches!(
-        tcx.def_kind(trait_id),
-        DefKind::Trait | DefKind::TraitAlias,
-        "`DefId` must belong to a trait or trait alias"
-    );
-    #[cfg(debug_assertions)]
-    assert_generic_args_match(tcx, trait_id, trait_ref.args);
-
-    let obligation = Obligation {
-        cause: ObligationCause::dummy(),
-        param_env,
-        recursion_depth: 0,
-        predicate: ty::Binder::dummy(trait_ref).to_predicate(tcx),
-    };
-    infcx
-        .evaluate_obligation(&obligation)
-        .is_ok_and(EvaluationResult::must_apply_modulo_regions)
-}
-
-/// Checks whether this type implements `Drop`.
-pub fn has_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.ty_adt_def() {
-        Some(def) => def.has_dtor(cx.tcx),
-        None => false,
-    }
-}
-
-// Returns whether the type has #[must_use] attribute
-pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.has_attr(adt.did(), sym::must_use),
-        ty::Foreign(did) => cx.tcx.has_attr(*did, sym::must_use),
-        ty::Slice(ty) | ty::Array(ty, _) | ty::RawPtr(ty::TypeAndMut { ty, .. }) | ty::Ref(_, ty, _) => {
-            // for the Array case we don't need to care for the len == 0 case
-            // because we don't want to lint functions returning empty arrays
-            is_must_use_ty(cx, *ty)
-        },
-        ty::Tuple(args) => args.iter().any(|ty| is_must_use_ty(cx, ty)),
-        ty::Alias(ty::Opaque, ty::AliasTy { def_id, .. }) => {
-            for (predicate, _) in cx.tcx.explicit_item_bounds(def_id).skip_binder() {
-                if let ty::ClauseKind::Trait(trait_predicate) = predicate.kind().skip_binder() {
-                    if cx.tcx.has_attr(trait_predicate.trait_ref.def_id, sym::must_use) {
-                        return true;
-                    }
-                }
-            }
-            false
-        },
-        ty::Dynamic(binder, _, _) => {
-            for predicate in *binder {
-                if let ty::ExistentialPredicate::Trait(ref trait_ref) = predicate.skip_binder() {
-                    if cx.tcx.has_attr(trait_ref.def_id, sym::must_use) {
-                        return true;
-                    }
-                }
-            }
-            false
-        },
-        _ => false,
-    }
-}
-
-// FIXME: Per https://doc.rust-lang.org/nightly/nightly-rustc/rustc_trait_selection/infer/at/struct.At.html#method.normalize
-// this function can be removed once the `normalize` method does not panic when normalization does
-// not succeed
-/// Checks if `Ty` is normalizable. This function is useful
-/// to avoid crashes on `layout_of`.
-pub fn is_normalizable<'tcx>(cx: &LateContext<'tcx>, param_env: ty::ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
-    is_normalizable_helper(cx, param_env, ty, &mut FxHashMap::default())
-}
-
-fn is_normalizable_helper<'tcx>(
-    cx: &LateContext<'tcx>,
-    param_env: ty::ParamEnv<'tcx>,
-    ty: Ty<'tcx>,
-    cache: &mut FxHashMap<Ty<'tcx>, bool>,
-) -> bool {
-    if let Some(&cached_result) = cache.get(&ty) {
-        return cached_result;
-    }
-    // prevent recursive loops, false-negative is better than endless loop leading to stack overflow
-    cache.insert(ty, false);
-    let infcx = cx.tcx.infer_ctxt().build();
-    let cause = rustc_middle::traits::ObligationCause::dummy();
-    let result = if infcx.at(&cause, param_env).query_normalize(ty).is_ok() {
-        match ty.kind() {
-            ty::Adt(def, args) => def.variants().iter().all(|variant| {
-                variant
-                    .fields
-                    .iter()
-                    .all(|field| is_normalizable_helper(cx, param_env, field.ty(cx.tcx, args), cache))
-            }),
-            _ => ty.walk().all(|generic_arg| match generic_arg.unpack() {
-                GenericArgKind::Type(inner_ty) if inner_ty != ty => {
-                    is_normalizable_helper(cx, param_env, inner_ty, cache)
-                },
-                _ => true, // if inner_ty == ty, we've already checked it
-            }),
-        }
-    } else {
-        false
-    };
-    cache.insert(ty, result);
-    result
-}
-
-/// Returns `true` if the given type is a non aggregate primitive (a `bool` or `char`, any
-/// integer or floating-point number type). For checking aggregation of primitive types (e.g.
-/// tuples and slices of primitive type) see `is_recursively_primitive_type`
-pub fn is_non_aggregate_primitive_type(ty: Ty<'_>) -> bool {
-    matches!(ty.kind(), ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_))
-}
-
-/// Returns `true` if the given type is a primitive (a `bool` or `char`, any integer or
-/// floating-point number type, a `str`, or an array, slice, or tuple of those types).
-pub fn is_recursively_primitive_type(ty: Ty<'_>) -> bool {
-    match *ty.kind() {
-        ty::Bool | ty::Char | ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Str => true,
-        ty::Ref(_, inner, _) if inner.is_str() => true,
-        ty::Array(inner_type, _) | ty::Slice(inner_type) => is_recursively_primitive_type(inner_type),
-        ty::Tuple(inner_types) => inner_types.iter().all(is_recursively_primitive_type),
-        _ => false,
-    }
-}
-
-/// Checks if the type is a reference equals to a diagnostic item
-pub fn is_type_ref_to_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
-    match ty.kind() {
-        ty::Ref(_, ref_ty, _) => match ref_ty.kind() {
-            ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did()),
-            _ => false,
-        },
-        _ => false,
-    }
-}
-
-/// Checks if the type is equal to a diagnostic item. To check if a type implements a
-/// trait marked with a diagnostic item use [`implements_trait`].
-///
-/// For a further exploitation what diagnostic items are see [diagnostic items] in
-/// rustc-dev-guide.
-///
-/// ---
-///
-/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
-///
-/// [Diagnostic Items]: https://rustc-dev-guide.rust-lang.org/diagnostics/diagnostic-items.html
-pub fn is_type_diagnostic_item(cx: &LateContext<'_>, ty: Ty<'_>, diag_item: Symbol) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.is_diagnostic_item(diag_item, adt.did()),
-        _ => false,
-    }
-}
-
-/// Checks if the type is equal to a lang item.
-///
-/// Returns `false` if the `LangItem` is not defined.
-pub fn is_type_lang_item(cx: &LateContext<'_>, ty: Ty<'_>, lang_item: hir::LangItem) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => cx.tcx.lang_items().get(lang_item) == Some(adt.did()),
-        _ => false,
-    }
-}
-
-/// Gets the diagnostic name of the type, if it has one
-pub fn type_diagnostic_name(cx: &LateContext<'_>, ty: Ty<'_>) -> Option<Symbol> {
-    ty.ty_adt_def().and_then(|adt| cx.tcx.get_diagnostic_name(adt.did()))
-}
-
-/// Return `true` if the passed `typ` is `isize` or `usize`.
-pub fn is_isize_or_usize(typ: Ty<'_>) -> bool {
-    matches!(typ.kind(), ty::Int(IntTy::Isize) | ty::Uint(UintTy::Usize))
-}
-
-/// Checks if type is struct, enum or union type with the given def path.
-///
-/// If the type is a diagnostic item, use `is_type_diagnostic_item` instead.
-/// If you change the signature, remember to update the internal lint `MatchTypeOnDiagItem`
-pub fn match_type(cx: &LateContext<'_>, ty: Ty<'_>, path: &[&str]) -> bool {
-    match ty.kind() {
-        ty::Adt(adt, _) => match_def_path(cx, adt.did(), path),
-        _ => false,
-    }
-}
-
-/// Checks if the drop order for a type matters. Some std types implement drop solely to
-/// deallocate memory. For these types, and composites containing them, changing the drop order
-/// won't result in any observable side effects.
-pub fn needs_ordered_drop<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    fn needs_ordered_drop_inner<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, seen: &mut FxHashSet<Ty<'tcx>>) -> bool {
-        if !seen.insert(ty) {
-            return false;
-        }
-        if !ty.has_significant_drop(cx.tcx, cx.param_env) {
-            false
-        }
-        // Check for std types which implement drop, but only for memory allocation.
-        else if is_type_lang_item(cx, ty, LangItem::OwnedBox)
-            || matches!(
-                get_type_diagnostic_name(cx, ty),
-                Some(sym::HashSet | sym::Rc | sym::Arc | sym::cstring_type)
-            )
-            || match_type(cx, ty, &paths::WEAK_RC)
-            || match_type(cx, ty, &paths::WEAK_ARC)
-        {
-            // Check all of the generic arguments.
-            if let ty::Adt(_, subs) = ty.kind() {
-                subs.types().any(|ty| needs_ordered_drop_inner(cx, ty, seen))
-            } else {
-                true
-            }
-        } else if !cx
-            .tcx
-            .lang_items()
-            .drop_trait()
-            .map_or(false, |id| implements_trait(cx, ty, id, &[]))
-        {
-            // This type doesn't implement drop, so no side effects here.
-            // Check if any component type has any.
-            match ty.kind() {
-                ty::Tuple(fields) => fields.iter().any(|ty| needs_ordered_drop_inner(cx, ty, seen)),
-                ty::Array(ty, _) => needs_ordered_drop_inner(cx, *ty, seen),
-                ty::Adt(adt, subs) => adt
-                    .all_fields()
-                    .map(|f| f.ty(cx.tcx, subs))
-                    .any(|ty| needs_ordered_drop_inner(cx, ty, seen)),
-                _ => true,
-            }
-        } else {
-            true
-        }
-    }
-
-    needs_ordered_drop_inner(cx, ty, &mut FxHashSet::default())
-}
-
-/// Peels off all references on the type. Returns the underlying type and the number of references
-/// removed.
-pub fn peel_mid_ty_refs(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn peel(ty: Ty<'_>, count: usize) -> (Ty<'_>, usize) {
-        if let ty::Ref(_, ty, _) = ty.kind() {
-            peel(*ty, count + 1)
-        } else {
-            (ty, count)
-        }
-    }
-    peel(ty, 0)
-}
-
-/// Peels off all references on the type. Returns the underlying type, the number of references
-/// removed, and whether the pointer is ultimately mutable or not.
-pub fn peel_mid_ty_refs_is_mutable(ty: Ty<'_>) -> (Ty<'_>, usize, Mutability) {
-    fn f(ty: Ty<'_>, count: usize, mutability: Mutability) -> (Ty<'_>, usize, Mutability) {
-        match ty.kind() {
-            ty::Ref(_, ty, Mutability::Mut) => f(*ty, count + 1, mutability),
-            ty::Ref(_, ty, Mutability::Not) => f(*ty, count + 1, Mutability::Not),
-            _ => (ty, count, mutability),
-        }
-    }
-    f(ty, 0, Mutability::Mut)
-}
-
-/// Returns `true` if the given type is an `unsafe` function.
-pub fn type_is_unsafe_function<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match ty.kind() {
-        ty::FnDef(..) | ty::FnPtr(_) => ty.fn_sig(cx.tcx).unsafety() == Unsafety::Unsafe,
-        _ => false,
-    }
-}
-
-/// Returns the base type for HIR references and pointers.
-pub fn walk_ptrs_hir_ty<'tcx>(ty: &'tcx hir::Ty<'tcx>) -> &'tcx hir::Ty<'tcx> {
-    match ty.kind {
-        TyKind::Ptr(ref mut_ty) | TyKind::Ref(_, ref mut_ty) => walk_ptrs_hir_ty(mut_ty.ty),
-        _ => ty,
-    }
-}
-
-/// Returns the base type for references and raw pointers, and count reference
-/// depth.
-pub fn walk_ptrs_ty_depth(ty: Ty<'_>) -> (Ty<'_>, usize) {
-    fn inner(ty: Ty<'_>, depth: usize) -> (Ty<'_>, usize) {
-        match ty.kind() {
-            ty::Ref(_, ty, _) => inner(*ty, depth + 1),
-            _ => (ty, depth),
-        }
-    }
-    inner(ty, 0)
-}
-
-/// Returns `true` if types `a` and `b` are same types having same `Const` generic args,
-/// otherwise returns `false`
-pub fn same_type_and_consts<'tcx>(a: Ty<'tcx>, b: Ty<'tcx>) -> bool {
-    match (&a.kind(), &b.kind()) {
-        (&ty::Adt(did_a, args_a), &ty::Adt(did_b, args_b)) => {
-            if did_a != did_b {
-                return false;
-            }
-
-            args_a
-                .iter()
-                .zip(args_b.iter())
-                .all(|(arg_a, arg_b)| match (arg_a.unpack(), arg_b.unpack()) {
-                    (GenericArgKind::Const(inner_a), GenericArgKind::Const(inner_b)) => inner_a == inner_b,
-                    (GenericArgKind::Type(type_a), GenericArgKind::Type(type_b)) => {
-                        same_type_and_consts(type_a, type_b)
-                    },
-                    _ => true,
-                })
-        },
-        _ => a == b,
-    }
-}
-
-/// Checks if a given type looks safe to be uninitialized.
-pub fn is_uninit_value_valid_for_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    cx.tcx
-        .check_validity_requirement((ValidityRequirement::Uninit, cx.param_env.and(ty)))
-        .unwrap_or_else(|_| is_uninit_value_valid_for_ty_fallback(cx, ty))
-}
-
-/// A fallback for polymorphic types, which are not supported by `check_validity_requirement`.
-fn is_uninit_value_valid_for_ty_fallback<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match *ty.kind() {
-        // The array length may be polymorphic, let's try the inner type.
-        ty::Array(component, _) => is_uninit_value_valid_for_ty(cx, component),
-        // Peek through tuples and try their fallbacks.
-        ty::Tuple(types) => types.iter().all(|ty| is_uninit_value_valid_for_ty(cx, ty)),
-        // Unions are always fine right now.
-        // This includes MaybeUninit, the main way people use uninitialized memory.
-        // For ADTs, we could look at all fields just like for tuples, but that's potentially
-        // exponential, so let's avoid doing that for now. Code doing that is sketchy enough to
-        // just use an `#[allow()]`.
-        ty::Adt(adt, _) => adt.is_union(),
-        // For the rest, conservatively assume that they cannot be uninit.
-        _ => false,
-    }
-}
-
-/// Gets an iterator over all predicates which apply to the given item.
-pub fn all_predicates_of(tcx: TyCtxt<'_>, id: DefId) -> impl Iterator<Item = &(ty::Clause<'_>, Span)> {
-    let mut next_id = Some(id);
-    iter::from_fn(move || {
-        next_id.take().map(|id| {
-            let preds = tcx.predicates_of(id);
-            next_id = preds.parent;
-            preds.predicates.iter()
-        })
-    })
-    .flatten()
-}
-
-/// A signature for a function like type.
-#[derive(Clone, Copy)]
-pub enum ExprFnSig<'tcx> {
-    Sig(Binder<'tcx, FnSig<'tcx>>, Option<DefId>),
-    Closure(Option<&'tcx FnDecl<'tcx>>, Binder<'tcx, FnSig<'tcx>>),
-    Trait(Binder<'tcx, Ty<'tcx>>, Option<Binder<'tcx, Ty<'tcx>>>, Option<DefId>),
-}
-impl<'tcx> ExprFnSig<'tcx> {
-    /// Gets the argument type at the given offset. This will return `None` when the index is out of
-    /// bounds only for variadic functions, otherwise this will panic.
-    pub fn input(self, i: usize) -> Option<Binder<'tcx, Ty<'tcx>>> {
-        match self {
-            Self::Sig(sig, _) => {
-                if sig.c_variadic() {
-                    sig.inputs().map_bound(|inputs| inputs.get(i).copied()).transpose()
-                } else {
-                    Some(sig.input(i))
-                }
-            },
-            Self::Closure(_, sig) => Some(sig.input(0).map_bound(|ty| ty.tuple_fields()[i])),
-            Self::Trait(inputs, _, _) => Some(inputs.map_bound(|ty| ty.tuple_fields()[i])),
-        }
-    }
-
-    /// Gets the argument type at the given offset. For closures this will also get the type as
-    /// written. This will return `None` when the index is out of bounds only for variadic
-    /// functions, otherwise this will panic.
-    pub fn input_with_hir(self, i: usize) -> Option<(Option<&'tcx hir::Ty<'tcx>>, Binder<'tcx, Ty<'tcx>>)> {
-        match self {
-            Self::Sig(sig, _) => {
-                if sig.c_variadic() {
-                    sig.inputs()
-                        .map_bound(|inputs| inputs.get(i).copied())
-                        .transpose()
-                        .map(|arg| (None, arg))
-                } else {
-                    Some((None, sig.input(i)))
-                }
-            },
-            Self::Closure(decl, sig) => Some((
-                decl.and_then(|decl| decl.inputs.get(i)),
-                sig.input(0).map_bound(|ty| ty.tuple_fields()[i]),
-            )),
-            Self::Trait(inputs, _, _) => Some((None, inputs.map_bound(|ty| ty.tuple_fields()[i]))),
-        }
-    }
-
-    /// Gets the result type, if one could be found. Note that the result type of a trait may not be
-    /// specified.
-    pub fn output(self) -> Option<Binder<'tcx, Ty<'tcx>>> {
-        match self {
-            Self::Sig(sig, _) | Self::Closure(_, sig) => Some(sig.output()),
-            Self::Trait(_, output, _) => output,
-        }
-    }
-
-    pub fn predicates_id(&self) -> Option<DefId> {
-        if let ExprFnSig::Sig(_, id) | ExprFnSig::Trait(_, _, id) = *self {
-            id
-        } else {
-            None
-        }
-    }
-}
-
-/// If the expression is function like, get the signature for it.
-pub fn expr_sig<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> Option<ExprFnSig<'tcx>> {
-    if let Res::Def(DefKind::Fn | DefKind::Ctor(_, CtorKind::Fn) | DefKind::AssocFn, id) = path_res(cx, expr) {
-        Some(ExprFnSig::Sig(cx.tcx.fn_sig(id).instantiate_identity(), Some(id)))
-    } else {
-        ty_sig(cx, cx.typeck_results().expr_ty_adjusted(expr).peel_refs())
-    }
-}
-
-/// If the type is function like, get the signature for it.
-pub fn ty_sig<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> Option<ExprFnSig<'tcx>> {
-    if ty.is_box() {
-        return ty_sig(cx, ty.boxed_ty());
-    }
-    match *ty.kind() {
-        ty::Closure(id, subs) => {
-            let decl = id
-                .as_local()
-                .and_then(|id| cx.tcx.hir().fn_decl_by_hir_id(cx.tcx.hir().local_def_id_to_hir_id(id)));
-            Some(ExprFnSig::Closure(decl, subs.as_closure().sig()))
-        },
-        ty::FnDef(id, subs) => Some(ExprFnSig::Sig(cx.tcx.fn_sig(id).instantiate(cx.tcx, subs), Some(id))),
-        ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => sig_from_bounds(
-            cx,
-            ty,
-            cx.tcx.item_bounds(def_id).iter_instantiated(cx.tcx, args),
-            cx.tcx.opt_parent(def_id),
-        ),
-        ty::FnPtr(sig) => Some(ExprFnSig::Sig(sig, None)),
-        ty::Dynamic(bounds, _, _) => {
-            let lang_items = cx.tcx.lang_items();
-            match bounds.principal() {
-                Some(bound)
-                    if Some(bound.def_id()) == lang_items.fn_trait()
-                        || Some(bound.def_id()) == lang_items.fn_once_trait()
-                        || Some(bound.def_id()) == lang_items.fn_mut_trait() =>
-                {
-                    let output = bounds
-                        .projection_bounds()
-                        .find(|p| lang_items.fn_once_output().map_or(false, |id| id == p.item_def_id()))
-                        .map(|p| p.map_bound(|p| p.term.ty().unwrap()));
-                    Some(ExprFnSig::Trait(bound.map_bound(|b| b.args.type_at(0)), output, None))
-                },
-                _ => None,
-            }
-        },
-        ty::Alias(ty::Projection, proj) => match cx.tcx.try_normalize_erasing_regions(cx.param_env, ty) {
-            Ok(normalized_ty) if normalized_ty != ty => ty_sig(cx, normalized_ty),
-            _ => sig_for_projection(cx, proj).or_else(|| sig_from_bounds(cx, ty, cx.param_env.caller_bounds(), None)),
-        },
-        ty::Param(_) => sig_from_bounds(cx, ty, cx.param_env.caller_bounds(), None),
-        _ => None,
-    }
-}
-
-fn sig_from_bounds<'tcx>(
-    cx: &LateContext<'tcx>,
-    ty: Ty<'tcx>,
-    predicates: impl IntoIterator<Item = ty::Clause<'tcx>>,
-    predicates_id: Option<DefId>,
-) -> Option<ExprFnSig<'tcx>> {
-    let mut inputs = None;
-    let mut output = None;
-    let lang_items = cx.tcx.lang_items();
-
-    for pred in predicates {
-        match pred.kind().skip_binder() {
-            ty::ClauseKind::Trait(p)
-                if (lang_items.fn_trait() == Some(p.def_id())
-                    || lang_items.fn_mut_trait() == Some(p.def_id())
-                    || lang_items.fn_once_trait() == Some(p.def_id()))
-                    && p.self_ty() == ty =>
-            {
-                let i = pred.kind().rebind(p.trait_ref.args.type_at(1));
-                if inputs.map_or(false, |inputs| i != inputs) {
-                    // Multiple different fn trait impls. Is this even allowed?
-                    return None;
-                }
-                inputs = Some(i);
-            },
-            ty::ClauseKind::Projection(p)
-                if Some(p.projection_ty.def_id) == lang_items.fn_once_output() && p.projection_ty.self_ty() == ty =>
-            {
-                if output.is_some() {
-                    // Multiple different fn trait impls. Is this even allowed?
-                    return None;
-                }
-                output = Some(pred.kind().rebind(p.term.ty().unwrap()));
-            },
-            _ => (),
-        }
-    }
-
-    inputs.map(|ty| ExprFnSig::Trait(ty, output, predicates_id))
-}
-
-fn sig_for_projection<'tcx>(cx: &LateContext<'tcx>, ty: AliasTy<'tcx>) -> Option<ExprFnSig<'tcx>> {
-    let mut inputs = None;
-    let mut output = None;
-    let lang_items = cx.tcx.lang_items();
-
-    for (pred, _) in cx
-        .tcx
-        .explicit_item_bounds(ty.def_id)
-        .iter_instantiated_copied(cx.tcx, ty.args)
-    {
-        match pred.kind().skip_binder() {
-            ty::ClauseKind::Trait(p)
-                if (lang_items.fn_trait() == Some(p.def_id())
-                    || lang_items.fn_mut_trait() == Some(p.def_id())
-                    || lang_items.fn_once_trait() == Some(p.def_id())) =>
-            {
-                let i = pred.kind().rebind(p.trait_ref.args.type_at(1));
-
-                if inputs.map_or(false, |inputs| inputs != i) {
-                    // Multiple different fn trait impls. Is this even allowed?
-                    return None;
-                }
-                inputs = Some(i);
-            },
-            ty::ClauseKind::Projection(p) if Some(p.projection_ty.def_id) == lang_items.fn_once_output() => {
-                if output.is_some() {
-                    // Multiple different fn trait impls. Is this even allowed?
-                    return None;
-                }
-                output = pred.kind().rebind(p.term.ty()).transpose();
-            },
-            _ => (),
-        }
-    }
-
-    inputs.map(|ty| ExprFnSig::Trait(ty, output, None))
-}
-
-#[derive(Clone, Copy)]
-pub enum EnumValue {
-    Unsigned(u128),
-    Signed(i128),
-}
-impl core::ops::Add<u32> for EnumValue {
-    type Output = Self;
-    fn add(self, n: u32) -> Self::Output {
-        match self {
-            Self::Unsigned(x) => Self::Unsigned(x + u128::from(n)),
-            Self::Signed(x) => Self::Signed(x + i128::from(n)),
-        }
-    }
-}
-
-/// Attempts to read the given constant as though it were an enum value.
-#[expect(clippy::cast_possible_truncation, clippy::cast_possible_wrap)]
-pub fn read_explicit_enum_value(tcx: TyCtxt<'_>, id: DefId) -> Option<EnumValue> {
-    if let Ok(ConstValue::Scalar(Scalar::Int(value))) = tcx.const_eval_poly(id) {
-        match tcx.type_of(id).instantiate_identity().kind() {
-            ty::Int(_) => Some(EnumValue::Signed(match value.size().bytes() {
-                1 => i128::from(value.assert_bits(Size::from_bytes(1)) as u8 as i8),
-                2 => i128::from(value.assert_bits(Size::from_bytes(2)) as u16 as i16),
-                4 => i128::from(value.assert_bits(Size::from_bytes(4)) as u32 as i32),
-                8 => i128::from(value.assert_bits(Size::from_bytes(8)) as u64 as i64),
-                16 => value.assert_bits(Size::from_bytes(16)) as i128,
-                _ => return None,
-            })),
-            ty::Uint(_) => Some(EnumValue::Unsigned(match value.size().bytes() {
-                1 => value.assert_bits(Size::from_bytes(1)),
-                2 => value.assert_bits(Size::from_bytes(2)),
-                4 => value.assert_bits(Size::from_bytes(4)),
-                8 => value.assert_bits(Size::from_bytes(8)),
-                16 => value.assert_bits(Size::from_bytes(16)),
-                _ => return None,
-            })),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
-/// Gets the value of the given variant.
-pub fn get_discriminant_value(tcx: TyCtxt<'_>, adt: AdtDef<'_>, i: VariantIdx) -> EnumValue {
-    let variant = &adt.variant(i);
-    match variant.discr {
-        VariantDiscr::Explicit(id) => read_explicit_enum_value(tcx, id).unwrap(),
-        VariantDiscr::Relative(x) => match adt.variant((i.as_usize() - x as usize).into()).discr {
-            VariantDiscr::Explicit(id) => read_explicit_enum_value(tcx, id).unwrap() + x,
-            VariantDiscr::Relative(_) => EnumValue::Unsigned(x.into()),
-        },
-    }
-}
-
-/// Check if the given type is either `core::ffi::c_void`, `std::os::raw::c_void`, or one of the
-/// platform specific `libc::<platform>::c_void` types in libc.
-pub fn is_c_void(cx: &LateContext<'_>, ty: Ty<'_>) -> bool {
-    if let ty::Adt(adt, _) = ty.kind()
-        && let &[krate, .., name] = &*cx.get_def_path(adt.did())
-        && let sym::libc | sym::core | sym::std = krate
-        && name == rustc_span::sym::c_void
-    {
-        true
-    } else {
-        false
-    }
-}
-
-pub fn for_each_top_level_late_bound_region<B>(
-    ty: Ty<'_>,
-    f: impl FnMut(BoundRegion) -> ControlFlow<B>,
-) -> ControlFlow<B> {
-    struct V<F> {
-        index: u32,
-        f: F,
-    }
-    impl<'tcx, B, F: FnMut(BoundRegion) -> ControlFlow<B>> TypeVisitor<TyCtxt<'tcx>> for V<F> {
-        type BreakTy = B;
-        fn visit_region(&mut self, r: Region<'tcx>) -> ControlFlow<Self::BreakTy> {
-            if let RegionKind::ReLateBound(idx, bound) = r.kind() && idx.as_u32() == self.index {
-                (self.f)(bound)
-            } else {
-                ControlFlow::Continue(())
-            }
-        }
-        fn visit_binder<T: TypeVisitable<TyCtxt<'tcx>>>(&mut self, t: &Binder<'tcx, T>) -> ControlFlow<Self::BreakTy> {
-            self.index += 1;
-            let res = t.super_visit_with(self);
-            self.index -= 1;
-            res
-        }
-    }
-    ty.visit_with(&mut V { index: 0, f })
-}
-
-pub struct AdtVariantInfo {
-    pub ind: usize,
-    pub size: u64,
-
-    /// (ind, size)
-    pub fields_size: Vec<(usize, u64)>,
-}
-
-impl AdtVariantInfo {
-    /// Returns ADT variants ordered by size
-    pub fn new<'tcx>(cx: &LateContext<'tcx>, adt: AdtDef<'tcx>, subst: &'tcx List<GenericArg<'tcx>>) -> Vec<Self> {
-        let mut variants_size = adt
-            .variants()
-            .iter()
-            .enumerate()
-            .map(|(i, variant)| {
-                let mut fields_size = variant
-                    .fields
-                    .iter()
-                    .enumerate()
-                    .map(|(i, f)| (i, approx_ty_size(cx, f.ty(cx.tcx, subst))))
-                    .collect::<Vec<_>>();
-                fields_size.sort_by(|(_, a_size), (_, b_size)| (a_size.cmp(b_size)));
-
-                Self {
-                    ind: i,
-                    size: fields_size.iter().map(|(_, size)| size).sum(),
-                    fields_size,
-                }
-            })
-            .collect::<Vec<_>>();
-        variants_size.sort_by(|a, b| (b.size.cmp(&a.size)));
-        variants_size
-    }
-}
-
-/// Gets the struct or enum variant from the given `Res`
-pub fn adt_and_variant_of_res<'tcx>(cx: &LateContext<'tcx>, res: Res) -> Option<(AdtDef<'tcx>, &'tcx VariantDef)> {
-    match res {
-        Res::Def(DefKind::Struct, id) => {
-            let adt = cx.tcx.adt_def(id);
-            Some((adt, adt.non_enum_variant()))
-        },
-        Res::Def(DefKind::Variant, id) => {
-            let adt = cx.tcx.adt_def(cx.tcx.parent(id));
-            Some((adt, adt.variant_with_id(id)))
-        },
-        Res::Def(DefKind::Ctor(CtorOf::Struct, _), id) => {
-            let adt = cx.tcx.adt_def(cx.tcx.parent(id));
-            Some((adt, adt.non_enum_variant()))
-        },
-        Res::Def(DefKind::Ctor(CtorOf::Variant, _), id) => {
-            let var_id = cx.tcx.parent(id);
-            let adt = cx.tcx.adt_def(cx.tcx.parent(var_id));
-            Some((adt, adt.variant_with_id(var_id)))
-        },
-        Res::SelfCtor(id) => {
-            let adt = cx.tcx.type_of(id).instantiate_identity().ty_adt_def().unwrap();
-            Some((adt, adt.non_enum_variant()))
-        },
-        _ => None,
-    }
-}
-
-/// Checks if the type is a type parameter implementing `FnOnce`, but not `FnMut`.
-pub fn ty_is_fn_once_param<'tcx>(tcx: TyCtxt<'_>, ty: Ty<'tcx>, predicates: &'tcx [ty::Clause<'_>]) -> bool {
-    let ty::Param(ty) = *ty.kind() else {
-        return false;
-    };
-    let lang = tcx.lang_items();
-    let (Some(fn_once_id), Some(fn_mut_id), Some(fn_id)) = (lang.fn_once_trait(), lang.fn_mut_trait(), lang.fn_trait())
-    else {
-        return false;
-    };
-    predicates
-        .iter()
-        .try_fold(false, |found, p| {
-            if let ty::ClauseKind::Trait(p) = p.kind().skip_binder()
-            && let ty::Param(self_ty) = p.trait_ref.self_ty().kind()
-            && ty.index == self_ty.index
-        {
-            // This should use `super_traits_of`, but that's a private function.
-            if p.trait_ref.def_id == fn_once_id {
-                return Some(true);
-            } else if p.trait_ref.def_id == fn_mut_id || p.trait_ref.def_id == fn_id {
-                return None;
-            }
-        }
-            Some(found)
-        })
-        .unwrap_or(false)
-}
-
-/// Comes up with an "at least" guesstimate for the type's size, not taking into
-/// account the layout of type parameters.
-pub fn approx_ty_size<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> u64 {
-    use rustc_middle::ty::layout::LayoutOf;
-    if !is_normalizable(cx, cx.param_env, ty) {
-        return 0;
-    }
-    match (cx.layout_of(ty).map(|layout| layout.size.bytes()), ty.kind()) {
-        (Ok(size), _) => size,
-        (Err(_), ty::Tuple(list)) => list.iter().map(|t| approx_ty_size(cx, t)).sum(),
-        (Err(_), ty::Array(t, n)) => {
-            n.try_eval_target_usize(cx.tcx, cx.param_env).unwrap_or_default() * approx_ty_size(cx, *t)
-        },
-        (Err(_), ty::Adt(def, subst)) if def.is_struct() => def
-            .variants()
-            .iter()
-            .map(|v| {
-                v.fields
-                    .iter()
-                    .map(|field| approx_ty_size(cx, field.ty(cx.tcx, subst)))
-                    .sum::<u64>()
-            })
-            .sum(),
-        (Err(_), ty::Adt(def, subst)) if def.is_enum() => def
-            .variants()
-            .iter()
-            .map(|v| {
-                v.fields
-                    .iter()
-                    .map(|field| approx_ty_size(cx, field.ty(cx.tcx, subst)))
-                    .sum::<u64>()
-            })
-            .max()
-            .unwrap_or_default(),
-        (Err(_), ty::Adt(def, subst)) if def.is_union() => def
-            .variants()
-            .iter()
-            .map(|v| {
-                v.fields
-                    .iter()
-                    .map(|field| approx_ty_size(cx, field.ty(cx.tcx, subst)))
-                    .max()
-                    .unwrap_or_default()
-            })
-            .max()
-            .unwrap_or_default(),
-        (Err(_), _) => 0,
-    }
-}
-
-/// Asserts that the given arguments match the generic parameters of the given item.
-#[allow(dead_code)]
-fn assert_generic_args_match<'tcx>(tcx: TyCtxt<'tcx>, did: DefId, args: &[GenericArg<'tcx>]) {
-    let g = tcx.generics_of(did);
-    let parent = g.parent.map(|did| tcx.generics_of(did));
-    let count = g.parent_count + g.params.len();
-    let params = parent
-        .map_or([].as_slice(), |p| p.params.as_slice())
-        .iter()
-        .chain(&g.params)
-        .map(|x| &x.kind);
-
-    assert!(
-        count == args.len(),
-        "wrong number of arguments for `{did:?}`: expected `{count}`, found {}\n\
-            note: the expected arguments are: `[{}]`\n\
-            the given arguments are: `{args:#?}`",
-        args.len(),
-        params.clone().map(GenericParamDefKind::descr).format(", "),
-    );
-
-    if let Some((idx, (param, arg))) =
-        params
-            .clone()
-            .zip(args.iter().map(|&x| x.unpack()))
-            .enumerate()
-            .find(|(_, (param, arg))| match (param, arg) {
-                (GenericParamDefKind::Lifetime, GenericArgKind::Lifetime(_))
-                | (GenericParamDefKind::Type { .. }, GenericArgKind::Type(_))
-                | (GenericParamDefKind::Const { .. }, GenericArgKind::Const(_)) => false,
-                (
-                    GenericParamDefKind::Lifetime
-                    | GenericParamDefKind::Type { .. }
-                    | GenericParamDefKind::Const { .. },
-                    _,
-                ) => true,
-            })
-    {
-        panic!(
-            "incorrect argument for `{did:?}` at index `{idx}`: expected a {}, found `{arg:?}`\n\
-                note: the expected arguments are `[{}]`\n\
-                the given arguments are `{args:#?}`",
-            param.descr(),
-            params.clone().map(GenericParamDefKind::descr).format(", "),
-        );
-    }
-}
-
-/// Returns whether `ty` is never-like; i.e., `!` (never) or an enum with zero variants.
-pub fn is_never_like(ty: Ty<'_>) -> bool {
-    ty.is_never() || (ty.is_enum() && ty.ty_adt_def().is_some_and(|def| def.variants().is_empty()))
-}
-
-/// Makes the projection type for the named associated type in the given impl or trait impl.
-///
-/// This function is for associated types which are "known" to exist, and as such, will only return
-/// `None` when debug assertions are disabled in order to prevent ICE's. With debug assertions
-/// enabled this will check that the named associated type exists, the correct number of
-/// arguments are given, and that the correct kinds of arguments are given (lifetime,
-/// constant or type). This will not check if type normalization would succeed.
-pub fn make_projection<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    container_id: DefId,
-    assoc_ty: Symbol,
-    args: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
-) -> Option<AliasTy<'tcx>> {
-    fn helper<'tcx>(
-        tcx: TyCtxt<'tcx>,
-        container_id: DefId,
-        assoc_ty: Symbol,
-        args: GenericArgsRef<'tcx>,
-    ) -> Option<AliasTy<'tcx>> {
-        let Some(assoc_item) = tcx.associated_items(container_id).find_by_name_and_kind(
-            tcx,
-            Ident::with_dummy_span(assoc_ty),
-            AssocKind::Type,
-            container_id,
-        ) else {
-            debug_assert!(false, "type `{assoc_ty}` not found in `{container_id:?}`");
-            return None;
-        };
-        #[cfg(debug_assertions)]
-        assert_generic_args_match(tcx, assoc_item.def_id, args);
-
-        Some(tcx.mk_alias_ty(assoc_item.def_id, args))
-    }
-    helper(
-        tcx,
-        container_id,
-        assoc_ty,
-        tcx.mk_args_from_iter(args.into_iter().map(Into::into)),
-    )
-}
-
-/// Normalizes the named associated type in the given impl or trait impl.
-///
-/// This function is for associated types which are "known" to be valid with the given
-/// arguments, and as such, will only return `None` when debug assertions are disabled in order
-/// to prevent ICE's. With debug assertions enabled this will check that type normalization
-/// succeeds as well as everything checked by `make_projection`.
-pub fn make_normalized_projection<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    param_env: ParamEnv<'tcx>,
-    container_id: DefId,
-    assoc_ty: Symbol,
-    args: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
-) -> Option<Ty<'tcx>> {
-    fn helper<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: AliasTy<'tcx>) -> Option<Ty<'tcx>> {
-        #[cfg(debug_assertions)]
-        if let Some((i, arg)) = ty.args.iter().enumerate().find(|(_, arg)| arg.has_late_bound_regions()) {
-            debug_assert!(
-                false,
-                "args contain late-bound region at index `{i}` which can't be normalized.\n\
-                    use `TyCtxt::erase_late_bound_regions`\n\
-                    note: arg is `{arg:#?}`",
-            );
-            return None;
-        }
-        match tcx.try_normalize_erasing_regions(param_env, Ty::new_projection(tcx, ty.def_id, ty.args)) {
-            Ok(ty) => Some(ty),
-            Err(e) => {
-                debug_assert!(false, "failed to normalize type `{ty}`: {e:#?}");
-                None
-            },
-        }
-    }
-    helper(tcx, param_env, make_projection(tcx, container_id, assoc_ty, args)?)
-}
-
-/// Check if given type has inner mutability such as [`std::cell::Cell`] or [`std::cell::RefCell`]
-/// etc.
-pub fn is_interior_mut_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
-    match *ty.kind() {
-        ty::Ref(_, inner_ty, mutbl) => mutbl == Mutability::Mut || is_interior_mut_ty(cx, inner_ty),
-        ty::Slice(inner_ty) => is_interior_mut_ty(cx, inner_ty),
-        ty::Array(inner_ty, size) => {
-            size.try_eval_target_usize(cx.tcx, cx.param_env)
-                .map_or(true, |u| u != 0)
-                && is_interior_mut_ty(cx, inner_ty)
-        },
-        ty::Tuple(fields) => fields.iter().any(|ty| is_interior_mut_ty(cx, ty)),
-        ty::Adt(def, args) => {
-            // Special case for collections in `std` who's impl of `Hash` or `Ord` delegates to
-            // that of their type parameters.  Note: we don't include `HashSet` and `HashMap`
-            // because they have no impl for `Hash` or `Ord`.
-            let def_id = def.did();
-            let is_std_collection = [
-                sym::Option,
-                sym::Result,
-                sym::LinkedList,
-                sym::Vec,
-                sym::VecDeque,
-                sym::BTreeMap,
-                sym::BTreeSet,
-                sym::Rc,
-                sym::Arc,
-            ]
-            .iter()
-            .any(|diag_item| cx.tcx.is_diagnostic_item(*diag_item, def_id));
-            let is_box = Some(def_id) == cx.tcx.lang_items().owned_box();
-            if is_std_collection || is_box {
-                // The type is mutable if any of its type parameters are
-                args.types().any(|ty| is_interior_mut_ty(cx, ty))
-            } else {
-                !ty.has_escaping_bound_vars()
-                    && cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
-                    && !ty.is_freeze(cx.tcx, cx.param_env)
-            }
-        },
-        _ => false,
-    }
-}
-
-pub fn make_normalized_projection_with_regions<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    param_env: ParamEnv<'tcx>,
-    container_id: DefId,
-    assoc_ty: Symbol,
-    args: impl IntoIterator<Item = impl Into<GenericArg<'tcx>>>,
-) -> Option<Ty<'tcx>> {
-    fn helper<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: AliasTy<'tcx>) -> Option<Ty<'tcx>> {
-        #[cfg(debug_assertions)]
-        if let Some((i, arg)) = ty.args.iter().enumerate().find(|(_, arg)| arg.has_late_bound_regions()) {
-            debug_assert!(
-                false,
-                "args contain late-bound region at index `{i}` which can't be normalized.\n\
-                    use `TyCtxt::erase_late_bound_regions`\n\
-                    note: arg is `{arg:#?}`",
-            );
-            return None;
-        }
-        let cause = rustc_middle::traits::ObligationCause::dummy();
-        match tcx
-            .infer_ctxt()
-            .build()
-            .at(&cause, param_env)
-            .query_normalize(Ty::new_projection(tcx, ty.def_id, ty.args))
-        {
-            Ok(ty) => Some(ty.value),
-            Err(e) => {
-                debug_assert!(false, "failed to normalize type `{ty}`: {e:#?}");
-                None
-            },
-        }
-    }
-    helper(tcx, param_env, make_projection(tcx, container_id, assoc_ty, args)?)
-}
-
-pub fn normalize_with_regions<'tcx>(tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, ty: Ty<'tcx>) -> Ty<'tcx> {
-    let cause = rustc_middle::traits::ObligationCause::dummy();
-    match tcx.infer_ctxt().build().at(&cause, param_env).query_normalize(ty) {
-        Ok(ty) => ty.value,
-        Err(_) => ty,
-    }
-}
diff --git a/scout-audit-clippy-utils/src/ty/type_certainty/certainty.rs b/scout-audit-clippy-utils/src/ty/type_certainty/certainty.rs
deleted file mode 100644
index 0e69ffa2..00000000
--- a/scout-audit-clippy-utils/src/ty/type_certainty/certainty.rs
+++ /dev/null
@@ -1,122 +0,0 @@
-use rustc_hir::def_id::DefId;
-use std::fmt::Debug;
-
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum Certainty {
-    /// Determining the type requires contextual information.
-    Uncertain,
-
-    /// The type can be determined purely from subexpressions. If the argument is `Some(..)`, the
-    /// specific `DefId` is known. Such arguments are needed to handle path segments whose `res` is
-    /// `Res::Err`.
-    Certain(Option<DefId>),
-
-    /// The heuristic believes that more than one `DefId` applies to a type---this is a bug.
-    Contradiction,
-}
-
-pub trait Meet {
-    fn meet(self, other: Self) -> Self;
-}
-
-pub trait TryJoin: Sized {
-    fn try_join(self, other: Self) -> Option<Self>;
-}
-
-impl Meet for Option<DefId> {
-    fn meet(self, other: Self) -> Self {
-        match (self, other) {
-            (None, _) | (_, None) => None,
-            (Some(lhs), Some(rhs)) => (lhs == rhs).then_some(lhs),
-        }
-    }
-}
-
-impl TryJoin for Option<DefId> {
-    fn try_join(self, other: Self) -> Option<Self> {
-        match (self, other) {
-            (Some(lhs), Some(rhs)) => (lhs == rhs).then_some(Some(lhs)),
-            (Some(def_id), _) | (_, Some(def_id)) => Some(Some(def_id)),
-            (None, None) => Some(None),
-        }
-    }
-}
-
-impl Meet for Certainty {
-    fn meet(self, other: Self) -> Self {
-        match (self, other) {
-            (Certainty::Uncertain, _) | (_, Certainty::Uncertain) => Certainty::Uncertain,
-            (Certainty::Certain(lhs), Certainty::Certain(rhs)) => Certainty::Certain(lhs.meet(rhs)),
-            (Certainty::Certain(inner), _) | (_, Certainty::Certain(inner)) => Certainty::Certain(inner),
-            (Certainty::Contradiction, Certainty::Contradiction) => Certainty::Contradiction,
-        }
-    }
-}
-
-impl Certainty {
-    /// Join two `Certainty`s preserving their `DefId`s (if any). Generally speaking, this method
-    /// should be used only when `self` and `other` refer directly to types. Otherwise,
-    /// `join_clearing_def_ids` should be used.
-    pub fn join(self, other: Self) -> Self {
-        match (self, other) {
-            (Certainty::Contradiction, _) | (_, Certainty::Contradiction) => Certainty::Contradiction,
-
-            (Certainty::Certain(lhs), Certainty::Certain(rhs)) => {
-                if let Some(inner) = lhs.try_join(rhs) {
-                    Certainty::Certain(inner)
-                } else {
-                    debug_assert!(false, "Contradiction with {lhs:?} and {rhs:?}");
-                    Certainty::Contradiction
-                }
-            },
-
-            (Certainty::Certain(inner), _) | (_, Certainty::Certain(inner)) => Certainty::Certain(inner),
-
-            (Certainty::Uncertain, Certainty::Uncertain) => Certainty::Uncertain,
-        }
-    }
-
-    /// Join two `Certainty`s after clearing their `DefId`s. This method should be used when `self`
-    /// or `other` do not necessarily refer to types, e.g., when they are aggregations of other
-    /// `Certainty`s.
-    pub fn join_clearing_def_ids(self, other: Self) -> Self {
-        self.clear_def_id().join(other.clear_def_id())
-    }
-
-    pub fn clear_def_id(self) -> Certainty {
-        if matches!(self, Certainty::Certain(_)) {
-            Certainty::Certain(None)
-        } else {
-            self
-        }
-    }
-
-    pub fn with_def_id(self, def_id: DefId) -> Certainty {
-        if matches!(self, Certainty::Certain(_)) {
-            Certainty::Certain(Some(def_id))
-        } else {
-            self
-        }
-    }
-
-    pub fn to_def_id(self) -> Option<DefId> {
-        match self {
-            Certainty::Certain(inner) => inner,
-            _ => None,
-        }
-    }
-
-    pub fn is_certain(self) -> bool {
-        matches!(self, Self::Certain(_))
-    }
-}
-
-/// Think: `iter.all(/* is certain */)`
-pub fn meet(iter: impl Iterator<Item = Certainty>) -> Certainty {
-    iter.fold(Certainty::Certain(None), Certainty::meet)
-}
-
-/// Think: `iter.any(/* is certain */)`
-pub fn join(iter: impl Iterator<Item = Certainty>) -> Certainty {
-    iter.fold(Certainty::Uncertain, Certainty::join)
-}
diff --git a/scout-audit-clippy-utils/src/ty/type_certainty/mod.rs b/scout-audit-clippy-utils/src/ty/type_certainty/mod.rs
deleted file mode 100644
index d05d9e76..00000000
--- a/scout-audit-clippy-utils/src/ty/type_certainty/mod.rs
+++ /dev/null
@@ -1,321 +0,0 @@
-//! A heuristic to tell whether an expression's type can be determined purely from its
-//! subexpressions, and the arguments and locals they use. Put another way, `expr_type_is_certain`
-//! tries to tell whether an expression's type can be determined without appeal to the surrounding
-//! context.
-//!
-//! This is, in some sense, a counterpart to `let_unit_value`'s `expr_needs_inferred_result`.
-//! Intuitively, that function determines whether an expression's type is needed for type inference,
-//! whereas `expr_type_is_certain` determines whether type inference is needed for an expression's
-//! type.
-//!
-//! As a heuristic, `expr_type_is_certain` may produce false negatives, but a false positive should
-//! be considered a bug.
-
-use crate::def_path_res;
-use rustc_hir::def::{DefKind, Res};
-use rustc_hir::def_id::DefId;
-use rustc_hir::intravisit::{walk_qpath, walk_ty, Visitor};
-use rustc_hir::{self as hir, Expr, ExprKind, GenericArgs, HirId, Node, PathSegment, QPath, TyKind};
-use rustc_lint::LateContext;
-use rustc_middle::ty::{self, AdtDef, GenericArgKind, Ty};
-use rustc_span::{Span, Symbol};
-
-mod certainty;
-use certainty::{join, meet, Certainty, Meet};
-
-pub fn expr_type_is_certain(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    expr_type_certainty(cx, expr).is_certain()
-}
-
-fn expr_type_certainty(cx: &LateContext<'_>, expr: &Expr<'_>) -> Certainty {
-    let certainty = match &expr.kind {
-        ExprKind::Unary(_, expr)
-        | ExprKind::Field(expr, _)
-        | ExprKind::Index(expr, _, _)
-        | ExprKind::AddrOf(_, _, expr) => expr_type_certainty(cx, expr),
-
-        ExprKind::Array(exprs) => join(exprs.iter().map(|expr| expr_type_certainty(cx, expr))),
-
-        ExprKind::Call(callee, args) => {
-            let lhs = expr_type_certainty(cx, callee);
-            let rhs = if type_is_inferrable_from_arguments(cx, expr) {
-                meet(args.iter().map(|arg| expr_type_certainty(cx, arg)))
-            } else {
-                Certainty::Uncertain
-            };
-            lhs.join_clearing_def_ids(rhs)
-        },
-
-        ExprKind::MethodCall(method, receiver, args, _) => {
-            let mut receiver_type_certainty = expr_type_certainty(cx, receiver);
-            // Even if `receiver_type_certainty` is `Certain(Some(..))`, the `Self` type in the method
-            // identified by `type_dependent_def_id(..)` can differ. This can happen as a result of a `deref`,
-            // for example. So update the `DefId` in `receiver_type_certainty` (if any).
-            if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
-                && let Some(self_ty_def_id) = adt_def_id(self_ty(cx, method_def_id))
-            {
-                receiver_type_certainty = receiver_type_certainty.with_def_id(self_ty_def_id);
-            };
-            let lhs = path_segment_certainty(cx, receiver_type_certainty, method, false);
-            let rhs = if type_is_inferrable_from_arguments(cx, expr) {
-                meet(
-                    std::iter::once(receiver_type_certainty).chain(args.iter().map(|arg| expr_type_certainty(cx, arg))),
-                )
-            } else {
-                Certainty::Uncertain
-            };
-            lhs.join(rhs)
-        },
-
-        ExprKind::Tup(exprs) => meet(exprs.iter().map(|expr| expr_type_certainty(cx, expr))),
-
-        ExprKind::Binary(_, lhs, rhs) => expr_type_certainty(cx, lhs).meet(expr_type_certainty(cx, rhs)),
-
-        ExprKind::Lit(_) => Certainty::Certain(None),
-
-        ExprKind::Cast(_, ty) => type_certainty(cx, ty),
-
-        ExprKind::If(_, if_expr, Some(else_expr)) => {
-            expr_type_certainty(cx, if_expr).join(expr_type_certainty(cx, else_expr))
-        },
-
-        ExprKind::Path(qpath) => qpath_certainty(cx, qpath, false),
-
-        ExprKind::Struct(qpath, _, _) => qpath_certainty(cx, qpath, true),
-
-        _ => Certainty::Uncertain,
-    };
-
-    let expr_ty = cx.typeck_results().expr_ty(expr);
-    if let Some(def_id) = adt_def_id(expr_ty) {
-        certainty.with_def_id(def_id)
-    } else {
-        certainty
-    }
-}
-
-struct CertaintyVisitor<'cx, 'tcx> {
-    cx: &'cx LateContext<'tcx>,
-    certainty: Certainty,
-}
-
-impl<'cx, 'tcx> CertaintyVisitor<'cx, 'tcx> {
-    fn new(cx: &'cx LateContext<'tcx>) -> Self {
-        Self {
-            cx,
-            certainty: Certainty::Certain(None),
-        }
-    }
-}
-
-impl<'cx, 'tcx> Visitor<'cx> for CertaintyVisitor<'cx, 'tcx> {
-    fn visit_qpath(&mut self, qpath: &'cx QPath<'_>, hir_id: HirId, _: Span) {
-        self.certainty = self.certainty.meet(qpath_certainty(self.cx, qpath, true));
-        if self.certainty != Certainty::Uncertain {
-            walk_qpath(self, qpath, hir_id);
-        }
-    }
-
-    fn visit_ty(&mut self, ty: &'cx hir::Ty<'_>) {
-        if matches!(ty.kind, TyKind::Infer) {
-            self.certainty = Certainty::Uncertain;
-        }
-        if self.certainty != Certainty::Uncertain {
-            walk_ty(self, ty);
-        }
-    }
-}
-
-fn type_certainty(cx: &LateContext<'_>, ty: &hir::Ty<'_>) -> Certainty {
-    // Handle `TyKind::Path` specially so that its `DefId` can be preserved.
-    //
-    // Note that `CertaintyVisitor::new` initializes the visitor's internal certainty to
-    // `Certainty::Certain(None)`. Furthermore, if a `TyKind::Path` is encountered while traversing
-    // `ty`, the result of the call to `qpath_certainty` is combined with the visitor's internal
-    // certainty using `Certainty::meet`. Thus, if the `TyKind::Path` were not treated specially here,
-    // the resulting certainty would be `Certainty::Certain(None)`.
-    if let TyKind::Path(qpath) = &ty.kind {
-        return qpath_certainty(cx, qpath, true);
-    }
-
-    let mut visitor = CertaintyVisitor::new(cx);
-    visitor.visit_ty(ty);
-    visitor.certainty
-}
-
-fn generic_args_certainty(cx: &LateContext<'_>, args: &GenericArgs<'_>) -> Certainty {
-    let mut visitor = CertaintyVisitor::new(cx);
-    visitor.visit_generic_args(args);
-    visitor.certainty
-}
-
-/// Tries to tell whether a `QPath` resolves to something certain, e.g., whether all of its path
-/// segments generic arguments are instantiated.
-///
-/// `qpath` could refer to either a type or a value. The heuristic never needs the `DefId` of a
-/// value. So `DefId`s are retained only when `resolves_to_type` is true.
-fn qpath_certainty(cx: &LateContext<'_>, qpath: &QPath<'_>, resolves_to_type: bool) -> Certainty {
-    let certainty = match qpath {
-        QPath::Resolved(ty, path) => {
-            let len = path.segments.len();
-            path.segments.iter().enumerate().fold(
-                ty.map_or(Certainty::Uncertain, |ty| type_certainty(cx, ty)),
-                |parent_certainty, (i, path_segment)| {
-                    path_segment_certainty(cx, parent_certainty, path_segment, i != len - 1 || resolves_to_type)
-                },
-            )
-        },
-
-        QPath::TypeRelative(ty, path_segment) => {
-            path_segment_certainty(cx, type_certainty(cx, ty), path_segment, resolves_to_type)
-        },
-
-        QPath::LangItem(lang_item, _, _) => {
-            cx.tcx
-                .lang_items()
-                .get(*lang_item)
-                .map_or(Certainty::Uncertain, |def_id| {
-                    let generics = cx.tcx.generics_of(def_id);
-                    if generics.parent_count == 0 && generics.params.is_empty() {
-                        Certainty::Certain(if resolves_to_type { Some(def_id) } else { None })
-                    } else {
-                        Certainty::Uncertain
-                    }
-                })
-        },
-    };
-    debug_assert!(resolves_to_type || certainty.to_def_id().is_none());
-    certainty
-}
-
-fn path_segment_certainty(
-    cx: &LateContext<'_>,
-    parent_certainty: Certainty,
-    path_segment: &PathSegment<'_>,
-    resolves_to_type: bool,
-) -> Certainty {
-    let certainty = match update_res(cx, parent_certainty, path_segment).unwrap_or(path_segment.res) {
-        // A definition's type is certain if it refers to something without generics (e.g., a crate or module, or
-        // an unparameterized type), or the generics are instantiated with arguments that are certain.
-        //
-        // If the parent is uncertain, then the current path segment must account for the parent's generic arguments.
-        // Consider the following examples, where the current path segment is `None`:
-        // - `Option::None`             // uncertain; parent (i.e., `Option`) is uncertain
-        // - `Option::<Vec<u64>>::None` // certain; parent (i.e., `Option::<..>`) is certain
-        // - `Option::None::<Vec<u64>>` // certain; parent (i.e., `Option`) is uncertain
-        Res::Def(_, def_id) => {
-            // Checking `res_generics_def_id(..)` before calling `generics_of` avoids an ICE.
-            if cx.tcx.res_generics_def_id(path_segment.res).is_some() {
-                let generics = cx.tcx.generics_of(def_id);
-                let count = generics.params.len() - usize::from(generics.host_effect_index.is_some());
-                let lhs = if (parent_certainty.is_certain() || generics.parent_count == 0) && count == 0 {
-                    Certainty::Certain(None)
-                } else {
-                    Certainty::Uncertain
-                };
-                let rhs = path_segment
-                    .args
-                    .map_or(Certainty::Uncertain, |args| generic_args_certainty(cx, args));
-                // See the comment preceding `qpath_certainty`. `def_id` could refer to a type or a value.
-                let certainty = lhs.join_clearing_def_ids(rhs);
-                if resolves_to_type {
-                    if let DefKind::TyAlias { .. } = cx.tcx.def_kind(def_id) {
-                        adt_def_id(cx.tcx.type_of(def_id).instantiate_identity())
-                            .map_or(certainty, |def_id| certainty.with_def_id(def_id))
-                    } else {
-                        certainty.with_def_id(def_id)
-                    }
-                } else {
-                    certainty
-                }
-            } else {
-                Certainty::Certain(None)
-            }
-        },
-
-        Res::PrimTy(_) | Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } | Res::SelfCtor(_) => {
-            Certainty::Certain(None)
-        },
-
-        // `get_parent` because `hir_id` refers to a `Pat`, and we're interested in the node containing the `Pat`.
-        Res::Local(hir_id) => match cx.tcx.hir().get_parent(hir_id) {
-            // An argument's type is always certain.
-            Node::Param(..) => Certainty::Certain(None),
-            // A local's type is certain if its type annotation is certain or it has an initializer whose
-            // type is certain.
-            Node::Local(local) => {
-                let lhs = local.ty.map_or(Certainty::Uncertain, |ty| type_certainty(cx, ty));
-                let rhs = local
-                    .init
-                    .map_or(Certainty::Uncertain, |init| expr_type_certainty(cx, init));
-                let certainty = lhs.join(rhs);
-                if resolves_to_type {
-                    certainty
-                } else {
-                    certainty.clear_def_id()
-                }
-            },
-            _ => Certainty::Uncertain,
-        },
-
-        _ => Certainty::Uncertain,
-    };
-    debug_assert!(resolves_to_type || certainty.to_def_id().is_none());
-    certainty
-}
-
-/// For at least some `QPath::TypeRelative`, the path segment's `res` can be `Res::Err`.
-/// `update_res` tries to fix the resolution when `parent_certainty` is `Certain(Some(..))`.
-fn update_res(cx: &LateContext<'_>, parent_certainty: Certainty, path_segment: &PathSegment<'_>) -> Option<Res> {
-    if path_segment.res == Res::Err && let Some(def_id) = parent_certainty.to_def_id() {
-        let mut def_path = cx.get_def_path(def_id);
-        def_path.push(path_segment.ident.name);
-        let reses = def_path_res(cx, &def_path.iter().map(Symbol::as_str).collect::<Vec<_>>());
-        if let [res] = reses.as_slice() { Some(*res) } else { None }
-    } else {
-        None
-    }
-}
-
-#[allow(clippy::cast_possible_truncation)]
-fn type_is_inferrable_from_arguments(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    let Some(callee_def_id) = (match expr.kind {
-        ExprKind::Call(callee, _) => {
-            let callee_ty = cx.typeck_results().expr_ty(callee);
-            if let ty::FnDef(callee_def_id, _) = callee_ty.kind() {
-                Some(*callee_def_id)
-            } else {
-                None
-            }
-        },
-        ExprKind::MethodCall(_, _, _, _) => cx.typeck_results().type_dependent_def_id(expr.hir_id),
-        _ => None,
-    }) else {
-        return false;
-    };
-
-    let generics = cx.tcx.generics_of(callee_def_id);
-    let fn_sig = cx.tcx.fn_sig(callee_def_id).skip_binder();
-
-    // Check that all type parameters appear in the functions input types.
-    (0..(generics.parent_count + generics.params.len()) as u32).all(|index| {
-        Some(index as usize) == generics.host_effect_index
-            || fn_sig
-                .inputs()
-                .iter()
-                .any(|input_ty| contains_param(*input_ty.skip_binder(), index))
-    })
-}
-
-fn self_ty<'tcx>(cx: &LateContext<'tcx>, method_def_id: DefId) -> Ty<'tcx> {
-    cx.tcx.fn_sig(method_def_id).skip_binder().inputs().skip_binder()[0]
-}
-
-fn adt_def_id(ty: Ty<'_>) -> Option<DefId> {
-    ty.peel_refs().ty_adt_def().map(AdtDef::did)
-}
-
-fn contains_param(ty: Ty<'_>, index: u32) -> bool {
-    ty.walk()
-        .any(|arg| matches!(arg.unpack(), GenericArgKind::Type(ty) if ty.is_param(index)))
-}
diff --git a/scout-audit-clippy-utils/src/usage.rs b/scout-audit-clippy-utils/src/usage.rs
deleted file mode 100644
index ec131c7f..00000000
--- a/scout-audit-clippy-utils/src/usage.rs
+++ /dev/null
@@ -1,210 +0,0 @@
-use crate::visitors::{for_each_expr, for_each_expr_with_closures, Descend, Visitable};
-use crate::{self as utils, get_enclosing_loop_or_multi_call_closure};
-use core::ops::ControlFlow;
-use hir::def::Res;
-use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{self as hir, Expr, ExprKind, HirId, HirIdSet};
-use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, Place, PlaceBase, PlaceWithHirId};
-use rustc_infer::infer::TyCtxtInferExt;
-use rustc_lint::LateContext;
-use rustc_middle::hir::nested_filter;
-use rustc_middle::mir::FakeReadCause;
-use rustc_middle::ty;
-
-/// Returns a set of mutated local variable IDs, or `None` if mutations could not be determined.
-pub fn mutated_variables<'tcx>(expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> Option<HirIdSet> {
-    let mut delegate = MutVarsDelegate {
-        used_mutably: HirIdSet::default(),
-        skip: false,
-    };
-    let infcx = cx.tcx.infer_ctxt().build();
-    ExprUseVisitor::new(
-        &mut delegate,
-        &infcx,
-        expr.hir_id.owner.def_id,
-        cx.param_env,
-        cx.typeck_results(),
-    )
-    .walk_expr(expr);
-
-    if delegate.skip {
-        return None;
-    }
-    Some(delegate.used_mutably)
-}
-
-pub fn is_potentially_mutated<'tcx>(variable: HirId, expr: &'tcx Expr<'_>, cx: &LateContext<'tcx>) -> bool {
-    mutated_variables(expr, cx).map_or(true, |mutated| mutated.contains(&variable))
-}
-
-pub fn is_potentially_local_place(local_id: HirId, place: &Place<'_>) -> bool {
-    match place.base {
-        PlaceBase::Local(id) => id == local_id,
-        PlaceBase::Upvar(_) => {
-            // Conservatively assume yes.
-            true
-        },
-        _ => false,
-    }
-}
-
-struct MutVarsDelegate {
-    used_mutably: HirIdSet,
-    skip: bool,
-}
-
-impl<'tcx> MutVarsDelegate {
-    fn update(&mut self, cat: &PlaceWithHirId<'tcx>) {
-        match cat.place.base {
-            PlaceBase::Local(id) => {
-                self.used_mutably.insert(id);
-            },
-            PlaceBase::Upvar(_) => {
-                //FIXME: This causes false negatives. We can't get the `NodeId` from
-                //`Categorization::Upvar(_)`. So we search for any `Upvar`s in the
-                //`while`-body, not just the ones in the condition.
-                self.skip = true;
-            },
-            _ => {},
-        }
-    }
-}
-
-impl<'tcx> Delegate<'tcx> for MutVarsDelegate {
-    fn consume(&mut self, _: &PlaceWithHirId<'tcx>, _: HirId) {}
-
-    fn borrow(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId, bk: ty::BorrowKind) {
-        if bk == ty::BorrowKind::MutBorrow {
-            self.update(cmt);
-        }
-    }
-
-    fn mutate(&mut self, cmt: &PlaceWithHirId<'tcx>, _: HirId) {
-        self.update(cmt);
-    }
-
-    fn fake_read(&mut self, _: &rustc_hir_typeck::expr_use_visitor::PlaceWithHirId<'tcx>, _: FakeReadCause, _: HirId) {}
-}
-
-pub struct ParamBindingIdCollector {
-    pub binding_hir_ids: Vec<hir::HirId>,
-}
-impl<'tcx> ParamBindingIdCollector {
-    fn collect_binding_hir_ids(body: &'tcx hir::Body<'tcx>) -> Vec<hir::HirId> {
-        let mut hir_ids: Vec<hir::HirId> = Vec::new();
-        for param in body.params {
-            let mut finder = ParamBindingIdCollector {
-                binding_hir_ids: Vec::new(),
-            };
-            finder.visit_param(param);
-            for hir_id in &finder.binding_hir_ids {
-                hir_ids.push(*hir_id);
-            }
-        }
-        hir_ids
-    }
-}
-impl<'tcx> intravisit::Visitor<'tcx> for ParamBindingIdCollector {
-    fn visit_pat(&mut self, pat: &'tcx hir::Pat<'tcx>) {
-        if let hir::PatKind::Binding(_, hir_id, ..) = pat.kind {
-            self.binding_hir_ids.push(hir_id);
-        }
-        intravisit::walk_pat(self, pat);
-    }
-}
-
-pub struct BindingUsageFinder<'a, 'tcx> {
-    cx: &'a LateContext<'tcx>,
-    binding_ids: Vec<hir::HirId>,
-    usage_found: bool,
-}
-impl<'a, 'tcx> BindingUsageFinder<'a, 'tcx> {
-    pub fn are_params_used(cx: &'a LateContext<'tcx>, body: &'tcx hir::Body<'tcx>) -> bool {
-        let mut finder = BindingUsageFinder {
-            cx,
-            binding_ids: ParamBindingIdCollector::collect_binding_hir_ids(body),
-            usage_found: false,
-        };
-        finder.visit_body(body);
-        finder.usage_found
-    }
-}
-impl<'a, 'tcx> intravisit::Visitor<'tcx> for BindingUsageFinder<'a, 'tcx> {
-    type NestedFilter = nested_filter::OnlyBodies;
-
-    fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) {
-        if !self.usage_found {
-            intravisit::walk_expr(self, expr);
-        }
-    }
-
-    fn visit_path(&mut self, path: &hir::Path<'tcx>, _: hir::HirId) {
-        if let Res::Local(id) = path.res {
-            if self.binding_ids.contains(&id) {
-                self.usage_found = true;
-            }
-        }
-    }
-
-    fn nested_visit_map(&mut self) -> Self::Map {
-        self.cx.tcx.hir()
-    }
-}
-
-pub fn contains_return_break_continue_macro(expression: &Expr<'_>) -> bool {
-    for_each_expr(expression, |e| {
-        match e.kind {
-            ExprKind::Ret(..) | ExprKind::Break(..) | ExprKind::Continue(..) => ControlFlow::Break(()),
-            // Something special could be done here to handle while or for loop
-            // desugaring, as this will detect a break if there's a while loop
-            // or a for loop inside the expression.
-            _ if e.span.from_expansion() => ControlFlow::Break(()),
-            _ => ControlFlow::Continue(()),
-        }
-    })
-    .is_some()
-}
-
-pub fn local_used_in<'tcx>(cx: &LateContext<'tcx>, local_id: HirId, v: impl Visitable<'tcx>) -> bool {
-    for_each_expr_with_closures(cx, v, |e| {
-        if utils::path_to_local_id(e, local_id) {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
-
-pub fn local_used_after_expr(cx: &LateContext<'_>, local_id: HirId, after: &Expr<'_>) -> bool {
-    let Some(block) = utils::get_enclosing_block(cx, local_id) else {
-        return false;
-    };
-
-    // for _ in 1..3 {
-    //    local
-    // }
-    //
-    // let closure = || local;
-    // closure();
-    // closure();
-    let loop_start = get_enclosing_loop_or_multi_call_closure(cx, after).map(|e| e.hir_id);
-
-    let mut past_expr = false;
-    for_each_expr_with_closures(cx, block, |e| {
-        if past_expr {
-            if utils::path_to_local_id(e, local_id) {
-                ControlFlow::Break(())
-            } else {
-                ControlFlow::Continue(Descend::Yes)
-            }
-        } else if e.hir_id == after.hir_id {
-            past_expr = true;
-            ControlFlow::Continue(Descend::No)
-        } else {
-            past_expr = Some(e.hir_id) == loop_start;
-            ControlFlow::Continue(Descend::Yes)
-        }
-    })
-    .is_some()
-}
diff --git a/scout-audit-clippy-utils/src/visitors.rs b/scout-audit-clippy-utils/src/visitors.rs
deleted file mode 100644
index 3b47a451..00000000
--- a/scout-audit-clippy-utils/src/visitors.rs
+++ /dev/null
@@ -1,750 +0,0 @@
-use crate::ty::needs_ordered_drop;
-use crate::{get_enclosing_block, path_to_local_id};
-use core::ops::ControlFlow;
-use rustc_hir as hir;
-use rustc_hir::def::{CtorKind, DefKind, Res};
-use rustc_hir::intravisit::{self, walk_block, walk_expr, Visitor};
-use rustc_hir::{
-    AnonConst, Arm, Block, BlockCheckMode, Body, BodyId, Expr, ExprKind, HirId, ItemId, ItemKind, Let, Pat, QPath,
-    Stmt, UnOp, UnsafeSource, Unsafety,
-};
-use rustc_lint::LateContext;
-use rustc_middle::hir::nested_filter;
-use rustc_middle::ty::adjustment::Adjust;
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeckResults};
-use rustc_span::Span;
-
-mod internal {
-    /// Trait for visitor functions to control whether or not to descend to child nodes. Implemented
-    /// for only two types. `()` always descends. `Descend` allows controlled descent.
-    pub trait Continue {
-        fn descend(&self) -> bool;
-    }
-}
-use internal::Continue;
-
-impl Continue for () {
-    fn descend(&self) -> bool {
-        true
-    }
-}
-
-/// Allows for controlled descent when using visitor functions. Use `()` instead when always
-/// descending into child nodes.
-#[derive(Clone, Copy)]
-pub enum Descend {
-    Yes,
-    No,
-}
-impl From<bool> for Descend {
-    fn from(from: bool) -> Self {
-        if from { Self::Yes } else { Self::No }
-    }
-}
-impl Continue for Descend {
-    fn descend(&self) -> bool {
-        matches!(self, Self::Yes)
-    }
-}
-
-/// A type which can be visited.
-pub trait Visitable<'tcx> {
-    /// Calls the corresponding `visit_*` function on the visitor.
-    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V);
-}
-impl<'tcx, T> Visitable<'tcx> for &'tcx [T]
-where
-    &'tcx T: Visitable<'tcx>,
-{
-    fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
-        for x in self {
-            x.visit(visitor);
-        }
-    }
-}
-macro_rules! visitable_ref {
-    ($t:ident, $f:ident) => {
-        impl<'tcx> Visitable<'tcx> for &'tcx $t<'tcx> {
-            fn visit<V: Visitor<'tcx>>(self, visitor: &mut V) {
-                visitor.$f(self);
-            }
-        }
-    };
-}
-visitable_ref!(Arm, visit_arm);
-visitable_ref!(Block, visit_block);
-visitable_ref!(Body, visit_body);
-visitable_ref!(Expr, visit_expr);
-visitable_ref!(Stmt, visit_stmt);
-
-/// Calls the given function once for each expression contained. This does not enter any bodies or
-/// nested items.
-pub fn for_each_expr<'tcx, B, C: Continue>(
-    node: impl Visitable<'tcx>,
-    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>,
-) -> Option<B> {
-    struct V<B, F> {
-        f: F,
-        res: Option<B>,
-    }
-    impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<B, F> {
-        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
-            if self.res.is_some() {
-                return;
-            }
-            match (self.f)(e) {
-                ControlFlow::Continue(c) if c.descend() => walk_expr(self, e),
-                ControlFlow::Break(b) => self.res = Some(b),
-                ControlFlow::Continue(_) => (),
-            }
-        }
-
-        // Avoid unnecessary `walk_*` calls.
-        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) {}
-        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
-        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
-        // Avoid monomorphising all `visit_*` functions.
-        fn visit_nested_item(&mut self, _: ItemId) {}
-    }
-    let mut v = V { f, res: None };
-    node.visit(&mut v);
-    v.res
-}
-
-/// Calls the given function once for each expression contained. This will enter bodies, but not
-/// nested items.
-pub fn for_each_expr_with_closures<'tcx, B, C: Continue>(
-    cx: &LateContext<'tcx>,
-    node: impl Visitable<'tcx>,
-    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>,
-) -> Option<B> {
-    struct V<'tcx, B, F> {
-        tcx: TyCtxt<'tcx>,
-        f: F,
-        res: Option<B>,
-    }
-    impl<'tcx, B, C: Continue, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B, C>> Visitor<'tcx> for V<'tcx, B, F> {
-        type NestedFilter = nested_filter::OnlyBodies;
-        fn nested_visit_map(&mut self) -> Self::Map {
-            self.tcx.hir()
-        }
-
-        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
-            if self.res.is_some() {
-                return;
-            }
-            match (self.f)(e) {
-                ControlFlow::Continue(c) if c.descend() => walk_expr(self, e),
-                ControlFlow::Break(b) => self.res = Some(b),
-                ControlFlow::Continue(_) => (),
-            }
-        }
-
-        // Only walk closures
-        fn visit_anon_const(&mut self, _: &'tcx AnonConst) {}
-        // Avoid unnecessary `walk_*` calls.
-        fn visit_ty(&mut self, _: &'tcx hir::Ty<'tcx>) {}
-        fn visit_pat(&mut self, _: &'tcx Pat<'tcx>) {}
-        fn visit_qpath(&mut self, _: &'tcx QPath<'tcx>, _: HirId, _: Span) {}
-        // Avoid monomorphising all `visit_*` functions.
-        fn visit_nested_item(&mut self, _: ItemId) {}
-    }
-    let mut v = V {
-        tcx: cx.tcx,
-        f,
-        res: None,
-    };
-    node.visit(&mut v);
-    v.res
-}
-
-/// returns `true` if expr contains match expr desugared from try
-fn contains_try(expr: &hir::Expr<'_>) -> bool {
-    for_each_expr(expr, |e| {
-        if matches!(e.kind, hir::ExprKind::Match(_, _, hir::MatchSource::TryDesugar(_))) {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
-
-pub fn find_all_ret_expressions<'hir, F>(_cx: &LateContext<'_>, expr: &'hir hir::Expr<'hir>, callback: F) -> bool
-where
-    F: FnMut(&'hir hir::Expr<'hir>) -> bool,
-{
-    struct RetFinder<F> {
-        in_stmt: bool,
-        failed: bool,
-        cb: F,
-    }
-
-    struct WithStmtGuard<'a, F> {
-        val: &'a mut RetFinder<F>,
-        prev_in_stmt: bool,
-    }
-
-    impl<F> RetFinder<F> {
-        fn inside_stmt(&mut self, in_stmt: bool) -> WithStmtGuard<'_, F> {
-            let prev_in_stmt = std::mem::replace(&mut self.in_stmt, in_stmt);
-            WithStmtGuard {
-                val: self,
-                prev_in_stmt,
-            }
-        }
-    }
-
-    impl<F> std::ops::Deref for WithStmtGuard<'_, F> {
-        type Target = RetFinder<F>;
-
-        fn deref(&self) -> &Self::Target {
-            self.val
-        }
-    }
-
-    impl<F> std::ops::DerefMut for WithStmtGuard<'_, F> {
-        fn deref_mut(&mut self) -> &mut Self::Target {
-            self.val
-        }
-    }
-
-    impl<F> Drop for WithStmtGuard<'_, F> {
-        fn drop(&mut self) {
-            self.val.in_stmt = self.prev_in_stmt;
-        }
-    }
-
-    impl<'hir, F: FnMut(&'hir hir::Expr<'hir>) -> bool> intravisit::Visitor<'hir> for RetFinder<F> {
-        fn visit_stmt(&mut self, stmt: &'hir hir::Stmt<'_>) {
-            intravisit::walk_stmt(&mut *self.inside_stmt(true), stmt);
-        }
-
-        fn visit_expr(&mut self, expr: &'hir hir::Expr<'_>) {
-            if self.failed {
-                return;
-            }
-            if self.in_stmt {
-                match expr.kind {
-                    hir::ExprKind::Ret(Some(expr)) => self.inside_stmt(false).visit_expr(expr),
-                    _ => intravisit::walk_expr(self, expr),
-                }
-            } else {
-                match expr.kind {
-                    hir::ExprKind::If(cond, then, else_opt) => {
-                        self.inside_stmt(true).visit_expr(cond);
-                        self.visit_expr(then);
-                        if let Some(el) = else_opt {
-                            self.visit_expr(el);
-                        }
-                    },
-                    hir::ExprKind::Match(cond, arms, _) => {
-                        self.inside_stmt(true).visit_expr(cond);
-                        for arm in arms {
-                            self.visit_expr(arm.body);
-                        }
-                    },
-                    hir::ExprKind::Block(..) => intravisit::walk_expr(self, expr),
-                    hir::ExprKind::Ret(Some(expr)) => self.visit_expr(expr),
-                    _ => self.failed |= !(self.cb)(expr),
-                }
-            }
-        }
-    }
-
-    !contains_try(expr) && {
-        let mut ret_finder = RetFinder {
-            in_stmt: false,
-            failed: false,
-            cb: callback,
-        };
-        ret_finder.visit_expr(expr);
-        !ret_finder.failed
-    }
-}
-
-/// Checks if the given resolved path is used in the given body.
-pub fn is_res_used(cx: &LateContext<'_>, res: Res, body: BodyId) -> bool {
-    for_each_expr_with_closures(cx, cx.tcx.hir().body(body).value, |e| {
-        if let ExprKind::Path(p) = &e.kind {
-            if cx.qpath_res(p, e.hir_id) == res {
-                return ControlFlow::Break(());
-            }
-        }
-        ControlFlow::Continue(())
-    })
-    .is_some()
-}
-
-/// Checks if the given local is used.
-pub fn is_local_used<'tcx>(cx: &LateContext<'tcx>, visitable: impl Visitable<'tcx>, id: HirId) -> bool {
-    for_each_expr_with_closures(cx, visitable, |e| {
-        if path_to_local_id(e, id) {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
-
-/// Checks if the given expression is a constant.
-pub fn is_const_evaluatable<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
-    struct V<'a, 'tcx> {
-        cx: &'a LateContext<'tcx>,
-        is_const: bool,
-    }
-    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
-        type NestedFilter = nested_filter::OnlyBodies;
-        fn nested_visit_map(&mut self) -> Self::Map {
-            self.cx.tcx.hir()
-        }
-
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            if !self.is_const {
-                return;
-            }
-            match e.kind {
-                ExprKind::ConstBlock(_) => return,
-                ExprKind::Call(
-                    &Expr {
-                        kind: ExprKind::Path(ref p),
-                        hir_id,
-                        ..
-                    },
-                    _,
-                ) if self
-                    .cx
-                    .qpath_res(p, hir_id)
-                    .opt_def_id()
-                    .map_or(false, |id| self.cx.tcx.is_const_fn_raw(id)) => {},
-                ExprKind::MethodCall(..)
-                    if self
-                        .cx
-                        .typeck_results()
-                        .type_dependent_def_id(e.hir_id)
-                        .map_or(false, |id| self.cx.tcx.is_const_fn_raw(id)) => {},
-                ExprKind::Binary(_, lhs, rhs)
-                    if self.cx.typeck_results().expr_ty(lhs).peel_refs().is_primitive_ty()
-                        && self.cx.typeck_results().expr_ty(rhs).peel_refs().is_primitive_ty() => {},
-                ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_ref() => (),
-                ExprKind::Unary(_, e) if self.cx.typeck_results().expr_ty(e).peel_refs().is_primitive_ty() => (),
-                ExprKind::Index(base, _, _)
-                    if matches!(
-                        self.cx.typeck_results().expr_ty(base).peel_refs().kind(),
-                        ty::Slice(_) | ty::Array(..)
-                    ) => {},
-                ExprKind::Path(ref p)
-                    if matches!(
-                        self.cx.qpath_res(p, e.hir_id),
-                        Res::Def(
-                            DefKind::Const
-                                | DefKind::AssocConst
-                                | DefKind::AnonConst
-                                | DefKind::ConstParam
-                                | DefKind::Ctor(..)
-                                | DefKind::Fn
-                                | DefKind::AssocFn,
-                            _
-                        ) | Res::SelfCtor(_)
-                    ) => {},
-
-                ExprKind::AddrOf(..)
-                | ExprKind::Array(_)
-                | ExprKind::Block(..)
-                | ExprKind::Cast(..)
-                | ExprKind::DropTemps(_)
-                | ExprKind::Field(..)
-                | ExprKind::If(..)
-                | ExprKind::Let(..)
-                | ExprKind::Lit(_)
-                | ExprKind::Match(..)
-                | ExprKind::Repeat(..)
-                | ExprKind::Struct(..)
-                | ExprKind::Tup(_)
-                | ExprKind::Type(..) => (),
-
-                _ => {
-                    self.is_const = false;
-                    return;
-                },
-            }
-            walk_expr(self, e);
-        }
-    }
-
-    let mut v = V { cx, is_const: true };
-    v.visit_expr(e);
-    v.is_const
-}
-
-/// Checks if the given expression performs an unsafe operation outside of an unsafe block.
-pub fn is_expr_unsafe<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> bool {
-    struct V<'a, 'tcx> {
-        cx: &'a LateContext<'tcx>,
-        is_unsafe: bool,
-    }
-    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
-        type NestedFilter = nested_filter::OnlyBodies;
-        fn nested_visit_map(&mut self) -> Self::Map {
-            self.cx.tcx.hir()
-        }
-        fn visit_expr(&mut self, e: &'tcx Expr<'_>) {
-            if self.is_unsafe {
-                return;
-            }
-            match e.kind {
-                ExprKind::Unary(UnOp::Deref, e) if self.cx.typeck_results().expr_ty(e).is_unsafe_ptr() => {
-                    self.is_unsafe = true;
-                },
-                ExprKind::MethodCall(..)
-                    if self
-                        .cx
-                        .typeck_results()
-                        .type_dependent_def_id(e.hir_id)
-                        .map_or(false, |id| {
-                            self.cx.tcx.fn_sig(id).skip_binder().unsafety() == Unsafety::Unsafe
-                        }) =>
-                {
-                    self.is_unsafe = true;
-                },
-                ExprKind::Call(func, _) => match *self.cx.typeck_results().expr_ty(func).peel_refs().kind() {
-                    ty::FnDef(id, _) if self.cx.tcx.fn_sig(id).skip_binder().unsafety() == Unsafety::Unsafe => {
-                        self.is_unsafe = true;
-                    },
-                    ty::FnPtr(sig) if sig.unsafety() == Unsafety::Unsafe => self.is_unsafe = true,
-                    _ => walk_expr(self, e),
-                },
-                ExprKind::Path(ref p)
-                    if self
-                        .cx
-                        .qpath_res(p, e.hir_id)
-                        .opt_def_id()
-                        .map_or(false, |id| self.cx.tcx.is_mutable_static(id)) =>
-                {
-                    self.is_unsafe = true;
-                },
-                _ => walk_expr(self, e),
-            }
-        }
-        fn visit_block(&mut self, b: &'tcx Block<'_>) {
-            if !matches!(b.rules, BlockCheckMode::UnsafeBlock(_)) {
-                walk_block(self, b);
-            }
-        }
-        fn visit_nested_item(&mut self, id: ItemId) {
-            if let ItemKind::Impl(i) = &self.cx.tcx.hir().item(id).kind {
-                self.is_unsafe = i.unsafety == Unsafety::Unsafe;
-            }
-        }
-    }
-    let mut v = V { cx, is_unsafe: false };
-    v.visit_expr(e);
-    v.is_unsafe
-}
-
-/// Checks if the given expression contains an unsafe block
-pub fn contains_unsafe_block<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> bool {
-    struct V<'cx, 'tcx> {
-        cx: &'cx LateContext<'tcx>,
-        found_unsafe: bool,
-    }
-    impl<'tcx> Visitor<'tcx> for V<'_, 'tcx> {
-        type NestedFilter = nested_filter::OnlyBodies;
-        fn nested_visit_map(&mut self) -> Self::Map {
-            self.cx.tcx.hir()
-        }
-
-        fn visit_block(&mut self, b: &'tcx Block<'_>) {
-            if self.found_unsafe {
-                return;
-            }
-            if b.rules == BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided) {
-                self.found_unsafe = true;
-                return;
-            }
-            walk_block(self, b);
-        }
-    }
-    let mut v = V {
-        cx,
-        found_unsafe: false,
-    };
-    v.visit_expr(e);
-    v.found_unsafe
-}
-
-/// Runs the given function for each sub-expression producing the final value consumed by the parent
-/// of the give expression.
-///
-/// e.g. for the following expression
-/// ```rust,ignore
-/// if foo {
-///     f(0)
-/// } else {
-///     1 + 1
-/// }
-/// ```
-/// this will pass both `f(0)` and `1+1` to the given function.
-pub fn for_each_value_source<'tcx, B>(
-    e: &'tcx Expr<'tcx>,
-    f: &mut impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>,
-) -> ControlFlow<B> {
-    match e.kind {
-        ExprKind::Block(Block { expr: Some(e), .. }, _) => for_each_value_source(e, f),
-        ExprKind::Match(_, arms, _) => {
-            for arm in arms {
-                for_each_value_source(arm.body, f)?;
-            }
-            ControlFlow::Continue(())
-        },
-        ExprKind::If(_, if_expr, Some(else_expr)) => {
-            for_each_value_source(if_expr, f)?;
-            for_each_value_source(else_expr, f)
-        },
-        ExprKind::DropTemps(e) => for_each_value_source(e, f),
-        _ => f(e),
-    }
-}
-
-/// Runs the given function for each path expression referencing the given local which occur after
-/// the given expression.
-pub fn for_each_local_use_after_expr<'tcx, B>(
-    cx: &LateContext<'tcx>,
-    local_id: HirId,
-    expr_id: HirId,
-    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>,
-) -> ControlFlow<B> {
-    struct V<'cx, 'tcx, F, B> {
-        cx: &'cx LateContext<'tcx>,
-        local_id: HirId,
-        expr_id: HirId,
-        found: bool,
-        res: ControlFlow<B>,
-        f: F,
-    }
-    impl<'cx, 'tcx, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>, B> Visitor<'tcx> for V<'cx, 'tcx, F, B> {
-        type NestedFilter = nested_filter::OnlyBodies;
-        fn nested_visit_map(&mut self) -> Self::Map {
-            self.cx.tcx.hir()
-        }
-
-        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
-            if !self.found {
-                if e.hir_id == self.expr_id {
-                    self.found = true;
-                } else {
-                    walk_expr(self, e);
-                }
-                return;
-            }
-            if self.res.is_break() {
-                return;
-            }
-            if path_to_local_id(e, self.local_id) {
-                self.res = (self.f)(e);
-            } else {
-                walk_expr(self, e);
-            }
-        }
-    }
-
-    if let Some(b) = get_enclosing_block(cx, local_id) {
-        let mut v = V {
-            cx,
-            local_id,
-            expr_id,
-            found: false,
-            res: ControlFlow::Continue(()),
-            f,
-        };
-        v.visit_block(b);
-        v.res
-    } else {
-        ControlFlow::Continue(())
-    }
-}
-
-// Calls the given function for every unconsumed temporary created by the expression. Note the
-// function is only guaranteed to be called for types which need to be dropped, but it may be called
-// for other types.
-#[allow(clippy::too_many_lines)]
-pub fn for_each_unconsumed_temporary<'tcx, B>(
-    cx: &LateContext<'tcx>,
-    e: &'tcx Expr<'tcx>,
-    mut f: impl FnMut(Ty<'tcx>) -> ControlFlow<B>,
-) -> ControlFlow<B> {
-    // Todo: Handle partially consumed values.
-    fn helper<'tcx, B>(
-        typeck: &'tcx TypeckResults<'tcx>,
-        consume: bool,
-        e: &'tcx Expr<'tcx>,
-        f: &mut impl FnMut(Ty<'tcx>) -> ControlFlow<B>,
-    ) -> ControlFlow<B> {
-        if !consume
-            || matches!(
-                typeck.expr_adjustments(e),
-                [adjust, ..] if matches!(adjust.kind, Adjust::Borrow(_) | Adjust::Deref(_))
-            )
-        {
-            match e.kind {
-                ExprKind::Path(QPath::Resolved(None, p))
-                    if matches!(p.res, Res::Def(DefKind::Ctor(_, CtorKind::Const), _)) =>
-                {
-                    f(typeck.expr_ty(e))?;
-                },
-                ExprKind::Path(_)
-                | ExprKind::Unary(UnOp::Deref, _)
-                | ExprKind::Index(..)
-                | ExprKind::Field(..)
-                | ExprKind::AddrOf(..) => (),
-                _ => f(typeck.expr_ty(e))?,
-            }
-        }
-        match e.kind {
-            ExprKind::AddrOf(_, _, e)
-            | ExprKind::Field(e, _)
-            | ExprKind::Unary(UnOp::Deref, e)
-            | ExprKind::Match(e, ..)
-            | ExprKind::Let(&Let { init: e, .. }) => {
-                helper(typeck, false, e, f)?;
-            },
-            ExprKind::Block(&Block { expr: Some(e), .. }, _) | ExprKind::Cast(e, _) | ExprKind::Unary(_, e) => {
-                helper(typeck, true, e, f)?;
-            },
-            ExprKind::Call(callee, args) => {
-                helper(typeck, true, callee, f)?;
-                for arg in args {
-                    helper(typeck, true, arg, f)?;
-                }
-            },
-            ExprKind::MethodCall(_, receiver, args, _) => {
-                helper(typeck, true, receiver, f)?;
-                for arg in args {
-                    helper(typeck, true, arg, f)?;
-                }
-            },
-            ExprKind::Tup(args) | ExprKind::Array(args) => {
-                for arg in args {
-                    helper(typeck, true, arg, f)?;
-                }
-            },
-            ExprKind::Index(borrowed, consumed, _)
-            | ExprKind::Assign(borrowed, consumed, _)
-            | ExprKind::AssignOp(_, borrowed, consumed) => {
-                helper(typeck, false, borrowed, f)?;
-                helper(typeck, true, consumed, f)?;
-            },
-            ExprKind::Binary(_, lhs, rhs) => {
-                helper(typeck, true, lhs, f)?;
-                helper(typeck, true, rhs, f)?;
-            },
-            ExprKind::Struct(_, fields, default) => {
-                for field in fields {
-                    helper(typeck, true, field.expr, f)?;
-                }
-                if let Some(default) = default {
-                    helper(typeck, false, default, f)?;
-                }
-            },
-            ExprKind::If(cond, then, else_expr) => {
-                helper(typeck, true, cond, f)?;
-                helper(typeck, true, then, f)?;
-                if let Some(else_expr) = else_expr {
-                    helper(typeck, true, else_expr, f)?;
-                }
-            },
-            ExprKind::Type(e, _) => {
-                helper(typeck, consume, e, f)?;
-            },
-
-            // Either drops temporaries, jumps out of the current expression, or has no sub expression.
-            ExprKind::DropTemps(_)
-            | ExprKind::Ret(_)
-            | ExprKind::Become(_)
-            | ExprKind::Break(..)
-            | ExprKind::Yield(..)
-            | ExprKind::Block(..)
-            | ExprKind::Loop(..)
-            | ExprKind::Repeat(..)
-            | ExprKind::Lit(_)
-            | ExprKind::ConstBlock(_)
-            | ExprKind::Closure { .. }
-            | ExprKind::Path(_)
-            | ExprKind::Continue(_)
-            | ExprKind::InlineAsm(_)
-            | ExprKind::OffsetOf(..)
-            | ExprKind::Err(_) => (),
-        }
-        ControlFlow::Continue(())
-    }
-    helper(cx.typeck_results(), true, e, &mut f)
-}
-
-pub fn any_temporaries_need_ordered_drop<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'tcx>) -> bool {
-    for_each_unconsumed_temporary(cx, e, |ty| {
-        if needs_ordered_drop(cx, ty) {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_break()
-}
-
-/// Runs the given function for each path expression referencing the given local which occur after
-/// the given expression.
-pub fn for_each_local_assignment<'tcx, B>(
-    cx: &LateContext<'tcx>,
-    local_id: HirId,
-    f: impl FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>,
-) -> ControlFlow<B> {
-    struct V<'cx, 'tcx, F, B> {
-        cx: &'cx LateContext<'tcx>,
-        local_id: HirId,
-        res: ControlFlow<B>,
-        f: F,
-    }
-    impl<'cx, 'tcx, F: FnMut(&'tcx Expr<'tcx>) -> ControlFlow<B>, B> Visitor<'tcx> for V<'cx, 'tcx, F, B> {
-        type NestedFilter = nested_filter::OnlyBodies;
-        fn nested_visit_map(&mut self) -> Self::Map {
-            self.cx.tcx.hir()
-        }
-
-        fn visit_expr(&mut self, e: &'tcx Expr<'tcx>) {
-            if let ExprKind::Assign(lhs, rhs, _) = e.kind
-                && self.res.is_continue()
-                && path_to_local_id(lhs, self.local_id)
-            {
-                self.res = (self.f)(rhs);
-                self.visit_expr(rhs);
-            } else {
-                walk_expr(self, e);
-            }
-        }
-    }
-
-    if let Some(b) = get_enclosing_block(cx, local_id) {
-        let mut v = V {
-            cx,
-            local_id,
-            res: ControlFlow::Continue(()),
-            f,
-        };
-        v.visit_block(b);
-        v.res
-    } else {
-        ControlFlow::Continue(())
-    }
-}
-
-pub fn contains_break_or_continue(expr: &Expr<'_>) -> bool {
-    for_each_expr(expr, |e| {
-        if matches!(e.kind, ExprKind::Break(..) | ExprKind::Continue(..)) {
-            ControlFlow::Break(())
-        } else {
-            ControlFlow::Continue(())
-        }
-    })
-    .is_some()
-}
diff --git a/scout-audit-internal/Cargo.toml b/scout-audit-internal/Cargo.toml
deleted file mode 100644
index 28bae192..00000000
--- a/scout-audit-internal/Cargo.toml
+++ /dev/null
@@ -1,31 +0,0 @@
-[package]
-name = "scout-audit-internal"
-version = "0.2.1"
-edition = "2021"
-authors = [
-    "José García Crosta <jose.garcia.crosta@coinfabrik.com>",
-    "Facundo Lerena <facundo.lerena@coinfabrik.com>",
-    "Agustin Losiggio <agustin.losiggio@coinfabrik.com>",
-    "Matias Cabello <matias.cabello@coinfabrik.com>",
-    "Ariel Waissbein <ariel.waissbein@coinfabrik.com",
-    "Arturo Beccar-Varela <arturo.beccar@coinfabrik.com>",
-]
-license = "MIT"
-description = "Scout is an extensible open-source tool intended to assist soroban smart contract developers and auditors detect common security issues and deviations from best practices."
-homepage = "https://github.com/CoinFabrik/scout-soroban"
-repository = "https://github.com/CoinFabrik/scout-soroban"
-readme = "../README.md"
-keywords = ["auditor", "rust", "security", "soroban", "stellar", "smart-contracts"]
-categories = ["development-tools", "command-line-utilities"]
-
-[features]
-detector = ["dep:strum"]
-lint_helper = [
-    "dep:scout-audit-clippy-utils",
-    "dep:serde_json"
-]
-
-[dependencies]
-strum = { version = "0.25", features = ["derive"], optional = true }
-serde_json = { version = "1.0", optional = true }
-scout-audit-clippy-utils = { version = "=0.2.3",  optional = true }
diff --git a/scout-audit-internal/rust-toolchain b/scout-audit-internal/rust-toolchain
deleted file mode 100644
index bcb80559..00000000
--- a/scout-audit-internal/rust-toolchain
+++ /dev/null
@@ -1,3 +0,0 @@
-[toolchain]
-channel = "nightly-2023-12-16"
-components = ["llvm-tools-preview", "rustc-dev"]
diff --git a/scout-audit-internal/src/detector.rs b/scout-audit-internal/src/detector.rs
deleted file mode 100644
index b6914bed..00000000
--- a/scout-audit-internal/src/detector.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-#[cfg(feature = "lint_helper")]
-extern crate rustc_driver;
-#[cfg(feature = "lint_helper")]
-extern crate rustc_errors;
-#[cfg(feature = "lint_helper")]
-extern crate rustc_lint;
-#[cfg(feature = "lint_helper")]
-extern crate rustc_span;
-
-mod lint_message;
-
-use lint_message::*;
-#[cfg(feature = "lint_helper")]
-use rustc_lint::{Lint, LintContext};
-#[cfg(feature = "lint_helper")]
-use rustc_span::Span;
-#[cfg(feature = "lint_helper")]
-use scout_audit_clippy_utils::diagnostics::{
-    span_lint as span_lint_clippy, span_lint_and_help as span_lint_and_help_clippy,
-};
-#[cfg(feature = "lint_helper")]
-use serde_json::json;
-use strum::{Display, EnumIter};
-
-/// Available detectors.
-#[derive(Debug, Display, Clone, EnumIter, PartialEq, Eq, Hash)]
-#[strum(serialize_all = "kebab-case")]
-pub enum Detector {
-    AvoidCoreMemForget,
-    AvoidPanicError,
-    AvoidUnsafeBlock,
-    DivideBeforeMultiply,
-    DosUnboundedOperation,
-    InsufficientlyRandomValues,
-    OverflowCheck,
-    SetContractStorage,
-    SorobanVersion,
-    UnprotectedUpdateCurrentContractWasm,
-    UnsafeExpect,
-    UnsafeUnwrap,
-    UnusedReturnEnum,
-}
-
-impl Detector {
-    /// Returns the lint message for the detector.
-    pub const fn get_lint_message(&self) -> &'static str {
-        match self {
-            Detector::AvoidCoreMemForget => AVOID_CORE_MEM_FORGET_LINT_MESSAGE,
-            Detector::AvoidPanicError => AVOID_PANIC_ERROR_LINT_MESSAGE,
-            Detector::DivideBeforeMultiply => DIVIDE_BEFORE_MULTIPLY_LINT_MESSAGE,
-            Detector::DosUnboundedOperation => DOS_UNBOUNDED_OPERATION_LINT_MESSAGE,
-            Detector::InsufficientlyRandomValues => INSUFFICIENTLY_RANDOM_VALUES_LINT_MESSAGE,
-            Detector::OverflowCheck => OVERFLOW_CHECK_LINT_MESSAGE,
-            Detector::SetContractStorage => SET_CONTRACT_STORAGE_LINT_MESSAGE,
-            Detector::SorobanVersion => SOROBAN_VERSION_LINT_MESSAGE,
-            Detector::UnprotectedUpdateCurrentContractWasm => {
-                UNPROTECTED_UPDATE_CURRENT_CONTRACT_LINT_MESSAGE
-            }
-            Detector::AvoidUnsafeBlock => AVOID_UNSAFE_BLOCK_LINT_MESSAGE,
-            Detector::UnsafeExpect => UNSAFE_EXPECT_LINT_MESSAGE,
-            Detector::UnsafeUnwrap => UNSAFE_UNWRAP_LINT_MESSAGE,
-            Detector::UnusedReturnEnum => UNUSED_RETURN_ENUM_LINT_MESSAGE,
-        }
-    }
-
-    #[cfg(feature = "lint_helper")]
-    pub fn span_lint_and_help<T: LintContext>(
-        &self,
-        cx: &T,
-        lint: &'static Lint,
-        span: Span,
-        help: &str,
-    ) {
-        print_scout_output(*lint, span);
-        span_lint_and_help_clippy(cx, lint, span, self.get_lint_message(), None, help);
-    }
-
-    #[cfg(feature = "lint_helper")]
-    pub fn span_lint<T: LintContext>(&self, cx: &T, lint: &'static Lint, span: Span) {
-        print_scout_output(*lint, span);
-        span_lint_clippy(cx, lint, span, self.get_lint_message());
-    }
-}
-
-#[cfg(feature = "lint_helper")]
-fn print_scout_output(lint: Lint, span: Span) {
-    let span_debug_string: Vec<String> = format!("{:?}", span)
-        .split(':')
-        .map(|s| s.trim().to_string())
-        .collect();
-
-    let no_span_detectors = ["OVERFLOW_CHECK", "CHECK_SOROBAN_VERSION"];
-
-    if no_span_detectors.contains(&lint.name.to_owned().as_str()) {
-        let span = json!({
-            "physicalLocation": {
-                "artifactLocation": {
-                    "uri": "Cargo.toml",
-                },
-                "region": {
-                    "startLine": 1,
-                    "startColumn": 1,
-                    "endLine": 1,
-                    "endColumn": 1,
-                }
-            }
-        });
-
-        println!("scout-internal:{}@{}", lint.name, span);
-        return;
-    }
-
-    let span = json!({
-        "physicalLocation": {
-            "artifactLocation": {
-                "uri": span_debug_string[0],
-            },
-            "region": {
-                "startLine": span_debug_string[1].parse::<i32>().unwrap(),
-                "startColumn": span_debug_string[2].parse::<i32>().unwrap(),
-                "endLine": span_debug_string[3].parse::<i32>().unwrap(),
-                "endColumn": span_debug_string[4].split(' ').collect::<Vec<&str>>()[0].trim().parse::<i32>().unwrap(),            }
-        }
-    });
-    println!("scout-internal:{}@{}", lint.name, span);
-}
diff --git a/scout-audit-internal/src/detector/lint_message.rs b/scout-audit-internal/src/detector/lint_message.rs
deleted file mode 100644
index 4cf87b5c..00000000
--- a/scout-audit-internal/src/detector/lint_message.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-pub const AVOID_CORE_MEM_FORGET_LINT_MESSAGE: &str =
-    "Use the `let _ = ...` pattern or `.drop()` method to forget the value";
-pub const AVOID_UNSAFE_BLOCK_LINT_MESSAGE: &str =
-    "Avoid using unsafe blocks as it may lead to undefined behavior";
-pub const INSUFFICIENTLY_RANDOM_VALUES_LINT_MESSAGE: &str =
-    "Use env.prng() to generate random numbers, and remember that all random numbers are under the control of validators";
-pub const AVOID_PANIC_ERROR_LINT_MESSAGE: &str = "The panic! macro is used to stop execution when a condition is not met. Even when this does not break the execution of the contract, it is recommended to use Result instead of panic! because it will stop the execution of the caller contract";
-pub const DIVIDE_BEFORE_MULTIPLY_LINT_MESSAGE: &str =
-    "Division before multiplication might result in a loss of precision";
-pub const DOS_UNBOUNDED_OPERATION_LINT_MESSAGE: &str =
-        "In order to prevent a single transaction from consuming all the gas in a block, unbounded operations must be avoided";
-pub const OVERFLOW_CHECK_LINT_MESSAGE: &str = "Use `overflow-checks = true` in Cargo.toml profile";
-pub const SET_CONTRACT_STORAGE_LINT_MESSAGE:&str = "Abitrary users should not have control over keys because it implies writing any value of left mapping, lazy variable, or the main struct of the contract located in position 0 of the storage";
-pub const SOROBAN_VERSION_LINT_MESSAGE: &str = "Use the latest version of Soroban";
-pub const UNPROTECTED_UPDATE_CURRENT_CONTRACT_LINT_MESSAGE: &str =
-    "This update_current_contract_wasm is called without access control";
-pub const UNSAFE_EXPECT_LINT_MESSAGE: &str = "Unsafe usage of `expect`";
-pub const UNSAFE_UNWRAP_LINT_MESSAGE: &str = "Unsafe usage of `unwrap`";
-pub const UNUSED_RETURN_ENUM_LINT_MESSAGE : &str = "If any of the variants (Ok/Err) is not used, the code could be simplified or it could imply a bug";
diff --git a/scout-audit-internal/src/lib.rs b/scout-audit-internal/src/lib.rs
deleted file mode 100644
index 51dd679a..00000000
--- a/scout-audit-internal/src/lib.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-#![cfg_attr(feature = "lint_helper", feature(rustc_private))]
-//! # Scout Audit Internal
-//!
-//! This library is for internal usage only by [`cargo_scout_audit`](https://crates.io/crates/cargo-scout-audit)
-#[cfg(feature = "detector")]
-mod detector;
-
-#[cfg(feature = "detector")]
-pub use detector::Detector;
-#[cfg(feature = "detector")]
-pub use strum::IntoEnumIterator;

From a6a442f4ceb0d27c0b125e4fe1b32cd98f02a8ec Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 11 Apr 2024 11:42:26 -0300
Subject: [PATCH 90/93] Enhance makefile, trigger workflow on scripts/** and
 validate detectors against test-case

---
 .github/workflows/general-rust.yml   |  2 +
 .github/workflows/test-detectors.yml |  2 +
 Makefile                             | 39 ++++----------
 scripts/validate-detectors.py        | 79 ++++++++++++++++++++--------
 4 files changed, 72 insertions(+), 50 deletions(-)

diff --git a/.github/workflows/general-rust.yml b/.github/workflows/general-rust.yml
index 5f858716..896da10b 100644
--- a/.github/workflows/general-rust.yml
+++ b/.github/workflows/general-rust.yml
@@ -7,10 +7,12 @@ on:
     paths:
       - "detectors/**"
       - "test-cases/**"
+      - "scripts/**"
   pull_request:
     paths:
       - "detectors/**"
       - "test-cases/**"
+      - "scripts/**"
 
 env:
   CARGO_TERM_COLOR: always
diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index a5f7be4a..3a5d1945 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -7,10 +7,12 @@ on:
     paths:
       - "detectors/**"
       - "test-cases/**"
+      - "scripts/**"
   pull_request:
     paths:
       - "detectors/**"
       - "test-cases/**"
+      - "scripts/**"
 
 env:
   CARGO_TERM_COLOR: always
diff --git a/Makefile b/Makefile
index 93dbcf2f..7fc9a2a1 100644
--- a/Makefile
+++ b/Makefile
@@ -1,37 +1,20 @@
-ci: fmt lint test
-ci-no-test: fmt lint
+ci: validate fmt lint test
+ci-no-test: validate fmt lint
 
-fmt:
-	@echo "\nFormatting test cases..."
-	@for dir in test-cases/*; do \
-		if [ -d "$$dir" ]; then \
-			python3 scripts/run-fmt.py --dir $$dir; \
-		fi; \
-	done
-	@echo "\nFormatting detectors..."
-	@for dir in detectors/*; do \
-		if [ -d "$$dir" ]; then \
-			python3 scripts/run-fmt.py --dir $$dir; \
-		fi; \
-	done
+validate:
+	@echo "\033[0;32m\n==> Validating the project structure and test cases... \033[0m"
+	@python3 scripts/validate-detectors.py
 
+fmt:
+	@echo "\033[0;32m\n---> Formatting test cases and detectors... \033[0m"
+	@python3 scripts/run-fmt.py --dir test-cases detectors
 
 lint:
-	@echo "\nLinting test cases..."
-	@for dir in test-cases/*; do \
-		if [ -d "$$dir" ]; then \
-			python3 scripts/run-clippy.py --dir $$dir; \
-		fi; \
-	done
-	@echo "\nLinting detectors..."
-	@for dir in detectors/*; do \
-		if [ -d "$$dir" ]; then \
-			python3 scripts/run-clippy.py --dir $$dir; \
-		fi; \
-	done
+	@echo "\033[0;32m\n--> Linting test cases and detectors... \033[0m"
+	@python3 scripts/run-clippy.py --dir test-cases detectors
 
 test:
-	@echo "\nRunning tests for test cases..."
+	@echo "\033[0;32m\n--> Running tests for test cases... \033[0m"
 	@for dir in test-cases/*; do \
 		if [ -d "$$dir" ]; then \
 			detector_name=$$(basename "$$dir"); \
diff --git a/scripts/validate-detectors.py b/scripts/validate-detectors.py
index 16f7de34..3dba4057 100644
--- a/scripts/validate-detectors.py
+++ b/scripts/validate-detectors.py
@@ -1,8 +1,11 @@
 import os
-import sys
 import re
 from fuzzywuzzy import process
 
+RED = "\033[91m"
+GREEN = "\033[92m"
+ENDC = "\033[0m"
+
 
 def is_rust_project(dir_path):
     """Check if a directory contains a Rust project with a Cargo.toml and src/lib.rs."""
@@ -86,36 +89,68 @@ def validate_examples(detector_path, examples):
     return errors
 
 
-def validate_detectors(base_path):
+def validate_detectors(test_cases_path, detectors_path):
     """Validate the structure of the test-cases directory."""
-    all_errors = []
+    errors = []
 
-    for detector in os.listdir(base_path):
-        detector_path = os.path.join(base_path, detector)
-        if detector == "README.md" or not os.path.isdir(detector_path):
-            continue
+    # Directories to ignore while validating
+    ignore_dirs = {"target", ".cargo"}
+
+    test_cases = [
+        tc
+        for tc in os.listdir(test_cases_path)
+        if os.path.isdir(os.path.join(test_cases_path, tc))
+    ]
+
+    for test_case in test_cases:
+        test_case_path = os.path.join(test_cases_path, test_case)
+
+        print(f"Validating {test_case}...")
+
+        # Validate that the detector exists
+        if not os.path.exists(os.path.join(detectors_path, test_case)):
+            errors.append(
+                f"Detector folder missing for {test_case} in {detectors_path}"
+            )
+        else:
+            errors.extend(is_rust_project(os.path.join(detectors_path, test_case)))
 
-        print(f"Validating {detector}...")
-        all_errors.extend(check_for_extra_files(detector_path))
+        # Check for unwanted files in the test case directory
+        errors.extend(check_for_extra_files(test_case_path))
         examples = [
             e
-            for e in os.listdir(detector_path)
-            if os.path.isdir(os.path.join(detector_path, e))
+            for e in os.listdir(test_case_path)
+            if os.path.isdir(os.path.join(test_case_path, e))
         ]
         if not examples:
-            all_errors.append(f"No examples found in {detector}.")
+            errors.append(f"No examples found in {test_case}.")
         else:
-            all_errors.extend(validate_examples(detector_path, examples))
+            # Validate each vulnerable and remediated example
+            errors.extend(validate_examples(test_case_path, examples))
+
+    # Validate that each detector has a test case
+    for detector in os.listdir(detectors_path):
+        if detector in ignore_dirs or not os.path.isdir(
+            os.path.join(detectors_path, detector)
+        ):
+            continue
 
-    if all_errors:
-        print("Validation errors found:")
-        for error in all_errors:
-            print(f"* {error}")
-        sys.exit(1)
-    else:
-        print("No validation errors found.")
+        if detector not in test_cases:
+            errors.append(
+                f"Test case missing for detector {detector} in {test_cases_path}"
+            )
+
+    return errors
 
 
 if __name__ == "__main__":
-    BASE_PATH = "test-cases"
-    validate_detectors(BASE_PATH)
+    TEST_CASES_PATH = "test-cases"
+    DETECTORS_PATH = "detectors"
+    errors = validate_detectors(TEST_CASES_PATH, DETECTORS_PATH)
+    if errors:
+        print(f"{RED}\nValidation errors found:{ENDC}")
+        for error in errors:
+            print(f"* {error}")
+        exit(1)
+    else:
+        print(f"{GREEN}\nAll detectors and test cases are valid.{ENDC}")

From 649d4d1e108d60242102343b50c7a9331619d2ea Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 11 Apr 2024 11:47:20 -0300
Subject: [PATCH 91/93] Checkout again for cache key purposes

---
 .github/workflows/test-detectors.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/.github/workflows/test-detectors.yml b/.github/workflows/test-detectors.yml
index 3a5d1945..39f17dda 100644
--- a/.github/workflows/test-detectors.yml
+++ b/.github/workflows/test-detectors.yml
@@ -50,6 +50,9 @@ jobs:
           - macos-latest
     runs-on: ${{ matrix.os }}
     steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
       - name: Cache cargo dependencies and tool versions
         uses: actions/cache@v4
         with:

From 3b9b34afbf014040048afedd84ce9e92473def40 Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 11 Apr 2024 12:06:13 -0300
Subject: [PATCH 92/93] Remove duplicate print_results function

---
 scripts/utils.py | 20 --------------------
 1 file changed, 20 deletions(-)

diff --git a/scripts/utils.py b/scripts/utils.py
index 25247f87..dcbddbec 100644
--- a/scripts/utils.py
+++ b/scripts/utils.py
@@ -49,26 +49,6 @@ def print_errors(errors):
         print(f"{GREEN}\nNo errors found in the specified directory.{ENDC}")
 
 
-def print_results(
-    returncode,
-    error_message,
-    check_type,
-    root,
-    elapsed_time,
-    issue_type="issues",
-    action_type="check",
-):
-    message_color = RED if returncode != 0 else BLUE
-    print(
-        f"{message_color}[> {elapsed_time:.2f} sec]{ENDC} - Completed {check_type} {action_type} in: {root}."
-    )
-    if returncode != 0:
-        print(f"\n{RED}{check_type.capitalize()} {issue_type} found in: {root}{ENDC}\n")
-        for line in error_message.strip().split("\n"):
-            print(f"| {line}")
-        print("\n")
-
-
 def print_results(returncode, error_message, check_type, root, elapsed_time):
     allowed_check_types = ["clippy", "format", "udeps", "unit-test", "integration-test"]
     if check_type not in allowed_check_types:

From a19cc9c8d7286054cb93f4eb71f25f369530c64d Mon Sep 17 00:00:00 2001
From: Jose Garcia Crosta <jgcrosta@gmail.com>
Date: Thu, 11 Apr 2024 12:28:40 -0300
Subject: [PATCH 93/93] Set cargo fmt to check-mode

---
 scripts/run-fmt.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/scripts/run-fmt.py b/scripts/run-fmt.py
index 83148142..5cfc3ef7 100644
--- a/scripts/run-fmt.py
+++ b/scripts/run-fmt.py
@@ -22,7 +22,7 @@ def run_fmt(directories):
             if "Cargo.toml" in files:
                 start_time = time.time()
                 returncode, _, stderr = run_subprocess(
-                    ["cargo", "fmt", "--all"],
+                    ["cargo", "fmt", "--all", "--check"],
                     cwd=root,
                 )
                 print_results(