clang/test/SemaTemplate/deduction-crash.cpp

   1 // RUN: %clang_cc1 -fsyntax-only %s -std=c++1z -verify
   2
   3 // PR7511
   4 template<a> // expected-error +{{}}
   5 struct int_;
   6
   7 template<a> // expected-error +{{}}
   8 template<int,typename T1,typename>
   9 struct ac
  10 {
  11   typedef T1 ae
  12 };
  13
  14 template<class>struct aaa
  15 {
  16   typedef ac<1,int,int>::ae ae // expected-error +{{}}
  17 };
  18
  19 template<class>
  20 struct state_machine
  21 {
  22   typedef aaa<int>::ae aaa;
  23   int start()
  24   {
  25     ant(0);
  26   }
  27
  28   template<class>
  29   struct region_processing_helper
  30   {
  31     template<class,int=0>
  32     struct In;
  33
  34     template<int my>
  35     struct In<a::int_<aaa::a>,my>; // expected-error +{{}}
  36
  37     template<class Event>
  38     int process(Event)
  39     {
  40       In<a::int_<0> > a; // expected-error +{{}}
  41     }
  42   } // expected-error +{{}}
  43   template<class Event>
  44   int ant(Event)
  45   {
  46     region_processing_helper<int>* helper;
  47     helper->process(0) // expected-error +{{}}
  48   }
  49 };
  50
  51 int a()
  52 {
  53   state_machine<int> p;
  54   p.ant(0);
  55 }
  56
  57 // PR9974
  58 template <int> struct enable_if;
  59 template <class > struct remove_reference ;
  60 template <class _Tp> struct remove_reference<_Tp&> ;
  61
  62 template <class > struct __tuple_like;
  63
  64 template <class _Tp, class _Up, int = __tuple_like<typename remove_reference<_Tp>::type>::value>
  65 struct __tuple_convertible;
  66
  67 struct pair
  68 {
  69 template<class _Tuple, int = enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
  70 pair(_Tuple&& );
  71 };
  72
  73 template <class> struct basic_ostream;
  74
  75 template <int>
  76 void endl( ) ;
  77
  78 extern basic_ostream<char> cout;
  79
  80 int operator<<( basic_ostream<char> , pair ) ; // expected-note +{{}}
  81
  82 void register_object_imp ( )
  83 {
  84 cout << endl<1>; // expected-error +{{}}
  85 }
  86
  87 // PR12933
  88 namespace PR12933 {
  89   template<typename S> // expected-error +{{}}
  90     template<typename T>
  91     void function(S a, T b) {}
  92
  93   int main() {
  94     function(0, 1); // expected-error +{{}}
  95     return 0;
  96   }
  97 }
  98
  99 // A buildbot failure from libcxx
 100 namespace libcxx_test {
 101   template <class _Ptr, bool> struct __pointer_traits_element_type;
 102   template <class _Ptr> struct __pointer_traits_element_type<_Ptr, true>;
 103   template <template <class, class...> class _Sp, class _Tp, class ..._Args> struct __pointer_traits_element_type<_Sp<_Tp, _Args...>, true> {
 104     typedef char type;
 105   };
 106   template <class T> struct B {};
 107   __pointer_traits_element_type<B<int>, true>::type x;
 108 }
 109
 110 namespace PR14281_part1 {
 111   template <class P, int> struct A;
 112   template <class P> struct A<P, 1>;
 113   template <template <class, int> class S, class T> struct A<S<T, 1>, 1> {
 114     typedef char type;
 115   };
 116   template <class T, int i> struct B {};
 117   A<B<int, 1>, 1>::type x;
 118 }
 119
 120 namespace PR14281_part2 {
 121   typedef decltype(nullptr) nullptr_t;
 122   template <class P, nullptr_t> struct A;
 123   template <class P> struct A<P, nullptr>;
 124   template <template <class, nullptr_t> class S, class T> struct A<S<T, nullptr>, nullptr> {
 125     typedef char type;
 126   };
 127   template <class T, nullptr_t i> struct B {};
 128   A<B<int, nullptr>, nullptr>::type x;
 129 }
 130
 131 namespace PR14281_part3 {
 132   extern int some_decl;
 133   template <class P, int*> struct A;
 134   template <class P> struct A<P, &some_decl>;
 135   template <template <class, int*> class S, class T> struct A<S<T, &some_decl>, &some_decl> {
 136     typedef char type;
 137   };
 138   template <class T, int* i> struct B {};
 139   A<B<int, &some_decl>, &some_decl>::type x;
 140 }
 141
 142 namespace var_template_partial_spec_incomplete {
 143   template<typename T> int n;
 144   template<typename T, typename U = void> int n<T *>; // expected-error +{{}} expected-note {{}}
 145   int k = n<void *>;
 146 }
 147
 148 namespace deduceFunctionSpecializationForInvalidOutOfLineFunction {
 149
 150 template <typename InputT, typename OutputT>
 151 struct SourceSelectionRequirement {
 152   template<typename T>
 153   OutputT evaluateSelectionRequirement(InputT &&Value) {
 154   }
 155 };
 156
 157 template <typename InputT, typename OutputT>
 158 OutputT SourceSelectionRequirement<InputT, OutputT>::
 159 evaluateSelectionRequirement<void>(InputT &&Value) { // expected-error {{cannot specialize a member of an unspecialized template}}
 160   return Value;
 161 }
 162
 163 }
 164
 165 namespace PR51872_part1 {
 166   template<int> class T1 { template <struct U1> T1(); };
 167   // expected-error@-1 {{non-type template parameter has incomplete type 'struct U1'}}
 168   // expected-note@-2  {{forward declaration of 'PR51872_part1::U1'}}
 169
 170   T1 t1 = 0;
 171   // expected-error@-1 {{no viable constructor or deduction guide for deduction of template arguments of 'T1'}}
 172   // expected-note@-6  {{candidate template ignored: could not match 'T1<>' against 'int'}}
 173 }