// RUN: %clang_cc1 %s -fcxx-exceptions -fexceptions -fsyntax-only -verify -fblocks -std=c++11 -Wunreachable-code-aggressive -Wno-unused-value -Wno-tautological-compare

int &halt() __attribute__((noreturn));
int &live();
int dead();
int liveti() throw(int);
int (*livetip)() throw(int);

int test1() {
  try {
    live();
  } catch (int i) {
    live();
  }
  return 1;
}

void test2() {
  try {
    live();
  } catch (int i) {
    live();
  }
  try {
    liveti();
  } catch (int i) {
    live();
  }
  try {
    livetip();
  } catch (int i) {
    live();
  }
  throw 1;
  dead();       // expected-warning {{will never be executed}}
}


void test3() {
  halt()
    --;         // expected-warning {{will never be executed}}
  // FIXME: The unreachable part is just the '?', but really all of this
  // code is unreachable and shouldn't be separately reported.
  halt()        // expected-warning {{will never be executed}}
    ? 
    dead() : dead();
  live(),
    float       
      (halt()); // expected-warning {{will never be executed}}
}

namespace Test4 {
  struct S {
    int mem;
  } s;
  S &foor();
  void test4() {
    halt(), foor()// expected-warning {{will never be executed}}
      .mem;       
  }
}

namespace Test5 {
  struct S {
    int mem;
  } s;
  S &foonr() __attribute__((noreturn));
  void test5() {
    foonr()
      .mem;       // expected-warning {{will never be executed}}
  }
}

void test6() {
  struct S {
    ~S() { }
    S(int i) { }
  };
  live(),
    S
      (halt());  // expected-warning {{will never be executed}}
}

// Don't warn about unreachable code in template instantiations, as
// they may only be unreachable in that specific instantiation.
void isUnreachable();

template <typename T> void test_unreachable_templates() {
  T::foo();
  isUnreachable();  // no-warning
}

struct TestUnreachableA {
  static void foo() __attribute__((noreturn));
};
struct TestUnreachableB {
  static void foo();
};

void test_unreachable_templates_harness() {
  test_unreachable_templates<TestUnreachableA>();
  test_unreachable_templates<TestUnreachableB>(); 
}

// Do warn about explicit template specializations, as they represent
// actual concrete functions that somebody wrote.

template <typename T> void funcToSpecialize() {}
template <> void funcToSpecialize<int>() {
  halt();
  dead(); // expected-warning {{will never be executed}}
}

// Handle 'try' code dominating a dead return.
enum PR19040_test_return_t
{ PR19040_TEST_FAILURE };
namespace PR19040_libtest
{
  class A {
  public:
    ~A ();
  };
}
PR19040_test_return_t PR19040_fn1 ()
{
    try
    {
        throw PR19040_libtest::A ();
    } catch (...)
    {
        return PR19040_TEST_FAILURE;
    }
    return PR19040_TEST_FAILURE; // expected-warning {{will never be executed}}
}

__attribute__((noreturn))
void raze();

namespace std {
template<typename T> struct basic_string {
  basic_string(const T* x) {}
  ~basic_string() {};
};
typedef basic_string<char> string;
}

std::string testStr() {
  raze();
  return ""; // expected-warning {{'return' will never be executed}}
}

std::string testStrWarn(const char *s) {
  raze();
  return s; // expected-warning {{will never be executed}}
}

bool testBool() {
  raze();
  return true; // expected-warning {{'return' will never be executed}}
}

static const bool ConditionVar = 1;
int test_global_as_conditionVariable() {
  if (ConditionVar)
    return 1;
  return 0; // no-warning
}

// Handle unreachable temporary destructors.
class A {
public:
  A();
  ~A();
};

__attribute__((noreturn))
void raze(const A& x);

void test_with_unreachable_tmp_dtors(int x) {
  raze(x ? A() : A()); // no-warning
}

// Test sizeof - sizeof in enum declaration.
enum { BrownCow = sizeof(long) - sizeof(char) };
enum { CowBrown = 8 - 1 };


int test_enum_sizeof_arithmetic() {
  if (BrownCow)
    return 1;
  return 2;
}

int test_enum_arithmetic() {
  if (CowBrown)
    return 1;
  return 2; // expected-warning {{never be executed}}
}

int test_arithmetic() {
  if (8 -1)
    return 1;
  return 2; // expected-warning {{never be executed}}
}

int test_treat_const_bool_local_as_config_value() {
  const bool controlValue = false;
  if (!controlValue)
    return 1;
  test_treat_const_bool_local_as_config_value(); // no-warning
  return 0;
}

int test_treat_non_const_bool_local_as_non_config_value() {
  bool controlValue = false;
  if (!controlValue)
    return 1;
  // There is no warning here because 'controlValue' isn't really
  // a control value at all.  The CFG will not treat this
  // branch as unreachable.
  test_treat_non_const_bool_local_as_non_config_value(); // no-warning
  return 0;
}

