Pass the whole GenericArgs to Interner::for_each_relevant_impl()

And not just the self type.

rustc does not make use of this, but rust-analyzer needs it to support impls in the same block as args, see https://rust-lang.zulipchat.com/#narrow/channel/144729-t-types/topic/non.20local.20impls.20for.20generic.20args/with/593629693.

I'm not entirely sure this covers all cases (e.g. an unnormalized alias), and wants feedback from a types team member.

Author: ChayimFriedman2

compiler/rustc_middle/src/ty/context/impl_interner.rs

@@ -525,9 +525,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     fn for_each_relevant_impl(
         self,
         trait_def_id: DefId,
-        self_ty: Ty<'tcx>,
+        args: ty::GenericArgsRef<'tcx>,
         mut f: impl FnMut(DefId),
     ) {
+        let self_ty = args.type_at(0);
         let tcx = self;
         let trait_impls = tcx.trait_impls_of(trait_def_id);
         let mut consider_impls_for_simplified_type = |simp| {

compiler/rustc_next_trait_solver/src/solve/assembly/mod.rs

@@ -50,6 +50,8 @@ where
 {
     fn self_ty(self) -> I::Ty;
 
+    fn args(self) -> I::GenericArgs;
+
     fn trait_ref(self, cx: I) -> ty::TraitRef<I>;
 
     fn with_replaced_self_ty(self, cx: I, self_ty: I::Ty) -> Self;
@@ -533,7 +535,7 @@ where
         let cx = self.cx();
         cx.for_each_relevant_impl(
             goal.predicate.trait_def_id(cx),
-            goal.predicate.self_ty(),
+            goal.predicate.args(),
             |impl_def_id| {
                 // For every `default impl`, there's always a non-default `impl`
                 // that will *also* apply. There's no reason to register a candidate

compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -25,6 +25,10 @@ where
         self.self_ty()
     }
 
+    fn args(self) -> I::GenericArgs {
+        self.trait_ref.args
+    }
+
     fn trait_ref(self, _: I) -> ty::TraitRef<I> {
         self.trait_ref
     }

compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs

@@ -140,6 +140,10 @@ where
         self.self_ty()
     }
 
+    fn args(self) -> I::GenericArgs {
+        self.alias.args
+    }
+
     fn trait_ref(self, cx: I) -> ty::TraitRef<I> {
         self.alias.trait_ref(cx)
     }

compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -35,6 +35,10 @@ where
         self.self_ty()
     }
 
+    fn args(self) -> I::GenericArgs {
+        self.trait_ref.args
+    }
+
     fn trait_ref(self, _: I) -> ty::TraitRef<I> {
         self.trait_ref
     }
@@ -1230,7 +1234,7 @@ where
             let mut disqualifying_impl = None;
             self.cx().for_each_relevant_impl(
                 goal.predicate.def_id(),
-                goal.predicate.self_ty(),
+                goal.predicate.trait_ref.args,
                 |impl_def_id| {
                     disqualifying_impl = Some(impl_def_id);
                 },

compiler/rustc_type_ir/src/interner.rs

@@ -404,7 +404,7 @@ pub trait Interner:
     fn for_each_relevant_impl(
         self,
         trait_def_id: Self::TraitId,
-        self_ty: Self::Ty,
+        args: Self::GenericArgs,
         f: impl FnMut(Self::ImplId),
     );
     fn for_each_blanket_impl(self, trait_def_id: Self::TraitId, f: impl FnMut(Self::ImplId));