checker, cgen: fix generic static method resolving on IfGuard (fix #2…

…3269) (fix #23270) (#23273)

vlib/v/checker/if.v

@@ -93,6 +93,18 @@ fn (mut c Checker) if_expr(mut node ast.IfExpr) ast.Type {
 						branch.scope.update_var_type(var.name, mr_info.types[vi])
 					}
 				}
+			} else {
+				for _, var in branch.cond.vars {
+					if var.name == '_' {
+						continue
+					}
+					if w := branch.scope.find_var(var.name) {
+						if var.name !in branch.scope.objects {
+							branch.scope.objects[var.name] = w
+						}
+						branch.scope.update_var_type(var.name, branch.cond.expr_type.clear_option_and_result())
+					}
+				}
 			}
 		}
 		if node.is_comptime { // Skip checking if needed

vlib/v/checker/return.v

@@ -110,6 +110,11 @@ fn (mut c Checker) return_stmt(mut node ast.Return) {
 					if expr.obj.ct_type_var != .no_comptime {
 						typ = c.comptime.get_type_or_default(expr, typ)
 					}
+					if mut expr.obj.expr is ast.IfGuardExpr {
+						if var := expr.scope.find_var(expr.name) {
+							typ = var.typ
+						}
+					}
 				}
 			}
 			got_types << typ

vlib/v/gen/c/autofree.v

@@ -95,6 +95,9 @@ fn (mut g Gen) autofree_scope_vars2(scope &ast.Scope, start_pos int, end_pos int
 					// Do not free vars that were declared after this scope
 					continue
 				}
+				if obj.expr is ast.IfGuardExpr {
+					continue
+				}
 				g.autofree_variable(obj)
 			}
 			else {}

vlib/v/gen/c/fn.v

@@ -2109,12 +2109,17 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 		}
 		is_selector_call = true
 	}
+	mut node_name := node.name // name to find on fn table
 	mut name := node.name
 	if node.is_static_method {
 		// resolve static call T.name()
 		if g.cur_fn != unsafe { nil } {
 			_, name = g.table.convert_generic_static_type_name(node.name, g.cur_fn.generic_names,
 				g.cur_concrete_types)
+			if node.concrete_types.len > 0 {
+				// Resolves T.from() to real symbol name to search on fn table
+				node_name = name
+			}
 		}
 	}
 	is_print := name in ['print', 'println', 'eprint', 'eprintln', 'panic']
@@ -2210,7 +2215,7 @@ fn (mut g Gen) fn_call(node ast.CallExpr) {
 		}
 	}
 	if !is_selector_call {
-		if func := g.table.find_fn(node.name) {
+		if func := g.table.find_fn(node_name) {
 			mut concrete_types := node.concrete_types.map(g.unwrap_generic(it))
 			mut node_ := unsafe { node }
 			comptime_args := g.resolve_comptime_args(func, mut node_, concrete_types)

vlib/v/gen/c/if.v

@@ -253,7 +253,13 @@ fn (mut g Gen) if_expr(node ast.IfExpr) {
 			if cond.expr !in [ast.IndexExpr, ast.PrefixExpr] {
 				var_name := g.new_tmp_var()
 				guard_vars[i] = var_name
-				g.writeln('${g.styp(g.unwrap_generic(cond.expr_type))} ${var_name};')
+				cond_expr_type := if cond.expr is ast.CallExpr && cond.expr.is_static_method
+					&& cond.expr.left_type.has_flag(.generic) {
+					g.resolve_return_type(cond.expr)
+				} else {
+					cond.expr_type
+				}
+				g.writeln('${g.styp(g.unwrap_generic(cond_expr_type))} ${var_name};')
 			} else {
 				guard_vars[i] = ''
 			}

vlib/v/tests/enums/enum_from_generic_static_call_test.v

@@ -0,0 +1,23 @@
+fn prompt_enum[T](s string) !T {
+	if x := T.from(s) {
+		return x
+	}
+	return error('fail')
+}
+
+enum EnumA {
+	a
+	b
+	c
+}
+
+enum EnumB {
+	x
+	y
+	z
+}
+
+fn test_main() {
+	assert prompt_enum[EnumA]('a')! == EnumA.a
+	assert prompt_enum[EnumB]('x')! == EnumB.x
+}