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>
instF0(X0<T (A1)> x0a,X0<T (A2)> x0b)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>
use_func_ptr()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 {{'pcs' calling convention is not supported for this target}}
92 };
93
f(X<int> x)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