[Bug c++/84684] inserting random code / flags produces wrong code

[jakub at gcc dot gnu.org]

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84684

--- Comment #7 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
#include <array>
#include <algorithm>

template <typename alphabet_type>
constexpr char to_char(alphabet_type const alph)
{
    return alph.to_char();
}

constexpr const char *check[][3] = {
{ "ACGT", __null, __null },
{ "ACGT", "-", __null },
{ "ACGT", "-", "ACGTN" },
{ "ACGTN", "-", "ACGT" },
{ "-", "ACGT", "ACGTN" } };

template <int idx, typename ...alphabet_types>
struct union_composition
{
    static constexpr size_t value_size = (alphabet_types::value_size + ... );
    uint8_t _value;

    template <size_t fixed_size, typename alphabet_t>
    static constexpr auto value_to_char_helper(alphabet_t alphabet)
    {
        std::array<char, fixed_size> value_to_char{};

        for (size_t i = 0u; i < alphabet_t::value_size; ++i) {
            value_to_char[i] = to_char(alphabet.assign_rank(i));

        }

        return value_to_char;
    }

    static constexpr auto make_value_to_char()
    {
        constexpr auto N = sizeof...(alphabet_types);

        constexpr std::array<size_t, N> alphabet_sizes
        {
            alphabet_types::value_size...
        };
        constexpr size_t fixed_size =
std::max({alphabet_types::value_size...});

        constexpr std::array value_to_char_tables = std::array<std::array<char,
fixed_size>, N>
        {
            value_to_char_helper<fixed_size>(alphabet_types{})...
        };

        std::array<char, value_size> value_to_char{};
static_assert (value_size == (idx == 0 ? 4 : (idx < 2 ? 5 : 10)));
static_assert (N == (idx == 0 ? 1 : (idx < 2 ? 2 : 3)));
static_assert (fixed_size == (idx < 2 ? 4 : 5));
static_assert (alphabet_sizes[0] == __builtin_strlen(check[idx][0]));
if constexpr(idx >= 1)
static_assert (alphabet_sizes[1] == __builtin_strlen(check[idx][1]));
if constexpr (idx >= 2)
static_assert (alphabet_sizes[2] == __builtin_strlen(check[idx][2]));
static_assert (value_to_char_tables[0][0] == check[idx][0][0]);
if constexpr (alphabet_sizes[0] > 1)
static_assert (value_to_char_tables[0][1] == check[idx][0][1]);
if constexpr (alphabet_sizes[0] > 2)
static_assert (value_to_char_tables[0][2] == check[idx][0][2]);
if constexpr (alphabet_sizes[0] > 3)
static_assert (value_to_char_tables[0][3] == check[idx][0][3]);
if constexpr (alphabet_sizes[0] > 4)
static_assert (value_to_char_tables[0][4] == check[idx][0][4]);
if constexpr (idx >= 1) {
static_assert (value_to_char_tables[1][0] == check[idx][1][0]);
if constexpr (alphabet_sizes[1] > 1)
static_assert (value_to_char_tables[1][1] == check[idx][1][1]);
if constexpr (alphabet_sizes[1] > 2)
static_assert (value_to_char_tables[1][2] == check[idx][1][2]);
if constexpr (alphabet_sizes[1] > 3)
static_assert (value_to_char_tables[1][3] == check[idx][1][3]);
if constexpr (alphabet_sizes[1] > 4)
static_assert (value_to_char_tables[1][4] == check[idx][1][4]);
}
if constexpr (idx >= 2) {
static_assert (value_to_char_tables[2][0] == check[idx][2][0]);
if constexpr (alphabet_sizes[2] > 1)
static_assert (value_to_char_tables[2][1] == check[idx][2][1]);
if constexpr (alphabet_sizes[2] > 2)
static_assert (value_to_char_tables[2][2] == check[idx][2][2]);
if constexpr (alphabet_sizes[2] > 3)
static_assert (value_to_char_tables[2][3] == check[idx][2][3]);
if constexpr (alphabet_sizes[2] > 4)
static_assert (value_to_char_tables[2][4] == check[idx][2][4]);
}
        for (size_t i = 0u, value = 0u; i < N; ++i)
            for (size_t k = 0u; k < alphabet_sizes[i]; ++k, ++value)
                value_to_char[value] = value_to_char_tables[i][k];

        return value_to_char;
    }

};

