1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2
3 struct notlit { // expected-note {{not literal because}}
notlitnotlit4 notlit() {}
5 };
6 struct notlit2 {
notlit2notlit27 notlit2() {}
8 };
9
10 // valid declarations
11 constexpr int i1 = 0;
f1()12 constexpr int f1() { return 0; }
13 struct s1 {
14 constexpr static int mi1 = 0;
15 const static int mi2;
16 };
17 constexpr int s1::mi2 = 0;
18
19 // invalid declarations
20 // not a definition of an object
21 constexpr extern int i2; // expected-error {{constexpr variable declaration must be a definition}}
22 // not a literal type
23 constexpr notlit nl1; // expected-error {{constexpr variable cannot have non-literal type 'const notlit'}}
24 // function parameters
f2(constexpr int i)25 void f2(constexpr int i) {} // expected-error {{function parameter cannot be constexpr}}
26 // non-static member
27 struct s2 {
28 constexpr int mi1; // expected-error {{non-static data member cannot be constexpr}}
29 static constexpr int mi2; // expected-error {{requires an initializer}}
30 };
31 // typedef
32 typedef constexpr int CI; // expected-error {{typedef cannot be constexpr}}
33 // tag
34 constexpr class C1 {}; // expected-error {{class cannot be marked constexpr}}
35 constexpr struct S1 {}; // expected-error {{struct cannot be marked constexpr}}
36 constexpr union U1 {}; // expected-error {{union cannot be marked constexpr}}
37 constexpr enum E1 {}; // expected-error {{enum cannot be marked constexpr}}
38 template <typename T> constexpr class TC1 {}; // expected-error {{class cannot be marked constexpr}}
39 template <typename T> constexpr struct TS1 {}; // expected-error {{struct cannot be marked constexpr}}
40 template <typename T> constexpr union TU1 {}; // expected-error {{union cannot be marked constexpr}}
41 class C2 {} constexpr; // expected-error {{class cannot be marked constexpr}}
42 struct S2 {} constexpr; // expected-error {{struct cannot be marked constexpr}}
43 union U2 {} constexpr; // expected-error {{union cannot be marked constexpr}}
44 enum E2 {} constexpr; // expected-error {{enum cannot be marked constexpr}}
45 constexpr class C3 {} c3 = C3();
46 constexpr struct S3 {} s3 = S3();
47 constexpr union U3 {} u3 = {};
48 constexpr enum E3 { V3 } e3 = V3;
49 class C4 {} constexpr c4 = C4();
50 struct S4 {} constexpr s4 = S4();
51 union U4 {} constexpr u4 = {};
52 enum E4 { V4 } constexpr e4 = V4;
53 constexpr int; // expected-error {{constexpr can only be used in variable and function declarations}}
54 // redeclaration mismatch
55 constexpr int f3(); // expected-note {{previous declaration is here}}
56 int f3(); // expected-error {{non-constexpr declaration of 'f3' follows constexpr declaration}}
57 int f4(); // expected-note {{previous declaration is here}}
58 constexpr int f4(); // expected-error {{constexpr declaration of 'f4' follows non-constexpr declaration}}
59 template<typename T> constexpr T f5(T);
60 template<typename T> constexpr T f5(T); // expected-note {{previous}}
61 template<typename T> T f5(T); // expected-error {{non-constexpr declaration of 'f5' follows constexpr declaration}}
62 template<typename T> T f6(T); // expected-note {{here}}
63 template<typename T> constexpr T f6(T); // expected-error {{constexpr declaration of 'f6' follows non-constexpr declaration}}
64 // destructor
65 struct ConstexprDtor {
66 constexpr ~ConstexprDtor() = default; // expected-error {{destructor cannot be marked constexpr}}
67 };
68
69 // template stuff
ft(T t)70 template <typename T> constexpr T ft(T t) { return t; }
gt(T t)71 template <typename T> T gt(T t) { return t; }
72 struct S {
73 template<typename T> constexpr T f();
74 template<typename T> T g() const;
75 };
76
77 // explicit specialization can differ in constepxr
ft(notlit nl)78 template <> notlit ft(notlit nl) { return nl; }
ft(char c)79 template <> char ft(char c) { return c; } // expected-note {{previous}}
80 template <> constexpr char ft(char nl); // expected-error {{constexpr declaration of 'ft<char>' follows non-constexpr declaration}}
gt(int nl)81 template <> constexpr int gt(int nl) { return nl; }
f() const82 template <> notlit S::f() const { return notlit(); }
g()83 template <> constexpr int S::g() { return 0; } // expected-note {{previous}}
84 template <> int S::g() const; // expected-error {{non-constexpr declaration of 'g<int>' follows constexpr declaration}}
85 // specializations can drop the 'constexpr' but not the implied 'const'.
g()86 template <> char S::g() { return 0; } // expected-error {{no function template matches}}
g() const87 template <> double S::g() const { return 0; } // ok
88
89 constexpr int i3 = ft(1);
90
test()91 void test() {
92 // ignore constexpr when instantiating with non-literal
93 notlit2 nl2;
94 (void)ft(nl2);
95 }
96
97 // Examples from the standard:
98 constexpr int square(int x); // expected-note {{declared here}}
99 constexpr int bufsz = 1024;
100
101 constexpr struct pixel { // expected-error {{struct cannot be marked constexpr}}
102 int x;
103 int y;
104 constexpr pixel(int);
105 };
106
pixel(int a)107 constexpr pixel::pixel(int a)
108 : x(square(a)), y(square(a)) // expected-note {{undefined function 'square' cannot be used in a constant expression}}
109 { }
110
111 constexpr pixel small(2); // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'pixel(2)'}}
112
square(int x)113 constexpr int square(int x) {
114 return x * x;
115 }
116
117 constexpr pixel large(4);
118
next(constexpr int x)119 int next(constexpr int x) { // expected-error {{function parameter cannot be constexpr}}
120 return x + 1;
121 }
122
123 extern constexpr int memsz; // expected-error {{constexpr variable declaration must be a definition}}
124