Enable experimentation with split/merged chains

To allow use of Receiver with Target diverging from Deref::Target,
one must now enable an unstable feature flag arbitrary-self-types-split-chains.

Signed-off-by: Xiangfei Ding <dingxiangfei2009@protonmail.ch>

Author: dingxiangfei2009

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

@@ -149,6 +149,11 @@ 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_deref_receiver_target_diverge_feature = `Receiver::Target` diverging from `Deref::Target` is not supported, we look forward to your feedback
+
 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

@@ -16,13 +16,14 @@ use rustc_middle::ty::print::PrintTraitRefExt as _;
 use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeVisitableExt, TypingMode, suggest_constraining_type_params,
 };
+use rustc_session::parse::feature_err;
 use rustc_span::{DUMMY_SP, Span, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 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 +49,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 +757,55 @@ 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_split_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,
+    ) {
+        feature_err(
+            tcx.sess,
+            sym::arbitrary_self_types_split_chains,
+            span,
+            crate::fluent_generated::hir_analysis_deref_receiver_target_diverge_feature,
+        )
+        .emit();
+        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

@@ -1075,6 +1075,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

@@ -477,6 +477,7 @@ symbols! {
         arbitrary_enum_discriminant,
         arbitrary_self_types,
         arbitrary_self_types_pointers,
+        arbitrary_self_types_split_chains,
         areg,
         args,
         arith_offset,

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

@@ -0,0 +1,59 @@
+// gate-test-arbitrary_self_types_split_chains
+
+#![feature(arbitrary_self_types)]
+
+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`
+    //~| ERROR `Receiver::Target` diverging from `Deref::Target` is not supported
+    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`
+    //~| ERROR `Receiver::Target` diverging from `Deref::Target` is not supported
+    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,47 @@
+error[E0658]: `Receiver::Target` diverging from `Deref::Target` is not supported, we look forward to your feedback
+  --> $DIR/arbitrary-self-types-merge-chains.rs:15:1
+   |
+LL | impl Receiver for A {
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #44874 <https://github.com/rust-lang/rust/issues/44874> for more information
+   = help: add `#![feature(arbitrary_self_types_split_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: `Deref::Target` does not agree with `Receiver::Target`
+  --> $DIR/arbitrary-self-types-merge-chains.rs:15: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:15:1
+   |
+LL | impl Receiver for A {
+   | ^^^^^^^^^^^^^^^^^^^
+
+error[E0658]: `Receiver::Target` diverging from `Deref::Target` is not supported, we look forward to your feedback
+  --> $DIR/arbitrary-self-types-merge-chains.rs:28:1
+   |
+LL | impl<'a, T> Receiver for B<'a, T> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #44874 <https://github.com/rust-lang/rust/issues/44874> for more information
+   = help: add `#![feature(arbitrary_self_types_split_chains)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+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 4 previous errors
+
+For more information about this error, try `rustc --explain E0658`.

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

@@ -0,0 +1,30 @@
+//@ check-pass
+
+#![feature(arbitrary_self_types)]
+#![feature(arbitrary_self_types_split_chains)]
+
+use std::ops::{Deref, Receiver};
+
+struct A;
+impl Deref for A {
+    type Target = u8;
+    fn deref(&self) -> &u8 {
+        &0
+    }
+}
+impl Receiver for A {
+    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> {
+    type Target = Box<T>;
+}
+
+fn main() {}