Expand description
Calculate cognitive complexity of Rust code.
Based on Cognitive Complexity by G. Ann Campbell.
§Getting started
You’ll need to bring the Complexity
trait into scope, and probably some
things from syn
.
use complexity::Complexity;
use syn::{Expr, parse_quote};
Complexity of expressions and other syn
types is as simple as calling
.complexity()
on an instance of that type.
let expr: Expr = parse_quote! {
for element in iterable { // +1
if something { // +2 (nesting = 1)
do_something();
}
}
};
assert_eq!(expr.complexity(), 3);
§Examples
The implementation of cognitive complexity in this crate is heavily based on Cognitive Complexity by G. Ann Campbell. And reading it would be beneficial to understanding how the complexity index is calculated.
Loops and structures that introduce branching increment the complexity by one each. Some syntax structures introduce a “nesting” level which increases some expressions complexity by that nesting level in addition to their regular increment. In the example below we see how two nested loops and an if statement can produce quite a high complexity of 7.
use complexity::Complexity;
use syn::{ItemFn, parse_quote};
let func: ItemFn = parse_quote! {
fn sum_of_primes(max: u64) -> u64 {
let mut total = 0;
'outer: for i in 1..=max { // +1
for j in 2..i { // +2 (nesting = 1)
if i % j == 0 { // +3 (nesting = 2)
continue 'outer; // +1
}
}
total += i;
}
}
};
assert_eq!(func.complexity(), 7);
But some structures are rewarded. Particularly a match
statement, which
only increases the complexity by one no matter how many branches there are.
(It does increase the nesting level though.) In the example below we see how
even though there are a lot of branches in the code (which would contribute
a lot to a more traditional cyclomatic complexity measurement), the
complexity is quite low at 1.
use complexity::Complexity;
use syn::{ItemFn, parse_quote};
let func: ItemFn = parse_quote! {
fn get_words(number: u64) -> &str {
match number { // +1
1 => "one",
2 => "a couple",
3 => "a few",
_ => "lots",
}
}
};
assert_eq!(func.complexity(), 1);
An example is provided to calculate and nicely print out the cognitive complexity of each function and method in an entire Rust file. See examples/lint-files.rs. You can run it on Rust files like this:
cargo run --example lint-files -- src/
Traits§
- Complexity
- A trait for calculating the cognitive complexity of a Rust type.