Code improvements around enum parsing

Author: daxpedda

src/attr/default.rs

@@ -1,5 +1,6 @@
 //! Attribute parsing for the `default` option.
 
+use proc_macro2::Span;
 use syn::{spanned::Spanned, Meta, Result};
 
 use crate::{DeriveWhere, Error, Trait};
@@ -8,23 +9,18 @@ use crate::{DeriveWhere, Error, Trait};
 /// [`Default`](std::default::Default).
 #[derive(Clone, Copy, Default)]
 #[cfg_attr(test, derive(Debug))]
-pub struct Default(pub bool);
+pub struct Default(pub Option<Span>);
 
 impl Default {
 	/// Token used for the `default` option.
 	pub const DEFAULT: &'static str = "default";
 
 	/// Adds a [`Meta`] to this [`Default`](self).
-	pub fn add_attribute(
-		&mut self,
-		meta: &Meta,
-		derive_wheres: &[DeriveWhere],
-		accumulated_defaults: &mut Default,
-	) -> Result<()> {
+	pub fn add_attribute(&mut self, meta: &Meta, derive_wheres: &[DeriveWhere]) -> Result<()> {
 		debug_assert!(meta.path().is_ident(Self::DEFAULT));
 
 		if let Meta::Path(path) = meta {
-			if self.0 {
+			if self.0.is_some() {
 				Err(Error::option_duplicate(path.span(), Self::DEFAULT))
 			} else {
 				let mut impl_default = false;
@@ -37,13 +33,8 @@ impl Default {
 				}
 
 				if impl_default {
-					if accumulated_defaults.0 {
-						Err(Error::default_duplicate(path.span()))
-					} else {
-						accumulated_defaults.0 = true;
-						self.0 = true;
-						Ok(())
-					}
+					self.0 = Some(path.span());
+					Ok(())
 				} else {
 					Err(Error::default(path.span()))
 				}

src/attr/variant.rs

@@ -18,17 +18,14 @@ impl VariantAttr {
 	pub fn from_attrs(
 		attrs: &[Attribute],
 		derive_wheres: &[DeriveWhere],
-		accumulated_defaults: &mut Default,
 		variant: &Variant,
 	) -> Result<Self> {
 		let mut self_ = VariantAttr::default();
 
 		for attr in attrs {
 			if attr.path.is_ident(DERIVE_WHERE) {
 				match attr.parse_meta() {
-					Ok(meta) => {
-						self_.add_meta(&meta, derive_wheres, accumulated_defaults, variant)?
-					}
+					Ok(meta) => self_.add_meta(&meta, derive_wheres, variant)?,
 					Err(error) => return Err(Error::attribute_syntax(attr.span(), error)),
 				}
 			}
@@ -42,7 +39,6 @@ impl VariantAttr {
 		&mut self,
 		meta: &Meta,
 		derive_wheres: &[DeriveWhere],
-		accumulated_defaults: &mut Default,
 		variant: &Variant,
 	) -> Result<()> {
 		debug_assert!(meta.path().is_ident(DERIVE_WHERE));
@@ -70,11 +66,7 @@ impl VariantAttr {
 								_ => self.skip_inner.add_attribute(derive_wheres, None, meta)?,
 							}
 						} else if meta.path().is_ident(Default::DEFAULT) {
-							self.default.add_attribute(
-								meta,
-								derive_wheres,
-								accumulated_defaults,
-							)?;
+							self.default.add_attribute(meta, derive_wheres)?;
 						} else {
 							return Err(Error::option(meta.path().span()));
 						}

src/data.rs

@@ -4,13 +4,13 @@ mod field;
 mod fields;
 
 use proc_macro2::Span;
-use syn::{FieldsNamed, Ident, Pat, PatPath, Path, Result};
+use syn::{FieldsNamed, Ident, Pat, PatPath, Path, Result, Variant};
 
 pub use self::{
 	field::{Field, Member},
 	fields::Fields,
 };
-use crate::{util, Default, DeriveWhere, Either, Error, Skip, Trait};
+use crate::{util, Default, DeriveWhere, Either, Error, Skip, Trait, VariantAttr};
 
 /// Holds all relevant data of a struct, union or variant.
 #[cfg_attr(test, derive(Debug))]
@@ -141,20 +141,23 @@ impl<'a> Data<'a> {
 	pub fn from_variant(
 		item_ident: &'a Ident,
 		derive_wheres: &[DeriveWhere],
-		skip_inner: Skip,
-		default: Default,
-		variant_ident: &'a Ident,
-		fields: &'a syn::Fields,
+		variant: &'a Variant,
 	) -> Result<Self> {
-		let path = util::path_from_idents(&[item_ident, variant_ident]);
+		// Parse `Attribute`s on variant.
+		let VariantAttr {
+			default,
+			skip_inner,
+		} = VariantAttr::from_attrs(&variant.attrs, derive_wheres, variant)?;
 
-		match fields {
+		let path = util::path_from_idents(&[item_ident, &variant.ident]);
+
+		match &variant.fields {
 			syn::Fields::Named(fields) => {
 				let fields = Fields::from_named(derive_wheres, &skip_inner, path.clone(), fields)?;
 
 				Ok(Self {
 					skip_inner,
-					ident: variant_ident,
+					ident: &variant.ident,
 					path,
 					type_: DataType::Variant {
 						default,
@@ -168,7 +171,7 @@ impl<'a> Data<'a> {
 
 				Ok(Self {
 					skip_inner,
-					ident: variant_ident,
+					ident: &variant.ident,
 					path,
 					type_: DataType::Variant {
 						default,
@@ -185,7 +188,7 @@ impl<'a> Data<'a> {
 
 				Ok(Self {
 					skip_inner,
-					ident: variant_ident,
+					ident: &variant.ident,
 					path,
 					type_: DataType::Variant {
 						default,
@@ -239,11 +242,20 @@ impl<'a> Data<'a> {
 	/// not a variant, always returns `true`.
 	pub fn is_default(&self) -> bool {
 		match self.type_ {
-			DataType::Variant { default, .. } => default.0,
+			DataType::Variant { default, .. } => default.0.is_some(),
 			_ => true,
 		}
 	}
 
+	/// Returns [`Some`] if this variant has a [`struct@Default`]. If
+	/// not a variant, always returns [`None`].
+	pub fn default_span(&self) -> Option<Span> {
+		match &self.type_ {
+			DataType::Variant { default, .. } => default.0,
+			_ => None,
+		}
+	}
+
 	/// Returns `true` if this [`Data`] has no [`Fields`].
 	pub fn is_empty(&self, trait_: &Trait) -> bool {
 		self.iter_fields(trait_).count() == 0

src/input.rs

@@ -5,7 +5,7 @@ use syn::{DeriveInput, GenericParam, Generics, Result};
 
 #[cfg(feature = "zeroize")]
 use crate::DeriveTrait;
-use crate::{Data, Default, DeriveWhere, Either, Error, Item, ItemAttr, Trait, VariantAttr};
+use crate::{Data, DeriveWhere, Either, Error, Item, ItemAttr, Trait};
 
 /// Parsed input.
 pub struct Input<'a> {
@@ -42,32 +42,10 @@ impl<'a> Input<'a> {
 					.map(Item::Item)?
 			}
 			syn::Data::Enum(data) => {
-				let mut accumulated_defaults = Default::default();
-
 				let variants = data
 					.variants
 					.iter()
-					.map(|variant| {
-						// Parse `Attribute`s on variant.
-						let VariantAttr {
-							default,
-							skip_inner,
-						} = VariantAttr::from_attrs(
-							&variant.attrs,
-							&derive_wheres,
-							&mut accumulated_defaults,
-							variant,
-						)?;
-
-						Data::from_variant(
-							ident,
-							&derive_wheres,
-							skip_inner,
-							default,
-							&variant.ident,
-							&variant.fields,
-						)
-					})
+					.map(|variant| Data::from_variant(ident, &derive_wheres, variant))
 					.collect::<Result<Vec<Data>>>()?;
 
 				// Empty enums aren't allowed.
@@ -78,9 +56,23 @@ impl<'a> Input<'a> {
 					return Err(Error::item_empty(span));
 				}
 
+				// Find if a default option is specified on a variant.
+				let mut found_default = false;
+
+				// While searching for a default option, check for duplicates.
+				for variant in &variants {
+					if let Some(span) = variant.default_span() {
+						if found_default {
+							return Err(Error::default_duplicate(span));
+						} else {
+							found_default = true;
+						}
+					}
+				}
+
 				// Make sure a variant has the `option` attribute if `Default` is being
 				// implemented.
-				if !accumulated_defaults.0
+				if !found_default
 					&& derive_wheres
 						.iter()
 						.any(|derive_where| derive_where.trait_(&Trait::Default).is_some())
@@ -99,10 +91,9 @@ impl<'a> Input<'a> {
 		// Don't allow no use-case compared to std `derive`.
 		let mut found_use_case = false;
 		// Any generics used.
-		found_use_case |= generics
-			.params
-			.iter()
-			.any(|generic_param| match generic_param {
+		found_use_case |= generics.params.iter().any(|generic_param|
+				// MSRV: `matches!` was added in 1.42.0.
+				match generic_param {
 				GenericParam::Type(_) => true,
 				GenericParam::Lifetime(_) | GenericParam::Const(_) => false,
 			});