transpile: Pass override_ty to init lists and their elements

Author: Rua

c2rust-transpile/src/translator/literals.rs

@@ -223,11 +223,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)?.try_map(|x| {
+                    let val =
+                        self.convert_expr(ctx.used(), id, Some(CQualTypeId::new(element_ty)))?;
+                    val.try_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
@@ -262,7 +264,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 =
@@ -282,7 +284,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) => {
@@ -291,7 +293,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 }`.
@@ -307,7 +309,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<_>>>()?
@@ -326,7 +328,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

@@ -3414,7 +3414,7 @@ impl<'c> Translation<'c> {
             CompoundLiteral(qty, val) => self.convert_compound_literal(ctx, qty, val, override_ty),
 
             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

@@ -57,8 +57,8 @@ pub unsafe extern "C" fn entry() {
     let mut int_zero: [::core::ffi::c_int; 0] = [0; 0];
     let mut int_too_short: [::core::ffi::c_int; 16] = [0 as ::core::ffi::c_int; 16];
     int_too_short[15 as ::core::ffi::c_int as usize] += 9 as ::core::ffi::c_int;
-    let mut override_ty: [int_t; 1] = [1 as ::core::ffi::c_int];
-    let mut override_ty_neg: [int_t; 1] = [-1 as ::core::ffi::c_int];
+    let mut override_ty: [int_t; 1] = [1 as int_t];
+    let mut override_ty_neg: [int_t; 1] = [-1 as int_t];
     let mut struct_init_too_short: [C2Rust_Unnamed_0; 1] = [C2Rust_Unnamed_0 {
         x: ::core::ptr::null_mut::<::core::ffi::c_char>(),
         y: 0,

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

@@ -57,8 +57,8 @@ pub unsafe extern "C" fn entry() {
     let mut int_zero: [::core::ffi::c_int; 0] = [0; 0];
     let mut int_too_short: [::core::ffi::c_int; 16] = [0 as ::core::ffi::c_int; 16];
     int_too_short[15 as ::core::ffi::c_int as usize] += 9 as ::core::ffi::c_int;
-    let mut override_ty: [int_t; 1] = [1 as ::core::ffi::c_int];
-    let mut override_ty_neg: [int_t; 1] = [-1 as ::core::ffi::c_int];
+    let mut override_ty: [int_t; 1] = [1 as int_t];
+    let mut override_ty_neg: [int_t; 1] = [-1 as int_t];
     let mut struct_init_too_short: [C2Rust_Unnamed_0; 1] = [C2Rust_Unnamed_0 {
         x: ::core::ptr::null_mut::<::core::ffi::c_char>(),
         y: 0,