feat: add a config option to enable lint on external crate

Author: l0ngvh

clippy_config/src/conf.rs

@@ -609,6 +609,10 @@ define_Conf! {
     /// - Use `".."` as part of the list to indicate that the configured values should be appended to the
     /// default configuration of Clippy. By default, any configuration will replace the default value
     (allowed_prefixes: Vec<String> = DEFAULT_ALLOWED_PREFIXES.iter().map(ToString::to_string).collect()),
+    /// Lint: UNNECESSARY_MIN_OR_MAX.
+    ///
+    /// Whether to also run the lints on external defined consts.
+    (allowed_external_crates: bool = false),
 }
 
 /// Search for the configuration file.

clippy_lints/src/lib.rs

@@ -595,6 +595,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
         ref allowed_duplicate_crates,
         allow_comparison_to_zero,
         ref allowed_prefixes,
+        allowed_external_crates,
 
         blacklisted_names: _,
         cyclomatic_complexity_threshold: _,
@@ -703,6 +704,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
             allow_expect_in_tests,
             allow_unwrap_in_tests,
             allowed_dotfiles.clone(),
+            allowed_external_crates,
         ))
     });
     store.register_late_pass(move |_| Box::new(matches::Matches::new(msrv())));

clippy_lints/src/methods/mod.rs

@@ -4119,6 +4119,7 @@ pub struct Methods {
     allow_expect_in_tests: bool,
     allow_unwrap_in_tests: bool,
     allowed_dotfiles: FxHashSet<String>,
+    allowed_external_crates: bool,
 }
 
 impl Methods {
@@ -4129,6 +4130,7 @@ impl Methods {
         allow_expect_in_tests: bool,
         allow_unwrap_in_tests: bool,
         mut allowed_dotfiles: FxHashSet<String>,
+        allowed_external_crates: bool,
     ) -> Self {
         allowed_dotfiles.extend(DEFAULT_ALLOWED_DOTFILES.iter().map(ToString::to_string));
 
@@ -4138,6 +4140,7 @@ impl Methods {
             allow_expect_in_tests,
             allow_unwrap_in_tests,
             allowed_dotfiles,
+            allowed_external_crates,
         }
     }
 }
@@ -4566,7 +4569,9 @@ impl Methods {
                     Some(("bytes", recv2, [], _, _)) => bytes_count_to_len::check(cx, expr, recv, recv2),
                     _ => {},
                 },
-                ("min" | "max", [arg]) => unnecessary_min_or_max::check(cx, expr, name, recv, arg),
+                ("min" | "max", [arg]) => {
+                    unnecessary_min_or_max::check(cx, expr, name, recv, arg, self.allowed_external_crates)
+                },
                 ("drain", ..) => {
                     if let Node::Stmt(Stmt { hir_id: _, kind, .. }) = cx.tcx.parent_hir_node(expr.hir_id)
                         && matches!(kind, StmtKind::Semi(_))

clippy_lints/src/methods/unnecessary_min_or_max.rs

@@ -4,8 +4,9 @@ use super::UNNECESSARY_MIN_OR_MAX;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 
 use clippy_utils::consts::{constant, Constant, FullInt};
+use clippy_utils::macros::HirNode;
 use clippy_utils::source::snippet;
-use hir::Expr;
+use hir::{Expr, ExprKind};
 
 use rustc_errors::Applicability;
 use rustc_hir as hir;
@@ -14,13 +15,17 @@ use rustc_lint::LateContext;
 use rustc_middle::ty;
 use rustc_span::Span;
 
-pub fn check<'tcx>(
+pub(super) fn check<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'_>,
     name: &str,
     recv: &'tcx Expr<'_>,
     arg: &'tcx Expr<'_>,
+    allowed_external_crates: bool,
 ) {
+    if !allowed_external_crates && (is_external_const(cx, recv) || is_external_const(cx, arg)) {
+        return;
+    }
     let typeck_results = cx.typeck_results();
     if let (Some(left), Some(right)) = (constant(cx, typeck_results, recv), constant(cx, typeck_results, arg)) {
         let Some(ord) = Constant::partial_cmp(cx.tcx, typeck_results.expr_ty(recv), &left, &right) else {
@@ -86,3 +91,14 @@ fn detect_extrema<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Option<
         _ => None,
     }
 }
+
+fn is_external_const<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>) -> bool {
+    let ExprKind::Path(ref qpath) = expr.kind else {
+        return false;
+    };
+
+    let Some(def_id) = cx.qpath_res(qpath, expr.hir_id()).opt_def_id() else {
+        return false;
+    };
+    !def_id.is_local()
+}

tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr

@@ -13,6 +13,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-unwrap-in-tests
            allowed-dotfiles
            allowed-duplicate-crates
+           allowed-external-crates
            allowed-idents-below-min-chars
            allowed-prefixes
            allowed-scripts
