clang/test/CXX/special/class.inhctor/p2.cpp

   1 // RUN: %clang_cc1 -std=c++11 -verify %s
   2 //
   3 // Note: [class.inhctor] was removed by P0136R1. This tests the new behavior
   4 // for the wording that used to be there.
   5
   6 template<int> struct X {};
   7
   8 // Constructor characteristics are:
   9 //   - the template parameter list
  10 //   - the parameter-type-list
  11 //   - absence or presence of explicit
  12 //   - absence or presence of constexpr
  13 struct A {
  14   A(X<0>) {} // expected-note 4{{here}}
  15   constexpr A(X<1>) {}
  16   explicit A(X<2>) {} // expected-note 6{{here}}
  17   explicit constexpr A(X<3>) {} // expected-note 4{{here}}
  18 };
  19
  20 A a0 { X<0>{} };
  21 A a0i = { X<0>{} };
  22 constexpr A a0c { X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
  23 constexpr A a0ic = { X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
  24
  25 A a1 { X<1>{} };
  26 A a1i = { X<1>{} };
  27 constexpr A a1c { X<1>{} };
  28 constexpr A a1ic = { X<1>{} };
  29
  30 A a2 { X<2>{} };
  31 A a2i = { X<2>{} }; // expected-error {{constructor is explicit}}
  32 constexpr A a2c { X<2>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
  33 constexpr A a2ic = { X<2>{} }; // expected-error {{constructor is explicit}}
  34
  35 A a3 { X<3>{} };
  36 A a3i = { X<3>{} }; // expected-error {{constructor is explicit}}
  37 constexpr A a3c { X<3>{} };
  38 constexpr A a3ic = { X<3>{} }; // expected-error {{constructor is explicit}}
  39
  40
  41 struct B : A {
  42   using A::A;
  43 };
  44
  45 B b0 { X<0>{} };
  46 B b0i = { X<0>{} };
  47 constexpr B b0c { X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
  48 constexpr B b0ic = { X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
  49
  50 B b1 { X<1>{} };
  51 B b1i = { X<1>{} };
  52 constexpr B b1c { X<1>{} };
  53 constexpr B b1ic = { X<1>{} };
  54
  55 B b2 { X<2>{} };
  56 B b2i = { X<2>{} }; // expected-error {{constructor is explicit}}
  57 constexpr B b2c { X<2>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
  58 constexpr B b2ic = { X<2>{} }; // expected-error {{constructor is explicit}}
  59
  60 B b3 { X<3>{} };
  61 B b3i = { X<3>{} }; // expected-error {{constructor is explicit}}
  62 constexpr B b3c { X<3>{} };
  63 constexpr B b3ic = { X<3>{} }; // expected-error {{constructor is explicit}}
  64
  65
  66 // 'constexpr' is OK even if the constructor doesn't obey the constraints.
  67 struct NonLiteral { NonLiteral(); };
  68 struct NonConstexpr { NonConstexpr(); constexpr NonConstexpr(int); };
  69 struct Constexpr { constexpr Constexpr(int) {} };
  70
  71 struct BothNonLiteral : NonLiteral, Constexpr { using Constexpr::Constexpr; }; // expected-note {{base class 'NonLiteral' of non-literal type}}
  72 constexpr BothNonLiteral bothNL{42}; // expected-error {{constexpr variable cannot have non-literal type 'const BothNonLiteral'}}
  73
  74 // FIXME: This diagnostic is not very good. We should explain that the problem is that base class NonConstexpr cannot be initialized.
  75 struct BothNonConstexpr
  76     : NonConstexpr,
  77       Constexpr {
  78   using Constexpr::Constexpr; // expected-note {{here}}
  79 };
  80 constexpr BothNonConstexpr bothNC{42}; // expected-error {{must be initialized by a constant expression}} expected-note {{inherited from base class 'Constexpr'}}
  81
  82
  83 struct ConstexprEval {
  84   constexpr ConstexprEval(int a, const char *p) : k(p[a]) {}
  85   char k;
  86 };
  87 struct ConstexprEval2 {
  88   char k2 = 'x';
  89 };
  90 struct ConstexprEval3 : ConstexprEval, ConstexprEval2 {
  91   using ConstexprEval::ConstexprEval;
  92 };
  93 constexpr ConstexprEval3 ce{4, "foobar"};
  94 static_assert(ce.k == 'a', "");
  95 static_assert(ce.k2 == 'x', "");
  96
  97
  98 struct TemplateCtors { // expected-note 2{{candidate constructor (the implicit}}
  99   constexpr TemplateCtors() {}
 100   template<template<int> class T> TemplateCtors(X<0>, T<0>); // expected-note {{here}} expected-note {{candidate inherited constructor}}
 101   template<int N> TemplateCtors(X<1>, X<N>); // expected-note {{here}} expected-note {{candidate inherited constructor}}
 102   template<typename T> TemplateCtors(X<2>, T); // expected-note {{here}} expected-note {{candidate inherited constructor}}
 103
 104   template<typename T = int> TemplateCtors(int, int = 0, int = 0);
 105 };
 106
 107 struct UsingTemplateCtors : TemplateCtors { // expected-note 3{{candidate constructor (the implicit}}
 108   using TemplateCtors::TemplateCtors; // expected-note 5{{inherited here}}
 109
 110   constexpr UsingTemplateCtors(X<0>, X<0>) {} // expected-note {{not viable}}
 111   constexpr UsingTemplateCtors(X<1>, X<1>) {} // expected-note {{not viable}}
 112   constexpr UsingTemplateCtors(X<2>, X<2>) {} // expected-note {{not viable}}
 113
 114   template<int = 0> constexpr UsingTemplateCtors(int) {} // expected-note {{not viable}}
 115   template<typename T = void> constexpr UsingTemplateCtors(int, int) {} // expected-note {{not viable}}
 116   template<typename T, typename U> constexpr UsingTemplateCtors(int, int, int) {} // expected-note {{couldn't infer}}
 117 };
 118
 119 template<int> struct Y {};
 120 constexpr UsingTemplateCtors uct1{ X<0>{}, X<0>{} };
 121 constexpr UsingTemplateCtors uct2{ X<0>{}, Y<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
 122 constexpr UsingTemplateCtors uct3{ X<1>{}, X<0>{} }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
 123 constexpr UsingTemplateCtors uct4{ X<1>{}, X<1>{} };
 124 constexpr UsingTemplateCtors uct5{ X<2>{}, 0 }; // expected-error {{must be initialized by a constant expression}} expected-note {{non-constexpr}}
 125 constexpr UsingTemplateCtors uct6{ X<2>{}, X<2>{} };
 126
 127 constexpr UsingTemplateCtors utc7{ 0 }; // ok
 128 constexpr UsingTemplateCtors utc8{ 0, 0 }; // ok
 129 // FIXME: The standard says that UsingTemplateCtors' (int, int, int) constructor
 130 // hides the one from TemplateCtors, even though the template parameter lists
 131 // don't match. It's not clear that that's *really* the intent, and it's not
 132 // what other compilers do.
 133 constexpr UsingTemplateCtors utc9{ 0, 0, 0 }; // expected-error {{no matching constructor}}