support more constants

Author: relaxcn

clippy_lints/src/declared_lints.rs

@@ -260,7 +260,6 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::literal_representation::UNREADABLE_LITERAL_INFO,
     crate::literal_representation::UNUSUAL_BYTE_GROUPINGS_INFO,
     crate::literal_string_with_formatting_args::LITERAL_STRING_WITH_FORMATTING_ARGS_INFO,
-    crate::localhost_hardcode::LOCALHOST_HARDCODE_INFO,
     crate::loops::CHAR_INDICES_AS_BYTE_INDICES_INFO,
     crate::loops::EMPTY_LOOP_INFO,
     crate::loops::EXPLICIT_COUNTER_LOOP_INFO,
@@ -398,6 +397,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::methods::ITER_SKIP_ZERO_INFO,
     crate::methods::ITER_WITH_DRAIN_INFO,
     crate::methods::JOIN_ABSOLUTE_PATHS_INFO,
+    crate::methods::LOCALHOST_HARDCODE_INFO,
     crate::methods::MANUAL_CONTAINS_INFO,
     crate::methods::MANUAL_C_STR_LITERALS_INFO,
     crate::methods::MANUAL_FILTER_MAP_INFO,

clippy_lints/src/lib.rs

@@ -199,7 +199,6 @@ mod lifetimes;
 mod lines_filter_map_ok;
 mod literal_representation;
 mod literal_string_with_formatting_args;
-mod localhost_hardcode;
 mod loops;
 mod macro_metavars_in_unsafe;
 mod macro_use;
@@ -947,6 +946,5 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(single_option_map::SingleOptionMap));
     store.register_late_pass(move |_| Box::new(redundant_test_prefix::RedundantTestPrefix));
     store.register_late_pass(|_| Box::new(cloned_ref_to_slice_refs::ClonedRefToSliceRefs::new(conf)));
-    store.register_late_pass(|_| Box::new(localhost_hardcode::LocalhostHardcode));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }

clippy_lints/src/localhost_hardcode.rs

@@ -0,0 +1,75 @@
+use clippy_utils::consts::{ConstEvalCtxt, Constant};
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, QPath, Ty, TyKind};
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+use super::LOCALHOST_HARDCODE;
+
+static IPV4V6_CONSTANTS: &[(&[u128], &str)] = &[
+    // Ipv4
+    (&[127, 0, 0, 1], "LOCALHOST"),
+    (&[255, 255, 255, 255], "BROADCAST"),
+    (&[0, 0, 0, 0], "UNSPECIFIED"),
+    // Ipv6
+    (&[0, 0, 0, 0, 0, 0, 0, 1], "LOCALHOST"),
+    (&[0, 0, 0, 0, 0, 0, 0, 0], "UNSPECIFIED"),
+];
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args: &[Expr<'_>]) {
+    if let ExprKind::Path(QPath::TypeRelative(
+        Ty {
+            kind: TyKind::Path(QPath::Resolved(_, func_path)),
+            ..
+        },
+        p,
+    )) = func.kind
+        && p.ident.as_str() == "new"
+        && let Some(func_def_id) = func_path.res.opt_def_id()
+        && (cx.tcx.is_diagnostic_item(sym::Ipv4Addr, func_def_id)
+            || cx.tcx.is_diagnostic_item(sym::Ipv6Addr, func_def_id))
+        && let Some(constant_name) = is_hardcoded_ipv4v6_constant(cx, args)
+    {
+        let sugg_snip = format!(
+            "{}::{}",
+            snippet(cx, func_path.span, cx.tcx.def_path_str(func_def_id).as_str()),
+            constant_name
+        );
+
+        span_lint_and_sugg(
+            cx,
+            LOCALHOST_HARDCODE,
+            expr.span,
+            format!("use `{sugg_snip}` instead"),
+            "try",
+            sugg_snip,
+            Applicability::MachineApplicable,
+        );
+    }
+}
+
+fn is_hardcoded_ipv4v6_constant(cx: &LateContext<'_>, args: &[Expr<'_>]) -> Option<&'static str> {
+    if args.len() != 4 && args.len() != 8 {
+        return None;
+    }
+
+    // Extract integer constants from arguments
+    let mut constants = Vec::new();
+    for arg in args {
+        if let Some(Constant::Int(constant)) = ConstEvalCtxt::new(cx).eval(arg) {
+            constants.push(constant);
+        } else {
+            return None;
+        }
+    }
+    // Check against known IP constants
+    for (pattern, name) in IPV4V6_CONSTANTS {
+        if pattern.len() == constants.len() && pattern.iter().eq(constants.iter()) {
+            return Some(name);
+        }
+    }
+
+    None
+}

clippy_lints/src/methods/localhost_hardcode.rs

@@ -54,6 +54,7 @@ mod iter_skip_zero;
 mod iter_with_drain;
 mod iterator_step_by_zero;
 mod join_absolute_paths;
+mod localhost_hardcode;
 mod manual_c_str_literals;
 mod manual_contains;
 mod manual_inspect;
