extern interop of tagged unions?

[expikr]

On Windows there are a lot of functions where you provide buffer and the system writes a struct to it that are essentially a tagged union:

typedef struct tagSOMEDATA {
    UINT cbSize;
    DWORD dwType;
    union {
        variant0: SOMEVARIANT0;
        variant1: SOMEVARIANT1;
        variant2: SOMEVARIANT2;
    } data;
} SOMEDATA, *PSOMEDATA

This is essentially a union(enum(u32)) that you receive, it would be a neat QoL to just declare the extern interop type as such from the start rather than manually checking the type field and returning your custom Ziggified tagged union to wrap it.

Perhaps something like

const SOMEDATA = extern struct {
    cbSize: u32,
    dwType: enum(u32){variant0,variant1,variant2},
    data: extern union (.dwType) {
        variant0: SOMEVARIANT0;
        variant1: SOMEVARIANT1;
        variant2: SOMEVARIANT2;
    }
}

But then that would have the problem of being able to mutate the type field separately from the data field, so not sure what the right solution would be here.

Another consideration is the use of anonymous unions, i.e. DUMMYUNIONNAME, which extracts their fields into the parent scope, e.g.

typedef struct tagSOMEDATA {
    UINT cbSize;
    DWORD dwType;
    union {
        variant0: SOMEVARIANT0;
        variant1: SOMEVARIANT1;
        variant2: SOMEVARIANT2;
    } DUMMYUNIONNAME; // anonymous union
} SOMEDATA, *PSOMEDATA

SOMEDATA mydata = {
    .cbSize = sizeof(SOMEDATA);
    .dwType = 0;
    .variant1 = myVariant1Details; // treated as if the union variant is in parent scope
}

[BratishkaErik]

Duplicate of #1072 ?