Segfault when assigning comptime fixed type function to comptime anytype function

[Veeloxfire]

Zig Version

0.13.0

Steps to Reproduce and Observed Behavior

(also fails using whatever version zig trunk on godbolt is using, but I wasnt sure exactly which that was so I put the version I currently have installed where it also fails)

Compile this code

const GenericFn = fn(comptime anytype)void;

fn foo(comptime _: i32) void {}

const f: GenericFn = foo;

pub fn main() void {
    _ = f(0);
}

https://godbolt.org/z/haEjaGqf7

Returns either "error code 5" or "SIGSEV" depending on setup

Expected Behavior

Im not sure what specifically I expect it to do, but I dont expect it to segfault

I suspect it should be a compile error (given it is for the non-comptime case) and that makes the most sense to me. But Im not 100% sure the intended behaviour isnt that this works, so I thought I'd report here instead of the "error message" section.

I'm pretty sure its const f: GenericFn = foo; thats segfaulting since _ = @TypeOf(f); also causes a segfault and that doesnt call it. (removing both doesnt segfault but I assume thats because its not instantiated)

[fluffinity]

In my opinion the assignment f: GenericFn = foo should result in a compile error. The problem is that the type of the first parameter of GenericFn is anytype whereas the type of the first parameter in foois i32. If you would call f with [_]u8{1}, for example, you would now call foo with an argument of type [1]u8 which is not i32 and, very importantly, has a different size and alignment to i32. This can easily result in the corruption of the stack.

The safest way to handle this is to enforce contravariance of parameter types, so if A is a subtype of B then fn(B) would be a subtype of fn(A), and covariance of return types, meaning if A is a subtype of B then fn()A is a subtype of fn()B.

As an example

const SpecificFn = fn(comptime i32)[*]u8;

fn generic(comptime _: anytype)  *u8 {}

const f: SpecificFn = generic;

Assuming that *u8 is a subtype of [*]u8 (it coerces to it) this assignment would be safe as we can only call f with i32 while generic accepts anytype and generic returns a *u8 which is basically a [*]u8 that points to exactly 1 element.