New lint: [duplicate_map_keys]

CHANGELOG.md

@@ -5290,6 +5290,7 @@ Released 2018-09-13
 [`get_first`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_first
 [`get_last_with_len`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_last_with_len
 [`get_unwrap`]: https://rust-lang.github.io/rust-clippy/master/index.html#get_unwrap
+[`hash_collision`]: https://rust-lang.github.io/rust-clippy/master/index.html#hash_collision
 [`host_endian_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#host_endian_bytes
 [`identity_conversion`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_conversion
 [`identity_op`]: https://rust-lang.github.io/rust-clippy/master/index.html#identity_op

clippy_lints/src/declared_lints.rs

@@ -210,6 +210,7 @@ pub(crate) static LINTS: &[&crate::LintInfo] = &[
     crate::functions::TOO_MANY_ARGUMENTS_INFO,
     crate::functions::TOO_MANY_LINES_INFO,
     crate::future_not_send::FUTURE_NOT_SEND_INFO,
+    crate::hash_collision::HASH_COLLISION_INFO,
     crate::if_let_mutex::IF_LET_MUTEX_INFO,
     crate::if_not_else::IF_NOT_ELSE_INFO,
     crate::if_then_some_else_none::IF_THEN_SOME_ELSE_NONE_INFO,

clippy_lints/src/hash_collision.rs

@@ -0,0 +1,91 @@
+use clippy_utils::diagnostics::span_lint_and_note;
+use clippy_utils::last_path_segment;
+use clippy_utils::ty::is_type_diagnostic_item;
+use rustc_hir::ExprKind;
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::symbol::sym;
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// When two items are inserted into a `HashMap` with the same key,
+    /// the second item will overwrite the first item.
+    ///
+    /// ### Why is this bad?
+    /// This can lead to data loss.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::collections::HashMap;
+    /// let example = HashMap::from([(5, 1), (5, 2)]);
+    /// ```
+    #[clippy::version = "1.79.0"]
+    pub HASH_COLLISION,
+    suspicious,
+    "`HashMap` with two identical keys loses data"
+}
+
+declare_lint_pass!(HashCollision => [HASH_COLLISION]);
+
+impl<'tcx> LateLintPass<'tcx> for HashCollision {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx rustc_hir::Expr<'tcx>) {
+        if has_hash_collision(cx, expr) {
+            span_lint_and_note(
+                cx,
+                HASH_COLLISION,
+                expr.span,
+                "this `HashMap` has a hash collision and will lose data",
+                None,
+                "consider using a different keys for all items",
+            );
+        }
+    }
+}
+
+// TODO: Also check for different sources of hash collisions
+// TODO: Maybe other types of hash maps should be checked as well?
+fn has_hash_collision(cx: &LateContext<'_>, expr: &rustc_hir::Expr<'_>) -> bool {
+    // If the expression is a call to `HashMap::from`, check if the keys are the same
+    if let ExprKind::Call(func, args) = &expr.kind
+        // First check for HashMap::from
+        && let ty = cx.typeck_results().expr_ty(expr)
+        && is_type_diagnostic_item(cx, ty, sym::HashMap)
+        && let ExprKind::Path(func_path) = func.kind
+        && last_path_segment(&func_path).ident.name == sym::from
+        // There should be exactly one argument to HashMap::from
+        && args.len() == 1
+        // which should be an array
+        && let ExprKind::Array(args) = &args[0].kind
+    // Then check the keys
+    {
+        // Put all keys in a vector
+        let mut literals = Vec::new();
+
+        for arg in *args {
+            //
+            if let ExprKind::Tup(args) = &arg.kind
+                && !args.is_empty()
+                && let ExprKind::Lit(lit) = args[0].kind
+            {
+                literals.push(lit.node.clone());
+            }
+        }
+        // Debug: it gets here, but doesn't trigger the lint
+
+        // Check if there are any duplicate keys
+        let mut duplicate = false;
+        for i in 0..literals.len() {
+            for j in i + 1..literals.len() {
+                if literals[i] == literals[j] {
+                    duplicate = true;
+                    break;
+                }
+            }
+            if duplicate {
+                break;
+            }
+        }
+        return duplicate;
+    }
+    false
+}

clippy_lints/src/lib.rs

@@ -153,6 +153,7 @@ mod from_raw_with_void_ptr;
 mod from_str_radix_10;
 mod functions;
 mod future_not_send;
+mod hash_collision;
 mod if_let_mutex;
 mod if_not_else;
 mod if_then_some_else_none;
@@ -1129,6 +1130,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::new(zero_repeat_side_effects::ZeroRepeatSideEffects));
     store.register_late_pass(|_| Box::new(manual_unwrap_or_default::ManualUnwrapOrDefault));
     store.register_late_pass(|_| Box::new(integer_division_remainder_used::IntegerDivisionRemainderUsed));
+    store.register_late_pass(|_| Box::new(hash_collision::HashCollision));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
 

tests/ui/hash_collision.rs

@@ -0,0 +1,6 @@
+#![warn(clippy::hash_collision)]
+use std::collections::HashMap;
+
+fn main() {
+    let example = HashMap::from([(5, 1), (5, 2)]);
+}

tests/ui/hash_collision.stderr

@@ -0,0 +1,12 @@
+error: this `HashMap` has a hash collision and will lose data
+  --> tests/ui/hash_collision.rs:5:19
+   |
+LL |     let example = HashMap::from([(5, 1), (5, 2)]);
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: consider using a different keys for all items
+   = note: `-D clippy::hash-collision` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::hash_collision)]`
+
+error: aborting due to 1 previous error
+