1 use clippy_utils::diagnostics::span_lint;
2 use clippy_utils::{match_def_path, paths, trait_ref_of_method};
4 use rustc_lint::{LateContext, LateLintPass};
5 use rustc_middle::ty::TypeFoldable;
6 use rustc_middle::ty::{Adt, Array, RawPtr, Ref, Slice, Tuple, Ty, TypeAndMut};
7 use rustc_session::{declare_lint_pass, declare_tool_lint};
8 use rustc_span::source_map::Span;
11 declare_clippy_lint! {
12 /// **What it does:** Checks for sets/maps with mutable key types.
14 /// **Why is this bad?** All of `HashMap`, `HashSet`, `BTreeMap` and
15 /// `BtreeSet` rely on either the hash or the order of keys be unchanging,
16 /// so having types with interior mutability is a bad idea.
18 /// **Known problems:** It's correct to use a struct, that contains interior mutability
19 /// as a key, when its `Hash` implementation doesn't access any of the interior mutable types.
20 /// However, this lint is unable to recognize this, so it causes a false positive in theses cases.
21 /// The `bytes` crate is a great example of this.
25 /// use std::cmp::{PartialEq, Eq};
26 /// use std::collections::HashSet;
27 /// use std::hash::{Hash, Hasher};
28 /// use std::sync::atomic::AtomicUsize;
31 /// struct Bad(AtomicUsize);
32 /// impl PartialEq for Bad {
33 /// fn eq(&self, rhs: &Self) -> bool {
35 /// ; unimplemented!();
39 /// impl Eq for Bad {}
41 /// impl Hash for Bad {
42 /// fn hash<H: Hasher>(&self, h: &mut H) {
44 /// ; unimplemented!();
49 /// let _: HashSet<Bad> = HashSet::new();
54 "Check for mutable `Map`/`Set` key type"
57 declare_lint_pass!(MutableKeyType => [ MUTABLE_KEY_TYPE ]);
59 impl<'tcx> LateLintPass<'tcx> for MutableKeyType {
60 fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) {
61 if let hir::ItemKind::Fn(ref sig, ..) = item.kind {
62 check_sig(cx, item.hir_id(), sig.decl);
66 fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'tcx>) {
67 if let hir::ImplItemKind::Fn(ref sig, ..) = item.kind {
68 if trait_ref_of_method(cx, item.hir_id()).is_none() {
69 check_sig(cx, item.hir_id(), sig.decl);
74 fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'tcx>) {
75 if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind {
76 check_sig(cx, item.hir_id(), sig.decl);
80 fn check_local(&mut self, cx: &LateContext<'_>, local: &hir::Local<'_>) {
81 if let hir::PatKind::Wild = local.pat.kind {
84 check_ty(cx, local.span, cx.typeck_results().pat_ty(&*local.pat));
88 fn check_sig<'tcx>(cx: &LateContext<'tcx>, item_hir_id: hir::HirId, decl: &hir::FnDecl<'_>) {
89 let fn_def_id = cx.tcx.hir().local_def_id(item_hir_id);
90 let fn_sig = cx.tcx.fn_sig(fn_def_id);
91 for (hir_ty, ty) in iter::zip(decl.inputs, fn_sig.inputs().skip_binder()) {
92 check_ty(cx, hir_ty.span, ty);
94 check_ty(cx, decl.output.span(), cx.tcx.erase_late_bound_regions(fn_sig.output()));
97 // We want to lint 1. sets or maps with 2. not immutable key types and 3. no unerased
98 // generics (because the compiler cannot ensure immutability for unknown types).
99 fn check_ty<'tcx>(cx: &LateContext<'tcx>, span: Span, ty: Ty<'tcx>) {
100 let ty = ty.peel_refs();
101 if let Adt(def, substs) = ty.kind() {
102 if [&paths::HASHMAP, &paths::BTREEMAP, &paths::HASHSET, &paths::BTREESET]
104 .any(|path| match_def_path(cx, def.did, &**path))
105 && is_mutable_type(cx, substs.type_at(0), span)
107 span_lint(cx, MUTABLE_KEY_TYPE, span, "mutable key type");
112 fn is_mutable_type<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span) -> bool {
114 RawPtr(TypeAndMut { ty: inner_ty, mutbl }) | Ref(_, inner_ty, mutbl) => {
115 mutbl == hir::Mutability::Mut || is_mutable_type(cx, inner_ty, span)
117 Slice(inner_ty) => is_mutable_type(cx, inner_ty, span),
118 Array(inner_ty, size) => {
119 size.try_eval_usize(cx.tcx, cx.param_env).map_or(true, |u| u != 0) && is_mutable_type(cx, inner_ty, span)
121 Tuple(..) => ty.tuple_fields().any(|ty| is_mutable_type(cx, ty, span)),
123 cx.tcx.layout_of(cx.param_env.and(ty)).is_ok()
124 && !ty.has_escaping_bound_vars()
125 && !ty.is_freeze(cx.tcx.at(span), cx.param_env)