Clang Project

clang_source_code/test/SemaTemplate/instantiate-function-params.cpp
1// RUN: %clang_cc1 -triple i686-unknown-unknown -fsyntax-only -verify %s
2
3// PR6619
4template<bool C> struct if_c { };
5template<typename T1> struct if_ {
6  typedef if_c< static_cast<bool>(T1::value)> almost_type_; // expected-note 5{{in instantiation}}
7};
8template <class Model, void (Model::*)()> struct wrap_constraints { };
9template <class Model> 
10inline char has_constraints_(Model* , // expected-note 3{{candidate template ignored}}
11                               wrap_constraints<Model,&Model::constraints>* = 0); // expected-note 2{{in instantiation}}
12
13template <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};
17template <class ModelFn> struct requirement_;
18template <void(*)()> struct instantiate {
19};
20template <class Model> struct requirement_<void(*)(Model)>                           : if_<       not_satisfied<Model>         >::type { // expected-note 5{{in instantiation}}
21};
22template <class Model> struct usage_requirements {
23};
24template < typename TT > struct InputIterator                            {
25    typedef  instantiate< & requirement_<void(*)(usage_requirements<InputIterator> x)>::failed> boost_concept_check1; // expected-note {{in instantiation}}
26};
27template < 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};
31typedef instantiate< &requirement_<void(*)(ForwardIterator<char*> x)>::failed> boost_concept_checkX;// expected-note 3{{in instantiation}}
32
33template<typename T> struct X0 { };
34template<typename R, typename A1> struct X0<R(A1 param)> { };
35
36template<typename T, typename A1, typename A2>
37void instF0(X0<T(A1)> x0a, X0<T(A2)> x0b) {
38  X0<T(A1)> x0c;
39  X0<T(A2)> x0d;
40}
41
42template void instF0<int, int, float>(X0<int(int)>, X0<int(float)>);
43
44template<typename R, typename A1, R (*ptr)(A1)> struct FuncPtr { };
45template<typename A1, int (*ptr)(A1)> struct FuncPtr<int, A1, ptr> { };
46
47template<typename R, typename A1> R unary_func(A1);
48
49template<typename R, typename A1, typename A2>
50void use_func_ptr() {
51  FuncPtr<R, A1, &unary_func<R, A1> > fp1;
52  FuncPtr<R, A2, &unary_func<R, A2> > fp2;
53};
54
55template void use_func_ptr<int, float, double>();
56
57namespace 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
80namespace 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 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
CodeThinker, Enjoy your reading code