Dereference matched value

This ensures patterns are exhaustive even in the case of an enum without variants.

Resolves #16

Author: stephaneyfx

enum-iterator-derive/src/lib.rs

@@ -236,11 +236,12 @@ where
         |(variant, next_variants)| {
             let next = init_enum(ty, next_variants, direction);
             let id = &variant.ident;
+            let destructuring = field_bindings(&variant.fields);
             let assignments = field_assignments(&variant.fields);
             let bindings = bindings().take(variant.fields.len()).collect::<Vec<_>>();
             let tuple = advance_tuple(&bindings, direction);
             quote! {
-                #ty::#id { #assignments } => {
+                #ty::#id { #destructuring } => {
                     #tuple
                         .map(|(#(#bindings,)*)| #ty::#id { #assignments })
                         .or_else(|| #next)
@@ -249,7 +250,7 @@ where
         },
     );
     quote! {
-        match self {
+        match *self {
             #(#arms,)*
         }
     }
@@ -308,6 +309,21 @@ where
         .collect()
 }
 
+fn field_bindings<'a, I>(fields: I) -> TokenStream
+where
+    I: IntoIterator<Item = &'a Field>,
+{
+    fields
+        .into_iter()
+        .enumerate()
+        .zip(bindings())
+        .map(|((i, field), binding)| {
+            let field_id = field_id(field, i);
+            quote! { #field_id: ref #binding, }
+        })
+        .collect()
+}
+
 fn bindings() -> impl Iterator<Item = Ident> {
     (0..).map(|i| Ident::new(&format!("x{i}"), Span::call_site()))
 }

enum-iterator/tests/derive.rs

@@ -145,3 +145,21 @@ fn reverse_all_works() {
     };
     assert_eq!(reverse_all::<Move>().collect::<Vec<_>>(), expected);
 }
+
+#[derive(Debug, PartialEq, Sequence)]
+enum Empty {}
+
+#[test]
+fn empty_cadinality_is_zero() {
+    assert_eq!(cardinality::<Empty>(), 0);
+}
+
+#[test]
+fn all_values_of_empty_are_yielded() {
+    assert_eq!(all::<Empty>().collect::<Vec<_>>(), Vec::new());
+}
+
+#[test]
+fn all_values_of_empty_are_yielded_in_reverse() {
+    assert_eq!(reverse_all::<Empty>().collect::<Vec<_>>(), Vec::new());
+}