Add tests for array literal pointer semantics

Add regression tests that verify pointer and decay semantics of array
compound literals. The tests cover decay during initialization, passing
array literals to functions that expect pointer arguments, pointer-typed
ternary expressions involving literal branches, and correctness for
char[] and short[] literals in simple computations.

These tests confirm the behavior introduced by the refined compound
literal semantics implemented in the preceding commit.

Author: lorettayao

src/parser.c

@@ -47,8 +47,7 @@ void parse_array_init(var_t *var,
                       bool emit_code);
 void parse_array_compound_literal(var_t *var,
                                   block_t *parent,
-                                  basic_block_t **bb,
-                                  bool emit_code);
+                                  basic_block_t **bb);
 
 label_t *find_label(char *name)
 {
@@ -1335,8 +1334,7 @@ void parse_array_init(var_t *var,
 
 void parse_array_compound_literal(var_t *var,
                                   block_t *parent,
-                                  basic_block_t **bb,
-                                  bool emit_code)
+                                  basic_block_t **bb)
 {
     int elem_size = var->type->size;
     int count = 0;
@@ -1349,16 +1347,16 @@ void parse_array_compound_literal(var_t *var,
             var_t *value = opstack_pop();
             if (count == 0)
                 var->init_val = value->init_val;
-            if (emit_code) {
-                var_t target = {0};
-                target.type = var->type;
-                target.ptr_level = 0;
-                var_t *store_val = resize_var(parent, bb, value, &target);
-                var_t *elem_addr =
-                    compute_element_address(parent, bb, var, count, elem_size);
-                add_insn(parent, *bb, OP_write, NULL, elem_addr, store_val,
-                         elem_size, NULL);
-            }
+
+            var_t target = {0};
+            target.type = var->type;
+            target.ptr_level = 0;
+            var_t *store_val = resize_var(parent, bb, value, &target);
+            var_t *elem_addr =
+                compute_element_address(parent, bb, var, count, elem_size);
+            add_insn(parent, *bb, OP_write, NULL, elem_addr, store_val,
+                     elem_size, NULL);
+
             count++;
             if (!lex_accept(T_comma))
                 break;
@@ -1385,7 +1383,11 @@ bool is_pointer_like_value(var_t *var)
     return var && (var->ptr_level || var->array_size ||
                    (var->type && var->type->ptr_level > 0));
 }
-
+/* Lower a compiler-emitted array literal placeholder (".tN" vars holding
+ * compound literals) into a scalar temporary when later IR expects a plain
+ * value instead of addressable storage. This keeps SSA joins uniform when
+ * only one branch originates from an array literal.
+ */
 var_t *scalarize_array_literal(block_t *parent,
                                basic_block_t **bb,
                                var_t *array_var,
@@ -1394,20 +1396,30 @@ var_t *scalarize_array_literal(block_t *parent,
     if (!is_array_literal_placeholder(array_var))
         return array_var;
 
+    /* Array literal placeholders carry the literal's natural type; default to
+     * int when the parser left the type unset.
+     */
     type_t *literal_type = array_var->type ? array_var->type : TY_int;
     int literal_size = literal_type->size;
     if (literal_size <= 0)
         literal_size = TY_int->size;
 
+    /* A caller-provided hint (e.g., assignment target) dictates the result
+     * type when available so we reuse wider/narrower scalar destinations.
+     */
     type_t *result_type = hint_type ? hint_type : literal_type;
     if (!result_type)
         result_type = TY_int;
 
+    /* Create a new scalar temporary, giving it a unique name and copying over
+     * the literal data so downstream code can treat it like a normal value.
+     */
     var_t *scalar = require_typed_var(parent, result_type);
     scalar->ptr_level = 0;
     gen_name_to(scalar->var_name);
     scalar->init_val = array_var->init_val;
 
+    /* Materialize the literal data into the scalar temporary via an OP_read. */
     add_insn(parent, *bb, OP_read, scalar, array_var, NULL, literal_size, NULL);
 
     return scalar;
@@ -2159,7 +2171,7 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
                 compound_var->array_size = 0;
                 add_insn(parent, *bb, OP_allocat, compound_var, NULL, NULL, 0,
                          NULL);
-                parse_array_compound_literal(compound_var, parent, bb, true);
+                parse_array_compound_literal(compound_var, parent, bb);
 
                 if (compound_var->array_size == 0) {
                     compound_var->init_val = 0;
@@ -3628,10 +3640,19 @@ void read_ternary_operation(block_t *parent, basic_block_t **bb)
     bool true_ptr_like = is_pointer_like_value(true_val);
     bool false_ptr_like = is_pointer_like_value(false_val);
 
+    /* The ternary result must look like whichever side is pointer-like. If the
+     * "true" expression is still a raw array literal but the "false" side is a
+     * plain scalar, materialize the literal now so both branches produce
+     * comparable scalar SSA values.
+     */
     if (true_array && !false_ptr_like)
         true_val = scalarize_array_literal(parent, &then_, true_val,
                                            false_val ? false_val->type : NULL);
 
+    /* Apply the same conversion symmetrically when only the false branch is a
+     * literal array. This prevents OP_assign from trying to move array storage
+     * into a scalar destination later in code generation.
+     */
     if (false_array && !true_ptr_like)
         false_val = scalarize_array_literal(parent, &else_, false_val,
                                             true_val ? true_val->type : NULL);

tests/driver.sh

@@ -733,6 +733,28 @@ int main() {
 }
 EOF
 
+# Test: Array compound literal decay to pointer in initializer
+try_ 0 << EOF
+int main(void) {
+    int *arr = (int[]){1, 2, 3, 4, 5};
+    return arr[0] != 1 || arr[4] != 5;
+}
+EOF
+
+# Test: Passing array compound literal as pointer argument
+try_ 0 << EOF
+int sum(int *p, int n) {
+    int s = 0;
+    for (int i = 0; i < n; i++)
+        s += p[i];
+    return s;
+}
+int main(void) {
+    int s = sum((int[]){1, 2, 3, 0, 0}, 3);
+    return s != 6;
+}
+EOF
+
 # Test: Complex expression with compound literals
 try_ 77 << EOF
 int main() {
@@ -4737,6 +4759,36 @@ int main() {
 }
 EOF
 
+try_ 200 << EOF
+int main(void) {
+    char *s = (char[]){'A', 'B', 'C', 'D', 'E'};
+    return s[0] + s[1] + s[4]; /* 65 + 66 + 69 */
+}
+EOF
+
+try_ 6 << EOF
+int main(void) {
+    short *s = (short[]){1, 2, 3, 4, 5};
+    return s[0] + s[4];
+}
+EOF
+
+try_ 60 << EOF
+int main(void) {
+    int arr[] = {10, 20, 30, 40, 50};
+    int *selected = 1 ? arr : (int[]){1, 2, 3, 4, 5};
+    return selected[0] + selected[4];
+}
+EOF
+
+try_ 6 << EOF
+int main(void) {
+    int arr[] = {10, 20, 30, 40, 50};
+    int *selected = 0 ? arr : (int[]){1, 2, 3, 4, 5};
+    return selected[0] + selected[4];
+}
+EOF
+
 try_ 120 << EOF
 int main() {
     /* Complex expression with mixed compound literals */