I’m in the process of getting super-strict about the code quality of cretrit, the comparison-revealing encryption library that underlies the queryable encryption of the Enquo project.
While I’m going to write a whole big thing about Rust linting in the future, I bumped across a rather gnarly problem that I thought was worth sharing separately.
The problem, in short, is that the
unused_crate_dependencies lint interacts badly with crates that are only needed for benchmarking, such as (in my case)
Rust has a whole bucketload of “lints” that can help your codebase adhere to certain standards, by warning (or exploding) if the problem is detected.
unused_crate_dependencies lint, as the name suggests, gets snippy when there’s a crate listed in your
Cargo.toml that doesn’t appear to be used anywhere.
All well and good so far.
However, while Rust has the ability to specify “crates needed for running the testsuite” (the
[dev-dependencies] section of
Cargo.toml) separately from “crates needed for actually using this thing” (
[dependencies]), it doesn’t have a way to specify “crates needed for running the benchmarks”.
That is a problem when you’re using something like
criterion for benchmarking, because it doesn’t get refered to at all in your project code – it only gets used in the benchmarks.
When building your codebase for running the test suite, the compiler sees that you’ve specified
criterion as one of your “testsuite dependencies”, but it never gets used in your testsuite.
This causes the
unused_crate_dependencies lint to lose its tiny mind, and make your build look ugly (or fail).
Thankfully, the solution is very simple, once you know the trick (this could be the unofficial theme song of the entire Rust ecosystem).
You need to refer to the
criterion crate somewhere in the code that gets built during the testsuite.
The lint tells you most of what you need to do (like most things Rust, it tries hard to be helpful), but since it’s a development dependency, you need a little extra secret sauce.
All you need to do is add these two lines to the bottom of your
src/main.rs for a binary crate):
use criterion as _;
For the less Rust-literate, this means “when the build-time configuration flag
test is set, import the
criterion crate, but don’t, like, allow it to actually be referred to”.
This is enough to make the lint believe that the dependency is being used, and making it only happen when the
test build-time config flag is set avoids the ugliness of it trying to refer to the crate during regular builds (which would fail, because
criterion is only a dev-dependency).
Simple? Yes. Did it take me a lot of skull-sweat to figure out? You betcha. That’s why I’m writing it down – even if everyone else already knows this, at least future Matt will find this post next time he trips over this problem.