*const Self method can't be called with *mut Self (arbitrary_self_types)

[osa1]

Using nightly 2020-12-03, this doesn't build: (play link)

#![feature(arbitrary_self_types)]

struct Test {}

impl Test {
    fn x(self: *const Self) {}
}

fn main() {
    let ptr: *mut Test = std::ptr::null_mut();
    ptr.x();
}

Error:

error[E0599]: no method named `x` found for raw pointer `*mut Test` in the current scope
  --> src/main.rs:11:9
   |
11 |     ptr.x();
   |         ^ method not found in `*mut Test`
   |
   = note: try using `<*const T>::as_ref()` to get a reference to the type behind the pointer: https://doc.rust-lang.org/std/primitive.pointer.html#method.as_ref
   = note: using `<*const T>::as_ref()` on a pointer which is unaligned or points to invalid or uninitialized memory is undefined behavior

error: aborting due to previous error

I think similar to how &self methods can be called on &mut references, *const Self methods should be allowed to be called on *mut pointers.

[osa1]

Also note that I can assign/copy a *mut pointer to a *const variable just fine:

struct Test {}

fn main() {
    let ptr: *mut Test = std::ptr::null_mut();
    let ptr_: *const Test = ptr;
}

[osa1]

If you agree that this is a bug/ something to improve I'm happy to implement/fix this myself. Would be good to know where to start reading the code though..

[camelid]

That does seem like a bug, though I'm not super knowledgeable about this so I'm not certain.

[camelid]

@osa1 Looks like the check is performed here:

rust/compiler/rustc_typeck/src/check/wfcheck.rs

