Cargo users get compiler-aware checks without a server
The 4,637-file Clippy checkout exposes more than 800 lints for mistakes, suspicious expressions, style, complexity, and performance. Most developers meet it through rustup component add clippy and cargo clippy, so there is no server to operate and no separate rule engine to wire into a project. Lint levels use the familiar allow, warn, and deny controls, and a denied finding makes the command exit with an error that CI can act on.
The contributor view is much larger than that simple command suggests. Our checkout held about 298,149 lines of source. Clippy combines early passes over syntax with late passes that can use type information from rustc, according to its contribution guide. Application teams do not need to understand those internals, but anyone writing a lint or diagnosing a compiler interaction is working inside a compiler-adjacent project rather than a small Cargo utility.
The default groups are safer than pedantic and restriction
Across the 15.9 MB checkout, the README divides Clippy's collection into 10 groups. Correctness lints are denied by default, while suspicious, style, complexity, and performance findings warn. Pedantic, restriction, nursery, and Cargo-manifest groups are opt-in. That split is one of Clippy's best decisions: a team can get useful feedback immediately, then make stricter taste and policy choices without pretending that every available rule has the same certainty.
Clippy's own README says the restriction group should emphatically never be switched on wholesale because individual rules may reject reasonable code, offer no alternative, or conflict with other lints. Rules such as banning todo!, forbidding unwrap, or limiting floating-point arithmetic can make sense in a particular module or CI job. They need a written reason and a narrow scope, even though the entire source checkout occupies only 15.9 MB.
One reported fix produced a Rust 1.100.0 compiler error
Open issue #17730 reports that a redundant_closure_for_method_calls edit failed to compile on Rust 1.100.0 nightly. cargo clippy --fix applies machine-applicable suggestions and implies --all-targets, which can bring examples, benches, and tests into the diff. In the reported case, Clippy suggested Option::copied, and the replacement failed because multiple applicable methods were in scope. Automatic application still needs a clean compile and an ordinary code review afterward.
Our source run used 3 CPUs and 12 GB of RAM, which was enough to complete installation, compilation, and the available tests. That successful run says the checked-out commit was buildable in the stated Debian container. It does not turn every lint suggestion into a safe rewrite for every generic type or macro expansion. Keep fixes in a separate diff, compile afterward, and allow a specific lint near code where the rule does not understand the surrounding constraints.
What happened when we ran it
Our sandbox installed commit 47e8223 in 90 seconds, adding 100 packages. The build then succeeded in 108 seconds. Our measurement setup was a fresh, unprivileged container with no secrets. For an end user, the README's rustup route is far less work; these measurements describe a source checkout, which is the path a contributor or distributor has to care about.
Cargo test succeeded in 297 seconds, reporting 38 passed and 0 failed out of 38. The repository occupied 15.9 MB before installed packages, and our scan counted 8 CI workflow files plus a tests directory. We found no Dockerfile, which is unsurprising for a rustup component but matters if a team expects the repository itself to supply a container build. Nothing in the supplied run log showed an install, compiler, or test failure.
clippy.toml cannot set allow, warn, or deny
Clippy's 15.9 MB source checkout reads per-lint values from clippy.toml or .clippy.toml, including disallowed names and the minimum supported Rust version. It can also take MSRV from the rust-version field in Cargo.toml or a crate attribute. The configuration file cannot allow or deny a lint; those levels belong in source attributes or command-line flags. That separation is easy to miss, especially when a team expects one TOML file to hold its entire policy.
All 38 tests passing in our no-secrets container also confirms that the checked-out test command did not depend on an external account or hosted service. A real project still needs a deliberate CI invocation. --no-deps limits checks to the selected crate, while workspace and feature flags decide which targets Clippy sees. On Cargo 1.97 and later, the README prefers CARGO_BUILD_WARNINGS=deny over -D warnings because the environment setting does not invalidate build caches.
September activity outweighs a 2,879-item queue
GitHub recorded a push on September 14, 2026, and 13,504 stars when we fetched the repository. It also listed 2,879 combined open issues and pull requests. The queue is large, but it is moving: pull requests were updated on September 14, and issue #17730 was opened on September 13. The contribution guide explains that volunteers handle new lints, fixes, reviews, and triage, so response time can vary even in an active project.
Clippy has 8 CI workflow files, a test directory, and a clean 38-test result in our sandbox. GitHub returned no latest release object, while the README directs users to the Clippy component shipped through rustup. That release shape is not a sign of abandonment when code and issue activity are current. The source is available under MIT or Apache-2.0 terms. For Rust code, start with Clippy before shopping for another source linter, but keep dependency policy in cargo-deny and editor assistance in rust-analyzer.