Does &mut T implements Borrow<T> break a mutable reference rule?

&mut T implements Borrow<T>，so (&mut T).borrow() will create &T. Does this break the rule that “if we have one mutable reference, we can not have any other references (mutable or not)”?

use std::borrow::Borrow;
let mut n = 1;
let r1: &mut i32 = &mut n;
let r2: &i32 = r1.borrow();

println!("log: {r1} {r2}");

The code compiles, but if I change r1.borrow() to &n, it will report error

What's the exact rule of the reference system?

Playground

This is more general than Borrow. You can do the same thing with regular references:

let r1: &mut i32 = &mut n;
let r2: &i32 = &*r1;

When you think about it, it's very necessary to be able to make immutable references from mutable references. For example, you need it to call &self methods on &mut variables.

But rust still ensures you aren't using the mut property of the variable.

Things you can do:

• Give out more & references

let r3: &i32 = &*r1;

• Use it behind another & reference

fn takes_ref_mut_ref(_: &&mut i32) {}
takes_ref_mut_ref(&r1);

• Copy types that implement Copy

let r4 = *r1;

• Deref to & (this does &*r1 implicitly)

fn print_three(a: &i32, b: &i32, c: &i32) {
    println!("{a} {b} {c}")
}
print_three(r1, r2, r3);

Things you can't do:

• Implicitly use it as a &&

fn takes_ref_ref(_: &&i32) {}
takes_ref_ref(&r1);

• Use it as &mut directly

fn print_three_mut(a: &mut i32, b: &i32, c: &i32) {
    println!("{a} {b} {c}")
}
print_three_mut(r1, r2, r3);

• And obviously, mutate the variable

*r1 = 5;

(playground)