Why is this implicit deref allowed?

[paldepind]

I’m trying to figure why the following Rust snippet is allowed:

let mut a = &12;
let b = &&34;
a = b; // <- seems like &&i32 is coerced to &i32

This is a reduced version of Rust code I've seen in the wild. Here a has the inferred type &i32 and b has the inferred type &&i32. Yet, even though there not the same type, the assignment it allowed.

I can't find anything in the Rust reference explaining why this is legal. What I can find is:

• There is a coercion enabled by the Deref trait.
• The type &T implements Deref<Target = T>.
• The above two implies that &&i32 can be coerced to &i32.
• But, coercions can only occur at coercion sites and assignment expressions are not coercion sites.

In other words, I do understand why this slightly modified program is allowed:

let mut a = &12;
let b = &&34;
let c: &i32 = b; // <- allowed since annotated let is a coercion site

Am I missing something about coercions? Or is the some completely different mechanism at play here?

Thanks in advance for helping me out!

[jofas]

@paldepind

assignment expressions are not coercion sites.

I'm quite sure they are, even though they are not explicitly mentioned in RFC 401, the Reference or the FLS. Found this previous topic on the matter:

Confused about coercions place

RFC401 says where the coercions take place, but doesn't mention this case, the "=" assign can also occur coercion. Is this an oversight by rfc or some other issue? fn main() { let a = String::from("abc"); let mut b = &a; let c = String::from("def"); b = &&&&&&c;//just "=" }

[paldepind]

Thanks for the answer @jofas. Ok, if that's the case then that explains it, but the behavior is not documented anywhere at all.

I suppose the Rust reference should be updated?

[alice]

The reference should probably be updated, yes.

Basically, any situation where the the compiler can figure out what the target type is, is a coercion site.

[paldepind]

Alright, here's a PR for the reference:

Document assignment expression as coercion site

Basically, any situation where the the compiler can figure out what the target type is, is a coercion site.

Assignment expressions as coercion sites feels a bit different to me compared to those documented in the reference.

In all those cases the coercion can be matched up with an explicit type annotation. For instance arguments are coercion sites and they can be matched to the parameter type annotation, let statements are only coercion sites when they have an annotation, etc.

For assignment expressions there may not be any annotation (like in my example) and yet a coercion can occur.

[quinedot]

Here's another coercion with no annotations.

Rust Playground

[paldepind]

Thanks, good point. Argument coercion sites are not guaranteed to be matchable to a type annotation since closures don't require annotations.