Suggest derive(Trait) or T: Trait from transitive obligation in s…

…ome cases

With code like the following

```rust
struct Ctx<A> {
    a_map: HashMap<String, B<A>>,
}

struct B<A> {
    a: A,
}
```

the derived trait will have an implicit restriction on `A: Clone` for both types.

When referenced as follows:

```rust
fn foo<Z>(ctx: &mut Ctx<Z>) {
    let a_map = ctx.a_map.clone(); //~ ERROR E0599
}
```

suggest constraining `Z`:

```
error[E0599]: the method `clone` exists for struct `HashMap<String, B<Z>>`, but its trait bounds were not satisfied
  --> $DIR/type-or-type-param-missing-transitive-trait-contraint.rs:16:27
   |
LL | struct B<A> {
   | ----------- doesn't satisfy `B<Z>: Clone`
...
LL |     let a_map = ctx.a_map.clone();
   |                           ^^^^^ method cannot be called on `HashMap<String, B<Z>>` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `B<Z>: Clone`
           which is required by `HashMap<String, B<Z>>: Clone`
help: consider restricting type parameter `Z`
   |
LL | fn foo<Z: std::clone::Clone>(ctx: &mut Ctx<Z>) {
   |         +++++++++++++++++++
```

When referenced as follows, with a specific type `S`:

```rust
struct S;
fn bar(ctx: &mut Ctx<S>) {
    let a_map = ctx.a_map.clone(); //~ ERROR E0599
}
```

suggest `derive`ing the appropriate trait on the local type:

```
error[E0599]: the method `clone` exists for struct `HashMap<String, B<S>>`, but its trait bounds were not satisfied
  --> $DIR/type-or-type-param-missing-transitive-trait-contraint.rs:21:27
   |
LL | struct B<A> {
   | ----------- doesn't satisfy `B<S>: Clone`
...
LL |     let a_map = ctx.a_map.clone();
   |                           ^^^^^ method cannot be called on `HashMap<String, B<S>>` due to unsatisfied trait bounds
   |
   = note: the following trait bounds were not satisfied:
           `B<S>: Clone`
           which is required by `HashMap<String, B<S>>: Clone`
help: consider annotating `S` with `#[derive(Clone)]`
   |
LL + #[derive(Clone)]
LL | struct S;
   |
