Fix self-recursive generic function call with explicit type args

namedFuncDecl registered a top-level generic function in the
generic-func registry only AFTER compiling its body. hasGenericFunc(name)
is what lets the expression compiler recognize name[T](...) as a
generic call rather than an indexing expression, so a self-recursive
call using explicit type args inside that same body (a common pattern
for generic recursive functions) was misparsed as indexing — evaluating
T as a nonexistent runtime variable and panicking with NotDefined.

Fixed by registering the generic function before compiling its body,
so a self-recursive call sees it already registered.

Author: ganehag

src/compiler_test.zig

@@ -3998,6 +3998,26 @@ test "compiler: dunder operators work at runtime inside a type-erased generic fu
     try std.testing.expectEqual(@as(i64, 7), result.int);
 }
 
+// addGenericFunc used to run AFTER compiling the function's own body, so a
+// self-recursive call with explicit type args (countdown[T](...)) inside
+// that same body couldn't find hasGenericFunc(name) yet — compiler_expr.zig
+// treated `countdown[T]` as an indexing expression instead of a generic
+// call, evaluating `T` as a (nonexistent) runtime variable and panicking
+// with NotDefined. Fixed by registering a top-level generic function before
+// compiling its body.
+test "compiler: self-recursive generic function call with explicit type args" {
+    var rt = try setup();
+    defer rt.deinit();
+    try runSrc(&rt,
+        \\func countdown[T](x T, n int) T {
+        \\    if n <= 0 { return x }
+        \\    return countdown[T](x, n - 1)
+        \\}
+    );
+    const result = try rt.callGlobal("countdown", &.{ .{ .int = 0 }, .{ .int = 5 } });
+    try std.testing.expectEqual(@as(i64, 0), result.int);
+}
+
 test "compiler: := infers struct type for dunder dispatch, same as an explicitly var-typed local" {
     // Struct literals previously left no ExprPrimInfo on their own result at
     // all, and := never inferred struct_type for a local either — both

src/lang/compiler_decls.zig

@@ -402,6 +402,20 @@ pub fn namedFuncDecl(c: anytype, is_pub: bool) !void {
     }
     errdefer c.type_param_count = saved_param_count;
 
+    // A top-level generic function must be registered in the generic-func
+    // registry BEFORE its body is compiled: hasGenericFunc(name) is what
+    // lets the expression compiler recognize name[T](...) as a generic
+    // call rather than an indexing expression (compiler_expr.zig), and a
+    // self-recursive call inside the body needs that recognition already
+    // in effect — registering afterward (as this used to) left every
+    // recursive call misparsed as indexing, panicking at runtime.
+    if (is_generic and !c.inFunc() and !c.skipping_test_body) {
+        const qname_early = try c.qualifyGlobalName(name.src);
+        var gi: ct.GenericFuncInfo = .{ .name = try c.copyName(name.src), .param_count = tparam_count, .qname = qname_early };
+        for (tparams[0..tparam_count], 0..) |tp, i| gi.params[i] = tp;
+        try c.registry.addGenericFunc(gi);
+    }
+
     // current token is '('; compile as a named function for return-type enforcement
     if (!is_generic) c.pending_func_qname = try c.qualifyGlobalName(name.src);
     _ = try c.compileFuncWithPrefix(&[_][]const u8{}, true, null);
@@ -428,11 +442,7 @@ pub fn namedFuncDecl(c: anytype, is_pub: bool) !void {
                     c.registry.setGlobalFuncReturnCount(qname, fo.function.named_return_count);
                 }
             }
-            if (is_generic) {
-                var gi: ct.GenericFuncInfo = .{ .name = try c.copyName(name.src), .param_count = tparam_count, .qname = qname };
-                for (tparams[0..tparam_count], 0..) |tp, i| gi.params[i] = tp;
-                try c.registry.addGenericFunc(gi);
-            }
+            // (generic registration now happens above, before compiling the body)
         }
         try c.cs.emitOpStringConst(.def_global, qname, kw.line);
         if (is_pub) try c.addExport(name.src, qname);