1 // RUN: %clang_cc1 %s -verify -fexceptions
2 class A {
3 void f() __attribute__((deprecated)); // expected-note 2 {{'f' has been explicitly marked deprecated here}}
4 void g(A* a);
5 void h(A* a) __attribute__((deprecated));
6
7 int b __attribute__((deprecated)); // expected-note 2 {{'b' has been explicitly marked deprecated here}}
8 };
9
g(A * a)10 void A::g(A* a)
11 {
12 f(); // expected-warning{{'f' is deprecated}}
13 a->f(); // expected-warning{{'f' is deprecated}}
14
15 (void)b; // expected-warning{{'b' is deprecated}}
16 (void)a->b; // expected-warning{{'b' is deprecated}}
17 }
18
h(A * a)19 void A::h(A* a)
20 {
21 f();
22 a->f();
23
24 (void)b;
25 (void)a->b;
26 }
27
28 struct B {
29 virtual void f() __attribute__((deprecated)); // expected-note 6 {{'f' has been explicitly marked deprecated here}}
30 void g();
31 };
32
g()33 void B::g() {
34 f(); // expected-warning{{'f' is deprecated}}
35 B::f(); // expected-warning{{'f' is deprecated}}
36 }
37
38 struct C : B {
39 virtual void f();
40 void g();
41 };
42
g()43 void C::g() {
44 f();
45 C::f();
46 B::f(); // expected-warning{{'f' is deprecated}}
47 }
48
f(B * b,C * c)49 void f(B* b, C *c) {
50 b->f(); // expected-warning{{'f' is deprecated}}
51 b->B::f(); // expected-warning{{'f' is deprecated}}
52
53 c->f();
54 c->C::f();
55 c->B::f(); // expected-warning{{'f' is deprecated}}
56 }
57
58 struct D {
59 virtual void f() __attribute__((deprecated));// expected-note{{'f' has been explicitly marked deprecated here}}
60 virtual void f(int) __attribute__((deprecated));// expected-note{{'f' has been explicitly marked deprecated here}}
61 virtual void f(int, int) __attribute__((deprecated));// expected-note{{'f' has been explicitly marked deprecated here}}
62 };
63
f()64 void D::f() { }
f(int v)65 void D::f(int v) { }
f(int v1,int v2)66 void D::f(int v1, int v2) { }
67
f(D * d)68 void f(D* d) {
69 d->f(); // expected-warning{{'f' is deprecated}}
70 d->f(42); // expected-warning{{'f' is deprecated}}
71 d->f(42, 24); // expected-warning{{'f' is deprecated}}
72 }
73
74
75 // Overloaded namespace members.
76 namespace test1 {
77 void foo(int) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
test1()78 void test1() { foo(10); } // expected-warning {{deprecated}}
79 void foo(short) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
test2(short s)80 void test2(short s) { foo(s); } // expected-warning {{deprecated}}
81 void foo(long);
test3(long l)82 void test3(long l) { foo(l); }
83 struct A {
84 friend void foo(A*) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
85 };
test4(A * a)86 void test4(A *a) { foo(a); } // expected-warning {{deprecated}}
87
88 namespace ns {
89 struct Foo {};
90 void foo(const Foo &f) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
91 }
test5()92 void test5() {
93 foo(ns::Foo()); // expected-warning {{deprecated}}
94 }
95 }
96
97 // Overloaded class members.
98 namespace test2 {
99 struct A {
100 void foo(int) __attribute__((deprecated)); // expected-note 2 {{'foo' has been explicitly marked deprecated here}}
101 void foo(long);
102 static void bar(int) __attribute__((deprecated)); // expected-note 3 {{'bar' has been explicitly marked deprecated here}}
103 static void bar(long);
104
105 void test2(int i, long l);
106 };
test1(int i,long l)107 void test1(int i, long l) {
108 A a;
109 a.foo(i); // expected-warning {{deprecated}}
110 a.foo(l);
111 a.bar(i); // expected-warning {{deprecated}}
112 a.bar(l);
113 A::bar(i); // expected-warning {{deprecated}}
114 A::bar(l);
115 }
116
test2(int i,long l)117 void A::test2(int i, long l) {
118 foo(i); // expected-warning {{deprecated}}
119 foo(l);
120 bar(i); // expected-warning {{deprecated}}
121 bar(l);
122 }
123 }
124
125 // Overloaded operators.
126 namespace test3 {
127 struct A {
128 void operator*(const A &);
129 void operator*(int) __attribute__((deprecated)); // expected-note {{'operator*' has been explicitly marked deprecated here}}
130 void operator-(const A &) const;
131 };
132 void operator+(const A &, const A &);
133 void operator+(const A &, int) __attribute__((deprecated)); // expected-note {{'operator+' has been explicitly marked deprecated here}}
134 void operator-(const A &, int) __attribute__((deprecated)); // expected-note {{'operator-' has been explicitly marked deprecated here}}
135
test()136 void test() {
137 A a, b;
138 a + b;
139 a + 1; // expected-warning {{deprecated}}
140 a - b;
141 a - 1; // expected-warning {{deprecated}}
142 a * b;
143 a * 1; // expected-warning {{deprecated}}
144 }
145 }
146
147 // Overloaded operator call.
148 namespace test4 {
149 struct A {
150 typedef void (*intfn)(int);
151 typedef void (*unintfn)(unsigned);
152 operator intfn() __attribute__((deprecated)); // expected-note {{'operator void (*)(int)' has been explicitly marked deprecated here}}
153 operator unintfn();
154 void operator ()(A &) __attribute__((deprecated)); // expected-note {{'operator()' has been explicitly marked deprecated here}}
155 void operator ()(const A &);
156 };
157
test()158 void test() {
159 A a;
160 a(1); // expected-warning {{deprecated}}
161 a(1U);
162
163 A &b = a;
164 const A &c = a;
165 a(b); // expected-warning {{deprecated}}
166 a(c);
167 }
168 }
169
170 namespace test5 {
171 struct A {
172 operator int() __attribute__((deprecated)); // expected-note 3 {{'operator int' has been explicitly marked deprecated here}}
173 operator long();
174 };
test1(A a)175 void test1(A a) {
176 int i = a; // expected-warning {{deprecated}}
177 long l = a;
178 }
179
180 void foo(int);
181 void foo(void*);
182 void bar(long);
183 void bar(void*);
test2(A a)184 void test2(A a) {
185 foo(a); // expected-warning {{deprecated}}
186 bar(a);
187 }
188
189 struct B {
190 int myInt;
191 long myLong;
192
Btest5::B193 B(A &a) :
194 myInt(a), // expected-warning {{deprecated}}
195 myLong(a)
196 {}
197 };
198 }
199
200 // rdar://problem/8518751
201 namespace test6 {
202 enum __attribute__((deprecated)) A { // expected-note 2 {{'A' has been explicitly marked deprecated here}}
203 a0
204 };
testA()205 void testA() {
206 A x; // expected-warning {{'A' is deprecated}}
207 x = a0; // expected-warning {{'a0' is deprecated}}
208 }
209
210 enum B {
211 b0 __attribute__((deprecated)), // expected-note {{'b0' has been explicitly marked deprecated here}}
212 b1
213 };
testB()214 void testB() {
215 B x;
216 x = b0; // expected-warning {{'b0' is deprecated}}
217 x = b1;
218 }
219
220 template <class T> struct C {
221 enum __attribute__((deprecated)) Enum { // expected-note 2 {{'Enum' has been explicitly marked deprecated here}}
222 c0
223 };
224 };
testC()225 void testC() {
226 C<int>::Enum x; // expected-warning {{'Enum' is deprecated}}
227 x = C<int>::c0; // expected-warning {{'c0' is deprecated}}
228 }
229
230 template <class T> struct D {
231 enum Enum {
232 d0,
233 d1 __attribute__((deprecated)), // expected-note {{'d1' has been explicitly marked deprecated here}}
234 };
235 };
testD()236 void testD() {
237 D<int>::Enum x;
238 x = D<int>::d0;
239 x = D<int>::d1; // expected-warning {{'d1' is deprecated}}
240 }
241 }
242
243 namespace test7 {
244 struct X {
245 void* operator new(typeof(sizeof(void*))) __attribute__((deprecated)); // expected-note{{'operator new' has been explicitly marked deprecated here}}
246 void operator delete(void *) __attribute__((deprecated)); // expected-note{{'operator delete' has been explicitly marked deprecated here}}
247 };
248
test()249 void test() {
250 X *x = new X; // expected-warning{{'operator new' is deprecated}} expected-warning{{'operator delete' is deprecated}}
251 }
252 }
253
254 // rdar://problem/15044218
255 typedef struct TDS {
256 } TDS __attribute__((deprecated)); // expected-note {{'TDS' has been explicitly marked deprecated here}}
257 TDS tds; // expected-warning {{'TDS' is deprecated}}
258 struct TDS tds2; // no warning, attribute only applies to the typedef.
259
260 namespace test8 {
261 struct A {
262 // expected-note@+1 {{'B' has been explicitly marked deprecated here}}
263 struct __attribute__((deprecated)) B {};
264 };
265 template <typename T> struct D : T {
266 using typename T::B;
267 B b; // expected-warning {{'B' is deprecated}}
268 };
269 D<A> da; // expected-note {{in instantiation of template class}}
270 } // namespace test8
271