checker,cgen: fix generic str edge cases

Author: medvednikov

vlib/v/checker/str.v

@@ -96,7 +96,6 @@ fn (mut c Checker) string_inter_lit(mut node ast.StringInterLiteral) ast.Type {
 		if ftyp == 0 {
 			return ast.void_type
 		}
-		c.markused_string_inter_lit(mut node, ftyp)
 		c.fail_if_unreadable(expr, ftyp, 'interpolation object')
 		node.expr_types << ftyp
 		if i < node.fwidth_exprs.len {
@@ -179,6 +178,7 @@ fn (mut c Checker) string_inter_lit(mut node ast.StringInterLiteral) ast.Type {
 			&& c.table.cur_fn.name == 'str' && c.table.cur_fn.receiver.name == '${expr}' {
 			c.error('cannot call `str()` method recursively', expr.pos())
 		}
+		c.markused_string_inter_lit(mut node, ftyp, fmt)
 	}
 	c.inside_interface_deref = inside_interface_deref_save
 	if c.pref.warn_about_allocs {

vlib/v/checker/used_features.v

@@ -213,17 +213,26 @@ fn (mut c Checker) markused_method_call(mut node ast.CallExpr, mut left_expr ast
 	}
 }
 
-fn (mut c Checker) markused_string_inter_lit(mut _ ast.StringInterLiteral, ftyp ast.Type) {
+fn string_inter_lit_format_uses_str(fmt u8) bool {
+	return fmt == `s`
+}
+
+fn (mut c Checker) markused_string_inter_lit(mut _ ast.StringInterLiteral, ftyp ast.Type, fmt u8) {
 	if c.is_builtin_mod {
 		return
 	}
+	uses_str_format := string_inter_lit_format_uses_str(fmt)
 	if !c.table.sym(ftyp).has_method('str') {
-		c.table.used_features.auto_str = true
-		c.markused_auto_str_dependencies(ftyp)
+		if uses_str_format {
+			c.table.used_features.auto_str = true
+			c.markused_auto_str_dependencies(ftyp)
+		}
 	} else {
-		c.markused_generic_str_method(ftyp, c.table.sym(ftyp))
-		c.mark_type_str_method_as_referenced(ftyp)
-		c.table.used_features.print_types[ftyp.idx()] = true
+		if uses_str_format {
+			c.markused_generic_str_method(ftyp, c.table.sym(ftyp))
+			c.mark_type_str_method_as_referenced(ftyp)
+			c.table.used_features.print_types[ftyp.idx()] = true
+		}
 	}
 	if ftyp.is_ptr() {
 		c.table.used_features.auto_str_ptr = true

vlib/v/gen/c/auto_str_methods.v

@@ -92,9 +92,9 @@ fn (mut g Gen) get_str_fn(typ ast.Type) string {
 	}
 	if !g.pref.new_generic_solver {
 		if str_method := sym.find_method_with_generic_parent('str') {
-			if str_method.generic_names.len > 0 {
+			if method_has_generic_source(str_method) {
 				match mut sym.info {
-					ast.Struct, ast.SumType, ast.Interface, ast.Alias {
+					ast.Struct, ast.SumType, ast.Interface, ast.Alias, ast.GenericInst, ast.FnType {
 						str_fn_name = g.generic_fn_name(g.str_method_concrete_types(unwrapped, sym),
 							str_fn_name)
 					}
@@ -675,12 +675,29 @@ fn styp_to_str_fn_name(styp string) string {
 	return styp.replace_each(['*', '', '.', '__', ' ', '__']) + '_str'
 }
 
+fn method_has_generic_source(method ast.Fn) bool {
+	if method.generic_names.len > 0 {
+		return true
+	}
+	if method.source_fn != unsafe { nil } {
+		fndecl := unsafe { &ast.FnDecl(method.source_fn) }
+		return fndecl.generic_names.len > 0
+	}
+	return false
+}
+
 fn (mut g Gen) str_method_concrete_types(typ ast.Type, sym &ast.TypeSymbol) []ast.Type {
 	if _ := g.receiver_exact_method_for_type(typ, 'str') {
 		match sym.info {
 			ast.Struct, ast.SumType, ast.Interface {
 				return sym.info.concrete_types.clone()
 			}
+			ast.GenericInst {
+				return sym.info.concrete_types.clone()
+			}
+			ast.FnType {
+				return g.concrete_types_for_fn_type_symbol(sym)
+			}
 			ast.Alias {
 				return g.alias_parent_concrete_types(sym.info)
 			}
@@ -694,6 +711,12 @@ fn (mut g Gen) str_method_concrete_types(typ ast.Type, sym &ast.TypeSymbol) []as
 		ast.Struct, ast.SumType, ast.Interface {
 			return sym.info.concrete_types.clone()
 		}
+		ast.GenericInst {
+			return sym.info.concrete_types.clone()
+		}
+		ast.FnType {
+			return g.concrete_types_for_fn_type_symbol(sym)
+		}
 		ast.Alias {
 			return g.alias_parent_concrete_types(sym.info)
 		}
@@ -703,6 +726,15 @@ fn (mut g Gen) str_method_concrete_types(typ ast.Type, sym &ast.TypeSymbol) []as
 	return []ast.Type{}
 }
 
+fn (mut g Gen) concrete_types_for_fn_type_symbol(sym &ast.TypeSymbol) []ast.Type {
+	if sym.info is ast.FnType && sym.generic_types.len > 0
+		&& !sym.generic_types.any(it.has_flag(.generic)
+		|| g.table.generic_type_names(it).len > 0) {
+		return sym.generic_types.clone()
+	}
+	return []ast.Type{}
+}
+
 fn (mut g Gen) alias_parent_concrete_types(info ast.Alias) []ast.Type {
 	parent_sym := g.table.sym(info.parent_type)
 	match parent_sym.info {
@@ -1230,9 +1262,10 @@ fn (mut g Gen) gen_str_for_struct(info ast.Struct, lang ast.Language, styp strin
 			}
 			if !g.pref.new_generic_solver {
 				if str_method := sym.find_method_with_generic_parent('str') {
-					if str_method.generic_names.len > 0 && !ftyp_noshared.has_flag(.option) {
+					if method_has_generic_source(str_method) && !ftyp_noshared.has_flag(.option) {
 						match sym.info {
-							ast.Struct, ast.SumType, ast.Interface, ast.Alias {
+							ast.Struct, ast.SumType, ast.Interface, ast.Alias, ast.GenericInst,
+							ast.FnType {
 								field_fn_name = g.generic_fn_name(g.str_method_concrete_types(ftyp_noshared, sym),
 									field_fn_name)
 							}
@@ -1436,6 +1469,9 @@ fn struct_auto_str_func(sym &ast.TypeSymbol, lang ast.Language, _field_type ast.
 		}
 		return 'indent_${fn_name}(${obj}, indent_count + 1)', true
 	} else if sym.kind == .function {
+		if has_custom_str {
+			return '${fn_name}(${prefix}it${op}${final_field_name}${sufix})', true
+		}
 		return '${fn_name}()', true
 	} else if sym.kind == .chan {
 		return '${fn_name}(${deref}it${op}${final_field_name}${sufix})', true

vlib/v/tests/generics/generic_auto_str_nested_generic_field_test.v

@@ -20,12 +20,18 @@ struct OverrideBox[T] {
 	val T
 }
 
+struct PointerInterpBad[T] {
+	val T
+}
+
 type InterpIntBox = InterpBox[int]
 
 type OverrideIntBox = OverrideBox[[]int]
 
 type Ints = []int
 
+type Parser[T] = fn (string) T
+
 struct StructuredContainer[T] {
 	box Box[[]T]
 }
@@ -34,6 +40,10 @@ struct IntsContainer {
 	values Ints
 }
 
+struct ParserContainer {
+	parser Parser[int] @[required]
+}
+
 struct AssertNode[T] {
 	val T
 }
@@ -73,10 +83,27 @@ fn (box OverrideIntBox) str[T]() string {
 	return 'override alias ${box.val[0]}'
 }
 
+fn (bad &PointerInterpBad[[]T]) str() string {
+	$if T is int {
+		$compile_error('pointer interpolation should not register str')
+	}
+	return 'bad pointer ${bad.val}'
+}
+
 fn (values Ints) str[T]() string {
 	return 'ints ${values[0]}'
 }
 
+fn (p Parser[T]) str[T]() string {
+	return 'parser'
+}
+
+fn new_int_parser() Parser[int] {
+	return fn (input string) int {
+		return input.int()
+	}
+}
+
 fn (list AssertList[T]) str() string {
 	return 'assert list'
 }
@@ -121,6 +148,14 @@ fn test_interpolation_registers_only_overridden_alias_str_method() {
 	assert '${box}' == 'override alias 246'
 }
 
+fn test_pointer_interpolation_does_not_register_generic_str_method() {
+	mut value := PointerInterpBad[[]int]{
+		val: [135]
+	}
+	ptr := &value
+	assert '${ptr:p}'.len > 0
+}
+
 fn test_auto_str_registers_container_alias_parent_str_method() {
 	c := IntsContainer{
 		values: Ints([654])
@@ -133,6 +168,18 @@ fn test_interpolation_registers_container_alias_parent_str_method() {
 	assert '${values}' == 'ints 321'
 }
 
+fn test_auto_str_registers_generic_fn_type_alias_str_method() {
+	c := ParserContainer{
+		parser: new_int_parser()
+	}
+	assert '${c}'.contains('parser: parser')
+}
+
+fn test_interpolation_registers_generic_fn_type_alias_str_method() {
+	parser := new_int_parser()
+	assert '${parser}' == 'parser'
+}
+
 fn test_dump_registers_exact_generic_alias_str_method() {
 	box := InterpIntBox{
 		val: 654