clang/test/SemaTemplate/GH18291.cpp

   1 // RUN: %clang_cc1 -std=c++23 -verify %s
   2
   3 namespace t1 {
   4   template<bool> struct enable_if { typedef void type; };
   5   template <class T> class Foo {};
   6   template <class X> constexpr bool check() { return true; }
   7   template <class X, class Enable = void> struct Bar {};
   8
   9   namespace param {
  10     template<class X> void func(Bar<X, typename enable_if<check<X>()>::type>) {}
  11     // expected-note@-1 2{{candidate function}}
  12     template<class T> void func(Bar<Foo<T>>) {}
  13     // expected-note@-1 2{{candidate function}}
  14
  15     void g() {
  16       func(Bar<Foo<int>>()); // expected-error {{call to 'func' is ambiguous}}
  17       void (*ptr)(Bar<Foo<int>>){func};
  18       // expected-error@-1 {{address of overloaded function 'func' is ambiguous}}
  19     }
  20   } // namespace param
  21   namespace ret {
  22     template<class X> Bar<X, typename enable_if<check<X>()>::type> func();
  23     // expected-note@-1 {{candidate function}}
  24     template<class T> Bar<Foo<T>> func();
  25     // expected-note@-1 {{candidate function}}
  26
  27     void g() {
  28       Bar<Foo<int>> (*ptr)(){func};
  29       // expected-error@-1 {{address of overloaded function 'func' is ambiguous}}
  30     }
  31   } // namespace ret
  32   namespace conv {
  33     struct A {
  34       template<class X> operator Bar<X, typename enable_if<check<X>()>::type>();
  35       // expected-note@-1 {{candidate function}}
  36       template<class T> operator Bar<Foo<T>>();
  37       // expected-note@-1 {{candidate function}}
  38     };
  39     void g() {
  40       Bar<Foo<int>> x = A();
  41       // expected-error@-1 {{conversion from 'A' to 'Bar<Foo<int>>' is ambiguous}}
  42     }
  43   } // namespace conv
  44 } // namespace t1
  45
  46 namespace t2 {
  47   template <bool> struct enable_if;
  48   template <> struct enable_if<true> {
  49     typedef int type;
  50   };
  51   struct pair {
  52     template <int = 0> pair(int);
  53     template <class _U2, enable_if<__is_constructible(int &, _U2)>::type = 0>
  54     pair(_U2 &&);
  55   };
  56   int test_test_i;
  57   void test() { pair{test_test_i}; }
  58 } // namespace t2
  59
  60 namespace t3 {
  61   template <class _Tp> void to_address(_Tp);
  62   template <class _Pointer> auto to_address(_Pointer __p) -> decltype(__p);
  63
  64   template <class _CharT> struct basic_string_view {
  65     basic_string_view(_CharT);
  66
  67     template <class _It> requires requires(_It __i) { to_address(__i); }
  68     basic_string_view(_It);
  69   };
  70   void operatorsv() { basic_string_view(0); }
  71 } // namespace t3
  72
  73 namespace func_pointer {
  74   template <class> struct __promote {
  75     using type = float;
  76   };
  77   template <class> class complex {};
  78
  79   namespace ret {
  80     template <class _Tp> complex<_Tp> pow(const complex<_Tp> &) {};
  81     template <class _Tp> complex<typename __promote<_Tp>::type> pow(_Tp) = delete;
  82     complex<float> (*ptr)(const complex<float> &){pow};
  83   } // namespace ret
  84   namespace param {
  85     template <class _Tp> void pow(const complex<_Tp> &, complex<_Tp>) {};
  86     template <class _Tp> void pow(_Tp, complex<typename __promote<_Tp>::type>) = delete;
  87     void (*ptr)(const complex<float> &, complex<float>){pow};
  88   } // namespace param
  89 } // namespace func_pointer
  90
  91 namespace static_vs_nonstatic {
  92   namespace implicit_obj_param {
  93     struct A {
  94       template <class... Args>
  95         static void f(int a, Args... args) {}
  96       template <class... Args>
  97         void f(Args... args) = delete;
  98     };
  99     void g(){
 100       A::f(0);
 101     }
 102   } // namespace implicit_obj_param
 103   namespace explicit_obj_param {
 104     struct A {
 105       template <class... Args>
 106         static void f(int, Args... args) {}
 107       template <class... Args>
 108         void f(this A *, Args... args) = delete;
 109     };
 110     void g(){
 111       A::f(0);
 112     }
 113   } // namespace explicit_obj_param
 114 } // namespace static_vs_nonstatic
 115
 116 namespace incomplete_on_sugar {
 117   template <unsigned P, class T> void f(T[P]) = delete;
 118   template <unsigned P> void f(int[][P]);
 119   void test() {
 120     int array[1][8];
 121     f<8>(array);
 122   }
 123 } // namespace incomplete_on_sugar