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_data_structures/src/intern.rs

@@ -2,6 +2,8 @@ use std::cmp::Ordering;
 use std::fmt::{self, Debug};
 use std::hash::{Hash, Hasher};
 use std::ops::Deref;
+#[cfg(not(bootstrap))]
+use std::ops::Receiver;
 use std::ptr;
 
 use crate::stable_hasher::{HashStable, StableHasher};
@@ -54,6 +56,11 @@ impl<'a, T> Deref for Interned<'a, T> {
     }
 }
 
+#[cfg(not(bootstrap))]
+impl<'a, T> Receiver for Interned<'a, T> {
+    type Target = T;
+}
+
 impl<'a, T> PartialEq for Interned<'a, T> {
     #[inline]
     fn eq(&self, other: &Self) -> bool {

compiler/rustc_data_structures/src/lib.rs

@@ -12,6 +12,7 @@
 #![allow(rustc::potential_query_instability)]
 #![deny(unsafe_op_in_unsafe_fn)]
 #![feature(allocator_api)]
+#![feature(arbitrary_self_types)]
 #![feature(ascii_char)]
 #![feature(ascii_char_variants)]
 #![feature(assert_matches)]

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_feature/src/unstable.rs

@@ -351,6 +351,8 @@ declare_features! (
     (unstable, arbitrary_self_types, "1.23.0", Some(44874)),
     /// Allows inherent and trait methods with arbitrary self types that are raw pointers.
     (unstable, arbitrary_self_types_pointers, "1.83.0", Some(44874)),
+    /// Enforce agreement between `Receiver::Target` and `Deref::Target`
+    (unstable, arbitrary_self_types_split_chains, "1.23.0", Some(44874)),
     /// Target features on arm.
     (unstable, arm_target_feature, "1.27.0", Some(150246)),
     /// Enables experimental inline assembly support for additional architectures.

compiler/rustc_hir_analysis/src/autoderef.rs

@@ -1,3 +1,6 @@
+use std::cell::RefCell;
+
+use rustc_data_structures::unord::UnordMap;
 use rustc_hir::limit::Limit;
 use rustc_infer::infer::InferCtxt;
 use rustc_infer::traits::PredicateObligations;
@@ -26,6 +29,39 @@ struct AutoderefSnapshot<'tcx> {
     obligations: PredicateObligations<'tcx>,
 }
 
+#[derive(Debug, Default)]
+pub struct AutoderefCache<'tcx> {
+    next_deref: RefCell<UnordMap<Ty<'tcx>, (Ty<'tcx>, PredicateObligations<'tcx>)>>,
+    next_receiver: RefCell<UnordMap<Ty<'tcx>, (Ty<'tcx>, PredicateObligations<'tcx>)>>,
+}
+
+impl<'tcx> AutoderefCache<'tcx> {
+    pub fn get(
+        &self,
+        use_receiver: bool,
+        ty: Ty<'tcx>,
+    ) -> Option<(Ty<'tcx>, PredicateObligations<'tcx>)> {
+        if use_receiver {
+            self.next_receiver.borrow().get(&ty).cloned()
+        } else {
+            self.next_deref.borrow().get(&ty).cloned()
+        }
+    }
+    pub fn cache(
+        &self,
+        use_receiver: bool,
+        ty: Ty<'tcx>,
+        next: Ty<'tcx>,
+        predicates: PredicateObligations<'tcx>,
+    ) {
+        if use_receiver {
+            self.next_receiver.borrow_mut().insert(ty, (next, predicates));
+        } else {
+            self.next_deref.borrow_mut().insert(ty, (next, predicates));
+        }
+    }
+}
+
 /// Recursively dereference a type, considering both built-in
 /// dereferences (`*`) and the `Deref` trait.
 /// Although called `Autoderef` it can be configured to use the
@@ -36,6 +72,7 @@ pub struct Autoderef<'a, 'tcx> {
     span: Span,
     body_id: LocalDefId,
     param_env: ty::ParamEnv<'tcx>,
+    cache: Option<&'a AutoderefCache<'tcx>>,
 
     // Current state:
     state: AutoderefSnapshot<'tcx>,
@@ -80,16 +117,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()
                 {
@@ -122,13 +162,15 @@ impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
 impl<'a, 'tcx> Autoderef<'a, 'tcx> {
     pub fn new(
         infcx: &'a InferCtxt<'tcx>,
+        cache: Option<&'a AutoderefCache<'tcx>>,
         param_env: ty::ParamEnv<'tcx>,
         body_def_id: LocalDefId,
         span: Span,
         base_ty: Ty<'tcx>,
     ) -> Self {
         Autoderef {
             infcx,
+            cache,
             span,
             body_id: body_def_id,
             param_env,
@@ -145,13 +187,19 @@ 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() {
             return None;
         }
+        if let Some(cache) = &self.cache
+            && let Some((ty, obligations)) = cache.get(self.use_receiver_trait, self.state.cur_ty)
+        {
+            self.state.obligations.extend(obligations);
+            return Some(ty);
+        }
 
         // <ty as Deref>, or whatever the equivalent trait is that we've been asked to walk.
         let (trait_def_id, trait_target_def_id) = if self.use_receiver_trait {
@@ -167,18 +215,23 @@ 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);
+        if matches!(ty.kind(), ty::Adt(..))
+            && let Some(cache) = &self.cache
+        {
+            cache.cache(self.use_receiver_trait, ty, normalized_ty, obligations.clone());
+        }
         self.state.obligations.extend(obligations);
 
         Some(self.infcx.resolve_vars_if_possible(normalized_ty))
@@ -255,11 +308,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

@@ -1773,7 +1773,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)
@@ -1787,7 +1789,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,
@@ -1809,7 +1811,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,
 }
@@ -1865,17 +1867,21 @@ fn receiver_is_valid<'tcx>(
 
     confirm_type_is_not_a_method_generic_param(receiver_ty, method_generics)?;
 
-    let mut autoderef = Autoderef::new(infcx, wfcx.param_env, wfcx.body_def_id, span, receiver_ty);
+    let cache = Default::default();
+    let mut autoderef =
+        Autoderef::new(infcx, Some(&cache), 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();
     }
 
@@ -1929,7 +1935,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>(