handle pointer type AST in v2 codegen

Author: medvednikov

vlib/v2/gen/cleanc/cleanc_test.v

@@ -113,6 +113,18 @@ fn test_record_generic_struct_bindings_filters_lifetime_params() {
 	assert instances[0].params_key == 'Value'
 }
 
+fn test_expr_type_to_c_lowers_pointer_type() {
+	mut g := Gen.new([])
+	pointer_type := ast.Expr(ast.Type(ast.PointerType{
+		base_type: ast.Expr(ast.Ident{
+			name: 'Foo'
+		})
+	}))
+	assert g.expr_type_to_c(pointer_type) == 'Foo*'
+	assert g.is_pointer_type(pointer_type)
+	assert g.receiver_type_to_scope_name(pointer_type) == 'Foo'
+}
+
 fn test_fixed_array_elem_type_ready_accepts_primitive_alias() {
 	mut g := Gen.new([])
 	g.primitive_type_aliases['sha3__Lane'] = true

vlib/v2/gen/cleanc/flag_enum_codegen_test.v

@@ -111,3 +111,41 @@ struct Holder[^a] {
 	assert csrc.contains('Value value;')
 	assert !csrc.contains('T value;')
 }
+
+fn test_generate_c_lowers_pointer_type_params_receivers_fields_and_generics() {
+	csrc := generate_c_for_test('
+struct Foo {
+	value int
+}
+
+struct Node[T] {
+	value T
+}
+
+struct Holder {
+	item &Foo
+	node &Node[Foo]
+}
+
+fn ptr_value(foo &Foo) int {
+	return foo.value
+}
+
+fn (foo &Foo) method_value() int {
+	return foo.value
+}
+
+fn main() {
+	foo := Foo{}
+	_ := ptr_value(&foo)
+	_ := foo.method_value()
+}
+')
+	assert csrc.contains('Foo* item;')
+	assert csrc.contains('Node* node;')
+	assert csrc.contains('Foo value;')
+	assert csrc.contains('ptr_value(Foo* foo)')
+	assert csrc.contains('Foo__method_value(Foo* foo)')
+	assert !csrc.contains('int item;')
+	assert !csrc.contains('int ptr_value(int foo)')
+}

vlib/v2/gen/cleanc/fn.v

@@ -530,6 +530,9 @@ fn collect_generic_placeholder_names_from_expr(expr ast.Expr, mut seen map[strin
 					collect_generic_placeholder_names_from_expr(expr.key_type, mut seen, mut out)
 					collect_generic_placeholder_names_from_expr(expr.value_type, mut seen, mut out)
 				}
+				ast.PointerType {
+					collect_generic_placeholder_names_from_expr(expr.base_type, mut seen, mut out)
+				}
 				ast.OptionType {
 					collect_generic_placeholder_names_from_expr(expr.base_type, mut seen, mut out)
 				}
@@ -972,6 +975,12 @@ fn infer_generic_type_bindings_from_param(param ast.Expr, concrete types.Type, g
 							concrete.value_type, generic_params, mut bindings)
 					}
 				}
+				ast.PointerType {
+					if concrete is types.Pointer {
+						infer_generic_type_bindings_from_param(param.base_type, concrete.base_type,
+							generic_params, mut bindings)
+					}
+				}
 				ast.OptionType {
 					if concrete is types.OptionType {
 						infer_generic_type_bindings_from_param(param.base_type, concrete.base_type,
@@ -1004,6 +1013,11 @@ fn direct_generic_placeholder_name(e ast.Expr) string {
 		ast.ModifierExpr {
 			return direct_generic_placeholder_name(e.expr)
 		}
+		ast.Type {
+			if e is ast.PointerType {
+				return direct_generic_placeholder_name(e.base_type)
+			}
+		}
 		else {}
 	}
 
@@ -4946,6 +4960,9 @@ fn expr_has_generic_placeholder(e ast.Expr) bool {
 					return expr_has_generic_placeholder(e.key_type)
 						|| expr_has_generic_placeholder(e.value_type)
 				}
+				ast.PointerType {
+					return expr_has_generic_placeholder(e.base_type)
+				}
 				ast.OptionType {
 					return expr_has_generic_placeholder(e.base_type)
 				}

vlib/v2/gen/cleanc/struct.v

@@ -118,6 +118,9 @@ fn (mut g Gen) propagate_generic_bindings(e ast.Expr, parent_bindings map[string
 					g.propagate_generic_bindings(param, parent_bindings)
 				}
 			}
+			if e is ast.PointerType {
+				g.propagate_generic_bindings(e.base_type, parent_bindings)
+			}
 		}
 		ast.PrefixExpr {
 			g.propagate_generic_bindings(e.expr, parent_bindings)
@@ -187,6 +190,9 @@ fn (mut g Gen) scan_expr_for_generic_types(e ast.Expr) {
 				g.scan_expr_for_generic_types(e.key_type)
 				g.scan_expr_for_generic_types(e.value_type)
 			}
+			if e is ast.PointerType {
+				g.scan_expr_for_generic_types(e.base_type)
+			}
 			if e is ast.OptionType {
 				g.scan_expr_for_generic_types(e.base_type)
 			}

vlib/v2/gen/cleanc/types.v

@@ -603,6 +603,11 @@ fn (mut g Gen) is_pointer_type(e ast.Expr) bool {
 	if e is ast.ModifierExpr {
 		return g.is_pointer_type(e.expr)
 	}
+	if e is ast.Type {
+		if e is ast.PointerType {
+			return true
+		}
+	}
 	if e is ast.Ident {
 		if e.name in ['voidptr', 'charptr', 'byteptr'] || e.name.ends_with('ptr') {
 			return true
@@ -1685,6 +1690,9 @@ fn (g &Gen) receiver_type_to_scope_name(typ ast.Expr) string {
 		}
 	}
 	if typ is ast.Type {
+		if typ is ast.PointerType {
+			return g.receiver_type_to_scope_name(typ.base_type)
+		}
 		// Array type: []T -> "[]T"
 		if typ is ast.ArrayType {
 			elem := g.receiver_type_to_scope_name(typ.elem_type)
@@ -2593,6 +2601,9 @@ fn (mut g Gen) expr_type_to_c(e ast.Expr) string {
 			if e is ast.ChannelType {
 				return 'chan'
 			}
+			if e is ast.PointerType {
+				return g.expr_type_to_c(e.base_type) + '*'
+			}
 			if e is ast.TupleType {
 				mut elem_types := []string{cap: e.types.len}
 				for t in e.types {

vlib/v2/transformer/transformer_test.v

@@ -4206,6 +4206,17 @@ fn test_transformer_preserves_pointer_lifetime_in_v_syntax_but_not_c_names() {
 	assert t.type_to_c_name(ptr_type) == 'Fooptr'
 }
 
+fn test_transformer_uses_pointer_type_receiver_name_for_scope_key() {
+	t := create_test_transformer()
+	receiver := ast.Expr(ast.Type(ast.PointerType{
+		base_type: ast.Expr(ast.Ident{
+			name: 'Ignore'
+		})
+		lifetime:  'a'
+	}))
+	assert t.get_receiver_type_name(receiver) == 'Ignore'
+}
+
 fn test_transformer_preserves_lifetime_method_signature_and_nested_generic_return_type() {
 	files := transform_code_for_test('
 struct Ignore {}

vlib/v2/transformer/types.v

@@ -3090,6 +3090,9 @@ fn (t &Transformer) get_receiver_type_name(typ ast.Expr) string {
 	}
 	if typ is ast.Type {
 		// Handle wrapped type variants (GenericType, etc.)
+		if typ is ast.PointerType {
+			return t.get_receiver_type_name(typ.base_type)
+		}
 		if typ is ast.GenericType {
 			// Type[T] -> Type
 			return t.get_receiver_type_name(typ.name)