adjust clippy to fix some of the issues

RalfJung · RalfJung · commit 55317ef15791 · 2025-11-21T16:38:20.000+01:00
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -2128,7 +2128,6 @@ symbols! {
         slice_from_raw_parts_mut,
         slice_from_ref,
         slice_get_unchecked,
-        slice_into_vec,
         slice_iter,
         slice_len_fn,
         slice_patterns,
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
@@ -260,6 +260,7 @@ unsafe fn box_new_uninit(size: usize, align: usize) -> *mut u8 {
 #[unstable(feature = "liballoc_internals", issue = "none")]
 #[inline(always)]
 #[cfg(not(no_global_oom_handling))]
+#[rustc_diagnostic_item = "box_uninit_array_into_vec_unsafe"]
 pub fn box_uninit_array_into_vec_unsafe<T, const N: usize>(
     b: Box<MaybeUninit<[T; N]>>,
 ) -> crate::vec::Vec<T> {
diff --git a/library/alloc/src/slice.rs b/library/alloc/src/slice.rs
@@ -474,7 +474,6 @@ impl<T> [T] {
     #[rustc_allow_incoherent_impl]
     #[stable(feature = "rust1", since = "1.0.0")]
     #[inline]
-    #[rustc_diagnostic_item = "slice_into_vec"]
     pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> {
         unsafe {
             let len = self.len();
diff --git a/src/tools/clippy/clippy_utils/src/higher.rs b/src/tools/clippy/clippy_utils/src/higher.rs
@@ -297,12 +297,12 @@ impl<'a> VecArgs<'a> {
                     // `vec![elem; size]` case
                     Some(VecArgs::Repeat(elem, size))
                 },
-                (sym::slice_into_vec, [slice])
-                    if let ExprKind::Call(_, [arg]) = slice.kind
-                        && let ExprKind::Array(args) = arg.kind =>
+                (sym::box_uninit_array_into_vec_unsafe, [write_box_via_move])
+                    if let ExprKind::Call(_, [_box, elems]) = write_box_via_move.kind
+                        && let ExprKind::Array(elems) = elems.kind =>
                 {
                     // `vec![a, b, c]` case
-                    Some(VecArgs::Vec(args))
+                    Some(VecArgs::Vec(elems))
                 },
                 (sym::vec_new, []) => Some(VecArgs::Vec(&[])),
                 _ => None,
diff --git a/src/tools/clippy/clippy_utils/src/sym.rs b/src/tools/clippy/clippy_utils/src/sym.rs
@@ -91,6 +91,7 @@ generate! {
     author,
     borrow,
     borrow_mut,
+    box_uninit_array_into_vec_unsafe,
     build_hasher,
     by_ref,
     bytes,
diff --git a/src/tools/clippy/tests/ui/cognitive_complexity.rs b/src/tools/clippy/tests/ui/cognitive_complexity.rs
@@ -119,6 +119,7 @@ fn kaboom() {
 }
 
 fn bloo() {
+    //~^ cognitive_complexity
     match 42 {
         0 => println!("hi"),
         1 => println!("hai"),
diff --git a/src/tools/clippy/tests/ui/cognitive_complexity.stderr b/src/tools/clippy/tests/ui/cognitive_complexity.stderr
@@ -17,164 +17,172 @@ LL | fn kaboom() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:158:4
+  --> tests/ui/cognitive_complexity.rs:121:4
+   |
+LL | fn bloo() {
+   |    ^^^^
+   |
+   = help: you could split it up into multiple smaller functions
+
+error: the function has a cognitive complexity of (2/1)
+  --> tests/ui/cognitive_complexity.rs:159:4
    |
 LL | fn baa() {
    |    ^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:161:13
+  --> tests/ui/cognitive_complexity.rs:162: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)
-  --> tests/ui/cognitive_complexity.rs:179:4
+  --> tests/ui/cognitive_complexity.rs:180:4
    |
 LL | fn bar() {
    |    ^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:192:4
+  --> tests/ui/cognitive_complexity.rs:193:4
    |
 LL | fn dont_warn_on_tests() {
    |    ^^^^^^^^^^^^^^^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:202:4
+  --> tests/ui/cognitive_complexity.rs:203:4
    |
 LL | fn barr() {
    |    ^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (3/1)
-  --> tests/ui/cognitive_complexity.rs:214:4
+  --> tests/ui/cognitive_complexity.rs:215:4
    |
 LL | fn barr2() {
    |    ^^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:232:4
+  --> tests/ui/cognitive_complexity.rs:233:4
    |
 LL | fn barrr() {
    |    ^^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (3/1)
-  --> tests/ui/cognitive_complexity.rs:244:4
+  --> tests/ui/cognitive_complexity.rs:245:4
    |
 LL | fn barrr2() {
    |    ^^^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:262:4
+  --> tests/ui/cognitive_complexity.rs:263:4
    |
 LL | fn barrrr() {
    |    ^^^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (3/1)
-  --> tests/ui/cognitive_complexity.rs:274:4
+  --> tests/ui/cognitive_complexity.rs:275:4
    |
 LL | fn barrrr2() {
    |    ^^^^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:292:4
+  --> tests/ui/cognitive_complexity.rs:293:4
    |
 LL | fn cake() {
    |    ^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (4/1)
-  --> tests/ui/cognitive_complexity.rs:304:8
+  --> tests/ui/cognitive_complexity.rs:305: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)
-  --> tests/ui/cognitive_complexity.rs:337:4
+  --> tests/ui/cognitive_complexity.rs:338: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)
-  --> tests/ui/cognitive_complexity.rs:390:4
+  --> tests/ui/cognitive_complexity.rs:391: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)
-  --> tests/ui/cognitive_complexity.rs:413:13
+  --> tests/ui/cognitive_complexity.rs:414: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)
-  --> tests/ui/cognitive_complexity.rs:428:8
+  --> tests/ui/cognitive_complexity.rs:429:8
    |
 LL |     fn moo(&self) {
    |        ^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:439:14
+  --> tests/ui/cognitive_complexity.rs:440:14
    |
 LL |     async fn a() {
    |              ^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:448:22
+  --> tests/ui/cognitive_complexity.rs:449:22
    |
 LL |         pub async fn async_method() {
    |                      ^^^^^^^^^^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:459:8
+  --> tests/ui/cognitive_complexity.rs:460:8
    |
 LL |     fn foo() {
    |        ^^^
    |
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:466:8
+  --> tests/ui/cognitive_complexity.rs:467:8
    |
 LL |     fn bar() {
    |        ^^^
    |
    = help: you could split it up into multiple smaller functions
 
-error: aborting due to 22 previous errors
+error: aborting due to 23 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_map_option.fixed b/src/tools/clippy/tests/ui/manual_map_option.fixed
@@ -113,10 +113,7 @@ fn main() {
     }
 
     // #6811
-    match Some(0) {
-        Some(x) => Some(vec![x]),
-        None => None,
-    };
+    Some(0).map(|x| vec![x]);
 
     // Don't lint, coercion
     let x: Option<Vec<&[u8]>> = match Some(()) {
diff --git a/src/tools/clippy/tests/ui/manual_map_option.rs b/src/tools/clippy/tests/ui/manual_map_option.rs
@@ -183,6 +183,7 @@ fn main() {
 
     // #6811
     match Some(0) {
+        //~^ manual_map
         Some(x) => Some(vec![x]),
         None => None,
     };
diff --git a/src/tools/clippy/tests/ui/manual_map_option.stderr b/src/tools/clippy/tests/ui/manual_map_option.stderr
@@ -173,7 +173,17 @@ LL | |     };
    | |_____^ help: try: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:196:5
+  --> tests/ui/manual_map_option.rs:185:5
+   |
+LL | /     match Some(0) {
+LL | |
+LL | |         Some(x) => Some(vec![x]),
+LL | |         None => None,
+LL | |     };
+   | |_____^ help: try: `Some(0).map(|x| vec![x])`
+
+error: manual implementation of `Option::map`
+  --> tests/ui/manual_map_option.rs:197:5
    |
 LL | /     match option_env!("") {
 LL | |
@@ -183,7 +193,7 @@ LL | |     };
    | |_____^ help: try: `option_env!("").map(String::from)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:217:12
+  --> tests/ui/manual_map_option.rs:218:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
@@ -195,7 +205,7 @@ LL | |     };
    | |_____^ help: try: `{ Some(0).map(|x| x + 1) }`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:226:12
+  --> tests/ui/manual_map_option.rs:227:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
@@ -206,5 +216,5 @@ LL | |         None
 LL | |     };
    | |_____^ help: try: `{ Some(0).map(|x| x + 1) }`
 
-error: aborting due to 20 previous errors
+error: aborting due to 21 previous errors
 
diff --git a/src/tools/clippy/tests/ui/or_fun_call.fixed b/src/tools/clippy/tests/ui/or_fun_call.fixed
@@ -53,7 +53,7 @@ fn or_fun_call() {
     with_constructor.unwrap_or_else(make);
     //~^ or_fun_call
 
-    let with_new = Some(vec![1]);
+    let with_new: Option<Vec<i32>> = Some(vec![1]);
     with_new.unwrap_or_default();
     //~^ unwrap_or_default
 
@@ -101,7 +101,7 @@ fn or_fun_call() {
     real_default.unwrap_or_default();
     //~^ unwrap_or_default
 
-    let with_vec = Some(vec![1]);
+    let with_vec: Option<Vec<i32>> = Some(vec![1]);
     with_vec.unwrap_or_default();
     //~^ unwrap_or_default
 
@@ -329,7 +329,7 @@ mod lazy {
             }
         }
 
-        let with_new = Some(vec![1]);
+        let with_new: Option<Vec<i32>> = Some(vec![1]);
         with_new.unwrap_or_default();
         //~^ unwrap_or_default
 
diff --git a/src/tools/clippy/tests/ui/or_fun_call.rs b/src/tools/clippy/tests/ui/or_fun_call.rs
@@ -53,7 +53,7 @@ fn or_fun_call() {
     with_constructor.unwrap_or(make());
     //~^ or_fun_call
 
-    let with_new = Some(vec![1]);
+    let with_new: Option<Vec<i32>> = Some(vec![1]);
     with_new.unwrap_or(Vec::new());
     //~^ unwrap_or_default
 
@@ -101,7 +101,7 @@ fn or_fun_call() {
     real_default.unwrap_or(<FakeDefault as Default>::default());
     //~^ unwrap_or_default
 
-    let with_vec = Some(vec![1]);
+    let with_vec: Option<Vec<i32>> = Some(vec![1]);
     with_vec.unwrap_or(Vec::new());
     //~^ unwrap_or_default
 
@@ -329,7 +329,7 @@ mod lazy {
             }
         }
 
-        let with_new = Some(vec![1]);
+        let with_new: Option<Vec<i32>> = Some(vec![1]);
         with_new.unwrap_or_else(Vec::new);
         //~^ unwrap_or_default
 
diff --git a/src/tools/clippy/tests/ui/unwrap_or_else_default.fixed b/src/tools/clippy/tests/ui/unwrap_or_else_default.fixed
@@ -43,8 +43,7 @@ fn unwrap_or_else_default() {
     with_enum.unwrap_or_else(Enum::A);
 
     let with_new = Some(vec![1]);
-    with_new.unwrap_or_default();
-    //~^ unwrap_or_default
+    with_new.unwrap_or_else(Vec::new);
 
     let with_err: Result<_, ()> = Ok(vec![1]);
     with_err.unwrap_or_else(make);
diff --git a/src/tools/clippy/tests/ui/unwrap_or_else_default.rs b/src/tools/clippy/tests/ui/unwrap_or_else_default.rs
@@ -44,7 +44,6 @@ fn unwrap_or_else_default() {
 
     let with_new = Some(vec![1]);
     with_new.unwrap_or_else(Vec::new);
-    //~^ unwrap_or_default
 
     let with_err: Result<_, ()> = Ok(vec![1]);
     with_err.unwrap_or_else(make);
diff --git a/src/tools/clippy/tests/ui/unwrap_or_else_default.stderr b/src/tools/clippy/tests/ui/unwrap_or_else_default.stderr

Original file line number	Diff line number	Diff line change
`@@ -119,6 +119,7 @@ fn kaboom() {`
`119`	`119`	`}`
`120`	`120`
`121`	`121`	`fn bloo() {`
	`122`	`+ //~^ cognitive_complexity`
`122`	`123`	`match 42 {`
`123`	`124`	`0 => println!("hi"),`
`124`	`125`	`1 => println!("hai"),`
Original file line number	Diff line number	Diff line change
`@@ -17,164 +17,172 @@ LL \| fn kaboom() {`
`17`	`17`	`= help: you could split it up into multiple smaller functions`
`18`	`18`
`19`	`19`	`error: the function has a cognitive complexity of (2/1)`
`20`		`- --> tests/ui/cognitive_complexity.rs:158:4`
	`20`	`+ --> tests/ui/cognitive_complexity.rs:121:4`
	`21`	`+ \|`
	`22`	`+LL \| fn bloo() {`
	`23`	`+ \| ^^^^`
	`24`	`+ \|`
	`25`	`+ = help: you could split it up into multiple smaller functions`
	`26`	`+`
	`27`	`+error: the function has a cognitive complexity of (2/1)`
	`28`	`+ --> tests/ui/cognitive_complexity.rs:159:4`
`21`	`29`	`\|`
`22`	`30`	`LL \| fn baa() {`
`23`	`31`	`\| ^^^`
`24`	`32`	`\|`
`25`	`33`	`= help: you could split it up into multiple smaller functions`
`26`	`34`
`27`	`35`	`error: the function has a cognitive complexity of (2/1)`
`28`		`- --> tests/ui/cognitive_complexity.rs:161:13`
	`36`	`+ --> tests/ui/cognitive_complexity.rs:162:13`
`29`	`37`	`\|`
`30`	`38`	`LL \| let x = \|\| match 99 {`
`31`	`39`	`\| ^^`
`32`	`40`	`\|`
`33`	`41`	`= help: you could split it up into multiple smaller functions`
`34`	`42`
`35`	`43`	`error: the function has a cognitive complexity of (2/1)`
`36`		`- --> tests/ui/cognitive_complexity.rs:179:4`
	`44`	`+ --> tests/ui/cognitive_complexity.rs:180:4`
`37`	`45`	`\|`
`38`	`46`	`LL \| fn bar() {`
`39`	`47`	`\| ^^^`
`40`	`48`	`\|`
`41`	`49`	`= help: you could split it up into multiple smaller functions`
`42`	`50`
`43`	`51`	`error: the function has a cognitive complexity of (2/1)`
`44`		`- --> tests/ui/cognitive_complexity.rs:192:4`
	`52`	`+ --> tests/ui/cognitive_complexity.rs:193:4`
`45`	`53`	`\|`
`46`	`54`	`LL \| fn dont_warn_on_tests() {`
`47`	`55`	`\| ^^^^^^^^^^^^^^^^^^`
`48`	`56`	`\|`
`49`	`57`	`= help: you could split it up into multiple smaller functions`
`50`	`58`
`51`	`59`	`error: the function has a cognitive complexity of (2/1)`
`52`		`- --> tests/ui/cognitive_complexity.rs:202:4`
	`60`	`+ --> tests/ui/cognitive_complexity.rs:203:4`
`53`	`61`	`\|`
`54`	`62`	`LL \| fn barr() {`
`55`	`63`	`\| ^^^^`
`56`	`64`	`\|`
`57`	`65`	`= help: you could split it up into multiple smaller functions`
`58`	`66`
`59`	`67`	`error: the function has a cognitive complexity of (3/1)`
`60`		`- --> tests/ui/cognitive_complexity.rs:214:4`
	`68`	`+ --> tests/ui/cognitive_complexity.rs:215:4`
`61`	`69`	`\|`
`62`	`70`	`LL \| fn barr2() {`
`63`	`71`	`\| ^^^^^`
`64`	`72`	`\|`
`65`	`73`	`= help: you could split it up into multiple smaller functions`
`66`	`74`
`67`	`75`	`error: the function has a cognitive complexity of (2/1)`
`68`		`- --> tests/ui/cognitive_complexity.rs:232:4`
	`76`	`+ --> tests/ui/cognitive_complexity.rs:233:4`
`69`	`77`	`\|`
`70`	`78`	`LL \| fn barrr() {`
`71`	`79`	`\| ^^^^^`
`72`	`80`	`\|`
`73`	`81`	`= help: you could split it up into multiple smaller functions`
`74`	`82`
`75`	`83`	`error: the function has a cognitive complexity of (3/1)`
`76`		`- --> tests/ui/cognitive_complexity.rs:244:4`
	`84`	`+ --> tests/ui/cognitive_complexity.rs:245:4`
`77`	`85`	`\|`
`78`	`86`	`LL \| fn barrr2() {`
`79`	`87`	`\| ^^^^^^`
`80`	`88`	`\|`
`81`	`89`	`= help: you could split it up into multiple smaller functions`
`82`	`90`
`83`	`91`	`error: the function has a cognitive complexity of (2/1)`
`84`		`- --> tests/ui/cognitive_complexity.rs:262:4`
	`92`	`+ --> tests/ui/cognitive_complexity.rs:263:4`
`85`	`93`	`\|`
`86`	`94`	`LL \| fn barrrr() {`
`87`	`95`	`\| ^^^^^^`
`88`	`96`	`\|`
`89`	`97`	`= help: you could split it up into multiple smaller functions`
`90`	`98`
`91`	`99`	`error: the function has a cognitive complexity of (3/1)`
`92`		`- --> tests/ui/cognitive_complexity.rs:274:4`
	`100`	`+ --> tests/ui/cognitive_complexity.rs:275:4`
`93`	`101`	`\|`
`94`	`102`	`LL \| fn barrrr2() {`
`95`	`103`	`\| ^^^^^^^`
`96`	`104`	`\|`
`97`	`105`	`= help: you could split it up into multiple smaller functions`
`98`	`106`
`99`	`107`	`error: the function has a cognitive complexity of (2/1)`
`100`		`- --> tests/ui/cognitive_complexity.rs:292:4`
	`108`	`+ --> tests/ui/cognitive_complexity.rs:293:4`
`101`	`109`	`\|`
`102`	`110`	`LL \| fn cake() {`
`103`	`111`	`\| ^^^^`
`104`	`112`	`\|`
`105`	`113`	`= help: you could split it up into multiple smaller functions`
`106`	`114`
`107`	`115`	`error: the function has a cognitive complexity of (4/1)`
`108`		`- --> tests/ui/cognitive_complexity.rs:304:8`
	`116`	`+ --> tests/ui/cognitive_complexity.rs:305:8`
`109`	`117`	`\|`
`110`	`118`	`LL \| pub fn read_file(input_path: &str) -> String {`
`111`	`119`	`\| ^^^^^^^^^`
`112`	`120`	`\|`
`113`	`121`	`= help: you could split it up into multiple smaller functions`
`114`	`122`
`115`	`123`	`error: the function has a cognitive complexity of (2/1)`
`116`		`- --> tests/ui/cognitive_complexity.rs:337:4`
	`124`	`+ --> tests/ui/cognitive_complexity.rs:338:4`
`117`	`125`	`\|`
`118`	`126`	`LL \| fn void(void: Void) {`
`119`	`127`	`\| ^^^^`
`120`	`128`	`\|`
`121`	`129`	`= help: you could split it up into multiple smaller functions`
`122`	`130`
`123`	`131`	`error: the function has a cognitive complexity of (8/1)`
`124`		`- --> tests/ui/cognitive_complexity.rs:390:4`
	`132`	`+ --> tests/ui/cognitive_complexity.rs:391:4`
`125`	`133`	`\|`
`126`	`134`	`LL \| fn early_ret() -> i32 {`
`127`	`135`	`\| ^^^^^^^^^`
`128`	`136`	`\|`
`129`	`137`	`= help: you could split it up into multiple smaller functions`
`130`	`138`
`131`	`139`	`error: the function has a cognitive complexity of (2/1)`
`132`		`- --> tests/ui/cognitive_complexity.rs:413:13`
	`140`	`+ --> tests/ui/cognitive_complexity.rs:414:13`
`133`	`141`	`\|`
`134`	`142`	`LL \| let x = \|a: i32, b: i32\| -> i32 {`
`135`	`143`	`\| ^^^^^^^^^^^^^^^^`
`136`	`144`	`\|`
`137`	`145`	`= help: you could split it up into multiple smaller functions`
`138`	`146`
`139`	`147`	`error: the function has a cognitive complexity of (2/1)`
`140`		`- --> tests/ui/cognitive_complexity.rs:428:8`
	`148`	`+ --> tests/ui/cognitive_complexity.rs:429:8`
`141`	`149`	`\|`
`142`	`150`	`LL \| fn moo(&self) {`
`143`	`151`	`\| ^^^`
`144`	`152`	`\|`
`145`	`153`	`= help: you could split it up into multiple smaller functions`
`146`	`154`
`147`	`155`	`error: the function has a cognitive complexity of (2/1)`
`148`		`- --> tests/ui/cognitive_complexity.rs:439:14`
	`156`	`+ --> tests/ui/cognitive_complexity.rs:440:14`
`149`	`157`	`\|`
`150`	`158`	`LL \| async fn a() {`
`151`	`159`	`\| ^`
`152`	`160`	`\|`
`153`	`161`	`= help: you could split it up into multiple smaller functions`
`154`	`162`
`155`	`163`	`error: the function has a cognitive complexity of (2/1)`
`156`		`- --> tests/ui/cognitive_complexity.rs:448:22`
	`164`	`+ --> tests/ui/cognitive_complexity.rs:449:22`
`157`	`165`	`\|`
`158`	`166`	`LL \| pub async fn async_method() {`
`159`	`167`	`\| ^^^^^^^^^^^^`
`160`	`168`	`\|`
`161`	`169`	`= help: you could split it up into multiple smaller functions`
`162`	`170`
`163`	`171`	`error: the function has a cognitive complexity of (2/1)`
`164`		`- --> tests/ui/cognitive_complexity.rs:459:8`
	`172`	`+ --> tests/ui/cognitive_complexity.rs:460:8`
`165`	`173`	`\|`
`166`	`174`	`LL \| fn foo() {`
`167`	`175`	`\| ^^^`
`168`	`176`	`\|`
`169`	`177`	`= help: you could split it up into multiple smaller functions`
`170`	`178`
`171`	`179`	`error: the function has a cognitive complexity of (2/1)`
`172`		`- --> tests/ui/cognitive_complexity.rs:466:8`
	`180`	`+ --> tests/ui/cognitive_complexity.rs:467:8`
`173`	`181`	`\|`
`174`	`182`	`LL \| fn bar() {`
`175`	`183`	`\| ^^^`
`176`	`184`	`\|`
`177`	`185`	`= help: you could split it up into multiple smaller functions`
`178`	`186`
`179`		`-error: aborting due to 22 previous errors`
	`187`	`+error: aborting due to 23 previous errors`
`180`	`188`