Update driver snapshots after decay tests.

Fix IR test failure.
Regenerate ARM IR snapshots to reflect the corrected lowering.
Restore ARM/RISC-V codegen files to original structure after earlier brace experiment.
Treat zero-length array compound literals as constant zero during lowering so scalar uses don't load garbage.

Fix coding style according to cubic-dev-ai's suggestion.

Author: lorettayao

src/arm-codegen.c

@@ -450,7 +450,7 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
             fatal("Unsupported truncation operation with invalid target size");
         }
         return;
-    case OP_sign_ext: {
+    case OP_sign_ext:
         /* Decode source size from upper 16 bits */
         int source_size = (rm >> 16) & 0xFFFF;
         if (source_size == 2) {
@@ -459,7 +459,6 @@ void emit_ph2_ir(ph2_ir_t *ph2_ir)
             /* For other cases, use byte extension (original behavior) */
             emit(__sxtb(__AL, rd, rn, 0));
         }
-    }
         return;
     case OP_cast:
         /* Generic cast operation - for now, just move the value */

src/parser.c

@@ -1285,7 +1285,10 @@ void parse_array_init(var_t *var,
         }
     }
 }
-
+/* Parse array compound literal contents: emit element stores to a temporary
+ * array. Counts initializers and consumes the closing brace. Used only for
+ * array types.
+ */
 void parse_array_compound_literal(var_t *var,
                                   block_t *parent,
                                   basic_block_t **bb,
@@ -1300,8 +1303,9 @@ void parse_array_compound_literal(var_t *var,
             read_expr(parent, bb);
             read_ternary_operation(parent, bb);
             var_t *value = opstack_pop();
-            if (count == 0)
+            if (count == 0) {
                 var->init_val = value->init_val;
+            }
             if (emit_code) {
                 var_t target = {0};
                 target.type = var->type;
@@ -1313,19 +1317,21 @@ void parse_array_compound_literal(var_t *var,
                          elem_size, NULL);
             }
             count++;
-            if (!lex_accept(T_comma))
+            if (!lex_accept(T_comma)) {
                 break;
-            if (lex_peek(T_close_curly, NULL))
+            }
+            if (lex_peek(T_close_curly, NULL)) {
                 break;
+            }
         }
     }
 
     lex_expect(T_close_curly);
     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.
