cxx0x-defaulted-functions.cpp revision afb7ce3f877594362381926eaeac8ed6bbe18069 
1// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
2
3void fn() = default; // expected-error {{only special member}}
4struct 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
15struct bar {
16  bar();
17  bar(const bar&);
18  bar(bar&&);
19  bar& operator = (const bar&);
20  bar& operator = (bar&&);
21  ~bar();
22};
23
24bar::bar() = default;
25bar::bar(const bar&) = default;
26bar::bar(bar&&) = default;
27bar& bar::operator = (const bar&) = default;
28bar& bar::operator = (bar&&) = default;
29bar::~bar() = default;
30
31static_assert(__is_trivial(foo), "foo should be trivial");
32
33static_assert(!__has_trivial_destructor(bar), "bar's destructor isn't trivial");
34static_assert(!__has_trivial_constructor(bar),
35              "bar's default constructor isn't trivial");
36static_assert(!__has_trivial_copy(bar), "bar has no trivial copy");
37static_assert(!__has_trivial_assign(bar), "bar has no trivial assign");
38
39void tester() {
40  foo f, g(f);
41  bar b, c(b);
42  f = g;
43  b = c;
44}
45
46template<typename T> struct S : T {
47  constexpr S() = default;
48  constexpr S(const S&) = default;
49  constexpr S(S&&) = default;
50};
51struct lit { constexpr lit() {} };
52S<lit> s_lit; // ok
53S<bar> s_bar; // ok
54
55struct Friends {
56  friend S<bar>::S();
57  friend S<bar>::S(const S&);
58  friend S<bar>::S(S&&);
59};
60
61namespace 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
121namespace 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
153namespace 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