Add ui test that invokes trait_variant

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["dynosaur", "dynosaur_derive"]
+members = ["dynosaur", "dynosaur_derive", "dynosaur/tests"]
 resolver = "2"
 
 [workspace.dependencies]

dynosaur/Cargo.toml

@@ -17,11 +17,11 @@ rust-version = "1.75"
 
 [dependencies]
 dynosaur_derive = { version = "0.1", path = "../dynosaur_derive" }
+trait-variant = { workspace = true }
 
 [dev-dependencies]
 tokio = { workspace = true }
 ui_test = "0.24"
-trait-variant = { workspace = true }
 
 [[example]]
 name = "next"

dynosaur/tests/Cargo.toml

@@ -0,0 +1,15 @@
+# Stub manifest file to specify dependencies.
+# This is required because ui tests don't have access to dev dependencies:
+# https://github.com/oli-obk/ui_test/issues/282
+
+[package]
+name = "dynosaur_ui_tests"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+dynosaur = { version = "0.1", path = "../" }
+trait-variant = { workspace = true }

dynosaur/tests/lib.rs

@@ -0,0 +1 @@
+// Empty stub for Cargo.toml.

dynosaur/tests/pass/trait-variant.rs

@@ -0,0 +1,7 @@
+#[trait_variant::make(SendNext: Send)]
+#[dynosaur::dynosaur(DynNext = dyn Next)]
+#[dynosaur::dynosaur(DynSendNext = dyn SendNext)]
+trait Next {
+    type Item;
+    async fn next(&mut self) -> Option<Self::Item>;
+}

dynosaur/tests/pass/trait-variant.stdout

