Compiler Explorer

Source code

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

const WrappedFn = fn (?*c_void) callconv(.C) void;

fn wrap(comptime Class: type, comptime func: anytype) WrappedFn {
    const Fn = @typeInfo(@TypeOf(func)).Fn;

return struct {
        fn thunk(ptr: ?*c_void) callconv(.C) void {
            const instance = @ptrCast(*Class, ptr);

pub fn ForeignClass(name: []const u8, comptime Class: anytype) type {
    const ti = @typeInfo(Class);

const meta = struct {
        pub fn isFinalize(comptime decl: std.builtin.TypeInfo.Declaration) bool {
            if (!std.mem.eql(u8, "finalize", decl.name)) return false;

const fn_type_info = @typeInfo(decl.data.Fn.fn_type);
            if (fn_type_info.Fn.args.len != 1) return false;

const arg1_info = @typeInfo(fn_type_info.Fn.args[0].arg_type orelse unreachable);
            if (arg1_info != .Pointer) return false;
            if (arg1_info.Pointer.child != Class) return false;

const ret_info = @typeInfo(fn_type_info.Fn.return_type orelse unreachable);
            // No access to the VM, so no way to signal errors to it.
            if (ret_info != .Void) return false;

return true;
        }
    };

return struct {
        pub fn printInfo() void {
            var finalizer: ?WrappedFn = undefined;
            inline for (ti.Struct.decls) |decl| {
            // comptime {
                switch (decl.data) {
                    .Fn => {
                        print("name = {s}\n", .{decl.name});
                        print("  function = {s}\n", .{@typeName(decl.data.Fn.fn_type)});
                        if (meta.isFinalize(decl)) {
                            print("  found the finalize function!\n", .{});
                            finalizer = wrap(Class, @field(Class, decl.name));
                        }
                    },
                    else => {},
                }
            // }
            }
        }
    };
}

const TestClass = struct {
    const Self = @This();

// Make the struct have a size > 0.
    data: [4]u8,

pub fn initialize0(self: *Self) !void {}

pub fn initialize3(self: *Self, x: i32, y: i32, z: i32) !void {}

pub fn finalize(self: *Self) void {}

pub fn call(self: *Self, str: []const u8) void {}
};

pub fn main() !void {
    ForeignClass("TestClass", TestClass).printInfo();
}