implicit-member-functions.cpp source code [clang_source_code/test/SemaCXX/implicit-member-functions.cpp]

1	// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
2
3	struct A { };
4	A::A() { } // expected-error {{definition of implicitly declared default constructor}}
5
6	struct B { };
7	B::B(const B&) { } // expected-error {{definition of implicitly declared copy constructor}}
8
9	struct C { };
10	C& C::operator=(const C&) { return *this; } // expected-error {{definition of implicitly declared copy assignment operator}}
11
12	struct D { };
13	D::~D() { } // expected-error {{definition of implicitly declared destructor}}
14
15	// Make sure that the special member functions are introduced for
16	// name-lookup purposes and overload with user-declared
17	// constructors and assignment operators.
18	namespace PR6570 {
19	class A { };
20
21	class B {
22	public:
23	B() {}
24
25	B(const A& a) {
26	operator = (CONST);
27	operator = (a);
28	}
29
30	B& operator = (const A& a) {
31	return *this;
32	}
33
34	void f(const A &a) {
35	B b(a);
36	};
37
38	static const B CONST;
39	};
40
41	}
42
43	namespace PR7594 {
44	// If the lazy declaration of special member functions is triggered
45	// in an out-of-line initializer, make sure the functions aren't in
46	// the initializer scope. This used to crash Clang:
47	struct C {
48	C();
49	static C *c;
50	};
51	C *C::c = new C();
52	}
53
54	namespace Recursion {
55	template<typename T> struct InvokeCopyConstructor {
56	static const T &get();
57	typedef decltype(T(get())) type; // expected-error {{no matching conver}}
58	};
59	struct B;
60	struct A {
61	// expected-note@-1 {{while substituting deduced template arguments}}
62	typedef B type;
63	template<typename T,
64	typename = typename InvokeCopyConstructor<typename T::type>::type>
65	// expected-note@-1 {{in instantiation of template class}}
66	A(const T &);
67	// expected-note@-1 {{in instantiation of default argument}}
68	};
69	struct B { // expected-note {{while declaring the implicit copy constructor for 'B'}}
70	// expected-note@-1 {{candidate constructor (the implicit move }}
71	B(); // expected-note {{candidate constructor not viable}}
72	A a;
73	};
74	// Triggering the declaration of B's copy constructor causes overload
75	// resolution to occur for A's copying constructor, which instantiates
76	// InvokeCopyConstructor<B>, which triggers the declaration of B's copy
77	// constructor. Notionally, this happens when we get to the end of the
78	// definition of 'struct B', so there is no declared copy constructor yet.
79	//
80	// This behavior is g++-compatible, but isn't exactly right; the class is
81	// supposed to be incomplete when we implicitly declare its special members.
82	B b = B();
83
84
85	// Another case, which isn't ill-formed under our rules. This is inspired by
86	// a problem which occurs when combining CGAL with libstdc++-4.7.
87
88	template<typename T> T &&declval();
89	template<typename T, typename U> struct pair {
90	pair();
91	template<typename V, typename W,
92	typename = decltype(T(declval<const V&>())),
93	typename = decltype(U(declval<const W&>()))>
94	pair(const pair<V,W> &);
95	};
96
97	template<typename K> struct Line;
98
99	template<typename K> struct Vector {
100	Vector(const Line<K> &l);
101	};
102
103	template<typename K> struct Point {
104	Vector<K> v;
105	};
106
107	template<typename K> struct Line {
108	pair<Point<K>, Vector<K>> x;
109	};
110
111	// Trigger declaration of Line copy ctor, which causes substitution into
112	// pair's templated constructor, which triggers instantiation of the
113	// definition of Point's copy constructor, which performs overload resolution
114	// on Vector's constructors, which requires declaring all of Line's
115	// constructors. That should not find a copy constructor (because we've not
116	// declared it yet), but by the time we get all the way back here, we should
117	// find the copy constructor.
118	Line<void> L1;
119	Line<void> L2(L1);
120	}
121

Clang Project