Home | History | Annotate | Download | only in SemaCXX
      1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify -fcxx-exceptions %s
      2 
      3 void fn() = default; // expected-error {{only special member}}
      4 struct foo {
      5   void fn() = default; // expected-error {{only special member}}
      6 
      7   foo() = default;
      8   foo(const foo&) = default;
      9   foo(foo&&) = default;
     10   foo& operator = (const foo&) = default;
     11   foo& operator = (foo&&) = default;
     12   ~foo() = default;
     13 };
     14 
     15 struct bar {
     16   bar();
     17   bar(const bar&);
     18   bar(bar&&);
     19   bar& operator = (const bar&);
     20   bar& operator = (bar&&);
     21   ~bar();
     22 };
     23 
     24 bar::bar() = default;
     25 bar::bar(const bar&) = default;
     26 bar::bar(bar&&) = default;
     27 bar& bar::operator = (const bar&) = default;
     28 bar& bar::operator = (bar&&) = default;
     29 bar::~bar() = default;
     30 
     31 static_assert(__is_trivial(foo), "foo should be trivial");
     32 
     33 static_assert(!__has_trivial_destructor(bar), "bar's destructor isn't trivial");
     34 static_assert(!__has_trivial_constructor(bar),
     35               "bar's default constructor isn't trivial");
     36 static_assert(!__has_trivial_copy(bar), "bar has no trivial copy");
     37 static_assert(!__has_trivial_assign(bar), "bar has no trivial assign");
     38 
     39 void tester() {
     40   foo f, g(f);
     41   bar b, c(b);
     42   f = g;
     43   b = c;
     44 }
     45 
     46 template<typename T> struct S : T {
     47   constexpr S() = default;
     48   constexpr S(const S&) = default;
     49   constexpr S(S&&) = default;
     50 };
     51 struct lit { constexpr lit() {} };
     52 S<lit> s_lit; // ok
     53 S<bar> s_bar; // ok
     54 
     55 struct Friends {
     56   friend S<bar>::S();
     57   friend S<bar>::S(const S&);
     58   friend S<bar>::S(S&&);
     59 };
     60 
     61 namespace DefaultedFnExceptionSpec {
     62   // DR1330: The exception-specification of an implicitly-declared special
     63   // member function is evaluated as needed.
     64   template<typename T> T &&declval();
     65   template<typename T> struct pair {
     66     pair(const pair&) noexcept(noexcept(T(declval<T>())));
     67   };
     68 
     69   struct Y;
     70   struct X { X(); X(const Y&); };
     71   struct Y { pair<X> p; };
     72 
     73   template<typename T>
     74   struct A {
     75     pair<T> p;
     76   };
     77   struct B {
     78     B();
     79     B(const A<B>&);
     80   };
     81 
     82   // Don't crash here.
     83   void f() {
     84     X x = X();
     85     (void)noexcept(B(declval<B>()));
     86   }
     87 
     88   template<typename T>
     89   struct Error {
     90     // FIXME: Type canonicalization causes all the errors to point at the first
     91     // declaration which has the type 'void () noexcept (T::error)'. We should
     92     // get one error for 'Error<int>::Error()' and one for 'Error<int>::~Error()'.
     93     void f() noexcept(T::error); // expected-error 2{{has no members}}
     94 
     95     Error() noexcept(T::error);
     96     Error(const Error&) noexcept(T::error);
     97     Error(Error&&) noexcept(T::error);
     98     Error &operator=(const Error&) noexcept(T::error);
     99     Error &operator=(Error&&) noexcept(T::error);
    100     ~Error() noexcept(T::error);
    101   };
    102 
    103   struct DelayImplicit {
    104     Error<int> e;
    105   };
    106 
    107   // Don't instantiate the exception specification here.
    108   void test1(decltype(declval<DelayImplicit>() = DelayImplicit(DelayImplicit())));
    109   void test2(decltype(declval<DelayImplicit>() = declval<const DelayImplicit>()));
    110   void test3(decltype(DelayImplicit(declval<const DelayImplicit>())));
    111 
    112   // Any odr-use causes the exception specification to be evaluated.
    113   struct OdrUse { // \
    114     expected-note {{instantiation of exception specification for 'Error'}} \
    115     expected-note {{instantiation of exception specification for '~Error'}}
    116     Error<int> e;
    117   };
    118   OdrUse use; // expected-note {{implicit default constructor for 'DefaultedFnExceptionSpec::OdrUse' first required here}}
    119 }
    120 
    121 namespace PR13527 {
    122   struct X {
    123     X() = delete; // expected-note {{here}}
    124     X(const X&) = delete; // expected-note {{here}}
    125     X(X&&) = delete; // expected-note {{here}}
    126     X &operator=(const X&) = delete; // expected-note {{here}}
    127     X &operator=(X&&) = delete; // expected-note {{here}}
    128     ~X() = delete; // expected-note {{here}}
    129   };
    130   X::X() = default; // expected-error {{redefinition}}
    131   X::X(const X&) = default; // expected-error {{redefinition}}
    132   X::X(X&&) = default; // expected-error {{redefinition}}
    133   X &X::operator=(const X&) = default; // expected-error {{redefinition}}
    134   X &X::operator=(X&&) = default; // expected-error {{redefinition}}
    135   X::~X() = default; // expected-error {{redefinition}}
    136 
    137   struct Y {
    138     Y() = default;
    139     Y(const Y&) = default;
    140     Y(Y&&) = default;
    141     Y &operator=(const Y&) = default;
    142     Y &operator=(Y&&) = default;
    143     ~Y() = default;
    144   };
    145   Y::Y() = default; // expected-error {{definition of explicitly defaulted}}
    146   Y::Y(const Y&) = default; // expected-error {{definition of explicitly defaulted}}
    147   Y::Y(Y&&) = default; // expected-error {{definition of explicitly defaulted}}
    148   Y &Y::operator=(const Y&) = default; // expected-error {{definition of explicitly defaulted}}
    149   Y &Y::operator=(Y&&) = default; // expected-error {{definition of explicitly defaulted}}
    150   Y::~Y() = default; // expected-error {{definition of explicitly defaulted}}
    151 }
    152 
    153 namespace PR14577 {
    154   template<typename T>
    155   struct Outer {
    156     template<typename U>
    157     struct Inner1 {
    158       ~Inner1();
    159     };
    160 
    161     template<typename U>
    162     struct Inner2 {
    163       ~Inner2();
    164     };
    165   };
    166 
    167   template<typename T>
    168   Outer<T>::Inner1<T>::~Inner1() = delete; // expected-error {{nested name specifier 'Outer<T>::Inner1<T>::' for declaration does not refer into a class, class template or class template partial specialization}}  expected-error {{only functions can have deleted definitions}}
    169 
    170   template<typename T>
    171   Outer<T>::Inner2<T>::~Inner2() = default; // expected-error {{nested name specifier 'Outer<T>::Inner2<T>::' for declaration does not refer into a class, class template or class template partial specialization}}  expected-error {{only special member functions may be defaulted}}
    172 }
    173 
    174 extern "C" {
    175  template<typename _Tp> // expected-error {{templates must have C++ linkage}}
    176  void PR13573(const _Tp&) = delete; // expected-error {{only functions can have deleted definitions}}
    177 }
    178 
    179 namespace PR15597 {
    180   template<typename T> struct A {
    181     A() noexcept(true) = default;
    182     ~A() noexcept(true) = default;
    183   };
    184   template<typename T> struct B {
    185     B() noexcept(false) = default; // expected-error {{does not match the calculated one}}
    186     ~B() noexcept(false) = default; // expected-error {{does not match the calculated one}}
    187   };
    188   A<int> a;
    189   B<int> b; // expected-note {{here}}
    190 }
    191