Fix lints

clippy.toml

@@ -1,4 +1,4 @@
-msrv = "1.70.0"
+msrv = "1.83.0"
 
 disallowed-types = [
     { path = "std::sync::Mutex", reason = "Use the faster & simpler non-poisonable primitives in `parking_lot` instead" },

deny.toml

@@ -28,6 +28,7 @@ deny = [
 ]
 skip = [
     { crate = "[email protected]", reason = "gix uses this old version" },
+    { crate = "[email protected]", reason = "reqwest -> system-configuration uses this old version" },
 ]
 skip-tree = [
     { crate = "[email protected]", reason = "a foundational crate for many that bumps far too frequently to ever have a shared version" },
@@ -53,7 +54,6 @@ allow = [
 exceptions = [
     # Use exceptions for these as they only have a single user
     { allow = ["Zlib"], crate = "tinyvec" },
-    { allow = ["Unicode-DFS-2016"], crate = "unicode-ident" },
     { allow = ["OpenSSL"], crate = "ring" },
 ]
 

src/advisories/diags.rs

@@ -66,7 +66,7 @@ fn get_notes_from_advisory(advisory: &Metadata) -> Vec<String> {
     n
 }
 
-impl<'a> crate::CheckCtx<'a, super::cfg::ValidConfig> {
+impl crate::CheckCtx<'_, super::cfg::ValidConfig> {
     pub(crate) fn diag_for_advisory<F>(
         &self,
         krate: &crate::Krate,

src/bans/diags.rs

@@ -541,7 +541,7 @@ pub(crate) struct HomePath<'a> {
     pub(crate) home: Option<&'a crate::Path>,
 }
 
-impl<'a> fmt::Display for HomePath<'a> {
+impl fmt::Display for HomePath<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         if let Some(rel_path) = self.home.and_then(|home| self.path.strip_prefix(home).ok()) {
             f.write_str("$CARGO_HOME/")?;

src/bans/graph.rs

@@ -24,13 +24,13 @@ impl<'a, 'b: 'a> From<&'b Krate> for Node<'a> {
     }
 }
 
-impl<'a> fmt::Debug for Node<'a> {
+impl fmt::Debug for Node<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}({})", self.name, self.version)
     }
 }
 
-impl<'a> fmt::Display for Node<'a> {
+impl fmt::Display for Node<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}({})", self.name, self.version)
     }
@@ -60,7 +60,7 @@ struct NodeAttributes<'a> {
     fill_color: Option<&'static str>,
 }
 
-impl<'a> NodeAttributes<'a> {
+impl NodeAttributes<'_> {
     fn has_attrs(&self) -> bool {
         self.label.is_some()
             || self.shape.is_some()

src/cargo-deny/common.rs

@@ -348,7 +348,7 @@ enum OutputFormat<'a> {
 }
 
 impl<'a> OutputFormat<'a> {
-    fn lock(&'a self, max_severity: Severity) -> OutputLock<'a, '_> {
+    fn lock(&'a self, max_severity: Severity) -> OutputLock<'a, 'a> {
         match self {
             Self::Human(human) => OutputLock::Human(
                 human,
@@ -366,7 +366,7 @@ pub enum StdLock<'a> {
     //Out(std::io::StdoutLock<'a>),
 }
 
-impl<'a> Write for StdLock<'a> {
+impl Write for StdLock<'_> {
     fn write(&mut self, d: &[u8]) -> std::io::Result<usize> {
         match self {
             Self::Err(stderr) => stderr.write(d),
@@ -392,7 +392,7 @@ pub enum OutputLock<'a, 'b> {
     Json(&'a Json<'a>, Severity, StdLock<'b>),
 }
 
-impl<'a, 'b> OutputLock<'a, 'b> {
+impl OutputLock<'_, '_> {
     pub fn print(&mut self, diag: CsDiag, files: &Files) {
         match self {
             Self::Human(cfg, max, l, _) => {
@@ -525,7 +525,7 @@ impl<'a> DiagPrinter<'a> {
     }
 
     #[inline]
-    pub fn lock(&'a self) -> OutputLock<'a, '_> {
+    pub fn lock(&'a self) -> OutputLock<'a, 'a> {
         self.which.lock(self.max_severity)
     }
 }

src/cargo-deny/list.rs

@@ -78,7 +78,7 @@ pub fn cmd(
     #[derive(Ord, PartialOrd, PartialEq, Eq)]
     struct SerKid<'k>(Cow<'k, Kid>);
 
-    impl<'k> serde::Serialize for SerKid<'k> {
+    impl serde::Serialize for SerKid<'_> {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: serde::Serializer,
@@ -92,7 +92,7 @@ pub fn cmd(
         }
     }
 
-    impl<'k> SerKid<'k> {
+    impl SerKid<'_> {
         fn parts(&self) -> (&str, &str) {
             (self.0.name(), self.0.version())
         }

src/cfg.rs

@@ -10,7 +10,7 @@ pub struct ValidationContext<'ctx> {
     pub diagnostics: &'ctx mut Vec<diag::Diagnostic>,
 }
 
-impl<'ctx> ValidationContext<'ctx> {
+impl ValidationContext<'_> {
     #[inline]
     pub fn push(&mut self, diag: diag::Diagnostic) {
         self.diagnostics.push(diag);

src/diag.rs

@@ -161,7 +161,7 @@ impl<'f> codespan_reporting::files::Files<'f> for Files {
         let start = *file
             .line_starts
             .get(line_index)
-            .ok_or_else(|| FilesErr::LineTooLarge {
+            .ok_or(FilesErr::LineTooLarge {
                 given: line_index,
                 max: file.line_starts.len(),
             })?;

src/diag/krate_spans.rs

@@ -637,12 +637,11 @@ fn read_workspace_deps<'k>(
                         name,
                     ) {
                         Ok(url) => url::Url::parse(url.as_str())
-                            .map_err(|err| {
+                            .inspect_err(|err| {
                                 log::warn!(
                                     "unable to parse url '{}' for registry '{name}': {err}",
                                     url.as_str()
                                 );
-                                err
                             })
                             .ok(),
                         Err(err) => {

src/licenses/gather.rs

@@ -393,7 +393,7 @@ pub struct Summary<'a> {
     pub nfos: Vec<KrateLicense<'a>>,
 }
 
-impl<'a> Summary<'a> {
+impl Summary<'_> {
     fn new(store: Arc<LicenseStore>) -> Self {
         Self {
             store,

tests/licenses.rs

@@ -3,20 +3,15 @@ use cargo_deny::{
     licenses::{self, cfg::Config},
     test_utils as tu, Krates,
 };
-use parking_lot::Once;
-use std::sync::Arc;
+use std::sync::{Arc, OnceLock};
 
-static mut STORE: Option<Arc<licenses::LicenseStore>> = None;
-static INIT: Once = Once::new();
+static STORE: OnceLock<Arc<licenses::LicenseStore>> = OnceLock::new();
 
+#[inline]
 fn store() -> Arc<licenses::LicenseStore> {
-    #[allow(unsafe_code)]
-    unsafe {
-        INIT.call_once(|| {
-            STORE = Some(Arc::new(licenses::LicenseStore::from_cache().unwrap()));
-        });
-        STORE.as_ref().unwrap().clone()
-    }
+    STORE
+        .get_or_init(|| Arc::new(licenses::LicenseStore::from_cache().unwrap()))
+        .clone()
 }
 
 fn setup<'k>(