arbitrary_self_types: split the Autoderef chain

Receiver chain has been an extension of Deref chain,
but the consequence has been questioned as this would admit method
signatures that are deemed dubious.

It is also debatable that Receiver trait which determines applicable
`Self` type should have anything to do with dereference operation
in general.

This patch separate the two traits and isolate their use in the language.
This means that in method probing, we will chase down a Deref chain for
an applicable type for the variable `self`, from which we additionally
chase down a Receiver chain for an applicable `Self` type from a list of
methods that accepts one of these possible types of `self`.

Author: dingxiangfei2009

compiler/rustc_codegen_cranelift/example/arbitrary_self_types_pointers_and_wrappers.rs

@@ -3,7 +3,7 @@
 #![feature(arbitrary_self_types, unsize, coerce_unsized, dispatch_from_dyn)]
 
 use std::marker::Unsize;
-use std::ops::{CoerceUnsized, Deref, DispatchFromDyn};
+use std::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
 
 struct Ptr<T: ?Sized>(Box<T>);
 
@@ -14,6 +14,9 @@ impl<T: ?Sized> Deref for Ptr<T> {
         &*self.0
     }
 }
+impl<T: ?Sized> Receiver for Ptr<T> {
+    type Target = T;
+}
 
 impl<T: Unsize<U> + ?Sized, U: ?Sized> CoerceUnsized<Ptr<U>> for Ptr<T> {}
 impl<T: Unsize<U> + ?Sized, U: ?Sized> DispatchFromDyn<Ptr<U>> for Ptr<T> {}
@@ -27,6 +30,9 @@ impl<T: ?Sized> Deref for Wrapper<T> {
         &self.0
     }
 }
+impl<T: ?Sized> Receiver for Wrapper<T> {
+    type Target = T;
+}
 
 impl<T: CoerceUnsized<U>, U> CoerceUnsized<Wrapper<U>> for Wrapper<T> {}
 impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<Wrapper<U>> for Wrapper<T> {}

compiler/rustc_codegen_gcc/example/arbitrary_self_types_pointers_and_wrappers.rs

@@ -4,10 +4,8 @@
 #![feature(rustc_attrs)]
 #![allow(internal_features)]
 
-use std::{
-    ops::{Deref, CoerceUnsized, DispatchFromDyn},
-    marker::Unsize,
-};
+use std::marker::Unsize;
+use std::ops::{CoerceUnsized, Deref, DispatchFromDyn, Receiver};
 
 struct Ptr<T: ?Sized>(Box<T>);
 
@@ -18,6 +16,9 @@ impl<T: ?Sized> Deref for Ptr<T> {
         &*self.0
     }
 }
+impl<T: ?Sized> Receiver for Ptr<T> {
+    type Target = T;
+}
 
 impl<T: Unsize<U> + ?Sized, U: ?Sized> CoerceUnsized<Ptr<U>> for Ptr<T> {}
 impl<T: Unsize<U> + ?Sized, U: ?Sized> DispatchFromDyn<Ptr<U>> for Ptr<T> {}
@@ -31,11 +32,13 @@ impl<T: ?Sized> Deref for Wrapper<T> {
         &self.0
     }
 }
+impl<T: ?Sized> Receiver for Wrapper<T> {
+    type Target = T;
+}
 
 impl<T: CoerceUnsized<U>, U> CoerceUnsized<Wrapper<U>> for Wrapper<T> {}
 impl<T: DispatchFromDyn<U>, U> DispatchFromDyn<Wrapper<U>> for Wrapper<T> {}
 
