about summary refs log tree commit diff
diff options
context:
space:
mode:
-rw-r--r--tests/ui/cast_size.32bit.stderr36
-rw-r--r--tests/ui/fn_to_numeric_cast.32bit.stderr44
-rw-r--r--tests/ui/large_enum_variant.32bit.stderr64
3 files changed, 81 insertions, 63 deletions
diff --git a/tests/ui/cast_size.32bit.stderr b/tests/ui/cast_size.32bit.stderr
index 8ff3464676c..d2c845dc821 100644
--- a/tests/ui/cast_size.32bit.stderr
+++ b/tests/ui/cast_size.32bit.stderr
@@ -13,7 +13,7 @@ LL |     i8::try_from(1isize);
    |     ~~~~~~~~~~~~~~~~~~~~
 
 error: casting `isize` to `f32` causes a loss of precision (`isize` is 32 or 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:21:5
+  --> tests/ui/cast_size.rs:22:5
    |
 LL |     x0 as f32;
    |     ^^^^^^^^^
@@ -22,25 +22,25 @@ LL |     x0 as f32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_precision_loss)]`
 
 error: casting `usize` to `f32` causes a loss of precision (`usize` is 32 or 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:22:5
+  --> tests/ui/cast_size.rs:24:5
    |
 LL |     x1 as f32;
    |     ^^^^^^^^^
 
 error: casting `isize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`isize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:23:5
+  --> tests/ui/cast_size.rs:26:5
    |
 LL |     x0 as f64;
    |     ^^^^^^^^^
 
 error: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:24:5
+  --> tests/ui/cast_size.rs:28:5
    |
 LL |     x1 as f64;
    |     ^^^^^^^^^
 
 error: casting `isize` to `i32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:28:5
+  --> tests/ui/cast_size.rs:33:5
    |
 LL |     1isize as i32;
    |     ^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL |     i32::try_from(1isize);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `isize` to `u32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:29:5
+  --> tests/ui/cast_size.rs:35:5
    |
 LL |     1isize as u32;
    |     ^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     u32::try_from(1isize);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:30:5
+  --> tests/ui/cast_size.rs:37:5
    |
 LL |     1usize as u32;
    |     ^^^^^^^^^^^^^
@@ -76,7 +76,7 @@ LL |     u32::try_from(1usize);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:31:5
+  --> tests/ui/cast_size.rs:39:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL |     i32::try_from(1usize);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:31:5
+  --> tests/ui/cast_size.rs:39:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     1usize as i32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
 
 error: casting `i64` to `isize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:32:5
+  --> tests/ui/cast_size.rs:42:5
    |
 LL |     1i64 as isize;
    |     ^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL |     isize::try_from(1i64);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:33:5
+  --> tests/ui/cast_size.rs:44:5
    |
 LL |     1i64 as usize;
    |     ^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     usize::try_from(1i64);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:34:5
+  --> tests/ui/cast_size.rs:46:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
@@ -133,13 +133,13 @@ LL |     isize::try_from(1u64);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:34:5
+  --> tests/ui/cast_size.rs:46:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:35:5
+  --> tests/ui/cast_size.rs:49:5
    |
 LL |     1u64 as usize;
    |     ^^^^^^^^^^^^^
@@ -151,25 +151,25 @@ LL |     usize::try_from(1u64);
    |     ~~~~~~~~~~~~~~~~~~~~~
 
 error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:36:5
