Не шмогла. Думала минут 10, кстати.

// We use __COUNTER__ to generate a unique integral at each instantiation
template<typename T>
struct first_call {
    static constexpr int value = __COUNTER__;
};

template<typename T, int N = __COUNTER__>
struct tick_count {
    static constexpr int value = N - first_call<T>::value - 1;
};

template<typename T>
constexpr int ct_tick = tick_count<T>::value;

template<typename T>
constexpr int ct_peek = ct_tick<T> + 1;

На gcc не работает. Сейчас попробую ему сказать про это.

Со второго раза тоже не получилось, вообще какая-то ахинея пошла.

template<typename T> struct counter {
    friend constexpr int adl_counter(counter<T>);
};

template<typename T, int N>
struct write {
    friend constexpr int adl_counter(counter<T>) { return N; }
};

template<typename T>
constexpr int read() {
    // If no specialization has been made yet, adl_counter is not defined and we default to 0
    // by using a conditional expression with a fallback.
    // We use SFINAE on a lambda to check if adl_counter is valid.
    auto lambda = []() -> int {
        return adl_counter(counter<T>());
    };
    struct fallback { static constexpr int value = 0; };
    struct tester {
        template<typename U>
        static auto test(int) -> decltype(adl_counter(counter<U>()), std::true_type{});
        template<typename>
        static auto test(...) -> std::false_type;
    };
    if constexpr (decltype(tester::template test<T>(0))::value)
        return lambda();
    else
        return 0;
}

template<typename T>
constexpr int increment() {
    // Increment the counter for T by writing a new friend definition
    write<T, read<T>() + 1>();
    return read<T>();
}

template<typename T>
constexpr int ct_tick = increment<T>() - 1;  // tick returns the previous value
template<typename T>
constexpr int ct_peek = read<T>() + 1;       // peek shows what the next tick would be

int main()
{
   static_assert(ct_tick<int> == 0);
   static_assert(ct_tick<class X> == 0);
   static_assert(ct_tick<void> == 0);

   struct Inner
   {
      static_assert(ct_tick<int> == 1);
      static_assert(ct_tick<class X> == 1);
      static_assert(ct_tick<void> == 1);

      static_assert(ct_peek<int> == 2);
      static_assert(ct_peek<class X> == 2);
      static_assert(ct_peek<void> == 2);
   };

   static_assert(ct_tick<int> == 2);
   static_assert(ct_tick<class X> == 2);
   static_assert(ct_tick<void> == 2);

   static_assert(ct_tick<int> == 3);
   static_assert(ct_tick<class X> == 3);
   static_assert(ct_tick<void> == 3);
}

Не шмогла. Думала минут 10, кстати.

// We use __COUNTER__ to generate a unique integral at each instantiation
template<typename T>
struct first_call {
    static constexpr int value = __COUNTER__;
};

template<typename T, int N = __COUNTER__>
struct tick_count {
    static constexpr int value = N - first_call<T>::value - 1;
};

template<typename T>
constexpr int ct_tick = tick_count<T>::value;

template<typename T>
constexpr int ct_peek = ct_tick<T> + 1;

На gcc не работает. Сейчас попробую ему сказать про это.

Со второго раза тоже не получилось, вообще какая-то ахинея пошла. Суровые сибирские лесорубы могут спать спокойно.

template<typename T> struct counter {
    friend constexpr int adl_counter(counter<T>);
};

template<typename T, int N>
struct write {
    friend constexpr int adl_counter(counter<T>) { return N; }
};

template<typename T>
constexpr int read() {
    // If no specialization has been made yet, adl_counter is not defined and we default to 0
    // by using a conditional expression with a fallback.
    // We use SFINAE on a lambda to check if adl_counter is valid.
    auto lambda = []() -> int {
        return adl_counter(counter<T>());
    };
    struct fallback { static constexpr int value = 0; };
    struct tester {
        template<typename U>
        static auto test(int) -> decltype(adl_counter(counter<U>()), std::true_type{});
        template<typename>
        static auto test(...) -> std::false_type;
    };
    if constexpr (decltype(tester::template test<T>(0))::value)
        return lambda();
    else
        return 0;
}

template<typename T>
constexpr int increment() {
    // Increment the counter for T by writing a new friend definition
    write<T, read<T>() + 1>();
    return read<T>();
}

template<typename T>
constexpr int ct_tick = increment<T>() - 1;  // tick returns the previous value
template<typename T>
constexpr int ct_peek = read<T>() + 1;       // peek shows what the next tick would be

int main()
{
   static_assert(ct_tick<int> == 0);
   static_assert(ct_tick<class X> == 0);
   static_assert(ct_tick<void> == 0);

   struct Inner
   {
      static_assert(ct_tick<int> == 1);
      static_assert(ct_tick<class X> == 1);
      static_assert(ct_tick<void> == 1);

      static_assert(ct_peek<int> == 2);
      static_assert(ct_peek<class X> == 2);
      static_assert(ct_peek<void> == 2);
   };

   static_assert(ct_tick<int> == 2);
   static_assert(ct_tick<class X> == 2);
   static_assert(ct_tick<void> == 2);

   static_assert(ct_tick<int> == 3);
   static_assert(ct_tick<class X> == 3);
   static_assert(ct_tick<void> == 3);
}