Proposal: Add function pointer field to TypeInfo.Definition.Data.FnDef

[alexnask]

Proposed structure:

pub const FnDef = struct {
    fn_type: type,
    inline_type: Inline,
    calling_convention: CallingConvention,
    is_var_args: bool,
    is_extern: bool,
    is_export: bool,
    lib_name: ?[]const u8,
    return_type: type,
    arg_names: [][] const u8,
    ptr: *const u8, // <- New field, guaranteed to point to fn of type 'fn_type'

    pub const Inline = enum {
        Auto,
        Always,
        Never,
    };
};

With the current structure, if @reify/@makeType was implemented, there would be no way to generate methods for a type.

This change would allow us to use the anonymous structure function trick or (eventually) function literals to generate methods for the types created.

EDIT:
Actually, this is just one of the changes that would need to be made to allow for method generation, the other issue being specifying the first argument type of the method when the type is not generated yet.

[andrewrk]

This is a bit tricky because the pointer type of the field would not be correct (*u8 instead of fn proto) - or we would have to make FnDef generic. If we went with the "you have to cast the ptr field" approach, we might need to improve the comptime mechanism to support a comptime known pointer value that has the wrong type.

[alexnask]

@andrewrk
I don't think making the struct generic can be achieved.
I believe this is achievable in the current master build, I've tested some type erasure comptime techniques before, here is a simple example that does work:

const assert = @import("std").debug.assert;

const WrappedFn = struct {
    const Self = this;

    fn_type: type,
    fn_ptr: *const u8,

    fn init(f: var) Self {
        return Self { .fn_type=@typeOf(f), .fn_ptr=@ptrCast(*const u8, f), };
    }

    fn get_fn(comptime self: *const Self) self.fn_type {
        return @ptrCast(self.fn_type, self.fn_ptr);
    }
};

fn foo(arg: u8) u8 {
    return arg;
}

test "comptime fn to u8 pointer casts" {
    comptime {
        const wrapped_foo = WrappedFn.init(foo);
        assert(wrapped_foo.get_fn()(42) == 42);
    }
}

EDIT

So something similar could be used in FnDef:

pub const FnDef = struct {
    const Self = this;

    fn_type: type,
    inline_type: Inline,
    calling_convention: CallingConvention,
    is_var_args: bool,
    is_extern: bool,
    is_export: bool,
    lib_name: ?[]const u8,
    return_type: type,
    arg_names: [][] const u8,
    ptr: *const u8, // <- New field, guaranteed to point to fn of type 'fn_type'

    pub const Inline = enum {
        Auto,
        Always,
        Never,
    };

    // TODO: https://github.com/ziglang/zig/issues/1124
    pub fn fn_ptr(comptime self: Self) self.fn_type {
        return @ptrCast(self.fn_type, self.ptr);
    }
};

So that the user needs only use the type safe fn_ptr method.

[andrewrk]

I think this is a reasonable approach. Let me have a discussion about @reify with @thejoshwolfe and see if we can come up with an accepted proposal.

[alexnask]

In addition to this, TypeInfo.Definition.Data.Var could be some type erased value (to allow reify-ing non type definitions)

[andrewrk]

We now have the ability to have fields of type var when the struct is comptime known. So the problem this issue tackles is solved. Whether to put function definitions into that struct is the same issue as #383.

[alexnask]

Great to see the comptime capabilities increasing, I'll have to catch up on the changes so I can maybe take a stab at fixing some bugs :)