enable experimentation with merged chains

Author: dingxiangfei2009

compiler/rustc_feature/src/unstable.rs

@@ -380,6 +380,8 @@ declare_features! (
     (unstable, alloc_error_handler, "1.29.0", Some(51540)),
     /// Allows inherent and trait methods with arbitrary self types.
     (unstable, arbitrary_self_types, "1.23.0", Some(44874)),
+    /// Enforce agreement between `Receiver::Target` and `Deref::Target`
+    (unstable, arbitrary_self_types_merge_chains, "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)),
     /// Allows #[cfg(...)] on inline assembly templates and operands.

compiler/rustc_hir_analysis/messages.ftl

@@ -149,6 +149,10 @@ hir_analysis_cross_crate_traits = cross-crate traits with a default impl, like `
 hir_analysis_cross_crate_traits_defined = cross-crate traits with a default impl, like `{$traits}`, can only be implemented for a struct/enum type defined in the current crate
     .label = can't implement cross-crate trait for type in another crate
 
+hir_analysis_deref_receiver_target_diverge = `Deref::Target` does not agree with `Receiver::Target`
+    .label = `Deref::Target` is `{$deref_ty}` but `Receiver::Target` is `{$recv_ty}`
+    .note = `#![feature(arbitrary_self_types_merge_chains)]` rejects this kind of divergence
+
 hir_analysis_dispatch_from_dyn_repr = structs implementing `DispatchFromDyn` may not have `#[repr(packed)]` or `#[repr(C)]`
 
 hir_analysis_dispatch_from_dyn_zst = the trait `DispatchFromDyn` may only be implemented for structs containing the field being coerced, ZST fields with 1 byte alignment that don't mention type/const generics, and nothing else

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -22,7 +22,7 @@ use rustc_trait_selection::traits::misc::{
     ConstParamTyImplementationError, CopyImplementationError, InfringingFieldsReason,
     type_allowed_to_implement_const_param_ty, type_allowed_to_implement_copy,
 };
-use rustc_trait_selection::traits::{self, ObligationCause, ObligationCtxt};
+use rustc_trait_selection::traits::{self, NormalizeExt, ObligationCause, ObligationCtxt};
 use tracing::debug;
 
 use crate::errors;
@@ -48,6 +48,7 @@ pub(super) fn check_trait<'tcx>(
         lang_items.coerce_pointee_validated_trait(),
         visit_implementation_of_coerce_pointee_validity,
     )?;
+    checker.check(lang_items.receiver_trait(), visit_implementation_of_receiver)?;
     Ok(())
 }
 
@@ -755,3 +756,48 @@ fn visit_implementation_of_coerce_pointee_validity(
     }
     Ok(())
 }
+
+fn visit_implementation_of_receiver(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
+    let tcx = checker.tcx;
+    if !tcx.features().arbitrary_self_types_merge_chains() {
+        return Ok(());
+    }
+    let impl_did = checker.impl_def_id;
+    let span = tcx.def_span(impl_did);
+    let deref_target_did = tcx.require_lang_item(LangItem::DerefTarget, span);
+    let receiver_target_did = tcx.require_lang_item(LangItem::ReceiverTarget, span);
+    let self_ty = tcx.impl_trait_ref(impl_did).instantiate_identity().self_ty();
+    let param_env = tcx.param_env(impl_did);
+    let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
+    let ocx = ObligationCtxt::new(&infcx);
+    let cause = ObligationCause::misc(span, impl_did);
+    ocx.register_obligation(Obligation::new(
+        tcx,
+        cause.clone(),
+        param_env,
+        ty::TraitRef::new(tcx, tcx.require_lang_item(LangItem::Deref, span), [self_ty]),
+    ));
+    if !ocx.evaluate_obligations_error_on_ambiguity().is_empty() {
+        // We cannot enforce Deref::Target == Receiver::Target because we cannot find `impl Deref`
+        return Ok(());
+    }
+    let infer::InferOk { value: deref_target_ty, .. } = infcx.at(&cause, param_env).normalize(
+        Ty::new_projection_from_args(tcx, deref_target_did, tcx.mk_args(&[self_ty.into()])),
+    );
+    let infer::InferOk { value: receiver_target_ty, .. } = infcx.at(&cause, param_env).normalize(
+        Ty::new_projection_from_args(tcx, receiver_target_did, tcx.mk_args(&[self_ty.into()])),
+    );
+    if let Err(_) = infcx.at(&cause, param_env).eq(
+        infer::DefineOpaqueTypes::No,
+        deref_target_ty,
+        receiver_target_ty,
+    ) {
+        Err(tcx.dcx().emit_err(errors::DerefReceiverTargetDiverge {
+            span,
+            deref_ty: deref_target_ty,
+            recv_ty: receiver_target_ty,
+        }))
+    } else {
+        Ok(())
+    }
+}

