[spr] initial version

Created using spr 1.3.6-beta.1

Author: sunshowers

daft-derive/src/internals/imp.rs

@@ -1,54 +1,50 @@
 use super::error_store::{ErrorSink, ErrorStore};
 use proc_macro2::{Span, TokenStream};
-use quote::{quote, ToTokens};
+use quote::{quote, quote_spanned, ToTokens};
 use syn::{
-    parse_quote, parse_str, visit::Visit, Attribute, Data, DataStruct,
-    DeriveInput, Expr, Field, Fields, GenericParam, Generics, Index, Lifetime,
-    LifetimeParam, Path, Token, WhereClause, WherePredicate,
+    parse_quote, parse_quote_spanned, parse_str, spanned::Spanned,
+    visit::Visit, Attribute, Data, DataStruct, DeriveInput, Expr, Field,
+    Fields, GenericParam, Generics, Index, Lifetime, 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(),
             }
         }
     }
@@ -568,11 +564,11 @@ impl DiffFields {
         let mut f = f.clone();
 
         f.ty = if config.mode == FieldMode::Leaf {
-            parse_quote! {
+            parse_quote_spanned! {f.span()=>
                 #daft_crate::Leaf<&#lt #ty>
             }
         } else {
-            parse_quote! {
+            parse_quote_spanned! {f.span()=>
                 <#ty as #daft_crate::Diffable>::Diff<#lt>
             }
         };
@@ -596,7 +592,7 @@ impl DiffFields {
         trait_bound: &syn::TraitBound,
     ) -> WhereClause {
         let predicates = self.types().map(|ty| -> WherePredicate {
-            parse_quote! {
+            parse_quote_spanned! {ty.span()=>
                 #ty: #trait_bound
             }
         });
@@ -632,14 +628,14 @@ fn generate_field_diffs(
                 }
             };
             if config.mode == FieldMode::Leaf {
-                quote! {
+                quote_spanned! {f.span()=>
                     #field_name: #daft_crate::Leaf {
                         before: &self.#field_name,
                         after: &other.#field_name
                     }
                 }
             } else {
-                quote! {
+                quote_spanned! {f.span()=>
                     #field_name: #daft_crate::Diffable::diff(
                         &self.#field_name,
                         &other.#field_name

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,39 @@
+struct MyStructDiff<'__daft> {
+    a: <i32 as ::daft::Diffable>::Diff<'__daft>,
+    b: <NonDiffable as ::daft::Diffable>::Diff<'__daft>,
+}
+impl<'__daft> ::std::fmt::Debug for MyStructDiff<'__daft>
+where
+    <i32 as ::daft::Diffable>::Diff<'__daft>: ::std::fmt::Debug,
+    <NonDiffable as ::daft::Diffable>::Diff<'__daft>: ::std::fmt::Debug,
+{
+    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        f.debug_struct(stringify!(MyStructDiff))
+            .field(stringify!(a), &self.a)
+            .field(stringify!(b), &self.b)
+            .finish()
+    }
+}
+impl<'__daft> ::std::cmp::PartialEq for MyStructDiff<'__daft>
+where
+    <i32 as ::daft::Diffable>::Diff<'__daft>: ::std::cmp::PartialEq,
+    <NonDiffable as ::daft::Diffable>::Diff<'__daft>: ::std::cmp::PartialEq,
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.a == other.a && self.b == other.b
+    }
+}
+impl<'__daft> ::std::cmp::Eq for MyStructDiff<'__daft>
+where
+    <i32 as ::daft::Diffable>::Diff<'__daft>: ::std::cmp::Eq,
+    <NonDiffable as ::daft::Diffable>::Diff<'__daft>: ::std::cmp::Eq,
+{}
+impl ::daft::Diffable for MyStruct {
+    type Diff<'__daft> = MyStructDiff<'__daft> where Self: '__daft;
+    fn diff<'__daft>(&'__daft self, other: &'__daft Self) -> MyStructDiff<'__daft> {
+        Self::Diff {
+            a: ::daft::Diffable::diff(&self.a, &other.a),
+            b: ::daft::Diffable::diff(&self.b, &other.b),
+        }
+    }
+}

daft-derive/tests/fixtures/invalid/output/field-leaf-and-ignore.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-specified-multiple-times.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-unknown-attribute.output.rs

@@ -0,0 +1,14 @@
+use daft::Diffable;
+
+struct NonDiffable {}
+
+#[derive(Diffable)]
+struct MyStruct {
+    a: i32,
+    b: NonDiffable,
+}
+
+fn main() {
+    // MyStruct should still exist, even though the Diffable impl has errors.
+    let _ = MyStruct { a: 0, b: NonDiffable {} };
+}

daft-derive/tests/fixtures/invalid/output/struct-attribute-with-value.output.rs

@@ -0,0 +1,88 @@
+error[E0277]: the trait bound `NonDiffable: Diffable` is not satisfied
+ --> tests/fixtures/invalid/struct-field-not-diffable.rs:8:5
+  |
+8 |     b: NonDiffable,
+  |     ^ the trait `Diffable` is not implemented for `NonDiffable`
+  |
+  = help: the following other types implement trait `Diffable`:
+            &'a T
+            ()
+            (A, B)
+            (A, B, C)
+            (A, B, C, D)
+            (A, B, C, D, E)
+            (A, B, C, D, E, F)
+            (A, B, C, D, E, F, G)
+          and $N others
+
+error[E0277]: the trait bound `NonDiffable: Diffable` is not satisfied
+ --> tests/fixtures/invalid/struct-field-not-diffable.rs:5:10
+  |
+5 | #[derive(Diffable)]
+  |          ^^^^^^^^ the trait `Diffable` is not implemented for `NonDiffable`
+  |
+  = help: the following other types implement trait `Diffable`:
+            &'a T
+            ()
+            (A, B)
+            (A, B, C)
+            (A, B, C, D)
+            (A, B, C, D, E)
+            (A, B, C, D, E, F)
+            (A, B, C, D, E, F, G)
+          and $N others
+  = note: this error originates in the derive macro `Diffable` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `NonDiffable: Diffable` is not satisfied in `MyStructDiff<'__daft>`
+ --> tests/fixtures/invalid/struct-field-not-diffable.rs:5:10
+  |
+5 | #[derive(Diffable)]
+  |          ^^^^^^^^ within `MyStructDiff<'__daft>`, the trait `Diffable` is not implemented for `NonDiffable`
+  |
+  = help: the following other types implement trait `Diffable`:
+            &'a T
+            ()
+            (A, B)
+            (A, B, C)
+            (A, B, C, D)
+            (A, B, C, D, E)
+            (A, B, C, D, E, F)
+            (A, B, C, D, E, F, G)
+          and $N others
+note: required because it appears within the type `MyStructDiff<'__daft>`
+ --> tests/fixtures/invalid/struct-field-not-diffable.rs:5:10
+  |
+5 | #[derive(Diffable)]
+  |          ^^^^^^^^
+note: required by a bound in `daft::Diffable::Diff`
+ --> $WORKSPACE/daft/src/diffable.rs
+  |
+  | /     type Diff<'daft>
+  | |     where
+  | |         Self: 'daft;
+  | |____________________^ required by this bound in `Diffable::Diff`
+  = note: this error originates in the derive macro `Diffable` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0277]: the trait bound `NonDiffable: Diffable` is not satisfied in `MyStructDiff<'__daft>`
+ --> tests/fixtures/invalid/struct-field-not-diffable.rs:5:10
+  |
+5 | #[derive(Diffable)]
+  |          ^^^^^^^^ within `MyStructDiff<'__daft>`, the trait `Diffable` is not implemented for `NonDiffable`
+  |
+  = help: the following other types implement trait `Diffable`:
+            &'a T
+            ()
+            (A, B)
+            (A, B, C)
+            (A, B, C, D)
+            (A, B, C, D, E)
+            (A, B, C, D, E, F)
+            (A, B, C, D, E, F, G)
+          and $N others
+note: required because it appears within the type `MyStructDiff<'__daft>`
+ --> tests/fixtures/invalid/struct-field-not-diffable.rs:5:10
+  |
+5 | #[derive(Diffable)]
+  |          ^^^^^^^^
+  = note: the return type of a function must have a statically known size
+  = note: this error originates in the derive macro `Diffable` (in Nightly builds, run with -Z macro-backtrace for more info)

daft-derive/tests/fixtures/invalid/output/struct-field-not-diffable.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,
+        }
+    }
+}