É um bug de compilação? Acessar um membro inativo da união na função constexpr causa erro de compilação na avaliação do tempo de compilação

Enquanto eu estava brincando com a função constexpr, me deparei com o seguinte problema.

Acessar membro inativo de union é um comportamento indefinido, eu sei. Mas há uma exceção para essa regra.

De acordo com o padrão C++23 [class.mem.general]/26,

Em uma união de layout padrão com um membro ativo (11.5) do tipo struct T1, é permitido ler um membro de dados não estático m de outro membro de união do tipo struct T2, desde que m faça parte da sequência inicial comum de T1 e T2; o comportamento é como se o membro correspondente de T1 fosse nomeado.

Portanto, de acordo com o padrão, o código a seguir tem um comportamento bem definido. (Observação: o código a seguir também foi retirado do padrão)

struct T1 { int a, b; };
struct T2 { int c; double d; };
union U { T1 t1; T2 t2; };
int f() {
    U u = { { 1, 2 } }; // active member is t1
    return u.t2.c; // OK, as if u.t1.a were nominated
}

Como o código acima é bem definido, ele deve ser avaliado em tempo de compilação.

Então preparei o seguinte código (Aqui está o link do explorador do compilador: https://godbolt.org/z/G4e3avMaz

#include <type_traits>

template <typename T, T value>
struct Test_Union {
    struct T1 {
        T item_1 ;
    } ;

    struct T2 {
        T item_1 ;
    } ;

    union Union {
        T1 t1 ;
        T2 t2 ;
    } ;

    static_assert(std::is_standard_layout_v<T1>) ;
    static_assert(std::is_standard_layout_v<T2>) ;
    static_assert(sizeof(T1) == sizeof(T2)) ;
    static_assert(sizeof(T1) == sizeof(Union)) ;

    static constexpr Union test_1 = {.t1 = {value}} ;

    constexpr T no_error_1 (void) {
        return test_1.t1.item_1 ;
    }

    constexpr T no_error_2 (void) {
        constexpr Union test_2 = {.t1 = {value}} ;
        return test_2.t1.item_1 ;
    }

    constexpr T error_1 (void) {
        return test_1.t2.item_1 ;
    }

    constexpr T error_2 (void) {
        constexpr Union test_2 = {.t1 = {value}} ;
        return test_2.t2.item_1 ;
    }
} ;

int main (void) {
    []() consteval {
        Test_Union<int, 123> test ;
        test.no_error_1() ;
    } () ;

    []() consteval {
        Test_Union<int, 123> test ;
        test.no_error_2() ;
    } () ;
    // consteval function is not a constant expression error
    []() consteval {
        Test_Union<int, 123> test ;
        test.error_1() ;
    } () ;

    // consteval function is not a constant expression error
    []() consteval {
        Test_Union<int, 123> test ;
        test.error_2() ;
    } () ;
}

Quando você compila o exemplo em g++ ou clang (eu fiz isso), você obtém um erro de tempo de compilação para os dois últimos consteval lambda que chamaram as funções error_1 e error_2.

As razões são semelhantes. Para clang:

<source>:55:5: error: call to consteval function 'main()::(anonymous class)::operator()' is not a constant expression
   55 |     []() consteval {
      |     ^
<source>:35:16: note: read of member 't2' of union with active member 't1' is not allowed in a constant expression
   35 |         return test_1.t2.item_1 ;
      |                ^
<source>:57:9: note: in call to 'test.error_1()'
   57 |         test.error_1() ;
      |         ^~~~~~~~~~~~~~
<source>:55:5: note: in call to '[]() {
    Test_Union<int, 123> test;
    test.error_1();
}.operator()()'
   55 |     []() consteval {
      |     ^~~~~~~~~~~~~~~~
   56 |         Test_Union<int, 123> test ;
      |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~
   57 |         test.error_1() ;
      |         ~~~~~~~~~~~~~~~~
   58 |     } () ;
      |     ~~~~
<source>:60:5: error: call to consteval function 'main()::(anonymous class)::operator()' is not a constant expression
   60 |     []() consteval {
      |     ^
<source>:40:16: note: read of member 't2' of union with active member 't1' is not allowed in a constant expression
   40 |         return test_2.t2.item_1 ;
      |                ^
<source>:62:9: note: in call to 'test.error_2()'
   62 |         test.error_2() ;
      |         ^~~~~~~~~~~~~~
<source>:60:5: note: in call to '[]() {
    Test_Union<int, 123> test;
    test.error_2();
}.operator()()'
   60 |     []() consteval {
      |     ^~~~~~~~~~~~~~~~
   61 |         Test_Union<int, 123> test ;
      |         ~~~~~~~~~~~~~~~~~~~~~~~~~~~
   62 |         test.error_2() ;
      |         ~~~~~~~~~~~~~~~~
   63 |     } () ;

O Clang está reclamando que está acessando membro inativo do union. Mas de acordo com o padrão cpp, deve estar ok. Como acessar t2.item_1 deve ser o mesmo que t1.item_1.

Então o que você acha? Não consegui pensar em nenhuma resposta lógica sobre o porquê de os compiladores mostrarem um erro. A única coisa que pensei é que parece um bug do compilador.