unnecessary_cast on as u64 for a c_ulong

[joshtriplett]

Summary

unnecessary_cast triggers on casts from C FFI type aliases, even though the type aliases may not always match the type being cast to.

Lint Name

unnecessary_cast

Reproducer

I tried this code:

use core::ffi::c_ulong;

fn main() {
    let x: c_ulong = 0;
    let y = x as u64;
    println!("Hello, {y}!");
}

I saw this happen:

warning: casting to the same type is unnecessary (`u64` -> `u64`)
 --> src/main.rs:5:13
  |
5 |     let y = x as u64;
  |             ^^^^^^^^ help: try: `x`
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
  = note: `#[warn(clippy::unnecessary_cast)]` on by default

I expected to not get an error, because c_ulong is a type alias that isn't always u64.

I thought #8596 was supposed to fix this.

Version

rustc 1.68.1 (8460ca823 2023-03-20)
binary: rustc
commit-hash: 8460ca823e8367a30dda430efda790588b8c84d3
commit-date: 2023-03-20
host: x86_64-unknown-linux-gnu
release: 1.68.1
LLVM version: 15.0.6

Additional Labels

No response

[joshtriplett]

Note that .into() has a similar false positive:

use core::ffi::c_ulong;

fn main() {
    let x: c_ulong = 0;
    let y: u64 = x.into();
    println!("Hello, {y}!");
}

produces:

warning: useless conversion to the same type: `u64`
 --> src/main.rs:5:18
  |
5 |     let y: u64 = x.into();
  |                  ^^^^^^^^ help: consider removing `.into()`: `x`
  |
  = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#useless_conversion
  = note: `#[warn(clippy::useless_conversion)]` on by default

[Alexendoo]

This one is tricky, #8596 would cover the case of some_u64 as c_ulong where we can check the rustc_hir::Ty of c_ulong to see it's an alias, but for the x in x as u64 we only have the rustc_middle::ty::Ty which doesn't distinguish u64 from c_ulong

[joshtriplett]

On Wed, Mar 29, 2023 at 04:50:24AM -0700, Alex Macleod wrote: This one is tricky, #8596 would cover the case of `some_u64 as c_ulong` where we can check the `rustc_hir::Ty` of `c_ulong` to see it's an alias, but for the `x` in `x as u64` we only have the `rustc_middle::ty::Ty` which doesn't distinguish `u64` from `c_ulong`

I realize that it's hard to distinguish type aliases, but I think it's important in order to avoid false positives like this. Casting a c_ulong to a u64 is useful in portable code.

[Alexendoo]

I saw https://rust-lang.zulipchat.com/#narrow/stream/213817-t-lang/topic/type.20aliases.20and.20names.20in.20errors today, may be a good way to resolve it if it does end up happening

Yeah I'm not saying it's unimportant, just a note for contributors looking through issues that this one wouldn't be easy

[Alexendoo]

The demonstrative example has been handled but the general issue remains, e.g.

fn main() {
    let pid = unsafe { libc::getpid() };
    pid as i32;
}