struct gap
{
    constexpr char to_char() const noexcept
    {
        return '-';
    }

    constexpr gap & assign_rank([[maybe_unused]] bool const i) noexcept
    {
        return *this;
    }

    static constexpr size_t value_size{1};
};

struct dna4
{
    constexpr char to_char() const noexcept
    {
        return value_to_char[_value];
    }

    constexpr dna4 & assign_rank(uint8_t const c)
    {
        _value = c;
        return *this;
    }

    static constexpr size_t value_size{4};
    static constexpr char value_to_char[value_size] { 'A', 'C', 'G', 'T' };
    uint8_t _value;
};


struct dna5
{
    constexpr char to_char() const noexcept
    {
        return value_to_char[_value];
    }

    constexpr dna5 & assign_rank(uint8_t const c)
    {
        _value = c;
        return *this;
    }

    static constexpr size_t value_size{5};
    static constexpr char value_to_char[value_size] { 'A', 'C', 'G', 'T', 'N'
};
    uint8_t _value;
};

constexpr std::array value_to_char1 = union_composition<0,
dna4>::make_value_to_char();
static_assert(value_to_char1.size() == 4u);
static_assert(value_to_char1[0] == 'A');
static_assert(value_to_char1[1] == 'C');
static_assert(value_to_char1[2] == 'G');
static_assert(value_to_char1[3] == 'T');

constexpr std::array value_to_char2 = union_composition<1, dna4,
gap>::make_value_to_char();
static_assert(value_to_char2.size() == 5u);
static_assert(value_to_char2[0] == 'A');
static_assert(value_to_char2[1] == 'C');
static_assert(value_to_char2[2] == 'G');
static_assert(value_to_char2[3] == 'T');
static_assert(value_to_char2[4] == '-');

constexpr std::array value_to_char3 = union_composition<2, dna4, gap,
dna5>::make_value_to_char();
static_assert(value_to_char3.size() == 10u);
static_assert(value_to_char3[0] == 'A');
static_assert(value_to_char3[1] == 'C');
static_assert(value_to_char3[2] == 'G');
static_assert(value_to_char3[3] == 'T');
static_assert(value_to_char3[4] == '-');
static_assert(value_to_char3[5] == 'A');
static_assert(value_to_char3[6] == 'C');
static_assert(value_to_char3[7] == 'G');
static_assert(value_to_char3[8] == 'T');
static_assert(value_to_char3[9] == 'N');

constexpr std::array value_to_char4 = union_composition<3, dna5, gap,
dna4>::make_value_to_char();
static_assert(value_to_char4.size() == 10u);
static_assert(value_to_char4[0] == 'A');
static_assert(value_to_char4[1] == 'C');
static_assert(value_to_char4[2] == 'G');
static_assert(value_to_char4[3] == 'T');
static_assert(value_to_char4[4] == 'N');
static_assert(value_to_char4[5] == '-');
static_assert(value_to_char4[6] == 'A');
static_assert(value_to_char4[7] == 'C');
static_assert(value_to_char4[8] == 'G');
static_assert(value_to_char4[9] == 'T');

constexpr std::array value_to_char5 = union_composition<4, gap, dna4,
dna5>::make_value_to_char();
static_assert(value_to_char5.size() == 10u);
static_assert(value_to_char5[0] == '-');
static_assert(value_to_char5[1] == 'A');
static_assert(value_to_char5[2] == 'C');
static_assert(value_to_char5[3] == 'G');
static_assert(value_to_char5[4] == 'T');
static_assert(value_to_char5[5] == 'A');
static_assert(value_to_char5[6] == 'C');
static_assert(value_to_char5[7] == 'G');
static_assert(value_to_char5[8] == 'T');
static_assert(value_to_char5[9] == 'N');

when preprocessed with -E -std=c++17 with g++ 7.3.1 and compiled with
-std=c++17 trunk gives:
./cc1plus -quiet -std=c++17 pr84684-6.ii
pr84684-6.C: In instantiation of ‘static constexpr auto union_composition<idx,
alphabet_types>::make_value_to_char() [with int idx = 0; alphabet_types =
{dna4}]’:
pr84684-6.C:152:67:   required from here
pr84684-6.C:64:43: error: static assertion failed
 static_assert (value_to_char_tables[0][2] == check[idx][0][2]);
pr84684-6.C:156:33: error: static assertion failed
 static_assert(value_to_char1[2] == 'G');