I got another question.

In the standard, the following %1 and %2 are unevaluated operands

template <typename T>
concept C = /* %1 */ true;

template <typename T>
concept CC = requires {
    requires /* %2 */ C<T>;
};

%1 is defined here: https://eel.is/c++draft/temp.concept#6
%2 is defined here: https://eel.is/c++draft/expr.prim.req#general-2

But clearly, they are evaluated and must evaluate to be true at compile time. (edited)

IMO, an unevaluated expression should be something we did not check its value, something like

  // DR 2392
  template<class T = void> constexpr int f() { T t; return 1; }
  using _ = decltype(new int[f()]);

But we cannot write

template <typename T>
concept C = foo();

So what's wrong here? Do I misinterpret anything?

But clearly, they are evaluated and must evaluate to be true at compile time.

They are evaluated when the naming a concept specialization outside unevaluated operands, and need not evaluate to true.

I think the example is not definitely correct even before CWG2392 - since some implementation may allow large object types of size equal to UINT_MAX + size_t(1), in which case -(int)sizeof(T) is 0 if T is such a type.