transpile: Pass override_ty to init lists and their elements

Author: Rua

c2rust-transpile/src/translator/literals.rs

@@ -168,11 +168,13 @@ impl<'c> Translation<'c> {
         opt_union_field_id: Option<CFieldId>,
     ) -> TranslationResult<WithStmts<Box<Expr>>> {
         match self.ast_context.resolve_type(ty.ctype).kind {
-            CTypeKind::ConstantArray(ty, n) => {
+            CTypeKind::ConstantArray(element_ty, n) => {
                 // Convert all of the provided initializer values
 
                 let to_array_element = |id: CExprId| -> TranslationResult<_> {
-                    self.convert_expr(ctx.used(), id, None)?.result_map(|x| {
+                    let val =
+                        self.convert_expr(ctx.used(), id, Some(CQualTypeId::new(element_ty)))?;
+                    val.result_map(|x| {
                         // Array literals require all of their elements to be
                         // the correct type; they will not use implicit casts to
                         // change mut to const. This becomes a problem when an
@@ -207,7 +209,7 @@ impl<'c> Translation<'c> {
                 // * the element type of the array being `CTypeKind::Char` (w/o this, `array_of_arrays` is included)
                 // * the expr kind being a string literal (`CExprKind::Literal` of a `CLiteral::String`).
                 let is_string_literal = |id: CExprId| {
-                    let ty_kind = &self.ast_context.resolve_type(ty).kind;
+                    let ty_kind = &self.ast_context.resolve_type(element_ty).kind;
                     let expr_kind = &self.ast_context.index(id).kind;
                     let is_char_array = matches!(*ty_kind, CTypeKind::Char);
                     let is_str_literal =
@@ -227,7 +229,7 @@ impl<'c> Translation<'c> {
                         // This was likely a C array of the form `int x[16] = {}`.
                         // We'll emit that as [0; 16].
                         let len = mk().lit_expr(mk().int_unsuffixed_lit(n as u128));
-                        let zeroed = self.implicit_default_expr(ctx, ty)?;
+                        let zeroed = self.implicit_default_expr(ctx, element_ty)?;
                         Ok(zeroed.map(|default_value| mk().repeat_expr(default_value, len)))
                     }
                     &[single] if is_string_literal(single) => {
@@ -236,7 +238,7 @@ impl<'c> Translation<'c> {
                         // * `ptr_extra_braces`
                         // * `array_of_ptrs`
                         // * `array_of_arrays`
-                        self.convert_expr(ctx.used(), single, None)
+                        self.convert_expr(ctx.used(), single, Some(ty))
                     }
                     &[single] if is_zero_literal(single) && n > 1 => {
                         // This was likely a C array of the form `int x[16] = { 0 }`.
@@ -252,7 +254,7 @@ impl<'c> Translation<'c> {
                             .map(to_array_element)
                             .chain(
                                 // Pad out the array literal with default values to the desired size
-                                iter::repeat(self.implicit_default_expr(ctx, ty))
+                                iter::repeat(self.implicit_default_expr(ctx, element_ty))
                                     .take(n - ids.len()),
                             )
                             .collect::<TranslationResult<WithStmts<_>>>()?
@@ -271,7 +273,7 @@ impl<'c> Translation<'c> {
             }
             ref kind if kind.is_scalar() => {
                 if let Some(&first) = ids.first() {
-                    self.convert_expr(ctx.used(), first, None)
+                    self.convert_expr(ctx.used(), first, Some(ty))
                 } else {
                     self.implicit_default_expr(ctx.used(), ty.ctype)
                 }

c2rust-transpile/src/translator/mod.rs

@@ -3932,7 +3932,7 @@ impl<'c> Translation<'c> {
             }
 
             InitList(ty, ref ids, opt_union_field_id, _) => {
-                self.convert_init_list(ctx, ty, ids, opt_union_field_id)
+                self.convert_init_list(ctx, override_ty.unwrap_or(ty), ids, opt_union_field_id)
             }
 
             ImplicitValueInit(ty) => self.implicit_default_expr(ctx, ty.ctype),

c2rust-transpile/tests/snapshots/snapshots__transpile@arrays.c.2021.snap

@@ -71,8 +71,7 @@ pub unsafe extern "C" fn entry() {
         'e' as i32 as ::core::ffi::c_char,
         'f' as i32 as ::core::ffi::c_char,
     ];
-    let mut char_with_ints: [::core::ffi::c_char; 2] =
-        [1 as ::core::ffi::c_int as ::core::ffi::c_char, 0];
+    let mut char_with_ints: [::core::ffi::c_char; 2] = [1 as ::core::ffi::c_char, 0];
     let mut char_with_init: [::core::ffi::c_char; 5] =
         ::core::mem::transmute::<[u8; 5], [::core::ffi::c_char; 5]>(*b"abcd\0");
     let mut char_too_long: [::core::ffi::c_char; 3] =

c2rust-transpile/tests/snapshots/snapshots__transpile@arrays.c.2024.snap

@@ -71,8 +71,7 @@ pub unsafe extern "C" fn entry() {
         'e' as i32 as ::core::ffi::c_char,
         'f' as i32 as ::core::ffi::c_char,
     ];
-    let mut char_with_ints: [::core::ffi::c_char; 2] =
-        [1 as ::core::ffi::c_int as ::core::ffi::c_char, 0];
+    let mut char_with_ints: [::core::ffi::c_char; 2] = [1 as ::core::ffi::c_char, 0];
     let mut char_with_init: [::core::ffi::c_char; 5] =
         ::core::mem::transmute::<[u8; 5], [::core::ffi::c_char; 5]>(*b"abcd\0");
     let mut char_too_long: [::core::ffi::c_char; 3] =