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

[camelid]

Hmm, that is pretty weird. You might want to ask in #t-compiler/help on Zulip if you haven't already – somewhere there may be able to help.

[osa1]

Creating a Zulip topic for this: https://rust-lang.zulipchat.com/#narrow/stream/182449-t-compiler.2Fhelp/topic/Type.20checker.20change.20causing.20unexpected.20errors

[osa1]

My previous attempt was completely wrong. I managed to make this work today. I can boot rustc, and the repro now works. However it's hacky, and I had to relax checks in two places to accept passing *mut to a method with *const receiver (as *mut A is not a subtype of *const A).

I think the right way to implement this would be to turn the argument (a *mut value) to *const by adding &*. If I understand the code correctly, currently this kind of thing is done via the Pick type with has fields for how many autoderefs to apply to the value, and whether to apply autoref or not (with given mutability). This type currently does not allow expressing converting a *mut A to *const A. I think the right way to fix this is by somehow updating the type so that we can express this conversion.

[RalfJung]

by adding &mut *

Without understanding the details here, this sounds wrong -- &mut creates a reference, not a raw pointer, and that should certainly not be done implicitly when the source code just used raw pointers.

[osa1]

(I had a typo in my comment above, I meant &* not &mut *)

@RalfJung How else can I convert a *mut T to a *const T? To summarize, I'm trying to make f.x() work when f is *mut T and receiver of x is *const T.

[osa1]

Looking into the Pick type and its uses more, I think we don't really insert &* but in effect just cast the type. I may be wrong though, first time looking at this code. Relevant code:

• rust/compiler/rustc_typeck/src/check/method/confirm.rs

  Line 133 in 15598a8

  fn adjust_self_ty(

  picks generated by probing passed to this function

• rust/compiler/rustc_typeck/src/check/fn_ctxt/_impl.rs

  Line 269 in 15598a8

  pub fn apply_adjustments(&self, expr: &hir::Expr<'_>, adj: Vec<Adjustment<'tcx>>) {

  the function above calls this to adjust the receiver expression's type. It doesn't really insert &*s AFAICS, I think in effect what it does is more like casting (ascription).

[osa1]

I pushed my code and submitted draft PR #82436. As the description says, it's a hacky proof-of-concept currently, but I can boot rustc with it and the original repro works. I'll be working on it.

@rustbot claim

[RalfJung]

(I had a typo in my comment above, I meant &* not &mut *)

That's just as problematic.

How else can I convert a *mut T to a *const T?

You can just do x as *const T.

[osa1]

That's just as problematic.

Right, I'm aware that dereferencing a pointer is unsafe and hence problematic to do automatically.

You can just do x as *const T.

That's what we do, yes. See my updates above.