rust-clippy/tests/ui/cognitive_complexity.stderr

error: the function has a cognitive complexity of (28/25)
  --> $DIR/cognitive_complexity.rs:6:4
   |
LL | fn main() {
   |    ^^^^
   |
   = note: `-D clippy::cognitive-complexity` implied by `-D warnings`
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (7/1)
  --> $DIR/cognitive_complexity.rs:91:4
   |
LL | fn kaboom() {
   |    ^^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:149:4
   |
LL | fn baa() {
   |    ^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:150:13
   |
LL |     let x = || match 99 {
   |             ^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:167:4
   |
LL | fn bar() {
   |    ^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:186:4
   |
LL | fn barr() {
   |    ^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (3/1)
  --> $DIR/cognitive_complexity.rs:196:4
   |
LL | fn barr2() {
   |    ^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:212:4
   |
LL | fn barrr() {
   |    ^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (3/1)
  --> $DIR/cognitive_complexity.rs:222:4
   |
LL | fn barrr2() {
   |    ^^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:238:4
   |
LL | fn barrrr() {
   |    ^^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (3/1)
  --> $DIR/cognitive_complexity.rs:248:4
   |
LL | fn barrrr2() {
   |    ^^^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:264:4
   |
LL | fn cake() {
   |    ^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (4/1)
  --> $DIR/cognitive_complexity.rs:274:8
   |
LL | pub fn read_file(input_path: &str) -> String {
   |        ^^^^^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:305:4
   |
LL | fn void(void: Void) {
   |    ^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (8/1)
  --> $DIR/cognitive_complexity.rs:356:4
   |
LL | fn early_ret() -> i32 {
   |    ^^^^^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:377:13
   |
LL |     let x = |a: i32, b: i32| -> i32 {
   |             ^^^^^^^^^^^^^^^^
   |
   = help: you could split it up into multiple smaller functions

error: the function has a cognitive complexity of (2/1)
  --> $DIR/cognitive_complexity.rs:390:8
   |
LL |     fn moo(&self) {
   |        ^^^
   |
   = help: you could split it up into multiple smaller functions

error: aborting due to 17 previous errors
Improve cognitive_complexity lint's warning. Adds the value of complexity limit set for the lint to the warning. Fixes #4466 Signed-off-by: Victor Polevoy <fx@thefx.co> 2019-08-29 08:56:13 +00:00			`error: the function has a cognitive complexity of (28/25)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:6:4`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn main() {`
			`\| ^^^^`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00			`\|`
Renamed: Cyclomatic Complexity -> Cognitive Complexity * Ran automatic naming update * Formalized rename of `cyclomatic_complexity` to `cognitive_complexity` Added the rename to `lib.rs` Added rename test * Added warning for deprecated key `cyclomatic_complexity_threshold` and tests for it * Added deprecation status for Clippy's builtin attribute * Updated tests for new builtin attribute renaming 2019-02-23 01:19:50 +00:00			= note: `-D clippy::cognitive-complexity` implied by `-D warnings`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00			`= help: you could split it up into multiple smaller functions`

Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (7/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:91:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn kaboom() {`
			`\| ^^^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (2/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:149:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn baa() {`
			`\| ^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (2/1)`
			`--> $DIR/cognitive_complexity.rs:150:13`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| let x = \|\| match 99 {`
			`\| ^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (2/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:167:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn bar() {`
			`\| ^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (2/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:186:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn barr() {`
			`\| ^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (3/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:196:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn barr2() {`
			`\| ^^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (2/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:212:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn barrr() {`
			`\| ^^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (3/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:222:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn barrr2() {`
			`\| ^^^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (2/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:238:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn barrrr() {`
			`\| ^^^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (3/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:248:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn barrrr2() {`
			`\| ^^^^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (2/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:264:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn cake() {`
			`\| ^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (4/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:274:8`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| pub fn read_file(input_path: &str) -> String {`
			`\| ^^^^^^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (2/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:305:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn void(void: Void) {`
			`\| ^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
Add license header to Rust files 2018-10-06 16:18:06 +00:00
Remove use of the HIR CFG 2019-09-08 10:39:42 +00:00			`error: the function has a cognitive complexity of (8/1)`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`--> $DIR/cognitive_complexity.rs:356:4`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`LL \| fn early_ret() -> i32 {`
			`\| ^^^^^^^^^`
Update *.stderr files 2018-12-27 15:57:55 +00:00			`\|`
			`= help: you could split it up into multiple smaller functions`
rustup and compile-fail -> ui test move 2017-02-07 20:05:30 +00:00
Reduce cognitive complexity lint span Currently the cognitive complexity lint spans the entire function body making it really difficult to read and refactor the code in editors. To fix this we reduce the lint span to the function name. 2019-12-22 02:07:53 +00:00			`error: the function has a cognitive complexity of (2/1)`
			`--> $DIR/cognitive_complexity.rs:377:13`
			`\|`
			`LL \| let x = \|a: i32, b: i32\| -> i32 {`
			`\| ^^^^^^^^^^^^^^^^`
			`\|`
			`= help: you could split it up into multiple smaller functions`

			`error: the function has a cognitive complexity of (2/1)`
			`--> $DIR/cognitive_complexity.rs:390:8`
			`\|`
			`LL \| fn moo(&self) {`
			`\| ^^^`
			`\|`
			`= help: you could split it up into multiple smaller functions`

			`error: aborting due to 17 previous errors`
Update changed ui tests 2018-01-16 16:06:27 +00:00