// RUN: %clang_cc1 -fsyntax-only -verify %s
// Reachability tests have to come first because they get suppressed
// if any errors have occurred.
namespace test5 {
struct A {
__attribute__((noreturn)) void fail();
void nofail();
} a;
int &test1() {
a.nofail();
} // expected-warning {{non-void function does not return a value}}
int &test2() {
a.fail();
}
}
namespace destructor_tests {
__attribute__((noreturn)) void fail();
struct A {
~A() __attribute__((noreturn)) { fail(); }
};
struct B {
B() {}
~B() __attribute__((noreturn)) { fail(); }
};
struct C : A {};
struct D : B {};
struct E : virtual A {};
struct F : A, virtual B {};
struct G : E {};
struct H : virtual D {};
struct I : A {};
struct J : I {};
struct K : virtual A {};
struct L : K {};
struct M : virtual C {};
struct N : M {};
struct O { N n; };
__attribute__((noreturn)) void test_1() { A a; }
__attribute__((noreturn)) void test_2() { B b; }
__attribute__((noreturn)) void test_3() { C c; }
__attribute__((noreturn)) void test_4() { D d; }
__attribute__((noreturn)) void test_5() { E e; }
__attribute__((noreturn)) void test_6() { F f; }
__attribute__((noreturn)) void test_7() { G g; }
__attribute__((noreturn)) void test_8() { H h; }
__attribute__((noreturn)) void test_9() { I i; }
__attribute__((noreturn)) void test_10() { J j; }
__attribute__((noreturn)) void test_11() { K k; }
__attribute__((noreturn)) void test_12() { L l; }
__attribute__((noreturn)) void test_13() { M m; }
__attribute__((noreturn)) void test_14() { N n; }
__attribute__((noreturn)) void test_15() { O o; }
__attribute__((noreturn)) void test_16() { const A& a = A(); }
__attribute__((noreturn)) void test_17() { const B& b = B(); }
__attribute__((noreturn)) void test_18() { const C& c = C(); }
__attribute__((noreturn)) void test_19() { const D& d = D(); }
__attribute__((noreturn)) void test_20() { const E& e = E(); }
__attribute__((noreturn)) void test_21() { const F& f = F(); }
__attribute__((noreturn)) void test_22() { const G& g = G(); }
__attribute__((noreturn)) void test_23() { const H& h = H(); }
__attribute__((noreturn)) void test_24() { const I& i = I(); }
__attribute__((noreturn)) void test_25() { const J& j = J(); }
__attribute__((noreturn)) void test_26() { const K& k = K(); }
__attribute__((noreturn)) void test_27() { const L& l = L(); }
__attribute__((noreturn)) void test_28() { const M& m = M(); }
__attribute__((noreturn)) void test_29() { const N& n = N(); }
__attribute__((noreturn)) void test_30() { const O& o = O(); }
struct AA {};
struct BB { BB() {} ~BB() {} };
struct CC : AA {};
struct DD : BB {};
struct EE : virtual AA {};
struct FF : AA, virtual BB {};
struct GG : EE {};
struct HH : virtual DD {};
struct II : AA {};
struct JJ : II {};
struct KK : virtual AA {};
struct LL : KK {};
struct MM : virtual CC {};
struct NN : MM {};
struct OO { NN n; };
__attribute__((noreturn)) void test_31() {
AA a;
BB b;
CC c;
DD d;
EE e;
FF f;
GG g;
HH h;
II i;
JJ j;
KK k;
LL l;
MM m;
NN n;
OO o;
const AA& aa = AA();
const BB& bb = BB();
const CC& cc = CC();
const DD& dd = DD();
const EE& ee = EE();
const FF& ff = FF();
const GG& gg = GG();
const HH& hh = HH();
const II& ii = II();
const JJ& jj = JJ();
const KK& kk = KK();
const LL& ll = LL();
const MM& mm = MM();
const NN& nn = NN();
const OO& oo = OO();
} // expected-warning {{function declared 'noreturn' should not return}}
struct P {
~P() __attribute__((noreturn)) { fail(); }
void foo() {}
};
struct Q : P { };
__attribute__((noreturn)) void test31() {
P().foo();
}
__attribute__((noreturn)) void test32() {
Q().foo();
}
struct R {
A a[5];
};
__attribute__((noreturn)) void test33() {
R r;
}
// FIXME: Code flow analysis does not preserve information about non-null
// pointers, so it can't determine that this function is noreturn.
__attribute__((noreturn)) void test34() {
A *a = new A;
delete a;
} // expected-warning {{function declared 'noreturn' should not return}}
struct S {
virtual ~S();
};
struct T : S {
__attribute__((noreturn)) ~T();
};
// FIXME: Code flow analysis does not preserve information about non-null
// pointers or derived class pointers, so it can't determine that this
// function is noreturn.
__attribute__((noreturn)) void test35() {
S *s = new T;
delete s;
} // expected-warning {{function declared 'noreturn' should not return}}
}
// PR5620
void f0() __attribute__((__noreturn__));
void f1(void (*)());
void f2() { f1(f0); }
// Taking the address of a noreturn function
void test_f0a() {
void (*fp)() = f0;
void (*fp1)() __attribute__((noreturn)) = f0;
}
// Taking the address of an overloaded noreturn function
void f0(int) __attribute__((__noreturn__));
void test_f0b() {
void (*fp)() = f0;
void (*fp1)() __attribute__((noreturn)) = f0;
}
// No-returned function pointers
typedef void (* noreturn_fp)() __attribute__((noreturn));
void f3(noreturn_fp); // expected-note{{candidate function}}
void test_f3() {
f3(f0); // okay
f3(f2); // expected-error{{no matching function for call}}
}
class xpto {
int blah() __attribute__((noreturn));
};
int xpto::blah() {
return 3; // expected-warning {{function 'blah' declared 'noreturn' should not return}}
}
// PR12948
namespace PR12948 {
template<int>
void foo() __attribute__((__noreturn__));
template<int>
void foo() {
while (1) continue;
}
void bar() __attribute__((__noreturn__));
void bar() {
foo<0>();
}
void baz() __attribute__((__noreturn__));
typedef void voidfn();
voidfn baz;
template<typename> void wibble() __attribute__((__noreturn__));
template<typename> voidfn wibble;
}
// PR15291
// Overload resolution per over.over should allow implicit noreturn adjustment.
namespace PR15291 {
__attribute__((noreturn)) void foo(int) {}
__attribute__((noreturn)) void foo(double) {}
template <typename T>
__attribute__((noreturn)) void bar(T) {}
void baz(int) {}
void baz(double) {}
template <typename T>
void qux(T) {}
// expected-note@+5 {{candidate function template not viable: no overload of 'baz' matching 'void (*)(int) __attribute__((noreturn))' for 1st argument}}
// expected-note@+4 {{candidate function template not viable: no overload of 'qux' matching 'void (*)(int) __attribute__((noreturn))' for 1st argument}}
// expected-note@+3 {{candidate function template not viable: no overload of 'bar' matching 'void (*)(int) __attribute__((noreturn))' for 1st argument}}
// expected-note@+2 {{candidate function template not viable: no overload of 'bar' matching 'void (*)(int)' for 1st argument}}
// expected-note@+1 {{candidate function template not viable: no overload of 'bar' matching 'void (*)(int)' for 1st argument}}
template <typename T> void accept_T(T) {}
// expected-note@+1 {{candidate function not viable: no overload of 'bar' matching 'void (*)(int)' for 1st argument}}
void accept_fptr(void (*f)(int)) {
f(42);
}
// expected-note@+2 {{candidate function not viable: no overload of 'baz' matching 'void (*)(int) __attribute__((noreturn))' for 1st argument}}
// expected-note@+1 {{candidate function not viable: no overload of 'qux' matching 'void (*)(int) __attribute__((noreturn))' for 1st argument}}
void accept_noreturn_fptr(void __attribute__((noreturn)) (*f)(int)) {
f(42);
}
typedef void (*fptr_t)(int);
typedef void __attribute__((noreturn)) (*fptr_noreturn_t)(int);
// expected-note@+1 {{candidate function not viable: no overload of 'bar' matching 'fptr_t' (aka 'void (*)(int)') for 1st argument}}
void accept_fptr_t(fptr_t f) {
f(42);
}
// expected-note@+2 {{candidate function not viable: no overload of 'baz' matching 'fptr_noreturn_t' (aka 'void (*)(int) __attribute__((noreturn))') for 1st argument}}
// expected-note@+1 {{candidate function not viable: no overload of 'qux' matching 'fptr_noreturn_t' (aka 'void (*)(int) __attribute__((noreturn))') for 1st argument}}
void accept_fptr_noreturn_t(fptr_noreturn_t f) {
f(42);
}
// Stripping noreturn should work if everything else is correct.
void strip_noreturn() {
accept_fptr(foo);
accept_fptr(bar<int>);
accept_fptr(bar<double>); // expected-error {{no matching function for call to 'accept_fptr'}}
accept_fptr_t(foo);
accept_fptr_t(bar<int>);
accept_fptr_t(bar<double>); // expected-error {{no matching function for call to 'accept_fptr_t'}}
accept_T<void __attribute__((noreturn)) (*)(int)>(foo);
accept_T<void __attribute__((noreturn)) (*)(int)>(bar<int>);
accept_T<void __attribute__((noreturn)) (*)(int)>(bar<double>); // expected-error {{no matching function for call to 'accept_T'}}
accept_T<void (*)(int)>(foo);
accept_T<void (*)(int)>(bar<int>);
accept_T<void (*)(int)>(bar<double>); // expected-error {{no matching function for call to 'accept_T'}}
accept_T<void (int)>(foo);
accept_T<void (int)>(bar<int>);
accept_T<void (int)>(bar<double>); // expected-error {{no matching function for call to 'accept_T'}}
}
// Introducing noreturn should not work.
void introduce_noreturn() {
accept_noreturn_fptr(baz); // expected-error {{no matching function for call to 'accept_noreturn_fptr'}}
accept_noreturn_fptr(qux<int>); // expected-error {{no matching function for call to 'accept_noreturn_fptr'}}
accept_fptr_noreturn_t(baz); // expected-error {{no matching function for call to 'accept_fptr_noreturn_t'}}
accept_fptr_noreturn_t(qux<int>); // expected-error {{no matching function for call to 'accept_fptr_noreturn_t'}}
accept_T<void __attribute__((noreturn)) (*)(int)>(baz); // expected-error {{no matching function for call to 'accept_T'}}
accept_T<void __attribute__((noreturn)) (*)(int)>(qux<int>); // expected-error {{no matching function for call to 'accept_T'}}
}
}
Codebase Browser
llvm