rust/tests/cc_seme.rs

#![feature(plugin)]
#![plugin(clippy)]

#[allow(dead_code)]
enum Baz {
    One,
    Two,
}

struct Test {
    t: Option<usize>,
    b: Baz,
}

fn main() {
    use Baz::*;
    let x = Test { t: Some(0), b: One };

    match x {
        Test { t: Some(_), b: One } => unreachable!(),
        Test {
            t: Some(42),
            b: Two,
        } => unreachable!(),
        Test { t: None, .. } => unreachable!(),
        Test { .. } => unreachable!(),
    }
}
fix cc computation in the presence of diverging calls CFG treats diverging calls as its completely own path out of the function. While this makes sense, it should also mean that a panic should increase the cyclomatic complexity. Instead it decreases it. Minimal example: ```rust if a { b } else { panic!("cake"); } d ``` creates the following graph ```dot digraph G { "if a" -> "b" "if a" -> "panic!(\"cake\")" "b" -> c } ``` which has a CC of 1 (3 - 4 + 2). A CC of 1 means there is one path through the program. Obviously that is wrong. There are two paths. One returning normally, and one panicking. 2015-12-14 14:29:20 +01:00			`#![feature(plugin)]`
			`#![plugin(clippy)]`

			`#[allow(dead_code)]`
			`enum Baz {`
fallout 2016-02-01 12:51:33 +01:00			`One,`
			`Two,`
fix cc computation in the presence of diverging calls CFG treats diverging calls as its completely own path out of the function. While this makes sense, it should also mean that a panic should increase the cyclomatic complexity. Instead it decreases it. Minimal example: ```rust if a { b } else { panic!("cake"); } d ``` creates the following graph ```dot digraph G { "if a" -> "b" "if a" -> "panic!(\"cake\")" "b" -> c } ``` which has a CC of 1 (3 - 4 + 2). A CC of 1 means there is one path through the program. Obviously that is wrong. There are two paths. One returning normally, and one panicking. 2015-12-14 14:29:20 +01:00			`}`

			`struct Test {`
			`t: Option<usize>,`
			`b: Baz,`
			`}`

			`fn main() {`
			`use Baz::*;`
Run rustfmt 2017-04-12 11:06:32 +02:00			`let x = Test { t: Some(0), b: One };`
fix cc computation in the presence of diverging calls CFG treats diverging calls as its completely own path out of the function. While this makes sense, it should also mean that a panic should increase the cyclomatic complexity. Instead it decreases it. Minimal example: ```rust if a { b } else { panic!("cake"); } d ``` creates the following graph ```dot digraph G { "if a" -> "b" "if a" -> "panic!(\"cake\")" "b" -> c } ``` which has a CC of 1 (3 - 4 + 2). A CC of 1 means there is one path through the program. Obviously that is wrong. There are two paths. One returning normally, and one panicking. 2015-12-14 14:29:20 +01:00
			`match x {`
fallout 2016-02-01 12:51:33 +01:00			`Test { t: Some(_), b: One } => unreachable!(),`
Run rustfmt 2017-04-12 11:06:32 +02:00			`Test {`
			`t: Some(42),`
			`b: Two,`
			`} => unreachable!(),`
fix cc computation in the presence of diverging calls CFG treats diverging calls as its completely own path out of the function. While this makes sense, it should also mean that a panic should increase the cyclomatic complexity. Instead it decreases it. Minimal example: ```rust if a { b } else { panic!("cake"); } d ``` creates the following graph ```dot digraph G { "if a" -> "b" "if a" -> "panic!(\"cake\")" "b" -> c } ``` which has a CC of 1 (3 - 4 + 2). A CC of 1 means there is one path through the program. Obviously that is wrong. There are two paths. One returning normally, and one panicking. 2015-12-14 14:29:20 +01:00			`Test { t: None, .. } => unreachable!(),`
			`Test { .. } => unreachable!(),`
			`}`
			`}`