clang/test/SemaCXX/warn-throw-out-noexcept-func.cpp

// RUN: %clang_cc1 %s  -fdelayed-template-parsing -fcxx-exceptions -fsyntax-only -Wexceptions -verify -fdeclspec -std=c++17
struct A_ShouldDiag {
  ~A_ShouldDiag(); // implicitly noexcept(true)
};
A_ShouldDiag::~A_ShouldDiag() { // expected-note {{destructor has a implicit non-throwing exception specification}}
  throw 1; // expected-warning {{has a non-throwing exception specification but can still throw}}
}
struct B_ShouldDiag {
  int i;
  ~B_ShouldDiag() noexcept(true) {} //no disg, no throw stmt
};
struct R_ShouldDiag : A_ShouldDiag {
  B_ShouldDiag b;
  ~R_ShouldDiag() { // expected-note  {{destructor has a implicit non-throwing exception specification}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
  __attribute__((nothrow)) R_ShouldDiag() {// expected-note {{function declared non-throwing here}}
    throw 1;// expected-warning {{has a non-throwing exception specification but}}
  }
  void __attribute__((nothrow)) SomeThrow() {// expected-note {{function declared non-throwing here}}
   throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
  void __declspec(nothrow) SomeDeclspecThrow() {// expected-note {{function declared non-throwing here}}
   throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
};

struct M_ShouldNotDiag {
  B_ShouldDiag b;
  ~M_ShouldNotDiag() noexcept(false);
};

M_ShouldNotDiag::~M_ShouldNotDiag() noexcept(false) {
  throw 1;
}

struct N_ShouldDiag {
  B_ShouldDiag b;
  ~N_ShouldDiag(); //implicitly noexcept(true)
};

N_ShouldDiag::~N_ShouldDiag() { // expected-note  {{destructor has a implicit non-throwing exception specification}}
  throw 1; // expected-warning {{has a non-throwing exception specification but}}
}
struct X_ShouldDiag {
  B_ShouldDiag b;
  ~X_ShouldDiag() noexcept { // expected-note  {{destructor has a non-throwing exception}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
};
struct Y_ShouldDiag : A_ShouldDiag {
  ~Y_ShouldDiag() noexcept(true) { // expected-note  {{destructor has a non-throwing exception specification}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
};
struct C_ShouldNotDiag {
  int i;
  ~C_ShouldNotDiag() noexcept(false) {}
};
struct D_ShouldNotDiag {
  C_ShouldNotDiag c;
  ~D_ShouldNotDiag() { //implicitly noexcept(false)
    throw 1;
  }
};
struct E_ShouldNotDiag {
  C_ShouldNotDiag c;
  ~E_ShouldNotDiag(); //implicitly noexcept(false)
};
E_ShouldNotDiag::~E_ShouldNotDiag() //implicitly noexcept(false)
{
  throw 1;
}

template <typename T>
class A1_ShouldDiag {
  T b;

public:
  ~A1_ShouldDiag() { // expected-note  {{destructor has a implicit non-throwing exception specification}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
};
template <typename T>
struct B1_ShouldDiag {
  T i;
  ~B1_ShouldDiag() noexcept(true) {}
};
template <typename T>
struct R1_ShouldDiag : A1_ShouldDiag<T> //expected-note {{in instantiation of member function}}
{
  B1_ShouldDiag<T> b;
  ~R1_ShouldDiag() { // expected-note  {{destructor has a implicit non-throwing exception specification}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
};
template <typename T>
struct S1_ShouldDiag : A1_ShouldDiag<T> {
  B1_ShouldDiag<T> b;
  ~S1_ShouldDiag() noexcept { // expected-note  {{destructor has a non-throwing exception specification}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
};
void operator delete(void *ptr) noexcept { // expected-note  {{deallocator has a non-throwing exception specification}}
  throw 1; // expected-warning {{has a non-throwing exception specification but}}
}
struct except_fun {
  static const bool i = false;
};
struct noexcept_fun {
  static const bool i = true;
};
template <typename T>
struct dependent_warn {
  ~dependent_warn() noexcept(T::i) {
    throw 1;
  }
};
template <typename T>
struct dependent_warn_noexcept {
  ~dependent_warn_noexcept() noexcept(T::i) { // expected-note  {{destructor has a non-throwing exception specification}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
};
template <typename T>
struct dependent_warn_both {
  ~dependent_warn_both() noexcept(T::i) { // expected-note  {{destructor has a non-throwing exception specification}}
    throw 1; // expected-warning {{has a non-throwing exception specification but}}
  }
};
void foo() noexcept { //expected-note {{function declared non-throwing here}}
  throw 1; // expected-warning {{has a non-throwing exception specification but}}
}
struct Throws {
  ~Throws() noexcept(false);
};

struct ShouldDiagnose {
  Throws T;
  ~ShouldDiagnose() noexcept { //expected-note {{destructor has a non-throwing exception specification}}
    throw; // expected-warning {{has a non-throwing exception specification but}}
  }
};
struct ShouldNotDiagnose {
  Throws T;
  ~ShouldNotDiagnose() {
    throw;
  }
};

void bar_ShouldNotDiag() noexcept {
  try {
    throw 1;
  } catch (...) {
  }
}
void f_ShouldNotDiag() noexcept {
  try {
    throw 12;
  } catch (int) {
  }
}
void g_ShouldNotDiag() noexcept {
  try {
    throw 12;
  } catch (...) {
  }
}

void h_ShouldDiag() noexcept { //expected-note {{function declared non-throwing here}}
  try {
    throw 12; // expected-warning {{has a non-throwing exception specification but}}
  } catch (const char *) {
  }
}

void i_ShouldDiag() noexcept { //expected-note {{function declared non-throwing here}}
  try {
    throw 12;
  } catch (int) {
    throw; // expected-warning {{has a non-throwing exception specification but}}
  }
}
void j_ShouldDiag() noexcept { //expected-note {{function declared non-throwing here}}
  try {
    throw 12;
  } catch (int) {
    throw "haha"; // expected-warning {{has a non-throwing exception specification but}}
  }
}

void k_ShouldDiag() noexcept { //expected-note {{function declared non-throwing here}}
  try {
    throw 12;
  } catch (...) {
    throw; // expected-warning {{has a non-throwing exception specification but}}
  }
}

void loo_ShouldDiag(int i) noexcept { //expected-note {{function declared non-throwing here}}
  if (i)
    try {
      throw 12;
    } catch (int) {
      throw "haha"; //expected-warning {{has a non-throwing exception specification but}}
    }
  i = 10;
}

void loo1_ShouldNotDiag() noexcept {
  if (0)
    throw 12;
}

void loo2_ShouldDiag() noexcept { //expected-note {{function declared non-throwing here}}
  if (1)
    throw 12; // expected-warning {{has a non-throwing exception specification but}}
}
struct S {};

void l_ShouldDiag() noexcept { //expected-note {{function declared non-throwing here}}
  try {
    throw S{}; //expected-warning {{has a non-throwing exception specification but}}
  } catch (S *s) {
  }
}

void m_ShouldNotDiag() noexcept {
  try {
    const S &s = S{};
    throw s;
  } catch (S s) {
  }
}
void n_ShouldNotDiag() noexcept {
  try {
    S s = S{};
    throw s;
  } catch (const S &s) {
  }
}
// As seen in p34973, this should not throw the warning.  If there is an active
// exception, catch(...) catches everything. 
void o_ShouldNotDiag() noexcept {
  try {
    throw;
  } catch (...) {
  }
}

void p_ShouldNotDiag() noexcept {
  // Don't warn here: it's possible that the user arranges to only call this
  // when the active exception is of type 'int'.
  try {
    throw;
  } catch (int){
  }
}

void q_ShouldNotDiag() noexcept {
  try {
    throw;
  } catch (int){
  } catch (...){
  }
}

#define NOEXCEPT noexcept
void with_macro() NOEXCEPT { //expected-note {{function declared non-throwing here}}
  throw 1; // expected-warning {{has a non-throwing exception specification but}}
}

void with_try_block() try {
  throw 2;
} catch (...) {
}

void with_try_block1() noexcept try { //expected-note {{function declared non-throwing here}}
  throw 2; // expected-warning {{has a non-throwing exception specification but}}
} catch (char *) {
}

namespace derived {
struct B {};
struct D: B {};
void goodPlain() noexcept {
  try {
    throw D();
  } catch (B) {}
}
void goodReference() noexcept {
  try {
    throw D();
  } catch (B &) {}
}
void goodPointer() noexcept {
  D d;
  try {
    throw &d;
  } catch (B *) {}
}
void badPlain() noexcept { //expected-note {{function declared non-throwing here}}
  try {
    throw B(); // expected-warning {{'badPlain' has a non-throwing exception specification but can still throw}}
  } catch (D) {}
}
void badReference() noexcept { //expected-note {{function declared non-throwing here}}
  try {
    throw B(); // expected-warning {{'badReference' has a non-throwing exception specification but can still throw}}
  } catch (D &) {}
}
void badPointer() noexcept { //expected-note {{function declared non-throwing here}}
  B b;
  try {
    throw &b; // expected-warning {{'badPointer' has a non-throwing exception specification but can still throw}}
  } catch (D *) {}
}
}

int main() {
  R1_ShouldDiag<int> o; //expected-note {{in instantiation of member function}}
  S1_ShouldDiag<int> b; //expected-note {{in instantiation of member function}}
  dependent_warn<except_fun> f;
  dependent_warn_noexcept<noexcept_fun> f1; //expected-note {{in instantiation of member function}}
  dependent_warn_both<except_fun> f2;
  dependent_warn_both<noexcept_fun> f3; //expected-note {{in instantiation of member function}}
  ShouldDiagnose obj;
  ShouldNotDiagnose obj1;
}

namespace ExceptionInNamespace {
  namespace N {
    struct E {};
  }
  void run() throw() {
    try {
      throw N::E();
    } catch (const N::E &e) {
    }
  }
}

namespace HandlerSpecialCases {
  struct A {};
  using CA = const A;

  struct B : A {};
  using CB = const B;

  struct AmbigBase {};
  struct AmbigMiddle : AmbigBase {};
  struct AmbigDerived : AmbigBase, AmbigMiddle {}; // expected-warning {{inaccessible}}

  struct PrivateBase {};
  struct PrivateDerived : private PrivateBase { friend void bad3() throw(); };

  void good() throw() {
    try { throw CA(); } catch (volatile A&) {}
    try { throw B(); } catch (A&) {}
    try { throw B(); } catch (const volatile A&) {}
    try { throw CB(); } catch (A&) {}
    try { throw (int*)0; } catch (void* const volatile) {}
    try { throw (int*)0; } catch (void* const &) {}
    try { throw (B*)0; } catch (A*) {}
    try { throw (B*)0; } catch (A* const &) {}
    try { throw (void(*)() noexcept)0; } catch (void (*)()) {}
    try { throw (void(*)() noexcept)0; } catch (void (*const &)()) {}
    try { throw (int**)0; } catch (const int * const*) {}
    try { throw (int**)0; } catch (const int * const* const&) {}
    try { throw nullptr; } catch (int*) {}
    try { throw nullptr; } catch (int* const&) {}
  }

  void bad1() throw() { // expected-note {{here}}
    try { throw A(); } catch (const B&) {} // expected-warning {{still throw}}
  }
  void bad2() throw() { // expected-note {{here}}
    try { throw AmbigDerived(); } catch (const AmbigBase&) {} // expected-warning {{still throw}}
  }
  void bad3() throw() { // expected-note {{here}}
    try { throw PrivateDerived(); } catch (const PrivateBase&) {} // expected-warning {{still throw}}
  }
  void bad4() throw() { // expected-note {{here}}
    try { throw (int*)0; } catch (void* &) {} // expected-warning {{still throw}}
  }
  void bad5() throw() { // expected-note {{here}}
    try { throw (int*)0; } catch (void* const volatile &) {} // expected-warning {{still throw}}
  }
  void bad6() throw() { // expected-note {{here}}
    try { throw (int* volatile)0; } catch (void* const volatile &) {} // expected-warning {{still throw}}
  }
  void bad7() throw() { // expected-note {{here}}
    try { throw (AmbigDerived*)0; } catch (AmbigBase*) {} // expected-warning {{still throw}}
  }
  void bad8() throw() { // expected-note {{here}}
    try { throw (PrivateDerived*)0; } catch (PrivateBase*) {} // expected-warning {{still throw}}
  }
  void bad9() throw() { // expected-note {{here}}
    try { throw (B*)0; } catch (A* &) {} // expected-warning {{still throw}}
  }
  void bad10() throw() { // expected-note {{here}}
    try { throw (void(*)())0; } catch (void (*)() noexcept) {} // expected-warning {{still throw}}
  }
  void bad11() throw() { // expected-note {{here}}
    try { throw (int**)0; } catch (const int **) {} // expected-warning {{still throw}}
  }
  void bad12() throw() { // expected-note {{here}}
    try { throw nullptr; } catch (int) {} // expected-warning {{still throw}}
  }
}

namespace NestedTry {
  void f() noexcept {
    try {
      try {
        throw 0;
      } catch (float) {}
    } catch (int) {}
  }

  struct A { [[noreturn]] ~A(); };

  void g() noexcept { // expected-note {{here}}
    try {
      try {
        throw 0; // expected-warning {{still throw}}
      } catch (float) {}
    } catch (const char*) {}
  }

  void h() noexcept { // expected-note {{here}}
    try {
      try {
        throw 0;
      } catch (float) {}
    } catch (int) {
      throw; // expected-warning {{still throw}}
    }
  }

  // FIXME: Ideally, this should still warn; we can track which types are
  // potentially thrown by the rethrow.
  void i() noexcept {
    try {
      try {
        throw 0;
      } catch (int) {
        throw;
      }
    } catch (float) {}
  }

  // FIXME: Ideally, this should not warn: the second catch block is
  // unreachable.
  void j() noexcept { // expected-note {{here}}
    try {
      try {
        throw 0;
      } catch (int) {}
    } catch (float) {
      throw; // expected-warning {{still throw}}
    }
  }
}