transpile: Minor refactor to struct functions

Author: Rua

c2rust-transpile/src/translator/literals.rs

@@ -290,21 +290,7 @@ impl<'c> Translation<'c> {
                 }
             }
             CTypeKind::Struct(struct_id) => {
-                let mut literal = self.convert_struct_literal(ctx, struct_id, ids.as_ref());
-                if self.ast_context.has_inner_struct_decl(struct_id) {
-                    // If the structure is split into an outer/inner,
-                    // wrap the inner initializer using the outer structure
-                    let outer_name = self
-                        .type_converter
-                        .borrow()
-                        .resolve_decl_name(struct_id)
-                        .unwrap();
-
-                    let outer_path = mk().path_expr(vec![outer_name]);
-                    literal = literal
-                        .map(|lit_ws| lit_ws.map(|lit| mk().call_expr(outer_path, vec![lit])));
-                };
-                literal
+                self.convert_struct_literal(ctx, struct_id, ids.as_ref())
             }
             CTypeKind::Union(union_id) => {
                 self.convert_union_literal(ctx, union_id, ids.as_ref(), ty, opt_union_field_id)

c2rust-transpile/src/translator/mod.rs

@@ -4763,16 +4763,13 @@ impl<'c> Translation<'c> {
                 fields: Some(ref fields),
                 platform_byte_size,
                 ..
-            } => {
-                let name = self.resolve_decl_inner_name(name_decl_id);
-                self.convert_struct_zero_initializer(
-                    name,
-                    decl_id,
-                    fields,
-                    platform_byte_size,
-                    is_static,
-                )?
-            }
+            } => self.convert_struct_zero_initializer(
+                decl_id,
+                name_decl_id,
+                fields,
+                platform_byte_size,
+                is_static,
+            )?,
 
             CDeclKind::Struct { fields: None, .. } => {
                 return Err(TranslationError::generic(

c2rust-transpile/src/translator/structs.rs

@@ -456,65 +456,77 @@ impl<'a> Translation<'a> {
         let fields = fields
             .into_iter()
             .collect::<WithStmts<Vec<syn::FieldValue>>>();
-        let struct_expr = fields.map(|fields| mk().struct_expr(name.as_str(), fields));
-
-        if bitfield_inits.is_empty() {
-            return Ok(struct_expr);
-        }
-
-        struct_expr.and_then(|struct_expr| {
-            let local_pat = mk().mutbl().ident_pat("init");
-            let local_variable = Box::new(mk().local(local_pat, None, Some(struct_expr)));
-
-            let mut is_unsafe = false;
-            let mut stmts = vec![mk().local_stmt(local_variable)];
+        let mut val = fields.map(|fields| mk().struct_expr(name.as_str(), fields));
+
+        if !bitfield_inits.is_empty() {
+            val = val.and_then(|val| -> TranslationResult<_> {
+                let local_pat = mk().mutbl().ident_pat("init");
+                let local_variable = Box::new(mk().local(local_pat, None, Some(val)));
+
+                let mut is_unsafe = false;
+                let mut stmts = vec![mk().local_stmt(local_variable)];
+
+                // Now we must use the bitfield methods to initialize bitfields
+                for (field_name, val) in bitfield_inits {
+                    let field_name_setter = format!("set_{}", field_name);
+                    let struct_ident = mk().ident_expr("init");
+                    is_unsafe |= val.is_unsafe();
+                    let val = val
+                        .to_pure_expr()
+                        .expect("Expected no statements in bitfield initializer");
+                    let expr = mk().method_call_expr(struct_ident, field_name_setter, vec![val]);
+
+                    stmts.push(mk().semi_stmt(expr));
+                }
 
-            // Now we must use the bitfield methods to initialize bitfields
-            for (field_name, val) in bitfield_inits {
-                let field_name_setter = format!("set_{}", field_name);
-                let struct_ident = mk().ident_expr("init");
-                is_unsafe |= val.is_unsafe();
-                let val = val
-                    .to_pure_expr()
-                    .expect("Expected no statements in bitfield initializer");
-                let expr = mk().method_call_expr(struct_ident, field_name_setter, vec![val]);
+                stmts.push(mk().expr_stmt(mk().ident_expr("init")));
 
-                stmts.push(mk().semi_stmt(expr));
-            }
+                let val = mk().block_expr(mk().block(stmts));
 
-            let struct_ident = mk().ident_expr("init");
+                if is_unsafe {
+                    Ok(WithStmts::new_unsafe_val(val))
+                } else {
+                    Ok(WithStmts::new_val(val))
+                }
+            })?;
+        }
 
-            stmts.push(mk().expr_stmt(struct_ident));
+        // If the structure is split into an outer/inner,
+        // wrap the inner initializer using the outer structure
+        if self.ast_context.has_inner_struct_decl(struct_id) {
+            let outer_name = self
+                .type_converter
+                .borrow()
+                .resolve_decl_name(struct_id)
+                .unwrap();
 
-            let val = mk().block_expr(mk().block(stmts));
+            let outer_path = mk().path_expr(vec![outer_name]);
+            val = val.map(|val| mk().call_expr(outer_path, vec![val]));
+        }
 
-            if is_unsafe {
-                Ok(WithStmts::new_unsafe_val(val))
-            } else {
-                Ok(WithStmts::new_val(val))
-            }
-        })
+        Ok(val)
     }
 
     /// This method handles zero-initializing bitfield structs including bitfields
     /// & padding fields
     pub fn convert_struct_zero_initializer(
         &self,
-        name: String,
-        struct_id: CRecordId,
+        decl_id: CRecordId,
+        name_decl_id: CDeclId,
         field_ids: &[CDeclId],
         platform_byte_size: u64,
         is_static: bool,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
-        let reorganized_fields = self.get_field_types(struct_id, field_ids, platform_byte_size)?;
+        let name = self.resolve_decl_inner_name(name_decl_id);
+        let reorganized_fields = self.get_field_types(decl_id, field_ids, platform_byte_size)?;
         let mut fields = Vec::with_capacity(reorganized_fields.len());
 
         let mut padding_count = 0;
         let mut next_padding_field = || {
             let field_name = self
                 .type_converter
                 .borrow_mut()
-                .declare_padding(struct_id, padding_count);
+                .declare_padding(decl_id, padding_count);
             padding_count += 1;
             field_name
         };