Lines 1053 to 1058 in 11c94a1

	fn check_method_receiver<'fcx, 'tcx>(
	fcx: &FnCtxt<'fcx, 'tcx>,
	fn_sig: &hir::FnSig<'_>,
	method: &ty::AssocItem,
	self_ty: Ty<'tcx>,
	) {

and here:

rust/compiler/rustc_typeck/src/check/wfcheck.rs

Lines 1125 to 1140 in 11c94a1

	/// 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 the feature is not enabled, the requirements are more
	/// strict: `receiver_ty` must implement `Receiver` and directly implement
	/// `Deref<Target = self_ty>`.
	///
	/// N.B., there are cases this function returns `true` but causes an error to be emitted,
	/// particularly when `receiver_ty` derefs to a type that is the same as `self_ty` but has the
	/// wrong lifetime. Be careful of this if you are calling this function speculatively.
	fn receiver_is_valid<'fcx, 'tcx>(
	fcx: &FnCtxt<'fcx, 'tcx>,
	span: Span,
	receiver_ty: Ty<'tcx>,
	self_ty: Ty<'tcx>,
	arbitrary_self_types_enabled: bool,
	) -> bool {

[camelid]

By the way, a tip is to grep or ripgrep through the source for the name of the feature. In this case, I did rg 'arbitrary_self_types' compiler/.

[osa1]

Is this comment relevant to this issue?

rust/compiler/rustc_middle/src/ty/sty.rs

Lines 1991 to 1992 in 463ce40

	/// The parameter `explicit` indicates if this is an *explicit* dereference.
	/// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.

Removing the if explicit guard in the pointer case in that code does not make any difference for this issue.

[camelid]

Is this comment relevant to this issue?

rust/compiler/rustc_middle/src/ty/sty.rs

Lines 1991 to 1992 in 463ce40

	/// The parameter `explicit` indicates if this is an *explicit* dereference.
	/// Some types -- notably unsafe ptrs -- can only be dereferenced explicitly.

Removing the if explicit guard in the pointer case in that code does not make any difference for this issue.

I’m not certain, but I don’t think so. The issue is not about deref but about pointer covariance (at least I think that’s the right word!). But I’m not knowledge enough to know where the issue is.

I recommend asking in the t-compiler/help stream on Zulip. Someone more knowledgeable about this part of the compiler can help you there.

[osa1]

I think I have an idea on what's going on. When resolving method receivers, in these lines:

rust/compiler/rustc_typeck/src/check/method/probe.rs

Lines 1069 to 1071 in fc93e47

	// skip types that are from a type error or that would require dereferencing
	// a raw pointer
	!step.self_ty.references_error() && !step.from_unsafe_deref

we don't consider Test (in my example above) as a potential receiver, as that would require dereferencing the pointer, which is unsafe.

However without considering Test as a potential receiver we can't consider &Test or *const Test as potential receivers. There's no other way currently to go from a *mut Test to &Test or *const Test.

I tried removing the !step.from_unsafe_deref guard in the code above to try this out but it did not fix this issue. So perhaps this is not the full story yet.

[osa1]

This code seems relevant:

rust/compiler/rustc_typeck/src/check/method/probe.rs

Lines 1113 to 1117 in fc93e47

	// Insert a `&*` or `&mut *` if this is a reference type:
	if let ty::Ref(_, _, mutbl) = *step.self_ty.value.value.kind() {
	pick.autoderefs += 1;
	pick.autoref = Some(mutbl);
	}

I think this is the code that, when the original receiver has type &T, tries receivers with types &*v or &mut *v (depending on mutability of the original receiver).

Unfortunately if I do the same treatment to pointers in that code I can no longer build stage 1 compiler, so can't even try it..

[osa1]

Re: the code above, I have this diff:

diff --git a/compiler/rustc_typeck/src/check/method/probe.rs b/compiler/rustc_typeck/src/check/method/probe.rs
index d4631c465a3..b0febd5eccb 100644
--- a/compiler/rustc_typeck/src/check/method/probe.rs
+++ b/compiler/rustc_typeck/src/check/method/probe.rs
@@ -20,7 +20,7 @@
 use rustc_infer::infer::{self, InferOk, TyCtxtInferExt};
 use rustc_middle::middle::stability;
 use rustc_middle::ty::subst::{InternalSubsts, Subst, SubstsRef};
-use rustc_middle::ty::GenericParamDefKind;
+use rustc_middle::ty::{GenericParamDefKind, TypeAndMut};
 use rustc_middle::ty::{
     self, ParamEnvAnd, ToPolyTraitRef, ToPredicate, Ty, TyCtxt, TypeFoldable, WithConstness,
 };
@@ -1111,9 +1111,16 @@ fn pick_by_value_method(
                 pick.autoderefs = step.autoderefs;

                 // Insert a `&*` or `&mut *` if this is a reference type:
-                if let ty::Ref(_, _, mutbl) = *step.self_ty.value.value.kind() {
-                    pick.autoderefs += 1;
-                    pick.autoref = Some(mutbl);
+                match *step.self_ty.value.value.kind() {
+                    ty::Ref(_, _, mutbl) => {
+                        pick.autoderefs += 1;
+                        pick.autoref = Some(mutbl);
+                    }
+                    ty::RawPtr(TypeAndMut { ty: _, mutbl }) => {
+                        pick.autoderefs += 1;
+                        pick.autoref = Some(mutbl);
+                    }
+                    _ => {}
                 }

                 pick

This causes build errors in libraries like

error[E0282]: type annotations needed
   --> library/core/src/fmt/num.rs:234:45
    |
209 | / macro_rules! impl_Display {
210 | |     ($($t:ident),* as $u:ident via $conv_fn:ident named $name:ident) => {
211 | |         fn $name(mut n: $u, is_nonnegative: bool, f: &mut fmt::Formatter<'_>) -> fmt::Result {
212 | |             // 2^128 is about 3*10^38, so 39 gives an extra byte of space
...   |
234 | |                     let d1 = (rem / 100) << 1;
    | |                                             ^ cannot infer type for type `{integer}`
...   |
290 | |     };
291 | | }
    | |_- in this expansion of `impl_Display!`
...
462 | /     impl_Display!(
463 | |         i8, u8, i16, u16, i32, u32, i64, u64, usize, isize
464 | |             as u64 via to_u64 named fmt_u64
465 | |     );
    | |______- in this macro invocation

error: aborting due to previous error

Anyone know how can that change cause this kind of errors?