test/std/algorithms/alg.nonmodifying/alg.fold/requirements.compile.pass.cpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

// <algorithm>

// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20

// template<input_iterator I, sentinel_for<I> S, class T,
//          indirectly-binary-left-foldable<T, I> F>
//   constexpr see below ranges::fold_left_with_iter(I first, S last, T init, F f);
//
// template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
//   constexpr see below ranges::fold_left_with_iter(R&& r, T init, F f);

// template<input_iterator I, sentinel_for<I> S, class T,
//          indirectly-binary-left-foldable<T, I> F>
//   constexpr see below ranges::fold_left(I first, S last, T init, F f);
//
// template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
//   constexpr see below ranges::fold_left(R&& r, T init, F f);

// Checks that the algorithm requirements reject parameters that don't meet the overloads' constraints.

#include <algorithm>
#include <concepts>
#include <cstddef>
#include <functional>
#include <iterator>
#include <ranges>

#include "test_iterators.h"

// FIXME(cjdb): deduplicate
struct bad_iterator_category {
  using value_type        = int;
  using difference_type   = std::ptrdiff_t;
  using iterator_category = void;

  value_type operator*() const;

  bad_iterator_category& operator++();
  void operator++(int);
};

// Covers indirectly_readable<I> too
template <std::input_or_output_iterator T>
  requires(!std::input_iterator<T>)
void requires_input_iterator() {
  struct bad_range {
    T begin();
    std::unreachable_sentinel_t end();
  };

  static_assert(!requires(bad_range r) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), std::unreachable_sentinel, 0, std::plus());
  });
  static_assert(!requires(bad_range r) { std::ranges::fold_left_with_iter(r, 0, std::plus()); });

  static_assert(!requires(bad_range r) {
    std::ranges::fold_left(r.begin(), r.end(), std::unreachable_sentinel, 0, std::plus());
  });

  static_assert(!requires(bad_range r) { std::ranges::fold_left(r, 0, std::plus()); });
}

template <std::equality_comparable S>
  requires(!std::sentinel_for<int*, S>)
void requires_sentinel() {
  static_assert(!requires(S first, S last) { std::ranges::fold_left_with_iter(first, last, 0, std::plus()); });
  static_assert(!requires(S first, S last) { std::ranges::fold_left(first, last, 0, std::plus()); });
}

struct non_copy_constructible_callable {
  non_copy_constructible_callable(non_copy_constructible_callable&&)      = default;
  non_copy_constructible_callable(non_copy_constructible_callable const&) = delete;

  int operator()(int, int) const;
};

template <class F>
  requires(!std::copy_constructible<F>)
void requires_copy_constructible_F() {
  static_assert(!requires(std::ranges::subrange<int*, int*> r, F f) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), 0, std::move(f));
  });
  static_assert(!requires(std::ranges::subrange<int*, int*> r, F f) {
    std::ranges::fold_left_with_iter(r, 0, std::move(f));
  });

  static_assert(!requires(std::ranges::subrange<int*, int*> r, F f) {
    std::ranges::fold_left(r.begin(), r.end(), 0, std::move(f));
  });
  static_assert(!requires(std::ranges::subrange<int*, int*> r, F f) { std::ranges::fold_left(r, 0, std::move(f)); });
}

struct not_invocable_with_lvalue_rhs {
  int operator()(int, int&&);
};

template <class F>
  requires(!std::invocable<F&, int, std::iter_reference_t<int*>>)
void requires_raw_invocable() {
  static_assert(!requires(std::ranges::subrange<int*, int*> r, F f) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), 0, f);
  });
  static_assert(!requires(std::ranges::subrange<int*, int*> r, F f) { std::ranges::fold_left_with_iter(r, 0, f); });

  static_assert(!requires(std::ranges::subrange<int*, int*> r, F f) {
    std::ranges::fold_left(r.begin(), r.end(), 0, f);
  });
  static_assert(!requires(std::ranges::subrange<int*, int*> r, F f) { std::ranges::fold_left(r, 0, f); });
}

struct S {};

struct non_decayable_result {
  S volatile& operator()(S, S) const;
};

template <std::invocable<S, std::iter_reference_t<S*>> F>
  requires(!std::convertible_to<std::invoke_result_t<F&, S, std::iter_reference_t<S*>>,
                                std::decay_t<std::invoke_result_t<F&, S, std::iter_reference_t<S*>>>>)
void requires_decaying_invoke_result() {
  static_assert(!requires(std::ranges::subrange<S*, S*> r, S init, F f) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), init, f);
  });
  static_assert(!requires(std::ranges::subrange<S*, S*> r, S init, F f) {
    std::ranges::fold_left_with_iter(r, init, f);
  });

  static_assert(!requires(std::ranges::subrange<S*, S*> r, S init, F f) {
    std::ranges::fold_left(r.begin(), r.end(), init, f);
  });
  static_assert(!requires(std::ranges::subrange<S*, S*> r, S init, F f) { std::ranges::fold_left(r, init, f); });
}

struct non_movable {
  non_movable(int);
  non_movable(non_movable&&) = delete;

  int apply(non_movable const&) const;
};

template <class T>
  requires(!std::movable<T>)