+/* Detect compiler temporaries ('.tN' names) holding array compound literals.
+ * These retain array metadata (size/type) without decaying to pointers until
+ * needed.
  */
 bool is_array_literal_placeholder(var_t *var)
 {
@@ -1341,9 +1347,8 @@ var_t *scalarize_array_literal(block_t *parent,
     if (!is_array_literal_placeholder(array_var))
         return array_var;
 
-    type_t *elem_type = hint_type ? hint_type : array_var->type;
-    if (!elem_type)
-        elem_type = TY_int;
+    type_t *elem_type =
+        hint_type ? hint_type : (array_var->type ? array_var->type : TY_int);
 
     int elem_size = elem_type->size;
     if (elem_size <= 0)
@@ -1355,6 +1360,7 @@ var_t *scalarize_array_literal(block_t *parent,
     scalar->init_val = array_var->init_val;
 
     add_insn(parent, *bb, OP_read, scalar, array_var, NULL, elem_size, NULL);
+
     return scalar;
 }
 void read_inner_var_decl(var_t *vd, bool anon, bool is_param)
@@ -1653,6 +1659,8 @@ void read_func_parameters(func_t *func, block_t *parent, basic_block_t **bb)
             if (param_num < func->num_params) {
                 var_t *target = &func->param_defs[param_num];
                 if (!target->ptr_level && !target->array_size)
+                    /* Decay array literals to scalars for non-pointer params,
+                     * per C semantics. */
                     param = scalarize_array_literal(parent, bb, param,
                                                     target->type);
             } else if (func->va_args) {
@@ -2107,6 +2115,14 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
                 add_insn(parent, *bb, OP_allocat, compound_var, NULL, NULL, 0,
                          NULL);
                 parse_array_compound_literal(compound_var, parent, bb, true);
+
+                if (compound_var->array_size == 0) {
+                    /* Zero-length arrays default to 0 constant (avoids garbage
+                     * reads in scalar contexts). */
+                    compound_var->init_val = 0;
+                    add_insn(parent, *bb, OP_load_constant, compound_var, NULL,
+                             NULL, 0, NULL);
+                }
                 opstack_push(compound_var);
                 consumed_close_brace = true;
             } else if (cast_ptr_level > 0) {
@@ -3531,14 +3547,12 @@ void finalize_logical(opcode_t op,
 
 void read_ternary_operation(block_t *parent, basic_block_t **bb)
 {
-    var_t *vd;
-
     if (!lex_accept(T_question))
         return;
 
     /* ternary-operator */
-    vd = opstack_pop();
-    add_insn(parent, *bb, OP_branch, NULL, vd, NULL, 0, NULL);
+    var_t *condition = opstack_pop();
+    add_insn(parent, *bb, OP_branch, NULL, condition, NULL, 0, NULL);
 
     basic_block_t *then_ = bb_create(parent);
     basic_block_t *else_ = bb_create(parent);
@@ -3566,17 +3580,21 @@ void read_ternary_operation(block_t *parent, basic_block_t **bb)
     bool false_array = is_array_literal_placeholder(false_val);
 
     if (true_array && !false_array)
+        /* Scalarize array literals if the other branch isn't pointer-like, to
+         * match types. */
         true_val = scalarize_array_literal(parent, &then_, true_val,
                                            false_val ? false_val->type : NULL);
 
     if (false_array && !true_array)
+        /* Scalarize array literals if the other branch isn't pointer-like, to
+         * match types. */
         false_val = scalarize_array_literal(parent, &else_, false_val,
                                             true_val ? true_val->type : NULL);
 
-    vd = require_var(parent);
-    gen_name_to(vd->var_name);
-    add_insn(parent, then_, OP_assign, vd, true_val, NULL, 0, NULL);
-    add_insn(parent, else_, OP_assign, vd, false_val, NULL, 0, NULL);
+    var_t *result_var = require_var(parent);
+    gen_name_to(result_var->var_name);
+    add_insn(parent, then_, OP_assign, result_var, true_val, NULL, 0, NULL);
+    add_insn(parent, else_, OP_assign, result_var, false_val, NULL, 0, NULL);
 
     var_t *array_ref = NULL;
     if (is_array_literal_placeholder(true_val))
@@ -3585,13 +3603,13 @@ void read_ternary_operation(block_t *parent, basic_block_t **bb)
         array_ref = false_val;
 
     if (array_ref) {
-        vd->array_size = array_ref->array_size;
-        vd->init_val = array_ref->init_val;
-        vd->type = array_ref->type;
+        result_var->array_size = array_ref->array_size;
+        result_var->init_val = array_ref->init_val;
+        result_var->type = array_ref->type;
     }
 
-    vd->is_ternary_ret = true;
-    opstack_push(vd);
+    result_var->is_ternary_ret = true;
+    opstack_push(result_var);
     bb[0] = end_ternary;
 }
 
@@ -3737,11 +3755,13 @@ bool read_body_assignment(char *token,
 
                 read_expr(parent, bb);
 
-                var_t *rhs_val = opstack_pop();
+                var_t *rhs = opstack_pop();
                 if (!lvalue.ptr_level && !lvalue.is_reference)
-                    rhs_val = scalarize_array_literal(parent, bb, rhs_val,
-                                                      lvalue.type);
-                opstack_push(rhs_val);
+                    /* Decay RHS array literal to scalar if target is
+                     * non-pointer (e.g., int x = (int[]){1}; uses first elem).
+                     */
+                    rhs = scalarize_array_literal(parent, bb, rhs, lvalue.type);
+                opstack_push(rhs);
                 vd = require_var(parent);
                 vd->init_val = increment_size;
                 gen_name_to(vd->var_name);