PRocess alias-relate obligations when proving receiver_is_valid

Author: compiler-errors

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1712,7 +1712,15 @@ fn receiver_is_valid<'tcx>(
     let cause =
         ObligationCause::new(span, wfcx.body_def_id, traits::ObligationCauseCode::MethodReceiver);
 
-    let can_eq_self = |ty| infcx.can_eq(wfcx.param_env, self_ty, ty);
+    let can_eq_self = |ty| {
+        wfcx.infcx.probe(|_| {
+            let ocx = ObligationCtxt::new(wfcx.infcx);
+            let Ok(()) = ocx.eq(&ObligationCause::dummy(), wfcx.param_env, self_ty, ty) else {
+                return false;
+            };
+            ocx.select_where_possible().is_empty()
+        })
+    };
 
     // `self: Self` is always valid.
     if can_eq_self(receiver_ty) {

compiler/rustc_infer/src/infer/mod.rs

@@ -767,6 +767,8 @@ impl<'tcx> InferCtxt<'tcx> {
             .collect()
     }
 
+    // FIXME(-Znext-solver): Get rid of this method, it's never correct. Either that,
+    // or we need to process the obligations.
     pub fn can_sub<T>(&self, param_env: ty::ParamEnv<'tcx>, expected: T, actual: T) -> bool
     where
         T: at::ToTrace<'tcx>,
@@ -779,6 +781,8 @@ impl<'tcx> InferCtxt<'tcx> {
         })
     }
 
+    // FIXME(-Znext-solver): Get rid of this method, it's never correct. Either that,
+    // or we need to process the obligations.
     pub fn can_eq<T>(&self, param_env: ty::ParamEnv<'tcx>, a: T, b: T) -> bool
     where
         T: at::ToTrace<'tcx>,

tests/ui/traits/next-solver/typeck/receiver-self-ty-check-eq.rs

@@ -0,0 +1,23 @@
+//@ compile-flags: -Znext-solver
+//@ check-pass
+
+// Fixes a regression in `receiver_is_valid` in wfcheck where we were using
+// `InferCtxt::can_eq` instead of processing alias-relate goals, leading to false
+// positives, not deref'ing enough steps to check the receiver is valid.
+
+trait Mirror {
+    type Mirror: ?Sized;
+}
+impl<T: ?Sized> Mirror for T {
+    type Mirror = T;
+}
+
+trait Foo {
+    fn foo(&self) {}
+}
+
+impl Foo for <() as Mirror>::Mirror {
+    fn foo(&self) {}
+}
+
+fn main() {}