`needless_type_cast` is mixing up casts and coercions

[kpreid]

Summary

needless_type_cast is in some way mixing up casts and coercions. It is taking my completely-type-annotated code and proposing that I replace the as with a type annotation, which then fails because coercions cannot perform numeric casts.

Lint Name

needless_type_cast

Reproducer

I tried this code:

#![warn(clippy::pedantic)]

pub const fn buffer_size_of<T>() -> u64 {
    let size: usize = size_of::<T>();

    // Ideally this would be `try_into()` but that's not available in const yet.
    // It will never overflow unless 128-bit pointers become a thing.
    let size: u64 = size as u64;
    
    size
}

I saw this happen:

warning: this binding is defined as `usize` but is always cast to `u64`
 --> src/lib.rs:4:15
  |
4 |     let size: usize = size_of::<T>();
  |               ^^^^^ help: consider defining it as: `u64`
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#needless_type_cast
  = note: `#[warn(clippy::needless_type_cast)]` implied by `#[warn(clippy::pedantic)]`

Applying the suggestion causes a compilation error since usize does not coerce to u64.

I believe that, instead, the lint should not fire at all in this case.

Version

rustc 1.94.0-nightly (430d8297c 2025-12-13)
binary: rustc
commit-hash: 430d8297c712ca7e8a4866d7ddccf1b71ba5d4d3
commit-date: 2025-12-13
host: aarch64-apple-darwin
release: 1.94.0-nightly
LLVM version: 21.1.5

Additional Labels

@rustbot label +I-suggestion-causes-error

[samueltardieu]

The suggestion is marked as MaybeIncorrect internally, which means that tools should not apply it automatically. What you've seen corroborates what I've seen in #16245 (see the note in the new tests).

[samueltardieu]

Those are two bugs (with the ICE in #16243) due to the new needless_type_cast lint. @borngraced could you have a look? This is problematic as the lint is in pedantic that many people use.

Cc @llogiq

[Jarcho]

The suggestion for the lint should be:

let size: u64 = size_of::<T>() as u64;
let size: u64 = size;

This should be probably special cased to get rid of the second binding.

Basically the lint sees that all uses of the first size binding are size as u64 and suggests that the original binding should have just been that type in the first place.

[borngraced]

The suggestion for the lint should be:

let size: u64 = size_of::() as u64;
let size: u64 = size;

This should be probably special cased to get rid of the second binding.

Basically the lint sees that all uses of the first size binding are size as u64 and suggests that the original binding should have just been that type in the first place.

So do you suggess we skip linting when the initializer has a fixed type that can't coerce to the target or suggest casting the initializer?

[llogiq]

The latter might still yield some improvement if there is more than one use site that would otherwise need the cast.

[kpreid]

With #16248, the lint will still be linting about a situation that does not match its name: needless_type_cast implies that fixing the lint would involve removing a cast, which is not true in this case. The cast is, literally, not needless.

I suggest adding a rule that there is no lint when there is exactly one use and the cast cannot be replaced with a coercion. That will:

• Not lint on cases that are intentionally separated.
• Narrow the lint to doing what it says it does: reducing the number of casts.

[borngraced]

With #16248, the lint will still be linting about a situation that does not match its name: needless_type_cast implies that fixing the lint would involve removing a cast, which is not true in this case. The cast is, literally, not needless.

I suggest adding a rule that there is no lint when there is exactly one use and the cast cannot be replaced with a coercion. That will:

* Not lint on cases that are intentionally separated.

* Narrow the lint to doing what it says it does: reducing the number of casts.

Good point! I've updated my PR to skip linting when there's exactly one use and the initializer cannot coerce to the target type. In such cases, the suggested fix would just move the cast to the initializer rather than eliminating it; contradicting needless

Also extended the coercion check to handle binary expressions of unsuffixed literals (e.g., 10 + 5), since these can coerce without an explicit cast @ 6f5421f