transformer: transform ArrayInit into a function call for C and native backends (part 1)

Author: medvednikov

vlib/v/ast/table.v

@@ -2837,3 +2837,8 @@ pub fn (mut t Table) get_veb_result_type_idx() int {
 pub fn (mut t Table) register_vls_info(key string, val VlsInfo) {
 	t.vls_info[key] = val
 }
+
+pub fn (t &Table) unwrap(typ Type) Type {
+	ts := t.sym(typ)
+	return if ts.info is Alias { t.unwrap(ts.info.parent_type) } else { typ }
+}

vlib/v/gen/c/array.v

@@ -24,7 +24,7 @@ fn (mut g Gen) array_init(node ast.ArrayInit, var_name string) {
 	}
 	len := node.exprs.len
 	elem_sym := g.table.sym(g.unwrap_generic(node.elem_type))
-	if array_type.unaliased_sym.kind == .array_fixed {
+	if node.is_fixed || array_type.unaliased_sym.kind == .array_fixed {
 		g.fixed_array_init(node, array_type, var_name, is_amp)
 		if is_amp {
 			g.write(')')

vlib/v/pref/pref.v

@@ -257,9 +257,10 @@ pub mut:
 	// forwards compatibility settings:
 	relaxed_gcc14 bool = true // turn on the generated pragmas, that make gcc versions > 14 a lot less pedantic. The default is to have those pragmas in the generated C output, so that gcc-14 can be used on Arch etc.
 	//
-	subsystem   Subsystem // the type of the window app, that is going to be generated; has no effect on !windows
-	is_vls      bool
-	json_errors bool // -json-errors, for VLS and other tools
+	subsystem     Subsystem // the type of the window app, that is going to be generated; has no effect on !windows
+	is_vls        bool
+	json_errors   bool // -json-errors, for VLS and other tools
+	new_transform bool // temporary for the new transformer
 }
 
 pub fn parse_args(known_external_commands []string, args []string) (&Preferences, string) {
@@ -762,6 +763,9 @@ pub fn parse_args_and_show_errors(known_external_commands []string, args []strin
 			'-experimental' {
 				res.experimental = true
 			}
+			'-new-transformer' {
+				res.new_transform = true
+			}
 			'-usecache' {
 				res.use_cache = true
 			}

vlib/v/transformer/transformer.v

@@ -554,12 +554,7 @@ pub fn (mut t Transformer) expr(mut node ast.Expr) ast.Expr {
 			node.expr = t.expr(mut node.expr)
 		}
 		ast.ArrayInit {
-			for mut expr in node.exprs {
-				expr = t.expr(mut expr)
-			}
-			node.len_expr = t.expr(mut node.len_expr)
-			node.cap_expr = t.expr(mut node.cap_expr)
-			node.init_expr = t.expr(mut node.init_expr)
+			return t.array_init(mut node)
 		}
 		ast.AsCast {
 			node.expr = t.expr(mut node.expr)
@@ -1153,6 +1148,125 @@ pub fn (mut t Transformer) infix_expr(mut node ast.InfixExpr) ast.Expr {
 	}
 }
 
+pub fn (mut t Transformer) array_init(mut node ast.ArrayInit) ast.Expr {
+	// For JS and Go generate array init using their syntax
+	// if t.pref.backend !in [.c, .native] {
+	if !t.pref.new_transform || node.is_fixed {
+		for mut expr in node.exprs {
+			expr = t.expr(mut expr)
+		}
+		node.len_expr = t.expr(mut node.len_expr)
+		node.cap_expr = t.expr(mut node.cap_expr)
+		node.init_expr = t.expr(mut node.init_expr)
+		return node
+	}
+	// For C and native transform into a function call `builtin__new_array_from_c_array_noscan(...)` etc
+	// println('transformer array-init ${t.pref.backend}')
+	// array_type := t.table.unwrap(node.typ)
+	// mut array_styp := ''
+	// elem_type := t.table.unwrap(node.elem_type)
+	// mut shared_styp := '' // only needed for shared &[]{...}
+	// is_shared := false // TODO g.is_shared => t.is_shared
+	len := node.exprs.len
+	// elem_sym := t.table.sym(t.unwrap_generic(node.elem_type))
+	// elem_sym := t.table.sym(t.table.unwrap(node.elem_type))
+	// if false { // array_type.unaliased_sym.kind == .array_fixed {
+	// g.fixed_array_init(node, array_type, var_name, is_amp)
+	// if is_amp {
+	// g.write(')')
+	//}
+	//} else if len == 0 {
+	// `[]int{len: 6, cap:10, init:22}`
+	// g.array_init_with_fields(node, elem_type, is_amp, shared_styp, var_name)
+	//} else {
+	// `[1, 2, 3]`
+	// elem_styp := g.styp(elem_type.typ)
+	noscan := '_noscan' // g.check_noscan(elem_type.typ)
+	mut fn_name := 'new_array_from_c_array'
+	len_arg := ast.CallArg{
+		expr: ast.IntegerLiteral{
+			val: len.str()
+		}
+	}
+	sizeof_arg := ast.CallArg{
+		expr: ast.SizeOf{
+			is_type: true
+			typ:     node.elem_type
+		}
+	}
+	fixed_array_arg := ast.CallArg{
+		expr: ast.ArrayInit{
+			is_fixed:  true
+			has_val:   true
+			typ:       t.table.find_or_register_array_fixed(node.elem_type, len, ast.empty_expr,
+				false)
+			elem_type: node.elem_type
+			exprs:     node.exprs
+		}
+	}
+	// if false { // elem_type.unaliased_sym.kind == .function {
+	//} else {
+	fn_name = 'new_array_from_c_array' + noscan
+	// g.write('builtin__new_array_from_c_array${noscan}(${len}, ${len}, sizeof(${elem_styp}), _MOV((${elem_styp}[${len}]){')
+	//}
+	call_expr := ast.CallExpr{
+		name:        fn_name
+		mod:         'builtin'
+		scope:       ast.empty_scope // node.scope
+		args:        [len_arg, len_arg, sizeof_arg, fixed_array_arg] //, sizeof(voidptr), _MOV((voidptr[${len}]){')
+		return_type: node.typ
+	}
+	// println('call expr')
+	// println(call_expr)
+	return call_expr
+	/*
+		if len > 8 {
+			g.writeln('')
+			g.write('\t\t')
+		}
+		is_iface_or_sumtype := elem_sym.kind in [.sum_type, .interface]
+		for i, expr in node.exprs {
+			expr_type := if node.expr_types.len > i { node.expr_types[i] } else { node.elem_type }
+			if expr_type == ast.string_type
+				&& expr !in [ast.IndexExpr, ast.CallExpr, ast.StringLiteral, ast.StringInterLiteral, ast.InfixExpr] {
+				if is_iface_or_sumtype {
+					g.expr_with_cast(expr, expr_type, node.elem_type)
+				} else {
+					g.write('builtin__string_clone(')
+					g.expr(expr)
+					g.write(')')
+				}
+			} else {
+				if node.elem_type.has_flag(.option) {
+					g.expr_with_opt(expr, expr_type, node.elem_type)
+				} else if elem_type.unaliased_sym.kind == .array_fixed
+					&& expr in [ast.Ident, ast.SelectorExpr] {
+					info := elem_type.unaliased_sym.info as ast.ArrayFixed
+					g.fixed_array_var_init(g.expr_string(expr), expr.is_auto_deref_var(),
+						info.elem_type, info.size)
+				} else {
+					g.expr_with_cast(expr, expr_type, node.elem_type)
+				}
+			}
+			if i != len - 1 {
+				if i > 0 && i & 7 == 0 { // i > 0 && i % 8 == 0
+					g.writeln(',')
+					g.write('\t\t')
+				} else {
+					g.write(', ')
+				}
+			}
+		}
+		g.write('}))')
+		if g.is_shared {
+			g.write('}, sizeof(${shared_styp}))')
+		} else if is_amp {
+			g.write(')')
+		}
+		*/
+	//}
+}
+
 pub fn (mut t Transformer) if_expr(mut node ast.IfExpr) ast.Expr {
 	for mut branch in node.branches {
 		branch.cond = t.expr(mut branch.cond)