```

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -37,6 +37,7 @@ use rustc_span::{edit_distance, ErrorGuaranteed, ExpnKind, FileName, MacroKind,
 use rustc_span::{Symbol, DUMMY_SP};
 use rustc_trait_selection::error_reporting::traits::on_unimplemented::OnUnimplementedNote;
 use rustc_trait_selection::error_reporting::traits::on_unimplemented::TypeErrCtxtExt as _;
+use rustc_trait_selection::error_reporting::traits::suggestions::TypeErrCtxtExt;
 use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use rustc_trait_selection::traits::{
@@ -1368,7 +1369,100 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
  "the following trait bounds were not satisfied:\n{bound_list}"
  ));
  }
- suggested_derive = self.suggest_derive(&mut err, unsatisfied_predicates);
+
+ let mut suggest_derive = true;
+ for (pred, _, cause) in unsatisfied_predicates {
+ let Some(ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_pred))) =
+ pred.kind().no_bound_vars()
+ else {
+ continue;
+ };
+ let (adt, params) = match trait_pred.self_ty().kind() {
+ ty::Adt(adt, params) if adt.did().is_local() => (*adt, params),
+ _ => continue,
+ };
+ if self
+ .tcx
+ .all_impls(trait_pred.def_id())
+ .filter_map(|imp_did| {
+ self.tcx.impl_trait_header(imp_did).map(|h| (imp_did, h))
+ })
+ .filter(|(did, header)| {
+ let imp = header.trait_ref.instantiate_identity();
+ let impl_adt = match imp.self_ty().ty_adt_def() {
+ Some(impl_adt) if adt.did().is_local() => impl_adt,
+ _ => return false,
+ };
+ header.polarity == ty::ImplPolarity::Positive
+ && impl_adt == adt
+ && self.tcx.is_automatically_derived(*did)
+ })
+ .count()
+ == 1
+ {
+ // We now know that for this predicate, there *was* a `derive(Trait)` for
+ // the trait at hand, so we don't want to suggest writing that again.
+ for param in &params[..] {
+ // Look at the type parameters for the currently obligated type to see
+ // if a restriciton of `TypeParam: Trait` would help. If the
+ // instantiated type param is not a type param but instead an actual
+ // type, see if we can suggest `derive(Trait)` on *that* type.
+ // See `tests/ui/suggestions/f1000.rs`
+ let Some(ty) = param.as_type() else {
+ continue;
+ };
+ match ty.kind() {
+ ty::Adt(adt, _) if adt.did().is_local() => {
+ // The type param at hand is a local type, try to suggest
+ // `derive(Trait)`.
+ let trait_ref =
+ ty::TraitRef::new(tcx, trait_pred.trait_ref.def_id, [ty]);
+ let trait_pred = ty::Binder::dummy(ty::TraitPredicate {
+ trait_ref,
+ polarity: ty::PredicatePolarity::Positive,
+ });
+ suggested_derive = self.suggest_derive(
+ &mut err,
+ &[(
+ <_ as ty::UpcastFrom<_, _>>::upcast_from(
+ trait_pred, self.tcx,
+ ),
+ None,
+ cause.clone(),
+ )],
+ );
+ }
+ ty::Param(_) => {
+ // It was a type param. See if it corresponds to the current
+ // `fn` and suggest `T: Trait`.
+ if let Some(obligation) = cause {
+ let trait_ref = ty::TraitRef::new(
+ tcx,
+ trait_pred.trait_ref.def_id,
+ [ty],
+ );
+ let trait_pred = ty::Binder::dummy(ty::TraitPredicate {
+ trait_ref,
+ polarity: ty::PredicatePolarity::Positive,
+ });
+ suggested_derive =
+ self.err_ctxt().suggest_restricting_param_bound(
+ &mut err,
+ trait_pred,
+ None,
+ obligation.body_id,
+ );
+ }
+ }
+ _ => {}
+ }
+ }
+ suggest_derive = false
+ }
+ }
+ if suggest_derive {
+ suggested_derive = self.suggest_derive(&mut err, unsatisfied_predicates);
+ }
 
  unsatisfied_bounds = true;
  }

compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs

@@ -249,9 +249,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  trait_pred: ty::PolyTraitPredicate<'tcx>,
  associated_ty: Option<(&'static str, Ty<'tcx>)>,
  mut body_id: LocalDefId,
- ) {
+ ) -> bool {
  if trait_pred.skip_binder().polarity != ty::PredicatePolarity::Positive {
- return;
+ return false;
  }
 
  let trait_pred = self.resolve_numeric_literals_with_default(trait_pred);
@@ -286,7 +286,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  trait_pred,
  Some((ident, bounds)),
  );
- return;
+ return true;
  }
 
  hir::Node::TraitItem(hir::TraitItem {
@@ -300,7 +300,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  self.tcx, body_id, generics, "`Self`", err, None, projection, trait_pred,
  None,
  );
- return;
+ return true;
  }
 
  hir::Node::TraitItem(hir::TraitItem {
@@ -328,7 +328,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  trait_pred,
  None,
  );
- return;
+ return true;
  }
  hir::Node::Item(hir::Item {
  kind:
@@ -348,7 +348,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  trait_pred,
  None,
  );
- return;
+ return true;
  }
 
  hir::Node::Item(hir::Item {
@@ -381,7 +381,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  .iter()
  .all(|g| g.is_suggestable(self.tcx, false))
  {
- return;
+ return false;
  }
  // Missing generic type parameter bound.
  let param_name = self_ty.to_string();
@@ -413,7 +413,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  Some(trait_pred.def_id()),
  None,
  ) {
- return;
+ return true;
  }
  }
 
@@ -439,10 +439,10 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
  trait_pred,
  associated_ty,
  ) {
- return;
+ return true;
  }
  }
- hir::Node::Crate(..) => return,
+ hir::Node::Crate(..) => return false,
 
  _ => {}
  }

tests/ui/suggestions/type-or-type-param-missing-transitive-trait-contraint.fixed

@@ -0,0 +1,25 @@
+//@ run-rustfix
+#![allow(warnings)]
+use std::collections::HashMap;
+
+#[derive(Clone)]
+struct Ctx<A> {
+ a_map: HashMap<String, B<A>>,
+}
+
+#[derive(Clone)]
+struct B<A> {
+ a: A,
+}
+
+fn foo<Z: std::clone::Clone>(ctx: &mut Ctx<Z>) {
+ let a_map = ctx.a_map.clone(); //~ ERROR E0599
+}
+
+#[derive(Clone)]
+struct S;
+fn bar(ctx: &mut Ctx<S>) {
+ let a_map = ctx.a_map.clone(); //~ ERROR E0599
+}
+
+fn main() {}

tests/ui/suggestions/type-or-type-param-missing-transitive-trait-contraint.rs

@@ -0,0 +1,24 @@
+//@ run-rustfix
+#![allow(warnings)]
+use std::collections::HashMap;
+
+#[derive(Clone)]
+struct Ctx<A> {
+ a_map: HashMap<String, B<A>>,
+}
+
+#[derive(Clone)]
+struct B<A> {
+ a: A,
+}
+
+fn foo<Z>(ctx: &mut Ctx<Z>) {
+ let a_map = ctx.a_map.clone(); //~ ERROR E0599
+}
+
+struct S;
+fn bar(ctx: &mut Ctx<S>) {
+ let a_map = ctx.a_map.clone(); //~ ERROR E0599
+}
+
+fn main() {}

tests/ui/suggestions/type-or-type-param-missing-transitive-trait-contraint.stderr

@@ -0,0 +1,38 @@
+error[E0599]: the method `clone` exists for struct `HashMap<String, B<Z>>`, but its trait bounds were not satisfied
+ --> $DIR/type-or-type-param-missing-transitive-trait-contraint.rs:16:27
+ |
+LL | struct B<A> {
+ | ----------- doesn't satisfy `B<Z>: Clone`
+...
+LL | let a_map = ctx.a_map.clone();
+ | ^^^^^ method cannot be called on `HashMap<String, B<Z>>` due to unsatisfied trait bounds
+ |
+ = note: the following trait bounds were not satisfied:
+ `B<Z>: Clone`
+ which is required by `HashMap<String, B<Z>>: Clone`
+help: consider restricting type parameter `Z`
+ |
+LL | fn foo<Z: std::clone::Clone>(ctx: &mut Ctx<Z>) {
+ | +++++++++++++++++++
+
+error[E0599]: the method `clone` exists for struct `HashMap<String, B<S>>`, but its trait bounds were not satisfied
+ --> $DIR/type-or-type-param-missing-transitive-trait-contraint.rs:21:27
+ |
+LL | struct B<A> {
+ | ----------- doesn't satisfy `B<S>: Clone`
+...
+LL | let a_map = ctx.a_map.clone();
+ | ^^^^^ method cannot be called on `HashMap<String, B<S>>` due to unsatisfied trait bounds
+ |
+ = note: the following trait bounds were not satisfied:
+ `B<S>: Clone`
+ which is required by `HashMap<String, B<S>>: Clone`
+help: consider annotating `S` with `#[derive(Clone)]`
+ |
+LL + #[derive(Clone)]
+LL | struct S;
+ |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0599`.