use span_suggestion_verbose

Author: ada4a

clippy_lints/src/missing_asserts_for_indexing.rs

@@ -401,7 +401,7 @@ fn report_indexes(cx: &LateContext<'_>, map: UnindexMap<u64, Vec<IndexEntry<'_>>
                             indexes,
                             "indexing into a slice multiple times with an `assert` that does not cover the highest index",
                             |diag| {
-                                diag.span_suggestion(
+                                diag.span_suggestion_verbose(
                                     assert_span,
                                     "provide the highest index that is indexed with",
                                     sugg,

tests/ui/missing_asserts_for_indexing.stderr

@@ -1,139 +1,191 @@
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:30:5
    |
-LL |     assert!(v.len() < 5);
-   |     -------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^   ^^^^   ^^^^   ^^^^   ^^^^
    |
    = note: asserting the length before indexing will elide bounds checks
    = note: `-D clippy::missing-asserts-for-indexing` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::missing_asserts_for_indexing)]`
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v.len() < 5);
+LL +     assert!(v.len() > 4);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:36:5
    |
-LL |     assert!(v.len() <= 5);
-   |     --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^   ^^^^   ^^^^   ^^^^   ^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v.len() <= 5);
+LL +     assert!(v.len() > 4);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:42:5
    |
-LL |     assert!(v.len() > 3);
-   |     -------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^   ^^^^   ^^^^   ^^^^   ^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v.len() > 3);
+LL +     assert!(v.len() > 4);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:48:5
    |
-LL |     assert!(v.len() >= 4);
-   |     --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
 LL |     v[0] + v[1] + v[2] + v[3] + v[4]
    |     ^^^^   ^^^^   ^^^^   ^^^^   ^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v.len() >= 4);
+LL +     assert!(v.len() > 4);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:66:13
    |
-LL |     assert!(v.len() >= 3);
-   |     --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 3)`
 LL |     let _ = v[0];
    |             ^^^^
 ...
 LL |     let _ = v[1..4];
    |             ^^^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v.len() >= 3);
+LL +     assert!(v.len() > 3);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:81:13
    |
-LL |     assert!(v.len() >= 4);
-   |     --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
 LL |     let _ = v[0];
    |             ^^^^
 ...
 LL |     let _ = v[1..=4];
    |             ^^^^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v.len() >= 4);
+LL +     assert!(v.len() > 4);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:97:13
    |
-LL |     assert!(v1.len() >= 12);
-   |     ----------------------- help: provide the highest index that is indexed with: `assert!(v1.len() > 12)`
-LL |     assert!(v2.len() >= 15);
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^   ^^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v1.len() >= 12);
+LL +     assert!(v1.len() > 12);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:100:13
    |
-LL |     assert!(v2.len() >= 15);
-   |     ----------------------- help: provide the highest index that is indexed with: `assert!(v2.len() > 15)`
-...
 LL |     let _ = v2[5] + v2[15];
    |             ^^^^^   ^^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v2.len() >= 15);
+LL +     assert!(v2.len() > 15);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:106:13
    |
-LL |     assert!(v1.len() >= 12);
-   |     ----------------------- help: provide the highest index that is indexed with: `assert!(v1.len() > 12)`
-LL |     assert!(v2.len() > 15);
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^   ^^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v1.len() >= 12);
+LL +     assert!(v1.len() > 12);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:131:13
    |
-LL |     assert!(v1.len() == 2);
-   |     ---------------------- help: provide the highest index that is indexed with: `assert!(v1.len() == 3)`
-...
 LL |     let _ = v1[0] + v1[1] + v1[2];
    |             ^^^^^   ^^^^^   ^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(v1.len() == 2);
+LL +     assert!(v1.len() == 3);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:136:13
    |
-LL |     assert!(2 == v3.len());
-   |     ---------------------- help: provide the highest index that is indexed with: `assert!(v3.len() == 3)`
-...
 LL |     let _ = v3[0] + v3[1] + v3[2];
    |             ^^^^^   ^^^^^   ^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert!(2 == v3.len());
+LL +     assert!(v3.len() == 3);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:158:13
    |
-LL |     assert_eq!(v1.len(), 2);
-   |     ----------------------- help: provide the highest index that is indexed with: `assert_eq!(v1.len(), 3)`
-...
 LL |     let _ = v1[0] + v1[1] + v1[2];
    |             ^^^^^   ^^^^^   ^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert_eq!(v1.len(), 2);
+LL +     assert_eq!(v1.len(), 3);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:163:13
    |
-LL |     assert_eq!(2, v3.len());
-   |     ----------------------- help: provide the highest index that is indexed with: `assert_eq!(v3.len(), 3)`
-...
 LL |     let _ = v3[0] + v3[1] + v3[2];
    |             ^^^^^   ^^^^^   ^^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -     assert_eq!(2, v3.len());
+LL +     assert_eq!(v3.len(), 3);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:172:17
    |
-LL |         assert_eq!(v.len(), 2);
-   |         ---------------------- help: provide the highest index that is indexed with: `assert_eq!(v.len(), 3)`
 LL |         let _ = v[0] + v[1] + v[2];
    |                 ^^^^   ^^^^   ^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -         assert_eq!(v.len(), 2);
+LL +         assert_eq!(v.len(), 3);
+   |
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
   --> tests/ui/missing_asserts_for_indexing.rs:178:17
    |
-LL |         debug_assert_eq!(v.len(), 2);
-   |         ---------------------------- help: provide the highest index that is indexed with: `debug_assert_eq!(v.len(), 3)`
 LL |         let _ = v[0] + v[1] + v[2];
    |                 ^^^^   ^^^^   ^^^^
+   |
+help: provide the highest index that is indexed with
+   |
+LL -         debug_assert_eq!(v.len(), 2);
+LL +         debug_assert_eq!(v.len(), 3);
+   |
 
 error: aborting due to 15 previous errors