Receiver trait with target: Ignore post-Deref errs.

When probing for methods, we step forward through a chain of types. The first
few of those steps can be reached by jumping through the chain of Derefs or the
chain of Receivers. Later steps can only be reached by following the chain of
Receivers. For instance, supposing A and B implement both Receiver and Deref,
while C and D implement only Receiver:

Type A<B<C<D<E>>>>

    Deref chain:      A -> B -> C
    Receiver chain:   A -> B -> C -> D -> E

We report bad type errors from the end of the chain. Previously this 'receiver
trait with target' code reported problems encountered at the end of the whole
chain, but in fact we never morph the self type that far. So we now instead
report errors encountered only at the end of the Deref chain.

A test case is included which demonstrates the problem.

Author: adetaylor

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -537,10 +537,14 @@ fn method_autoderef_steps<'tcx>(
             .chain(std::iter::repeat(false));
 
     let mut reached_raw_pointer = false;
+    let mut final_ty_reachable_by_deref = None;
     let mut steps: Vec<_> = autoderef_via_receiver
         .by_ref()
         .zip(reachable_via_deref)
         .map(|((ty, d), reachable_via_deref)| {
+            if reachable_via_deref {
+                final_ty_reachable_by_deref = Some(ty);
+            }
             let step = CandidateStep {
                 self_ty: infcx.make_query_response_ignoring_pending_obligations(inference_vars, ty),
                 autoderefs: d,
@@ -555,12 +559,15 @@ fn method_autoderef_steps<'tcx>(
             step
         })
         .collect();
-    let final_ty = autoderef_via_receiver.final_ty(true);
+    let final_ty =
+        final_ty_reachable_by_deref.expect("Should be at least one type in any autoderef");
+    let final_ty = infcx.resolve_vars_if_possible(final_ty);
     let opt_bad_ty = match final_ty.kind() {
         ty::Infer(ty::TyVar(_)) | ty::Error(_) => Some(MethodAutoderefBadTy {
             reached_raw_pointer,
             ty: infcx.make_query_response_ignoring_pending_obligations(inference_vars, final_ty),
         }),
+
         ty::Array(elem_ty, _) => {
             let dereferences = steps.len() - 1;
             let reachable_via_deref =
@@ -584,6 +591,10 @@ fn method_autoderef_steps<'tcx>(
         _ => None,
     };
 
+    // FIXME - the previous section may emit an error if the final type reachable
+    // by the Deref chain is ty::Infer(ty::TyVar(_)). We should consider emitting a warning
+    // if the final type reachable by the Receiver chain is similarly problematic.
+
     debug!("method_autoderef_steps: steps={:?} opt_bad_ty={:?}", steps, opt_bad_ty);
 
     MethodAutoderefStepsResult {

tests/ui/self/recursive-receiver.rs

@@ -0,0 +1,32 @@
+// run-pass
+#![feature(receiver_trait)]
+
+struct MyNonNull<T>(*const T);
+
+impl<T> std::ops::Receiver for MyNonNull<T> {
+    type Target = T;
+}
+
+#[allow(dead_code)]
+impl<T> MyNonNull<T> {
+    fn foo<U>(&self) -> *const U {
+        self.cast().bar()
+    }
+    fn cast<U>(&self) -> MyNonNull<U> {
+        MyNonNull(self.0 as *const U)
+    }
+    fn bar(&self) -> *const T {
+        self.0
+    }
+}
+
+#[repr(transparent)]
+struct Foo(usize);
+#[repr(transparent)]
+struct Bar(usize);
+
+fn main() {
+    let a = Foo(3);
+    let ptr = MyNonNull(&a);
+    let _bar_ptr: *const Bar = ptr.foo();
+}