DKLoehr wrote:
Here's what cvise gave me; unfortunately, I'm in a rush so I don't have time to
clean it up any further. It crashes when run with `clang++ repro.cc -std=c++20
-Wno-everyt hing -fsyntax-only -ferror-limit=0`
repro.cc:
```
template <bool, class _IfRes, class> using conditional_t = _IfRes;
template <class> void forward();
template <typename> class OnceCallback;
template <template <typename> class, typename> bool is_instantiation_v;
template <template <typename> class C, typename... Ts>
constexpr bool is_instantiation_v<C, C<Ts...>> = true;
template <template <typename> class C, typename T>
concept is_instantiation = is_instantiation_v<C, T>;
template <bool...> constexpr bool kIsWeakMethod = false;
template <typename> struct TypeList;
struct C;
template <int, typename> using DropTypeListItem = TypeList<C>;
template <typename, typename> struct MakeFunctionTypeImpl;
template <typename R, typename... Args>
struct MakeFunctionTypeImpl<R, TypeList<Args...>> {
using Type = R(Args...);
};
template <typename R, typename ArgList>
using MakeFunctionType = MakeFunctionTypeImpl<R, ArgList>::Type;
template <typename Signature> using ExtractArgs = Signature;
template <typename Signature> using ExtractReturnType = Signature;
template <typename...> struct FunctorTraits;
template <typename> struct DecayedFunctorTraits;
template <typename R, typename Receiver>
struct DecayedFunctorTraits<R (Receiver::*)()> {
using RunType = R;
template <typename Method, typename ReceiverPtr>
static void Invoke(Method, ReceiverPtr);
};
template <typename Functor>
struct FunctorTraits<Functor> : DecayedFunctorTraits<Functor> {};
template <bool, typename...> struct InvokeHelper;
template <typename Traits, typename ReturnType>
struct InvokeHelper<false, Traits, ReturnType> {
template <typename Functor, typename BoundArgsTuple, typename... RunArgs>
static void MakeItSo(Functor, BoundArgsTuple, RunArgs...) {
Traits::Invoke(0, forward<RunArgs>...);
}
};
template <bool is_once, typename T, typename StoredType = T,
typename ForwardedType =
conditional_t<is_once, StoredType, StoredType>>
using TransformToUnwrappedType = decltype(ForwardedType());
template <typename, typename> struct Invoker2;
template <typename Traits, typename R, typename... UnboundArgs>
struct Invoker2<Traits, R(UnboundArgs...)> {
static void RunOnce() { RunImpl(0, 0); }
template <typename Functor, typename BoundArgsTuple>
static void RunImpl(Functor, BoundArgsTuple) {
InvokeHelper<kIsWeakMethod<>, Traits, R>::MakeItSo(0, 0,
forward<UnboundArgs>...);
}
};
template <template <typename> class CallbackT> struct BindHelper2 {
static constexpr bool kIsOnce =
is_instantiation<OnceCallback, CallbackT<void>>;
template <typename Functor, typename... Args> static void BindImpl(Functor) {
using Traits = FunctorTraits<TransformToUnwrappedType<kIsOnce, Functor>>;
Invoker2<
Traits,
MakeFunctionType<
ExtractReturnType<typename Traits::RunType>,
DropTypeListItem<sizeof...(Args),
ExtractArgs<typename Traits::RunType>>>>::RunOnce;
}
};
void (C::*BindOnce2void___trans_tmp_1)();
void BindOnce2void() {
BindHelper2<OnceCallback>::BindImpl(BindOnce2void___trans_tmp_1);
}
```
https://github.com/llvm/llvm-project/pull/136128
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
