fix: add array compound literal support

Previously, array compound literals such as (int[]){100, 200, 300}
failed with an "Unexpected token" error. Struct compound literals
worked correctly, but array syntax [] was unhandled in the parser.

This change adds proper array compound literal handling, including
scalar and pointer contexts. In scalar context, the literal returns
its first element (e.g. int x = (int[]){100,200}; yields 100). In
pointer context, it allocates and initializes backing storage and
returns the address (e.g. int *p = (int[]){100,200};). Arithmetic
expressions using literals (e.g. 50 + (int[]){100}) also evaluate
correctly.

Additional fixes include:
- Consume missing '{' token for int/char compound literals
- Add return statements to prevent control flow fall-through
- Prevent segfaults in pointer assignments by allocating memory

As a result, shecc now supports array compound literals alongside
existing struct compound literals, improving C99 compatibility and
preserving self-hosting capability.

Known limitations remain: designated initializers and complex
expression combinations are still unsupported.

Author: lorettayao

src/parser.c

@@ -47,9 +47,9 @@ void parse_array_init(var_t *var,
                       bool emit_code);
 /* helper function to emit struct brace initializers */
 void emit_struct_brace_initializer(block_t *parent,
-                                          basic_block_t **bb,
-                                          var_t *dest,
-                                          type_t *struct_type);
+                                   basic_block_t **bb,
+                                   var_t *dest,
+                                   type_t *struct_type);
 
 
 
@@ -1967,9 +1967,8 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
 
                 /* Check what follows the closing ) */
                 if (lex_accept(T_close_bracket)) {
-            
                     if (lex_peek(T_open_curly, NULL)) {
-                        /* (type){...} - compound literal */            
+                        /* (type){...} - compound literal */
                         is_compound_literal = true;
                         cast_or_literal_type = type;
                         cast_ptr_level = ptr_level;
@@ -2179,7 +2178,6 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
                        cast_or_literal_type->base_type == TYPE_char) {
                 /* Consume the opening { token */
                 lex_expect(T_open_curly);
-                
                 /* Handle empty compound literals */
                 if (lex_peek(T_close_curly, NULL)) {
                     /* Empty compound literal: (int){} */
@@ -2258,15 +2256,21 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
 
                         /* Store first element value for array-to-scalar */
                         compound_var->init_val = first_element->init_val;
-
-                        /* Return the array itself, let normal array decay handle conversion.
-                         * This enables both scalar and pointer contexts:
-                         * int x = (int[]){1,2,3};     // array decays to first element
-                         * int *p = (int[]){1,2,3};    // array decays to pointer
+                        /* Create result that provides first element access for
+                         * scalar contexts. This enables array compound literals
+                         * in scalar contexts: int x = (int[]){1,2,3};  // x
+                         * gets 1 int y = 5 + (int[]){10}; // adds 5 + 10
                          */
-                        compound_var->array_size = element_count;
-                        compound_var->ptr_level = 0;
-                        opstack_push(compound_var);
+                        var_t *result_var = require_var(parent);
+                        gen_name_to(result_var->var_name);
+                        result_var->type = compound_var->type;
+                        result_var->ptr_level = 0;
+                        result_var->array_size = 0;
+
+                        /* Read first element from the array */
+                        add_insn(parent, *bb, OP_read, result_var, compound_var,
+                                 NULL, compound_var->type->size, NULL);
+                        opstack_push(result_var);
                     } else {
                         /* Single value: (int){42} - scalar compound literal */
                         compound_var = opstack_pop();
@@ -2276,6 +2280,7 @@ void read_expr_operand(block_t *parent, basic_block_t **bb)
             }
 
             lex_expect(T_close_curly);
+            return;
         } else {
             /* Regular parenthesized expression */
             read_expr(parent, bb);
@@ -2443,9 +2448,9 @@ bool is_logical(opcode_t op)
 
 /* Helper function to emit struct brace initializer */
 void emit_struct_brace_initializer(block_t *parent,
-                                          basic_block_t **bb,
-                                          var_t *dest,
-                                          type_t *struct_type)
+                                   basic_block_t **bb,
+                                   var_t *dest,
+                                   type_t *struct_type)
 {
     if (struct_type->base_type == TYPE_typedef && struct_type->base_struct)
         struct_type = struct_type->base_struct;