Typechecker doesn't honor Deref as a trait bound on references when using * operator

[djrenren]

I tried this code:

// Ought to work fine but doesn't
fn borrow_and_deref<T>(p: T) -> i32 where for<'a> &'a T: Deref<Target=i32> {
    *&p
}

I expected to see this happen: Successful typechecking

Instead, this happened:

If we invoke deref manually, rather than implicitly through syntax sugar everything works fine:

// Works, so the issue is specifically at the intersection of syntax
// sugar and the trait bound
fn borrow_and_deref<T>(p: T) -> i32 where for<'a> &'a T: Deref<Target=i32> {
    *(&p).deref()
}

So this issue is specifically at the intersection of this kind of constraint and the syntax sugar.

Playground link

[djrenren]

Further reading up on the dereferencing operator makes it seem like this is intended (or at least specified) behavior, because *x is only semantically equivalent to *Deref::deref(&x) for non-pointer types (ref). but since there's an impl for &'_ [T] it seems odd to make this exclusion.

Also, even if there's a specialized implementation of dereferencing, allowing this program to typecheck isn't a soundness issue, since the specialized implementation still adheres to the invariants.

[djrenren]

Found the culprit:

rust/src/librustc_typeck/check/place_op.rs

Lines 21 to 23 in 39d5a61

	if let Some(mt) = oprnd_ty.builtin_deref(true) {
	return Some(mt.ty);
	}

It seems we could solve this problem by resolving the impl of Deref first, then emitting that type (with no adjustments to the IR). However, maybe this is just too expensive and not worth it. Thoughts?

[nbdd0121]

Sound plausible, but as you said this could potentially be expensive. I am not sure if this would needs a lang-team approval though. cc @nikomatsakis

@rustbot modify labels: +A-traits +T-lang

[nikomatsakis]

Yeah, it sounds plausible indeed, but it may have implications. I wouldn't be opposed to experimenting but I admit I also don't feel very highly motivated, it'd be nice to have a more concrete motivation for this change. Is this just experimentation with strange programs, or is there a use case here?