Arbitrary self types v2: new diagnostics

The RFC for arbitrary self types v2 says we'll produce the following
diagnostics in the event that a receiver isn't valid:
1. Specific diagnostics for raw pointers
2. Specific diagnostics for Weak
3. Specific diagnostics for NonNull
4. Specific diagnostics if Receiver is implemented for SmartPtr<T>, but
   not SmartPtr<T: ?Sized>

This commit implements 2 and 3, adjusts the existing diagnostics for
case 1.

For other cases, including case 4, we now instead generate additional
errors explaining why the type can't implement Receiver. This uses
existing code which is sensitive to lots of cases about why a trait may
not be implemented, and makes many helpful suggestions. At present this
emits additional separate errors.

Author: adetaylor

compiler/rustc_hir_analysis/messages.ftl

@@ -246,6 +246,12 @@ hir_analysis_invalid_receiver_ty = invalid `self` parameter type: `{$receiver_ty
 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_nonnull_note =
+    `NonNull` does not implement `Receiver`; consider wrapping your `NonNull` in a newtype wrapper for which you implement `Receiver`
+
+hir_analysis_invalid_receiver_ty_help_weak_note =
+    `Weak` does not implement `Receiver`; consider wrapping your `Weak` in a newtype wrapper for which you implement `Receiver`
+
 hir_analysis_invalid_union_field =
     field must implement `Copy` or be wrapped in `ManuallyDrop<...>` to be used in a union
     .note = union fields must not have drop side-effects, which is currently enforced via either `Copy` or `ManuallyDrop<...>`

compiler/rustc_hir_analysis/src/autoderef.rs

@@ -1,6 +1,6 @@
 use rustc_infer::infer::InferCtxt;
-use rustc_infer::traits::PredicateObligations;
-use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt};
+use rustc_infer::traits::{Obligation, PredicateObligations};
+use rustc_middle::ty::{self, Predicate, Ty, TyCtxt, TypeVisitableExt};
 use rustc_session::Limit;
 use rustc_span::Span;
 use rustc_span::def_id::{LOCAL_CRATE, LocalDefId};
@@ -44,6 +44,9 @@ pub struct Autoderef<'a, 'tcx> {
     include_raw_pointers: bool,
     use_receiver_trait: bool,
     silence_errors: bool,
+
+    // For diagnostics
+    unmet_obligation: Option<Obligation<'tcx, Predicate<'tcx>>>,
 }
 
 impl<'a, 'tcx> Iterator for Autoderef<'a, 'tcx> {
@@ -135,6 +138,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
             include_raw_pointers: false,
             use_receiver_trait: false,
             silence_errors: false,
+            unmet_obligation: None,
         }
     }
 
@@ -162,6 +166,7 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         );
         if !self.infcx.predicate_may_hold(&obligation) {
             debug!("overloaded_deref_ty: cannot match obligation");
+            self.unmet_obligation = Some(obligation);
             return None;
         }
 
@@ -236,6 +241,10 @@ impl<'a, 'tcx> Autoderef<'a, 'tcx> {
         self.state.reached_recursion_limit
     }
 
+    pub fn unmet_obligation(&mut self) -> Option<Obligation<'tcx, Predicate<'tcx>>> {
+        self.unmet_obligation.take()
+    }
+
     /// also dereference through raw pointer types
     /// e.g., assuming ptr_to_Foo is the type `*const Foo`
     /// fcx.autoderef(span, ptr_to_Foo)  => [*const Foo]

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -13,7 +13,7 @@ use rustc_hir::lang_items::LangItem;
 use rustc_infer::infer::outlives::env::OutlivesEnvironment;
 use rustc_infer::infer::{self, InferCtxt, TyCtxtInferExt};
 use rustc_macros::LintDiagnostic;
-use rustc_middle::query::Providers;
+use rustc_middle::query::{Key, Providers};
 use rustc_middle::ty::print::with_no_trimmed_paths;
 use rustc_middle::ty::trait_def::TraitSpecializationKind;
 use rustc_middle::ty::{
@@ -43,6 +43,7 @@ use {rustc_ast as ast, rustc_hir as hir};
 use crate::autoderef::Autoderef;
 use crate::collect::CollectItemTypesVisitor;
 use crate::constrained_generic_params::{Parameter, identify_constrained_generic_params};
+use crate::errors::InvalidReceiverTyHint;
 use crate::{errors, fluent_generated as fluent};
 
 pub(super) struct WfCheckingCtxt<'a, 'tcx> {
@@ -1736,7 +1737,24 @@ fn check_method_receiver<'tcx>(
             {
                 match receiver_validity_err {
                     ReceiverValidityError::DoesNotDeref => {
-                        tcx.dcx().emit_err(errors::InvalidReceiverTy { span, receiver_ty })
+                        let hint = match receiver_ty
+                            .ty_def_id()
+                            .and_then(|defid| tcx.get_diagnostic_name(defid))
+                        {
+                            Some(sym::RcWeak | sym::ArcWeak) => Some(InvalidReceiverTyHint::Weak),
+                            Some(sym::NonNull) => Some(InvalidReceiverTyHint::NonNull),
+                            _ => {
+                                emit_receiver_not_implemented_errors(
+                                    wfcx,
+                                    span,
+                                    receiver_ty,
+                                    arbitrary_self_types_level,
+                                );
+                                None
+                            }
+                        };
+
+                        tcx.dcx().emit_err(errors::InvalidReceiverTy { span, receiver_ty, hint })
                     }
                     ReceiverValidityError::MethodGenericParamUsed => {
                         tcx.dcx().emit_err(errors::InvalidGenericReceiverTy { span, receiver_ty })
@@ -1891,6 +1909,40 @@ fn legacy_receiver_is_implemented<'tcx>(
     }
 }
 
+/// Determine whether it _would have_ been possible to use `receiver_ty` as
+/// a self type if it had been `Sized`, so we can show a specialized diagnostic.
+/// This is because it's an easy mistake to `impl<T> Receiver` instead of
+/// `impl<T: ?Sized> Receiver`.
+fn emit_receiver_not_implemented_errors<'tcx>(
+    wfcx: &WfCheckingCtxt<'_, 'tcx>,
+    span: Span,
+    receiver_ty: Ty<'tcx>,
+    arbitrary_self_types_enabled: Option<ArbitrarySelfTypesLevel>,
+) {
+    let infcx = wfcx.infcx;
+    let mut autoderef = Autoderef::new(infcx, wfcx.param_env, wfcx.body_def_id, span, receiver_ty)
+        .use_receiver_trait();
+
+    if arbitrary_self_types_enabled.is_some() {
+        autoderef = autoderef.use_receiver_trait();
+    }
+    if arbitrary_self_types_enabled == Some(ArbitrarySelfTypesLevel::WithPointers) {
+        autoderef = autoderef.include_raw_pointers();
+    }
+
+    while let Some((_, _)) = autoderef.next() {
+        // Iterate as far along the `Receiver::Target` hop chain as we can.
+    }
+    if let Some(unmet_obligation) = autoderef.unmet_obligation() {
+        let ocx = traits::ObligationCtxt::new_with_diagnostics(&infcx);
+        ocx.register_obligation(unmet_obligation);
+        let errors = ocx.select_all_or_error();
+        if !errors.is_empty() {
+            infcx.err_ctxt().report_fulfillment_errors(errors);
+        }
+    }
+}
+
 fn check_variances_for_type_defn<'tcx>(
     tcx: TyCtxt<'tcx>,
     item: &'tcx hir::Item<'tcx>,

compiler/rustc_hir_analysis/src/errors.rs

@@ -1646,6 +1646,14 @@ pub(crate) struct NonConstRange {
     pub span: Span,
 }
 
+#[derive(Subdiagnostic)]
+pub(crate) enum InvalidReceiverTyHint {
+    #[note(hir_analysis_invalid_receiver_ty_help_weak_note)]
+    Weak,
+    #[note(hir_analysis_invalid_receiver_ty_help_nonnull_note)]
+    NonNull,
+}
+
 #[derive(Diagnostic)]
 #[diag(hir_analysis_invalid_receiver_ty, code = E0307)]
 #[note]
@@ -1654,6 +1662,8 @@ pub(crate) struct InvalidReceiverTy<'tcx> {
     #[primary_span]
     pub span: Span,
     pub receiver_ty: Ty<'tcx>,
+    #[subdiagnostic]
+    pub hint: Option<InvalidReceiverTyHint>,
 }
 
 #[derive(Diagnostic)]

tests/ui/async-await/inference_var_self_argument.stderr

@@ -1,3 +1,11 @@
+error[E0277]: the trait bound `dyn Foo: std::ops::Receiver` is not satisfied
+  --> $DIR/inference_var_self_argument.rs:5:24
+   |
+LL |     async fn foo(self: &dyn Foo) {
+   |                        ^^^^^^^^ the trait `Deref` is not implemented for `dyn Foo`
+   |
+   = note: required for `dyn Foo` to implement `std::ops::Receiver`
+
 error[E0307]: invalid `self` parameter type: `&dyn Foo`
   --> $DIR/inference_var_self_argument.rs:5:24
    |
@@ -22,7 +30,7 @@ LL |     async fn foo(self: &dyn Foo) {
    |              ^^^ ...because method `foo` is `async`
    = help: consider moving `foo` to another trait
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-Some errors have detailed explanations: E0038, E0307.
+Some errors have detailed explanations: E0038, E0277, E0307.
 For more information about an error, try `rustc --explain E0038`.

tests/ui/async-await/issue-66312.stderr

@@ -1,3 +1,15 @@
+error[E0277]: the trait bound `T: std::ops::Receiver` is not satisfied
+  --> $DIR/issue-66312.rs:4:22
+   |
+LL |     fn is_some(self: T);
+   |                      ^ the trait `Deref` is not implemented for `T`
+   |
+   = note: required for `T` to implement `std::ops::Receiver`
+help: consider restricting type parameter `T`
+   |
+LL | trait Test<T: std::ops::Deref> {
+   |             +++++++++++++++++
+
 error[E0307]: invalid `self` parameter type: `T`
   --> $DIR/issue-66312.rs:4:22
    |
@@ -13,7 +25,7 @@ error[E0308]: mismatched types
 LL |     if x.is_some() {
    |        ^^^^^^^^^^^ expected `bool`, found `()`
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
-Some errors have detailed explanations: E0307, E0308.
-For more information about an error, try `rustc --explain E0307`.
+Some errors have detailed explanations: E0277, E0307, E0308.
+For more information about an error, try `rustc --explain E0277`.

tests/ui/feature-gates/feature-gate-dispatch-from-dyn-cell.stderr

@@ -1,3 +1,11 @@
+error[E0277]: the trait bound `Cell<&Self>: std::ops::Receiver` is not satisfied
+  --> $DIR/feature-gate-dispatch-from-dyn-cell.rs:6:19
+   |
+LL |     fn cell(self: Cell<&Self>);
+   |                   ^^^^^^^^^^^ the trait `Deref` is not implemented for `Cell<&Self>`
+   |
+   = note: required for `Cell<&Self>` to implement `std::ops::Receiver`
+
 error[E0307]: invalid `self` parameter type: `Cell<&Self>`
   --> $DIR/feature-gate-dispatch-from-dyn-cell.rs:6:19
    |
@@ -7,6 +15,7 @@ LL |     fn cell(self: Cell<&Self>);
    = note: type of `self` must be `Self` or some type implementing Receiver
    = 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>`
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0307`.
+Some errors have detailed explanations: E0277, E0307.
+For more information about an error, try `rustc --explain E0277`.

tests/ui/issues/issue-56806.stderr

@@ -1,3 +1,11 @@
+error[E0277]: the trait bound `(dyn Trait + 'static): std::ops::Receiver` is not satisfied
+  --> $DIR/issue-56806.rs:2:34
+   |
+LL |     fn dyn_instead_of_self(self: Box<dyn Trait>);
+   |                                  ^^^^^^^^^^^^^^ the trait `Deref` is not implemented for `(dyn Trait + 'static)`
+   |
+   = note: required for `(dyn Trait + 'static)` to implement `std::ops::Receiver`
+
 error[E0307]: invalid `self` parameter type: `Box<(dyn Trait + 'static)>`
   --> $DIR/issue-56806.rs:2:34
    |
@@ -7,6 +15,7 @@ LL |     fn dyn_instead_of_self(self: Box<dyn Trait>);
    = note: type of `self` must be `Self` or some type implementing Receiver
    = 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>`
 
-error: aborting due to 1 previous error
+error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0307`.
+Some errors have detailed explanations: E0277, E0307.
+For more information about an error, try `rustc --explain E0277`.

tests/ui/self/arbitrary-self-opaque.stderr

@@ -1,3 +1,11 @@
+error[E0277]: the trait bound `Bar: std::ops::Receiver` is not satisfied
+  --> $DIR/arbitrary-self-opaque.rs:8:18
+   |
+LL |     fn foo(self: Bar) {}
+   |                  ^^^ the trait `Deref` is not implemented for `Bar`
+   |
+   = note: required for `Bar` to implement `std::ops::Receiver`
+
 error[E0307]: invalid `self` parameter type: `Bar`
   --> $DIR/arbitrary-self-opaque.rs:8:18
    |
@@ -28,6 +36,7 @@ LL | type Bar = impl Sized;
    |
    = note: `Bar` must be used in combination with a concrete type within the same module
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
-For more information about this error, try `rustc --explain E0307`.
+Some errors have detailed explanations: E0277, E0307.
+For more information about an error, try `rustc --explain E0277`.

tests/ui/self/arbitrary_self_types_nonnull.rs

@@ -0,0 +1,13 @@
+#[feature(arbitrary_self_types)]
+
+struct A;
+
+impl A {
+    fn m(self: std::ptr::NonNull<Self>) {}
+    //~^ ERROR: invalid `self` parameter type
+    fn n(self: &std::ptr::NonNull<Self>) {}
+    //~^ ERROR: invalid `self` parameter type
+}
+
+fn main() {
+}