1 // RUN: %clang_cc1 -std=c++11 -verify %s 2 3 template<int> struct X {}; 4 5 // Constructor characteristics are: 6 // - the template parameter list 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', ""); 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 99 struct UsingTemplateCtors : TemplateCtors { 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}} 122