+  --> tests/ui/cast_size.rs:51:5
    |
 LL |     1u32 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `i32` to `f32` causes a loss of precision (`i32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:43:5
+  --> tests/ui/cast_size.rs:59:5
    |
 LL |     999_999_999 as f32;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:44:5
+  --> tests/ui/cast_size.rs:61:5
    |
 LL |     9_999_999_999_999_999usize as f64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: literal out of range for `usize`
-  --> tests/ui/cast_size.rs:44:5
+  --> tests/ui/cast_size.rs:61:5
    |
 LL |     9_999_999_999_999_999usize as f64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/fn_to_numeric_cast.32bit.stderr b/tests/ui/fn_to_numeric_cast.32bit.stderr
index 65991a3989a..7093f8caf10 100644
--- a/tests/ui/fn_to_numeric_cast.32bit.stderr
+++ b/tests/ui/fn_to_numeric_cast.32bit.stderr
@@ -8,13 +8,13 @@ LL |     let _ = foo as i8;
    = help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast_with_truncation)]`
 
 error: casting function pointer `foo` to `i16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:11:13
+  --> tests/ui/fn_to_numeric_cast.rs:12:13
    |
 LL |     let _ = foo as i16;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `i32`
-  --> tests/ui/fn_to_numeric_cast.rs:12:13
+  --> tests/ui/fn_to_numeric_cast.rs:14:13
    |
 LL |     let _ = foo as i32;
    |             ^^^^^^^^^^ help: try: `foo as usize`
@@ -23,121 +23,121 @@ LL |     let _ = foo as i32;
    = help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast)]`
 
 error: casting function pointer `foo` to `i64`
-  --> tests/ui/fn_to_numeric_cast.rs:13:13
+  --> tests/ui/fn_to_numeric_cast.rs:16:13
    |
 LL |     let _ = foo as i64;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `i128`
-  --> tests/ui/fn_to_numeric_cast.rs:14:13
+  --> tests/ui/fn_to_numeric_cast.rs:18:13
    |
 LL |     let _ = foo as i128;
    |             ^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `isize`
-  --> tests/ui/fn_to_numeric_cast.rs:15:13
+  --> tests/ui/fn_to_numeric_cast.rs:20:13
    |
 LL |     let _ = foo as isize;
    |             ^^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:17:13
+  --> tests/ui/fn_to_numeric_cast.rs:23:13
    |
 LL |     let _ = foo as u8;
    |             ^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:18:13
+  --> tests/ui/fn_to_numeric_cast.rs:25:13
    |
 LL |     let _ = foo as u16;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u32`
-  --> tests/ui/fn_to_numeric_cast.rs:19:13
+  --> tests/ui/fn_to_numeric_cast.rs:27:13
    |
 LL |     let _ = foo as u32;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u64`
-  --> tests/ui/fn_to_numeric_cast.rs:20:13
+  --> tests/ui/fn_to_numeric_cast.rs:29:13
    |
 LL |     let _ = foo as u64;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u128`
-  --> tests/ui/fn_to_numeric_cast.rs:21:13
+  --> tests/ui/fn_to_numeric_cast.rs:31:13
    |
 LL |     let _ = foo as u128;
    |             ^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `abc` to `i8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:34:13
+  --> tests/ui/fn_to_numeric_cast.rs:45:13
    |
 LL |     let _ = abc as i8;
    |             ^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:35:13
+  --> tests/ui/fn_to_numeric_cast.rs:47:13
    |
 LL |     let _ = abc as i16;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i32`
-  --> tests/ui/fn_to_numeric_cast.rs:36:13
+  --> tests/ui/fn_to_numeric_cast.rs:49:13
    |
 LL |     let _ = abc as i32;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i64`
-  --> tests/ui/fn_to_numeric_cast.rs:37:13
+  --> tests/ui/fn_to_numeric_cast.rs:51:13
    |
 LL |     let _ = abc as i64;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i128`
-  --> tests/ui/fn_to_numeric_cast.rs:38:13
+  --> tests/ui/fn_to_numeric_cast.rs:53:13
    |
 LL |     let _ = abc as i128;
    |             ^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `isize`
-  --> tests/ui/fn_to_numeric_cast.rs:39:13
+  --> tests/ui/fn_to_numeric_cast.rs:55:13
    |
 LL |     let _ = abc as isize;
    |             ^^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:41:13
+  --> tests/ui/fn_to_numeric_cast.rs:58:13
    |
 LL |     let _ = abc as u8;
    |             ^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:42:13
+  --> tests/ui/fn_to_numeric_cast.rs:60:13
    |
 LL |     let _ = abc as u16;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u32`
-  --> tests/ui/fn_to_numeric_cast.rs:43:13
+  --> tests/ui/fn_to_numeric_cast.rs:62:13
    |
 LL |     let _ = abc as u32;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u64`
-  --> tests/ui/fn_to_numeric_cast.rs:44:13
+  --> tests/ui/fn_to_numeric_cast.rs:64:13
    |
 LL |     let _ = abc as u64;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u128`
-  --> tests/ui/fn_to_numeric_cast.rs:45:13
+  --> tests/ui/fn_to_numeric_cast.rs:66:13
    |
 LL |     let _ = abc as u128;
    |             ^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `f` to `i32`
-  --> tests/ui/fn_to_numeric_cast.rs:52:5
+  --> tests/ui/fn_to_numeric_cast.rs:74:5
    |
 LL |     f as i32
    |     ^^^^^^^^ help: try: `f as usize`
diff --git a/tests/ui/large_enum_variant.32bit.stderr b/tests/ui/large_enum_variant.32bit.stderr
index 36f3d930b53..af09a56854a 100644
--- a/tests/ui/large_enum_variant.32bit.stderr
+++ b/tests/ui/large_enum_variant.32bit.stderr
@@ -2,6 +2,7 @@ error: large size difference between variants
   --> tests/ui/large_enum_variant.rs:11:1
    |
 LL | / enum LargeEnum {
+LL | |
 LL | |     A(i32),
    | |     ------ the second-largest variant contains at least 4 bytes
 LL | |     B([i32; 8000]),
@@ -17,9 +18,10 @@ LL |     B(Box<[i32; 8000]>),
    |       ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:35:1
+  --> tests/ui/large_enum_variant.rs:36:1
    |
 LL | / enum LargeEnum2 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     ContainingLargeEnum(LargeEnum),
@@ -33,9 +35,10 @@ LL |     ContainingLargeEnum(Box<LargeEnum>),
    |                         ~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:40:1
+  --> tests/ui/large_enum_variant.rs:42:1
    |
 LL | / enum LargeEnum3 {
+LL | |
 LL | |     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
    | |     --------------------------------------------------------- the largest variant contains at least 70004 bytes
 LL | |     VoidVariant,
@@ -50,9 +53,10 @@ LL |     ContainingMoreThanOneField(i32, Box<[i32; 8000]>, Box<[i32; 9500]>),
    |                                     ~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:46:1
+  --> tests/ui/large_enum_variant.rs:49:1
    |
 LL | / enum LargeEnum4 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     StructLikeLarge { x: [i32; 8000], y: i32 },
@@ -66,9 +70,10 @@ LL |     StructLikeLarge { x: Box<[i32; 8000]>, y: i32 },
    |                          ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:51:1
+  --> tests/ui/large_enum_variant.rs:55:1
    |
 LL | / enum LargeEnum5 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     StructLikeLarge2 { x: [i32; 8000] },
@@ -82,9 +87,10 @@ LL |     StructLikeLarge2 { x: Box<[i32; 8000]> },
    |                           ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:67:1
+  --> tests/ui/large_enum_variant.rs:72:1
    |
 LL | / enum LargeEnum7 {
+LL | |
 LL | |     A,
 LL | |     B([u8; 1255]),
    | |     ------------- the largest variant contains at least 1255 bytes
@@ -99,9 +105,10 @@ LL |     B(Box<[u8; 1255]>),
    |       ~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:73:1
+  --> tests/ui/large_enum_variant.rs:79:1
    |
 LL | / enum LargeEnum8 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
@@ -115,9 +122,10 @@ LL |     ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>
    |                                ~~~~~~~~~~~~~~~~            ~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:78:1
+  --> tests/ui/large_enum_variant.rs:85:1
    |
 LL | / enum LargeEnum9 {
+LL | |
 LL | |     A(Struct<()>),
    | |     ------------- the second-largest variant contains at least 4 bytes
 LL | |     B(Struct2),
@@ -131,9 +139,10 @@ LL |     B(Box<Struct2>),
    |       ~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:83:1
+  --> tests/ui/large_enum_variant.rs:91:1
    |
 LL | / enum LargeEnumOk2<T> {
+LL | |
 LL | |     A(T),
    | |     ---- the second-largest variant contains at least 0 bytes
 LL | |     B(Struct2),
@@ -147,9 +156,10 @@ LL |     B(Box<Struct2>),
    |       ~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:88:1
+  --> tests/ui/large_enum_variant.rs:97:1
    |
 LL | / enum LargeEnumOk3<T> {
+LL | |
 LL | |     A(Struct<T>),
    | |     ------------ the second-largest variant contains at least 4 bytes
 LL | |     B(Struct2),
@@ -163,9 +173,10 @@ LL |     B(Box<Struct2>),
    |       ~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:103:1
+  --> tests/ui/large_enum_variant.rs:113:1
    |
 LL | / enum CopyableLargeEnum {
+LL | |
 LL | |     A(bool),
    | |     ------- the second-largest variant contains at least 1 bytes
 LL | |     B([u64; 8000]),
@@ -174,20 +185,21 @@ LL | | }
    | |_^ the entire enum is at least 64004 bytes
    |
 note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:103:6
+  --> tests/ui/large_enum_variant.rs:113:6
    |
 LL | enum CopyableLargeEnum {
    |      ^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:105:5
+  --> tests/ui/large_enum_variant.rs:116:5
    |
 LL |     B([u64; 8000]),
    |     ^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:108:1
+  --> tests/ui/large_enum_variant.rs:119:1
    |
 LL | / enum ManuallyCopyLargeEnum {
+LL | |
 LL | |     A(bool),
    | |     ------- the second-largest variant contains at least 1 bytes
 LL | |     B([u64; 8000]),
@@ -196,20 +208,21 @@ LL | | }
    | |_^ the entire enum is at least 64004 bytes
    |
 note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:108:6
+  --> tests/ui/large_enum_variant.rs:119:6
    |
 LL | enum ManuallyCopyLargeEnum {
    |      ^^^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:110:5
+  --> tests/ui/large_enum_variant.rs:122:5
    |
 LL |     B([u64; 8000]),
    |     ^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:121:1
+  --> tests/ui/large_enum_variant.rs:133:1
    |
 LL | / enum SomeGenericPossiblyCopyEnum<T> {
+LL | |
 LL | |     A(bool, std::marker::PhantomData<T>),
    | |     ------------------------------------ the second-largest variant contains at least 1 bytes
 LL | |     B([u64; 4000]),
@@ -218,20 +231,21 @@ LL | | }
    | |_^ the entire enum is at least 32004 bytes
    |
 note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:121:6
+  --> tests/ui/large_enum_variant.rs:133:6
    |
 LL | enum SomeGenericPossiblyCopyEnum<T> {
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:123:5
+  --> tests/ui/large_enum_variant.rs:136:5
    |
 LL |     B([u64; 4000]),
    |     ^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:134:1
+  --> tests/ui/large_enum_variant.rs:147:1
    |
 LL | / enum LargeEnumWithGenerics<T> {
+LL | |
 LL | |     Small,
    | |     ----- the second-largest variant carries no data at all
 LL | |     Large((T, [u8; 512])),
@@ -245,9 +259,10 @@ LL |     Large(Box<(T, [u8; 512])>),
    |           ~~~~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:143:1
+  --> tests/ui/large_enum_variant.rs:157:1
    |
 LL | / enum WithGenerics {
+LL | |
 LL | |     Large([Foo<u64>; 64]),
    | |     --------------------- the largest variant contains at least 512 bytes
 LL | |     Small(u8),
@@ -261,9 +276,10 @@ LL |     Large(Box<[Foo<u64>; 64]>),
    |           ~~~~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:153:1
+  --> tests/ui/large_enum_variant.rs:168:1
    |
 LL | / enum LargeEnumOfConst {
+LL | |
 LL | |     Ok,
    | |     -- the second-largest variant carries no data at all
 LL | |     Error(PossiblyLargeEnumWithConst<256>),
@@ -277,9 +293,10 @@ LL |     Error(Box<PossiblyLargeEnumWithConst<256>>),
    |           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:158:1
+  --> tests/ui/large_enum_variant.rs:174:1
    |
 LL | / enum WithRecursion {
+LL | |
 LL | |     Large([u64; 64]),
    | |     ---------------- the largest variant contains at least 512 bytes
 LL | |     Recursive(Box<WithRecursion>),
@@ -293,9 +310,10 @@ LL |     Large(Box<[u64; 64]>),
    |           ~~~~~~~~~~~~~~
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:168:1
+  --> tests/ui/large_enum_variant.rs:185:1
    |
 LL | / enum LargeEnumWithGenericsAndRecursive {
+LL | |
 LL | |     Ok(),
    | |     ---- the second-largest variant carries no data at all
 LL | |     Error(WithRecursionAndGenerics<u64>),