• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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));
60   virtual void f(int) __attribute__((deprecated));
61   virtual void f(int, int) __attribute__((deprecated));
62 };
63 
f()64 void D::f() { } // expected-note{{'f' has been explicitly marked deprecated here}}
f(int v)65 void D::f(int v) { } // expected-note{{'f' has been explicitly marked deprecated here}}
f(int v1,int v2)66 void D::f(int v1, int v2) { } // expected-note{{'f' has been explicitly marked deprecated here}}
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 {{'A' has been explicitly marked deprecated here}}
203     a0 // expected-note {{'a0' has been explicitly marked deprecated here}}
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 {{'Enum' has been explicitly marked deprecated here}}
222       c0 // expected-note {{'c0' has been explicitly marked deprecated here}}
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