Fix incorrect scalarization in variadic and pointer contexts

Update `scalarize_array_literal` to read using the literal’s element size while still allowing callers to select the final result type.

Stop collapsing array literals in variadic call arguments and pointer arithmetic operands merely because the opposite operand is an integer.
This ensures array literals decay to pointers when required rather than being forced into scalars.

For literal-plus-literal arithmetic, preserve the historical behavior by computing a scalar sum of the first elements, while still honoring proper pointer arithmetic when a real pointer participates.

Author: lorettayao

src/parser.c

@@ -1380,6 +1380,12 @@ bool is_array_literal_placeholder(var_t *var)
            var->var_name[0] == '.';
 }
 
+bool is_pointer_like_value(var_t *var)
+{
+    return var && (var->ptr_level || var->array_size ||
+                   (var->type && var->type->ptr_level > 0));
+}
+
 var_t *scalarize_array_literal(block_t *parent,
                                basic_block_t **bb,
                                var_t *array_var,
@@ -1388,20 +1394,21 @@ 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 *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;
 
-    int elem_size = elem_type->size;
-    if (elem_size <= 0)
-        elem_size = TY_int->size;
+    type_t *result_type = hint_type ? hint_type : literal_type;
+    if (!result_type)
+        result_type = TY_int;
 
-    var_t *scalar = require_typed_var(parent, elem_type);
+    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;
 
-    add_insn(parent, *bb, OP_read, scalar, array_var, NULL, elem_size, NULL);
+    add_insn(parent, *bb, OP_read, scalar, array_var, NULL, literal_size, NULL);
 
     return scalar;
 }
@@ -1703,8 +1710,6 @@ void read_func_parameters(func_t *func, block_t *parent, basic_block_t **bb)
                 if (!target->ptr_level && !target->array_size)
                     param = scalarize_array_literal(parent, bb, param,
                                                     target->type);
-            } else if (func->va_args) {
-                param = scalarize_array_literal(parent, bb, param, TY_int);
             }
         }
         /* Handle parameter type conversion for direct calls.
@@ -2612,20 +2617,14 @@ void handle_pointer_arithmetic(block_t *parent,
         }
 
         /* Check if both have ptr_level or typedef pointer type */
-        bool rs1_is_ptr = (orig_rs1->ptr_level > 0) ||
-                          (orig_rs1->type && orig_rs1->type->ptr_level > 0);
-        bool rs2_is_ptr = (orig_rs2->ptr_level > 0) ||
-                          (orig_rs2->type && orig_rs2->type->ptr_level > 0);
+        bool rs1_is_ptr = is_pointer_like_value(orig_rs1);
+        bool rs2_is_ptr = is_pointer_like_value(orig_rs2);
 
         /* If variable lookup failed, check the passed variables directly */
-        if (!rs1_is_ptr) {
-            rs1_is_ptr =
-                (rs1->ptr_level > 0) || (rs1->type && rs1->type->ptr_level > 0);
-        }
-        if (!rs2_is_ptr) {
-            rs2_is_ptr =
-                (rs2->ptr_level > 0) || (rs2->type && rs2->type->ptr_level > 0);
-        }
+        if (!rs1_is_ptr)
+            rs1_is_ptr = is_pointer_like_value(rs1);
+        if (!rs2_is_ptr)
+            rs2_is_ptr = is_pointer_like_value(rs2);
 
         if (rs1_is_ptr && rs2_is_ptr) {
             /* Both are pointers - this is pointer difference */
@@ -2704,11 +2703,11 @@ void handle_pointer_arithmetic(block_t *parent,
         }
     }
     /* Determine which operand is the pointer for regular pointer arithmetic */
-    if (rs1->ptr_level || (rs1->type && rs1->type->ptr_level > 0)) {
+    if (is_pointer_like_value(rs1)) {
         ptr_var = rs1;
         int_var = rs2;
         element_size = get_pointer_element_size(rs1);
-    } else if (rs2->ptr_level || (rs2->type && rs2->type->ptr_level > 0)) {
+    } else if (is_pointer_like_value(rs2)) {
         /* Only for addition (p + n == n + p) */
         if (op == OP_add) {
             ptr_var = rs2;
@@ -2755,8 +2754,7 @@ bool is_pointer_operation(opcode_t op, var_t *rs1, var_t *rs2)
     if (op != OP_add && op != OP_sub)
         return false;
 
-    return (rs1->ptr_level || (rs1->type && rs1->type->ptr_level > 0) ||
-            rs2->ptr_level || (rs2->type && rs2->type->ptr_level > 0));
+    return is_pointer_like_value(rs1) || is_pointer_like_value(rs2);
 }
 
 /* Helper function to check if a variable is a pointer based on its declaration
@@ -2949,22 +2947,31 @@ void read_expr(block_t *parent, basic_block_t **bb)
         rs2 = opstack_pop();
         rs1 = opstack_pop();
 
+        bool rs1_is_placeholder = is_array_literal_placeholder(rs1);
+        bool rs2_is_placeholder = is_array_literal_placeholder(rs2);
+        bool rs1_is_ptr_like = is_pointer_like_value(rs1);
+        bool rs2_is_ptr_like = is_pointer_like_value(rs2);
+        bool pointer_context = (rs1_is_ptr_like && !rs1_is_placeholder) ||
+                               (rs2_is_ptr_like && !rs2_is_placeholder);
+
         /* Pointer arithmetic handling */
-        if (is_pointer_operation(top_op, rs1, rs2)) {
+        if (pointer_context && is_pointer_operation(top_op, rs1, rs2)) {
             handle_pointer_arithmetic(parent, bb, top_op, rs1, rs2);
             continue; /* skip normal processing */
         }
 
-        bool rs1_is_ptr_like = rs1 && (rs1->ptr_level || rs1->array_size);
-        bool rs2_is_ptr_like = rs2 && (rs2->ptr_level || rs2->array_size);
-
-        if (is_array_literal_placeholder(rs1) && !rs2_is_ptr_like)
-            rs1 = scalarize_array_literal(parent, bb, rs1,
-                                          rs2 && rs2->type ? rs2->type : NULL);
+        if (rs1_is_placeholder && rs2_is_placeholder) {
+            rs1 = scalarize_array_literal(parent, bb, rs1, NULL);
+            rs2 = scalarize_array_literal(parent, bb, rs2, NULL);
+        } else {
+            if (rs1_is_placeholder && !rs2_is_ptr_like)
+                rs1 = scalarize_array_literal(
+                    parent, bb, rs1, rs2 && rs2->type ? rs2->type : NULL);
 
-        if (is_array_literal_placeholder(rs2) && !rs1_is_ptr_like)
-            rs2 = scalarize_array_literal(parent, bb, rs2,
-                                          rs1 && rs1->type ? rs1->type : NULL);
+            if (rs2_is_placeholder && !rs1_is_ptr_like)
+                rs2 = scalarize_array_literal(
+                    parent, bb, rs2, rs1 && rs1->type ? rs1->type : NULL);
+        }
         /* Constant folding for binary operations */
         if (rs1 && rs2 && rs1->init_val && !rs1->ptr_level && !rs1->is_global &&
             rs2->init_val && !rs2->ptr_level && !rs2->is_global) {