recommend using a HashMap if a HashSet's second generic parameter doesn't implement BuildHasher

Author: Qelxiros

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -2925,7 +2925,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .filter_map(|e| match e.obligation.predicate.kind().skip_binder() {
                 ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) => {
                     match pred.self_ty().kind() {
-                        ty::Adt(_, _) => Some(pred),
+                        ty::Adt(_, _) => Some((
+                            (e.root_obligation.predicate, e.root_obligation.cause.span),
+                            pred,
+                        )),
                         _ => None,
                     }
                 }
@@ -2935,18 +2938,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // Note for local items and foreign items respectively.
         let (mut local_preds, mut foreign_preds): (Vec<_>, Vec<_>) =
-            preds.iter().partition(|&pred| {
+            preds.iter().partition(|&(_, pred)| {
                 if let ty::Adt(def, _) = pred.self_ty().kind() {
                     def.did().is_local()
                 } else {
                     false
                 }
             });
 
-        local_preds.sort_by_key(|pred: &&ty::TraitPredicate<'_>| pred.trait_ref.to_string());
+        local_preds.sort_by_key(|(_, pred)| pred.trait_ref.to_string());
         let local_def_ids = local_preds
             .iter()
-            .filter_map(|pred| match pred.self_ty().kind() {
+            .filter_map(|(_, pred)| match pred.self_ty().kind() {
                 ty::Adt(def, _) => Some(def.did()),
                 _ => None,
             })
@@ -2959,7 +2962,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             })
             .collect::<Vec<_>>()
             .into();
-        for pred in &local_preds {
+        for (_, pred) in &local_preds {
             if let ty::Adt(def, _) = pred.self_ty().kind() {
                 local_spans.push_span_label(
                     self.tcx.def_span(def.did()),
@@ -2968,7 +2971,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
         if local_spans.primary_span().is_some() {
-            let msg = if let [local_pred] = local_preds.as_slice() {
+            let msg = if let [(_, local_pred)] = local_preds.as_slice() {
                 format!(
                     "an implementation of `{}` might be missing for `{}`",
                     local_pred.trait_ref.print_trait_sugared(),
@@ -2986,10 +2989,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             err.span_note(local_spans, msg);
         }
 
-        foreign_preds.sort_by_key(|pred: &&ty::TraitPredicate<'_>| pred.trait_ref.to_string());
+        foreign_preds.sort_by_key(|(_, pred)| pred.trait_ref.to_string());
         let foreign_def_ids = foreign_preds
             .iter()
-            .filter_map(|pred| match pred.self_ty().kind() {
+            .filter_map(|(_, pred)| match pred.self_ty().kind() {
                 ty::Adt(def, _) => Some(def.did()),
                 _ => None,
             })
@@ -3002,7 +3005,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             })
             .collect::<Vec<_>>()
             .into();
-        for pred in &foreign_preds {
+        for (_, pred) in &foreign_preds {
             if let ty::Adt(def, _) = pred.self_ty().kind() {
                 foreign_spans.push_span_label(
                     self.tcx.def_span(def.did()),
@@ -3011,7 +3014,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
         if foreign_spans.primary_span().is_some() {
-            let msg = if let [foreign_pred] = foreign_preds.as_slice() {
+            let msg = if let [(_, foreign_pred)] = foreign_preds.as_slice() {
                 format!(
                     "the foreign item type `{}` doesn't implement `{}`",
                     foreign_pred.self_ty(),
@@ -3027,6 +3030,21 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 )
             };
             err.span_note(foreign_spans, msg);
+
+            if let Some(span) = foreign_preds.iter().find_map(|&((root_pred, span), pred)| {
+                match root_pred.kind().skip_binder() {
+                    ty::PredicateKind::Clause(ty::ClauseKind::Trait(root_pred))
+                        if let Some(root_adt) = root_pred.self_ty().ty_adt_def()
+                            && self.tcx.is_diagnostic_item(sym::HashSet, root_adt.did())
+                            && self.tcx.is_diagnostic_item(sym::BuildHasher, pred.def_id()) =>
+                    {
+                        Some(span)
+                    }
+                    _ => None,
+                }
+            }) {
+                err.span_help(span, "you might have intended to use a HashMap instead");
+            }
         }
 
         let preds: Vec<_> = errors

compiler/rustc_span/src/symbol.rs

@@ -191,6 +191,7 @@ symbols! {
         Borrow,
         BorrowMut,
         Break,
+        BuildHasher,
         C,
         CStr,
         C_dash_unwind: "C-unwind",

library/core/src/hash/mod.rs

@@ -633,6 +633,7 @@ impl<H: Hasher + ?Sized> Hasher for &mut H {
 ///
 /// [`build_hasher`]: BuildHasher::build_hasher
 /// [`HashMap`]: ../../std/collections/struct.HashMap.html
+#[cfg_attr(not(test), rustc_diagnostic_item = "BuildHasher")]
 #[stable(since = "1.7.0", feature = "build_hasher")]
 pub trait BuildHasher {
     /// Type of the hasher that will be created.

tests/ui/suggestions/hashset_generics.rs

@@ -0,0 +1,13 @@
+use std::collections::HashSet;
+
+#[derive(PartialEq)]
+//~^ NOTE in this expansion of
+//~| NOTE in this expansion of
+//~| NOTE in this expansion of
+pub struct MyStruct {
+    pub parameters: HashSet<String, String>,
+    //~^ NOTE the foreign item type
+    //~| ERROR binary operation
+}
+
+fn main() {}

tests/ui/suggestions/hashset_generics.stderr

@@ -0,0 +1,25 @@
+error[E0369]: binary operation `==` cannot be applied to type `HashSet<String, String>`
+  --> $DIR/hashset_generics.rs:8:5
+   |
+LL | #[derive(PartialEq)]
+   |          --------- in this derive macro expansion
+...
+LL |     pub parameters: HashSet<String, String>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the foreign item type `String` doesn't implement `BuildHasher`
+  --> $SRC_DIR/alloc/src/string.rs:LL:COL
+   |
+   = note: not implement `BuildHasher`
+help: you might have intended to use a HashMap instead
+  --> $DIR/hashset_generics.rs:8:5
+   |
+LL | #[derive(PartialEq)]
+   |          --------- in this derive macro expansion
+...
+LL |     pub parameters: HashSet<String, String>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0369`.