Use two structs rather than a const generic

smoelius · smoelius · commit fef10d42a330 · 2024-12-18T19:13:10.000-05:00
diff --git a/clippy_config/src/conf.rs b/clippy_config/src/conf.rs
@@ -1,8 +1,8 @@
 use crate::ClippyConfiguration;
 use crate::types::{
-    DisallowedPath, MacroMatcher, MatchLintBehaviour, PubUnderscoreFieldsBehaviour, Rename, SourceItemOrdering,
-    SourceItemOrderingCategory, SourceItemOrderingModuleItemGroupings, SourceItemOrderingModuleItemKind,
-    SourceItemOrderingTraitAssocItemKind, SourceItemOrderingTraitAssocItemKinds,
+    DisallowedPath, DisallowedPathWithoutReplacement, MacroMatcher, MatchLintBehaviour, PubUnderscoreFieldsBehaviour,
+    Rename, SourceItemOrdering, SourceItemOrderingCategory, SourceItemOrderingModuleItemGroupings,
+    SourceItemOrderingModuleItemKind, SourceItemOrderingTraitAssocItemKind, SourceItemOrderingTraitAssocItemKinds,
 };
 use clippy_utils::msrvs::Msrv;
 use rustc_errors::Applicability;
@@ -445,7 +445,7 @@ define_Conf! {
     avoid_breaking_exported_api: bool = true,
     /// The list of types which may not be held across an await point.
     #[lints(await_holding_invalid_type)]
-    await_holding_invalid_types: Vec<DisallowedPath<false>> = Vec::new(),
+    await_holding_invalid_types: Vec<DisallowedPathWithoutReplacement> = Vec::new(),
     /// DEPRECATED LINT: BLACKLISTED_NAME.
     ///
     /// Use the Disallowed Names lint instead
diff --git a/clippy_config/src/types.rs b/clippy_config/src/types.rs
@@ -15,21 +15,40 @@ pub struct Rename {
 }
 
 #[derive(Debug, Serialize)]
-pub struct DisallowedPath<const REPLACEMENT_ALLOWED: bool = true> {
+pub struct DisallowedPathWithoutReplacement {
+    path: String,
+    reason: Option<String>,
+}
+
+#[derive(Clone, Debug, Serialize)]
+pub struct DisallowedPath {
     path: String,
     reason: Option<String>,
     replacement: Option<String>,
 }
 
-impl<'de, const REPLACEMENT_ALLOWED: bool> Deserialize<'de> for DisallowedPath<REPLACEMENT_ALLOWED> {
+impl<'de> Deserialize<'de> for DisallowedPathWithoutReplacement {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>,
     {
         let enum_ = DisallowedPathEnum::deserialize(deserializer)?;
-        if !REPLACEMENT_ALLOWED && enum_.replacement().is_some() {
+        if enum_.replacement().is_some() {
             return Err(de::Error::custom("replacement not allowed for this configuration"));
         }
+        Ok(Self {
+            path: enum_.path().to_owned(),
+            reason: enum_.reason().map(ToOwned::to_owned),
+        })
+    }
+}
+
+impl<'de> Deserialize<'de> for DisallowedPath {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let enum_ = DisallowedPathEnum::deserialize(deserializer)?;
         Ok(Self {
             path: enum_.path().to_owned(),
             reason: enum_.reason().map(ToOwned::to_owned),
@@ -49,24 +68,45 @@ pub enum DisallowedPathEnum {
     },
 }
 
-impl<const REPLACEMENT_ALLOWED: bool> DisallowedPath<REPLACEMENT_ALLOWED> {
-    pub fn path(&self) -> &str {
+pub trait AmendDiag {
+    fn path(&self) -> &str;
+    fn reason(&self) -> Option<&str>;
+    fn replacement(&self) -> Option<&str>;
+    fn amend_diag(&self, span: Span, diag: &mut Diag<'_, ()>) {
+        if let Some(replacement) = &self.replacement() {
+            diag.span_suggestion(
+                span,
+                self.reason().map_or_else(|| String::from("use"), ToOwned::to_owned),
+                replacement,
+                Applicability::MachineApplicable,
+            );
+        } else if let Some(reason) = self.reason() {
+            diag.note(reason.to_owned());
+        }
+    }
+}
+
+impl AmendDiag for DisallowedPathWithoutReplacement {
+    fn path(&self) -> &str {
         &self.path
     }
+    fn reason(&self) -> Option<&str> {
+        self.reason.as_deref()
+    }
+    fn replacement(&self) -> Option<&str> {
+        None
+    }
+}
 
-    pub fn diag_amendment(&self, span: Span) -> impl FnOnce(&mut Diag<'_, ()>) + use<'_, REPLACEMENT_ALLOWED> {
-        move |diag| {
-            if let Some(replacement) = &self.replacement {
-                diag.span_suggestion(
-                    span,
-                    self.reason.as_ref().map_or_else(|| String::from("use"), Clone::clone),
-                    replacement,
-                    Applicability::MachineApplicable,
-                );
-            } else if let Some(reason) = &self.reason {
-                diag.note(reason.clone());
-            }
-        }
+impl AmendDiag for DisallowedPath {
+    fn path(&self) -> &str {
+        &self.path
+    }
+    fn reason(&self) -> Option<&str> {
+        self.reason.as_deref()
+    }
+    fn replacement(&self) -> Option<&str> {
+        self.replacement.as_deref()
     }
 }
 
@@ -93,10 +133,10 @@ impl DisallowedPathEnum {
 }
 
 /// Creates a map of disallowed items to the reason they were disallowed.
-pub fn create_disallowed_map<const REPLACEMENT_ALLOWED: bool>(
+pub fn create_disallowed_map<T: AmendDiag>(
     tcx: TyCtxt<'_>,
-    disallowed: &'static [DisallowedPath<REPLACEMENT_ALLOWED>],
-) -> DefIdMap<(&'static str, &'static DisallowedPath<REPLACEMENT_ALLOWED>)> {
+    disallowed: &'static [T],
+) -> DefIdMap<(&'static str, &'static T)> {
     disallowed
         .iter()
         .map(|x| (x.path(), x.path().split("::").collect::<Vec<_>>(), x))
diff --git a/clippy_lints/src/await_holding_invalid.rs b/clippy_lints/src/await_holding_invalid.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_config::types::{DisallowedPath, create_disallowed_map};
+use clippy_config::types::{AmendDiag, DisallowedPathWithoutReplacement, create_disallowed_map};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
 use rustc_hir as hir;
@@ -174,7 +174,7 @@ declare_clippy_lint! {
 impl_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF, AWAIT_HOLDING_INVALID_TYPE]);
 
 pub struct AwaitHolding {
-    def_ids: DefIdMap<(&'static str, &'static DisallowedPath<false>)>,
+    def_ids: DefIdMap<(&'static str, &'static DisallowedPathWithoutReplacement)>,
 }
 
 impl AwaitHolding {
@@ -259,14 +259,14 @@ fn emit_invalid_type(
     cx: &LateContext<'_>,
     span: Span,
     path: &'static str,
-    disallowed_path: &'static DisallowedPath<false>,
+    disallowed_path: &'static DisallowedPathWithoutReplacement,
 ) {
     span_lint_and_then(
         cx,
         AWAIT_HOLDING_INVALID_TYPE,
         span,
         format!("holding a disallowed type across an await point `{path}`"),
-        disallowed_path.diag_amendment(span),
+        |diag| disallowed_path.amend_diag(span, diag),
     );
 }
 
diff --git a/clippy_lints/src/disallowed_macros.rs b/clippy_lints/src/disallowed_macros.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_config::types::{DisallowedPath, create_disallowed_map};
+use clippy_config::types::{AmendDiag, DisallowedPath, create_disallowed_map};
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::macros::macro_backtrace;
 use rustc_data_structures::fx::FxHashSet;
@@ -92,7 +92,6 @@ impl DisallowedMacros {
 
             if let Some(&(path, disallowed_path)) = self.disallowed.get(&mac.def_id) {
                 let msg = format!("use of a disallowed macro `{path}`");
-                let add_note = disallowed_path.diag_amendment(mac.span);
                 if matches!(mac.kind, MacroKind::Derive)
                     && let Some(derive_src) = derive_src
                 {
@@ -102,10 +101,12 @@ impl DisallowedMacros {
                         cx.tcx.local_def_id_to_hir_id(derive_src.def_id),
                         mac.span,
                         msg,
-                        add_note,
+                        |diag| disallowed_path.amend_diag(mac.span, diag),
                     );
                 } else {
-                    span_lint_and_then(cx, DISALLOWED_MACROS, mac.span, msg, add_note);
+                    span_lint_and_then(cx, DISALLOWED_MACROS, mac.span, msg, |diag| {
+                        disallowed_path.amend_diag(mac.span, diag);
+                    });
                 }
             }
         }
diff --git a/clippy_lints/src/disallowed_methods.rs b/clippy_lints/src/disallowed_methods.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_config::types::{DisallowedPath, create_disallowed_map};
+use clippy_config::types::{AmendDiag, DisallowedPath, create_disallowed_map};
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::DefIdMap;
@@ -93,7 +93,7 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
                 DISALLOWED_METHODS,
                 span,
                 format!("use of a disallowed method `{path}`"),
-                disallowed_path.diag_amendment(span),
+                |diag| disallowed_path.amend_diag(span, diag),
             );
         }
     }
diff --git a/clippy_lints/src/disallowed_types.rs b/clippy_lints/src/disallowed_types.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_config::types::DisallowedPath;
+use clippy_config::types::{AmendDiag, DisallowedPath};
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::Res;
@@ -89,7 +89,7 @@ impl DisallowedTypes {
             DISALLOWED_TYPES,
             span,
             format!("use of a disallowed type `{path}`"),
-            disallowed_path.diag_amendment(span),
+            |diag| disallowed_path.amend_diag(span, diag),
         );
     }
 }