@@ -0,0 +1,163 @@
+#![feature(prelude_import)]
+#[prelude_import]
+use std::prelude::rust_2021::*;
+#[macro_use]
+extern crate std;
+#[allow(async_fn_in_trait)]
+trait Next {
+    type Item;
+    async fn next(&mut self)
+    -> Option<Self::Item>;
+}
+mod _dynosaur_macro_DynNext {
+    use super::*;
+    #[allow(async_fn_in_trait)]
+    trait ErasedNext {
+        type Item;
+        fn next<'life0, 'dynosaur>(&'life0 mut self)
+        ->
+            ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
+            Option<Self::Item>> + 'dynosaur>>
+        where
+        'life0: 'dynosaur,
+        Self: 'dynosaur;
+    }
+    impl<DYNOSAUR: Next> ErasedNext for DYNOSAUR {
+        type Item = <Self as Next>::Item;
+        fn next<'life0, 'dynosaur>(&'life0 mut self)
+            ->
+                ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
+                Option<Self::Item>> + 'dynosaur>> where 'life0: 'dynosaur,
+            Self: 'dynosaur {
+            Box::pin(<Self as Next>::next(self))
+        }
+    }
+    #[repr(transparent)]
+    pub struct DynNext<'dynosaur_struct, Item> {
+        ptr: dyn ErasedNext<Item = Item> + 'dynosaur_struct,
+    }
+    impl<'dynosaur_struct, Item> Next for DynNext<'dynosaur_struct, Item> {
+        type Item = Item;
+        fn next(&mut self)
+            -> impl ::core::future::Future<Output = Option<Self::Item>> {
+            let fut:
+                    ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
+                    Option<Self::Item>> + '_>> = self.ptr.next();
+            let fut:
+                    ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
+                    Option<Self::Item>> + 'static>> =
+                unsafe { ::core::mem::transmute(fut) };
+            fut
+        }
+    }
+    impl<'dynosaur_struct, Item> DynNext<'dynosaur_struct, Item> {
+        pub fn new(value: Box<impl Next<Item = Item> + 'dynosaur_struct>)
+            -> Box<DynNext<'dynosaur_struct, Item>> {
+            let value: Box<dyn ErasedNext<Item = Item> + 'dynosaur_struct> =
+                value;
+            unsafe { ::core::mem::transmute(value) }
+        }
+        pub fn boxed(value: impl Next<Item = Item> + 'dynosaur_struct)
+            -> Box<DynNext<'dynosaur_struct, Item>> {
+            Self::new(Box::new(value))
+        }
+        pub fn from_ref(value: &(impl Next<Item = Item> + 'dynosaur_struct))
+            -> &DynNext<'dynosaur_struct, Item> {
+            let value: &(dyn ErasedNext<Item = Item> + 'dynosaur_struct) =
+                &*value;
+            unsafe { ::core::mem::transmute(value) }
+        }
+        pub fn from_mut(value:
+                &mut (impl Next<Item = Item> + 'dynosaur_struct))
+            -> &mut DynNext<'dynosaur_struct, Item> {
+            let value: &mut (dyn ErasedNext<Item = Item> + 'dynosaur_struct) =
+                &mut *value;
+            unsafe { ::core::mem::transmute(value) }
+        }
+    }
+}
+use _dynosaur_macro_DynNext::DynNext;
+trait SendNext: Send {
+    type Item;
+    fn next(&mut self)
+    -> impl ::core::future::Future<Output = Option<Self::Item>> + Send;
+}
+mod _dynosaur_macro_DynSendNext {
+    use super::*;
+    trait ErasedSendNext: Send {
+        type Item;
+        fn next<'life0, 'dynosaur>(&'life0 mut self)
+        ->
+            ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
+            Option<Self::Item>> + Send + 'dynosaur>>
+        where
+        'life0: 'dynosaur,
+        Self: 'dynosaur;
+    }
+    impl<DYNOSAUR: SendNext> ErasedSendNext for DYNOSAUR {
+        type Item = <Self as SendNext>::Item;
+        fn next<'life0, 'dynosaur>(&'life0 mut self)
+            ->
+                ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
+                Option<Self::Item>> + Send + 'dynosaur>> where
+            'life0: 'dynosaur, Self: 'dynosaur {
+            Box::pin(<Self as SendNext>::next(self))
+        }
+    }
+    #[repr(transparent)]
+    pub struct DynSendNext<'dynosaur_struct, Item> {
+        ptr: dyn ErasedSendNext<Item = Item> + 'dynosaur_struct,
+    }
+    impl<'dynosaur_struct, Item> SendNext for
+        DynSendNext<'dynosaur_struct, Item> {
+        type Item = Item;
+        fn next(&mut self)
+            ->
+                impl ::core::future::Future<Output = Option<Self::Item>> +
+                Send {
+            let fut:
+                    ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
+                    Option<Self::Item>> + Send + '_>> = self.ptr.next();
+            let fut:
+                    ::core::pin::Pin<Box<dyn ::core::future::Future<Output =
+                    Option<Self::Item>> + Send + 'static>> =
+                unsafe { ::core::mem::transmute(fut) };
+            fut
+        }
+    }
+    impl<'dynosaur_struct, Item> DynSendNext<'dynosaur_struct, Item> {
+        pub fn new(value: Box<impl SendNext<Item = Item> + 'dynosaur_struct>)
+            -> Box<DynSendNext<'dynosaur_struct, Item>> {
+            let value:
+                    Box<dyn ErasedSendNext<Item = Item> + 'dynosaur_struct> =
+                value;
+            unsafe { ::core::mem::transmute(value) }
+        }
+        pub fn boxed(value: impl SendNext<Item = Item> + 'dynosaur_struct)
+            -> Box<DynSendNext<'dynosaur_struct, Item>> {
+            Self::new(Box::new(value))
+        }
+        pub fn from_ref(value:
+                &(impl SendNext<Item = Item> + 'dynosaur_struct))
+            -> &DynSendNext<'dynosaur_struct, Item> {
+            let value: &(dyn ErasedSendNext<Item = Item> + 'dynosaur_struct) =
+                &*value;
+            unsafe { ::core::mem::transmute(value) }
+        }
+        pub fn from_mut(value:
+                &mut (impl SendNext<Item = Item> + 'dynosaur_struct))
+            -> &mut DynSendNext<'dynosaur_struct, Item> {
+            let value:
+                    &mut (dyn ErasedSendNext<Item = Item> + 'dynosaur_struct) =
+                &mut *value;
+            unsafe { ::core::mem::transmute(value) }
+        }
+    }
+}
+use _dynosaur_macro_DynSendNext::DynSendNext;
+impl<TraitVariantBlanketType: SendNext> Next for TraitVariantBlanketType {
+    type Item = <Self as SendNext>::Item;
+    async fn next(&mut self) -> Option<Self::Item> {
+        <Self as SendNext>::next(self).await
+    }
+}

dynosaur/tests/ui.rs

@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use ui_test::color_eyre::eyre::Result;
 use ui_test::dependencies::DependencyBuilder;
@@ -26,10 +26,13 @@ fn cfg(path: &Path, mode: Mode) -> Config {
     let require_annotations = false; // we're not showing errors in a specific line anyway
     config.comment_defaults.base().exit_status = Spanned::dummy(exit_status).into();
     config.comment_defaults.base().require_annotations = Spanned::dummy(require_annotations).into();
-    config
-        .comment_defaults
-        .base()
-        .set_custom("dependencies", DependencyBuilder::default());
+    config.comment_defaults.base().set_custom(
+        "dependencies",
+        DependencyBuilder {
+            crate_manifest_path: PathBuf::from("tests/Cargo.toml"),
+            ..DependencyBuilder::default()
+        },
+    );
     config
 }
 

dynosaur_derive/src/lib.rs

@@ -19,8 +19,6 @@ struct Attrs {
 }
 
 struct Target {
-    _equals: Token![=],
-    _dyn: Token![dyn],
     trait_name: Ident,
 }
 
@@ -29,9 +27,9 @@ impl Parse for Attrs {
         Ok(Attrs {
             ident: input.parse()?,
             target: if input.peek(Token![=]) {
+                input.parse::<Token![=]>()?;
+                input.parse::<Token![dyn]>()?;
                 Some(Target {
-                    _equals: input.parse()?,
-                    _dyn: input.parse()?,
                     trait_name: input.parse()?,
                 })
             } else {