Sema: add error for recursive inline call

Closes ziglang#12973

src/Sema.zig

@@ -335,6 +335,7 @@ pub const Block = struct {
     /// It is shared among all the blocks in an inline or comptime called
     /// function.
     pub const Inlining = struct {
+        func: ?*Module.Fn,
         comptime_result: Air.Inst.Ref,
         merges: Merges,
     };
@@ -6435,6 +6436,16 @@ fn analyzeCall(
             });
         }
 
+        const recursive_msg = "inline call is recursive";
+        var head = if (!is_comptime_call) block else null;
+        while (head) |some| {
+            const inlining = some.inlining orelse break;
+            if (inlining.func == module_fn) {
+                return sema.fail(block, call_src, recursive_msg, .{});
+            }
+            head = some.parent;
+        }
+
         // Analyze the ZIR. The same ZIR gets analyzed into a runtime function
         // or an inlined call depending on what union tag the `label` field is
         // set to in the `Block`.
@@ -6448,6 +6459,7 @@ fn analyzeCall(
         // This one is shared among sub-blocks within the same callee, but not
         // shared among the entire inline/comptime call stack.
         var inlining: Block.Inlining = .{
+            .func = if (!is_comptime_call) module_fn else null,
             .comptime_result = undefined,
             .merges = .{
                 .results = .{},
@@ -6657,6 +6669,7 @@ fn analyzeCall(
                     error.ComptimeReturn => break :result inlining.comptime_result,
                     error.AnalysisFail => {
                         const err_msg = sema.err orelse return err;
+                        if (std.mem.eql(u8, err_msg.msg, recursive_msg)) return err;
                         try sema.errNote(block, call_src, err_msg, "called from here", .{});
                         err_msg.clearTrace(sema.gpa);
                         return err;

test/cases/compile_errors/recursive_inline_fn.zig

@@ -0,0 +1,12 @@
+inline fn foo() void {
+    foo();
+}
+export fn entry() void {
+    foo();
+}
+
+// error
+// backend=stage2
+// target=native
+//
+// :2:8: error: inline call is recursive