Recommended Free Tools
A strong Rust code review checks whether a change does what it claims, handles boundary and error cases, preserves its invariants, and uses unsafe code soundly. Rust’s type system and memory-safety guarantees help prevent classes of bugs; they do not establish that program logic is correct. This guide is about reviewing Rust source code, not reviews of Rust games, crates, or products.
What should a Rust code review check?
Start with the change’s stated purpose, then trace how its behavior follows from the implementation. Ask what callers can observe, which invariants must remain true, and whether compatibility expectations are respected. Rust’s safety guarantees do not eliminate the need to test program logic; the Rust Book’s testing chapter makes that distinction explicit.
- Inputs and boundaries: Check empty, maximum, minimum, malformed, and otherwise unusual inputs relevant to the API.
- Errors: Follow failures through the call chain. Are errors propagated, transformed, or intentionally handled? Can a failure be mistaken for success?
- State and invariants: Identify what must be true before and after the change, including across early returns and partial updates.
- Concurrency: Where relevant, examine shared state, synchronization, ordering assumptions, and behavior under competing operations.
- Compatibility: Consider how the change affects existing callers, serialized data, public APIs, and documented behavior.
Compare tests with the behavior being claimed. A large test count does not show that the important cases are covered; look for tests that exercise the changed behavior, failure paths, and meaningful edge cases.
How should you review unsafe Rust?
Unsafe Rust permits five operations that the compiler does not verify for memory safety: dereferencing raw pointers, calling unsafe functions or methods, accessing or modifying mutable statics, implementing unsafe traits, and accessing union fields. Every unsafe block or abstraction deserves a specific safety argument, not just a comment saying that it is safe.
#1 Best Overall
- Identify the unsafe operation and the invariant that makes it sound.
- Check where that invariant is established, documented, and maintained, including at every call site and across mutations or concurrency.
- Ask whether the unsafe region can be smaller or contained behind a safe abstraction.
- Check that the safety explanation describes the conditions the code actually relies on, rather than restating the operation.
- Where useful, run Miri on relevant tests or examples to look for undefined behavior along executed paths.
The Rust Book’s Unsafe Rust chapter recommends keeping unsafe blocks small and using safe abstractions where possible. It notes that Miri can help build confidence that unsafe code upholds Rust’s rules. Miri can reveal some problems on paths it executes; it does not prove soundness, replace review, or cover every possible execution.
What can compiler checks, tests, and tools establish?
These checks serve different purposes. Treat their output as evidence for a particular scope, not as interchangeable proof that a change is correct.
Rank #2
| Review method | Useful for | Does not establish |
|---|---|---|
| Compiler checks | Finding violations of Rust’s compile-time rules in the code being built. | That the program’s logic matches its intended behavior or that all runtime cases are correct. |
| Tests | Checking behavior for the inputs and execution paths exercised by the test suite. | Correctness for untested cases or every possible execution. |
| Manual source review | Evaluating intent, invariants, error handling, API design, and edge cases in context. | A guarantee that a reviewer has found every defect. |
| Miri | Detecting some undefined behavior in unsafe code on paths it executes. | Soundness across unexecuted paths or a substitute for reasoning about invariants. |
| Dependency auditing | Checking dependencies for known advisories and, depending on tool configuration, policy violations. | A complete security assessment or proof that dependencies have no vulnerabilities. |
Run the formatter and the lint checks expected by the project to reduce style noise, then spend review attention on behavior and safety. There is no universally required lint configuration established here; follow the repository’s documented conventions rather than imposing a different policy.
How do you review dependencies and security?
Review the dependency graph separately from the semantics of the patch. RustSec maintains advisories for crates.io packages. cargo-audit checks Cargo.lock against known vulnerabilities; cargo-deny can also enforce policies involving licenses, package sources, and duplicate versions.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
Rank #3
When a tool reports an issue, inspect the advisory and confirm which versions and conditions are affected. Check for a maintainer-provided fix and evaluate whether the project’s use matches the reported risk. A clean scan means no issue was identified by the checks and advisory data used; it is not proof that the code or its dependencies are secure.
For suspected vulnerabilities, follow the affected project’s security policy and coordinate with maintainers before public disclosure. The Rust Project security policy defines the Rust Project’s stated scope and treats third-party crates separately. The Rust Foundation explains that crates.io vulnerabilities are filed in RustSec and cross-referenced to CVEs in its vulnerability disclosure policy. RustSec’s advisory contribution guide recommends reporting upstream and coordinating disclosure before filing an advisory, with stated exceptions. Apply the policy for the project in question; the Rust Project’s policy is not a universal policy for every crate.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.What makes a Rust API easier to review?
Consider whether the types express the states and constraints the implementation expects. Ask whether invalid states can be represented unnecessarily, whether callers can misuse the interface, and whether errors communicate actionable outcomes. A type that narrows what callers can do may make invariants easier to preserve, but it does not remove the need to examine how the implementation enforces them.
For deeper treatment of API design, testing, error handling, unsafe code, and concurrency, Rust for Rustaceans by Jon Gjengset is a further-reading option. It is not a prerequisite for reviewing a change.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