void test_do_while(int x) {
  // Handle trivial expressions with
  // implicit casts to bool.
  do {
    break;
  } while (0); // no-warning
}

class Frobozz {
public:
  Frobozz(int x);
  ~Frobozz();
};

Frobozz test_return_object(int flag) {
  return Frobozz(flag);
  return Frobozz(42);  // expected-warning {{'return' will never be executed}}
}

Frobozz test_return_object_control_flow(int flag) {
  return Frobozz(flag);
  return Frobozz(flag ? 42 : 24); // expected-warning {{code will never be executed}}
}

void somethingToCall();

static constexpr bool isConstExprConfigValue() { return true; }

int test_const_expr_config_value() {
 if (isConstExprConfigValue()) {
   somethingToCall();
   return 0;
 }
 somethingToCall(); // no-warning
 return 1;
}
int test_const_expr_config_value_2() {
 if (!isConstExprConfigValue()) {
   somethingToCall(); // no-warning
   return 0;
 }
 somethingToCall();
 return 1;
}

class Frodo {
public:
  static const bool aHobbit = true;
};

void test_static_class_var() {
  if (Frodo::aHobbit)
    somethingToCall();
  else
    somethingToCall(); // no-warning
}

void test_static_class_var(Frodo &F) {
  if (F.aHobbit)
    somethingToCall();
  else
    somethingToCall(); // no-warning
}

void test_unreachable_for_null_increment() {
  for (unsigned i = 0; i < 10 ; ) // no-warning
    break;
}

void test_unreachable_forrange_increment() {
  int x[10] = { 0 };
  for (auto i : x) { // expected-warning {{loop will run at most once (loop increment never executed)}}
    break;
  }
}

void calledFun() {}

// Test "silencing" with parentheses.
void test_with_paren_silencing(int x) {
  if (false) calledFun(); // expected-warning {{will never be executed}} expected-note {{silence by adding parentheses to mark code as explicitly dead}}
  if ((false)) calledFun(); // no-warning

  if (true) // expected-note {{silence by adding parentheses to mark code as explicitly dead}}
    calledFun();
  else
    calledFun(); // expected-warning {{will never be executed}}

  if ((true))
    calledFun();
  else
    calledFun(); // no-warning
  
  if (!true) // expected-note {{silence by adding parentheses to mark code as explicitly dead}}
    calledFun(); // expected-warning {{code will never be executed}}
  else
    calledFun();
  
  if ((!true))
    calledFun(); // no-warning
  else
    calledFun();
  
  if (!(true))
    calledFun(); // no-warning
  else
    calledFun();
}

void test_with_paren_silencing_impcast(int x) {
  if (0) calledFun(); // expected-warning {{will never be executed}} expected-note {{silence by adding parentheses to mark code as explicitly dead}}
  if ((0)) calledFun(); // no-warning

  if (1) // expected-note {{silence by adding parentheses to mark code as explicitly dead}}
    calledFun();
  else
    calledFun(); // expected-warning {{will never be executed}}

  if ((1))
    calledFun();
  else
    calledFun(); // no-warning
  
  if (!1) // expected-note {{silence by adding parentheses to mark code as explicitly dead}}
    calledFun(); // expected-warning {{code will never be executed}}
  else
    calledFun();
  
  if ((!1))
    calledFun(); // no-warning
  else
    calledFun();
  
  if (!(1))
    calledFun(); // no-warning
  else
    calledFun();
}

void tautological_compare(bool x, int y) {
  if (x > 10)           // expected-note {{silence}}
    calledFun();        // expected-warning {{will never be executed}}
  if (10 < x)           // expected-note {{silence}}
    calledFun();        // expected-warning {{will never be executed}}
  if (x == 10)          // expected-note {{silence}}
    calledFun();        // expected-warning {{will never be executed}}

  if (x < 10)           // expected-note {{silence}}
    calledFun();
  else
    calledFun();        // expected-warning {{will never be executed}}
  if (10 > x)           // expected-note {{silence}}
    calledFun();
  else
    calledFun();        // expected-warning {{will never be executed}}
  if (x != 10)          // expected-note {{silence}}
    calledFun();
  else
    calledFun();        // expected-warning {{will never be executed}}

  if (y != 5 && y == 5) // expected-note {{silence}}
    calledFun();        // expected-warning {{will never be executed}}

  if (y > 5 && y < 4)   // expected-note {{silence}}
    calledFun();        // expected-warning {{will never be executed}}

  if (y < 10 || y > 5)  // expected-note {{silence}}
    calledFun();
  else
    calledFun();        // expected-warning {{will never be executed}}

  if (y == -1 && y != -1)  // expected-note {{silence}}
    calledFun();        // expected-warning {{will never be executed}}

  // TODO: Extend warning to the following code:
  if (x < -1)
    calledFun();
  if (x == -1)
    calledFun();

  if (x != -1)
    calledFun();
  else
    calledFun();
  if (-1 > x)
    calledFun();
  else
    calledFun();

}