Richard Smith | 07b0fdc | 2013-03-18 21:12:30 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -std=c++11 -verify %s |
| 2 | |
| 3 | template<int> struct X {}; |
| 4 | |
| 5 | // Constructor characteristics are: |
Richard Smith | 4841ca5 | 2013-04-10 05:48:59 +0000 | [diff] [blame] | 6 | // - the template parameter list |
Richard Smith | 07b0fdc | 2013-03-18 21:12:30 +0000 | [diff] [blame] | 7 | // - the parameter-type-list |
| 8 | // - absence or presence of explicit |
| 9 | // - absence or presence of constexpr |
| 10 | struct A { |
| 11 | A(X<0>) {} // expected-note 2{{here}} |
| 12 | constexpr A(X<1>) {} |
| 13 | explicit A(X<2>) {} // expected-note 3{{here}} |
| 14 | explicit constexpr A(X<3>) {} // expected-note 2{{here}} |
| 15 | }; |
| 16 | |
| 17 | A a0 { X<0>{} }; |
| 18 | A a0i = { X<0>{} }; |
| 19 | constexpr A a0c { X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 20 | constexpr A a0ic = { X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 21 | |
| 22 | A a1 { X<1>{} }; |
| 23 | A a1i = { X<1>{} }; |
| 24 | constexpr A a1c { X<1>{} }; |
| 25 | constexpr A a1ic = { X<1>{} }; |
| 26 | |
| 27 | A a2 { X<2>{} }; |
| 28 | A a2i = { X<2>{} }; // expected-error {{constructor is explicit}} |
| 29 | constexpr A a2c { X<2>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 30 | constexpr A a2ic = { X<2>{} }; // expected-error {{constructor is explicit}} |
| 31 | |
| 32 | A a3 { X<3>{} }; |
| 33 | A a3i = { X<3>{} }; // expected-error {{constructor is explicit}} |
| 34 | constexpr A a3c { X<3>{} }; |
| 35 | constexpr A a3ic = { X<3>{} }; // expected-error {{constructor is explicit}} |
| 36 | |
| 37 | |
| 38 | struct B : A { |
| 39 | using A::A; // expected-note 7{{here}} |
| 40 | }; |
| 41 | |
| 42 | B b0 { X<0>{} }; |
| 43 | B b0i = { X<0>{} }; |
| 44 | constexpr B b0c { X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 45 | constexpr B b0ic = { X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 46 | |
| 47 | B b1 { X<1>{} }; |
| 48 | B b1i = { X<1>{} }; |
| 49 | constexpr B b1c { X<1>{} }; |
| 50 | constexpr B b1ic = { X<1>{} }; |
| 51 | |
| 52 | B b2 { X<2>{} }; |
| 53 | B b2i = { X<2>{} }; // expected-error {{constructor is explicit}} |
| 54 | constexpr B b2c { X<2>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 55 | constexpr B b2ic = { X<2>{} }; // expected-error {{constructor is explicit}} |
| 56 | |
| 57 | B b3 { X<3>{} }; |
| 58 | B b3i = { X<3>{} }; // expected-error {{constructor is explicit}} |
| 59 | constexpr B b3c { X<3>{} }; |
| 60 | constexpr B b3ic = { X<3>{} }; // expected-error {{constructor is explicit}} |
| 61 | |
| 62 | |
| 63 | // 'constexpr' is OK even if the constructor doesn't obey the constraints. |
| 64 | struct NonLiteral { NonLiteral(); }; |
| 65 | struct NonConstexpr { NonConstexpr(); constexpr NonConstexpr(int); }; // expected-note {{here}} |
| 66 | struct Constexpr { constexpr Constexpr(int) {} }; |
| 67 | |
| 68 | struct BothNonLiteral : NonLiteral, Constexpr { using Constexpr::Constexpr; }; // expected-note {{base class 'NonLiteral' of non-literal type}} |
| 69 | constexpr BothNonLiteral bothNL{42}; // expected-error {{constexpr variable cannot have non-literal type 'const BothNonLiteral'}} |
| 70 | |
| 71 | struct BothNonConstexpr : NonConstexpr, Constexpr { using Constexpr::Constexpr; }; // expected-note {{non-constexpr constructor 'NonConstexpr}} |
| 72 | constexpr BothNonConstexpr bothNC{42}; // expected-error {{must be initialized by a constant expression}} expected-note {{in call to 'BothNonConstexpr(42)'}} |
| 73 | |
| 74 | |
| 75 | struct ConstexprEval { |
| 76 | constexpr ConstexprEval(int a, const char *p) : k(p[a]) {} |
| 77 | char k; |
| 78 | }; |
| 79 | struct ConstexprEval2 { |
| 80 | char k2 = 'x'; |
| 81 | }; |
| 82 | struct ConstexprEval3 : ConstexprEval, ConstexprEval2 { |
| 83 | using ConstexprEval::ConstexprEval; |
| 84 | }; |
| 85 | constexpr ConstexprEval3 ce{4, "foobar"}; |
| 86 | static_assert(ce.k == 'a', ""); |
| 87 | static_assert(ce.k2 == 'x', ""); |
Richard Smith | 4841ca5 | 2013-04-10 05:48:59 +0000 | [diff] [blame] | 88 | |
| 89 | |
| 90 | struct TemplateCtors { |
| 91 | constexpr TemplateCtors() {} |
| 92 | template<template<int> class T> TemplateCtors(X<0>, T<0>); |
| 93 | template<int N> TemplateCtors(X<1>, X<N>); |
| 94 | template<typename T> TemplateCtors(X<2>, T); |
| 95 | |
| 96 | template<typename T = int> TemplateCtors(int, int = 0, int = 0); // expected-note {{inherited from here}} |
| 97 | }; |
| 98 | |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame^] | 99 | struct UsingTemplateCtors : TemplateCtors { // expected-note 2{{candidate is the implicit}} |
Richard Smith | 4841ca5 | 2013-04-10 05:48:59 +0000 | [diff] [blame] | 100 | using TemplateCtors::TemplateCtors; // expected-note 4{{here}} expected-note {{candidate}} |
| 101 | |
| 102 | constexpr UsingTemplateCtors(X<0>, X<0>) {} |
| 103 | constexpr UsingTemplateCtors(X<1>, X<1>) {} |
| 104 | constexpr UsingTemplateCtors(X<2>, X<2>) {} |
| 105 | |
| 106 | template<int = 0> constexpr UsingTemplateCtors(int) {} // expected-note {{candidate}} |
| 107 | template<typename T = void> constexpr UsingTemplateCtors(int, int) {} |
| 108 | template<typename T, typename U> constexpr UsingTemplateCtors(int, int, int) {} |
| 109 | }; |
| 110 | |
| 111 | template<int> struct Y {}; |
| 112 | constexpr UsingTemplateCtors uct1{ X<0>{}, X<0>{} }; |
| 113 | constexpr UsingTemplateCtors uct2{ X<0>{}, Y<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 114 | constexpr UsingTemplateCtors uct3{ X<1>{}, X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 115 | constexpr UsingTemplateCtors uct4{ X<1>{}, X<1>{} }; |
| 116 | constexpr UsingTemplateCtors uct5{ X<2>{}, 0 }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |
| 117 | constexpr UsingTemplateCtors uct6{ X<2>{}, X<2>{} }; |
| 118 | |
| 119 | constexpr UsingTemplateCtors utc7{ 0 }; // expected-error {{ambiguous}} |
| 120 | constexpr UsingTemplateCtors utc8{ 0, 0 }; // ok |
| 121 | constexpr UsingTemplateCtors utc9{ 0, 0, 0 }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}} |