Lint for `as _` casts

[daprilik]

What it does

(Discussed in #8846)

A lint to warn against as _ conversions.

Lint Name

as_underscore

Category

style

Advantage

as _ is the Rust equivalent of C/C++'s implicit casting (albeit with a visual signal that some cast is indeed happening), and comes with many of the same problems.

e.g: consider a fn foo(n: usize) and a n: u16.
If foo is called as foo(n as _), and at some point, the function signature of foo changes to fn foo(n: u8), then the code would continue to compile just fine, albeit with a (likely unexpected) integer truncation.

Drawbacks

as _ is far more concise when the type being cast to is very wordy (but hence why this lint would live in the style category, and be disabled by default).

Example

fn foo(n: usize) {}
let n: u16 = 256;
foo(n as _);

Could be written as:

fn foo(n: usize) {}
let n: u16 = 256;
foo(n as u16);

[xFrednet]

Thank you for the ticket, I would put this lint in the restriction group like clippy::as_conversions that would make it allow by default. The group also sets the lint level, having it in the style group would make this allow by default, which we probably don't want 🙃

The implementation can be based on clippy::as_conversions and probably reuse a bunch of code.

@rustbot label +good-first-issue

It's not just as _ that's problematic but as as a whole. Even if you used as usize it's possible that the type of n could change to u128 and now you have that same situation. This is why you should use Into instead whenever possible because it guarantees that the conversion is not lossy. I would recommend you use cast_lossless instead.

[daprilik]

@mikerite I generally agree with you that as casts should be avoided when possible, and I'm well aware of their pitfalls. That said, while your point is certainly valid, it's not an argument against adding a new lint here.

For one reason or another, I doubt I'd be able to remove all as lints from the codebase I'm interested in, hence why I'm interested in this kind of "middle ground" lint, where folks can still use as, but are forced to be a bit more mindful about the specific type being cast to.

[DevAccentor]

@rustbot claim

[daprilik]

Thanks @DevAccentor 🎉