Why can't Rust access private fields when a struct is in a different module?

constructors
    |---------src
    |          |----------lib.rs
    |          |----------constructor_file.rs    
    |
    |----------Cargo.toml
    |----------main.rs

lib.rs

pub mod constructor_file;

constructor_file.rs

pub struct Person {
    name: String,
    age: u32,
}

impl Person {
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }
    pub fn show(self)
    {
        println!("Name: {}, Age: {}", self.name, self.age);
    }
}

main.rs

use constructor_lib::constructor_file::Person;

fn main() {
    let person = Person { name: "Alice".to_string(), age: 33 };
    person.show();
    let person2 = Person::new("Bob".to_string(), 99 );
    person2.show();
}

cargo.toml

[package]
name = "constructor_lib"
version = "0.1.0"
edition = "2021"

[[bin]]
name="constructor_exe"
path="main.rs"

The above project is giving me the following build error

C:\git\Rust examples\constructors>cargo build
   Compiling constructor_lib v0.1.0 (C:\git\Rust examples\constructors)
error[E0451]: field `name` of struct `Person` is private
 --> main.rs:4:27
  |
4 |     let person = Person { name: "Alice".to_string(), age: 33 };
  |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ private field

error[E0451]: field `age` of struct `Person` is private
 --> main.rs:4:54
  |
4 |     let person = Person { name: "Alice".to_string(), age: 33 };
  |                                                      ^^^^^^^ private field

For more information about this error, try `rustc --explain E0451`.
error: could not compile `constructor_lib` due to 2 previous errors

C:\git\Rust examples\constructors>

Why doesn't this error show up when I keep Person in the same file as main.rs?

main.rs

//use constructor_lib::constructor_file::Person;
pub struct Person {
    name: String,
    age: u32,
}

impl Person {
    pub fn new(name: String, age: u32) -> Person {
        Person { name, age }
    }
    pub fn show(self)
    {
        println!("Name: {}, Age: {}", self.name, self.age);
    }
}

fn main() {
    let person = Person { name: "Alice".to_string(), age: 33 };
    person.show();
    let person2 = Person::new("Bob".to_string(), 99 );
    person2.show();
}

Because that's how visibility works in Rust?

> If an item is private, it may be accessed by the current module and its descendants.

If the structure is defined in main.rs, then main.rs is part of "the module or its descendant", thus private fields are accessible.

If the structure is defined in a sub-module, then main.rs is not part of "the module or its descendant", and private fields are not accessible.

As also documented in the book, and unlike many other languages, because Rust's privacy baseline is so restrictive you have a lot more flexibility in defining visibility than just "public".

Notably, you can define a symbol as pub(super) to make it accessible from the parent module, and pub(crate) to be accessible from the entire crate.

In many languages (e.g. java) the default is something like pub(crate), and "private" has to be opted in. In Rust, it's the other way around, "private" is the default (although it's a bit more relaxed than Java's own private, I think).