Merge pull request #99 from ModProg/clippy

Clippy + Typos

Author: ModProg

Cargo.toml

@@ -47,3 +47,6 @@ zeroize_ = { version = "1.5", package = "zeroize", default-features = false }
 [package.metadata.docs.rs]
 all-features = true
 targets = []
+
+[workspace.metadata.typos]
+default.extend-words.wheres = "wheres"

src/data.rs

@@ -4,7 +4,9 @@ mod field;
 mod fields;
 
 use proc_macro2::Span;
-use syn::{Expr, FieldsNamed, Ident, Pat, PatPath, Path, Result, Variant};
+#[cfg(not(feature = "nightly"))]
+use syn::Expr;
+use syn::{FieldsNamed, Ident, Pat, PatPath, Path, Result, Variant};
 
 pub use self::{
 	field::{Field, Member},
@@ -27,6 +29,7 @@ pub struct Data<'a> {
 	pub path: Path,
 	/// [Type](DataType) of this struct, union or variant.
 	pub type_: DataType<'a>,
+	#[cfg(not(feature = "nightly"))]
 	/// Discriminant of this variant.
 	pub discriminant: Option<&'a Expr>,
 }
@@ -69,7 +72,7 @@ pub enum SimpleType<'a> {
 	/// Tuple struct or tuple variant.
 	Tuple(&'a Fields<'a>),
 	/// Union.
-	Union(&'a Fields<'a>),
+	Union,
 	/// Unit variant.
 	Unit(&'a Pat),
 }
@@ -100,6 +103,7 @@ impl<'a> Data<'a> {
 						ident,
 						path,
 						type_: DataType::Struct(fields),
+						#[cfg(not(feature = "nightly"))]
 						discriminant: None,
 					})
 				}
@@ -117,6 +121,7 @@ impl<'a> Data<'a> {
 						ident,
 						path,
 						type_: DataType::Tuple(fields),
+						#[cfg(not(feature = "nightly"))]
 						discriminant: None,
 					})
 				}
@@ -131,6 +136,7 @@ impl<'a> Data<'a> {
 					qself: None,
 					path,
 				})),
+				#[cfg(not(feature = "nightly"))]
 				discriminant: None,
 			}),
 			syn::Fields::Unit => Err(Error::item_empty(span)),
@@ -158,6 +164,7 @@ impl<'a> Data<'a> {
 				ident,
 				path,
 				type_: DataType::Union(fields),
+				#[cfg(not(feature = "nightly"))]
 				discriminant: None,
 			})
 		}
@@ -191,6 +198,7 @@ impl<'a> Data<'a> {
 						default,
 						type_: VariantType::Struct(fields),
 					},
+					#[cfg(not(feature = "nightly"))]
 					discriminant: variant.discriminant.as_ref().map(|(_, expr)| expr),
 				})
 			}
@@ -207,6 +215,7 @@ impl<'a> Data<'a> {
 						default,
 						type_: VariantType::Tuple(fields),
 					},
+					#[cfg(not(feature = "nightly"))]
 					discriminant: variant.discriminant.as_ref().map(|(_, expr)| expr),
 				})
 			}
@@ -226,6 +235,7 @@ impl<'a> Data<'a> {
 						default,
 						type_: VariantType::Unit(pattern),
 					},
+					#[cfg(not(feature = "nightly"))]
 					discriminant: variant.discriminant.as_ref().map(|(_, expr)| expr),
 				})
 			}
@@ -327,15 +337,12 @@ impl<'a> Data<'a> {
 				type_: VariantType::Unit(pattern),
 				..
 			} => SimpleType::Unit(pattern),
-			DataType::Union(fields) => SimpleType::Union(fields),
+			DataType::Union(_) => SimpleType::Union,
 		}
 	}
 
 	/// Returns an [`Iterator`] over [`Field`]s.
