Lint for functions/variables/etc using the same name as a type (`str`, `u32`, ...)

[joshtriplett]

Code

fn func(u32: u32) {
    println!("{u32}");
}

fn main() {
    let u32 = 42;
    func(u32);

    let closure = |str: &str| {
        println!("{}", str.len());
    };
    closure("hello");
}

Current output

(none)

Desired output

warning: variable `u32` should use a name that doesn't conflict with a standard type
 --> src/main.rs:1:9
  |
1 | fn func(u32: u32) {
  |         ^^^ help: rename the identifier

Rationale and extra context

It's confusing to read code where str (or another standard type name) is used as an identifier. It also produces misleading syntax highlighting.

Other cases

Rust Version

rustc 1.83.0 (90b35a623 2024-11-26)
binary: rustc
commit-hash: 90b35a6239c3d8bdabc530a6a0816f7ff89a0aaf
commit-date: 2024-11-26
host: x86_64-unknown-linux-gnu
release: 1.83.0
LLVM version: 19.1.1

Anything else?

No response

[Noratrieb]

I don't like it, in my opinion str is a perfectly clear name for a string variable. Rust didn't make primitives keywords, so I don't see a reason why we shouldn't use the names. I don't think syntax highlighters should highlight primitive types in a special way, which would avoid this problem (r-a's highlighter doesn't).
I think this should be a pedantic clippy lint at most, I wouldn't want this to be a rustc lint.

[joshtriplett]

This came up for me when searching for str in the codebase. Having it used as both a variable name and a type name made that much more challenging.

And many syntax highlighters do highlight these type names, and consider that a feature.

[ultimaweapon]

Naming a thing already hard. If this lint enabled by default it will even harder. One thing I like about Rust is I can name a thing without conflicts. e.g.:

mod str;

let foo = foo.bar();
let foo = foo.baz();

if let Some(v) = foo.str() {
} else if let Some(v) = foo.u32() {
}

[scottmcm]

The particular case of this I think we should definitely lint on in bindings is

let Foo { x: u32 } = foo;

because that does something very different from what it looks like at first glance.

---

I wonder if an item-vs-binding distinction here could be reasonable.

I think type str = ...; is much worse than let str = ...;.

[ultimaweapon]

Another example from the project I'm working on is I need to create a struct to store character stats on my game like the following:

struct CharStats {
    pub str: u16,
    pub int: u16,
    pub vit: u16,
    ...
}

It is common to use str as an abbreviation for strength.