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.

Add a driver test to ensure array compound literals decay to pointers
(int *p = (int[]){42,43,44}) and fix parsing to track compound literals
explicitly and keep them pointer-like for varargs and pointer initializers.

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

Parser cleanup: flattened the nested parameter-handling conditionals in
 parser.c so array-literal parameters are scalarized and promoted/resized
 without deep if-nesting, improving readability while preserving the
decay semantics enforced by the new tests

Author: lorettayao

src/defs.h

@@ -410,6 +410,11 @@ struct var {
      * the variable is based on the top of the local stack.
      */
     bool ofs_based_on_stack_top;
+
+    /* True when this variable was synthesized to hold a compound literal
+     * (e.g., array or struct literal temporaries).
+     */
+    bool is_compound_literal;
 };
 
 typedef struct {

src/parser.c

@@ -45,10 +45,6 @@ void parse_array_init(var_t *var,
                       block_t *parent,
                       basic_block_t **bb,
                       bool emit_code);
-void parse_array_compound_literal(var_t *var,
-                                  block_t *parent,
-                                  basic_block_t **bb,
-                                  bool emit_code);
 
 label_t *find_label(char *name)
 {
@@ -877,6 +873,7 @@ void parse_array_literal_expr(block_t *parent, basic_block_t **bb)
 {
     var_t *array_var = require_var(parent);
     gen_name_to(array_var->var_name);
+    array_var->is_compound_literal = true;
 
     int element_count = 0;
     var_t *first_element = NULL;
@@ -1335,8 +1332,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 +1345,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;
@@ -1371,13 +1367,13 @@ void parse_array_compound_literal(var_t *var,
     var->array_size = count;
 }
 /* Identify compiler-emitted temporaries that hold array compound literals.
- * Parsing assigns these temporaries synthetic names via gen_name_to (".tN")
- * and they keep array metadata without pointer indirection.
+ * They keep array metadata without pointer indirection and are marked via
+ * is_compound_literal when synthesized.
  */
 bool is_array_literal_placeholder(var_t *var)
 {
     return var && var->array_size > 0 && !var->ptr_level &&
-           var->var_name[0] == '.';
+           var->is_compound_literal;
 }
 
 bool is_pointer_like_value(var_t *var)
@@ -1386,6 +1382,11 @@ bool is_pointer_like_value(var_t *var)
                    (var->type && var->type->ptr_level > 0));
 }
 
+/* Lower a compiler-emitted array literal placeholder (marked via
+ * is_compound_literal) 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,24 +1395,50 @@ 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;
 }
+
+/* Centralized guard for lowering array literal placeholders when a scalar
+ * value is expected, keeping the scattered special cases consistent.
+ */
+var_t *scalarize_array_literal_if_needed(block_t *parent,
+                                                basic_block_t **bb,
+                                                var_t *value,
+                                                type_t *hint_type,
+                                                bool needs_scalar)
+{
+    if (!needs_scalar)
+        return value;
+
+    return scalarize_array_literal(parent, bb, value, hint_type);
+}
+
 void read_inner_var_decl(var_t *vd, bool anon, bool is_param)
 {
     /* Preserve typedef pointer level - don't reset if already inherited */
@@ -1704,24 +1731,24 @@ void read_func_parameters(func_t *func, block_t *parent, basic_block_t **bb)
         read_ternary_operation(parent, bb);
 
         param = opstack_pop();
-        if (func) {
-            if (param_num < func->num_params) {
-                var_t *target = &func->param_defs[param_num];
-                if (!target->ptr_level && !target->array_size)
-                    param = scalarize_array_literal(parent, bb, param,
-                                                    target->type);
-            }
+        if (func && param_num < func->num_params) {
+            var_t *target = &func->param_defs[param_num];
+            if (!target->ptr_level && !target->array_size)
+                param =
+                    scalarize_array_literal(parent, bb, param, target->type);
         }
         /* Handle parameter type conversion for direct calls.
          * Indirect calls currently don't provide function instance.
          */
-        if (func) {
-            if (param_num >= func->num_params && func->va_args) {
+        if (func && param_num >= func->num_params && func->va_args) {
+            /* Default promotions apply to scalar varargs, but pointer-like
+             * values (including array literals) must flow through unchanged so
+             * "%p" and friends see an address rather than a scalarized value.
+             */
+            if (!is_pointer_like_value(param))
                 param = promote(parent, bb, param, TY_int, 0);
-            } else {
-                param =
-                    resize_var(parent, bb, param, &func->param_defs[param_num]);
-            }
+        } else if (func) {
+            param = resize_var(parent, bb, param, &func->param_defs[param_num]);
         }
 
         params[param_num++] = param;
@@ -2148,6 +2175,7 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
             var_t *compound_var =
                 require_typed_var(parent, cast_or_literal_type);
             gen_name_to(compound_var->var_name);
+            compound_var->is_compound_literal = true;
 
             /* Check if this is an array compound literal (int[]){...} */
             bool is_array_literal = (cast_ptr_level == -1);
@@ -2159,7 +2187,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,13 +3656,22 @@ 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);
 
-    if (true_array && !false_ptr_like)
-        true_val = scalarize_array_literal(parent, &then_, true_val,
-                                           false_val ? false_val->type : NULL);
+    /* 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.
+     */
+    true_val = scalarize_array_literal_if_needed(
+        parent, &then_, true_val, false_val ? false_val->type : NULL,
+        true_array && !false_ptr_like);
 
-    if (false_array && !true_ptr_like)
-        false_val = scalarize_array_literal(parent, &else_, false_val,
-                                            true_val ? true_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.
+     */
+    false_val = scalarize_array_literal_if_needed(
+        parent, &else_, false_val, true_val ? true_val->type : NULL,
+        false_array && !true_ptr_like);
 
     vd = require_var(parent);
     gen_name_to(vd->var_name);
@@ -3801,9 +3838,9 @@ bool read_body_assignment(char *token,
                 read_expr(parent, bb);
 
                 var_t *rhs_val = opstack_pop();
-                if (!lvalue.ptr_level && !lvalue.is_reference)
-                    rhs_val = scalarize_array_literal(parent, bb, rhs_val,
-                                                      lvalue.type);
+                rhs_val = scalarize_array_literal_if_needed(
+                    parent, bb, rhs_val, lvalue.type,
+                    !lvalue.ptr_level && !lvalue.is_reference);
                 opstack_push(rhs_val);
                 vd = require_var(parent);
                 vd->init_val = increment_size;
@@ -4546,9 +4583,9 @@ basic_block_t *read_body_statement(block_t *parent, basic_block_t *bb)
                     read_ternary_operation(parent, &bb);
 
                     var_t *rhs = opstack_pop();
-                    if (!var->ptr_level && var->array_size == 0)
-                        rhs = scalarize_array_literal(parent, &bb, rhs,
-                                                      var->type);
+                    rhs = scalarize_array_literal_if_needed(
+                        parent, &bb, rhs, var->type,
+                        !var->ptr_level && var->array_size == 0);
 
                     rs1 = resize_var(parent, &bb, rhs, var);
                     add_insn(parent, bb, OP_assign, var, rs1, NULL, 0, NULL);
@@ -4643,9 +4680,9 @@ basic_block_t *read_body_statement(block_t *parent, basic_block_t *bb)
                         read_expr(parent, &bb);
                         read_ternary_operation(parent, &bb);
                         var_t *rhs = opstack_pop();
-                        if (!nv->ptr_level && nv->array_size == 0)
-                            rhs = scalarize_array_literal(parent, &bb, rhs,
-                                                          nv->type);
+                        rhs = scalarize_array_literal_if_needed(
+                            parent, &bb, rhs, nv->type,
+                            !nv->ptr_level && nv->array_size == 0);
 
                         rs1 = resize_var(parent, &bb, rhs, nv);
                         add_insn(parent, bb, OP_assign, nv, rs1, NULL, 0, NULL);
@@ -5303,6 +5340,7 @@ void initialize_struct_field(var_t *nv, var_t *v, int offset)
     nv->base = NULL;
     nv->subscript = 0;
     nv->subscripts_idx = 0;
+    nv->is_compound_literal = false;
 }
 
 void read_global_statement(void)

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 */
@@ -4789,6 +4841,14 @@ int main() {
 }
 EOF
 
+# Array literal decay in initializer for pointer variable
+try_ 0 << EOF
+int main(void) {
+    int *p = (int[]){42, 43, 44};
+    return *p == 42 ? 0 : 1;
+}
+EOF
+
 # Test pointer compound literals
 try_ 0 << EOF
 int main()