An easy to configure wrapper for Rust's clippy

Eric Seppanen

Last update: Dec 19, 2022

Related tags

Configuration cargo-cranky

Overview

cargo-cranky

I wish that I could check in a file that would specify Rust lints for my entire Cargo workspace, and have that be applied to all the crates, libraries, binaries, and examples.

Doing this with just Rust/Cargo/Clippy can be a bit of a pain. cargo-cranky makes it a little easier!

cargo-cranky is just a wrapper around cargo clippy; it examines your Cranky.toml config file, and constructs the necessary cargo clippy command line. Most arguments are passed through to clippy, so it should work from every context where clippy works (IDEs, CI scripts, etc).

For example, if Cranky.toml contains this:

warn = [
  "clippy::empty_structs_with_brackets",
  "clippy::cast_possible_truncation",
]

and I run cargo cranky, I get those extra lints:

warning: found empty brackets on struct declaration
  --> src/main.rs:11:12
   |
11 | struct Unit {}
   |            ^^^

warning: casting `u64` to `u8` may truncate the value
  --> src/main.rs:23:9
   |
23 |         x as u8

This is exactly the same as manually running cargo clippy with the extra parameters --warn clippy::empty_structs_with_brackets and --warn clippy::cast_possible_truncation.

You may find some useful clippy lints for your project in the clippy documentation. I recommend browsing the "pedantic" and "restriction" groups.

Installing

cargo install cargo-cranky

Configuring

Create a file called Cranky.toml at the top of your project tree. The file can contain keys allow, warn, or deny that contain an array of clippy lint names.

Example:

deny = [
  # My crate should never need unsafe code.
  "unsafe_code",
]

warn = [
  "clippy::empty_structs_with_brackets",
  "clippy::cast_possible_truncation",
]

allow = [
  "clippy::double_comparisons",
]

Note: in the case of overlap, allow will always override warn, which in turn will always override deny. The order of these fields in Cranky.toml has no effect.

FAQ

Can I specify non-clippy lints?

Yes! Try for example unsafe_code or missing_docs.

Note: Clippy lints should be specified using the long syntax, e.g. clippy::some_lint_name. Clippy will issue a warning if the prefix is missing.

Does it work with vscode?

Yes! Just type cranky into the "Check On Save: Command" setting, or drop this into settings.json:

{
    "rust-analyzer.checkOnSave.command": "cranky"
}

Set it back to "check" (or "clippy") to return to the previous behavior.

Is this reckless or non-idiomatic?

That depends on how you use it. If your goal is to enforce a non-idiomatic coding style, that's probably not a great idea.

If you want to suppress lints that are enabled by default, it's probably better to do that using the #[allow(clippy::some_lint)] syntax in the source file, since that gives you a chance to add a comment explaining your reasoning.

The main goal of this tool is to make it easier to enable additional clippy lints, that improve code maintainability or safety (i.e. clippy::cast_possible_truncation).

I have ~~complaints~~ suggestions!

Please file a GitHub issue if you have ideas that could make this tool better.

Comments

Non-clippy lints
Thanks for cargo cranky!

There are lints outside of clippy that I often enable, for instance:

"-Dunsafe_code", "-Wfuture_incompatible", "-Wnonstandard_style", "-Wrust_2018_idioms", "-Wrustdoc::missing_crate_level_docs", "-Wsemicolon_in_expressions_from_macros", "-Wtrivial_casts", "-Wtrivial_numeric_casts", "-Wunused_extern_crates", "-Wunused_import_braces",

It would be wonderful if Cranky could handle these non-clippy lints as well, as then it would be a very good solution to https://github.com/rust-lang/cargo/issues/5034

