mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
rust/tests/ui/crashes/cc_seme.rs

30 lines
490 B
Rust
Raw Normal View History

Add missing `// run-pass` annotations to ICE tests compiletest UI tests do not fail when encountering panics and ICEs unless the `// run-pass` flag is used. (This was forgotten in https://github.com/rust-lang/rust-clippy/pull/3743)
2019-04-05 07:22:36 +02:00
// run-pass
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
#[allow(dead_code)]
Move run-pass tests to UI tests This should give us more UI coverage for free. It also removes the `run-pass` suite, so we now only have the `ui` suite.
2019-02-06 07:45:57 +01:00
/// Test for https://github.com/rust-lang/rust-clippy/issues/478
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
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,
}
rustfmt tests
2018-12-09 23:26:16 +01:00
fn main() {}
Remove all mention and testing of #[plugin(clippy)] and warn if used
2018-05-11 13:20:39 +02:00
pub fn foo() {
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
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!(),
rustfmt tests
2018-12-09 23:26:16 +01: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!(),
}
}
Reference in New Issue Copy Permalink