Home | History | Annotate | Download | only in SemaTemplate 
      1 // RUN: %clang_cc1 -triple i686-unknown-unknown -fsyntax-only -verify %s
      2 
      3 // PR6619
      4 template<bool C> struct if_c { };
      5 template<typename T1> struct if_ {
      6   typedef if_c< static_cast<bool>(T1::value)> almost_type_; // expected-note 5{{in instantiation}}
      7 };
      8 template <class Model, void (Model::*)()> struct wrap_constraints { };
      9 template <class Model>
     10 inline char has_constraints_(Model* , // expected-note 3{{candidate template ignored}}
     11                                wrap_constraints<Model,&Model::constraints>* = 0); // expected-note 2{{in instantiation}}
     12 
     13 template <class Model> struct not_satisfied {
     14   static const bool value = sizeof( has_constraints_((Model*)0)  == 1); // expected-error 3{{no matching function}} \
     15   // expected-note 2{{while substituting deduced template arguments into function template 'has_constraints_' [with }}
     16 };
     17 template <class ModelFn> struct requirement_;
     18 template <void(*)()> struct instantiate {
     19 };
     20 template <class Model> struct requirement_<void(*)(Model)>                           : if_<       not_satisfied<Model>         >::type { // expected-note 5{{in instantiation}}
     21 };
     22 template <class Model> struct usage_requirements {
     23 };
     24 template < typename TT > struct InputIterator                            {
     25     typedef  instantiate< & requirement_<void(*)(usage_requirements<InputIterator> x)>::failed> boost_concept_check1; // expected-note {{in instantiation}}
     26 };
     27 template < typename TT > struct ForwardIterator                              : InputIterator<TT>                              { // expected-note {{in instantiation}}
     28   typedef instantiate< & requirement_<void(*)(usage_requirements<ForwardIterator> x)>::failed> boost_concept_check2; // expected-note {{in instantiation}}
     29 
     30 };
     31 typedef instantiate< &requirement_<void(*)(ForwardIterator<char*> x)>::failed> boost_concept_checkX;// expected-note 3{{in instantiation}}
     32 
     33 template<typename T> struct X0 { };
     34 template<typename R, typename A1> struct X0<R(A1 param)> { };
     35 
     36 template<typename T, typename A1, typename A2>
     37 void instF0(X0<T(A1)> x0a, X0<T(A2)> x0b) {
     38   X0<T(A1)> x0c;
     39   X0<T(A2)> x0d;
     40 }
     41 
     42 template void instF0<int, int, float>(X0<int(int)>, X0<int(float)>);
     43 
     44 template<typename R, typename A1, R (*ptr)(A1)> struct FuncPtr { };
     45 template<typename A1, int (*ptr)(A1)> struct FuncPtr<int, A1, ptr> { };
     46 
     47 template<typename R, typename A1> R unary_func(A1);
     48 
     49 template<typename R, typename A1, typename A2>
     50 void use_func_ptr() {
     51   FuncPtr<R, A1, &unary_func<R, A1> > fp1;
     52   FuncPtr<R, A2, &unary_func<R, A2> > fp2;
     53 };
     54 
     55 template void use_func_ptr<int, float, double>();
     56 
     57 namespace PR6990 {
     58   template < typename , typename = int, typename = int > struct X1;
     59   template <typename >
     60   struct X2;
     61 
     62   template <typename = int *, typename TokenT = int,
     63             typename = int( X2<TokenT> &)>
     64   struct X3
     65   {
     66   };
     67 
     68   template <typename , typename P>
     69   struct X3_base : X3< X1<int, P> >
     70   {
     71   protected: typedef X1< P> type;
     72     X3<type> e;
     73   };
     74 
     75   struct r : X3_base<int, int>
     76   {
     77   };
     78 }
     79 
     80 namespace InstantiateFunctionTypedef {
     81   template<typename T>
     82   struct X {
     83     typedef int functype(int, int);
     84     functype func1;
     85     __attribute__((noreturn)) functype func2;
     86 
     87     typedef int stdfunctype(int, int) __attribute__((stdcall));
     88     __attribute__((stdcall)) functype stdfunc1;
     89     stdfunctype stdfunc2;
     90 
     91     __attribute__((pcs("aapcs"))) functype pcsfunc; // expected-warning {{calling convention 'pcs' ignored for this target}}
     92   };
     93 
     94   void f(X<int> x) {
     95     (void)x.func1(1, 2);
     96     (void)x.func2(1, 2);
     97     (void)x.stdfunc1(1, 2);
     98     (void)x.stdfunc2(1, 2);
     99     (void)x.pcsfunc(1, 2);
    100   }
    101 }
    102