Handle QSelf of TypePath in actor macro

riker-macros/src/lib.rs

@@ -5,8 +5,11 @@ use quote::quote;
 use syn::parse::{Parse, ParseStream, Result};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::token::{Colon2, Comma};
-use syn::{DeriveInput, Generics, PathSegment, TypePath};
+use syn::token::Comma;
+use syn::{
+    DeriveInput, Generics, QSelf, Type, TypeArray, TypeGroup, TypeParen, TypePath, TypePtr,
+    TypeReference, TypeSlice, TypeTuple,
+};
 
 struct MsgTypes {
     types: Vec<MsgVariant>,
@@ -43,32 +46,60 @@ impl Parse for MsgTypes {
             types: vars
                 .into_iter()
                 .map(|t| MsgVariant {
-                    name: get_name(&t.path.segments),
+                    name: Ident::new(&get_path_name(&t), t.span()),
                     mtype: t,
                 })
                 .collect::<Vec<_>>(),
         })
     }
 }
 
-fn get_name(segments: &Punctuated<PathSegment, Colon2>) -> Ident {
-    let vname = segments
-        .iter()
-        .map(|seg| {
-            let ident = format!("{}", seg.ident);
-            ident
-                .split('_')
-                .map(|s| {
-                    let mut s = s.to_string();
-                    if let Some(c) = s.get_mut(0..1) {
-                        c.make_ascii_uppercase();
-                    }
-                    s
-                })
-                .collect::<String>()
-        })
-        .collect::<String>();
-    syn::Ident::new(&vname, segments.span())
+fn get_type_name(ty: &Type) -> String {
+    match ty {
+        Type::Path(path) => get_path_name(path),
+        Type::Array(TypeArray { elem, .. })
+        | Type::Group(TypeGroup { elem, .. })
+        | Type::Paren(TypeParen { elem, .. })
+        | Type::Ptr(TypePtr { elem, .. })
+        | Type::Reference(TypeReference { elem, .. })
+        | Type::Slice(TypeSlice { elem, .. }) => get_type_name(elem.as_ref()),
+        Type::Tuple(TypeTuple { elems, .. }) => {
+            elems.iter().fold(String::new(), |mut acc, curr| {
+                acc.push_str(&get_type_name(&curr));
+                acc
+            })
+        }
+        _ => unreachable!(),
+    }
+}
+
+fn get_path_name(type_path: &TypePath) -> String {
+    let mut vname = if let Some(QSelf { ty, .. }) = &type_path.qself {
+        get_type_name(ty.as_ref())
+    } else {
+        String::new()
+    };
+    vname.push_str(
+        &type_path
+            .path
+            .segments
+            .iter()
+            .map(|seg| {
+                let ident = format!("{}", seg.ident);
+                ident
+                    .split('_')
+                    .map(|s| {
+                        let mut s = s.to_string();
+                        if let Some(c) = s.get_mut(0..1) {
+                            c.make_ascii_uppercase();
+                        }
+                        s
+                    })
+                    .collect::<String>()
+            })
+            .collect::<String>(),
+    );
+    vname
 }
 
 #[proc_macro_attribute]

riker-macros/tests/macro.rs

@@ -149,17 +149,27 @@ fn run_generic_message_actor() {
     }
 }
 
+pub trait TestTrait {
+    type TraitType;
+}
+
 mod test_mod {
+    use super::TestTrait;
+
     #[derive(Clone, Debug)]
     pub struct GenericMessage<T> {
         pub inner: T,
     }
 
     #[derive(Clone, Debug)]
     pub struct Message;
+
+    impl TestTrait for Message {
+        type TraitType = String;
+    }
 }
 
-#[actor(test_mod::GenericMessage<String>, test_mod::Message)]
+#[actor(test_mod::GenericMessage<String>, <test_mod::Message as TestTrait>::TraitType)]
 #[derive(Clone, Default)]
 struct PathMsgActor;
 
@@ -189,13 +199,13 @@ impl Receive<test_mod::GenericMessage<String>> for PathMsgActor {
     }
 }
 
-impl Receive<test_mod::Message> for PathMsgActor {
+impl Receive<<test_mod::Message as TestTrait>::TraitType> for PathMsgActor {
     type Msg = PathMsgActorMsg;
 
     fn receive(
         &mut self,
         _ctx: &Context<Self::Msg>,
-        _msg: test_mod::Message,
+        _msg: <test_mod::Message as TestTrait>::TraitType,
         _sender: Option<BasicActorRef>,
     ) {
         println!("message");
@@ -208,7 +218,7 @@ fn run_path_message_actor() {
 
     let act = sys.actor_of::<PathMsgActor>("act").unwrap();
 
-    let msg = PathMsgActorMsg::TestModMessage(test_mod::Message);
+    let msg = PathMsgActorMsg::TestModMessageTestTraitTraitType(String::from("test"));
     act.tell(msg, None);
 
     let generic_msg = PathMsgActorMsg::TestModGenericMessage(test_mod::GenericMessage {