p3.cpp revision 762bb9d0ad20320b9f97a841dce57ba5e8e48b07 
1// RUN: %clang_cc1 -verify -std=c++11 %s
2
3namespace N {
4  typedef char C;
5}
6
7namespace M {
8  typedef double D;
9}
10
11struct NonLiteral { // expected-note 4{{no constexpr constructors}}
12  NonLiteral() {}
13  NonLiteral(int) {}
14};
15struct Literal {
16  constexpr Literal() {}
17  operator int() const { return 0; }
18};
19
20struct S {
21  virtual int ImplicitlyVirtual() const = 0; // expected-note {{overridden virtual function}}
22};
23struct SS : S {
24  int ImplicitlyVirtual() const;
25};
26
27// Note, the wording applies constraints to the definition of constexpr
28// functions, but we intentionally apply all that we can to the declaration
29// instead. See DR1360.
30
31// The definition of a constexpr function shall satisfy the following
32// constraints:
33struct T : SS { // expected-note {{base class 'SS' of non-literal type}}
34  constexpr T(); // expected-error {{non-literal type 'T' cannot have constexpr members}}
35
36  //  - it shall not be virtual;
37  virtual constexpr int ExplicitlyVirtual(); // expected-error {{virtual function cannot be constexpr}}
38
39  constexpr int ImplicitlyVirtual(); // expected-error {{virtual function cannot be constexpr}}
40
41  //  - its return type shall be a literal type;
42  constexpr NonLiteral NonLiteralReturn(); // expected-error {{constexpr function's return type 'NonLiteral' is not a literal type}}
43  constexpr ~T(); // expected-error {{destructor cannot be marked constexpr}}
44  typedef NonLiteral F();
45  constexpr F NonLiteralReturn2; // expected-error {{constexpr function's return type 'NonLiteral' is not a literal type}}
46
47  //  - each of its parameter types shall be a literal type;
48  constexpr int NonLiteralParam(NonLiteral); // expected-error {{constexpr function's 1st parameter type 'NonLiteral' is not a literal type}}
49  typedef int G(NonLiteral);
50  constexpr G NonLiteralParam2; // expected-error {{constexpr function's 1st parameter type 'NonLiteral' is not a literal type}}
51
52  //  - its function-body shall be = delete, = default,
53  constexpr int Deleted() = delete;
54  // It's not possible for the function-body to legally be "= default" here.
55  // Other than constructors, only the copy- and move-assignment operators and
56  // destructor can be defaulted. Destructors can't be constexpr since they
57  // don't have a literal return type. Defaulted assignment operators can't be
58  // constexpr since they can't be const.
59  constexpr T &operator=(const T&) = default; // expected-error {{an explicitly-defaulted copy assignment operator may not have 'const', 'constexpr' or 'volatile' qualifiers}}
60};
61struct U {
62  constexpr U SelfReturn();
63  constexpr int SelfParam(U);
64};
65
66//  or a compound-statememt that contains only
67constexpr int AllowedStmts() {
68  //  - null statements
69  ;
70
71  //  - static_assert-declarations
72  static_assert(true, "the impossible happened!");
73
74  //  - typedef declarations and alias-declarations that do not define classes
75  //    or enumerations
76  typedef int I;
77  typedef struct S T;
78  using J = int;
79  using K = int[sizeof(I) + sizeof(J)];
80  // Note, the standard requires we reject this.
81  struct U;
82
83  //  - using-declarations
84  using N::C;
85
86  //  - using-directives
87  using namespace N;
88
89  //  - and exactly one return statement
90  return sizeof(K) + sizeof(C) + sizeof(K);
91}
92constexpr int ForStmt() {
93  for (int n = 0; n < 10; ++n) // expected-error {{statement not allowed in constexpr function}}
94    return 0;
95}
96constexpr int VarDecl() {
97  constexpr int a = 0; // expected-error {{variables cannot be declared in a constexpr function}}
98  return 0;
99}
100constexpr int FuncDecl() {
101  constexpr int ForwardDecl(int); // expected-error {{statement not allowed in constexpr function}}
102  return ForwardDecl(42);
103}
104constexpr int ClassDecl1() {
105  typedef struct { } S1; // expected-error {{types cannot be defined in a constexpr function}}
106  return 0;
107}
108constexpr int ClassDecl2() {
109  using S2 = struct { }; // expected-error {{types cannot be defined in a constexpr function}}
110  return 0;
111}
112constexpr int ClassDecl3() {
113  struct S3 { }; // expected-error {{types cannot be defined in a constexpr function}}
114  return 0;
115}
116constexpr int NoReturn() {} // expected-error {{no return statement in constexpr function}}
117constexpr int MultiReturn() {
118  return 0; // expected-note {{return statement}}
119  return 0; // expected-error {{multiple return statements in constexpr function}}
120}
121
122//  - every constructor call and implicit conversion used in initializing the
123//    return value shall be one of those allowed in a constant expression.
124//
125// We implement the proposed resolution of DR1364 and ignore this bullet.
126