What are Rust's exact auto-dereferencing rules?

In Rust, automatic dereferencing is a feature provided by the compiler to simplify programming, which automatically converts reference types to their corresponding value types. Rust's automatic dereferencing rules are primarily used for method calls and property access, designed to streamline code and enhance readability.

Specifically, when invoking a method or accessing a property, Rust automatically performs one or more dereferencing operations as needed until a matching method or property is found. This process is implemented by repeatedly applying the dereference operation (using the * operator) on the type. If no matching method or property is found, the compiler will report an error.

Example

Assume we have the following types and implementation:

rust
struct Point {
    x: i32,
    y: i32,
}

impl Point {
    fn get_x(&self) -> &i32 {
        &self.x
    }
}

Now we create a reference to Point and attempt to call the get_x method using it:

rust
let point = Point { x: 10, y: 20 };
let point_ref = &point;

// Call the get_x method
let x = point_ref.get_x();

In the above code, point_ref is of type &Point, and the get_x method requires a &self parameter. Here, Rust automatically dereferences point_ref (i.e., &Point) to Point to match the signature of the get_x function.

Deeper Rules

Rust's automatic dereferencing rules extend beyond a single dereference. When necessary, Rust attempts multiple dereferencing operations until a match is found or it is determined that no match is possible. For example:

rust
struct Wrapper(Point);

impl Wrapper {
    fn get_inner(&self) -> &Point {
        &self.0
    }
}

let wrapper = Wrapper(Point { x: 10, y: 20 });
let wrapper_ref = &wrapper;

// Here, it first dereferences &Wrapper to Wrapper, then accesses the internal Point
let inner_point = wrapper_ref.get_inner();

In this example, wrapper_ref is of type &Wrapper, and the get_inner method is defined on Wrapper. Rust automatically dereferences wrapper_ref to match the signature of the get_inner method.

In summary, Rust's automatic dereferencing feature significantly simplifies the use of references and pointers, enabling developers to focus more on business logic without frequent manual dereferencing. This represents an elegant balance that Rust achieves between safety and usability.