Always print all traits in error messages

- Instead, if the crate feature is not enabled, we say that in the error message instead.
- Implement `Serialize` skeleton.
- Hook up `serde` in the CI.
- Handle `#[serde(...)]` attributes without `De/Serialize`.
- Add tests for all these new errors.
- Add test to check for `#[derive(De/Serialize)`]` support without `#[derive_where(De/Serialize)]`.

Author: daxpedda

.github/workflows/lint.yml

@@ -28,12 +28,16 @@ jobs:
             features: --features safe
           - channel: nightly
             features: --features nightly 
+          - channel: stable
+            features: --features serde
           - channel: stable
             features: --features zeroize
           - channel: stable
             features: --features zeroize-on-drop
           - channel: nightly
             features: --features safe,nightly
+          - channel: stable
+            features: --features safe,serde
           - channel: stable
             features: --features safe,zeroize
           - channel: stable
@@ -42,6 +46,12 @@ jobs:
             features: --features nightly,zeroize
           - channel: nightly
             features: --features nightly,zeroize-on-drop
+          - channel: nightly
+            features: --features nightly,serde
+          - channel: stable
+            features: --features serde,zeroize
+          - channel: stable
+            features: --features serde,zeroize-on-drop
           - channel: nightly
             features: --all-features
 

.github/workflows/test.yml

@@ -28,17 +28,23 @@ jobs:
         features:
           - ""
           - --features safe
+          - --features serde
           - --features zeroize
           - --features zeroize-on-drop
+          - --features safe,serde
           - --features safe,zeroize
           - --features safe,zeroize-on-drop
+          - --features serde,zeroize
+          - --features serde,zeroize-on-drop
         include:
           - rust: 1.57.0
             msrv: true
           - rust: nightly
             features: --features nightly
           - rust: nightly
             features: --features safe,nightly
+          - rust: nightly
+            features: --features nightly,serde
           - rust: nightly
             features: --features nightly,zeroize
           - rust: nightly
@@ -83,17 +89,23 @@ jobs:
         features:
           - ""
           - --features safe
+          - --features serde
           - --features zeroize
           - --features zeroize-on-drop
+          - --features safe,serde
           - --features safe,zeroize
           - --features safe,zeroize-on-drop
+          - --features serde,zeroize
+          - --features serde,zeroize-on-drop
         include:
           - rust: 1.57.0
             msrv: true
           - rust: nightly
             features: --features nightly
           - rust: nightly
             features: --features safe,nightly
+          - rust: nightly
+            features: --features nightly,serde
           - rust: nightly
             features: --features nightly,zeroize
           - rust: nightly
@@ -127,9 +139,9 @@ jobs:
       matrix:
         rust:
           - version: 1.57.0
-            features: safe,zeroize-on-drop
+            features: safe,serde,zeroize-on-drop
           - version: stable
-            features: safe,zeroize-on-drop
+            features: safe,serde,zeroize-on-drop
 
     steps:
       - name: Checkout

CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - `no_drop` item-level option to `ZeroizeOnDrop` which does not implement
   `Drop` but instead only asserts that every field implements `ZeroizeOnDrop`.
 
+### Changed
+- Error messages now point to crate features instead of reporting traits as
+  unsupported.
+
 ### Fixed
 - Stop depending on unstable APIs for `Eq` for `ZeroizeOnDrop`.
 

Cargo.toml

