Fix "... must be defined only once in the type namespace of this module" and NonFixedWidthArray serialisation

.github/workflows/rust.yml

@@ -16,6 +16,8 @@ jobs:
 
     steps:
     - uses: actions/checkout@v2
+    - name: Install glib for testing
+      run: sudo apt-get install -y libglib2.0-dev
     - name: Build
       run: cargo build --verbose
     - name: Run tests

gvariant-macro/src/generate_impl.rs

@@ -1,27 +1,37 @@
-use std::error::Error;
 use std::io::Write;
+use std::{collections::HashSet, error::Error};
 
 use crate::{marker_type, type_parser::GVariantType};
 
-pub(crate) fn generate_types(spec: &GVariantType) -> Result<String, Box<dyn Error>> {
+pub(crate) fn generate_types(
+    spec: &GVariantType,
+    defined_types: &mut HashSet<GVariantType>,
+) -> Result<String, Box<dyn Error>> {
+    if defined_types.contains(spec) {
+        // If we've already defined this type in this scope.  Don't want to
+        // define it again otherwise we get "must be defined only once in the
+        // type namespace of this module" compiler errors:
+        return Ok("".to_owned());
+    }
+    defined_types.insert(spec.clone());
     Ok(match spec {
         GVariantType::Tuple(children) => {
             let mut out = "".to_string();
             for child in children {
-                out += generate_types(child)?.as_ref();
+                out += generate_types(child, defined_types)?.as_ref();
             }
             out += generate_tuple(spec, children)?.as_ref();
             out
         }
         GVariantType::DictItem(children) => {
             let mut out = "".to_string();
-            out += generate_types(&children[0])?.as_ref();
-            out += generate_types(&children[1])?.as_ref();
+            out += generate_types(&children[0], defined_types)?.as_ref();
+            out += generate_types(&children[1], defined_types)?.as_ref();
             out += generate_tuple(spec, children.as_ref())?.as_ref();
             out
         }
-        GVariantType::A(x) => generate_types(x)?,
-        GVariantType::M(x) => generate_types(x)?,
+        GVariantType::A(x) => generate_types(x, defined_types)?,
+        GVariantType::M(x) => generate_types(x, defined_types)?,
 
         // Everything else is a builtin
         _ => "".to_owned(),

gvariant-macro/src/lib.rs

@@ -2,7 +2,7 @@
 
 extern crate proc_macro;
 use proc_macro::TokenStream;
-use std::error::Error;
+use std::{collections::HashSet, error::Error};
 
 mod generate_impl;
 mod type_parser;
@@ -20,7 +20,8 @@ pub fn gv_type(input: TokenStream) -> TokenStream {
 #[proc_macro]
 pub fn define_gv(input: TokenStream) -> TokenStream {
     let typestr = parse_macro_input!(input as LitStr).value();
-    generate_impl::generate_types(&one(typestr.as_ref()).unwrap())
+    let mut defined_types: HashSet<GVariantType> = HashSet::new();
+    generate_impl::generate_types(&one(typestr.as_ref()).unwrap(), &mut defined_types)
         .unwrap()
         .parse()
         .unwrap()

gvariant-macro/src/type_parser.rs

@@ -12,7 +12,7 @@ impl fmt::Display for ParseError {
 }
 impl Error for ParseError {}
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Hash, Eq)]
 pub(crate) enum GVariantType {
     B,
     Y,

gvariant/src/lib.rs

@@ -1629,11 +1629,11 @@ where
         let mut bytes_written = 0;
         let mut offsets = vec![];
         for x in self.into_iter() {
-            bytes_written += x.serialize(f)?;
-            offsets.push(bytes_written);
             let padding = align_offset::<GvT::AlignOf>(bytes_written).to_usize() - bytes_written;
             f.write_all(&b"\0\0\0\0\0\0\0"[..padding])?;
             bytes_written += padding;
+            bytes_written += x.serialize(f)?;
+            offsets.push(bytes_written);
         }
         write_offsets(bytes_written, offsets.as_ref(), f)
     }

gvariant/tests/test.rs

@@ -192,6 +192,25 @@ fn test_complex_types() {
     assert_eq!(t.8, "");
 }
 
+#[test]
+fn test_repeated_types() {
+    let foo = [("hi", 3)];
+    let data = gv!("(a{si}a{si})").serialize_to_vec(&(&foo, &foo));
+    let aligned = copy_to_align(&*data);
+
+    assert_eq!(
+        &data,
+        b"hi\x00\x00\x03\x00\x00\x00\x03\x09\x00\x00hi\x00\x00\x03\x00\x00\x00\x03\x09\x0a"
+    );
+
+    let s = gv!("(a{si}a{si})").cast(aligned.as_ref()).to_tuple();
+    println!("{:?}", s);
+    assert_eq!(s.0, s.1);
+    assert_eq!(s.0.len(), 1);
+    assert_eq!(s.0[0].to_tuple().0, "hi");
+    assert_eq!(*s.0[0].to_tuple().1, 3);
+}
+
 #[test]
 fn test_spec_examples() {
     let data = copy_to_align(b"foo\0\xff\xff\xff\xff\x04");