Access the non-public function from object created by default().

The following code can successfully compile.

#![allow(unused)]

#[derive(Default)]
pub struct Bar2 { i: i32 } 

impl Bar2 {
    fn f(&self) -> bool { true }
}

pub mod foo {
    #[derive(Default)]
    pub struct Bar { i: ::Bar2 } 

    impl Bar {
        // here this function ,  
        fn f(&self) -> bool { false }
    }

    impl ::std::ops::Deref for Bar {
        type Target = ::Bar2;
        fn deref(&self) -> &::Bar2 { &self.i }
    }
}

fn main() {
    let bar = foo::Bar::default(); 
    print!("{}",bar.f()); // true
}

Here it print 'true', which I think it is the default implementation of function f.
The function f is not a public function?

And if I comment these lines of codes.

    impl ::std::ops::Deref for Bar {
        type Target = ::Bar2;
        fn deref(&self) -> &::Bar2 { &self.i }
    }

Then the program is not compilable.

Start by compiling the provided example with and without the Deref implementation, then inspect how method resolution handles the private f methods and the dereferenced Bar2 value. Confirm whether the observed access is expected Rust behavior or a compiler bug, and document the result with a focused regression test if a compiler change is needed.