// RUN: %clang_cc1 %s -verify -fexceptions
class A {
void f() __attribute__((deprecated)); // expected-note 2 {{'f' has been explicitly marked deprecated here}}
void g(A* a);
void h(A* a) __attribute__((deprecated));
int b __attribute__((deprecated)); // expected-note 2 {{'b' has been explicitly marked deprecated here}}
};
void A::g(A* a)
{
f(); // expected-warning{{'f' is deprecated}}
a->f(); // expected-warning{{'f' is deprecated}}
(void)b; // expected-warning{{'b' is deprecated}}
(void)a->b; // expected-warning{{'b' is deprecated}}
}
void A::h(A* a)
{
f();
a->f();
(void)b;
(void)a->b;
}
struct B {
virtual void f() __attribute__((deprecated)); // expected-note 6 {{'f' has been explicitly marked deprecated here}}
void g();
};
void B::g() {
f(); // expected-warning{{'f' is deprecated}}
B::f(); // expected-warning{{'f' is deprecated}}
}
struct C : B {
virtual void f();
void g();
};
void C::g() {
f();
C::f();
B::f(); // expected-warning{{'f' is deprecated}}
}
void f(B* b, C *c) {
b->f(); // expected-warning{{'f' is deprecated}}
b->B::f(); // expected-warning{{'f' is deprecated}}
c->f();
c->C::f();
c->B::f(); // expected-warning{{'f' is deprecated}}
}
struct D {
virtual void f() __attribute__((deprecated));// expected-note{{'f' has been explicitly marked deprecated here}}
virtual void f(int) __attribute__((deprecated));// expected-note{{'f' has been explicitly marked deprecated here}}
virtual void f(int, int) __attribute__((deprecated));// expected-note{{'f' has been explicitly marked deprecated here}}
};
void D::f() { }
void D::f(int v) { }
void D::f(int v1, int v2) { }
void f(D* d) {
d->f(); // expected-warning{{'f' is deprecated}}
d->f(42); // expected-warning{{'f' is deprecated}}
d->f(42, 24); // expected-warning{{'f' is deprecated}}
}
// Overloaded namespace members.
namespace test1 {
void foo(int) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
void test1() { foo(10); } // expected-warning {{deprecated}}
void foo(short) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
void test2(short s) { foo(s); } // expected-warning {{deprecated}}
void foo(long);
void test3(long l) { foo(l); }
struct A {
friend void foo(A*) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
};
void test4(A *a) { foo(a); } // expected-warning {{deprecated}}
namespace ns {
struct Foo {};
void foo(const Foo &f) __attribute__((deprecated)); // expected-note {{'foo' has been explicitly marked deprecated here}}
}
void test5() {
foo(ns::Foo()); // expected-warning {{deprecated}}
}
}
// Overloaded class members.
namespace test2 {
struct A {
void foo(int) __attribute__((deprecated)); // expected-note 2 {{'foo' has been explicitly marked deprecated here}}
void foo(long);
static void bar(int) __attribute__((deprecated)); // expected-note 3 {{'bar' has been explicitly marked deprecated here}}
static void bar(long);
void test2(int i, long l);
};
void test1(int i, long l) {
A a;
a.foo(i); // expected-warning {{deprecated}}
a.foo(l);
a.bar(i); // expected-warning {{deprecated}}
a.bar(l);
A::bar(i); // expected-warning {{deprecated}}
A::bar(l);
}
void A::test2(int i, long l) {
foo(i); // expected-warning {{deprecated}}
foo(l);
bar(i); // expected-warning {{deprecated}}
bar(l);
}
}
// Overloaded operators.
namespace test3 {
struct A {
void operator*(const A &);
void operator*(int) __attribute__((deprecated)); // expected-note {{'operator*' has been explicitly marked deprecated here}}
void operator-(const A &) const;
};
void operator+(const A &, const A &);
void operator+(const A &, int) __attribute__((deprecated)); // expected-note {{'operator+' has been explicitly marked deprecated here}}
void operator-(const A &, int) __attribute__((deprecated)); // expected-note {{'operator-' has been explicitly marked deprecated here}}
void test() {
A a, b;
a + b;
a + 1; // expected-warning {{deprecated}}
a - b;
a - 1; // expected-warning {{deprecated}}
a * b;
a * 1; // expected-warning {{deprecated}}
}
}
// Overloaded operator call.
namespace test4 {
struct A {
typedef void (*intfn)(int);
typedef void (*unintfn)(unsigned);
operator intfn() __attribute__((deprecated)); // expected-note {{'operator void (*)(int)' has been explicitly marked deprecated here}}
operator unintfn();
void operator ()(A &) __attribute__((deprecated)); // expected-note {{'operator()' has been explicitly marked deprecated here}}
void operator ()(const A &);
};
void test() {
A a;
a(1); // expected-warning {{deprecated}}
a(1U);
A &b = a;
const A &c = a;
a(b); // expected-warning {{deprecated}}
a(c);
}
}
namespace test5 {
struct A {
operator int() __attribute__((deprecated)); // expected-note 3 {{'operator int' has been explicitly marked deprecated here}}
operator long();
};
void test1(A a) {
int i = a; // expected-warning {{deprecated}}
long l = a;
}
void foo(int);
void foo(void*);
void bar(long);
void bar(void*);
void test2(A a) {
foo(a); // expected-warning {{deprecated}}
bar(a);
}
struct B {
int myInt;
long myLong;
B(A &a) :
myInt(a), // expected-warning {{deprecated}}
myLong(a)
{}
};
}
namespace test6 {
enum __attribute__((deprecated)) A { // expected-note 2 {{'A' has been explicitly marked deprecated here}}
a0
};
void testA() {
A x; // expected-warning {{'A' is deprecated}}
x = a0; // expected-warning {{'a0' is deprecated}}
}
enum B {
b0 __attribute__((deprecated)), // expected-note {{'b0' has been explicitly marked deprecated here}}
b1
};
void testB() {
B x;
x = b0; // expected-warning {{'b0' is deprecated}}
x = b1;
}
template <class T> struct C {
enum __attribute__((deprecated)) Enum { // expected-note 2 {{'Enum' has been explicitly marked deprecated here}}
c0
};
};
void testC() {
C<int>::Enum x; // expected-warning {{'Enum' is deprecated}}
x = C<int>::c0; // expected-warning {{'c0' is deprecated}}
}
template <class T> struct D {
enum Enum {
d0,
d1 __attribute__((deprecated)), // expected-note {{'d1' has been explicitly marked deprecated here}}
};
};
void testD() {
D<int>::Enum x;
x = D<int>::d0;
x = D<int>::d1; // expected-warning {{'d1' is deprecated}}
}
}
namespace test7 {
struct X {
void* operator new(typeof(sizeof(void*))) __attribute__((deprecated)); // expected-note{{'operator new' has been explicitly marked deprecated here}}
void operator delete(void *) __attribute__((deprecated)); // expected-note{{'operator delete' has been explicitly marked deprecated here}}
};
void test() {
X *x = new X; // expected-warning{{'operator new' is deprecated}} expected-warning{{'operator delete' is deprecated}}
}
}
typedef struct TDS {
} TDS __attribute__((deprecated)); // expected-note {{'TDS' has been explicitly marked deprecated here}}
TDS tds; // expected-warning {{'TDS' is deprecated}}
struct TDS tds2; // no warning, attribute only applies to the typedef.
namespace test8 {
struct A {
// expected-note@+1 {{'B' has been explicitly marked deprecated here}}
struct __attribute__((deprecated)) B {};
};
template <typename T> struct D : T {
using typename T::B;
B b; // expected-warning {{'B' is deprecated}}
};
D<A> da; // expected-note {{in instantiation of template class}}
} // namespace test8
Codebase Browser
llvm