1 // RUN: %clang_cc1 -triple %itanium_abi_triple -fsyntax-only -verify %s
2 // RUN: %clang_cc1 -triple %ms_abi_triple -DMSABI -fsyntax-only -verify %s
3
4 namespace PR5557 {
5 template <class T> struct A {
6 A(); // expected-note{{instantiation}}
7 virtual int a(T x);
8 };
A()9 template<class T> A<T>::A() {}
10
a(T x)11 template<class T> int A<T>::a(T x) {
12 return *x; // expected-error{{requires pointer operand}}
13 }
14
f()15 void f() {
16 A<int> x; // expected-note{{instantiation}}
17 }
18
19 template<typename T>
20 struct X {
21 virtual void f();
22 };
23
24 template<>
f()25 void X<int>::f() { }
26 }
27
28 // Like PR5557, but with a defined destructor instead of a defined constructor.
29 namespace PR5557_dtor {
30 template <class T> struct A {
31 A(); // Don't have an implicit constructor.
32 ~A(); // expected-note{{instantiation}}
33 virtual int a(T x);
34 };
~A()35 template<class T> A<T>::~A() {}
36
a(T x)37 template<class T> int A<T>::a(T x) {
38 return *x; // expected-error{{requires pointer operand}}
39 }
40
f()41 void f() {
42 A<int> x; // expected-note{{instantiation}}
43 }
44 }
45
46 template<typename T>
47 struct Base {
~BaseBase48 virtual ~Base() {
49 int *ptr = 0;
50 T t = ptr; // expected-error{{cannot initialize}}
51 }
52 };
53
54 template<typename T>
55 struct Derived : Base<T> {
fooDerived56 virtual void foo() { }
57 };
58
59 template struct Derived<int>; // expected-note {{in instantiation of member function 'Base<int>::~Base' requested here}}
60
61 template<typename T>
62 struct HasOutOfLineKey {
HasOutOfLineKeyHasOutOfLineKey63 HasOutOfLineKey() { } // expected-note{{in instantiation of member function 'HasOutOfLineKey<int>::f' requested here}}
64 virtual T *f(float *fp);
65 };
66
67 template<typename T>
f(float * fp)68 T *HasOutOfLineKey<T>::f(float *fp) {
69 return fp; // expected-error{{cannot initialize return object of type 'int *' with an lvalue of type 'float *'}}
70 }
71
72 HasOutOfLineKey<int> out_of_line; // expected-note{{in instantiation of member function 'HasOutOfLineKey<int>::HasOutOfLineKey' requested here}}
73
74 namespace std {
75 class type_info;
76 }
77
78 namespace PR7114 {
79 class A { virtual ~A(); }; // expected-note{{declared private here}}
80
81 template<typename T>
82 class B {
83 public:
84 class Inner : public A { }; // expected-error{{base class 'PR7114::A' has private destructor}}
85 static Inner i;
86 static const unsigned value = sizeof(i) == 4;
87 };
88
f()89 int f() { return B<int>::value; }
90
91 #ifdef MSABI
test_typeid(B<float>::Inner bfi)92 void test_typeid(B<float>::Inner bfi) { // expected-note{{implicit destructor}}
93 (void)typeid(bfi);
94 #else
95 void test_typeid(B<float>::Inner bfi) {
96 (void)typeid(bfi); // expected-note{{implicit destructor}}
97 #endif
98 }
99
100 template<typename T>
101 struct X : A {
102 void f() { }
103 };
104
105 void test_X(X<int> &xi, X<float> &xf) {
106 xi.f();
107 }
108 }
109
110 namespace DynamicCast {
111 struct Y {};
112 template<typename T> struct X : virtual Y {
fooDynamicCast::X113 virtual void foo() { T x; }
114 };
115 template<typename T> struct X2 : virtual Y {
fooDynamicCast::X2116 virtual void foo() { T x; }
117 };
f(X<void> * x)118 Y* f(X<void>* x) { return dynamic_cast<Y*>(x); }
f2(X<void> * x)119 Y* f2(X<void>* x) { return dynamic_cast<Y*>(x); }
120 }
121
122 namespace avoid_using_vtable {
123 // We shouldn't emit the vtable for this code, in any ABI. If we emit the
124 // vtable, we emit an implicit virtual dtor, which calls ~RefPtr, which requires
125 // a complete type for DeclaredOnly.
126 //
127 // Previously we would reference the vtable in the MS C++ ABI, even though we
128 // don't need to emit either the ctor or the dtor. In the Itanium C++ ABI, the
129 // 'trace' method is the key function, so even though we use the vtable, we
130 // don't emit it.
131
132 template <typename T>
133 struct RefPtr {
134 T *m_ptr;
~RefPtravoid_using_vtable::RefPtr135 ~RefPtr() { m_ptr->deref(); }
136 };
137 struct DeclaredOnly;
138 struct Base {
139 virtual ~Base();
140 };
141
142 struct AvoidVTable : Base {
143 RefPtr<DeclaredOnly> m_insertionStyle;
144 virtual void trace();
145 AvoidVTable();
146 };
147 // Don't call the dtor, because that will emit an implicit dtor, and require a
148 // complete type for DeclaredOnly.
foo()149 void foo() { new AvoidVTable; }
150 }
151
152 namespace vtable_uses_incomplete {
153 // Opposite of the previous test that avoids a vtable, this one tests that we
154 // use the vtable when the ctor is defined inline.
155 template <typename T>
156 struct RefPtr {
157 T *m_ptr;
~RefPtrvtable_uses_incomplete::RefPtr158 ~RefPtr() { m_ptr->deref(); } // expected-error {{member access into incomplete type 'vtable_uses_incomplete::DeclaredOnly'}}
159 };
160 struct DeclaredOnly; // expected-note {{forward declaration of 'vtable_uses_incomplete::DeclaredOnly'}}
161 struct Base {
162 virtual ~Base();
163 };
164
165 struct UsesVTable : Base {
166 RefPtr<DeclaredOnly> m_insertionStyle;
167 virtual void trace();
UsesVTablevtable_uses_incomplete::UsesVTable168 UsesVTable() {} // expected-note {{in instantiation of member function 'vtable_uses_incomplete::RefPtr<vtable_uses_incomplete::DeclaredOnly>::~RefPtr' requested here}}
169 };
170 }
171