Actor derive macro (#837)

Summary:
Pull Request resolved: #837

We have many trivial `Actor` implementations. (Usually, the the actor's handlers are more involved.)

We add a derive macro for actors, supporting two patterns:

1) "empty params", where we use the actors Default::default implementation to create a new actor;
2) "passthrough actor", where the params themselves are simply an actor instance which we immediately return

This change introduces the macro and adjusts usages throughout our code base.
ghstack-source-id: 302711475
exported-using-ghexport

Reviewed By: vidhyav

Differential Revision: D80139026

fbshipit-source-id: af2ad6a67038d6decc0e2884f7cbee70481de18a

Author: mariusae

controller/src/lib.rs

@@ -527,7 +527,7 @@ impl ControllerMessageHandler for ControllerActor {
                 // Randomly pick a failed proc as the failed actor.
                 let (_, failed_state) = world_state.procs.iter().next().unwrap();
                 let (failed_actor, failure_reason) =
-                    failed_state.failed_actors.iter().next().map_or_else(
+                    failed_state.failed_actors.first().map_or_else(
                         || {
                             let proc_id = &failed_state.proc_id;
                             (
@@ -1808,23 +1808,14 @@ mod tests {
         Panic(String),
     }
 
-    #[derive(Debug)]
+    #[derive(Debug, Default, Actor)]
     #[hyperactor::export(
         handlers = [
             PanickingMessage,
         ],
     )]
     struct PanickingActor;
 
-    #[async_trait]
-    impl Actor for PanickingActor {
-        type Params = ();
-
-        async fn new(_params: ()) -> Result<Self, anyhow::Error> {
-            Ok(Self)
-        }
-    }
-
     #[async_trait]
     #[hyperactor::forward(PanickingMessage)]
     impl PanickingMessageHandler for PanickingActor {

hyper/src/commands/demo.rs

@@ -210,7 +210,7 @@ enum DemoMessage {
     Error(String, #[reply] OncePortRef<()>),
 }
 
-#[derive(Debug)]
+#[derive(Debug, Default, Actor)]
 #[hyperactor::export(
     spawn = true,
     handlers = [
@@ -219,15 +219,6 @@ enum DemoMessage {
 )]
 struct DemoActor;
 
-#[async_trait]
-impl Actor for DemoActor {
-    type Params = ();
-
-    async fn new(_params: ()) -> Result<Self, anyhow::Error> {
-        Ok(Self)
-    }
-}
-
 #[async_trait]
 #[forward(DemoMessage)]
 impl DemoMessageHandler for DemoActor {

hyperactor/example/derive.rs

@@ -35,7 +35,7 @@ enum ShoppingList {
 }
 
 // Define an actor.
-#[derive(Debug)]
+#[derive(Debug, Actor, Default)]
 #[hyperactor::export(
     spawn = true,
     handlers = [
@@ -44,15 +44,6 @@ enum ShoppingList {
 )]
 struct ShoppingListActor(HashSet<String>);
 
-#[async_trait]
-impl Actor for ShoppingListActor {
-    type Params = ();
-
-    async fn new(_params: ()) -> Result<Self, anyhow::Error> {
-        Ok(Self(HashSet::new()))
-    }
-}
-
 // ShoppingListHandler is the trait generated by derive(Handler) above.
 // We implement the trait here for the actor, defining a handler for
 // each ShoppingList message.

hyperactor/src/actor.rs

@@ -658,6 +658,8 @@ mod tests {
     use tokio::time::timeout;
 
     use super::*;
+    use crate as hyperactor;
+    use crate::Actor;
     use crate::Mailbox;
     use crate::OncePortHandle;
     use crate::PortRef;
@@ -666,7 +668,7 @@ mod tests {
     use crate::test_utils::pingpong::PingPongActor;
     use crate::test_utils::pingpong::PingPongActorParams;
     use crate::test_utils::pingpong::PingPongMessage;
-    use crate::test_utils::proc_supervison::ProcSupervisionCoordinator;
+    use crate::test_utils::proc_supervison::ProcSupervisionCoordinator; // for macros
 
     #[derive(Debug)]
     struct EchoActor(PortRef<u64>);
@@ -983,18 +985,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_actor_handle_downcast() {
-        #[derive(Debug)]
+        #[derive(Debug, Default, Actor)]
         struct NothingActor;
 
-        #[async_trait]
-        impl Actor for NothingActor {
-            type Params = ();
-
-            async fn new(_: ()) -> Result<Self, anyhow::Error> {
-                Ok(Self)
-            }
-        }
-
         // Just test that we can round-trip the handle through a downcast.
 
         let proc = Proc::local();

hyperactor/src/lib.rs

@@ -106,6 +106,8 @@ pub use cityhasher;
 #[doc(hidden)]
 pub use dashmap; // For intern_typename!
 pub use data::Named;
+#[doc(hidden)]
+pub use hyperactor_macros::Actor;
 #[doc(inline)]
 pub use hyperactor_macros::Bind;
 #[doc(inline)]

hyperactor/src/mailbox.rs

@@ -2924,17 +2924,9 @@ mod tests {
         );
     }
 
-    #[derive(Debug)]
+    #[derive(Debug, Default, Actor)]
     struct Foo;
 
-    #[async_trait]
-    impl Actor for Foo {
-        type Params = ();
-        async fn new(_params: ()) -> Result<Self, anyhow::Error> {
-            Ok(Self)
-        }
-    }
-
     // Test that a message delivery failure causes the sending actor
     // to stop running.
     #[tokio::test]

hyperactor/src/proc.rs

@@ -1857,7 +1857,7 @@ mod tests {
         }
     }
 
-    #[derive(Debug)]
+    #[derive(Debug, Default, Actor)]
     #[export]
     struct TestActor;
 
@@ -1880,15 +1880,6 @@ mod tests {
         }
     }
 
-    #[async_trait]
-    impl Actor for TestActor {
-        type Params = ();
-
-        async fn new(_params: ()) -> Result<Self, anyhow::Error> {
-            Ok(Self)
-        }
-    }
-
     #[async_trait]
     #[crate::forward(TestActorMessage)]
     impl TestActorMessageHandler for TestActor {
@@ -2017,23 +2008,14 @@ mod tests {
         rx.await.unwrap();
     }
 
-    #[derive(Debug)]
+    #[derive(Debug, Default, Actor)]
     struct LookupTestActor;
 
     #[derive(Handler, HandleClient, Debug)]
     enum LookupTestMessage {
         ActorExists(ActorRef<TestActor>, #[reply] OncePortRef<bool>),
     }
 
-    #[async_trait]
-    impl Actor for LookupTestActor {
-        type Params = ();
-
-        async fn new(_params: ()) -> Result<Self, anyhow::Error> {
-            Ok(Self)
-        }
-    }
-
     #[async_trait]
     #[crate::forward(LookupTestMessage)]
     impl LookupTestMessageHandler for LookupTestActor {
@@ -2745,18 +2727,9 @@ mod tests {
 
     #[tokio::test]
     async fn test_instance() {
-        #[derive(Debug)]
+        #[derive(Debug, Default, Actor)]
         struct TestActor;
 
-        #[async_trait]
-        impl Actor for TestActor {
-            type Params = ();
-
-            async fn new(_params: ()) -> Result<Self, anyhow::Error> {
-                Ok(Self)
-            }
-        }
-
         #[async_trait]
         impl Handler<(String, PortRef<String>)> for TestActor {
             async fn handle(
@@ -2834,7 +2807,7 @@ mod tests {
     #[ignore = "until trace recording is turned back on"]
     #[test]
     fn test_handler_logging() {
-        #[derive(Debug)]
+        #[derive(Debug, Default, Actor)]
         struct LoggingActor;
 
         impl LoggingActor {
@@ -2845,15 +2818,6 @@ mod tests {
             }
         }
 
-        #[async_trait]
-        impl Actor for LoggingActor {
-            type Params = ();
-
-            async fn new(_params: ()) -> Result<Self, anyhow::Error> {
-                Ok(Self)
-            }
-        }
-
         #[async_trait]
         impl Handler<String> for LoggingActor {
             async fn handle(

hyperactor_macros/Cargo.toml

@@ -30,6 +30,7 @@ anyhow = "1.0.98"
 async-trait = "0.1.86"
 hyperactor = { version = "0.0.0", path = "../hyperactor" }
 serde = { version = "1.0.185", features = ["derive", "rc"] }
+static_assertions = "1.1.0"
 timed_test = { version = "0.0.0", path = "../timed_test" }
 tokio = { version = "1.37.0", features = ["full", "test-util", "tracing"] }
 tracing = { version = "0.1.41", features = ["attributes", "valuable"] }

hyperactor_macros/src/lib.rs

@@ -1789,3 +1789,93 @@ pub fn derive_unbind(input: TokenStream) -> TokenStream {
     };
     TokenStream::from(expand)
 }
+
+/// Derives the `Actor` trait for a struct. By default, generates an implementation
+/// with no params (`type Params = ()` and `async fn new(_params: ()) -> Result<Self, anyhow::Error>`).
+/// This requires that the Actor implements [`Default`].
+///
+/// If the `#[actor(passthrough)]` attribute is specified, generates an implementation
+/// with where the parameter type is `Self`
+/// (`type Params = Self` and `async fn new(instance: Self) -> Result<Self, anyhow::Error>`).
+///
+/// # Examples
+///
+/// Default behavior:
+/// ```
+/// #[derive(Actor, Default)]
+/// struct MyActor(u64);
+/// ```
+///
+/// Generates:
+/// ```ignore
+/// #[async_trait]
+/// impl Actor for MyActor {
+///     type Params = ();
+///
+///     async fn new(_params: ()) -> Result<Self, anyhow::Error> {
+///         Ok(Default::default())
+///     }
+/// }
+/// ```
+///
+/// Passthrough behavior:
+/// ```
+/// #[derive(Actor, Default)]
+/// #[actor(passthrough)]
+/// struct MyActor(u64);
+/// ```
+///
+/// Generates:
+/// ```ignore
+/// #[async_trait]
+/// impl Actor for MyActor {
+///     type Params = Self;
+///
+///     async fn new(instance: Self) -> Result<Self, anyhow::Error> {
+///         Ok(instance)
+///     }
+/// }
+/// ```
+#[proc_macro_derive(Actor, attributes(actor))]
+pub fn derive_actor(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = &input.ident;
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+
+    let is_passthrough = input.attrs.iter().any(|attr| {
+        if attr.path().is_ident("actor") {
+            if let Ok(meta) = attr.parse_args_with(
+                syn::punctuated::Punctuated::<syn::Ident, syn::Token![,]>::parse_terminated,
+            ) {
+                return meta.iter().any(|ident| ident == "passthrough");
+            }
+        }
+        false
+    });
+
+    let expanded = if is_passthrough {
+        quote! {
+            #[hyperactor::async_trait::async_trait]
+            impl #impl_generics hyperactor::Actor for #name #ty_generics #where_clause {
+                type Params = Self;
+
+                async fn new(instance: Self) -> Result<Self, hyperactor::anyhow::Error> {
+                    Ok(instance)
+                }
+            }
+        }
+    } else {
+        quote! {
+            #[hyperactor::async_trait::async_trait]
+            impl #impl_generics hyperactor::Actor for #name #ty_generics #where_clause {
+                type Params = ();
+
+                async fn new(_params: ()) -> Result<Self, hyperactor::anyhow::Error> {
+                    Ok(Default::default())
+                }
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}

hyperactor_macros/tests/basic.rs

@@ -120,3 +120,22 @@ impl GenericArgMessageHandler<usize> for GenericArgActor {
         Ok(())
     }
 }
+
+#[derive(Actor, Default, Debug)]
+struct DefaultActorTest {
+    value: u64,
+}
+
+static_assertions::assert_impl_all!(DefaultActorTest: Actor);
+
+#[derive(Actor, Default, Debug)]
+#[actor(passthrough)]
+struct PassthroughActorTest {
+    value: u64,
+}
+
+static_assertions::assert_impl_all!(PassthroughActorTest: Actor);
+static_assertions::assert_type_eq_all!(
+    <PassthroughActorTest as hyperactor::Actor>::Params,
+    PassthroughActorTest
+);