1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++1z %s 2 3 template<typename T, T val> struct A {}; 4 5 template<typename T, typename U> constexpr bool is_same = false; // expected-note +{{here}} 6 template<typename T> constexpr bool is_same<T, T> = true; 7 8 namespace String { 9 A<const char*, "test"> a; // expected-error {{pointer to subobject of string literal}} 10 A<const char (&)[5], "test"> b; // expected-error {{reference to string literal}} 11 } 12 13 namespace Array { 14 char arr[3]; 15 char x; 16 A<const char*, arr> a; 17 A<const char(&)[3], arr> b; 18 A<const char*, &arr[0]> c; 19 A<const char*, &arr[1]> d; // expected-error {{refers to subobject '&arr[1]'}} 20 A<const char*, (&arr)[0]> e; 21 A<const char*, &x> f; 22 A<const char*, &(&x)[0]> g; 23 A<const char*, &(&x)[1]> h; // expected-error {{refers to subobject '&x + 1'}} 24 A<const char*, 0> i; // expected-error {{not allowed in a converted constant}} 25 A<const char*, nullptr> j; 26 27 extern char aub[]; 28 A<char[], aub> k; 29 } 30 31 namespace Function { 32 void f(); 33 void g() noexcept; 34 void h(); 35 void h(int); 36 template<typename...T> void i(T...); 37 typedef A<void (*)(), f> a; 38 typedef A<void (*)(), &f> a; 39 typedef A<void (*)(), g> b; 40 typedef A<void (*)(), &g> b; 41 typedef A<void (*)(), h> c; 42 typedef A<void (*)(), &h> c; 43 typedef A<void (*)(), i> d; 44 typedef A<void (*)(), &i> d; 45 typedef A<void (*)(), i<>> d; 46 typedef A<void (*)(), i<int>> e; // expected-error {{is not implicitly convertible}} 47 48 typedef A<void (*)(), 0> x; // expected-error {{not allowed in a converted constant}} 49 typedef A<void (*)(), nullptr> y; 50 } 51 52 void Func() { 53 A<const char*, __func__> a; // expected-error {{pointer to subobject of predefined '__func__' variable}} 54 } 55 56 namespace LabelAddrDiff { 57 void f() { 58 a: b: A<int, __builtin_constant_p(true) ? (__INTPTR_TYPE__)&&b - (__INTPTR_TYPE__)&&a : 0> s; // expected-error {{label address difference}} 59 }; 60 } 61 62 namespace Temp { 63 struct S { int n; }; 64 constexpr S &addr(S &&s) { return s; } 65 A<S &, addr({})> a; // expected-error {{reference to temporary object}} 66 A<S *, &addr({})> b; // expected-error {{pointer to temporary object}} 67 A<int &, addr({}).n> c; // expected-error {{reference to subobject of temporary object}} 68 A<int *, &addr({}).n> d; // expected-error {{pointer to subobject of temporary object}} 69 } 70 71 namespace std { struct type_info; } 72 73 namespace RTTI { 74 A<const std::type_info&, typeid(int)> a; // expected-error {{reference to type_info object}} 75 A<const std::type_info*, &typeid(int)> b; // expected-error {{pointer to type_info object}} 76 } 77 78 namespace PtrMem { 79 struct B { int b; }; 80 struct C : B {}; 81 struct D : B {}; 82 struct E : C, D { int e; }; 83 84 constexpr int B::*b = &B::b; 85 constexpr int C::*cb = b; 86 constexpr int D::*db = b; 87 constexpr int E::*ecb = cb; // expected-note +{{here}} 88 constexpr int E::*edb = db; // expected-note +{{here}} 89 90 constexpr int E::*e = &E::e; 91 constexpr int D::*de = (int D::*)e; 92 constexpr int C::*ce = (int C::*)e; 93 constexpr int B::*bde = (int B::*)de; // expected-note +{{here}} 94 constexpr int B::*bce = (int B::*)ce; // expected-note +{{here}} 95 96 // FIXME: This should all be accepted, but we don't yet have a representation 97 // nor mangling for this form of template argument. 98 using Ab = A<int B::*, b>; 99 using Ab = A<int B::*, &B::b>; 100 using Abce = A<int B::*, bce>; // expected-error {{not supported}} 101 using Abde = A<int B::*, bde>; // expected-error {{not supported}} 102 static_assert(!is_same<Ab, Abce>, ""); // expected-error {{undeclared}} expected-error {{must be a type}} 103 static_assert(!is_same<Ab, Abde>, ""); // expected-error {{undeclared}} expected-error {{must be a type}} 104 static_assert(!is_same<Abce, Abde>, ""); // expected-error 2{{undeclared}} expected-error {{must be a type}} 105 static_assert(is_same<Abce, A<int B::*, (int B::*)(int C::*)&E::e>>, ""); // expected-error {{undeclared}} expected-error {{not supported}} 106 107 using Ae = A<int E::*, e>; 108 using Ae = A<int E::*, &E::e>; 109 using Aecb = A<int E::*, ecb>; // expected-error {{not supported}} 110 using Aedb = A<int E::*, edb>; // expected-error {{not supported}} 111 static_assert(!is_same<Ae, Aecb>, ""); // expected-error {{undeclared}} expected-error {{must be a type}} 112 static_assert(!is_same<Ae, Aedb>, ""); // expected-error {{undeclared}} expected-error {{must be a type}} 113 static_assert(!is_same<Aecb, Aedb>, ""); // expected-error 2{{undeclared}} expected-error {{must be a type}} 114 static_assert(is_same<Aecb, A<int E::*, (int E::*)(int C::*)&B::b>>, ""); // expected-error {{undeclared}} expected-error {{not supported}} 115 116 using An = A<int E::*, nullptr>; 117 using A0 = A<int E::*, (int E::*)0>; 118 static_assert(is_same<An, A0>); 119 } 120 121 namespace DeduceDifferentType { 122 template<int N> struct A {}; 123 template<long N> int a(A<N>); // expected-note {{does not have the same type}} 124 int a_imp = a(A<3>()); // expected-error {{no matching function}} 125 int a_exp = a<3>(A<3>()); 126 127 template<decltype(nullptr)> struct B {}; 128 template<int *P> int b(B<P>); // expected-error {{value of type 'int *' is not implicitly convertible to 'decltype(nullptr)'}} 129 int b_imp = b(B<nullptr>()); // expected-error {{no matching function}} 130 int b_exp = b<nullptr>(B<nullptr>()); // expected-error {{no matching function}} 131 132 struct X { constexpr operator int() { return 0; } } x; 133 template<X &> struct C {}; 134 template<int N> int c(C<N>); // expected-error {{value of type 'int' is not implicitly convertible to 'DeduceDifferentType::X &'}} 135 int c_imp = c(C<x>()); // expected-error {{no matching function}} 136 int c_exp = c<x>(C<x>()); // expected-error {{no matching function}} 137 138 struct Z; 139 struct Y { constexpr operator Z&(); } y; 140 struct Z { constexpr operator Y&() { return y; } } z; 141 constexpr Y::operator Z&() { return z; } 142 template<Y &> struct D {}; 143 template<Z &z> int d(D<z>); // expected-note {{couldn't infer template argument 'z'}} 144 int d_imp = d(D<y>()); // expected-error {{no matching function}} 145 int d_exp = d<y>(D<y>()); 146 } 147 148 namespace DeclMatch { 149 template<typename T, T> int f(); 150 template<typename T> class X { friend int f<T, 0>(); static int n; }; 151 template<typename T, T> int f() { return X<T>::n; } 152 int k = f<int, 0>(); // ok, friend 153 } 154 155 namespace PR24921 { 156 enum E { e }; 157 template<E> void f(); 158 template<int> void f(int); 159 template<> void f<e>() {} 160 } test_X0_X1()161 162 namespace Auto { 163 namespace Basic { 164 // simple auto 165 template<auto x> constexpr auto constant = x; // expected-note {{declared here}} 166 167 auto v1 = constant<5>; 168 auto v2 = constant<true>; 169 auto v3 = constant<'a'>; 170 auto v4 = constant<2.5>; // expected-error {{cannot have type 'double'}} 171 172 using T1 = decltype(v1); 173 using T1 = int; 174 using T2 = decltype(v2); 175 using T2 = bool; 176 using T3 = decltype(v3); 177 using T3 = char; 178 179 // pointers 180 template<auto v> class B { }; 181 template<auto* p> class B<p> { }; // expected-note {{matches}} 182 template<auto** pp> class B<pp> { }; 183 template<auto* p0> int &f(B<p0> b); // expected-note {{candidate}} 184 template<auto** pp0> float &f(B<pp0> b); // expected-note {{candidate}} 185 186 int a, *b = &a; 187 int &r = f(B<&a>()); 188 float &s = f(B<&b>()); 189 190 void type_affects_identity(B<&a>) {} 191 void type_affects_identity(B<(const int*)&a>) {} 192 void type_affects_identity(B<(void*)&a>) {} 193 void type_affects_identity(B<(const void*)&a>) {} 194 195 // pointers to members 196 template<typename T, auto *T::*p> struct B<p> {}; 197 template<typename T, auto **T::*p> struct B<p> {}; 198 template<typename T, auto *T::*p0> char &f(B<p0> b); // expected-note {{candidate}} 199 template<typename T, auto **T::*pp0> short &f(B<pp0> b); // expected-note {{candidate}} 200 201 struct X { int n; int *p; int **pp; typedef int a, b; }; 202 auto t = f(B<&X::n>()); // expected-error {{no match}} 203 char &u = f(B<&X::p>()); 204 short &v = f(B<&X::pp>()); 205 206 struct Y : X {}; 207 void type_affects_identity(B<&X::n>) {} 208 void type_affects_identity(B<(int Y::*)&X::n>) {} // FIXME: expected-error {{sorry}} 209 void type_affects_identity(B<(const int X::*)&X::n>) {} 210 void type_affects_identity(B<(const int Y::*)&X::n>) {} // FIXME: expected-error {{sorry}} 211 212 // A case where we need to do auto-deduction, and check whether the 213 // resulting dependent types match during partial ordering. These 214 // templates are not ordered due to the mismatching function parameter. 215 template<typename T, auto *(*f)(T, typename T::a)> struct B<f> {}; // expected-note {{matches}} 216 template<typename T, auto **(*f)(T, typename T::b)> struct B<f> {}; // expected-note {{matches}} 217 int **g(X, int); 218 B<&g> bg; // expected-error {{ambiguous}} 219 } 220 221 namespace Chained { 222 // chained template argument deduction 223 template<long n> struct C { }; 224 template<class T> struct D; 225 template<class T, T n> struct D<C<n>> 226 { 227 using Q = T; 228 }; 229 using DQ = long; 230 using DQ = D<C<short(2)>>::Q; 231 232 // chained template argument deduction from an array bound 233 template<typename T> struct E; 234 template<typename T, T n> struct E<int[n]> { 235 using Q = T; 236 }; 237 using EQ = E<int[short(42)]>::Q; 238 using EQ = decltype(sizeof 0); 239 240 template<int N> struct F; 241 template<typename T, T N> int foo(F<N> *) = delete; // expected-note {{explicitly deleted}} 242 void foo(void *); // expected-note {{candidate function}} 243 void bar(F<0> *p) { 244 foo(p); // expected-error {{deleted function}} 245 } 246 } 247 248 namespace ArrayToPointer { 249 constexpr char s[] = "test"; 250 template<const auto* p> struct S { }; 251 S<s> p; 252 253 template<typename R, typename P, R F(P)> struct A {}; 254 template<typename R, typename P, R F(P)> void x(A<R, P, F> a); 255 void g(int) { x(A<void, int, &g>()); } 256 } 257 258 namespace DecltypeAuto { 259 template<auto v> struct A { }; 260 template<decltype(auto) v> struct DA { }; 261 template<auto&> struct R { }; 262 263 auto n = 0; // expected-note + {{declared here}} 264 A<n> a; // expected-error {{not a constant}} expected-note {{non-const variable 'n'}} 265 DA<n> da1; // expected-error {{not a constant}} expected-note {{non-const variable 'n'}} 266 DA<(n)> da2; 267 R<n> r; 268 } 269 270 namespace Decomposition { 271 // Types of deduced non-type template arguments must match exactly, so 272 // partial ordering fails in both directions here. 273 template<auto> struct Any; 274 template<int N> struct Any<N> { typedef int Int; }; // expected-note 3{{match}} 275 template<short N> struct Any<N> { typedef int Short; }; // expected-note 3{{match}} 276 Any<0>::Int is_int; // expected-error {{ambiguous}} 277 Any<(short)0>::Short is_short; // expected-error {{ambiguous}} 278 Any<(char)0>::Short is_char; // expected-error {{ambiguous}} 279 280 template<int, auto> struct NestedAny; 281 template<auto N> struct NestedAny<0, N>; // expected-note 3{{match}} 282 template<int N> struct NestedAny<0, N> { typedef int Int; }; // expected-note 3{{match}} 283 template<short N> struct NestedAny<0, N> { typedef int Short; }; // expected-note 3{{match}} 284 NestedAny<0, 0>::Int nested_int; // expected-error {{ambiguous}} 285 NestedAny<0, (short)0>::Short nested_short; // expected-error {{ambiguous}} 286 NestedAny<0, (char)0>::Short nested_char; // expected-error {{ambiguous}} 287 288 double foo(int, bool); 289 template<auto& f> struct fn_result_type; 290 291 template<class R, class... Args, R (& f)(Args...)> 292 struct fn_result_type<f> 293 { 294 using type = R; 295 }; 296 297 using R1 = fn_result_type<foo>::type; 298 using R1 = double; 299 300 template<int, auto &f> struct fn_result_type_partial_order; 301 template<auto &f> struct fn_result_type_partial_order<0, f>; 302 template<class R, class... Args, R (& f)(Args...)> 303 struct fn_result_type_partial_order<0, f> {}; 304 fn_result_type_partial_order<0, foo> frtpo; 305 } 306 307 namespace Variadic { 308 template<auto... vs> struct value_list { }; 309 310 using size_t = decltype(sizeof 0); 311 template<size_t n, class List> struct nth_element; 312 template<size_t n, class List> constexpr auto nth_element_v = nth_element<n, List>::value; 313 314 template<size_t n, auto v0, auto... vs> 315 struct nth_element<n, value_list<v0, vs...>> 316 { 317 static constexpr auto value = nth_element<n - 1, value_list<vs...>>::value; 318 }; 319 template<auto v0, auto... vs> 320 struct nth_element<0, value_list<v0, vs...>> 321 { 322 static constexpr auto value = v0; 323 }; 324 325 static_assert(nth_element_v<2, value_list<'a', 27U, false>> == false, "value mismatch"); 326 } 327 } 328 329 namespace Nested { 330 template<typename T> struct A { 331 template<auto X> struct B; 332 template<auto *P> struct B<P>; 333 template<auto **P> struct B<P> { using pointee = decltype(+**P); }; 334 template<auto (*P)(T)> struct B<P> { using param = T; }; 335 template<typename U, auto (*P)(T, U)> struct B<P> { using param2 = U; }; 336 }; main()337 338 using Int = int; 339 340 int *n; 341 using Int = A<int>::B<&n>::pointee; 342 343 void f(int); 344 using Int = A<int>::B<&f>::param; 345 346 void g(int, int); 347 using Int = A<int>::B<&g>::param2; 348 } 349 350 namespace rdar41852459 { 351 template <auto V> struct G {}; 352 353 template <class T> struct S { 354 template <auto V> void f() { 355 G<V> x; 356 } 357 template <auto *PV> void f2() { test()358 G<PV> x; 359 } 360 template <decltype(auto) V> void f3() { 361 G<V> x; 362 } 363 }; 364 365 template <auto *PV> struct I {}; 366 367 template <class T> struct K { 368 template <auto *PV> void f() { 369 I<PV> x; 370 } 371 template <auto V> void f2() { foo()372 I<V> x; 373 } 374 template <decltype(auto) V> void f3() { 375 I<V> x; 376 } 377 }; 378 379 template <decltype(auto)> struct L {}; 380 template <class T> struct M { 381 template <auto *PV> void f() { 382 L<PV> x; bPR17696::b383 } 384 template <auto V> void f() { 385 L<V> x; 386 } 387 template <decltype(auto) V> void f() { 388 L<V> x; 389 } 390 }; 391 } 392 393 namespace PR42362 { 394 template<auto ...A> struct X { struct Y; void f(int...[A]); }; 395 template<auto ...A> struct X<A...>::Y {}; 396 template<auto ...A> void X<A...>::f(int...[A]) {} 397 void f() { X<1, 2>::Y y; X<1, 2>().f(0, 0); } 398 399 template<typename, auto...> struct Y; 400 template<auto ...A> struct Y<int, A...> {}; 401 Y<int, 1, 2, 3> y; 402 403 template<auto (&...F)()> struct Z { struct Q; }; 404 template<auto (&...F)()> struct Z<F...>::Q {}; 405 Z<f, f, f>::Q q; 406 } 407 408 namespace QualConv { 409 int *X; 410 template<const int *const *P> void f() { 411 using T = decltype(P); 412 using T = const int* const*; 413 } 414 template void f<&X>(); 415 416 template<const int *const &R> void g() { 417 using T = decltype(R); 418 using T = const int *const &; 419 } 420 template void g<(const int *const&)X>(); 421 } 422 423 namespace FunctionConversion { 424 struct a { void c(char *) noexcept; }; 425 template<void (a::*f)(char*)> void g() { 426 using T = decltype(f); 427 using T = void (a::*)(char*); // (not 'noexcept') 428 } 429 template void g<&a::c>(); 430 431 void c() noexcept; 432 template<void (*p)()> void h() { 433 using T = decltype(p); 434 using T = void (*)(); // (not 'noexcept') 435 } 436 template void h<&c>(); 437 } 438 439 namespace VoidPtr { 440 // Note, this is an extension in C++17 but valid in C++20. 441 template<void *P> void f() { 442 using T = decltype(P); 443 using T = void*; 444 } 445 int n; 446 template void f<(void*)&n>(); 447 } 448 449 namespace PR42108 { 450 struct R {}; 451 struct S { constexpr S() {} constexpr S(R) {} }; 452 struct T { constexpr operator S() { return {}; } }; 453 template <const S &> struct A {}; 454 void f() { 455 A<R{}>(); // expected-error {{would bind reference to a temporary}} 456 A<S{}>(); // expected-error {{reference to temporary object}} 457 A<T{}>(); // expected-error {{reference to temporary object}} 458 } 459 } 460 461 namespace PR46637 { 462 template<auto (*f)() -> auto> struct X { // expected-note {{here}} 463 auto call() { return f(); } 464 }; 465 X<nullptr> x; // expected-error {{incompatible initializer}} g()466 467 void *f(); 468 X<f> y; 469 int n = y.call(); // expected-error {{cannot initialize a variable of type 'int' with an rvalue of type 'void *'}} 470 } 471 472 namespace PR48517 { 473 template<const int *P> struct A { static constexpr const int *p = P; }; 474 template<typename T> auto make_nonconst() { 475 static int n; 476 return A<&n>(); 477 }; 478 using T = decltype(make_nonconst<int>()); // expected-note {{previous}} f()479 using U = decltype(make_nonconst<float>()); 480 static_assert(T::p != U::p); g()481 using T = U; // expected-error {{different types}} 482 483 template<typename T> auto make_const() { 484 static constexpr int n = 42; 485 return A<&n>(); 486 }; 487 using V = decltype(make_const<int>()); // expected-note {{previous}} 488 using W = decltype(make_const<float>()); 489 static_assert(*V::p == *W::p); 490 static_assert(V::p != W::p); 491 using V = W; // expected-error {{different types}} 492 f()493 template<auto V> struct Q { 494 using X = int; 495 static_assert(V == "primary template should not be instantiated"); 496 }; 497 template<typename T> struct R { 498 int n; a()499 constexpr int f() { 500 return Q<&R::n>::X; 501 } 502 }; 503 template<> struct Q<&R<int>::n> { static constexpr int X = 1; }; 504 static_assert(R<int>().f() == 1); 505 } 506 507 namespace dependent_reference { 508 template<int &r> struct S { int *q = &r; }; 509 template<int> auto f() { static int n; return S<n>(); } 510 auto v = f<0>(); 511 auto w = f<1>(); 512 static_assert(!is_same<decltype(v), decltype(w)>); 513 // Ensure that we can instantiate the definition of S<...>. 514 int n = *v.q + *w.q; 515 } 516 517 namespace decay { 518 template<typename T, typename C, const char *const A[(int)T::count]> struct X { 519 template<typename CC> void f(const X<T, CC, A> &v) {} 520 }; 521 struct A { 522 static constexpr const char *arr[] = {"hello", "world"}; 523 static constexpr int count = 2; 524 }; 525 void f() { 526 X<A, int, A::arr> x1; 527 X<A, float, A::arr> x2; 528 x1.f(x2); ftype_of_pack::A529 } 530 } 531 532 namespace TypeSuffix { 533 template <auto N> struct A {}; 534 template <> struct A<1> { using type = int; }; // expected-note {{'A<1>::type' declared here}} 535 A<1L>::type a; // expected-error {{no type named 'type' in 'TypeSuffix::A<1L>'; did you mean 'A<1>::type'?}} 536 537 template <auto N> struct B {}; 538 template <> struct B<1> { using type = int; }; // expected-note {{'B<1>::type' declared here}} 539 B<2>::type b; // expected-error {{no type named 'type' in 'TypeSuffix::B<2>'; did you mean 'B<1>::type'?}} 540 541 template <auto N> struct C {}; 542 template <> struct C<'a'> { using type = signed char; }; // expected-note {{'C<'a'>::type' declared here}} 543 C<(signed char)'a'>::type c; // expected-error {{no type named 'type' in 'TypeSuffix::C<(signed char)'a'>'; did you mean 'C<'a'>::type'?}} 544 545 template <auto N> struct D {}; 546 template <> struct D<'a'> { using type = signed char; }; // expected-note {{'D<'a'>::type' declared here}} 547 D<'b'>::type d; // expected-error {{no type named 'type' in 'TypeSuffix::D<'b'>'; did you mean 'D<'a'>::type'?}} 548 549 template <auto N> struct E {}; 550 template <> struct E<'a'> { using type = unsigned char; }; // expected-note {{'E<'a'>::type' declared here}} 551 E<(unsigned char)'a'>::type e; // expected-error {{no type named 'type' in 'TypeSuffix::E<(unsigned char)'a'>'; did you mean 'E<'a'>::type'?}} 552 553 template <auto N> struct F {}; 554 template <> struct F<'a'> { using type = unsigned char; }; // expected-note {{'F<'a'>::type' declared here}} 555 F<'b'>::type f; // expected-error {{no type named 'type' in 'TypeSuffix::F<'b'>'; did you mean 'F<'a'>::type'?}} 556 557 template <auto... N> struct X {}; 558 X<1, 1u>::type y; // expected-error {{no type named 'type' in 'TypeSuffix::X<1, 1U>'}} 559 X<1, 1>::type z; // expected-error {{no type named 'type' in 'TypeSuffix::X<1, 1>'}} 560 } 561