Add remaining use-case tests

Author: daxpedda

non-msrv-tests/tests/ui/use_case.rs

@@ -26,4 +26,20 @@ enum EnumNone {
 	A(u8),
 }
 
+#[derive(DeriveWhere)]
+#[derive_where(Clone; T)]
+struct SameGenerics<T>(T);
+
+#[derive(DeriveWhere)]
+#[derive_where(Clone, Debug; T)]
+#[derive_where(skip_inner)]
+struct Skip<T>(T);
+
+#[derive(DeriveWhere)]
+#[derive_where(Clone, Default; T)]
+enum Default<T> {
+	#[derive_where(default)]
+	A(T),
+}
+
 fn main() {}

non-msrv-tests/tests/ui/use_case.stderr

@@ -26,18 +26,32 @@ error: derive-where doesn't support empty items, as this can already be handled
 17 | | struct UnionEmpty {}
    | |____________________^
 
-error: derive-where doesn't support items without generics, `skip` attributes or `enum`s implementing `Default`, as this can already be handled by standard `#[derive(..)]`
-  --> tests/ui/use_case.rs:20:1
+error: this can be handled by standard `#[derive(..)]`, use a `skip` attribute, implement `Default` on an enum, of different generic type parameters
+  --> tests/ui/use_case.rs:20:16
    |
-20 | / #[derive_where(Clone)]
-21 | | struct StructNone(u8);
-   | |______________________^
+20 | #[derive_where(Clone)]
+   |                ^^^^^
 
-error: derive-where doesn't support items without generics, `skip` attributes or `enum`s implementing `Default`, as this can already be handled by standard `#[derive(..)]`
-  --> tests/ui/use_case.rs:24:1
+error: this can be handled by standard `#[derive(..)]`, use a `skip` attribute, implement `Default` on an enum, of different generic type parameters
+  --> tests/ui/use_case.rs:24:16
    |
-24 | / #[derive_where(Clone)]
-25 | | enum EnumNone {
-26 | |     A(u8),
-27 | | }
-   | |_^
+24 | #[derive_where(Clone)]
+   |                ^^^^^
+
+error: this can be handled by standard `#[derive(..)]`, use a `skip` attribute, implement `Default` on an enum, of different generic type parameters
+  --> tests/ui/use_case.rs:30:16
+   |
+30 | #[derive_where(Clone; T)]
+   |                ^^^^^
+
+error: this can be handled by standard `#[derive(..)]`, use a `skip` attribute, implement `Default` on an enum, of different generic type parameters
+  --> tests/ui/use_case.rs:34:16
+   |
+34 | #[derive_where(Clone, Debug; T)]
+   |                ^^^^^
+
+error: this can be handled by standard `#[derive(..)]`, use a `skip` attribute, implement `Default` on an enum, of different generic type parameters
+  --> tests/ui/use_case.rs:39:16
+   |
+39 | #[derive_where(Clone, Default; T)]
+   |                ^^^^^

non-msrv-tests/tests/ui/zeroize/use_case.rs

@@ -0,0 +1,13 @@
+extern crate zeroize_ as zeroize;
+
+use derive_where::DeriveWhere;
+
+#[derive(DeriveWhere)]
+#[derive_where(Clone, Zeroize(crate = "zeroize_"); T)]
+struct ZeroizeCrate<T>(T);
+
+#[derive(DeriveWhere)]
+#[derive_where(Clone, Zeroize; T)]
+struct ZeroizeFqs<T>(#[derive_where(Zeroize(fqs))] T);
+
+fn main() {}

non-msrv-tests/tests/ui/zeroize/use_case.stderr

@@ -0,0 +1,11 @@
+error: this can be handled by standard `#[derive(..)]`, use a `skip` attribute, implement `Default` on an enum, of different generic type parameters
+ --> tests/ui/zeroize/use_case.rs:6:16
+  |
+6 | #[derive_where(Clone, Zeroize(crate = "zeroize_"); T)]
+  |                ^^^^^
+
+error: this can be handled by standard `#[derive(..)]`, use a `skip` attribute, implement `Default` on an enum, of different generic type parameters
+  --> tests/ui/zeroize/use_case.rs:10:16
+   |
+10 | #[derive_where(Clone, Zeroize; T)]
+   |                ^^^^^

src/test/mod.rs

@@ -3,6 +3,7 @@ mod bound;
 mod enum_;
 mod misc;
 mod skip;
+mod use_case;
 #[cfg(feature = "zeroize")]
 mod zeroize;
 
@@ -17,3 +18,7 @@ fn test_derive(input: TokenStream, expected: TokenStream) -> Result<()> {
 	assert_eq!(left, right);
 	Ok(())
 }
+
+fn compiles(input: TokenStream) -> Result<()> {
+	crate::derive_where_internal(input).map(|_| ())
+}

src/test/use_case.rs

@@ -0,0 +1,168 @@
+use quote::quote;
+use syn::Result;
+
+use super::compiles;
+
+#[test]
+fn struct_skip() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		struct Test(#[derive_where(skip)] u8);
+	})
+}
+
+#[test]
+fn struct_skip_multiple() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		struct Test(#[derive_where(skip)] u8, u8);
+	})
+}
+
+#[test]
+fn struct_skip_trait() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		struct Test(#[derive_where(skip(Debug))] u8);
+	})
+}
+
+#[test]
+fn struct_skip_trait_multiple() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		struct Test(#[derive_where(skip(Debug))] u8, u8);
+	})
+}
+
+#[test]
+fn struct_skip_inner() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		#[derive_where(skip_inner)]
+		struct Test(u8);
+	})
+}
+
+#[test]
+fn struct_skip_inner_trait() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		#[derive_where(skip_inner(Debug))]
+		struct Test(u8);
+	})
+}
+#[test]
+fn enum_skip() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		enum Test {
+			A(#[derive_where(skip)] u8),
+		}
+	})
+}
+
+#[test]
+fn enum_skip_multiple() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		enum Test {
+			A(#[derive_where(skip)] u8),
+			B,
+		}
+	})
+}
+
+#[test]
+fn enum_skip_trait() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		enum Test {
+			A(#[derive_where(skip(Debug))] u8),
+		}
+	})
+}
+
+#[test]
+fn enum_skip_trait_multiple() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		enum Test {
+			A(#[derive_where(skip(Debug))] u8),
+			B,
+		}
+	})
+}
+
+#[test]
+fn enum_skip_inner() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		enum Test {
+			#[derive_where(skip_inner)]
+			A(u8),
+		}
+	})
+}
+
+#[test]
+fn enum_skip_inner_trait() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug)]
+		enum Test {
+			#[derive_where(skip_inner(Debug))]
+			A(u8),
+		}
+	})
+}
+
+#[test]
+fn default() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Default)]
+		enum Test {
+			#[derive_where(default)]
+			A,
+		}
+	})
+}
+
+#[test]
+#[cfg(feature = "zeroize")]
+fn zeroize_crate() -> Result<()> {
+	compiles(quote! {
+		#[derive_where(Zeroize(crate = "zeroize_"))]
+		struct Test(u8);
+	})
+}
+
+#[test]
+#[cfg(feature = "zeroize")]
+fn zeroize_fqs() -> Result<()> {
+	compiles(quote! {
+		#[derive_where(Zeroize)]
+		struct Test(#[derive_where(Zeroize(fqs))] u8);
+	})
+}
+
+#[test]
+fn custom_bound() -> Result<()> {
+	compiles(quote! {
+		#[derive(DeriveWhere)]
+		#[derive_where(Debug; T: Clone)]
+		struct Test<T>(T);
+	})
+}