Abstracted pointers cannot be used at comptime

[tgschultz]

const Any = *@OpaqueType();

const Iface = struct
{
    impl: Any,
    funcFn: fn(Any)u32,
    
    pub fn func(self: *Iface) u32
    {
        return self.funcFn(self.impl);
    }
};

const Impl = struct
{
    val: u32,
    
    pub fn func(self: *Impl) u32
    {
        return self.val;
    }
};

test "comptime type erasure failure"
{
    comptime
    {
        var impl = Impl{ .val = 123, };
        var iface = Iface
        {
            .impl = @ptrCast(Any, &impl),
            .funcFn = @ptrCast(fn(Any)u32, Impl.func),
        };
        var x = iface.func();
    }
}

: error: expected type '*Impl', found '*Any'
        return self.funcFn(self.impl);
                               ^
: note: called from here
        var x = iface.func();
                          ^
: note: pointer type child 'Any' cannot cast into pointer type child 'Impl'
        return self.funcFn(self.impl);
                               ^
: note: Impl declared here
const Impl = struct
             ^

Removing comptime allows the test to pass.

This affects my experiments with new std interface patterns somewhat, but I'm not actually sure it should work.

[SpexGuy]

I think this is UB, so the compiler is right to reject this. It's not technically specified that you should be able to cast from (a function with unspecified calling convention accepting a pointer) to (a function accepting a different pointer type) and call the result. But if you generate a function that does a ptrCast and then calls the implementation, it seems to work correctly:

const Any = *opaque{};

const Iface = struct
{
    impl: Any,
    funcFn: fn(Any)u32,
    
    pub fn func(self: *Iface) u32
    {
        return self.funcFn(self.impl);
    }
};

const Impl = struct
{
    val: u32,
    
    pub fn func(self: *Impl) u32
    {
        return self.val;
    }

    pub fn iface(self: *Impl) Iface
    {
        return Iface
        {
            .impl = @ptrCast(Any, self),
            .funcFn = struct
            {
                pub fn f(i: Any) u32
                {
                    return func(@ptrCast(*Impl, @alignCast(@alignOf(Impl), i)));
                }
            }.f,
        };
    }
};

test "comptime type erasure success"
{
    comptime
    {
        var impl = Impl{ .val = 123 };
        var iface = impl.iface();
        var x = iface.func();
    }
}