Optimizing the code and modify the error message

Author: relaxcn

clippy_lints/src/lib.rs

@@ -55,6 +55,7 @@ extern crate rustc_session;
 extern crate rustc_span;
 extern crate rustc_target;
 extern crate rustc_trait_selection;
+extern crate smallvec;
 extern crate thin_vec;
 
 #[macro_use]

clippy_lints/src/methods/ip_constant.rs

@@ -1,10 +1,10 @@
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
+use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath, Ty, TyKind};
 use rustc_lint::LateContext;
 use rustc_span::sym;
+use smallvec::SmallVec;
 
 use super::IP_CONSTANT;
 
@@ -16,109 +16,37 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args
         },
         p,
     )) = func.kind
-        && p.ident.as_str() == "new"
+        && p.ident.name == sym::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_ipaddr_constants(cx, args)
+        && matches!(
+            cx.tcx.get_diagnostic_name(func_def_id),
+            Some(sym::Ipv4Addr | sym::Ipv6Addr)
+        )
+        && let Some(args) = args
+            .iter()
+            .map(|arg| {
+                if let Some(Constant::Int(constant @ (0 | 1 | 127 | 255))) = ConstEvalCtxt::new(cx).eval(arg) {
+                    u8::try_from(constant).ok()
+                } else {
+                    None
+                }
+            })
+            .collect::<Option<SmallVec<[u8; 8]>>>()
     {
-        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,
-            IP_CONSTANT,
-            expr.span,
-            format!("use `{sugg_snip}` instead"),
-            "try",
-            sugg_snip,
-            Applicability::MachineApplicable,
-        );
+        let constant_name = match args.as_slice() {
+            [0, 0, 0, 0] | [0, 0, 0, 0, 0, 0, 0, 0] => "UNSPECIFIED",
+            [127, 0, 0, 1] | [0, 0, 0, 0, 0, 0, 0, 1] => "LOCALHOST",
+            [255, 255, 255, 255] => "BROADCAST",
+            _ => return,
+        };
+
+        span_lint_and_then(cx, IP_CONSTANT, expr.span, "hand-coded well-known IP address", |diag| {
+            diag.span_suggestion_verbose(
+                expr.span.with_lo(p.ident.span.lo()),
+                "use",
+                constant_name,
+                Applicability::MachineApplicable,
+            );
+        });
     }
 }
-
-struct Node {
-    children: &'static [(u128, Node)],
-    constant_name: Option<&'static str>,
-}
-
-impl Node {
-    const fn new(children: &'static [(u128, Node)], constant_name: Option<&'static str>) -> Self {
-        Self {
-            children,
-            constant_name,
-        }
-    }
-
-    const fn leaf(constant_name: &'static str) -> Self {
-        Self {
-            children: &[],
-            constant_name: Some(constant_name),
-        }
-    }
-}
-
-// Tree structure for IP constants
-#[rustfmt::skip]
-static IPADDR_CONSTANTS_TREE: Node = Node::new(&[
-    (127, Node::new(&[
-        (0, Node::new(&[
-            (0, Node::new(&[
-                (1, Node::leaf("LOCALHOST")) // IPv4 127.0.0.1
-            ], None))
-        ], None))
-    ], None)),
-    (255, Node::new(&[
-        (255, Node::new(&[
-            (255, Node::new(&[
-                (255, Node::leaf("BROADCAST")) // IPv4 255.255.255.255
-            ], None))
-        ], None))
-    ], None)),
-    (0, Node::new(&[
-        (0, Node::new(&[
-            (0, Node::new(&[
-                (0, Node::new(&[
-                    (0, Node::new(&[
-                        (0, Node::new(&[
-                            (0, Node::new(&[
-                                (0, Node::leaf("UNSPECIFIED")), // IPv6 ::
-                                (1, Node::leaf("LOCALHOST"))    // IPv6 ::1
-                            ], None))
-                        ], None))
-                    ], None))
-                ], Some("UNSPECIFIED"))) // IPv4 0.0.0.0
-            ], None))
-        ], None))
-    ], None)),
-], None);
-
-fn is_ipaddr_constants(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;
-        }
-    }
-
-    let mut current_node = &IPADDR_CONSTANTS_TREE;
-    for value in constants {
-        if let Some((_, next_node)) = current_node.children.iter().find(|(val, _)| *val == value) {
-            current_node = next_node;
-        } else {
-            return None; // Early termination on mismatch
-        }
-    }
-
-    current_node.constant_name
-}