v3: fix array map origins and comparator types

Author: medvednikov

vlib/v/tests/builtin_arrays/sorting_compare_fn_with_mut_reference_test.v

@@ -60,6 +60,16 @@ fn test_sort_compare_local_fn_with_pointer_values() {
 	assert items.map(it.a) == [1, 2, 3]
 }
 
+fn get_thing_comparator() fn (&Thing, &Thing) int {
+	return compare_thing_values
+}
+
+fn test_sort_compare_call_fn_with_pointer_values() {
+	mut items := [&Thing{a: 3}, &Thing{a: 1}, &Thing{a: 2}]
+	items.sort_with_compare(get_thing_comparator())
+	assert items.map(it.a) == [1, 2, 3]
+}
+
 struct ThingComparators {
 	@[required]
 	compare fn (&Thing, &Thing) int

vlib/v3/tests/review_transform_regressions_test.v

@@ -5592,6 +5592,37 @@ fn main() {
 	assert out == '4\n42'
 }
 
+fn test_array_map_drops_source_for_unselected_literal_element_pointer() {
+	v3_bin := build_v3_review_transform_ownership()
+	source := 'struct Item {
+	text string
+}
+
+fn make_items() []Item {
+	return [Item{
+		text: "source"
+	}]
+}
+
+fn main() {
+	external := Item{
+		text: "external"
+	}
+	selected := make_items().map([&it, &external][1])
+	println(selected[0].text)
+}
+'
+	c_source := gen_c_from_source_with_flags(v3_bin, 'array_map_selected_external_pointer_c',
+		'-ownership', source)
+	main_body := c_fn_body(c_source, 'int main(int argc, char** argv) {')
+	source_drop_pos := main_body.index('array__free(&(') or { -1 }
+	result_move_pos := main_body.index('Array selected = ') or { -1 }
+	assert source_drop_pos >= 0 && source_drop_pos < result_move_pos, main_body
+	out := run_good_with_flags(v3_bin, 'array_map_selected_external_pointer', '-ownership',
+		source)
+	assert out == 'external'
+}
+
 fn test_array_filter_and_map_reclaim_branch_selected_bound_methods() {
 	v3_bin := build_v3_review_transform()
 	source := '@[heap]

vlib/v3/transform/array.v

@@ -2832,8 +2832,7 @@ fn (mut t Transformer) array_map_expr_result_retains_element_address(id flat.Nod
 					node.value, name)
 		}
 		.index {
-			return node.children_count > 0
-				&& t.array_map_expr_result_retains_element_address(t.a.child(&node, 0), name)
+			return t.array_map_index_result_retains_element_address(node, name)
 		}
 		.call {
 			call_type := t.checker_expr_type_name(id) or { t.node_type(id) }
@@ -2861,6 +2860,25 @@ fn (mut t Transformer) array_map_expr_result_retains_element_address(id flat.Nod
 	}
 }
 
+fn (mut t Transformer) array_map_index_result_retains_element_address(node flat.Node, name string) bool {
+	if node.children_count == 0 {
+		return false
+	}
+	base_id := t.a.child(&node, 0)
+	if node.children_count > 1 {
+		base := t.a.nodes[int(base_id)]
+		index := t.a.child_node(&node, 1)
+		if base.kind == .array_literal && index.kind == .int_literal {
+			selected := index.value.int()
+			if selected >= 0 && selected < int(base.children_count) {
+				return t.array_map_expr_result_retains_element_address(t.a.child(&base, selected),
+					name)
+			}
+		}
+	}
+	return t.array_map_expr_result_retains_element_address(base_id, name)
+}
+
 fn (mut t Transformer) array_map_selector_result_retains_element_address(base_id flat.NodeId, field_name string, elem_name string) bool {
 	if int(base_id) < 0 || int(base_id) >= t.a.nodes.len {
 		return false
@@ -3583,11 +3601,31 @@ fn (mut t Transformer) stable_array_compare_fn(cmp_id flat.NodeId, elem_type str
 	if int(cmp_id) >= 0 && t.a.nodes[int(cmp_id)].kind == .lambda_expr {
 		return cmp_id
 	}
+	cmp_type := t.array_compare_fn_type(cmp_id, elem_type)
 	cmp := t.transform_expr(cmp_id)
-	cmp_type := 'fn (&${elem_type}, &${elem_type}) int'
 	return t.stable_transformed_expr_for_reuse(cmp, cmp_type, 'sort_cmp')
 }
 
+fn (t &Transformer) array_compare_fn_type(cmp_id flat.NodeId, elem_type string) string {
+	default_type := 'fn (&${elem_type}, &${elem_type}) int'
+	if isnil(t.tc) || int(cmp_id) < 0 || int(cmp_id) >= t.a.nodes.len {
+		return default_type
+	}
+	cmp_node := t.a.nodes[int(cmp_id)]
+	raw_type := if cmp_node.kind == .ident {
+		t.raw_var_type(cmp_node.value)
+	} else {
+		t.raw_checker_node_type(cmp_id)
+	}
+	if raw_type.len == 0 {
+		return default_type
+	}
+	if types.unalias_type(t.tc.parse_type(raw_type)) is types.FnType {
+		return raw_type
+	}
+	return default_type
+}
+
 // make_array_default_sort_stmt builds make array default sort stmt data for transform.
 fn (mut t Transformer) make_array_default_sort_stmt(base flat.NodeId, elem_type string, src flat.Node, cmp_id flat.NodeId) flat.NodeId {
 	if int(cmp_id) < 0 {