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

template<typename T, typename U>
constexpr static bool is_same_v = false;

template<typename T>
constexpr static bool is_same_v<T, T> = true;

namespace templates
{
  template<typename T>
  concept AtLeast1 = sizeof(T) >= 1;

  template<typename T>
  int foo(T t) requires (sizeof(T) == 4) { // expected-note {{candidate function}}
    return 0;
  }

  template<typename T>
  char foo(T t) requires AtLeast1<T> { // expected-note {{candidate function}}
    return 'a';
  }

  template<typename T>
  double foo(T t) requires (AtLeast1<T> && sizeof(T) <= 2) {
    return 'a';
  }

  static_assert(is_same_v<decltype(foo(10)), int>); // expected-error {{call to 'foo' is ambiguous}}
  static_assert(is_same_v<decltype(foo(short(10))), double>);

  template<typename T>
  void bar() requires (sizeof(T) == 1) { }
  // expected-note@-1{{similar constraint expressions not considered equivalent}}
  // expected-note@-2{{candidate function [with T = char]}}

  template<typename T>
  void bar() requires (sizeof(T) == 1 && sizeof(T) >= 0) { }
  // expected-note@-1{{candidate function [with T = char]}}
  // expected-note@-2{{similar constraint expression here}}

  static_assert(is_same_v<decltype(bar<char>()), void>);
  // expected-error@-1{{call to 'bar' is ambiguous}}

  template<typename T>
  constexpr int baz() requires AtLeast1<T> { // expected-note {{candidate function}}
    return 1;
  }

  template<typename T> requires AtLeast1<T>
  constexpr int baz() { // expected-note {{candidate function [with T = int]}}
    return 2;
  }

  static_assert(baz<int>() == 1); // expected-error {{call to 'baz' is ambiguous}}
}

namespace non_template
{
  template<typename T>
  concept AtLeast2 = sizeof(T) >= 2;

  template<typename T>
  concept AtMost8 = sizeof(T) <= 8;

  int foo() requires AtLeast2<long> && AtMost8<long> {
    return 0;
  }

  double foo() requires AtLeast2<long> {
    return 0.0;
  }

  double baz() requires AtLeast2<long> && AtMost8<long> { // expected-note {{candidate function}}
    return 0.0;
  }

  int baz() requires AtMost8<long> && AtLeast2<long> { // expected-note {{candidate function}}
    return 0.0;
  }

  void bar() requires (sizeof(char[8]) >= 8) { }
  // expected-note@-1 {{candidate function}}
  // expected-note@-2 {{similar constraint expressions not considered equivalent}}

  void bar() requires (sizeof(char[8]) >= 8 && sizeof(int) <= 30) { }
  // expected-note@-1 {{candidate function}}
  // expected-note@-2 {{similar constraint expression here}}

  static_assert(is_same_v<decltype(foo()), int>);
  static_assert(is_same_v<decltype(baz()), int>); // expected-error {{call to 'baz' is ambiguous}}
  static_assert(is_same_v<decltype(bar()), void>); // expected-error {{call to 'bar' is ambiguous}}
  
  constexpr int goo(int a) requires AtLeast2<int> && true {
    return 1;
  }

  constexpr int goo(const int b) requires AtLeast2<int> {
    return 2;
  }

  // Only trailing requires clauses of redeclarations are compared for overload resolution.
  constexpr int doo(int a, ...) requires AtLeast2<int> && true { // expected-note {{candidate function}}
    return 1;
  }

  constexpr int doo(int b) requires AtLeast2<int> { // expected-note {{candidate function}}
    return 2;
  }

  static_assert(goo(1) == 1);
  static_assert(doo(2) == 1); // expected-error {{call to 'doo' is ambiguous}}
}