An interesting way to do stack allocation in Zig

stack.zig

const std = @import("std");

pub const Params = struct {
    Return: type,
    Args: type,
};

pub fn with(
    comptime T: type,
    comptime params: Params,
    args: params.Args,
    size: usize,
    callback: fn (params.Args, []T) params.Return,
) params.Return {
    return switch (size) {
        (0 << 0)...(1 << 11) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 11) - 1 }),
        (1 << 11)...(1 << 12) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 12) - 1 }),
        (1 << 12)...(1 << 13) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 13) - 1 }),
        (1 << 13)...(1 << 14) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 14) - 1 }),
        (1 << 14)...(1 << 15) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 15) - 1 }),
        (1 << 15)...(1 << 16) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 16) - 1 }),
        (1 << 16)...(1 << 17) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 17) - 1 }),
        (1 << 17)...(1 << 18) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 18) - 1 }),
        (1 << 18)...(1 << 19) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 19) - 1 }),
        (1 << 19)...(1 << 20) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 20) - 1 }),
        (1 << 20)...(1 << 21) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 21) - 1 }),
        (1 << 21)...(1 << 22) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 22) - 1 }),
        (1 << 22)...(1 << 23) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 23) - 1 }),
        (1 << 23)...(1 << 24) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 24) - 1 }),
        (1 << 24)...(1 << 25) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 25) - 1 }),
        (1 << 25)...(1 << 26) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 26) - 1 }),
        (1 << 26)...(1 << 27) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 27) - 1 }),
        (1 << 27)...(1 << 28) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 28) - 1 }),
        (1 << 28)...(1 << 29) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 29) - 1 }),
        (1 << 29)...(1 << 30) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 30) - 1 }),
        // (1 << 30)...(1 << 31) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 31) - 1 }),
        // (1 << 31)...(1 << 32) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 32) - 1 }),
        // (1 << 32)...(1 << 33) - 1 => @call(.never_inline, withBuf, .{ T, params, args, size, callback, (1 << 33) - 1 }),
        else => @panic("stack overflow"),
        // lol...have fun with your stack overflow :)
        // else => @panic("here"),
        //(1 << 29) + 1...std.math.maxInt(usize) => @call(.never_inline, withBuf, .{ T, params, args, size, callback, std.math.maxInt(usize) }),
    };
}

fn withBuf(
    comptime T: type,
    comptime params: Params,
    args: params.Args,
    size: usize,
    callback: fn (params.Args, []T) params.Return,
    comptime capacity: usize,
) params.Return {
    var buffer: [capacity]T = undefined;
    return callback(args, buffer[0..size]);
}