Arbitrary self types v2: new diagnostics (part)

Part-implement new diagnostics specified in the RFC,
and leave TODOs for the rest.

Author: adetaylor

compiler/rustc_hir_analysis/messages.ftl

@@ -246,6 +246,10 @@ 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_pointer_note =
+    Raw pointers do not implement Receiver. Consider wrapping your pointer 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/check/wfcheck.rs

@@ -1677,6 +1677,16 @@ fn check_method_receiver<'tcx>(
     };
     let generics = tcx.generics_of(method.def_id);
 
+    // yet to do: determine whether self_ty is Sized. If not (most commonly
+    // if it's a trait) determine whether receiver_ty::Target is Sized.
+    // If so, arrange to emit the extra help in _HELP_FOR_SIZED_SELF_TYPE.
+    // Then adjust tests/ui/self/arbitrary_self_types_sizedness_trait.rs
+    // to match.
+    // yet to do: determine whether self_ty is NonNull or Weak, and use
+    // _HELP_FOR_NONNULL and _HELP_FOR_WEAK as appropriate. No tests yet
+    // exist for this.
+    let raw_pointer = is_raw_pointer(receiver_ty);
+
     let receiver_validity =
         receiver_is_valid(wfcx, span, receiver_ty, self_ty, arbitrary_self_types_level, generics);
     if let Err(receiver_validity_err) = receiver_validity {
@@ -1735,9 +1745,9 @@ fn check_method_receiver<'tcx>(
             // Report error; would not have worked with `arbitrary_self_types[_pointers]`.
             {
                 match receiver_validity_err {
-                    ReceiverValidityError::DoesNotDeref => {
-                        tcx.dcx().emit_err(errors::InvalidReceiverTy { span, receiver_ty })
-                    }
+                    ReceiverValidityError::DoesNotDeref => tcx
+                        .dcx()
+                        .emit_err(errors::InvalidReceiverTy { span, receiver_ty, raw_pointer }),
                     ReceiverValidityError::MethodGenericParamUsed => {
                         tcx.dcx().emit_err(errors::InvalidGenericReceiverTy { span, receiver_ty })
                     }
@@ -1773,6 +1783,10 @@ fn confirm_type_is_not_a_method_generic_param(
     Ok(())
 }
 
+fn is_raw_pointer<'tcx>(ty: Ty<'tcx>) -> bool {
+    matches!(ty.kind(), ty::RawPtr(..))
+}
+
 /// Returns whether `receiver_ty` would be considered a valid receiver type for `self_ty`. If
 /// `arbitrary_self_types` is enabled, `receiver_ty` must transitively deref to `self_ty`, possibly
 /// through a `*const/mut T` raw pointer if  `arbitrary_self_types_pointers` is also enabled.

compiler/rustc_hir_analysis/src/errors.rs

@@ -1653,6 +1653,8 @@ pub(crate) struct InvalidReceiverTy<'tcx> {
     #[primary_span]
     pub span: Span,
     pub receiver_ty: Ty<'tcx>,
+    #[note(hir_analysis_invalid_receiver_ty_help_pointer_note)]
+    pub raw_pointer: bool,
 }
 
 #[derive(Diagnostic)]

tests/ui/self/arbitrary_self_types_pointer.rs

@@ -0,0 +1,19 @@
+#![feature(arbitrary_self_types)]
+
+struct A;
+
+impl A {
+    fn m(self: *const Self) {}
+    //~^ ERROR: `*const A` cannot be used as the type of `self` without the `arbitrary_self_types_pointers` feature
+}
+
+trait B {
+    fn bm(self: *const Self) {}
+    //~^ ERROR: `*const Self` cannot be used as the type of `self` without the `arbitrary_self_types_pointers` feature
+}
+
+fn main() {
+    let a = A;
+    let ptr = &a as *const A;
+    ptr.m();
+}

tests/ui/self/arbitrary_self_types_pointer.stderr

@@ -0,0 +1,25 @@
+error[E0658]: `*const A` cannot be used as the type of `self` without the `arbitrary_self_types_pointers` feature
+  --> $DIR/arbitrary_self_types_pointer.rs:6:16
+   |
+LL |     fn m(self: *const Self) {}
+   |                ^^^^^^^^^^^
+   |
+   = note: see issue #44874 <https://github.com/rust-lang/rust/issues/44874> for more information
+   = help: add `#![feature(arbitrary_self_types_pointers)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = 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[E0658]: `*const Self` cannot be used as the type of `self` without the `arbitrary_self_types_pointers` feature
+  --> $DIR/arbitrary_self_types_pointer.rs:11:17
+   |
+LL |     fn bm(self: *const Self) {}
+   |                 ^^^^^^^^^^^
+   |
+   = note: see issue #44874 <https://github.com/rust-lang/rust/issues/44874> for more information
+   = help: add `#![feature(arbitrary_self_types_pointers)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+   = 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 2 previous errors
+
+For more information about this error, try `rustc --explain E0658`.

tests/ui/self/arbitrary_self_types_sizedness_trait.rs

@@ -0,0 +1,24 @@
+#![feature(arbitrary_self_types)]
+
+struct SmartPtr<'a, T: ?Sized>(&'a T);
+
+impl<T> std::ops::Receiver for SmartPtr<'_, T> {
+    type Target = T;
+}
+
+struct A;
+
+trait B {
+    fn m(self: SmartPtr<Self>) {}
+    //~^ ERROR: invalid `self` parameter type
+}
+
+impl B for A {
+    fn m(self: SmartPtr<Self>) {}
+}
+
+fn main() {
+    let a = A;
+    let a = SmartPtr(&A);
+    a.m();
+}

tests/ui/self/arbitrary_self_types_sizedness_trait.stderr

@@ -0,0 +1,12 @@
+error[E0307]: invalid `self` parameter type: `SmartPtr<'_, Self>`
+  --> $DIR/arbitrary_self_types_sizedness_trait.rs:12:16
+   |
+LL |     fn m(self: SmartPtr<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
+
+For more information about this error, try `rustc --explain E0307`.