void requires_movable_init() {
  static_assert(!requires(std::ranges::subrange<T*, T*> r, T init) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), init, &T::apply);
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r, T init) {
    std::ranges::fold_left_with_iter(r, init, &T::apply);
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r, T init) {
    std::ranges::fold_left(r.begin(), r.end(), init, &T::apply);
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r, T init) { std::ranges::fold_left(r, init, &T::apply); });
}

struct result_not_movable_after_decay {
  result_not_movable_after_decay(int);
  result_not_movable_after_decay(result_not_movable_after_decay&&) = delete;
  result_not_movable_after_decay(result_not_movable_after_decay const&);

  friend result_not_movable_after_decay const& operator+(int, result_not_movable_after_decay const&);
  friend result_not_movable_after_decay const& operator+(result_not_movable_after_decay const&, int);
  friend result_not_movable_after_decay const&
  operator+(result_not_movable_after_decay const&, result_not_movable_after_decay const&);
};

template <class T>
  requires(!std::movable<T>)
void requires_movable_decayed() {
  static_assert(!requires(std::ranges::subrange<T*, T*> r) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), 0, std::plus());
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r) { std::ranges::fold_left_with_iter(r, 0, std::plus()); });

  static_assert(!requires(std::ranges::subrange<T*, T*> r) {
    std::ranges::fold_left(r.begin(), r.end(), 0, T::apply);
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r) { std::ranges::fold_left(r, 0, std::plus()); });
}

struct not_convertible_to_int {
  friend int operator+(not_convertible_to_int, not_convertible_to_int);
  friend int operator+(not_convertible_to_int, int);
  friend int operator+(int, not_convertible_to_int);
};

template <class T>
  requires(!std::convertible_to<T, int>)
void requires_init_is_convertible_to_decayed() {
  static_assert(!requires(std::ranges::subrange<int*, int*> r, T init) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), init, std::plus());
  });
  static_assert(!requires(std::ranges::subrange<int*, int*> r, T init) {
    std::ranges::fold_left_with_iter(r, init, std::plus());
  });

  static_assert(!requires(std::ranges::subrange<int*, int*> r, T init) {
    std::ranges::fold_left(r.begin(), r.end(), init, std::plus());
  });
  static_assert(!requires(std::ranges::subrange<int*, int*> r, T init) {
    std::ranges::fold_left(r, init, std::plus());
  });
}

struct not_invocable_with_decayed {
  not_invocable_with_decayed(int);
  friend not_invocable_with_decayed& operator+(int, not_invocable_with_decayed&);
  friend not_invocable_with_decayed& operator+(not_invocable_with_decayed&, int);
  friend not_invocable_with_decayed& operator+(not_invocable_with_decayed volatile&, not_invocable_with_decayed&);
};

template <class T>
  requires(!std::invocable<std::plus<>&, T, T&>)
void requires_invocable_with_decayed() {
  static_assert(!requires(std::ranges::subrange<T*, T*> r, int init) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), init, std::plus());
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r, int init) {
    std::ranges::fold_left_with_iter(r, init, std::plus());
  });

  static_assert(!requires(std::ranges::subrange<T*, T*> r, int init) {
    std::ranges::fold_left(r.begin(), r.end(), init, std::plus());
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r, int init) { std::ranges::fold_left(r, init, std::plus()); });
}

struct not_assignable_to_decayed {
  not_assignable_to_decayed();
  not_assignable_to_decayed(not_assignable_to_decayed&);
  not_assignable_to_decayed(not_assignable_to_decayed const&);
  not_assignable_to_decayed(not_assignable_to_decayed volatile&);
  not_assignable_to_decayed(not_assignable_to_decayed const volatile&);
  friend not_assignable_to_decayed volatile& operator+(not_assignable_to_decayed, not_assignable_to_decayed);
};

template <class T>
  requires(!std::assignable_from<T&, T volatile&>)
void requires_assignable_from_invoke_result() {
  static_assert(!requires(std::ranges::subrange<T*, T*> r, T init) {
    std::ranges::fold_left_with_iter(r.begin(), r.end(), init, std::plus());
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r, T init) {
    std::ranges::fold_left_with_iter(r, init, std::plus());
  });

  static_assert(!requires(std::ranges::subrange<T*, T*> r, T init) {
    std::ranges::fold_left(r.begin(), r.end(), init, std::plus());
  });
  static_assert(!requires(std::ranges::subrange<T*, T*> r, T init) { std::ranges::fold_left(r, init, std::plus()); });
}

void test() {
  requires_input_iterator<bad_iterator_category>();
  requires_sentinel<cpp17_input_iterator<int*>>();
  requires_copy_constructible_F<non_copy_constructible_callable>();
  requires_raw_invocable<not_invocable_with_lvalue_rhs>();
  requires_decaying_invoke_result<non_decayable_result>();
  requires_movable_init<non_movable>();
  requires_movable_decayed<result_not_movable_after_decay>();
  requires_init_is_convertible_to_decayed<not_convertible_to_int>();
  requires_invocable_with_decayed<not_invocable_with_decayed>();
  requires_assignable_from_invoke_result<not_assignable_to_decayed>();
}