[2/n] [daft-derive] make snapshot_test only look at types annotated with derive(Diffable)

We want to add some more tests where some types are annotated with
`derive(Diffable)` and others aren't.

Also extend snapshot tests to look at unions.

Reviewers: andrewjstone

Reviewed By: andrewjstone

Pull Request: #59

Author: sunshowers

daft-derive/tests/fixtures/README.md

@@ -9,9 +9,7 @@ These fixtures ensure that:
 
 Each file in `valid` is automatically picked up by the snapshot and UI tests.
 
-Currently, `snapshot_test.rs` only tests the first struct or enum in the file.
-The test can be extended to test multiple macro invocations per file if
-necessary.
+`snapshot_test.rs` tests all macro invocations annotated with `#[derive(Diffable)]`.
 
 ## Invalid fixtures
 
@@ -21,3 +19,5 @@ These fixtures ensure that:
 * the macro's output fails with a good error message, via `ui_test.rs`.
 
 Each file in `invalid` is automatically picked up by the snapshot and UI tests.
+
+Like with valid fixtures, `snapshot_test.rs` tests all macro invocations annotated with `#[derive(Diffable)]`.

daft-derive/tests/fixtures/invalid/output/union-attributes.output.rs

@@ -0,0 +1,18 @@
+impl ::daft::Diffable for MyUnion {
+    type Diff<'__daft> = ::daft::Leaf<&'__daft Self> where Self: '__daft;
+    fn diff<'__daft>(&'__daft self, other: &'__daft Self) -> Self::Diff<'__daft> {
+        ::daft::Leaf {
+            before: self,
+            after: other,
+        }
+    }
+}
+impl ::daft::Diffable for MyUnion2 {
+    type Diff<'__daft> = ::daft::Leaf<&'__daft Self> where Self: '__daft;
+    fn diff<'__daft>(&'__daft self, other: &'__daft Self) -> Self::Diff<'__daft> {
+        ::daft::Leaf {
+            before: self,
+            after: other,
+        }
+    }
+}

daft-derive/tests/fixtures/valid/output/union.output.rs

@@ -0,0 +1,9 @@
+impl ::daft::Diffable for Inner {
+    type Diff<'__daft> = ::daft::Leaf<&'__daft Self> where Self: '__daft;
+    fn diff<'__daft>(&'__daft self, other: &'__daft Self) -> Self::Diff<'__daft> {
+        ::daft::Leaf {
+            before: self,
+            after: other,
+        }
+    }
+}

daft-derive/tests/snapshot_test.rs

@@ -49,8 +49,15 @@ fn run_derive_macro(
 ) -> impl Iterator<Item = internals::DeriveDiffableOutput> + '_ {
     // Look for structs and enums in the input -- give them to the derive macro.
     let items = data.items.iter().filter_map(|item| match item {
-        syn::Item::Struct(item) => Some(item.to_token_stream()),
-        syn::Item::Enum(item) => Some(item.to_token_stream()),
+        syn::Item::Struct(item) => {
+            has_derive_diffable(&item.attrs).then(|| item.to_token_stream())
+        }
+        syn::Item::Enum(item) => {
+            has_derive_diffable(&item.attrs).then(|| item.to_token_stream())
+        }
+        syn::Item::Union(item) => {
+            has_derive_diffable(&item.attrs).then(|| item.to_token_stream())
+        }
         _ => None,
     });
 
@@ -63,6 +70,24 @@ fn run_derive_macro(
     })
 }
 
+fn has_derive_diffable(attrs: &[syn::Attribute]) -> bool {
+    attrs.iter().any(|attr| {
+        if !attr.path().is_ident("derive") {
+            return false;
+        }
+
+        let mut is_diffable = false;
+        attr.parse_nested_meta(|meta| {
+            if meta.path.is_ident("Diffable") {
+                is_diffable = true;
+            }
+            Ok(())
+        })
+        .expect("derive attributes parsed correctly");
+        is_diffable
+    })
+}
+
 fn assert_derive_output<T: ToTokens>(
     path: &Utf8Path,
     output: impl IntoIterator<Item = T>,