1 // RUN: %clang_cc1 -fsyntax-only -verify %s
2 
3 // C++0x [temp.arg.nontype] p5:
4 //   The following conversions are performed on each expression used as
5 //   a non-type template-argument. If a non-type template-argument cannot be
6 //   converted to the type of the corresponding template-parameter then the
7 //   program is ill-formed.
8 //     -- for a non-type template-parameter of integral or enumeration type,
9 //        integral promotions (4.5) and integral conversions (4.7) are applied.
10 namespace integral_parameters {
11   template<short s> struct X0 { };
12   X0<17> x0i;
13   X0<'a'> x0c;
14   template<char c> struct X1 { };
15   X1<100l> x1l;
16 }
17 
18 //     -- for a non-type template-parameter of type pointer to object,
19 //        qualification conversions (4.4) and the array-to-pointer conversion
20 //        (4.2) are applied; if the template-argument is of type
21 //        std::nullptr_t, the null pointer conversion (4.10) is applied.
22 namespace pointer_to_object_parameters {
23   // PR6226
24   struct Str {
25     Str(const char *);
26   };
27 
28   template<const char *s>
29   struct A {
getpointer_to_object_parameters::A30     Str get() { return s; }
31   };
32 
33   char hello[6] = "Hello";
34   extern const char world[6];
35   const char world[6] = "world";
test()36   void test() {
37     (void)A<hello>().get();
38     (void)A<world>().get();
39   }
40 
41   class X {
42   public:
43     X();
44     X(int, int);
45     operator int() const;
46   };
47 
48   template<X const *Ptr> struct A2; // expected-note{{template parameter is declared here}}
49 
50   X *X_ptr;
51   X an_X;
52   X array_of_Xs[10];
53   A2<X_ptr> *a12; // expected-error{{must have its address taken}}
54   A2<array_of_Xs> *a13;
55   A2<&an_X> *a13_2;
56   A2<(&an_X)> *a13_3; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
57 
58   // PR6244
59   struct X1 {} X1v;
60   template <X1*> struct X2 { };
61   template <X1* Value> struct X3 : X2<Value> { };
62   struct X4 : X3<&X1v> { };
63 
64   // PR6563
65   int *bar;
66   template <int *> struct zed {}; // expected-note 2{{template parameter is declared here}}
67   void g(zed<bar>*); // expected-error{{must have its address taken}}
68 
69   int baz;
70   void g2(zed<baz>*); // expected-error{{must have its address taken}}
71 
72   void g3(zed<&baz>*); // okay
73 }
74 
75 //     -- For a non-type template-parameter of type reference to object, no
76 //        conversions apply. The type referred to by the reference may be more
77 //        cv-qualified than the (otherwise identical) type of the
78 //        template-argument. The template-parameter is bound directly to the
79 //        template-argument, which shall be an lvalue.
80 namespace reference_parameters {
81   template <int& N> struct S0 { }; // expected-note 3 {{template parameter is declared here}}
82   template <const int& N> struct S1 { }; // expected-note 2 {{template parameter is declared here}}
83   template <volatile int& N> struct S2 { }; // expected-note 2 {{template parameter is declared here}}
84   template <const volatile int& N> struct S3 { };
85   int i;
86   extern const int ci;
87   volatile int vi;
88   extern const volatile int cvi;
test()89   void test() {
90     S0<i> s0;
91     S0<ci> s0c; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'const int' ignores qualifiers}}
92     S0<vi> s0v; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'volatile int' ignores qualifiers}}
93     S0<cvi> s0cv; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'const volatile int' ignores qualifiers}}
94 
95     S1<i> s1;
96     S1<ci> s1c;
97     S1<vi> s1v; // expected-error{{reference binding of non-type template parameter of type 'const int &' to template argument of type 'volatile int' ignores qualifiers}}
98     S1<cvi> s1cv; // expected-error{{reference binding of non-type template parameter of type 'const int &' to template argument of type 'const volatile int' ignores qualifiers}}
99 
100     S2<i> s2;
101     S2<ci> s2c; // expected-error{{reference binding of non-type template parameter of type 'volatile int &' to template argument of type 'const int' ignores qualifiers}}
102     S2<vi> s2v;
103     S2<cvi> s2cv; // expected-error{{reference binding of non-type template parameter of type 'volatile int &' to template argument of type 'const volatile int' ignores qualifiers}}
104 
105     S3<i> s3;
106     S3<ci> s3c;
107     S3<vi> s3v;
108     S3<cvi> s3cv;
109   }
110 
111   namespace PR6250 {
inc()112     template <typename T, const T &ref> void inc() {
113       ref++; // expected-error{{read-only variable is not assignable}}
114     }
115 
bind()116     template<typename T, const T &ref> void bind() {
117       T &ref2 = ref; // expected-error{{drops qualifiers}}
118     }
119 
120     int counter;
test()121     void test() {
122       inc<int, counter>(); // expected-note{{instantiation of}}
123       bind<int, counter>(); // expected-note{{instantiation of}}
124     }
125   }
126 
127   namespace PR6749 {
128     template <int& i> struct foo {}; // expected-note{{template parameter is declared here}}
129     int x, &y = x;
130     foo<y> f; // expected-error{{is not an object}}
131   }
132 }
133 
134 //     -- For a non-type template-parameter of type pointer to function, the
135 //        function-to-pointer conversion (4.3) is applied; if the
136 //        template-argument is of type std::nullptr_t, the null pointer
137 //        conversion (4.10) is applied. If the template-argument represents
138 //        a set of overloaded functions (or a pointer to such), the matching
139 //        function is selected from the set (13.4).
140 namespace pointer_to_function {
141   template<int (*)(int)> struct X0 { }; // expected-note 3{{template parameter is declared here}}
142   int f(int);
143   int f(float);
144   int g(float);
145   int (*funcptr)(int);
146   void x0a(X0<f>);
147   void x0b(X0<&f>);
148   void x0c(X0<g>); // expected-error{{non-type template argument of type 'int (float)' cannot be converted to a value of type 'int (*)(int)'}}
149   void x0d(X0<&g>); // expected-error{{non-type template argument of type 'int (*)(float)' cannot be converted to a value of type 'int (*)(int)'}}
150   void x0e(X0<funcptr>); // expected-error{{must have its address taken}}
151 }
152 
153 //     -- For a non-type template-parameter of type reference to function, no
154 //        conversions apply. If the template-argument represents a set of
155 //        overloaded functions, the matching function is selected from the set
156 //        (13.4).
157 namespace reference_to_function {
158   template<int (&)(int)> struct X0 { }; // expected-note 4{{template parameter is declared here}}
159   int f(int);
160   int f(float);
161   int g(float);
162   int (*funcptr)(int);
163   void x0a(X0<f>);
164   void x0b(X0<&f>); // expected-error{{address taken in non-type template argument for template parameter of reference type 'int (&)(int)'}}
165   void x0c(X0<g>); // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'int (float)'}}
166   void x0d(X0<&g>); // expected-error{{address taken in non-type template argument for template parameter of reference type 'int (&)(int)'}}
167   void x0e(X0<funcptr>); // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'int (*)(int)'}}
168 }
169 //     -- For a non-type template-parameter of type pointer to member function,
170 //        if the template-argument is of type std::nullptr_t, the null member
171 //        pointer conversion (4.11) is applied; otherwise, no conversions
172 //        apply. If the template-argument represents a set of overloaded member
173 //        functions, the matching member function is selected from the set
174 //        (13.4).
175 namespace pointer_to_member_function {
176   struct X { };
177   struct Y : X {
178     int f(int);
179     int g(int);
180     int g(float);
181     float h(float);
182   };
183 
184   template<int (Y::*)(int)> struct X0 {}; // expected-note{{template parameter is declared here}}
185   X0<&Y::f> x0a;
186   X0<&Y::g> x0b;
187   X0<&Y::h> x0c; // expected-error-re{{non-type template argument of type 'float (pointer_to_member_function::Y::*)(float){{( __attribute__\(\(thiscall\)\))?}}' cannot be converted to a value of type 'int (pointer_to_member_function::Y::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
188 }
189 
190 //     -- For a non-type template-parameter of type pointer to data member,
191 //        qualification conversions (4.4) are applied; if the template-argument
192 //        is of type std::nullptr_t, the null member pointer conversion (4.11)
193 //        is applied.
194 namespace pointer_to_member_data {
195   struct X { int x; };
196   struct Y : X { int y; };
197 
198   template<int Y::*> struct X0 {}; // expected-note{{template parameter is declared here}}
199   X0<&Y::y> x0a;
200   X0<&Y::x> x0b;  // expected-error{{non-type template argument of type 'int pointer_to_member_data::X::*' cannot be converted to a value of type 'int pointer_to_member_data::Y::*'}}
201 
202   // Test qualification conversions
203   template<const int Y::*> struct X1 {};
204   X1<&Y::y> x1a;
205 }
206