Currently I enable clippy and non-clippy lints in .cargo/config.toml (https://github.com/emilk/egui/blob/e76c919c7e70c208c9a6209b9fe3369e7b6db99d/.cargo/config.toml) but it is a bit of a hack and has some problems (https://github.com/emilk/egui/issues/1439).
opened by emilk 3
Fix severity ordering, allow non-clippy lints, use short-form args

wrt severity ordering, the allow section would do nothing if the warn/deny section was smth like clippy::all

all lints would have to be specified as clippy::xxxx but otherwise you need special-case handling if you want to configure non-clippy lints

opened by Awpteamoose 2
Integrating configuration into `Cargo.toml`
Recently I was getting annoyed at how many metadata files are in the root of my workspace. To combat this issue it feels like tooling that is completely cargo-focused like this should really be storing its configuration in the Cargo.toml. The example from the readme could look like:

[workspace.metadata.lints] warn = [ "clippy::empty_structs_with_brackets", "clippy::cast_possible_truncation", ]

This could also support some of the usecases from #3 easily. The lints could be merged from workspace.metadata.lints and package.metadata.lints to support crate-specific overrides.
opened by Nemo157 1
Support `rustdoc::` lints

Currently if I put "rustdoc::missing_crate_level_docs" in warn in Cranky.toml it does nothing.

…though honestly I don't understand the rustdoc lints. cargo clippy -- -D rustdoc::missing_crate_level_docs runs without warnings when there are missing crate level docs.

opened by emilk 4
Somehow specify rules for #![doc(test(attr( ... )))] ?
I don't know if it is possible but all my projects maintain slightly adjusted lint rules for doc-tests, specifically:

#![doc(test(attr(deny(future_incompatible, rust_2018_idioms, warnings))))] #![doc(test(attr(allow(unused_extern_crates, unused_variables))))]

Ideally this tool would be able to provide that as well but I feel like that is probably not possible.
opened by Fishrock123 0
Override global rules from in-source attributes?

Similar to what was mentioned in https://github.com/ericseppanen/cargo-cranky/issues/3#issue-1298199372, but a little different. Perhaps that issue exists because this is just impossible.

I'd like to be able to use this tool, but with a blanket set of fairly "aggressive" rules across an entire organization.

Sometimes, like in the case of clippy::print_stdout this is appropriate for most projects (encourage folks to use the log crate), but I may want to disable it fro a CLI tool. Ideally I'd like to not have to adjust the project or workspace level Cranky.toml (since it may be automated). So, i'm hoping there would be a way to set an override from an in-code attribute, since that seems the most reasonable place to have such a thing...

See also https://rust-lang.zulipchat.com/#narrow/stream/257328-clippy/topic/Have.20in-code.20lint.20attributes.20have.20higher.20precidence.20than.20.2E.2E.2E/near/291373867

opened by Fishrock123 4
idea: support for multiple config files
"Multiple config files" might be a can of worms, but I could see a few different ways this could be useful:

I have a set of aggressive lints I usually use, but I have one crate that needs to disable a few of those because they're just not appropriate for this crate.

I have a standard set of lints I use for everything, but my projects don't share a common filesystem tree so I'd like my Cranky.toml file to live in my home directory.

Maybe this could be supported by having a "fall_through = true" config flag in Cranky.toml; when found we keep searching for additional Cranky.toml files (and merge their contents intelligently). And then when we reach the filesystem root we check in ~/.Cranky.toml also.
opened by ericseppanen 2
idea: smart handling of new lints

If I use a new clippy lint in Cranky.toml, but someone else hasn't moved to that Rust version yet, they will get an "unknown lint" error.

If I don't want to bump the crate's minimum supported Rust version, I should be able to add that lint anyway-- and cargo cranky should be able to observe what stable release I'm on and disable lints that are too new.

Would this require hardcoding a list of clippy lints and the version when they landed? That sounds a bit hard to keep up with.

opened by ericseppanen 0

Releases(v0.3.0)

v0.3.0(Jul 8, 2022)
Fix severity ordering so allow always overrides warn or deny.

Support non-clippy lints; requires full lint names, e.g. clippy::lint_name.

Source code(tar.gz)
Source code(zip)