Sema: more validation for builtin decl types

src/Sema.zig

@@ -38581,7 +38581,7 @@ pub fn resolveNavPtrModifiers(
     };
 }
 
-pub fn analyzeMemoizedState(sema: *Sema, block: *Block, src: LazySrcLoc, builtin_namespace: InternPool.NamespaceIndex, stage: InternPool.MemoizedStateStage) CompileError!bool {
+pub fn analyzeMemoizedState(sema: *Sema, block: *Block, simple_src: LazySrcLoc, builtin_namespace: InternPool.NamespaceIndex, stage: InternPool.MemoizedStateStage) CompileError!bool {
     const pt = sema.pt;
     const zcu = pt.zcu;
     const ip = &zcu.intern_pool;
@@ -38596,38 +38596,47 @@ pub fn analyzeMemoizedState(sema: *Sema, block: *Block, src: LazySrcLoc, builtin
                 .nested => |nested| access: {
                     const parent_ty: Type = .fromInterned(zcu.builtin_decl_values.get(nested[0]));
                     const parent_ns = parent_ty.getNamespace(zcu).unwrap() orelse {
-                        return sema.fail(block, src, "std.builtin.{s} is not a container type", .{@tagName(nested[0])});
+                        return sema.fail(block, simple_src, "std.builtin.{s} is not a container type", .{@tagName(nested[0])});
                     };
                     break :access .{ parent_ns, "std.builtin." ++ @tagName(nested[0]), nested[1] };
                 },
             };
 
             const name_nts = try ip.getOrPutString(gpa, pt.tid, name, .no_embedded_nulls);
-            const result = try sema.namespaceLookupVal(block, src, parent_ns, name_nts) orelse
-                return sema.fail(block, src, "{s} missing {s}", .{ parent_name, name });
+            const nav = try sema.namespaceLookup(block, simple_src, parent_ns, name_nts) orelse
+                return sema.fail(block, simple_src, "{s} missing {s}", .{ parent_name, name });
 
-            const val = try sema.resolveConstDefinedValue(block, src, result, null);
+            const src: LazySrcLoc = .{
+                .base_node_inst = ip.getNav(nav).srcInst(ip),
+                .offset = .nodeOffset(0),
+            };
 
-            switch (builtin_decl.kind()) {
-                .type => if (val.typeOf(zcu).zigTypeTag(zcu) != .type) {
+            const result = try sema.analyzeNavVal(block, src, nav);
+
+            const uncoerced_val = try sema.resolveConstDefinedValue(block, src, result, null);
+            const maybe_lazy_val: Value = switch (builtin_decl.kind()) {
+                .type => if (uncoerced_val.typeOf(zcu).zigTypeTag(zcu) != .type) {
                     return sema.fail(block, src, "{s}.{s} is not a type", .{ parent_name, name });
-                } else {
-                    try val.toType().resolveFully(pt);
+                } else val: {
+                    try uncoerced_val.toType().resolveFully(pt);
+                    break :val uncoerced_val;
                 },
-                .func => if (val.typeOf(zcu).zigTypeTag(zcu) != .@"fn") {
-                    return sema.fail(block, src, "{s}.{s} is not a function", .{ parent_name, name });
-                },
-                .string => {
-                    const ty = val.typeOf(zcu);
-                    if (!ty.isSinglePointer(zcu) or
-                        !ty.isConstPtr(zcu) or
-                        ty.childType(zcu).zigTypeTag(zcu) != .array or
-                        ty.childType(zcu).childType(zcu).toIntern() != .u8_type)
-                    {
-                        return sema.fail(block, src, "{s}.{s} is not a valid string", .{ parent_name, name });
+                .func => val: {
+                    if (try sema.getExpectedBuiltinFnType(src, builtin_decl)) |func_ty| {
+                        const coerced = try sema.coerce(block, func_ty, Air.internedToRef(uncoerced_val.toIntern()), src);
+                        break :val .fromInterned(coerced.toInterned().?);
                     }
+                    if (uncoerced_val.typeOf(zcu).zigTypeTag(zcu) != .@"fn") {
+                        return sema.fail(block, src, "{s}.{s} is not a function", .{ parent_name, name });
+                    }
+                    break :val uncoerced_val;
                 },
-            }
+                .string => val: {
+                    const coerced = try sema.coerce(block, .slice_const_u8, Air.internedToRef(uncoerced_val.toIntern()), src);
+                    break :val .fromInterned(coerced.toInterned().?);
+                },
+            };
+            const val = try sema.resolveLazyValue(maybe_lazy_val);
 
             const prev = zcu.builtin_decl_values.get(builtin_decl);
             if (val.toIntern() != prev) {
@@ -38639,7 +38648,7 @@ pub fn analyzeMemoizedState(sema: *Sema, block: *Block, src: LazySrcLoc, builtin
 
     if (stage == .panic) {
         // We use `getBuiltinType` because this is from an earlier stage.
-        const stack_trace_ty = try sema.getBuiltinType(src, .StackTrace);
+        const stack_trace_ty = try sema.getBuiltinType(simple_src, .StackTrace);
         const ptr_stack_trace_ty = try pt.singleMutPtrType(stack_trace_ty);
         const opt_ptr_stack_trace_ty = try pt.optionalType(ptr_stack_trace_ty.toIntern());
         const null_stack_trace = try pt.intern(.{ .opt = .{
@@ -38654,3 +38663,59 @@ pub fn analyzeMemoizedState(sema: *Sema, block: *Block, src: LazySrcLoc, builtin
 
     return any_changed;
 }
+
+/// Given that `decl.kind() == .func`, get the type expected of the function if necessary.
+/// If this will be type checked by `Sema` anyway, this function may return `null`. In
+/// particular, generic functions should return `null`, as `Sema` will necessarily check
+/// them at instantiation time. Returning non-null is necessary only when backends can emit
+/// calls to the function, as is the case with the panic handler.
+fn getExpectedBuiltinFnType(sema: *Sema, src: LazySrcLoc, decl: Zcu.BuiltinDecl) CompileError!?Type {
+    const pt = sema.pt;
+    return switch (decl) {
+        // `fn ([]const u8, ?*StackTrace, ?usize) noreturn`
+        .@"Panic.call" => try pt.funcType(.{
+            .param_types = &.{
+                .slice_const_u8_type,
+                (try pt.optionalType(
+                    (try pt.singleMutPtrType(
+                        try sema.getBuiltinType(src, .StackTrace),
+                    )).toIntern(),
+                )).toIntern(),
+                (try pt.optionalType(.usize_type)).toIntern(),
+            },
+            .return_type = .noreturn_type,
+        }),
+
+        // `fn (?*StackTrace, anyerror) noreturn`
+        .@"Panic.unwrapError" => try pt.funcType(.{
+            .param_types = &.{
+                (try pt.optionalType(
+                    (try pt.singleMutPtrType(
+                        try sema.getBuiltinType(src, .StackTrace),
+                    )).toIntern(),
+                )).toIntern(),
+                .anyerror_type,
+            },
+            .return_type = .noreturn_type,
+        }),
+
+        // `fn (usize, usize) noreturn`
+        .@"Panic.outOfBounds",
+        .@"Panic.startGreaterThanEnd",
+        => try pt.funcType(.{
+            .param_types = &.{ .usize_type, .usize_type },
+            .return_type = .noreturn_type,
+        }),
+
+        // Generic functions, so calls are necessarily validated by Sema
+        .@"Panic.sentinelMismatch",
+        .@"Panic.inactiveUnionField",
+        => null,
+
+        // Other functions called exclusively by Sema
+        .returnError,
+        => null,
+
+        else => unreachable,
+    };
+}

src/codegen/llvm.zig

@@ -5754,10 +5754,12 @@ pub const FuncGen = struct {
         const o = fg.ng.object;
         const zcu = o.pt.zcu;
         const ip = &zcu.intern_pool;
-        const panic_msg_val = zcu.builtin_decl_values.get(panic_id.toBuiltin());
-        assert(panic_msg_val != .none);
-        const msg_len = Value.fromInterned(panic_msg_val).typeOf(zcu).childType(zcu).arrayLen(zcu);
-        const msg_ptr = try o.lowerValue(panic_msg_val);
+        const msg_len: u64, const msg_ptr: Builder.Constant = msg: {
+            const str_val = zcu.builtin_decl_values.get(panic_id.toBuiltin());
+            assert(str_val != .none);
+            const slice = ip.indexToKey(str_val).slice;
+            break :msg .{ Value.fromInterned(slice.len).toUnsignedInt(zcu), try o.lowerValue(slice.ptr) };
+        };
         const null_opt_addr_global = try fg.resolveNullOptUsize();
         const target = zcu.getTarget();
         const llvm_usize = try o.lowerType(Type.usize);

test/cases/compile_errors/bad_panic_signature.zig

@@ -0,0 +1,28 @@
+pub const Panic = struct {
+    pub const call = badPanicSignature;
+    pub const sentinelMismatch = std.debug.FormattedPanic.sentinelMismatch;
+    pub const unwrapError = std.debug.FormattedPanic.unwrapError;
+    pub const outOfBounds = std.debug.FormattedPanic.outOfBounds;
+    pub const startGreaterThanEnd = std.debug.FormattedPanic.startGreaterThanEnd;
+    pub const inactiveUnionField = std.debug.FormattedPanic.inactiveUnionField;
+    pub const messages = std.debug.FormattedPanic.messages;
+};
+
+fn badPanicSignature(msg: []const u8, bad1: usize, bad2: void) noreturn {
+    _ = msg;
+    _ = bad1;
+    _ = bad2;
+    @trap();
+}
+
+export fn foo(a: u8) void {
+    @setRuntimeSafety(true);
+    _ = a + 1; // safety check to reference the panic handler
+}
+
+const std = @import("std");
+
+// error
+//
+// :2:9: error: expected type 'fn ([]const u8, ?*builtin.StackTrace, ?usize) noreturn', found 'fn ([]const u8, usize, void) noreturn'
+// :2:9: note: parameter 1 'usize' cannot cast into '?*builtin.StackTrace'