@@ -43,6 +43,7 @@ syn = { version = "2", default-features = false, features = [
 pretty_assertions = "1"
 rustversion = "1"
 serde_ = { package = "serde", version = "1", default-features = false, features = ["derive"] }
+serde_test = "1"
 trybuild = { version = "1.0.18", default-features = false }
 zeroize_ = { package = "zeroize", version = "1.5", default-features = false }
 

src/attr/item.rs

@@ -96,6 +96,18 @@ impl ItemAttr {
 			return Err(Error::none(span));
 		}
 
+		// Check for `#[serde(...)]` attributes without `De/Serialize`.
+		#[cfg(feature = "serde")]
+		if !self_.derive_wheres.iter().any(|derive_where| {
+			derive_where.contains(Trait::Deserialize) | derive_where.contains(Trait::Serialize)
+		}) {
+			for attr in attrs {
+				if attr.path().is_ident("serde") {
+					return Err(Error::serde_without_serde(attr.span()));
+				}
+			}
+		}
+
 		// Merge `DeriveWhere`s with the same bounds.
 		self_
 			.derive_wheres

src/attr/skip.rs

@@ -271,7 +271,7 @@ impl SkipGroup {
 			| Trait::PartialEq
 			| Trait::PartialOrd => true,
 			#[cfg(feature = "serde")]
-			Trait::Deserialize => false,
+			Trait::Deserialize | Trait::Serialize => false,
 			#[cfg(feature = "zeroize")]
 			Trait::Zeroize | Trait::ZeroizeOnDrop => true,
 		}

src/error.rs

@@ -74,7 +74,7 @@ impl Error {
 	}
 
 	/// Unsupported option in attribute.
-	#[cfg(feature = "zeroize")]
+	#[cfg(any(feature = "serde", feature = "zeroize"))]
 	pub fn option_trait(span: Span, attribute: &str) -> syn::Error {
 		syn::Error::new(span, format!("`{}` doesn't support this option", attribute))
 	}
@@ -191,6 +191,24 @@ impl Error {
 		)
 	}
 
+	/// Requires crate feature `serde`.
+	#[cfg(not(feature = "serde"))]
+	pub fn serde_feature(span: Span) -> syn::Error {
+		syn::Error::new(span, "requires crate feature `serde`")
+	}
+
+	/// Requires crate feature `zeroize`.
+	#[cfg(not(feature = "zeroize"))]
+	pub fn zeroize_feature(span: Span) -> syn::Error {
+		syn::Error::new(span, "requires crate feature `zeroize`")
+	}
+
+	/// Requires crate feature `zeroize-on-drop`.
+	#[cfg(all(feature = "zeroize", not(feature = "zeroize-on-drop")))]
+	pub fn zeroize_on_drop_feature(span: Span) -> syn::Error {
+		syn::Error::new(span, "requires crate feature `zeroize-on-drop`")
+	}
+
 	/// Invalid delimiter in `derive_where` attribute for
 	/// [`Trait`](crate::Trait)s.
 	pub fn derive_where_delimiter(span: Span) -> syn::Error {
@@ -282,37 +300,35 @@ impl Error {
 		syn::Error::new(skip_clone, "Cannot skip `Clone` while deriving `Copy`")
 	}
 
+	/// Unsupported `serde(...)` without deriving `De/Serialize`.
+	#[cfg(feature = "serde")]
+	pub fn serde_without_serde(serde: Span) -> syn::Error {
+		syn::Error::new(serde, "Found unused `#[serde(...)]`")
+	}
+
 	/// List of available [`Trait`](crate::Trait)s.
 	fn trait_list() -> String {
 		[
 			"Clone",
 			"Copy",
 			"Debug",
 			"Default",
+			"Deserialize",
 			"Eq",
 			"Hash",
 			"Ord",
 			"PartialEq",
 			"PartialOrd",
-			#[cfg(feature = "zeroize")]
+			"Serialize",
 			"Zeroize",
-			#[cfg(feature = "zeroize")]
 			"ZeroizeOnDrop",
 		]
 		.join(", ")
 	}
 
 	/// List of available [`SkipGroup`](crate::SkipGroup)s.
 	fn skip_group_list() -> String {
-		[
-			"Clone",
-			"Debug",
-			"EqHashOrd",
-			"Hash",
-			#[cfg(feature = "zeroize")]
-			"Zeroize",
-		]
-		.join(", ")
+		["Clone", "Debug", "EqHashOrd", "Hash", "Zeroize"].join(", ")
 	}
 
 	/// Unsupported `Zeroize` option if [`Zeroize`](https://docs.rs/zeroize/latest/zeroize/trait.Zeroize.html) isn't implemented.

src/trait_.rs

@@ -12,6 +12,10 @@ pub mod hash;
 pub mod ord;
 pub mod partial_eq;
 pub mod partial_ord;
+#[cfg(feature = "serde")]
+mod serde;
+#[cfg(feature = "serde")]
+pub mod serialize;
 #[cfg(feature = "zeroize")]
 pub mod zeroize;
 #[cfg(feature = "zeroize")]
@@ -56,6 +60,9 @@ pub enum Trait {
 	PartialEq,
 	/// [`PartialOrd`].
 	PartialOrd,
+	/// [`Serialize`](https://docs.rs/serde/latest/serde/derive.Serialize.html).
+	#[cfg(feature = "serde")]
+	Serialize,
 	/// [`Zeroize`](https://docs.rs/zeroize/latest/zeroize/trait.Zeroize.html).
 	#[cfg(feature = "zeroize")]
 	Zeroize,
@@ -78,6 +85,8 @@ macro_rules! trait_dispatch {
 			Trait::Ord => ord::Ord::$method($($par),*),
 			Trait::PartialEq => partial_eq::PartialEq::$method($($par),*),
 			Trait::PartialOrd => partial_ord::PartialOrd::$method($($par),*),
+			#[cfg(feature = "serde")]
+			Trait::Serialize => serialize::Serialize::$method($($par),*),
 			#[cfg(feature = "zeroize")]
 			Trait::Zeroize => zeroize::Zeroize::$method($($par),*),
 			#[cfg(feature = "zeroize")]
@@ -99,15 +108,25 @@ impl Trait {
 				"Default" => Ok(Default),
 				#[cfg(feature = "serde")]
 				"Deserialize" => Ok(Deserialize),
+				#[cfg(not(feature = "serde"))]
+				"Deserialize" => Err(Error::serde_feature(path.span())),
 				"Eq" => Ok(Eq),
 				"Hash" => Ok(Hash),
 				"Ord" => Ok(Ord),
 				"PartialEq" => Ok(PartialEq),
 				"PartialOrd" => Ok(PartialOrd),
+				#[cfg(feature = "serde")]
+				"Serialize" => Ok(Serialize),
+				#[cfg(not(feature = "serde"))]
+				"Serialize" => Err(Error::serde_feature(path.span())),
 				#[cfg(feature = "zeroize")]
 				"Zeroize" => Ok(Zeroize),
+				#[cfg(not(feature = "zeroize"))]
+				"Zeroize" => Err(Error::zeroize_feature(path.span())),
 				#[cfg(feature = "zeroize")]
 				"ZeroizeOnDrop" => Ok(ZeroizeOnDrop),
+				#[cfg(not(feature = "zeroize"))]
+				"ZeroizeOnDrop" => Err(Error::zeroize_feature(path.span())),
 				"crate" => Err(Error::crate_(path.span())),
 				_ => Err(Error::trait_(path.span())),
 			}
@@ -170,6 +189,9 @@ pub enum DeriveTrait {
 	PartialEq,
 	/// [`PartialOrd`].
 	PartialOrd,
+	/// [`Serialize`](https://docs.rs/serde/latest/serde/derive.Serialize.html).
+	#[cfg(feature = "serde")]
+	Serialize(serialize::Serialize),
 	/// [`Zeroize`](https://docs.rs/zeroize/latest/zeroize/trait.Zeroize.html).
 	#[cfg(feature = "zeroize")]
 	Zeroize(zeroize::Zeroize),
@@ -196,6 +218,8 @@ impl Deref for DeriveTrait {
 			Ord => &ord::Ord,
 			PartialEq => &partial_eq::PartialEq,
 			PartialOrd => &partial_ord::PartialOrd,
+			#[cfg(feature = "serde")]
+			Serialize(trait_) => trait_,
 			#[cfg(feature = "zeroize")]
 			Zeroize(trait_) => trait_,
 			#[cfg(feature = "zeroize")]

src/trait_/deserialize.rs

@@ -2,10 +2,14 @@
 
 use std::{borrow::Cow, ops::Deref};
 
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::quote;
-use syn::{DeriveInput, Ident, ImplGenerics, Path, TypeGenerics, WhereClause};
+use syn::{
+	punctuated::Punctuated, DeriveInput, Ident, ImplGenerics, Meta, Path, Result, TypeGenerics,
+	WhereClause,
+};
 
+use super::serde;
 use crate::{util, DeriveTrait, Trait, TraitImpl, DERIVE_WHERE};
 
 /// [`TraitImpl`] for [`Deserialize`](https://docs.rs/serde/latest/serde/derive.Deserialize.html).
@@ -30,6 +34,15 @@ impl TraitImpl for Deserialize {
 		DeriveTrait::Deserialize(Self { crate_: None })
 	}
 
+	fn parse_derive_trait(span: Span, list: Punctuated<Meta, syn::Token![,]>) -> Result<DeriveTrait>
+	where
+		Self: Sized,
+	{
+		Ok(DeriveTrait::Deserialize(Self {
+			crate_: serde::parse_derive_trait(Trait::Deserialize, span, list)?,
+		}))
+	}
+
 	fn path(&self) -> Path {
 		util::path_from_root_and_strs(self.crate_(), &["Deserialize"])
 	}

src/trait_/serde.rs

@@ -0,0 +1,63 @@
+//! Common functionality between
+//! [`Deserialize`](https://docs.rs/serde/latest/serde/derive.Deserialize.html) and
+//! [`Serialize`](https://docs.rs/serde/latest/serde/derive.Serialize.html).
+
+use proc_macro2::Span;
+use syn::{
+	punctuated::Punctuated, spanned::Spanned, Expr, ExprLit, ExprPath, Lit, Meta, Path, Token,
+};
+
+use crate::{util, Error, Result, Trait};
+
+/// Parses
+pub fn parse_derive_trait(
+	trait_: Trait,
+	_span: Span,
+	list: Punctuated<Meta, Token![,]>,
+) -> Result<Option<Path>> {
+	// This is already checked in `DeriveTrait::from_stream`.
+	debug_assert!(!list.is_empty());
+
+	let mut crate_ = None;
+
+	for meta in list {
+		match &meta {
+			Meta::Path(path) => {
+				return Err(Error::option_trait(path.span(), trait_.as_str()));
+			}
+			Meta::NameValue(name_value) => {
+				if name_value.path.is_ident("crate") {
+					// Check for duplicate `crate` option.
+					if crate_.is_none() {
+						let path = match &name_value.value {
+							Expr::Lit(ExprLit {
+								lit: Lit::Str(lit_str),
+								..
+							}) => match lit_str.parse::<Path>() {
+								Ok(path) => path,
+								Err(error) => return Err(Error::path(lit_str.span(), error)),
+							},
+							Expr::Path(ExprPath { path, .. }) => path.clone(),
+							_ => return Err(Error::option_syntax(name_value.value.span())),
+						};
+
+						if path == util::path_from_strs(&["serde"]) {
+							return Err(Error::path_unnecessary(path.span(), "::serde"));
+						}
+
+						crate_ = Some(path);
+					} else {
+						return Err(Error::option_duplicate(name_value.span(), "crate"));
+					}
+				} else {
+					return Err(Error::option_trait(name_value.path.span(), trait_.as_str()));
+				}
+			}
+			_ => {
+				return Err(Error::option_syntax(meta.span()));
+			}
+		}
+	}
+
+	Ok(crate_)
+}