Deref/DerefMut Desugarings

The expression *$expr is allowed if $expr is a built-in reference type (&T, &mut T, *const T, *mut T and Box<T>), or if $expr: T and T: core::ops::Deref. In this step we desugar the Deref case.

Let T: Deref be a type and $expr be an expression of that type. Let context!(..) be a context in which one may find the expression *$expr.

For each context we figure out an associated mutability: &mut $expr and if let Some(ref mut x) = $expr are two examples of mutable contexts. Uses that don't require mutability are considered immutable contexts. Examples of immutable contexts are &$expr and function_call($expr). For let place p = $expr; assignments, mutability is inferred from the mutability of the contexts in which p is used.

We then desugar as follows:

#![allow(unused)]
fn main() {
context!(*$expr)
// becomes, if the context is considered mutable:
context!(*<T as DerefMut>::deref_mut(&mut $expr))
// otherwise, if the context is considered immutable:
context!(*<T as Deref>::deref(&$expr))
}

For example:

#![allow(unused)]
fn main() {
let arc: Arc<Option<i32>> = ...;
if arc.is_some() { .. }

// becomes, before this step:
if Option::is_some(&*arc) { .. }

// becomes, after this step:
if Option::is_some(&*Deref::deref(&arc)) { .. }
}

#![allow(unused)]
fn main() {
let mut v: Vec<u32> = ...;
match *v {
    [0, ref mut rest @ ..] => ..,
    _ => ..,
}

// becomes, because the pattern context is seen to be mutable:
match *DerefMut::deref_mut(&mut v) {
    [0, ref mut rest @ ..] => ..,
    _ => ..,
}
}

Backlinks

• Method Resolution & Operator Overload
• Place Aliases