@@ -4528,6 +4529,30 @@ declare_clippy_lint! {
     "detect swap with a temporary value"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Detects hardcoded localhost IP addresses using `Ipv4Addr::new(127, 0, 0, 1)`.
+    ///
+    /// ### Why is this bad?
+    /// Using a hardcoded IP address `(127.0.0.1)` is less clear and maintainable than using the
+    /// `Ipv4Addr::LOCALHOST` constant.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// use std::net::Ipv4Addr;
+    /// let addr = Ipv4Addr::new(127, 0, 0, 1);
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// use std::net::Ipv4Addr;
+    /// let addr = Ipv4Addr::LOCALHOST;
+    /// ```
+    #[clippy::version = "1.89.0"]
+    pub LOCALHOST_HARDCODE,
+    style,
+    "hardcoded localhost IP address"
+}
+
 #[expect(clippy::struct_excessive_bools)]
 pub struct Methods {
     avoid_breaking_exported_api: bool,
@@ -4706,6 +4731,7 @@ impl_lint_pass!(Methods => [
     MANUAL_CONTAINS,
     IO_OTHER_ERROR,
     SWAP_WITH_TEMPORARY,
+    LOCALHOST_HARDCODE,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4738,6 +4764,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 useless_nonzero_new_unchecked::check(cx, expr, func, args, self.msrv);
                 io_other_error::check(cx, expr, func, args, self.msrv);
                 swap_with_temporary::check(cx, expr, func, args);
+                localhost_hardcode::check(cx, expr, func, args);
             },
             ExprKind::MethodCall(method_call, receiver, args, _) => {
                 let method_span = method_call.ident.span;

clippy_lints/src/methods/mod.rs

@@ -1,63 +1,112 @@
 #![warn(clippy::localhost_hardcode)]
 #![allow(dead_code)]
+#![allow(clippy::identity_op)]
+#![allow(clippy::eq_op)]
 
 fn literal_test1() {
     use std::net::Ipv4Addr;
     let _ = Ipv4Addr::LOCALHOST;
     //~^ localhost_hardcode
+    let _ = Ipv4Addr::BROADCAST;
+    //~^ localhost_hardcode
+    let _ = Ipv4Addr::UNSPECIFIED;
+    //~^ localhost_hardcode
+
+    use std::net::Ipv6Addr;
+    let _ = Ipv6Addr::LOCALHOST;
+    //~^ localhost_hardcode
+    let _ = Ipv6Addr::UNSPECIFIED;
+    //~^ localhost_hardcode
 }
 
 fn literal_test2() {
     use std::net;
     let _ = net::Ipv4Addr::LOCALHOST;
     //~^ localhost_hardcode
+    let _ = net::Ipv4Addr::BROADCAST;
+    //~^ localhost_hardcode
+    let _ = net::Ipv4Addr::UNSPECIFIED;
+    //~^ localhost_hardcode
+
+    let _ = net::Ipv6Addr::LOCALHOST;
+    //~^ localhost_hardcode
+    let _ = net::Ipv6Addr::UNSPECIFIED;
+    //~^ localhost_hardcode
 }
 
 fn literal_test3() {
     let _ = std::net::Ipv4Addr::LOCALHOST;
     //~^ localhost_hardcode
+    let _ = std::net::Ipv4Addr::BROADCAST;
+    //~^ localhost_hardcode
+    let _ = std::net::Ipv4Addr::UNSPECIFIED;
+    //~^ localhost_hardcode
+
+    let _ = std::net::Ipv6Addr::LOCALHOST;
+    //~^ localhost_hardcode
+    let _ = std::net::Ipv6Addr::UNSPECIFIED;
+    //~^ localhost_hardcode
 }
 
-const CONSTANT_1: u8 = 127;
-const CONSTANT_2: u8 = 0;
-const CONSTANT_3: u8 = 0;
-const CONSTANT_4: u8 = 1;
+const CONST_U8_0: u8 = 0;
+const CONST_U8_1: u8 = 1;
+const CONST_U8_127: u8 = 127;
+const CONST_U8_255: u8 = 255;
+
+const CONST_U16_0: u16 = 0;
+const CONST_U16_1: u16 = 1;
 
 fn const_test1() {
     use std::net::Ipv4Addr;
     let _ = Ipv4Addr::LOCALHOST;
     //~^ localhost_hardcode
-}
-
-fn const_test2() {
-    use std::net;
-    let _ = net::Ipv4Addr::LOCALHOST;
+    let _ = Ipv4Addr::BROADCAST;
     //~^ localhost_hardcode
-}
-
-fn const_test3() {
-    let _ = std::net::Ipv4Addr::LOCALHOST;
+    let _ = Ipv4Addr::UNSPECIFIED;
     //~^ localhost_hardcode
+
+    use std::net::Ipv6Addr;
+    let _ = Ipv6Addr::LOCALHOST;
+
+    let _ = Ipv6Addr::UNSPECIFIED;
 }
 
-fn const_test4() {
+fn const_test2() {
     use std::net::Ipv4Addr;
     let _ = Ipv4Addr::LOCALHOST;
     //~^ localhost_hardcode
-    let _ = Ipv4Addr::LOCALHOST;
+    let _ = Ipv4Addr::BROADCAST;
     //~^ localhost_hardcode
-    let _ = Ipv4Addr::LOCALHOST;
+    let _ = Ipv4Addr::UNSPECIFIED;
     //~^ localhost_hardcode
-    let _ = Ipv4Addr::LOCALHOST;
+
+    use std::net::Ipv6Addr;
+    let _ = Ipv6Addr::LOCALHOST;
+    //~^ localhost_hardcode
+    let _ = Ipv6Addr::LOCALHOST;
     //~^ localhost_hardcode
 }
 
+macro_rules! ipv4_new {
+    ($a:expr, $b:expr, $c:expr, $d:expr) => {
+        std::net::Ipv4Addr::new($a, $b, $c, $d)
+    };
+}
+
+fn macro_test() {
+    let _ = ipv4_new!(127, 0, 0, 1);
+    // no lint
+    let _ = ipv4_new!(255, 255, 255, 255);
+    // no lint
+    let _ = ipv4_new!(0, 0, 0, 0);
+    // no lint
+}
+
 fn main() {
     literal_test1();
     literal_test2();
     literal_test3();
     const_test1();
     const_test2();
-    const_test3();
-    const_test4();
+    macro_test();
 }