Template argument limit of 0x7fff in clang-21 onward

[jameswplayer]

I noticed that clang TOT fails to compile variadic templates with argument count exceeding 0x7fff. I plugged a simple reproducer into godbolt and noticed that this behavior starts at clang-21 (i.e. clang-20 compiles successfully).

The simplest repro I came up with was to simply instantiate a std::index_sequence at various sizes, where the first static_assert() succeeds and the second one fails:

namespace std {
typedef int a;
template <typename b, b... c> struct d {
  constexpr a size() { return sizeof...(c); }
};
template <typename b, b e> using f = __make_integer_seq<d, b, e>;
template <a e> using make_index_sequence = f<a, e>;
} // namespace std
int main() {
  constexpr unsigned SeqLength = 0x7fff;
  std::make_index_sequence<SeqLength> Seq;
  static_assert(Seq.size() == SeqLength);
  {
    constexpr unsigned SeqLength = 0x8000;
    std::make_index_sequence<SeqLength> Seq;
    static_assert(Seq.size() == SeqLength);
  }
}

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: James Player (jameswplayer)

I noticed that clang TOT fails to compile variadic templates with argument count exceeding 0x7fff. I plugged a simple reproducer into [godbolt](https://godbolt.org/z/nq4q4djz7) and noticed that this behavior starts at clang-21 (i.e. clang-20 compiles successfully).

The simplest repro I came up with was to simply instantiate a std::index_sequence at various sizes, where the first static_assert() succeeds and the second one fails:

namespace std {
typedef int a;
template <typename b, b... c> struct d {
  constexpr a size() { return sizeof...(c); }
};
template <typename b, b e> using f = __make_integer_seq<d, b, e>;
template <a e> using make_index_sequence = f<a, e>;
} // namespace std
int main() {
  constexpr unsigned SeqLength = 0x7fff;
  std::make_index_sequence<SeqLength> Seq;
  static_assert(Seq.size() == SeqLength);
  {
    constexpr unsigned SeqLength = 0x8000;
    std::make_index_sequence<SeqLength> Seq;
    static_assert(Seq.size() == SeqLength);
  }
}

[frederick-vs-ja]

I believe at least we should reject the N beyond the limit, rather than silently miscompile the template specialization.

[efriedma-quic]

I think the truncation to 15 bits instead of 16 bits is f302f35 . CC @mizvekov .

Limiting the maximum number of template arguments is probably fine as long as there's some explicit limit.

[mizvekov]

Yeah, a lot of our impl limits are basically however many free bits we have somewhere. If we need another bit for something else, it's simplest to decrease that limit, as long as it still looks reasonably large.

One solution here is to simply tail allocate the extra bits for the number of template args when needed, if we want to support that many arguments.

[shafik]

Like the previous comment, it feels like it would be more user-friendly to generate a diagnostic if we pass the implementation limit here.

[mizvekov]

I am not sure a diagnostic would be worth here, it would maybe be easier to implement support for a really huge amount of template arguments.

And we have these sorts of issues with almost all implementation limits by the way, it is just that most of them are a really big number which people are unlikely to hit. It would be a huge effort to make all of these hit a diagnostic.