Merge pull request #3 from kampffrosch94/switcharoo

Add proxy attribute

Author: kampffrosch94

quicksilver/tests/it/main.rs

@@ -1,6 +1,7 @@
 mod basic;
 mod cenum;
 mod containers;
+mod proxy;
 mod regression;
 mod rust_enum;
 mod tilemap;

quicksilver/tests/it/proxy.rs

@@ -0,0 +1,128 @@
+use std::collections::HashMap;
+
+use quicksilver::{Quicksilver, json::from_json, reflections_ref::reflect_ref};
+
+#[derive(PartialEq, Debug)]
+struct Entity {
+    id: u32,
+    generation: u32,
+}
+
+#[derive(PartialEq, Debug)]
+#[repr(transparent)]
+struct EntityWrapper(Entity);
+
+impl ::quicksilver::Quicksilver for EntityWrapper {
+    const MIRROR: ::quicksilver::Type = ::quicksilver::Type::Struct(&::quicksilver::Struct {
+        name: "EntityWrapper",
+        size: ::std::mem::size_of::<Self>(),
+        align: align_of::<Self>(),
+        fields: &[
+            ::quicksilver::Field {
+                name: "id",
+                ty: u32::MIRROR,
+                offset: ::std::mem::offset_of!(Self, 0.id),
+            },
+            ::quicksilver::Field {
+                name: "generation",
+                ty: u32::MIRROR,
+                offset: ::std::mem::offset_of!(Self, 0.generation),
+            },
+        ],
+    });
+}
+
+#[derive(PartialEq, Debug, Quicksilver)]
+struct Container {
+    #[quicksilver(proxy(Entity, EntityWrapper))]
+    leader: Entity,
+    #[quicksilver(proxy(Entity, EntityWrapper))]
+    followers: Vec<Entity>,
+    #[quicksilver(proxy(Entity, EntityWrapper))]
+    mappings: HashMap<u32, Entity>,
+}
+
+#[test]
+fn subst_roundtrip() {
+    let mut val = Container {
+        leader: Entity {
+            id: 1,
+            generation: 1,
+        },
+        followers: vec![
+            Entity {
+                id: 2,
+                generation: 1,
+            },
+            Entity {
+                id: 3,
+                generation: 701,
+            },
+            Entity {
+                id: 4,
+                generation: 1,
+            },
+        ],
+        mappings: vec![(
+            23,
+            Entity {
+                id: 23,
+                generation: 12,
+            },
+        )]
+        .into_iter()
+        .collect(),
+    };
+    let s = reflect_ref(&mut val).to_json();
+    println!("{}", &s);
+    let val2 = from_json::<Container>(&s);
+    dbg!(&val2);
+    assert_eq!(val, val2);
+}
+
+#[derive(PartialEq, Debug, Quicksilver)]
+enum ContainerEnum {
+    One(#[quicksilver(proxy(Entity, EntityWrapper))] Entity),
+    More {
+        #[quicksilver(proxy(Entity, EntityWrapper))]
+        followers: Vec<Entity>,
+    },
+}
+
+#[test]
+fn subst_roundtrip_enum_one() {
+    let mut val = ContainerEnum::One(Entity {
+        id: 1,
+        generation: 1,
+    });
+    let s = reflect_ref(&mut val).to_json();
+    println!("{}", &s);
+    let val2 = from_json::<ContainerEnum>(&s);
+    dbg!(&val2);
+    assert_eq!(val, val2);
+}
+
+#[test]
+fn subst_roundtrip_enum_more() {
+    let mut val = ContainerEnum::More {
+        followers: vec![
+            Entity {
+                id: 2,
+                generation: 1,
+            },
+            Entity {
+                id: 3,
+                generation: 701,
+            },
+            Entity {
+                id: 4,
+                generation: 1,
+            },
+        ],
+    };
+    let s = reflect_ref(&mut val).to_json();
+    println!("{}", &s);
+    let val2 = from_json::<ContainerEnum>(&s);
+    dbg!(&val2);
+    assert_eq!(val, val2);
+}

quicksilver_derive/src/lib.rs

@@ -220,20 +220,47 @@ fn parse_fields(input: TokenStream) -> Result<Vec<Field>, MacroError> {
 
 fn parse_field(mut buffer: &[TokenTree]) -> Result<Field, MacroError> {
     let mut skip = false;
+    let mut substitution = None;
     if matches!(&buffer[0], TT::Punct(c) if c.as_char() == '#') {
         if let TT::Group(attribute_group) = &buffer[1] {
             for a in chunked(attribute_group.stream(), 2) {
-                let [name, group] = &a[..] else {
+                let [name, group_tt] = &a[..] else {
                     unreachable!()
                 };
                 if matches!(name, TT::Ident(s) if s.to_string() == "quicksilver") {
-                    let TT::Group(group) = group else {
-                        panic!("Expected group.")
+                    let TT::Group(group) = group_tt else {
+                        error_single!(group_tt, "Expected TokenTree::Group.")
                     };
-                    for attr in group.stream() {
-                        if matches!(attr, TT::Ident(s) if s.to_string() == "skip") {
+                    // dbg!(&group);
+                    let mut it = group.stream().into_iter();
+                    match (it.next(), it.next()) {
+                        (Some(TT::Ident(s)), None) if s.to_string() == "skip" => {
                             skip = true;
                         }
+                        (Some(TT::Ident(p)), Some(ref proxy_tt @ TT::Group(ref subst_group)))
+                            if p.to_string() == "proxy" =>
+                        {
+                            let mut it = subst_group.stream().into_iter();
+                            match (it.next(), it.next(), it.next(), it.next()) {
+                                (
+                                    Some(TT::Ident(from)),
+                                    Some(TT::Punct(c)),
+                                    Some(TT::Ident(to)),
+                                    None,
+                                ) if c.as_char() == ',' => {
+                                    substitution = Some((from.to_string(), to.to_string()));
+                                }
+                                _ => {
+                                    error_single!(
+                                        &proxy_tt,
+                                        "Wrong arguments for proxy atttribute."
+                                    )
+                                }
+                            }
+                        }
+                        _ => {
+                            error_single!(group_tt, "Unknown attribute");
+                        }
                     }
                 }
             }
@@ -243,15 +270,15 @@ fn parse_field(mut buffer: &[TokenTree]) -> Result<Field, MacroError> {
 
     let mut iter = buffer.iter();
 
-    match (iter.next(), iter.next(), iter.next()) {
+    let mut r = match (iter.next(), iter.next(), iter.next()) {
         (Some(TT::Ident(ty)), None, None) => {
             let name = None;
             let mirror = parse_mirror(&buffer, &ty.to_string(), skip)?;
-            Ok(Field {
+            Field {
                 name,
                 mirror,
                 ty: ty.to_string(),
-            })
+            }
         }
         (Some(TT::Ident(name)), Some(TT::Punct(colon)), Some(TT::Ident(ty)))
             if colon.as_char() == ':' =>
@@ -264,7 +291,7 @@ fn parse_field(mut buffer: &[TokenTree]) -> Result<Field, MacroError> {
                 .map(|it| it.to_string())
                 .collect::<Vec<_>>()
                 .join("");
-            Ok(Field { name, mirror, ty })
+            Field { name, mirror, ty }
         }
         (Some(TT::Ident(ty)), Some(TT::Punct(stair)), Some(_)) if stair.as_char() == '<' => {
             let name = None;
@@ -274,15 +301,24 @@ fn parse_field(mut buffer: &[TokenTree]) -> Result<Field, MacroError> {
                 .map(|it| it.to_string())
                 .collect::<Vec<_>>()
                 .join("");
-            Ok(Field { name, mirror, ty })
+            Field { name, mirror, ty }
         }
         _ => {
             error!(
                 &[buffer[0].clone(), buffer.last().unwrap().clone()],
                 "Quicksilver can't parse this."
             )
         }
+    };
+
+    if let Some((from, to)) = substitution {
+        if let Some(ref mut name) = r.name {
+            *name = name.replace(&from, &to);
+        }
+        r.mirror = r.mirror.replace(&from, &to);
     }
+
+    Ok(r)
 }
 
 fn parse_mirror(buffer: &[TokenTree], ty: &str, skip: bool) -> Result<String, MacroError> {