-	pub fn iter_fields(
-		&self,
-		trait_: Trait,
-	) -> impl '_ + Iterator<Item = &'_ Field> + DoubleEndedIterator {
+	pub fn iter_fields(&self, trait_: Trait) -> impl '_ + DoubleEndedIterator<Item = &'_ Field> {
 		if self.skip(trait_) {
 			[].iter()
 		} else {
@@ -354,19 +361,13 @@ impl<'a> Data<'a> {
 
 	/// Returns an [`Iterator`] over [`struct@Ident`]s used as temporary
 	/// variables for destructuring `self`.
-	pub fn iter_self_ident(
-		&self,
-		trait_: Trait,
-	) -> impl Iterator<Item = &'_ Ident> + DoubleEndedIterator {
+	pub fn iter_self_ident(&self, trait_: Trait) -> impl DoubleEndedIterator<Item = &'_ Ident> {
 		self.iter_fields(trait_).map(|field| &field.self_ident)
 	}
 
 	/// Returns an [`Iterator`] over [`struct@Ident`]s used as temporary
 	/// variables for destructuring `other`.
-	pub fn iter_other_ident(
-		&self,
-		trait_: Trait,
-	) -> impl Iterator<Item = &'_ Ident> + DoubleEndedIterator {
+	pub fn iter_other_ident(&self, trait_: Trait) -> impl DoubleEndedIterator<Item = &'_ Ident> {
 		self.iter_fields(trait_).map(|field| &field.other_ident)
 	}
 }

src/error.rs

@@ -213,12 +213,14 @@ impl Error {
 	}
 
 	/// Unknown `repr`.
+	#[cfg(not(feature = "nightly"))]
 	pub fn repr_unknown(span: Span) -> syn::Error {
 		syn::Error::new(span, "found unknown representation")
 	}
 
 	/// Invalid enum with non-empty variants and custom discriminants without an
 	/// integer representation.
+	#[cfg(not(feature = "nightly"))]
 	pub fn repr_discriminant_invalid(span: Span) -> syn::Error {
 		syn::Error::new(
 			span,

src/input.rs

@@ -5,7 +5,9 @@ use syn::{DeriveInput, GenericParam, Generics, ImplGenerics, Result, TypeGeneric
 
 #[cfg(feature = "zeroize")]
 use crate::DeriveTrait;
-use crate::{Data, DeriveWhere, Discriminant, Either, Error, Item, ItemAttr, Trait};
+#[cfg(not(feature = "nightly"))]
+use crate::Discriminant;
+use crate::{Data, DeriveWhere, Either, Error, Item, ItemAttr, Trait};
 
 /// Parsed input.
 pub struct Input<'a> {
@@ -51,6 +53,7 @@ impl<'a> Input<'a> {
 			)
 			.map(Item::Item)?,
 			syn::Data::Enum(data) => {
+				#[cfg(not(feature = "nightly"))]
 				let discriminant = Discriminant::parse(attrs, &data.variants)?;
 
 				let variants = data
@@ -99,6 +102,7 @@ impl<'a> Input<'a> {
 				}
 
 				Item::Enum {
+					#[cfg(not(feature = "nightly"))]
 					discriminant,
 					ident,
 					variants,

src/item.rs

@@ -1,17 +1,24 @@
 //! Intermediate representation of item data.
 
-use proc_macro2::{Ident, Span, TokenStream, TokenTree};
-use quote::ToTokens;
-use syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Meta, Result, Token, Variant};
+use proc_macro2::Ident;
+#[cfg(not(feature = "nightly"))]
+use {
+	proc_macro2::{Span, TokenStream, TokenTree},
+	quote::ToTokens,
+	syn::{punctuated::Punctuated, spanned::Spanned, Attribute, Meta, Result, Token, Variant},
+};
 
-use crate::{Data, Error, Incomparable, Trait};
+#[cfg(not(feature = "nightly"))]
+use crate::Error;
+use crate::{Data, Incomparable, Trait};
 
 /// Fields or variants of an item.
 #[cfg_attr(test, derive(Debug))]
 #[allow(clippy::large_enum_variant)]
 pub enum Item<'a> {
 	/// Enum.
 	Enum {
+		#[cfg(not(feature = "nightly"))]
 		/// Type of discriminant used.
 		discriminant: Discriminant,
 		/// [`struct@Ident`] of this enum.
@@ -96,6 +103,7 @@ impl Item<'_> {
 /// Type of discriminant used.
 #[derive(Clone, Copy)]
 #[cfg_attr(test, derive(Debug))]
+#[cfg(not(feature = "nightly"))]
 pub enum Discriminant {
 	/// The enum has only a single variant.
 	Single,
@@ -109,6 +117,7 @@ pub enum Discriminant {
 	DataRepr(Representation),
 }
 
+#[cfg(not(feature = "nightly"))]
 impl Discriminant {
 	/// Parse the representation of an item.
 	pub fn parse(attrs: &[Attribute], variants: &Punctuated<Variant, Token![,]>) -> Result<Self> {
@@ -165,6 +174,7 @@ impl Discriminant {
 /// The type used to represent an enum.
 #[derive(Clone, Copy)]
 #[cfg_attr(test, derive(Debug))]
+#[cfg(not(feature = "nightly"))]
 pub enum Representation {
 	/// [`u8`].
 	U8,
@@ -192,6 +202,7 @@ pub enum Representation {
 	ISize,
 }
 
+#[cfg(not(feature = "nightly"))]
 impl Representation {
 	/// Parse an [`struct@Ident`] to a valid representation if it is.
 	fn parse(ident: &Ident) -> Option<Self> {
@@ -245,6 +256,7 @@ impl Representation {
 	}
 }
 
+#[cfg(not(feature = "nightly"))]
 impl ToTokens for Representation {
 	fn to_tokens(&self, tokens: &mut TokenStream) {
 		tokens.extend(self.to_token());

src/lib.rs

@@ -55,7 +55,7 @@
 //!
 //! ## Generic type bounds
 //!
-//! Separated from the list of traits with a semi-colon, types to bind to can be
+//! Separated from the list of traits with a semicolon, types to bind to can be
 //! specified. This example will restrict the implementation for `Example` to
 //! `T: Clone`:
 //!
@@ -307,7 +307,7 @@
 //! ## Supported items
 //!
 //! Structs, tuple structs, unions and enums are supported. Derive-where tries
-//! it's best to discourage usage that could be covered by std's `derive`. For
+//! its best to discourage usage that could be covered by std's `derive`. For
 //! example unit structs and enums only containing unit variants aren't
 //! supported.
 //!
@@ -408,6 +408,8 @@ use util::MetaListExt;
 
 #[cfg(feature = "zeroize")]
 use self::attr::ZeroizeFqs;
+#[cfg(not(feature = "nightly"))]
+use self::item::Discriminant;
 use self::{
 	attr::{
 		Default, DeriveTrait, DeriveWhere, FieldAttr, Incomparable, ItemAttr, Skip, SkipGroup,
@@ -416,7 +418,7 @@ use self::{
 	data::{Data, DataType, Field, SimpleType},
 	error::Error,
 	input::Input,
-	item::{Discriminant, Item},
+	item::Item,
 	trait_::{Trait, TraitImpl},
 	util::Either,
 };
@@ -588,7 +590,7 @@ pub fn derive_where_actual(input: proc_macro::TokenStream) -> proc_macro::TokenS
 		clean_item.span()
 	};
 
-	match { Input::from_input(span, &item) } {
+	match Input::from_input(span, &item) {
 		Ok(Input {
 			derive_wheres,
 			generics,

src/trait_/clone.rs

@@ -123,7 +123,7 @@ impl TraitImpl for Clone {
 			SimpleType::Unit(pattern) => {
 				quote! { #pattern => #pattern, }
 			}
-			SimpleType::Union(_) => TokenStream::new(),
+			SimpleType::Union => TokenStream::new(),
 		}
 	}
 }

src/trait_/common_ord.rs

@@ -461,7 +461,7 @@ pub fn build_incomparable_pattern(variants: &[Data]) -> Option<TokenStream> {
 		.map(|variant @ Data { path, .. }| match variant.simple_type() {
 			SimpleType::Struct(_) => quote!(#path{..}),
 			SimpleType::Tuple(_) => quote!(#path(..)),
-			SimpleType::Union(_) => unreachable!("enum variants cannot be unions"),
+			SimpleType::Union => unreachable!("enum variants cannot be unions"),
 			SimpleType::Unit(_) => quote!(#path),
 		})
 		.peekable();

src/trait_/debug.rs

@@ -79,7 +79,7 @@ impl TraitImpl for Debug {
 			SimpleType::Unit(_) => {
 				quote! { #self_pattern => ::core::fmt::Formatter::write_str(__f, #debug_name), }
 			}
-			SimpleType::Union(_) => unreachable!("unexpected trait for union"),
+			SimpleType::Union => unreachable!("unexpected trait for union"),
 		}
 	}
 }

src/trait_/default.rs

@@ -60,7 +60,7 @@ impl TraitImpl for Default {
 				SimpleType::Unit(_) => {
 					quote! { #path }
 				}
-				SimpleType::Union(_) => unreachable!("unexpected trait for union"),
+				SimpleType::Union => unreachable!("unexpected trait for union"),
 			}
 		}
 		// Skip `Default` implementation if variant isn't marked with a `default` attribute.