transformer,markused,cgen: fix some problem for array init when use -new-transformer

vlib/v/gen/c/assign.v

@@ -1086,7 +1086,23 @@ fn (mut g Gen) assign_stmt(node_ ast.AssignStmt) {
 							old_inside_assign_fn_var := g.inside_assign_fn_var
 							g.inside_assign_fn_var = val is ast.PrefixExpr && val.op == .amp
 								&& is_fn_var
-							g.expr(val)
+							mut nval := val
+							if val is ast.PrefixExpr && val.right is ast.CallExpr {
+								call_expr := val.right as ast.CallExpr
+								if call_expr.name == 'new_array_from_c_array' {
+									nval = call_expr
+									if !var_type.has_flag(.shared_f) {
+										g.write('HEAP(${g.styp(var_type.clear_ref())}, ')
+									}
+									g.expr(nval)
+									if !var_type.has_flag(.shared_f) {
+										g.write(')')
+									}
+								}
+							}
+							if nval == val {
+								g.expr(nval)
+							}
 							g.inside_assign_fn_var = old_inside_assign_fn_var
 						}
 						if !is_fn_var && is_auto_heap && !is_option_auto_heap

vlib/v/gen/c/cgen.v

@@ -5864,13 +5864,16 @@ fn (mut g Gen) cast_expr(node ast.CastExpr) {
 						g.write('&'.repeat(ptr_cnt))
 					}
 				}
+				old_inside_cast := g.inside_cast
 				if node_typ == ast.voidptr_type && node.expr is ast.ArrayInit
 					&& (node.expr as ast.ArrayInit).is_fixed {
+					g.inside_cast = false
 					expr_styp := g.styp(node.expr_type)
 					g.write('(${expr_styp})')
 				}
 				g.expr(node.expr)
 				g.inside_assign_fn_var = old_inside_assign_fn_var
+				g.inside_cast = old_inside_cast
 				g.write('))')
 			}
 		}
@@ -7887,8 +7890,12 @@ fn (mut g Gen) get_type(typ ast.Type) ast.Type {
 
 fn (mut g Gen) size_of(node ast.SizeOf) {
 	typ := g.type_resolver.typeof_type(node.expr, g.get_type(node.typ))
-	node_typ := g.unwrap_generic(typ)
+	mut node_typ := g.unwrap_generic(typ)
 	sym := g.table.sym(node_typ)
+	if sym.kind == .function {
+		// todo fix fn type with fn name now
+		node_typ = ast.voidptr_type
+	}
 	if sym.language == .v && sym.kind in [.placeholder, .any] {
 		g.error('unknown type `${sym.name}`', node.pos)
 	}

vlib/v/markused/walker.v

@@ -524,6 +524,10 @@ fn (mut w Walker) expr(node_ ast.Expr) {
 		}
 		ast.ComptimeCall {
 			w.expr(node.left)
+			for args in node.args {
+				w.expr(args.expr)
+			}
+			w.expr(node.or_block)
 			if node.is_vweb {
 				w.stmts(node.veb_tmpl.stmts)
 			}

vlib/v/transformer/array.v

@@ -18,8 +18,8 @@ pub fn (mut t Transformer) array_init(mut node ast.ArrayInit) ast.Expr {
 	if node.has_init {
 		node.init_expr = t.expr(mut node.init_expr)
 	}
-	if !t.pref.new_transform || t.skip_array_transform || node.is_fixed || t.inside_in
-		|| node.has_len || node.has_cap || node.exprs.len == 0 {
+	if t.pref.backend == .js_node || !t.pref.new_transform || t.skip_array_transform
+		|| node.is_fixed || t.inside_in || node.has_len || node.has_cap || node.exprs.len == 0 {
 		return node
 	}
 	// For C and native transform into a function call `builtin__new_array_from_c_array_noscan(...)` etc
@@ -52,7 +52,7 @@ pub fn (mut t Transformer) array_init(mut node ast.ArrayInit) ast.Expr {
 				typ:        fixed_array_typ
 				elem_type:  node.elem_type
 				exprs:      node.exprs
-				expr_types: node.exprs.map(it.type())
+				expr_types: node.expr_types
 			}
 			typ:       ast.voidptr_type
 			typname:   'voidptr'

vlib/v/transformer/transformer.v

@@ -625,6 +625,13 @@ pub fn (mut t Transformer) expr(mut node ast.Expr) ast.Expr {
 			for mut stmt in node.stmts {
 				stmt = t.stmt(mut stmt)
 			}
+			if node.stmts.len > 0 {
+				// todo fix [] => new_array_from_c_array() now
+				mut stmt := node.stmts.last()
+				if stmt is ast.ExprStmt && stmt.expr is ast.CallExpr {
+					((stmt as ast.ExprStmt).expr as ast.CallExpr).is_return_used = true
+				}
+			}
 		}
 		ast.ParExpr {
 			mut inner_expr := t.expr(mut node.expr)