filter lifetime params from generic struct bindings

Author: medvednikov

vlib/v2/gen/cleanc/cleanc_test.v

@@ -2,6 +2,7 @@
 module cleanc
 
 import v2.ast
+import v2.types
 
 fn test_c_string_literal_content_to_c_single_line() {
 	out := c_string_literal_content_to_c('hello')
@@ -57,6 +58,61 @@ fn test_struct_generic_params_need_bindings_returns_true_for_runtime_generic_par
 	assert struct_generic_params_need_bindings(params)
 }
 
+fn test_runtime_generic_params_filter_lifetime_params() {
+	params := [
+		ast.Expr(ast.LifetimeExpr{
+			name: 'a'
+		}),
+		ast.Expr(ast.Ident{
+			name: 'T'
+		}),
+	]
+	args := [
+		ast.Expr(ast.LifetimeExpr{
+			name: 'a'
+		}),
+		ast.Expr(ast.Ident{
+			name: 'Value'
+		}),
+	]
+	filtered_args := runtime_generic_args(args)
+	assert runtime_generic_param_names(['^a', 'T']) == ['T']
+	assert generic_param_names(params) == ['T']
+	assert filtered_args.len == 1
+	assert filtered_args[0] is ast.Ident
+	assert (filtered_args[0] as ast.Ident).name == 'Value'
+}
+
+fn test_record_generic_struct_bindings_filters_lifetime_params() {
+	mut env := types.Environment.new()
+	mut scope := types.new_scope(unsafe { nil })
+	scope.insert('Ref', types.Object(types.Type(types.Struct{
+		name:           'Ref'
+		generic_params: ['^a', 'T']
+	})))
+	scope.insert('Value', types.Object(types.Type(types.Struct{
+		name: 'Value'
+	})))
+	lock env.scopes {
+		env.scopes['main'] = scope
+	}
+	mut g := Gen.new_with_env([], env)
+	g.record_generic_struct_bindings('Ref', 'Ref', [
+		ast.Expr(ast.LifetimeExpr{
+			name: 'a'
+		}),
+		ast.Expr(ast.Ident{
+			name: 'Value'
+		}),
+	])
+	bindings := (g.generic_struct_bindings['Ref'] or { panic('missing Ref binding') }).clone()
+	value_type := bindings['T'] or { panic('missing T binding') }
+	assert value_type.name() == 'Value'
+	instances := g.generic_struct_instances['Ref']
+	assert instances.len == 1
+	assert instances[0].params_key == 'Value'
+}
+
 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

@@ -92,3 +92,22 @@ fn test_generate_c_uses_concrete_map_method_name_in_generic_comptime_body() {
 	assert csrc.contains('Map_string_int__query_item(')
 	assert !csrc.contains('map__query_item(')
 }
