Transfer the packed attribute on unions to repr(packed)

Closes: #346

Author: chrysn

c2rust-transpile/src/c_ast/conversion.rs

@@ -1946,6 +1946,8 @@ impl ConversionContext {
                     let name = expect_opt_str(&node.extras[0]).unwrap().map(str::to_string);
                     let has_def = from_value(node.extras[1].clone())
                         .expect("Expected has_def flag on struct");
+                    let attrs = from_value::<Vec<Value>>(node.extras[2].clone())
+                        .expect("Expected attribute array on record");
                     let fields: Option<Vec<CDeclId>> = if has_def {
                         Some(
                             node.children
@@ -1962,7 +1964,18 @@ impl ConversionContext {
                         None
                     };
 
-                    let record = CDeclKind::Union { name, fields };
+                    let mut is_packed = false;
+                    for attr in attrs {
+                        match from_value::<String>(attr.clone())
+                            .expect("Records attributes should be strings")
+                            .as_str()
+                        {
+                            "packed" => is_packed = true,
+                            _ => {}
+                        }
+                    }
+
+                    let record = CDeclKind::Union { name, fields, is_packed };
 
                     self.add_decl(new_id, located(node, record));
                     self.processed_nodes.insert(new_id, RECORD_DECL);

c2rust-transpile/src/c_ast/mod.rs

@@ -933,6 +933,7 @@ pub enum CDeclKind {
     Union {
         name: Option<String>,
         fields: Option<Vec<CFieldId>>,
+        is_packed: bool,
     },
 
     // Field

c2rust-transpile/src/translator/mod.rs

@@ -1614,6 +1614,7 @@ impl<'c> Translation<'c> {
 
             CDeclKind::Union {
                 fields: Some(ref fields),
+                is_packed,
                 ..
             } => {
                 let name = self
@@ -1642,21 +1643,26 @@ impl<'c> Translation<'c> {
                     }
                 }
 
+                let mut repr = vec!["C"];
+                if is_packed {
+                    repr.push("packed");
+                }
+
                 Ok(if field_syns.is_empty() {
                     // Empty unions are a GNU extension, but Rust doesn't allow empty unions.
                     ConvertedDecl::Item(
                         mk().span(s)
                             .pub_()
                             .call_attr("derive", vec!["Copy", "Clone"])
-                            .call_attr("repr", vec!["C"])
+                            .call_attr("repr", repr)
                             .struct_item(name, vec![], false),
                     )
                 } else {
                     ConvertedDecl::Item(
                         mk().span(s)
                             .pub_()
                             .call_attr("derive", vec!["Copy", "Clone"])
-                            .call_attr("repr", vec!["C"])
+                            .call_attr("repr", repr)
                             .union_item(name, field_syns),
                     )
                 })