compiler/rustc_hir_analysis/src/errors.rs

@@ -1156,6 +1156,17 @@ pub(crate) struct CoercePointeeNoField {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_analysis_deref_receiver_target_diverge)]
+pub(crate) struct DerefReceiverTargetDiverge<'a> {
+    #[primary_span]
+    #[label]
+    #[note]
+    pub span: Span,
+    pub deref_ty: Ty<'a>,
+    pub recv_ty: Ty<'a>,
+}
+
 #[derive(Diagnostic)]
 #[diag(hir_analysis_inherent_ty_outside_relevant, code = E0390)]
 #[help]

compiler/rustc_span/src/symbol.rs

@@ -463,6 +463,7 @@ symbols! {
         apx_target_feature,
         arbitrary_enum_discriminant,
         arbitrary_self_types,
+        arbitrary_self_types_merge_chains,
         arbitrary_self_types_pointers,
         areg,
         args,

tests/ui/self/arbitrary-self-types-merge-chains.rs

@@ -0,0 +1,58 @@
+// gate-test-arbitrary_self_types_merge_chains
+
+#![feature(arbitrary_self_types)]
+#![feature(arbitrary_self_types_merge_chains)]
+
+use std::marker::PhantomData;
+use std::ops::{Deref, Receiver};
+
+struct A;
+impl Deref for A {
+    type Target = u8;
+    fn deref(&self) -> &u8 {
+        &0
+    }
+}
+impl Receiver for A {
+    //~^ ERROR `Deref::Target` does not agree with `Receiver::Target`
+    type Target = u32;
+}
+
+struct B<'a, T>(&'a T);
+impl<'a, T> Deref for B<'a, T> {
+    type Target = T;
+    fn deref(&self) -> &T {
+        &*self.0
+    }
+}
+impl<'a, T> Receiver for B<'a, T> {
+    //~^ ERROR `Deref::Target` does not agree with `Receiver::Target`
+    type Target = Box<T>;
+}
+
+struct C<'a, T>(&'a T);
+impl<'a, T> Deref for C<'a, T> {
+    type Target = Self;
+    fn deref(&self) -> &Self {
+        self
+    }
+}
+impl<'b, T> Receiver for C<'b, T> {
+    type Target = Self; // OK
+}
+
+struct D<T>(PhantomData<fn() -> T>);
+trait Trait {
+    type Output;
+}
+impl<T: Trait<Output = T>> Deref for D<T> {
+    type Target = T::Output;
+    fn deref(&self) -> &T {
+        unimplemented!()
+    }
+}
+impl<T> Receiver for D<T> {
+    type Target = T; // OK
+}
+
+fn main() {}

tests/ui/self/arbitrary-self-types-merge-chains.stderr

@@ -0,0 +1,26 @@
+error: `Deref::Target` does not agree with `Receiver::Target`
+  --> $DIR/arbitrary-self-types-merge-chains.rs:16:1
+   |
+LL | impl Receiver for A {
+   | ^^^^^^^^^^^^^^^^^^^ `Deref::Target` is `u8` but `Receiver::Target` is `u32`
+   |
+note: `#![feature(arbitrary_self_types_merge_chains)]` rejects this kind of divergence
+  --> $DIR/arbitrary-self-types-merge-chains.rs:16:1
+   |
+LL | impl Receiver for A {
+   | ^^^^^^^^^^^^^^^^^^^
+
+error: `Deref::Target` does not agree with `Receiver::Target`
+  --> $DIR/arbitrary-self-types-merge-chains.rs:28:1
+   |
+LL | impl<'a, T> Receiver for B<'a, T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `Deref::Target` is `T` but `Receiver::Target` is `Box<T>`
+   |
+note: `#![feature(arbitrary_self_types_merge_chains)]` rejects this kind of divergence
+  --> $DIR/arbitrary-self-types-merge-chains.rs:28:1
+   |
+LL | impl<'a, T> Receiver for B<'a, T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+