rust-clippy

I agree. The friction is not an issue of the language or of toxic communities but the culture of how software is crafted and passed on. I use rust for hobby projects and besides the savety and soundness decisions, i love the tooling. Having countless [0] very restrictive guard rails like deny(clippy::float_arithmetic) for your usecases codifies intent about project structure in a way i have seen nowhere else. Not engaging with the benefits of rust but instead blanket-dismiss projects based on unrelated issues is irrational and i suspect its a phenomenon of older generations that grew up with C and never inherited eg. cobol on mainframes. https://github.com/rust-lang/rust-clippy

To be fair, Vec::set_len bug in Rust was in 2021. And even then it had to be annotated as `unsafe`. It was then deprecated and a linter check was added: https://github.com/rust-lang/rust-clippy/issues/7681

It's interesting that you can remove a future state machine instance for an async function that returns a constant value by just returning impl Future<Output = [return type]> with return std::future::ready(return_value). They even developed a lint[1] to help users find these cases. https://github.com/rust-lang/rust-clippy/pull/16244 Could the compiler not identify this case and perform the transformation automatically?

While that is true, there are clippy::indexing_slicing, clippy::string_slice for that: https://github.com/rust-lang/rust-clippy/issues/8184#issuecomment-1003651774 error: indexing may panic --> src/main.rs:100:57 | 100 | rtmp::header::BasicHeader::ID0 => u32::from(buffer[1]) + 64, | ^^^^^^^^^ | = help: consider using `.get(n)` or `.get_mut(n)` instead = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#indexing_slicing

I couldn't find it in the API guidelines either. From what I understand, the idea is that any trait bounds, which includes generic type parameter bounds and lifetime bound on a type (struct or enum) would be repeated back in the impl block there is a nice discussion on this issue here: https://github.com/rust-lang/rust-clippy/issues/1689

Yup, I've ran into this when my entire program ended up being a single massive Future struct, which caused a stack overflow :) I wish there was a Clippy lint for this (https://github.com/rust-lang/rust-clippy/issues/5263). My current practice is to sprinkle `Box::pin` on code paths that are less common (fallbacks, error handling) or expensive anyway. This cuts down the inlined state considerably without actually causing that many allocations.

What the sibling comment said is spot on! Rust requires you to design programs very differently than what you do in GC-languages. You may try to avoid using things like lifetimes for a while, but those are completely undispensable to writing Rust... same with macros. They are really important and widely used in Rust. One very good way to avoid simple mistakes is to configure Clippy to run on your IDE (or just run it manually): https://github.com/rust-lang/rust-clippy

>Nobody wants to be second-guessed by a robot overlord (proof: Clippy). People in the Rust community love clippy. https://github.com/rust-lang/rust-clippy

C++ [1], Java [2], Python [3], and even Rust [4] all have static analyzers. There will always be room for analysis that is beyond the compiler's purview. [1] https://clang.llvm.org/extra/clang-tidy/checks/list.html [2] https://spotbugs.github.io/ [3] http://mypy-lang.org/ [4] https://github.com/rust-lang/rust-clippy

There is a clippy lint, pedantic and allowed by default, that warns about passing a large type by value. https://rust-lang.github.io/rust-clippy/master/#large_types_... The default threshold is 256 bytes: https://github.com/rust-lang/rust-clippy/blob/1fc1aee7be6e7e... So you might use that as a rule of thumb. But officially, "Generally speaking, if your type can implement Copy, it should." https://doc.rust-lang.org/std/marker/trait.Copy.html#when-sh...

A combination of clippy [1] and cargo-audit [2] covers several of these issues, though not all (I'm not aware of a tool to check for uses of bad ciphers in Rust for example). [1]: https://github.com/rust-lang/rust-clippy [2]: https://github.com/rustsec/rustsec

Maybe we can combine it with Rust's clippy for displaying the error messages. https://github.com/rust-lang/rust-clippy

Does it work if you run `cargo clean` and then `cargo clippy` again? Clippy runs it's lints in an early pass of the compiler/checker. Many IDEs/editors will automatically `cargo check` under the hood to grab errors. Then when you run `cargo clippy`, that part of the compilation is already cached and so clippy doesn't give you any output :( To my knowledge (it's been a while since I looked) fixing this behavior is blocked on cargo stabilizing something and has been for literal years. That point of frustration aside, it's worth it...Clippy is an absolutely amazing piece of software. Both for pedagogy and normal development. EDIT: Just dug up the issue. If you're on nightly you can use `cargo clippy -Z unstable-options` to avoid the clean/rebuild. Hopefully stuff gets stabilized soon. Here's the issue for reference: https://github.com/rust

Rust has a tool called, you guessed it, Clippy, that does very similar things to what you suggest: https://github.com/rust-lang/rust-clippy The Rust compiler exposes a lot of information, so it's actually quite powerful in my experience.

I am convinced that `rustc` should have an "optimizer lint" phase with all the same checks other languages perform to change the behavior of the code and instead suggest changes that affect running code and compile time, like `Box`ing fields or variants that disproportionately affect the size of an `enum`[1] or to suggest changing generic params to trait objects or vice versa[2] when it makes sense. The advantage of not doing it automatically is that the behavior of the code once compiled can be always inferred from looking at the code, no magic and sudden changes in behavior because some threshold has been passed in some optimizer. [1]: https://github.com/rust-lang/rust-clippy/pull/5466 [2]: https://github.com/rust-lang/rust-clippy/issues/14