Home | History | Annotate | Download | only in SemaCXX 
      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 
     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 
     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 
     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 
     43 void C::g() {
     44   f();
     45   C::f();
     46   B::f(); // expected-warning{{'f' is deprecated}}
     47 }
     48 
     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 
     64 void D::f() { } // expected-note{{'f' has been explicitly marked deprecated here}}
     65 void D::f(int v) { } // expected-note{{'f' has been explicitly marked deprecated here}}
     66 void D::f(int v1, int v2) { } // expected-note{{'f' has been explicitly marked deprecated here}}
     67 
     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}}
     78   void test1() { foo(10); } // expected-warning {{deprecated}}
     79   void foo(short) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
     80   void test2(short s) { foo(s); } // expected-warning {{deprecated}}
     81   void foo(long);
     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   };
     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   }
     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   };
    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 
    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 
    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 
    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   };
    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*);
    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 
    193     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   };
    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   };
    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   };
    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   };
    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 
    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