Detect leaking of private types which are only public in their module

Suppose I have a Rust crate mycrate with lib.rs:

mod internal {
    pub struct X();

    pub fn x() -> X {
        X()
    }
}

pub use internal::x;

This works fine on Rust 2024 and any consumer can use let val = mycrate::x();. However, X is not publically available making it very tricky to work with.

Question

How can I automatically detect if there are private types that my API "leaks".

Notes and clarifications

• The best I have found to manually check this is to play around with pub(crate) rather than pub. If I use e.g. pub(crate) fn x() -> X I cannot compile due to "x is only public within the crate, and cannot be re-exported outside". Alternatively, I can use pub(crate) struct X(); which gives me the correct warning "type Xis more private than the itemx". However, this requires manual checking which is not scalable for larger projects.
• AI tools steer me towards using cargo doc and cargo-public-api, which produce insight into the API. Here too it is not straightforward to manually check the output and see which modules are private.
• I am looking for a tool or workflow that helps me to easily detect these cases on any source code, without requiring me to know the details of that source code.
• While the question is generic, it primarily came up in error handling where I often encounter the case Result<PublicStruct, PrivateEnumError>.
• I have seen the following threads, which suprisingly seem to almost express my desired solution in older versions of Rust...

  • How to reference private types from public functions in private modules?

  • Private inner module returning private item gives "private type in public interface" error

  • What's the best way to use a private type in a public function?

The compiler has a lint for that: unnameable_types. It is just allowed by default. You can #[warn] or #[deny] it in source code or from the command line.

Also see the close sibling unreachable_pub.