arbitrary_self_types: Split the Autoderef chain

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/messages.ftl

@@ -264,7 +264,8 @@ hir_analysis_invalid_receiver_ty_help =
     consider changing to `self`, `&self`, `&mut self`, or a type implementing `Receiver` such as `self: Box<Self>`, `self: Rc<Self>`, or `self: Arc<Self>`
 
 hir_analysis_invalid_receiver_ty_help_no_arbitrary_self_types =
-    consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
+    consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`);
+    alternatively, consider implement `Receiver` trait on the type of `self`, where applicable
 
 hir_analysis_invalid_receiver_ty_help_nonnull_note =
     `NonNull` does not implement `Receiver` because it has methods that may shadow the referent; consider wrapping your `NonNull` in a newtype wrapper for which you implement `Receiver`

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() {
@@ -167,18 +170,18 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
             self.param_env,
             ty::Binder::dummy(trait_ref),
         );
-        // We detect whether the self type implements `Deref` before trying to
+        // We detect whether the self type implements `Deref`/`Receiver` before trying to
         // structurally normalize. We use `predicate_may_hold_opaque_types_jank`
         // 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,
 }
@@ -1817,14 +1819,16 @@ fn receiver_is_valid<'tcx>(
     let mut autoderef = Autoderef::new(infcx, wfcx.param_env, wfcx.body_def_id, span, receiver_ty);
 
     // The `arbitrary_self_types` feature allows custom smart pointer
-    // types to be method receivers, as identified by following the Receiver<Target=T>
+    // 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`.
-    if arbitrary_self_types_enabled == Some(ArbitrarySelfTypesLevel::WithPointers) {
+    if matches!(arbitrary_self_types_enabled, Some(ArbitrarySelfTypesLevel::WithPointers)) {
         autoderef = autoderef.include_raw_pointers();
     }
 
@@ -1878,7 +1882,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,