From 43fb2f8f8e83c0b6e5c4e67b7da7e2f2b329a9d2 Mon Sep 17 00:00:00 2001
From: Yeaseen <yeaseen.arafat96@gmail.com>
Date: Fri, 6 Dec 2024 04:41:56 -0700
Subject: [PATCH] `transpile`: fix previously ignored `enum` usage in compound
 literals (#1185)

* Fixes #1168.

### Modification:
- Suggested changes mentioned in #1168 were added in the
`c2rust-transpile/src/translator/literals.rs` file
- Added a relevant C program in `tests/enums/src/enum_compound.c` file
- Modified `tests/enums/src/test_enums.rs` file to check the correct
outputs

### Testing

The added test case specifically checks for the correct assignment of
enum values in buffer initialization using compound literals. This test
has been integrated into the existing test suite and passed
successfully, confirming the fix.
---
 c2rust-transpile/src/translator/literals.rs |  4 ++++
 tests/enums/src/enum_compound.c             | 13 +++++++++++++
 tests/enums/src/test_enums.rs               | 18 ++++++++++++++++++
 3 files changed, 35 insertions(+)
 create mode 100644 tests/enums/src/enum_compound.c

diff --git a/c2rust-transpile/src/translator/literals.rs b/c2rust-transpile/src/translator/literals.rs
index 3924aaa657..a04dee2e0f 100644
--- a/c2rust-transpile/src/translator/literals.rs
+++ b/c2rust-transpile/src/translator/literals.rs
@@ -254,6 +254,10 @@ impl<'c> Translation<'c> {
                 let id = ids.first().unwrap();
                 self.convert_expr(ctx.used(), *id)
             }
+            CTypeKind::Enum(_) => {
+                let id = ids.first().unwrap();
+                self.convert_expr(ctx.used(), *id)
+            }
             CTypeKind::Vector(CQualTypeId { ctype, .. }, len) => {
                 self.vector_list_initializer(ctx, ids, ctype, len)
             }
diff --git a/tests/enums/src/enum_compound.c b/tests/enums/src/enum_compound.c
new file mode 100644
index 0000000000..370c282c50
--- /dev/null
+++ b/tests/enums/src/enum_compound.c
@@ -0,0 +1,13 @@
+
+typedef enum {
+    B = 2
+} a;
+
+void entry6(const unsigned buffer_size, int buffer[]) {
+  if (buffer_size < 1) {
+    return; 
+  }
+  
+  // Using a compound literal with enum to assign the value
+  buffer[0] = (a) { B };
+}
diff --git a/tests/enums/src/test_enums.rs b/tests/enums/src/test_enums.rs
index 2410ab12f0..b95fe8b95f 100644
--- a/tests/enums/src/test_enums.rs
+++ b/tests/enums/src/test_enums.rs
@@ -7,6 +7,7 @@ use crate::non_canonical_enum_def::{
     hrtimer_restart, rust_abc, HRTIMER_NORESTART, HRTIMER_RESTART,
 };
 use crate::top_enum::{rust_entry4, E as otherE};
+use crate::enum_compound::rust_entry6;
 
 use libc::{c_int, c_uint};
 
@@ -21,6 +22,8 @@ extern "C" {
     fn entry4(_: c_uint, _: *mut c_int);
 
     fn entry5(_: c_uint, _: *mut c_int);
+
+    fn entry6(_: c_uint, _: *mut c_int);
 }
 
 const BUFFER_SIZE: usize = 10;
@@ -28,6 +31,7 @@ const BUFFER_SIZE2: usize = 7;
 const BUFFER_SIZE3: usize = 4;
 const BUFFER_SIZE4: usize = 1;
 const BUFFER_SIZE5: usize = 6;
+const BUFFER_SIZE6: usize = 1;
 
 pub fn test_variants() {
     assert_eq!(A as u32, 0);
@@ -103,3 +107,17 @@ pub fn test_buffer5() {
     assert_eq!(buffer, rust_buffer);
     assert_eq!(buffer, expected_buffer);
 }
+
+pub fn test_buffer6() {
+    let mut buffer = [0; BUFFER_SIZE6];
+    let mut rust_buffer = [0; BUFFER_SIZE6];
+    let expected_buffer = [2];
+
+    unsafe {
+        entry6(BUFFER_SIZE6 as u32, buffer.as_mut_ptr());
+        rust_entry6(BUFFER_SIZE6 as u32, rust_buffer.as_mut_ptr());
+    }
+
+    assert_eq!(buffer, rust_buffer);
+    assert_eq!(buffer, expected_buffer);
+}