Change:
let tcx = self.tcx; let assoc = tcx.associated_item(proj_ty.def_id); let (trait_ref, assoc_args) = proj_ty.trait_ref_and_own_args(tcx); <del> if let Some(item) = tcx.hir().get_if_local(body_owner_def_id) { if let Some(hir_generics) = item.generics() { // Get the `DefId` for the type parameter corresponding to `A` in `<A as T>::Foo`. // This will also work for `impl Trait`. let def_id = if let ty::Param(param_ty) = proj_ty.self_ty().kind() { let generics = tcx.generics_of(body_owner_def_id); generics.type_param(param_ty, tcx).def_id } else { return false; }; let Some(def_id) = def_id.as_local() else { return false; }; // First look in the `where` clause, as this might be // `fn foo<T>(x: T) where T: Trait`. for pred in hir_generics.bounds_for_param(def_id) { if self.constrain_generic_bound_associated_type_structured_suggestion( diag, &trait_ref, pred.bounds, assoc, assoc_args, ty, &msg, false, ) { return true; } } </del> <ins> let Some(item) = tcx.hir().get_if_local(body_owner_def_id) else { return false; }; let Some(hir_generics) = item.generics() else { return false; }; // Get the `DefId` for the type parameter corresponding to `A` in `<A as T>::Foo`. // This will also work for `impl Trait`. let def_id = if let ty::Param(param_ty) = proj_ty.self_ty().kind() { let generics = tcx.generics_of(body_owner_def_id); generics.type_param(param_ty, tcx).def_id } else { return false; }; let Some(def_id) = def_id.as_local() else { return false; }; // First look in the `where` clause, as this might be // `fn foo<T>(x: T) where T: Trait`. for pred in hir_generics.bounds_for_param(def_id) { if self.constrain_generic_bound_associated_type_structured_suggestion( diag, &trait_ref, pred.bounds, assoc, assoc_args, ty, &msg, false, ) { return true; </ins> } } <del> false </del> <ins> // If associated item, look to constrain the params of the trait/impl. let hir_id = match item { hir::Node::ImplItem(item) => item.hir_id(), hir::Node::TraitItem(item) => item.hir_id(), _ => return false, }; let parent = tcx.hir().get_parent_item(hir_id).def_id; self.suggest_constraint(diag, msg, parent.into(), proj_ty, ty) </ins> } /// An associated type was expected and a different type was found.

Discussion:
Repro: This caused E0277 "the trait bound is not satisfied" error: The error doesn't make sense because is obviously . It seems the associated const type is evaluated before the generic bounds are , causing this error. Changing both and to makes the error go away. Reproducible on all 3 versions on playground (1.23.0, 1.24.0-beta, 1.25.0-nightly).
This exact issue just occured to and me when trying to use associated constants to create a constant struct in a library with user-provided data (without const fns) (actual use case: ). A minimized examples is this (): Error: The interesting thing is that even though both bounds are specified, the compiler doesn't seem to take them into account. Edit: The issue is not using a trait with an associated type and const as generic bound. Instead the problem is implementing a trait with an associated type and const in general:
I ran into the same problem. It's also in 1.26 stable. Here's a further minimized example (): We can also use the type parameter in the trait rather than the type (): Both code fragments give an error saying that in the blanket impl, Rust cannot figure out that implements and : Note that in both cases, if you remove the constraint on the quantified type , the error about goes away! This is very strange. However, like in , the error message stays. The problem goes away if you declare the type of in to be , rather than some type that is computed potentially based on parameters. I'm not familiar with the compiler internals, but my hypothesis is that associated types and constants depending on a type parameter are not evaluated properly in the constant expression evaluator. In this case, it's associated types that do not reduce well: forces Rust to do some fancy type of computation at compile time in order to type check, but there's a bug in the code for such computations. I feel there are a couple of different issues in the same spirit: In , Rust is trying to check two types against each other, which forces it to simplify the type . This fails. The error message shows that Rust cannot decide that , even though was in the where clause. Same in , where they get a warning (!) about a "constant evaluation error".

In , the same happens but with a consteval that uses a different trait fn.
Copying over my minimal example from as another data point (): Here I've a supertrait to my trait to get rid of the issue but it still can't determine the required trait implementation (of my trait in this case) to make this work.
All of these cases now compile, except for , which has a type error: Current output: The correct code would be The outstanding work would be providing a suggestion explaining what "consider constraining the associated type to " means. This will be hard to do given the different cases that need to be accounted for, for the case above you need to move the constraint to , for example (although that's not needed, just nicer stylistically).