Failure to assume GAT normalization holds when proving GAT bounds in impl

[compiler-errors]

#![feature(associated_type_defaults)]

trait Foo {
    type Bar<T>: Baz<Self> = i32;
    // We should be able to prove that `i32: Baz<Self>` because of
    // the impl below, which requires that `Self::Bar<()>: Eq<i32>`
    // which is true, because we assume `for<T> Self::Bar<T> = i32`.
}

trait Baz<T: ?Sized> {}
impl<T: Foo + ?Sized> Baz<T> for i32 where T::Bar<()>: Eq<i32> {}
trait Eq<T> {}
impl<T> Eq<T> for T {}

fn main() {}

This code should pass, but it doesn't after #117542.

Instead, it fails with:

error[E0277]: the trait bound `<Self as Foo>::Bar<()>: Eq<i32>` is not satisfied
  --> $DIR/assume-gat-normalization-for-nested-goals.rs:6:30
   |
LL |     type Bar<T>: Baz<Self> = i32;
   |                              ^^^ the trait `Eq<i32>` is not implemented for `<Self as Foo>::Bar<()>`
   |
note: required for `i32` to implement `Baz<Self>`
  --> $DIR/assume-gat-normalization-for-nested-goals.rs:13:23
   |
LL | impl<T: Foo + ?Sized> Baz<T> for i32 where T::Bar<()>: Eq<i32> {}
   |                       ^^^^^^     ^^^                   ------- unsatisfied trait bound introduced here
note: required by a bound in `Foo::Bar`
  --> $DIR/assume-gat-normalization-for-nested-goals.rs:6:18
   |
LL |     type Bar<T>: Baz<Self> = i32;
   |                  ^^^^^^^^^ required by this bound in `Foo::Bar`
help: consider further restricting the associated type
   |
LL | trait Foo where <Self as Foo>::Bar<()>: Eq<i32> {
   |           +++++++++++++++++++++++++++++++++++++

error: aborting due to previous error

For more information about this error, try `rustc --explain E0277`.

[compiler-errors]

To fix this, we need to quantify the GAT universally over all of its (impl+gat) vars here:

rust/compiler/rustc_hir_analysis/src/check/compare_impl_item.rs

Lines 2324 to 2365 in 513a485

	// Extend the impl's identity args with late-bound GAT vars
	let normalize_impl_ty_args = ty::GenericArgs::identity_for_item(tcx, container_id)
	.extend_to(tcx, impl_ty.def_id, |param, _| match param.kind {
	GenericParamDefKind::Type { .. } => {
	let kind = ty::BoundTyKind::Param(param.def_id, param.name);
	let bound_var = ty::BoundVariableKind::Ty(kind);
	bound_vars.push(bound_var);
	Ty::new_bound(
	tcx,
	ty::INNERMOST,
	ty::BoundTy { var: ty::BoundVar::from_usize(bound_vars.len() - 1), kind },
	)
	.into()
	}
	GenericParamDefKind::Lifetime => {
	let kind = ty::BoundRegionKind::BrNamed(param.def_id, param.name);
	let bound_var = ty::BoundVariableKind::Region(kind);
	bound_vars.push(bound_var);
	ty::Region::new_late_bound(
	tcx,
	ty::INNERMOST,
	ty::BoundRegion {
	var: ty::BoundVar::from_usize(bound_vars.len() - 1),
	kind,
	},
	)
	.into()
	}
	GenericParamDefKind::Const { .. } => {
	let bound_var = ty::BoundVariableKind::Const;
	bound_vars.push(bound_var);
	ty::Const::new_bound(
	tcx,
	ty::INNERMOST,
	ty::BoundVar::from_usize(bound_vars.len() - 1),
	tcx.type_of(param.def_id)
	.no_bound_vars()
	.expect("const parameter types cannot be generic"),
	)
	.into()
	}
	});

...rather than just its gat vars.

That's obviously not sound unless the projection predicate requires the where clauses of the impl to hold, which requires having where clauses on binders.