[spr] initial version

Created using spr 1.3.6-beta.1

Author: sunshowers

daft-derive/src/internals/imp.rs

@@ -7,48 +7,43 @@ use syn::{
     LifetimeParam, Path, Token, WhereClause, WherePredicate,
 };
 
-pub fn derive_diffable(input: syn::DeriveInput) -> TokenStream {
+pub struct DeriveDiffableOutput {
+    pub out: Option<TokenStream>,
+    pub errors: Vec<syn::Error>,
+}
+
+impl ToTokens for DeriveDiffableOutput {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        tokens.extend(self.out.clone());
+        tokens.extend(self.errors.iter().map(|error| error.to_compile_error()));
+    }
+}
+
+pub fn derive_diffable(input: syn::DeriveInput) -> DeriveDiffableOutput {
     let mut error_store = ErrorStore::new();
 
     match &input.data {
         Data::Enum(_) => {
             // Implement all Enums as `Leaf`s
             let out = make_leaf(&input, AttrPosition::Enum, error_store.sink());
-            // Errors might have occurred while parsing attributes.
-            let errors = error_store
-                .into_inner()
-                .into_iter()
-                .map(|error| error.into_compile_error());
-            quote! {
-                #out
-                #(#errors)*
+            DeriveDiffableOutput {
+                out: Some(out),
+                errors: error_store.into_inner(),
             }
         }
         Data::Struct(s) => {
             // This might be None if there are errors.
             let out = make_struct_impl(&input, s, error_store.sink());
-            let errors = error_store
-                .into_inner()
-                .into_iter()
-                .map(|error| error.into_compile_error());
-            quote! {
-                #out
-                #(#errors)*
-            }
+            DeriveDiffableOutput { out, errors: error_store.into_inner() }
         }
 
         Data::Union(_) => {
             // Implement all unions as `Leaf`s
             let out =
                 make_leaf(&input, AttrPosition::Union, error_store.sink());
-            // Errors might have occurred while parsing attributes.
-            let errors = error_store
-                .into_inner()
-                .into_iter()
-                .map(|error| error.into_compile_error());
-            quote! {
-                #out
-                #(#errors)*
+            DeriveDiffableOutput {
+                out: Some(out),
+                errors: error_store.into_inner(),
             }
         }
     }

daft-derive/src/lib.rs

@@ -6,6 +6,7 @@
 #![doc(html_root_url = "https://docs.rs/daft-derive/0.1.1")]
 mod internals;
 
+use quote::ToTokens;
 use syn::parse_macro_input;
 
 // NOTE: We do not define documentation here -- only in daft while re-exporting
@@ -16,5 +17,5 @@ pub fn derive_diffable(
     input: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
     let input = parse_macro_input!(input as syn::DeriveInput);
-    internals::derive_diffable(input).into()
+    internals::derive_diffable(input).into_token_stream().into()
 }

daft-derive/tests/fixtures/README.md

@@ -9,6 +9,15 @@ 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
+
+These fixtures ensure that:
+
+* the macro's success output, if any, is stable, via `snapshot_test.rs`.
+* 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/enum-attributes.output.rs

@@ -0,0 +1,18 @@
+impl ::daft::Diffable for MyEnum {
+    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 MyEnum2 {
+    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/invalid/output/field-attribute-with-value.output.rs

@@ -0,0 +1,9 @@
+impl ::daft::Diffable for MyStruct {
+    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/invalid/output/field-leaf-and-ignore.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/invalid/output/field-specified-multiple-times.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/fixtures/invalid/output/field-unknown-attribute.output.rs

@@ -11,7 +11,8 @@ mod internals;
 
 datatest_stable::harness! {
     // The pattern matches all .rs files that aren't .output.rs files.
-    { test = daft_snapshot, root = "tests/fixtures/valid", pattern = r"^.*(?<!\.output)\.rs$" }
+    { test = daft_snapshot, root = "tests/fixtures/valid", pattern = r"^.*(?<!\.output)\.rs$" },
+    { test = daft_snapshot_invalid, root = "tests/fixtures/invalid", pattern = r"^.*(?<!\.output)\.rs$" },
 }
 
 /// Snapshot tests for valid inputs.
@@ -21,10 +22,42 @@ fn daft_snapshot(
 ) -> datatest_stable::Result<()> {
     let data = syn::parse_str::<syn::File>(&input)?;
 
+    let output = run_derive_macro(&data);
+    assert_derive_output(path, output);
+
+    Ok(())
+}
+
+/// Snapshot tests for invalid inputs.
+fn daft_snapshot_invalid(
+    path: &Utf8Path,
+    input: String,
+) -> datatest_stable::Result<()> {
+    let data = syn::parse_str::<syn::File>(&input)?;
+
+    let output = run_derive_macro(&data).map(|output| {
+        // Drop the errors for snapshot tests -- only use the output.
+        output.out
+    });
+    assert_derive_output(path, output);
+
+    Ok(())
+}
+
+fn run_derive_macro(
+    data: &syn::File,
+) -> 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,
     });
 
@@ -35,8 +68,33 @@ fn daft_snapshot(
         });
         internals::derive_diffable(data)
     });
+    output
+}
+
+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>,
+) {
     // Read the output as a `syn::File`.
+    let output = output.into_iter();
     let file = parse_quote! {
         #(#output)*
     };
@@ -52,6 +110,4 @@ fn daft_snapshot(
     output_path.set_extension("output.rs");
 
     expectorate::assert_contents(&output_path, &output);
-
-    Ok(())
 }