clang/test/CXX/dcl.decl/dcl.fct.def/dcl.fct.def.default/p2.cpp

   1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -fcxx-exceptions %s
   2
   3 // An explicitly-defaulted function may be declared constexpr only if it would
   4 // have been implicitly declared as constexpr.
   5 struct S1 {
   6   constexpr S1() = default; // expected-error {{defaulted definition of default constructor cannot be marked constexpr}}
   7   constexpr S1(const S1&) = default;
   8   constexpr S1(S1&&) = default;
   9   constexpr S1 &operator=(const S1&) const = default; // expected-error {{explicitly-defaulted copy assignment operator may not have}}
  10   constexpr S1 &operator=(S1&&) const = default; // expected-error {{explicitly-defaulted move assignment operator may not have}}
  11   constexpr ~S1() = default; // expected-error {{destructor cannot be declared constexpr}}
  12   int n;
  13 };
  14 struct NoCopyMove {
  15   constexpr NoCopyMove() {}
  16   NoCopyMove(const NoCopyMove&);
  17   NoCopyMove(NoCopyMove&&);
  18 };
  19 struct S2 {
  20   constexpr S2() = default;
  21   constexpr S2(const S2&) = default; // expected-error {{defaulted definition of copy constructor cannot be marked constexpr}}
  22   constexpr S2(S2&&) = default; // expected-error {{defaulted definition of move constructor cannot be marked}}
  23   NoCopyMove ncm;
  24 };
  25
  26 // If a function is explicitly defaulted on its first declaration
  27 //   -- it is implicitly considered to be constexpr if the implicit declaration
  28 //      would be
  29 struct S3 {
  30   S3() = default;
  31   S3(const S3&) = default;
  32   S3(S3&&) = default;
  33   constexpr S3(int n) : n(n) {}
  34   int n;
  35 };
  36 constexpr S3 s3a = S3(0);
  37 constexpr S3 s3b = s3a;
  38 constexpr S3 s3c = S3();
  39 constexpr S3 s3d; // expected-error {{default initialization of an object of const type 'const S3' without a user-provided default constructor}}
  40
  41 struct S4 {
  42   S4() = default;
  43   S4(const S4&) = default; // expected-note {{here}}
  44   S4(S4&&) = default; // expected-note {{here}}
  45   NoCopyMove ncm;
  46 };
  47 constexpr S4 s4a{}; // ok
  48 constexpr S4 s4b = S4(); // expected-error {{constant expression}} expected-note {{non-constexpr constructor}}
  49 constexpr S4 s4c = s4a; // expected-error {{constant expression}} expected-note {{non-constexpr constructor}}
  50
  51 struct S5 {
  52   constexpr S5();
  53   int n = 1, m = n + 3;
  54 };
  55 constexpr S5::S5() = default;
  56 static_assert(S5().m == 4, "");
  57
  58
  59 // An explicitly-defaulted function may have a different exception specification
  60 // from the exception specification on an implicit declaration.
  61 struct E1 {
  62   E1() noexcept = default;
  63   E1(const E1&) noexcept = default;
  64   E1(E1&&) noexcept = default;
  65   E1 &operator=(const E1&) noexcept = default;
  66   E1 &operator=(E1&&) noexcept = default;
  67   ~E1() noexcept = default;
  68 };
  69 struct E2 {
  70   E2() noexcept(false) = default;
  71   E2(const E2&) noexcept(false) = default;
  72   E2(E2&&) noexcept(false) = default;
  73   E2 &operator=(const E2&) noexcept(false) = default;
  74   E2 &operator=(E2&&) noexcept(false) = default;
  75   ~E2() noexcept(false) = default;
  76 };
  77 E2 e2;
  78 E2 make_e2() noexcept;
  79 void take_e2(E2&&) noexcept;
  80 static_assert(!noexcept(E2()), "");
  81 static_assert(!noexcept(E2(e2)), "");
  82 static_assert(!noexcept(E2(static_cast<E2&&>(e2))), "");
  83 static_assert(!noexcept(e2 = e2), "");
  84 static_assert(!noexcept(e2 = static_cast<E2&&>(e2)), "");
  85 // FIXME: This expression results in destruction of an E2 temporary; the
  86 // noexcept expression should evaluate to false.
  87 static_assert(noexcept(take_e2(make_e2())), "");
  88
  89 // If a function is explicitly defaulted on its first declaration
  90 //   -- it is implicitly considered to have the same exception-specification as
  91 //      if it had been implicitly declared
  92 struct E3 {
  93   E3() = default;
  94   E3(const E3&) = default;
  95   E3(E3&&) = default;
  96   E3 &operator=(const E3&) = default;
  97   E3 &operator=(E3&&) = default;
  98   ~E3() = default;
  99 };
 100 E3 e3;
 101 static_assert(noexcept(E3(), E3(E3()), E3(e3), e3 = E3(), e3 = e3), "");
 102 struct E4 {
 103   E4() noexcept(false);
 104   E4(const E4&) noexcept(false);
 105   E4(E4&&) noexcept(false);
 106   E4 &operator=(const E4&) noexcept(false);
 107   E4 &operator=(E4&&) noexcept(false);
 108   ~E4() noexcept(false);
 109 };
 110 struct E5 {
 111   E5() = default;
 112   E5(const E5&) = default;
 113   E5(E5&&) = default;
 114   E5 &operator=(const E5&) = default;
 115   E5 &operator=(E5&&) = default;
 116   ~E5() = default;
 117
 118   E4 e4;
 119 };
 120 E5 e5;
 121 static_assert(!noexcept(E5()), "");
 122 static_assert(!noexcept(E5(static_cast<E5&&>(e5))), "");
 123 static_assert(!noexcept(E5(e5)), "");
 124 static_assert(!noexcept(e5 = E5()), "");
 125 static_assert(!noexcept(e5 = e5), "");
 126
 127 namespace PR13492 {
 128   struct B {
 129     B() = default;
 130     int field;
 131   };
 132
 133   void f() {
 134     const B b; // expected-error {{default initialization of an object of const type 'const B' without a user-provided default constructor}}
 135   }
 136 }