wasm: add support for array initialization with named params

Implemented array initialization with named parameters (len:, cap:, init:):
- Updated ArrayInit handling in mem.v to detect has_len, has_cap, has_init flags
- Calls __new_array_with_default() when named params are used
- Supports syntax like []int{len: 5, cap: 10, init: 42}
- Handles init value by creating temporary stack variable
- Falls back to regular __new_array() for literal arrays [1, 2, 3]

Added test array_named_init.vv demonstrating:
- Array with just len parameter
- Array with len and cap
- Array with len, cap, and init value
- String arrays with init

All WASM tests pass including the new named parameter tests.

Co-authored-by: enghitalo <63821277+enghitalo@users.noreply.github.com>

Author: Copilot

vlib/v/gen/wasm/mem.v

@@ -1087,18 +1087,63 @@ pub fn (mut g Gen) set_with_expr(init ast.Expr, v Var) {
 		ast.ArrayInit {
 			if !init.is_fixed {
 				// Dynamic array initialization
-				// Use __new_array() function to create the array struct
+				// Use __new_array() or __new_array_with_default() function
 				elm_typ := init.elem_type
 				elm_size, _ := g.pool.type_size(elm_typ)
 
-				// Calculate array length
-				arr_len := init.exprs.len
-
-				// Call __new_array(len, cap, element_size) to create array struct
-				g.literalint(arr_len, ast.int_type) // len
-				g.literalint(arr_len, ast.int_type) // cap (same as len for now)
-				g.literalint(elm_size, ast.int_type) // element_size
-				g.func.call('builtin____new_array')
+				// Check if using named parameters (len:, cap:, init:)
+				if init.has_len || init.has_cap || init.has_init {
+					// Array init with named params: []int{len: 5, cap: 10, init: 42}
+					// Use __new_array_with_default(len, cap, elm_size, default_value_ptr)
+					
+					// Push len (required or 0)
+					if init.has_len {
+						g.expr(init.len_expr, ast.int_type)
+					} else {
+						g.literalint(0, ast.int_type)
+					}
+					
+					// Push cap (or use len if not specified)
+					if init.has_cap {
+						g.expr(init.cap_expr, ast.int_type)
+					} else if init.has_len {
+						g.expr(init.len_expr, ast.int_type)
+					} else {
+						g.literalint(0, ast.int_type)
+					}
+					
+					// Push element_size
+					g.literalint(elm_size, ast.int_type)
+					
+					// Push init value pointer (or 0 for no default)
+					if init.has_init {
+						// Allocate space on stack for init value
+						init_var := g.new_local('__init', elm_typ)
+						init_var_addr := g.ensure_var_addressable(mut init_var)
+						
+						// Store init value
+						g.get(init_var_addr)
+						g.expr(init.init_expr, elm_typ)
+						g.store(elm_typ, 0)
+						
+						// Push address of init value
+						g.get(init_var_addr)
+					} else {
+						g.literalint(0, ast.int_type)
+					}
+					
+					g.func.call('builtin____new_array_with_default')
+				} else {
+					// Regular array initialization: [1, 2, 3]
+					// Calculate array length
+					arr_len := init.exprs.len
+
+					// Call __new_array(len, cap, element_size) to create array struct
+					g.literalint(arr_len, ast.int_type) // len
+					g.literalint(arr_len, ast.int_type) // cap (same as len for now)
+					g.literalint(elm_size, ast.int_type) // element_size
+					g.func.call('builtin____new_array')
+				}
 
 				// Store the returned array struct
 				array_struct_tmp := g.func.new_local_named(.i32_t, '__tmp<array_struct>')
@@ -1112,8 +1157,9 @@ pub fn (mut g Gen) set_with_expr(init ast.Expr, v Var) {
 				g.func.call('vmemcpy')
 				g.func.drop()
 
-				// Now populate the data if there are elements
-				if arr_len > 0 {
+				// Now populate the data if there are explicit elements (not using init:)
+				arr_len := init.exprs.len
+				if arr_len > 0 && !init.has_init {
 					// Get pointer to array data
 					data_ptr := g.func.new_local_named(.i32_t, '__tmp<array_data>')
 					g.func.local_get(array_struct_tmp)

vlib/v/gen/wasm/tests/array_named_init.vv

@@ -0,0 +1,38 @@
+// Test array initialization with named parameters
+fn main() {
+	// Test len only
+	println('=== Array with len ===')
+	a := []int{len: 5}
+	println('len:')
+	println(a.len)
+	println('cap:')
+	println(a.cap)
+	
+	// Test len and cap
+	println('=== Array with len and cap ===')
+	b := []int{len: 3, cap: 10}
+	println('len:')
+	println(b.len)
+	println('cap:')
+	println(b.cap)
+	
+	// Test len, cap, and init
+	println('=== Array with len, cap, and init ===')
+	c := []int{len: 4, cap: 8, init: 42}
+	println('len:')
+	println(c.len)
+	println('cap:')
+	println(c.cap)
+	println('first element:')
+	println(c[0])
+	println('last element:')
+	println(c[3])
+	
+	// Test with different types
+	println('=== String array with init ===')
+	d := []string{len: 2, init: 'hello'}
+	println('len:')
+	println(d.len)
+	println('first element:')
+	println(d[0])
+}

vlib/v/gen/wasm/tests/array_named_init.vv.out

@@ -0,0 +1,24 @@
+=== Array with len ===
+len:
+5
+cap:
+5
+=== Array with len and cap ===
+len:
+3
+cap:
+10
+=== Array with len, cap, and init ===
+len:
+4
+cap:
+8
+first element:
+42
+last element:
+42
+=== String array with init ===
+len:
+2
+first element:
+hello