*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..