[clang] [clang] Handle instantiated members to determine visibility (PR #136128)

[Devon Loehr via cfe-commits]

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