+
+fn test_generate_c_filters_lifetime_params_from_generic_struct_binding() {
+	csrc := generate_c_for_test('
+struct Value {
+	n int
+}
+
+struct Ref[^a, T] {
+	value T
+}
+
+struct Holder[^a] {
+	item Ref[^a, Value]
+}
+')
+	assert csrc.contains('struct Ref {')
+	assert csrc.contains('Value value;')
+	assert !csrc.contains('T value;')
+}

vlib/v2/gen/cleanc/struct.v

@@ -16,6 +16,28 @@ fn struct_generic_params_need_bindings(params []ast.Expr) bool {
 	return false
 }
 
+fn runtime_generic_param_names(param_names []string) []string {
+	mut names := []string{cap: param_names.len}
+	for name in param_names {
+		if name.starts_with('^') {
+			continue
+		}
+		names << name
+	}
+	return names
+}
+
+fn runtime_generic_args(params []ast.Expr) []ast.Expr {
+	mut args := []ast.Expr{cap: params.len}
+	for param in params {
+		if param is ast.LifetimeExpr {
+			continue
+		}
+		args << param
+	}
+	return args
+}
+
 // collect_generic_struct_bindings scans all struct fields for GenericType
 // instantiations (e.g. LinkedList[ValueInfo]) and records the concrete type
 // bindings so that methods on generic structs can resolve their generic params.

vlib/v2/gen/cleanc/types.v

@@ -2706,15 +2706,16 @@ fn (g &Gen) is_c_type_name(name string) bool {
 fn (mut g Gen) record_generic_struct_bindings(struct_base_name string, struct_c_name string, concrete_params []ast.Expr) {
 	// Find the struct decl to get generic param names.
 	env_struct := g.lookup_struct_type(struct_base_name)
-	generic_param_names := env_struct.generic_params
-	if generic_param_names.len == 0 || generic_param_names.len != concrete_params.len {
+	generic_param_names := runtime_generic_param_names(env_struct.generic_params)
+	concrete_runtime_params := runtime_generic_args(concrete_params)
+	if generic_param_names.len == 0 || generic_param_names.len != concrete_runtime_params.len {
 		return
 	}
 	// Check that all concrete params are non-placeholder types.
 	mut bindings := map[string]types.Type{}
-	mut param_c_names := []string{cap: concrete_params.len}
+	mut param_c_names := []string{cap: concrete_runtime_params.len}
 	for i, param_name in generic_param_names {
-		concrete_expr := concrete_params[i]
+		concrete_expr := concrete_runtime_params[i]
 		if is_generic_placeholder_type_name(concrete_expr.name()) {
 			return
 		}
@@ -2762,14 +2763,15 @@ fn (mut g Gen) record_generic_struct_bindings(struct_base_name string, struct_c_
 // by resolving placeholder params through the parent struct's known bindings.
 fn (mut g Gen) record_generic_struct_bindings_with_parent(struct_base_name string, struct_c_name string, concrete_params []ast.Expr, parent_bindings map[string]types.Type) {
 	env_struct := g.lookup_struct_type(struct_base_name)
-	generic_param_names := env_struct.generic_params
-	if generic_param_names.len == 0 || generic_param_names.len != concrete_params.len {
+	generic_param_names := runtime_generic_param_names(env_struct.generic_params)
+	concrete_runtime_params := runtime_generic_args(concrete_params)
+	if generic_param_names.len == 0 || generic_param_names.len != concrete_runtime_params.len {
 		return
 	}
 	mut bindings := map[string]types.Type{}
-	mut param_c_names := []string{cap: concrete_params.len}
+	mut param_c_names := []string{cap: concrete_runtime_params.len}
 	for i, param_name in generic_param_names {
-		concrete_expr := concrete_params[i]
+		concrete_expr := concrete_runtime_params[i]
 		expr_name := concrete_expr.name()
 		if is_generic_placeholder_type_name(expr_name) {
 			if parent_type := parent_bindings[expr_name] {
@@ -2825,8 +2827,9 @@ fn (mut g Gen) resolve_generic_struct_c_name(base_name string, concrete_params [
 	if instances.len <= 1 {
 		return base_name
 	}
-	mut param_c_names := []string{cap: concrete_params.len}
-	for p in concrete_params {
+	concrete_runtime_params := runtime_generic_args(concrete_params)
+	mut param_c_names := []string{cap: concrete_runtime_params.len}
+	for p in concrete_runtime_params {
 		param_c_names << g.expr_type_to_c(p)
 	}
 	params_key := param_c_names.join('_')
@@ -3928,9 +3931,10 @@ fn (mut g Gen) resolve_generic_struct_field_name(expr ast.Expr) string {
 			// Build the params_key from active_generic_types
 			// Find the struct's generic params to know the order
 			env_struct := g.lookup_struct_type(c_name.all_after_last('__'))
-			if env_struct.generic_params.len > 0 {
-				mut param_c_names := []string{cap: env_struct.generic_params.len}
-				for param_name in env_struct.generic_params {
+			generic_param_names := runtime_generic_param_names(env_struct.generic_params)
+			if generic_param_names.len > 0 {
+				mut param_c_names := []string{cap: generic_param_names.len}
+				for param_name in generic_param_names {
 					if concrete := g.active_generic_types[param_name] {
 						param_c_names << g.types_type_to_c(concrete)
 					} else {