ok

Author: medvednikov

vlib/v/checker/check_types.v

@@ -1263,7 +1263,10 @@ fn (mut c Checker) infer_fn_generic_types(func &ast.Fn, mut node ast.CallExpr) {
 				// Use param.typ (not param_infer_typ) to get the actual pointer
 				// count including mut lowering, so that e.g. `mut val T` with
 				// param.typ=&T correctly strips the pointer from the arg type.
-				if param.typ.nr_muls() > 0 && typ.nr_muls() > 0 && !arg.is_mut {
+				// For auto-deref vars passed as mut, skip stripping since their
+				// type already has the auto-deref pointer removed.
+				if param.typ.nr_muls() > 0 && typ.nr_muls() > 0
+					&& (!arg.is_mut || !arg.expr.is_auto_deref_var()) {
 					param_muls := param.typ.nr_muls()
 					arg_muls := typ.nr_muls()
 					typ = if arg_muls >= param_muls {

vlib/v/checker/interface.v

@@ -411,16 +411,22 @@ fn (mut c Checker) unwrap_generic_interface(typ ast.Type, interface_type ast.Typ
 				}
 				inferred_types << inferred_type
 			}
-			// add concrete types to method
-			for imethod in inter_sym.info.methods {
-				im_fkey := imethod.fkey()
-				if c.table.register_fn_concrete_types(im_fkey, inferred_types) {
-					c.need_recheck_generic_fns = true
-				}
-				if method := typ_sym.find_method_with_generic_parent(imethod.name) {
-					if c.table.register_fn_concrete_types(method.fkey(), inferred_types) {
+			// add concrete types to method, but only if at least one
+			// inferred type is actually concrete (not still generic).
+			// When all inferred types are generic (e.g. T -> T from
+			// `implements`), registering them would cause a circular
+			// recheck that fails to resolve field types.
+			if !inferred_types.all(it.has_flag(.generic)) {
+				for imethod in inter_sym.info.methods {
+					im_fkey := imethod.fkey()
+					if c.table.register_fn_concrete_types(im_fkey, inferred_types) {
 						c.need_recheck_generic_fns = true
 					}
+					if method := typ_sym.find_method_with_generic_parent(imethod.name) {
+						if c.table.register_fn_concrete_types(method.fkey(), inferred_types) {
+							c.need_recheck_generic_fns = true
+						}
+					}
 				}
 			}
 			result_type := c.table.unwrap_generic_type(interface_type, generic_names,

vlib/v/checker/tests/implements_generic_err.out

@@ -1,41 +1,21 @@
 vlib/v/checker/tests/implements_generic_err.vv:12:31: error: missing generic type on IB
    10 | }
-   11 | 
+   11 |
    12 | struct Foo1[T] implements IA, IB {
       |                               ~~
    13 |     a int
    14 |     b T
 vlib/v/checker/tests/implements_generic_err.vv:17:31: error: unknown generic type Y
    15 | }
-   16 | 
+   16 |
    17 | struct Foo2[T] implements IA, IB[Y] {
       |                               ~~
    18 |     a int
    19 |     b T
 vlib/v/checker/tests/implements_generic_err.vv:22:31: error: unknown generic type Y
    20 | }
-   21 | 
+   21 |
    22 | struct Foo3[T] implements IA, IB[T,Y] {
       |                               ~~
    23 |     a int
    24 |     b T
-vlib/v/checker/tests/implements_generic_err.vv:28:2: error: `println` can not print void expressions
-   26 | 
-   27 | fn (foo Foo1[T]) fa() {
-   28 |     println(foo.b)
-      |     ~~~~~~~~~~~~~~
-   29 | }
-   30 |
-vlib/v/checker/tests/implements_generic_err.vv:32:2: error: `println` can not print void expressions
-   30 | 
-   31 | fn (foo Foo2[T]) fa() {
-   32 |     println(foo.b)
-      |     ~~~~~~~~~~~~~~
-   33 | }
-   34 |
-vlib/v/checker/tests/implements_generic_err.vv:36:2: error: `println` can not print void expressions
-   34 | 
-   35 | fn (foo Foo3[T]) fa() {
-   36 |     println(foo.b)
-      |     ~~~~~~~~~~~~~~
-   37 | }

vlib/v/gen/c/auto_str_methods.v

@@ -1142,7 +1142,7 @@ fn (mut g Gen) gen_str_for_struct(info ast.Struct, lang ast.Language, styp strin
 			funcprefix += ' ? _S("nil") : '
 			// struct, floats and ints have a special case through the _str function
 			if !ftyp_noshared.has_flag(.option)
-				&& sym.kind !in [.struct, .alias, .enum, .sum_type, .map, .interface]
+				&& sym.kind !in [.struct, .alias, .enum, .sum_type, .map, .interface, .bool]
 				&& !field.typ.is_int_valptr() && !field.typ.is_float_valptr() {
 				funcprefix += '*'
 			}
@@ -1266,7 +1266,8 @@ fn struct_auto_str_func(sym &ast.TypeSymbol, lang ast.Language, _field_type ast.
 			method_str = 'it${op}${final_field_name}${sufix}'
 		}
 		if sym.kind == .bool {
-			return '(${method_str} ? _S("true") : _S("false"))', false
+			deref_str := if field_type.is_ptr() { '*${method_str}' } else { method_str }
+			return '(${deref_str} ? _S("true") : _S("false"))', false
 		} else if (field_type.is_int_valptr() || field_type.is_float_valptr()) && !expects_ptr {
 			// ptr int can be "nil", so this needs to be casted to a string
 			if sym.kind == .f32 {

vlib/v/gen/c/cgen.v

@@ -5268,14 +5268,12 @@ fn (mut g Gen) selector_expr(node ast.SelectorExpr) {
 				} else if node.field_name in ['idx', 'unaliased_typ'] {
 					// `T.idx`, `T.unaliased_typ`, `typeof(expr).idx`, `typeof(expr).unalised_typ`
 					mut name_type := node.name_type
-					mut resolved_via_generic := false
 					if node.expr is ast.TypeOf {
 						if g.cur_fn != unsafe { nil } && g.cur_concrete_types.len > 0 {
 							resolved := g.resolve_typeof_in_generic(node.expr)
 							if resolved != 0 {
 								name_type = g.type_resolver.typeof_field_type(resolved,
 									node.field_name)
-								resolved_via_generic = true
 							} else {
 								name_type = g.type_resolver.typeof_field_type(g.type_resolver.typeof_type(node.expr.expr,
 									g.resolve_typeof_expr_type(node.expr.expr, name_type)),
@@ -5288,7 +5286,7 @@ fn (mut g Gen) selector_expr(node ast.SelectorExpr) {
 						}
 						// For mut params (auto_deref), strip pointer so that
 						// typeof(mut_param).idx == typeof(val_param).idx
-						if !resolved_via_generic && node.expr.expr is ast.Ident {
+						if node.expr.expr is ast.Ident {
 							if node.expr.expr.obj is ast.Var {
 								if node.expr.expr.obj.is_auto_deref && name_type.is_ptr() {
 									name_type = name_type.deref()
@@ -6948,7 +6946,8 @@ fn (mut g Gen) ident(node ast.Ident) {
 					} else {
 						comptime_type
 					}
-					g.or_block(var_name, node.or_expr, or_return_type)
+					g.or_block(var_name, node.or_expr, g.or_type_with_auto_deref(node,
+						or_return_type))
 					g.writeln(stmt_str)
 				}
 				return
@@ -7019,7 +7018,7 @@ fn (mut g Gen) ident(node ast.Ident) {
 				} else {
 					node.info.typ
 				}
-				g.or_block(var_name, node.or_expr, or_return_type)
+				g.or_block(var_name, node.or_expr, g.or_type_with_auto_deref(node, or_return_type))
 				g.write(stmt_str)
 			}
 			if has_resolved_var {
@@ -7295,7 +7294,7 @@ fn (mut g Gen) ident(node ast.Ident) {
 		stmt_str := g.go_before_last_stmt().trim_space()
 		g.empty_line = true
 		var_opt := if is_auto_heap { '(*${name})' } else { name }
-		g.or_block(var_opt, node.or_expr, node.obj.typ)
+		g.or_block(var_opt, node.or_expr, g.or_type_with_auto_deref(node, node.obj.typ))
 		g.write(stmt_str)
 	}
 }
@@ -9226,6 +9225,16 @@ fn (mut g Gen) gen_or_block_stmts(cvar_name string, cast_typ string, stmts []ast
 // If the user is not using the option return value. We need to pass a temp var
 // to access its fields (`.ok`, `.error` etc)
 // `os.cp(...)` => `Option bool tmp = os__cp(...); if (tmp.state != 0) { ... }`
+// For auto-deref option variables (e.g. `mut t ?&T`), ensure the
+// `option_mut_param_t` flag is set so that `or_block` uses `->` instead of `.`.
+fn (g &Gen) or_type_with_auto_deref(node ast.Ident, typ ast.Type) ast.Type {
+	if node.obj is ast.Var && node.obj.is_auto_deref && typ.has_flag(.option)
+		&& !typ.has_flag(.option_mut_param_t) {
+		return typ.set_flag(.option_mut_param_t)
+	}
+	return typ
+}
+
 // Returns the type of the last stmt
 fn (mut g Gen) or_block(var_name string, or_block ast.OrExpr, return_type ast.Type) {
 	cvar_name := c_name(var_name)

vlib/v/gen/c/fn.v

@@ -2010,8 +2010,8 @@ fn (mut g Gen) gen_array_method_call(node ast.CallExpr, left_type ast.Type, left
 			if node.kind in [.pop_left, .pop] {
 				g.gen_arg_from_type(left_type, node.left)
 			} else {
-				if node.left_type.is_ptr() {
-					g.write2('(', '*'.repeat(node.left_type.nr_muls()))
+				if node.left_type.is_ptr() || node.left.is_auto_deref_var() {
+					g.write('(*')
 					g.expr(node.left)
 					g.write(')')
 				} else {

vlib/v/gen/c/for.v

@@ -395,7 +395,11 @@ fn (mut g Gen) for_in_stmt(node_ ast.ForInStmt) {
 		}
 		mut styp := g.styp(node.val_type)
 		mut val_sym := g.table.sym(node.val_type)
-		op_field := g.dot_or_ptr(node.cond_type)
+		op_field := if node.cond_type.is_ptr() || resolved_cond_expr.is_auto_deref_var() {
+			'->'
+		} else {
+			g.dot_or_ptr(node.cond_type)
+		}
 
 		mut cond_var := ''
 		// Check if the cond has an or-block that unwraps the option

vlib/v/gen/c/index.v

@@ -458,7 +458,7 @@ fn (mut g Gen) index_of_fixed_array(node ast.IndexExpr, sym ast.TypeSymbol) {
 		if is_fn_index_call {
 			g.write('(*')
 		}
-		if node.left_type.is_ptr() {
+		if node.left_type.is_ptr() || node.left.is_auto_deref_var() {
 			g.write('(*')
 			g.expr(ast.Expr(node.left))
 			g.write(')')