Add #[allow(unreachable_code)] to generated impls for ! type (#404,

#400) ## Synopsis For `!` never type used in trait signatures, `rustc` emits `unreachable_code` warning ignoring the `#[automatically_derived]` attribute. ## Solution Add `#[allow(unreachable_code)]` to generated `impl`s to suppress such warnings for `!` and similar types.
JelteF · Aug 29, 2024 · 06acaad · 06acaad
1 parent d7c4a68
commit 06acaad
Show file tree

Hide file tree

Showing 24 changed files with 363 additions and 3 deletions.
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 - Associated types of type parameters not being treated as generics in `Debug`
   and `Display` expansions.
   ([#399](https://github.com/JelteF/derive_more/pull/399))
+- `unreachable_code` warnings on generated code when `!` (never type) is used.
+  ([#404](https://github.com/JelteF/derive_more/pull/404))
 
 
 ## 1.0.0 - 2024-08-07

diff --git a/impl/src/as/mod.rs b/impl/src/as/mod.rs
@@ -280,6 +280,7 @@ impl<'a> ToTokens for Expansion<'a> {
             };
 
             quote! {
+                #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
                 #[automatically_derived]
                 impl #impl_gens #trait_ty for #ty_ident #ty_gens #where_clause {
                     #[inline]

diff --git a/impl/src/constructor.rs b/impl/src/constructor.rs
@@ -26,6 +26,7 @@ pub fn expand(input: &DeriveInput, _: &str) -> TokenStream {
     let original_types = &get_field_types(&fields);
     quote! {
         #[allow(missing_docs)]
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #impl_generics #input_type #ty_generics #where_clause {
             #[inline]

diff --git a/impl/src/deref.rs b/impl/src/deref.rs
@@ -42,6 +42,7 @@ pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStre
     let (impl_generics, _, where_clause) = generics.split_for_impl();
 
     Ok(quote! {
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #impl_generics #trait_path for #input_type #ty_generics #where_clause {
             type Target = #target;

diff --git a/impl/src/deref_mut.rs b/impl/src/deref_mut.rs
@@ -33,6 +33,7 @@ pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStre
     let (impl_generics, _, where_clause) = generics.split_for_impl();
 
     Ok(quote! {
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #impl_generics #trait_path for #input_type #ty_generics #where_clause {
             #[inline]

diff --git a/impl/src/fmt/debug.rs b/impl/src/fmt/debug.rs
@@ -60,6 +60,7 @@ pub fn expand(input: &syn::DeriveInput, _: &str) -> syn::Result<TokenStream> {
     };
 
     Ok(quote! {
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #impl_gens derive_more::Debug for #ident #ty_gens #where_clause {
             #[inline]

diff --git a/impl/src/fmt/display.rs b/impl/src/fmt/display.rs
@@ -62,6 +62,7 @@ pub fn expand(input: &syn::DeriveInput, trait_name: &str) -> syn::Result<TokenSt
     };
 
     Ok(quote! {
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #impl_gens derive_more::#trait_ident for #ident #ty_gens #where_clause {
             fn fmt(

diff --git a/impl/src/from.rs b/impl/src/from.rs
@@ -172,6 +172,7 @@ impl<'a> Expansion<'a> {
                     });
 
                     Ok(quote! {
+                        #[allow(unreachable_code)] // omit warnings for `!` and unreachable types
                         #[automatically_derived]
                         impl #impl_gens derive_more::From<#ty> for #ident #ty_gens #where_clause {
                             #[inline]
@@ -192,6 +193,7 @@ impl<'a> Expansion<'a> {
                 });
 
                 Ok(quote! {
+                    #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
                     #[automatically_derived]
                     impl #impl_gens derive_more::From<(#( #field_tys ),*)> for #ident #ty_gens #where_clause {
                         #[inline]
@@ -222,9 +224,10 @@ impl<'a> Expansion<'a> {
                 let generics = {
                     let mut generics = self.generics.clone();
                     for (ty, ident) in field_tys.iter().zip(&gen_idents) {
-                        generics.make_where_clause().predicates.push(
-                            parse_quote! { #ty: derive_more::From<#ident> },
-                        );
+                        generics
+                            .make_where_clause()
+                            .predicates
+                            .push(parse_quote! { #ty: derive_more::From<#ident> });
                         generics
                             .params
                             .push(syn::TypeParam::from(ident.clone()).into());
@@ -234,6 +237,7 @@ impl<'a> Expansion<'a> {
                 let (impl_gens, _, where_clause) = generics.split_for_impl();
 
                 Ok(quote! {
+                    #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
                     #[automatically_derived]
                     impl #impl_gens derive_more::From<(#( #gen_idents ),*)> for #ident #ty_gens #where_clause {
                         #[inline]

diff --git a/impl/src/is_variant.rs b/impl/src/is_variant.rs
@@ -53,6 +53,7 @@ pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStre
     }
 
     let imp = quote! {
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #imp_generics #enum_name #type_generics #where_clause {
             #(#funcs)*

diff --git a/impl/src/not_like.rs b/impl/src/not_like.rs
@@ -35,6 +35,7 @@ pub fn expand(input: &DeriveInput, trait_name: &str) -> TokenStream {
     };
 
     quote! {
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #impl_generics derive_more::#trait_ident for #input_type #ty_generics #where_clause {
             type Output = #output_type;

diff --git a/impl/src/try_unwrap.rs b/impl/src/try_unwrap.rs
@@ -123,6 +123,7 @@ pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStre
     }
 
     let imp = quote! {
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #imp_generics #enum_name #type_generics #where_clause {
             #(#funcs)*

diff --git a/impl/src/unwrap.rs b/impl/src/unwrap.rs
@@ -118,6 +118,7 @@ pub fn expand(input: &DeriveInput, trait_name: &'static str) -> Result<TokenStre
     }
 
     let imp = quote! {
+        #[allow(unreachable_code)] // omit warnings for `!` and other unreachable types
         #[automatically_derived]
         impl #imp_generics #enum_name #type_generics #where_clause {
             #(#funcs)*

diff --git a/tests/as_mut.rs b/tests/as_mut.rs
@@ -1,4 +1,5 @@
 #![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(nightly, feature(never_type))]
 #![allow(clippy::unnecessary_mut_passed)] // testing correct signatures rather than actual code
 #![allow(dead_code)] // some code is tested for type checking only
 
@@ -423,6 +424,14 @@ mod single_field {
                 assert!(ptr::eq(item.as_mut(), item.0.as_mut()));
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use super::*;
+
+            #[derive(AsMut)]
+            struct Nothing(!);
+        }
     }
 
     mod named {
@@ -881,6 +890,16 @@ mod single_field {
                 assert!(ptr::eq(item.as_mut(), item.first.as_mut()));
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use super::*;
+
+            #[derive(AsMut)]
+            struct Nothing {
+                first: !,
+            }
+        }
     }
 }
 
@@ -1071,6 +1090,14 @@ mod multi_field {
                 assert!(ptr::eq(item.as_mut(), item.0.as_mut()));
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use super::*;
+
+            #[derive(AsMut)]
+            struct Nothing(String, !);
+        }
     }
 
     mod named {
@@ -1346,5 +1373,16 @@ mod multi_field {
                 assert!(ptr::eq(item.as_mut(), item.first.as_mut()));
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use super::*;
+
+            #[derive(AsMut)]
+            struct Nothing {
+                first: !,
+                second: i32,
+            }
+        }
     }
 }
diff --git a/tests/as_ref.rs b/tests/as_ref.rs
@@ -1,4 +1,5 @@
 #![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(nightly, feature(never_type))]
 #![allow(dead_code)] // some code is tested for type checking only
 
 #[cfg(not(feature = "std"))]
@@ -416,6 +417,14 @@ mod single_field {
                 assert!(ptr::eq(item.as_ref(), item.0.as_ref()));
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use super::*;
+
+            #[derive(AsRef)]
+            struct Nothing(!);
+        }
     }
 
     mod named {
@@ -874,6 +883,16 @@ mod single_field {
                 assert!(ptr::eq(item.as_ref(), item.first.as_ref()));
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use super::*;
+
+            #[derive(AsRef)]
+            struct Nothing {
+                first: !,
+            }
+        }
     }
 }
 
@@ -1064,6 +1083,14 @@ mod multi_field {
                 assert!(ptr::eq(item.as_ref(), item.0.as_ref()));
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use super::*;
+
+            #[derive(AsRef)]
+            struct Nothing(String, !);
+        }
     }
 
     mod named {
@@ -1339,5 +1366,16 @@ mod multi_field {
                 assert!(ptr::eq(item.as_ref(), item.first.as_ref()));
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use super::*;
+
+            #[derive(AsRef)]
+            struct Nothing {
+                first: !,
+                second: i32,
+            }
+        }
     }
 }
diff --git a/tests/constructor.rs b/tests/constructor.rs
@@ -1,4 +1,5 @@
 #![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(nightly, feature(never_type))]
 #![allow(dead_code)] // some code is tested for type checking only
 
 use derive_more::Constructor;
@@ -30,3 +31,25 @@ struct Point2D {
 }
 
 const POINT_2D: Point2D = Point2D::new(-4, 7);
+
+#[cfg(nightly)]
+mod never {
+    use super::*;
+
+    #[derive(Constructor)]
+    struct Tuple(!);
+
+    #[derive(Constructor)]
+    struct Struct {
+        field: !,
+    }
+
+    #[derive(Constructor)]
+    struct TupleMulti(i32, !);
+
+    #[derive(Constructor)]
+    struct StructMulti {
+        field: !,
+        other: i32,
+    }
+}
diff --git a/tests/debug.rs b/tests/debug.rs
@@ -1,4 +1,5 @@
 #![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(nightly, feature(never_type))]
 #![allow(dead_code)] // some code is tested for type checking only
 
 #[cfg(not(feature = "std"))]
@@ -417,6 +418,19 @@ mod structs {
                 }
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use derive_more::Debug;
+
+            #[derive(Debug)]
+            struct Tuple(!);
+
+            #[derive(Debug)]
+            struct Struct {
+                field: !,
+            }
+        }
     }
 
     mod multi_field {
@@ -676,6 +690,20 @@ mod structs {
                 );
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use derive_more::Debug;
+
+            #[derive(Debug)]
+            struct Tuple(i32, !);
+
+            #[derive(Debug)]
+            struct Struct {
+                field: !,
+                other: i32,
+            }
+        }
     }
 }
 
@@ -980,6 +1008,17 @@ mod enums {
                 }
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use derive_more::Debug;
+
+            #[derive(Debug)]
+            enum Enum {
+                Unnamed(!),
+                Named { field: ! },
+            }
+        }
     }
 
     mod multi_field_variant {
@@ -1155,6 +1194,17 @@ mod enums {
                 );
             }
         }
+
+        #[cfg(nightly)]
+        mod never {
+            use derive_more::Debug;
+
+            #[derive(Debug)]
+            enum Enum {
+                Unnamed(i32, !),
+                Named { field: !, other: i32 },
+            }
+        }
     }
 }