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
