1 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++11 %s 2 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++14 %s 3 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++17 %s 4 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify -std=c++2a %s 5 6 // MSVC always adopted the C++17 rule that implies that constexpr variables are 7 // implicitly inline, so do the test again. 8 // RUN: %clang_cc1 -triple x86_64-windows-msvc -DMS_ABI -fsyntax-only -verify -std=c++11 %s 9 10 struct notlit { // expected-note {{not literal because}} 11 notlit() {} 12 }; 13 struct notlit2 { 14 notlit2() {} 15 }; 16 17 // valid declarations 18 constexpr int i1 = 0; 19 constexpr int f1() { return 0; } 20 struct s1 { 21 constexpr static int mi1 = 0; 22 const static int mi2; 23 }; 24 constexpr int s1::mi2 = 0; 25 26 // invalid declarations 27 // not a definition of an object 28 constexpr extern int i2; // expected-error {{constexpr variable declaration must be a definition}} 29 // not a literal type 30 constexpr notlit nl1; // expected-error {{constexpr variable cannot have non-literal type 'const notlit'}} 31 // function parameters 32 void f2(constexpr int i) {} // expected-error {{function parameter cannot be constexpr}} 33 // non-static member 34 struct s2 { 35 constexpr int mi1; // expected-error {{non-static data member cannot be constexpr; did you intend to make it const?}} 36 static constexpr int mi2; 37 #if __cplusplus <= 201402L && !defined(MS_ABI) 38 // expected-error@-2 {{requires an initializer}} 39 #else 40 // expected-error@-4 {{constexpr variable 'mi2' must be initialized by a constant expression}} 41 #endif 42 mutable constexpr int mi3 = 3; // expected-error-re {{non-static data member cannot be constexpr{{$}}}} expected-error {{'mutable' and 'const' cannot be mixed}} 43 }; 44 // typedef 45 typedef constexpr int CI; // expected-error {{typedef cannot be constexpr}} 46 // tag 47 constexpr class C1 {}; // expected-error {{class cannot be marked constexpr}} 48 constexpr struct S1 {}; // expected-error {{struct cannot be marked constexpr}} 49 constexpr union U1 {}; // expected-error {{union cannot be marked constexpr}} 50 constexpr enum E1 {}; // expected-error {{enum cannot be marked constexpr}} 51 template <typename T> constexpr class TC1 {}; // expected-error {{class cannot be marked constexpr}} 52 template <typename T> constexpr struct TS1 {}; // expected-error {{struct cannot be marked constexpr}} 53 template <typename T> constexpr union TU1 {}; // expected-error {{union cannot be marked constexpr}} 54 class C2 {} constexpr; // expected-error {{class cannot be marked constexpr}} 55 struct S2 {} constexpr; // expected-error {{struct cannot be marked constexpr}} 56 union U2 {} constexpr; // expected-error {{union cannot be marked constexpr}} 57 enum E2 {} constexpr; // expected-error {{enum cannot be marked constexpr}} 58 constexpr class C3 {} c3 = C3(); 59 constexpr struct S3 {} s3 = S3(); 60 constexpr union U3 {} u3 = {}; 61 constexpr enum E3 { V3 } e3 = V3; 62 class C4 {} constexpr c4 = C4(); 63 struct S4 {} constexpr s4 = S4(); 64 union U4 {} constexpr u4 = {}; 65 enum E4 { V4 } constexpr e4 = V4; 66 constexpr int; // expected-error {{constexpr can only be used in variable and function declarations}} 67 // redeclaration mismatch 68 constexpr int f3(); // expected-note {{previous declaration is here}} 69 int f3(); // expected-error {{non-constexpr declaration of 'f3' follows constexpr declaration}} 70 int f4(); // expected-note {{previous declaration is here}} 71 constexpr int f4(); // expected-error {{constexpr declaration of 'f4' follows non-constexpr declaration}} 72 template<typename T> constexpr T f5(T); 73 template<typename T> constexpr T f5(T); // expected-note {{previous}} 74 template<typename T> T f5(T); // expected-error {{non-constexpr declaration of 'f5' follows constexpr declaration}} 75 template<typename T> T f6(T); // expected-note {{here}} 76 template<typename T> constexpr T f6(T); // expected-error {{constexpr declaration of 'f6' follows non-constexpr declaration}} 77 // destructor 78 struct ConstexprDtor { 79 constexpr ~ConstexprDtor() = default; 80 #if __cplusplus <= 201703L 81 // expected-error@-2 {{destructor cannot be declared constexpr}} 82 #endif 83 }; 84 85 // template stuff 86 template <typename T> constexpr T ft(T t) { return t; } 87 template <typename T> T gt(T t) { return t; } 88 struct S { 89 template<typename T> constexpr T f(); // expected-warning 0-1{{C++14}} expected-note 0-1{{candidate}} 90 template <typename T> 91 T g() const; // expected-note-re {{candidate template ignored: could not match 'T (){{( __attribute__\(\(thiscall\)\))?}} const' against 'char (){{( __attribute__\(\(thiscall\)\))?}}'}} 92 #if __cplusplus >= 201402L 93 // expected-note@-2 {{candidate template ignored: could not match 'T () const' against 'int ()'}} 94 #endif 95 }; 96 97 // explicit specialization can differ in constepxr 98 template <> notlit ft(notlit nl) { return nl; } 99 template <> char ft(char c) { return c; } // expected-note {{previous}} 100 template <> constexpr char ft(char nl); // expected-error {{constexpr declaration of 'ft<char>' follows non-constexpr declaration}} 101 template <> constexpr int gt(int nl) { return nl; } 102 template <> notlit S::f() const { return notlit(); } 103 #if __cplusplus >= 201402L 104 // expected-error@-2 {{no function template matches}} 105 #endif 106 template <> constexpr int S::g() { return 0; } 107 #if __cplusplus < 201402L 108 // expected-warning@-2 {{C++14}} 109 // expected-note@-3 {{previous}} 110 #else 111 // expected-error@-5 {{no function template matches function template specialization 'g'}} 112 #endif 113 template <> int S::g() const; 114 #if __cplusplus < 201402L 115 // expected-error@-2 {{non-constexpr declaration of 'g<int>' follows constexpr declaration}} 116 #endif 117 // specializations can drop the 'constexpr' but not the implied 'const'. 118 template <> char S::g() { return 0; } // expected-error {{no function template matches}} 119 template <> double S::g() const { return 0; } // ok 120 121 constexpr int i3 = ft(1); 122 123 void test() { 124 // ignore constexpr when instantiating with non-literal 125 notlit2 nl2; 126 (void)ft(nl2); 127 } 128 129 // Examples from the standard: 130 constexpr int square(int x); // expected-note {{declared here}} 131 constexpr int bufsz = 1024; 132 133 constexpr struct pixel { // expected-error {{struct cannot be marked constexpr}} 134 int x; 135 int y; 136 constexpr pixel(int); 137 }; 138 139 constexpr pixel::pixel(int a) 140 : x(square(a)), y(square(a)) // expected-note {{undefined function 'square' cannot be used in a constant expression}} 141 { } 142 143 constexpr pixel small(2); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'pixel(2)'}} 144 145 constexpr int square(int x) { 146 return x * x; 147 } 148 149 constexpr pixel large(4); 150 151 int next(constexpr int x) { // expected-error {{function parameter cannot be constexpr}} 152 return x + 1; 153 } 154 155 extern constexpr int memsz; // expected-error {{constexpr variable declaration must be a definition}} 156 157 namespace { 158 struct A { 159 static constexpr int n = 0; 160 }; 161 // FIXME: We should diagnose this prior to C++17. 162 const int &r = A::n; 163 } 164 165 #if __cplusplus < 201402L 166 namespace ImplicitConstexprDef { 167 struct A { // #defined-here 168 void f(); // expected-note {{member declaration does not match because it is not const qualified}} 169 }; 170 171 constexpr void A::f() { } // expected-warning {{'constexpr' non-static member function will not be implicitly 'const' in C++14; add 'const' to avoid a change in behavior}} 172 // expected-error@-1 {{out-of-line definition of 'f' does not match any declaration in 'ImplicitConstexprDef::A'}} 173 // expected-note@#defined-here {{defined here}} 174 } 175 #endif 176