// RUN: %clang_cc1 -fsyntax-only -verify -std=c++2a %s

// PR5908
template <typename Iterator>
void Test(Iterator it) {
  *(it += 1);
}

namespace PR6045 {
  template<unsigned int r>
  class A
  {
    static const unsigned int member = r;
    void f();
  };
  
  template<unsigned int r>
  const unsigned int A<r>::member;
  
  template<unsigned int r>
  void A<r>::f() 
  {
    unsigned k;
    (void)(k % member);
  }
}

namespace PR7198 {
  struct A
  {
    ~A() { }
  };

  template<typename T>
  struct B {
    struct C : A {};
    void f()
    {
      C c = C();
    }
  };
}

namespace PR7724 {
  template<typename OT> int myMethod()
  { return 2 && sizeof(OT); }
}

namespace test4 {
  template <typename T> T *addressof(T &v) {
    return reinterpret_cast<T*>(
             &const_cast<char&>(reinterpret_cast<const volatile char &>(v)));
  }
}

namespace test5 {
  template <typename T> class chained_map {
    int k;
    void lookup() const {
      int &v = (int &)k;
    }
  };
}

namespace test6 {
  template<typename T> T f() {
    const T &v(0);
    return v;
  }
  int use = f<int>();
}

namespace PR8795 {
  template <class _CharT> int test(_CharT t)
  {
    int data [] = {
      sizeof(_CharT) > sizeof(char)
    };
    return data[0];
  }
}

template<typename T> struct CastDependentIntToPointer {
  static void* f() {
    T *x;
    return ((void*)(((unsigned long)(x)|0x1ul)));
  }
};

// Regression test for crasher in r194540.
namespace PR10837 {
  typedef void t(int);
  template<typename> struct A {
    void f();
    static t g;
  };
  t *p;
  template<typename T> void A<T>::f() {
    p = g;
  }
  template struct A<int>;
}

namespace PR18152 {
  template<int N> struct A {
    static const int n = {N};
  };
  template struct A<0>;
}

template<typename T> void stmt_expr_1() {
  static_assert( ({ false; }), "" );
}
void stmt_expr_2() {
  static_assert( ({ false; }), "" ); // expected-error {{failed}}
}

namespace PR45083 {
  struct A { bool x; };

  template<typename> struct B : A {
    void f() {
      const int n = ({ if (x) {} 0; });
    }
  };

  template void B<int>::f();

  template<typename> void f() {
    decltype(({})) x; // expected-error {{incomplete type}}
  }
  template void f<int>(); // expected-note {{instantiation of}}

  template<typename> auto g() {
    auto c = [](auto, int) -> decltype(({})) {};
    using T = decltype(c(0.0, 0));
    using T = void;
    return c(0, 0);
  }
  using U = decltype(g<int>()); // expected-note {{previous}}
  using U = float; // expected-error {{different types ('float' vs 'decltype(g<int>())' (aka 'void'))}}

  void h(auto a, decltype(g<char>())*) {} // expected-note {{previous}}
  void h(auto a, void*) {} // expected-error {{redefinition}}

  void i(auto a) {
    [](auto a, int = ({decltype(a) i; i * 2;})){}(a); // expected-error {{invalid operands to binary expression ('decltype(a)' (aka 'void *') and 'int')}} expected-note {{in instantiation of}}
  }
  void use_i() {
    i(0);
    i((void*)0); // expected-note {{instantiation of}}
  }
}

namespace BindingInStmtExpr {
  template<class ...Ts> struct overload : Ts... {
    overload(Ts ...ts) : Ts(decltype(ts)(ts))... {}
    using Ts::operator()...;
  };

  template<int> struct N {};

  template<class T> auto num_bindings() {
    auto f0 = [](auto t, unsigned) { return N<0>(); };
    auto f1 = [](auto t, int) -> decltype(({ auto [_1] = t; N<1>(); })) { return {}; };
    auto f2 = [](auto t, int) -> decltype(({ auto [_1, _2] = t; N<2>(); })) { return {}; };
    auto f3 = [](auto t, int) -> decltype(({ auto [_1, _2, _3] = t; N<3>(); })) { return {}; };
    return decltype(overload(f0, f1, f2, f3)(T(), 0))();
  }

  struct T { int a; int b; };
  // Make sure we get a correct, non-dependent type back.
  using U = decltype(num_bindings<T>()); // expected-note {{previous}}
  using U = N<3>; // expected-error-re {{type alias redefinition with different types ('N<3>' vs {{.*}}N<2>}}
}