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 {{does not refer to any declaration}}
10 A<const char (&)[5], "test"> b; // expected-error {{does not refer to any declaration}}
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
28 namespace Function {
29 void f();
30 void g() noexcept;
31 void h();
32 void h(int);
33 template<typename...T> void i(T...);
34 typedef A<void (*)(), f> a;
35 typedef A<void (*)(), &f> a;
36 typedef A<void (*)(), g> b;
37 typedef A<void (*)(), &g> b;
38 typedef A<void (*)(), h> c;
39 typedef A<void (*)(), &h> c;
40 typedef A<void (*)(), i> d;
41 typedef A<void (*)(), &i> d;
42 typedef A<void (*)(), i<>> d;
43 typedef A<void (*)(), i<int>> e; // expected-error {{is not implicitly convertible}}
44
45 typedef A<void (*)(), 0> x; // expected-error {{not allowed in a converted constant}}
46 typedef A<void (*)(), nullptr> y;
47 }
48
Func()49 void Func() {
50 A<const char*, __func__> a; // expected-error {{does not refer to any declaration}}
51 }
52
53 namespace LabelAddrDiff {
f()54 void f() {
55 a: b: A<int, __builtin_constant_p(true) ? (__INTPTR_TYPE__)&&b - (__INTPTR_TYPE__)&&a : 0> s; // expected-error {{label address difference}}
56 };
57 }
58
59 namespace Temp {
60 struct S { int n; };
addr(S && s)61 constexpr S &addr(S &&s) { return s; }
62 A<S &, addr({})> a; // expected-error {{constant}} expected-note 2{{temporary}}
63 A<S *, &addr({})> b; // expected-error {{constant}} expected-note 2{{temporary}}
64 A<int &, addr({}).n> c; // expected-error {{constant}} expected-note 2{{temporary}}
65 A<int *, &addr({}).n> d; // expected-error {{constant}} expected-note 2{{temporary}}
66 }
67
68 namespace std { struct type_info; }
69
70 namespace RTTI {
71 A<const std::type_info&, typeid(int)> a; // expected-error {{does not refer to any declaration}}
72 A<const std::type_info*, &typeid(int)> b; // expected-error {{does not refer to any declaration}}
73 }
74
75 namespace PtrMem {
76 struct B { int b; };
77 struct C : B {};
78 struct D : B {};
79 struct E : C, D { int e; };
80
81 constexpr int B::*b = &B::b;
82 constexpr int C::*cb = b;
83 constexpr int D::*db = b;
84 constexpr int E::*ecb = cb; // expected-note +{{here}}
85 constexpr int E::*edb = db; // expected-note +{{here}}
86
87 constexpr int E::*e = &E::e;
88 constexpr int D::*de = (int D::*)e;
89 constexpr int C::*ce = (int C::*)e;
90 constexpr int B::*bde = (int B::*)de; // expected-note +{{here}}
91 constexpr int B::*bce = (int B::*)ce; // expected-note +{{here}}
92
93 // FIXME: This should all be accepted, but we don't yet have a representation
94 // nor mangling for this form of template argument.
95 using Ab = A<int B::*, b>;
96 using Ab = A<int B::*, &B::b>;
97 using Abce = A<int B::*, bce>; // expected-error {{not supported}}
98 using Abde = A<int B::*, bde>; // expected-error {{not supported}}
99 static_assert(!is_same<Ab, Abce>, ""); // expected-error {{undeclared}} expected-error {{must be a type}}
100 static_assert(!is_same<Ab, Abde>, ""); // expected-error {{undeclared}} expected-error {{must be a type}}
101 static_assert(!is_same<Abce, Abde>, ""); // expected-error 2{{undeclared}} expected-error {{must be a type}}
102 static_assert(is_same<Abce, A<int B::*, (int B::*)(int C::*)&E::e>, ""); // expected-error {{undeclared}} expected-error {{not supported}}
103
104 using Ae = A<int E::*, e>;
105 using Ae = A<int E::*, &E::e>;
106 using Aecb = A<int E::*, ecb>; // expected-error {{not supported}}
107 using Aedb = A<int E::*, edb>; // expected-error {{not supported}}
108 static_assert(!is_same<Ae, Aecb>, ""); // expected-error {{undeclared}} expected-error {{must be a type}}
109 static_assert(!is_same<Ae, Aedb>, ""); // expected-error {{undeclared}} expected-error {{must be a type}}
110 static_assert(!is_same<Aecb, Aedb>, ""); // expected-error 2{{undeclared}} expected-error {{must be a type}}
111 static_assert(is_same<Aecb, A<int E::*, (int E::*)(int C::*)&B::b>, ""); // expected-error {{undeclared}} expected-error {{not supported}}
112
113 using An = A<int E::*, nullptr>;
114 using A0 = A<int E::*, (int E::*)0>;
115 static_assert(is_same<An, A0>);
116 }
117
118 namespace DeduceDifferentType {
119 template<int N> struct A {};
120 template<long N> int a(A<N>); // expected-note {{does not have the same type}}
121 int a_imp = a(A<3>()); // expected-error {{no matching function}}
122 int a_exp = a<3>(A<3>());
123
124 template<decltype(nullptr)> struct B {};
125 template<int *P> int b(B<P>); // expected-note {{could not match}} expected-note {{not implicitly convertible}}
126 int b_imp = b(B<nullptr>()); // expected-error {{no matching function}}
127 int b_exp = b<nullptr>(B<nullptr>()); // expected-error {{no matching function}}
128
operator intDeduceDifferentType::X129 struct X { constexpr operator int() { return 0; } } x;
130 template<X &> struct C {};
131 template<int N> int c(C<N>); // expected-note {{does not have the same type}} expected-note {{not implicitly convertible}}
132 int c_imp = c(C<x>()); // expected-error {{no matching function}}
133 int c_exp = c<x>(C<x>()); // expected-error {{no matching function}}
134
135 struct Z;
136 struct Y { constexpr operator Z&(); } y;
operator Y&DeduceDifferentType::Z137 struct Z { constexpr operator Y&() { return y; } } z;
operator Z&()138 constexpr Y::operator Z&() { return z; }
139 template<Y &> struct D {};
140 template<Z &z> int d(D<z>); // expected-note {{does not have the same type}}
141 int d_imp = d(D<y>()); // expected-error {{no matching function}}
142 int d_exp = d<y>(D<y>());
143 }
144
145 namespace DeclMatch {
146 template<typename T, T> int f();
147 template<typename T> class X { friend int f<T, 0>(); static int n; };
f()148 template<typename T, T> int f() { return X<T>::n; }
149 int k = f<int, 0>(); // ok, friend
150 }
151
152 namespace PR24921 {
153 enum E { e };
154 template<E> void f();
155 template<int> void f(int);
f()156 template<> void f<e>() {}
157 }
158