Неявное приведение к типу объединения?

Я мог видеть:

typedef enum person_param_name {
    NAME,
    AGE,
} person_param_name_t;

typedef union person_param_val
{
    char* name;
    unsigned int age;
} person_param_val_t;

person_param_val_t person_param_val_init_charp(char *name) {
    return (person_param_val_t){.name=name};
}
person_param_val_t person_param_val_init_u(unsigned age) {
    return (person_param_val_t){.age=age};
}
#define MAKE_PERSON_PARAM_VAL(x)  _Generic((x) \
    , unsigned: person_param_val_init_u \
    , char *:person_param_val_init_charp \
    )(x)

int set_person_param(person_param_name_t param_name, person_param_val_t param_val);

#define set_person_param(a, b) \
    set_person_param(a, MAKE_PERSON_PARAM_VAL(b))
    
int main() {
    set_person_param(NAME, "Alex");
    set_person_param(AGE, 5u);
}

С GCC с расширением вы получите только:

#define set_person_param(a, b) \
     set_person_param(a, (person_param_val_t)(b))

Но я бы не стал писать такой код. Это C. В C вы бы написали все это явно. Не вижу смысла в person_param_name. Вам все равно придется явно перечислять все типы внутри set_person_param. Я бы просто написал set_person_param_age(unsigned age) и set_person_param_name(char *name) явно. Если нет, я бы подумал о переосмыслении всего подхода, поскольку, скорее всего, вы хотите реализовать виртуальную функцию. Я бы посоветовал настоятельно не писать интерфейс с бесконечным количеством случаев в перечислениях, потому что вы можете получить это. Вместо этого создайте объекты с указателем на интерфейс, хранящийся в виртуальной таблице.

Вам не нужна никакая магия. этого макроса достаточно

#define set_person_param(param, val)  g_person_##param.param = (val)

И эта примерная функция:

int foo(void)
{
    person_param_val_t g_person_name, g_person_age;

    set_person_param(name, "Alex");
    set_person_param(age, 5);
}

Будет предварительно обработан для:

int foo(void)
{
    person_param_val_t g_person_name, g_person_age;

    g_person_name.name = "Alex";
    g_person_age.age = 5;
}

Насколько я понимаю, это было что-то, что вы хотели заархивировать. Ваш тип перечисления не нужен.

Если вы хотите, чтобы val был того же типа союза, то:

#define set_person_param(param, val)  g_person_##param = (val)

Пример:

    set_person_param(name, (person_param_val_t){.name = "Alex"});

Если вы измените объединение так, чтобы имена полей были идентичны константам перечисления:

typedef union person_param_val
{
    char* NAME;
    unsigned int AGE;
} person_param_val_t;

Затем вы можете создать макрос, который будет передавать правильно инициализированный составной литерал:

#define set_person_param_ext(k,v) \
        set_person_param(k, (person_param_val_t){.k=v})

Тогда это:

set_person_param_ext(NAME, "Alex");
set_person_param_ext(AGE, 5);

Будет расширяться до этого:

set_person_param(NAME, (person_param_val_t){.NAME = "Alex"});
set_person_param(AGE, (person_param_val_t){.AGE=5});