@@ -93,6 +94,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-unwrap-in-tests
            allowed-dotfiles
            allowed-duplicate-crates
+           allowed-external-crates
            allowed-idents-below-min-chars
            allowed-prefixes
            allowed-scripts
@@ -173,6 +175,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            allow-unwrap-in-tests
            allowed-dotfiles
            allowed-duplicate-crates
+           allowed-external-crates
            allowed-idents-below-min-chars
            allowed-prefixes
            allowed-scripts

tests/ui-toml/unnecessary_min_or_max/clippy.toml

@@ -0,0 +1 @@
+allowed-external-crates = true

tests/ui-toml/unnecessary_min_or_max/unnecessary_min_or_max.fixed

@@ -0,0 +1,62 @@
+#![allow(unused)]
+#![warn(clippy::unnecessary_min_or_max)]
+fn main() {
+    // Both are Literals
+    let _ = (-6_i32);
+    let _ = 9;
+    let _ = 6;
+    let _ = 9_u32;
+    let _ = 6;
+    let _ = 7_u8;
+
+    let x: i32 = 42;
+    // signed MIN
+    let _ = i32::MIN;
+    let _ = x;
+    let _ = i32::MIN;
+    let _ = x;
+
+    // signed MAX
+    let _ = x;
+    let _ = i32::MAX;
+    let _ = x;
+    let _ = i32::MAX;
+
+    let x: u32 = 42;
+    // unsigned MAX
+    let _ = x;
+    let _ = u32::MAX;
+    let _ = x;
+    let _ = u32::MAX;
+
+    // unsigned MIN
+    let _ = u32::MIN;
+    let _ = x;
+    let _ = u32::MIN;
+    let _ = x;
+
+    // unsigned with zero
+    let _ = 0;
+    let _ = x;
+    let _ = 0_u32;
+    let _ = x;
+
+    let _ = std::f64::consts::E;
+
+    // The below cases shouldn't be lint
+    let mut min = u32::MAX;
+    for _ in 0..1000 {
+        min = min.min(random_u32());
+    }
+
+    const I32_MIN_ISIZE: isize = i32::MIN as isize;
+    let x: isize = 42;
+    let _ = I32_MIN_ISIZE.min(x);
+    let _ = I32_MIN_ISIZE.max(x);
+    let _ = x.min(I32_MIN_ISIZE);
+    let _ = x.max(I32_MIN_ISIZE);
+}
+fn random_u32() -> u32 {
+    // random number generator
+    0
+}

tests/ui-toml/unnecessary_min_or_max/unnecessary_min_or_max.rs

@@ -0,0 +1,62 @@
+#![allow(unused)]
+#![warn(clippy::unnecessary_min_or_max)]
+fn main() {
+    // Both are Literals
+    let _ = (-6_i32).min(9);
+    let _ = (-6_i32).max(9);
+    let _ = 9_u32.min(6);
+    let _ = 9_u32.max(6);
+    let _ = 6.min(7_u8);
+    let _ = 6.max(7_u8);
+
+    let x: i32 = 42;
+    // signed MIN
+    let _ = i32::MIN.min(x);
+    let _ = i32::MIN.max(x);
+    let _ = x.min(i32::MIN);
+    let _ = x.max(i32::MIN);
+
+    // signed MAX
+    let _ = i32::MAX.min(x);
+    let _ = i32::MAX.max(x);
+    let _ = x.min(i32::MAX);
+    let _ = x.max(i32::MAX);
+
+    let x: u32 = 42;
+    // unsigned MAX
+    let _ = u32::MAX.min(x);
+    let _ = u32::MAX.max(x);
+    let _ = x.min(u32::MAX);
+    let _ = x.max(u32::MAX);
+
+    // unsigned MIN
+    let _ = u32::MIN.min(x);
+    let _ = u32::MIN.max(x);
+    let _ = x.min(u32::MIN);
+    let _ = x.max(u32::MIN);
+
+    // unsigned with zero
+    let _ = 0.min(x);
+    let _ = 0.max(x);
+    let _ = x.min(0_u32);
+    let _ = x.max(0_u32);
+
+    let _ = (6.0_f64).min(std::f64::consts::E);
+
+    // The below cases shouldn't be lint
+    let mut min = u32::MAX;
+    for _ in 0..1000 {
+        min = min.min(random_u32());
+    }
+
+    const I32_MIN_ISIZE: isize = i32::MIN as isize;
+    let x: isize = 42;
+    let _ = I32_MIN_ISIZE.min(x);
+    let _ = I32_MIN_ISIZE.max(x);
+    let _ = x.min(I32_MIN_ISIZE);
+    let _ = x.max(I32_MIN_ISIZE);
+}
+fn random_u32() -> u32 {
+    // random number generator
+    0
+}