-
 trait Trait {
     fn ptr_wrapper(self: Ptr<Wrapper<Self>>) -> i32;
     fn wrapper_ptr(self: Wrapper<Ptr<Self>>) -> i32;

compiler/rustc_error_codes/src/error_codes/E0307.md

@@ -67,22 +67,16 @@ impl Trait for Foo {
 The nightly feature [Arbitrary self types][AST] extends the accepted
 set of receiver types to also include any type that implements the
 `Receiver` trait and can follow its chain of `Target` types to `Self`.
-There's a blanket implementation of `Receiver` for `T: Deref`, so any
-type which dereferences to `Self` can be used.
 
 ```
 #![feature(arbitrary_self_types)]
 
 struct Foo;
 struct Bar;
 
-// Because you can dereference `Bar` into `Foo`...
-impl std::ops::Deref for Bar {
+// Because you can set `Bar` as method receiver for `Foo`...
+impl std::ops::Receiver for Bar {
     type Target = Foo;
-
-    fn deref(&self) -> &Foo {
-        &Foo
-    }
 }
 
 impl Foo {

compiler/rustc_hir_analysis/src/autoderef.rs

@@ -80,16 +80,19 @@ impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
         }
 
         // Otherwise, deref if type is derefable:
-        // NOTE: in the case of self.use_receiver_trait = true, you might think it would
-        // be better to skip this clause and use the Overloaded case only, since &T
-        // and &mut T implement Receiver. But built-in derefs apply equally to Receiver
-        // and Deref, and this has benefits for const and the emitted MIR.
+        // NOTE: in the case of self.use_receiver_trait = true,
+        // Autoderef works only with Receiver trait.
+        // Caller is expecting us to expand the Receiver chain only.
         let (kind, new_ty) =
             if let Some(ty) = self.state.cur_ty.builtin_deref(self.include_raw_pointers) {
                 debug_assert_eq!(ty, self.infcx.resolve_vars_if_possible(ty));
                 // NOTE: we may still need to normalize the built-in deref in case
                 // we have some type like `&<Ty as Trait>::Assoc`, since users of
                 // autoderef expect this type to have been structurally normalized.
+                // NOTE: even when we follow Receiver chain we still unwrap
+                // references and pointers here, but this is only symbolic and
+                // we are not going to really dereferences any references or pointers.
+                // That happens when autoderef is chasing the Deref chain.
                 if self.infcx.next_trait_solver()
                     && let ty::Alias(..) = ty.kind()
                 {
@@ -145,8 +148,8 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         }
     }
 
+    #[instrument(level = "debug", skip(self), ret)]
     fn overloaded_deref_ty(&mut self, ty: Ty<'tcx>) -> Option<Ty<'tcx>> {
-        debug!("overloaded_deref_ty({:?})", ty);
         let tcx = self.infcx.tcx;
 
         if ty.references_error() {
@@ -172,13 +175,13 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         // to support not-yet-defined opaque types. It will succeed for `impl Deref`
         // but fail for `impl OtherTrait`.
         if !self.infcx.predicate_may_hold_opaque_types_jank(&obligation) {
-            debug!("overloaded_deref_ty: cannot match obligation");
+            debug!("cannot match obligation");
             return None;
         }
 
         let (normalized_ty, obligations) =
             self.structurally_normalize_ty(Ty::new_projection(tcx, trait_target_def_id, [ty]))?;
-        debug!("overloaded_deref_ty({:?}) = ({:?}, {:?})", ty, normalized_ty, obligations);
+        debug!(?ty, ?normalized_ty, ?obligations);
         self.state.obligations.extend(obligations);
 
         Some(self.infcx.resolve_vars_if_possible(normalized_ty))
@@ -255,11 +258,10 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
     /// Use `core::ops::Receiver` and `core::ops::Receiver::Target` as
     /// the trait and associated type to iterate, instead of
     /// `core::ops::Deref` and `core::ops::Deref::Target`
-    pub fn use_receiver_trait(mut self) -> Self {
+    pub fn follow_receiver_chain(mut self) -> Self {
         self.use_receiver_trait = true;
         self
     }
-
     pub fn silence_errors(mut self) -> Self {
         self.silence_errors = true;
         self

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -1722,7 +1722,9 @@ fn check_method_receiver<'tcx>(
             // Report error; would not have worked with `arbitrary_self_types[_pointers]`.
             {
                 match receiver_validity_err {
-                    ReceiverValidityError::DoesNotDeref if arbitrary_self_types_level.is_some() => {
+                    ReceiverValidityError::DoesNotReceive
+                        if arbitrary_self_types_level.is_some() =>
+                    {
                         let hint = match receiver_ty
                             .builtin_deref(false)
                             .unwrap_or(receiver_ty)
@@ -1736,7 +1738,7 @@ fn check_method_receiver<'tcx>(
 
                         tcx.dcx().emit_err(errors::InvalidReceiverTy { span, receiver_ty, hint })
                     }
-                    ReceiverValidityError::DoesNotDeref => {
+                    ReceiverValidityError::DoesNotReceive => {
                         tcx.dcx().emit_err(errors::InvalidReceiverTyNoArbitrarySelfTypes {
                             span,
                             receiver_ty,
@@ -1758,7 +1760,7 @@ fn check_method_receiver<'tcx>(
 enum ReceiverValidityError {
     /// The self type does not get to the receiver type by following the
     /// autoderef chain.
-    DoesNotDeref,
+    DoesNotReceive,
     /// A type was found which is a method type parameter, and that's not allowed.
     MethodGenericParamUsed,
 }
@@ -1816,7 +1818,9 @@ fn receiver_is_valid<'tcx>(
     // types to be method receivers, as identified by following the Receiver<Target=T>
     // chain.
     if arbitrary_self_types_enabled.is_some() {
-        autoderef = autoderef.use_receiver_trait();
+        // We are in the wf check, so we would like to deref the references in the type head.
+        // However, we do not want to walk `Deref` chain.
+        autoderef = autoderef.follow_receiver_chain();
     }
 
     // The `arbitrary_self_types_pointers` feature allows raw pointer receivers like `self: *const Self`.
@@ -1870,7 +1874,7 @@ fn receiver_is_valid<'tcx>(
     }
 
     debug!("receiver_is_valid: type `{:?}` does not deref to `{:?}`", receiver_ty, self_ty);
-    Err(ReceiverValidityError::DoesNotDeref)
+    Err(ReceiverValidityError::DoesNotReceive)
 }
 
 fn legacy_receiver_is_implemented<'tcx>(

compiler/rustc_hir_typeck/src/method/confirm.rs

@@ -1,3 +1,4 @@
+use std::marker::PhantomData;
 use std::ops::Deref;
 
 use rustc_hir as hir;
@@ -350,18 +351,37 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
         // yield an object-type (e.g., `&Object` or `Box<Object>`
         // etc).
 
-        let mut autoderef = self.fcx.autoderef(self.span, self_ty);
+        let fcx = self.fcx;
+        let span = self.span;
+        let autoderef = fcx.autoderef(span, self_ty);
 
         // We don't need to gate this behind arbitrary self types
         // per se, but it does make things a bit more gated.
-        if self.tcx.features().arbitrary_self_types()
-            || self.tcx.features().arbitrary_self_types_pointers()
-        {
-            autoderef = autoderef.use_receiver_trait();
-        }
+        let follow_receiver_chain = self.tcx.features().arbitrary_self_types()
+            || self.tcx.features().arbitrary_self_types_pointers();
 
         autoderef
             .include_raw_pointers()
+            .flat_map(|(ty, derefs)| {
+                enum EitherIter<A, B, C> {
+                    A(A, PhantomData<fn() -> C>),
+                    B(B, PhantomData<fn() -> C>),
+                }
+                impl<A: Iterator<Item = C>, B: Iterator<Item = C>, C> Iterator for EitherIter<A, B, C> {
+                    type Item = C;
+                    fn next(&mut self) -> Option<Self::Item> {
+                        match self {
+                            EitherIter::A(a, _) => a.next(),
+                            EitherIter::B(b, _) => b.next(),
+                        }
+                    }
+                }
+                if follow_receiver_chain {
+                    EitherIter::A(fcx.autoderef(span, ty).follow_receiver_chain(), PhantomData)
+                } else {
+                    EitherIter::B([(ty, derefs)].into_iter(), PhantomData)
+                }
+            })
             .find_map(|(ty, _)| match ty.kind() {
                 ty::Dynamic(data, ..) => Some(closure(
                     self,