Handle `Option<[u8; 32]>`, mapping it same as `Option<&[u8; 32]>`

diff --git a/c-bindings-gen/src/types.rs b/c-bindings-gen/src/types.rs
index 4e7ac8ae5c1f27312692649ed1eee01043d56bfd..21b0458ceae6d5bf24b7cb76c7bb44bdbdca3366 100644 (file)
--- a/c-bindings-gen/src/types.rs
+++ b/c-bindings-gen/src/types.rs
@@ -1296,6 +1296,22 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                        assert!(args.next().is_none());
                        match inner {
                                syn::Type::Reference(_) => true,
+                               syn::Type::Array(a) => {
+                                       if let syn::Expr::Lit(l) = &a.len {
+                                               if let syn::Lit::Int(i) = &l.lit {
+                                                       if i.base10_digits().parse::<usize>().unwrap() >= 32 {
+                                                               let mut buf = Vec::new();
+                                                               self.write_rust_type(&mut buf, generics, &a.elem);
+                                                               let ty = String::from_utf8(buf).unwrap();
+                                                               ty == "u8"
+                                                       } else {
+                                                               // Blindly assume that if we're trying to create an empty value for an
+                                                               // array < 32 entries that all-0s may be a valid state.
+                                                               unimplemented!();
+                                                       }
+                                               } else { unimplemented!(); }
+                                       } else { unimplemented!(); }
+                               },
                                syn::Type::Path(p) => {
                                        if let Some(resolved) = self.maybe_resolve_path(&p.path, generics) {
                                                if self.c_type_has_inner_from_path(&resolved) { return true; }
@@ -2610,8 +2626,15 @@ impl<'a, 'c: 'a> TypeResolver<'a, 'c> {
                                                if !self.is_primitive(&resolved) { return false; }
                                                if let syn::Expr::Lit(syn::ExprLit { lit: syn::Lit::Int(len), .. }) = &a.len {
                                                        if self.c_type_from_path(&format!("[{}; {}]", resolved, len.base10_digits()), is_ref, ptr_for_ref).is_none() { return false; }
-                                                       write!(w, "_{}{}", resolved, len.base10_digits()).unwrap();
-                                                       write!(mangled_type, "_{}{}", resolved, len.base10_digits()).unwrap();
+                                                       if in_type || args.len() != 1 {
+                                                               write!(w, "_{}{}", resolved, len.base10_digits()).unwrap();
+                                                               write!(mangled_type, "_{}{}", resolved, len.base10_digits()).unwrap();
+                                                       } else {
+                                                               let arrty = format!("[{}; {}]", resolved, len.base10_digits());
+                                                               let realty = self.c_type_from_path(&arrty, is_ref, ptr_for_ref).unwrap_or(&arrty);
+                                                               write!(w, "{}", realty).unwrap();
+                                                               write!(mangled_type, "{}", realty).unwrap();
+                                                       }
                                                } else { return false; }
                                        } else { return false; }
                                },