Allow extern tagged unions

[Hejsil]

Sometimes you need to provide a tagged union through your C api. Currently, the best way to do this is to declare an extern struct with a tag, and a union member:

pub const S = extern struct {
    tag: u8,
    data: extern union {
        A: u16,
        B: u8,
    },
};

export fn b(ptr: *const S) u8 {
    return ptr.data.B;
}

But is there really any reason that extern tagged unions shouldn't work? We could make this:

pub const U = extern union(enum) {
    A: u8,
    B: u16,
};

export fn a(ptr: *const U) u8 {
    return ptr.A;
}

Equivalent to this header:

enum UEnum {
    UA,
    UB,
};

struct U {
    enum UEnum tag;
    union {
        uint8_t A;
        uint16_t B;
    };
};

uint8_t a(struct U *ptr);

The only problem I see here is that the "tag" has to be given some name in the C header. If this is a problem, we could introduce a syntax like this:

pub const U = extern union(tag: enum) {
    A: u8,
    B: u16,
};

This would give the tag a name, and make it accessible from both Zig and C.

[BraedonWooding]

What's a use case of having a tag name, you can access it in Zig through the struct regardless and there is a standard naming procedure for the produced header? Is there ever a need for just the 'tag' and not the whole union.

[Hejsil]

In the C headers generated, a tag name is required for the union to be useful in C code.

[BraedonWooding]

Yes, but I meant couldn't we just have a standard name like structName_tag?

[Hejsil]

Sure, we can do that. It was just an idea to avoid field name collisions completely while allowing the tag name to be something not ugly. Keep in mind, this feature is for C using a Zig lib. The users of your lib would appreciate id, tag or kind over SomeLongStructName_tag.

[BraedonWooding]

Fair enough, I can see that being much more pleasant 👍

[Hejsil]

Ideas for how to set the tag name for extern unions are welcome :) I remember @andrewrk mentioning that all parameters to keywords should be <param> instead of (param) to be consistent with async. With that in mind, name: tag is not really a parameter but a declaration, so maybe we want it to be extern union(enum, "tag") instead.

[andrewrk]

I'd like to reconsider this issue in light of #1922

[expikr]

extern struct {
    tag: enum(u8){
        a,b,c,
    },
    data: extern union(.tag){
        a: A,
        b: B,
        c: C,
    },
}

[Pyrolistical]

Just to be clear about about the problem, here is a comparison the status quo vs what is being proposed:

status quo

pub const S = extern struct {
    tag: enum(i32) {
        A,
        B,
    },
    data: extern union {
        A: u16,
        B: u8,
    },
};

const s: S = ...
switch (s.tag) {
    .A => {
        // use s.data.A, which could be undefined behavior
    },
    .B => {
        // use s.data.B, which could be undefined behavior
    },
}

proposed

pub const S = extern struct {
    tag: enum(i32) {
        A,
        B,
    },
    data: extern union(.tag) {  // the union(.tag) part is subject to change
        A: u16,
        B: u8,
    },
};

const s: S = ...
switch (s.data) {
    .A => |a| {
        // a is u16
    },
    .B => |b| {
        // b is u8
    },
}