//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H
#define TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H
#include <cstddef>
#include <functional>
#include <initializer_list>
#include <iterator>
#include <memory>
#include <type_traits>
#include <utility>
#include <vector>
#include "test_macros.h"
#if TEST_STD_VER >= 23
#include "almost_satisfies_types.h"
#endif
#if TEST_STD_VER >= 23
template <class T>
struct RangeT {
T* begin();
T* end();
};
static_assert(std::ranges::input_range<RangeT<int>>);
template <class T>
using BadRangeT = InputRangeNotDerivedFromGeneric<T>;
static_assert(std::ranges::range<BadRangeT<int>>);
static_assert(!std::ranges::input_range<BadRangeT<int>>);
#endif
// `SFINAEs_away` template variable checks whether the template arguments for
// a given template class `Instantiated` can be deduced from the given
// constructor parameter types `CtrArgs` using CTAD.
template<template<typename ...> class Instantiated, class ...CtrArgs,
class = decltype(Instantiated(std::declval<CtrArgs>()...))>
std::false_type SFINAEs_away_impl(int);
template<template<typename ...> class Instantiated, class ...CtrArgs>
std::true_type SFINAEs_away_impl(...);
template<template<typename ...> class Instantiated, class ...CtrArgs>
constexpr bool SFINAEs_away =
decltype(SFINAEs_away_impl<Instantiated, CtrArgs...>(0))::value;
struct Empty {};
// For sequence containers the deduction guides should be SFINAE'd away when
// given:
// - "bad" input iterators (that is, a type not qualifying as an input
// iterator);
// - a bad allocator;
// - a range not satisfying the `input_range` concept.
template<template<typename ...> class Container, typename InstantiatedContainer, typename BadAlloc = Empty>
constexpr void SequenceContainerDeductionGuidesSfinaeAway() {
using T = typename InstantiatedContainer::value_type;
using Alloc = std::allocator<T>;
using Iter = T*;
// Note: the only requirement in the Standard is that integral types cannot be
// considered input iterators; however, this doesn't work for sequence
// containers because they have constructors of the form `(size_type count,
// const value_type& value)`. These constructors would be used when passing
// two integral types and would deduce `value_type` to be an integral type.
#ifdef _LIBCPP_VERSION
using OutputIter = std::insert_iterator<InstantiatedContainer>;
#endif // _LIBCPP_VERSION
// (iter, iter)
//
// Cannot deduce from (BAD_iter, BAD_iter)
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter>);
// (iter, iter, alloc)
//
// Cannot deduce from (BAD_iter, BAD_iter, alloc)
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, Alloc>);
// Cannot deduce from (iter, iter, BAD_alloc)
static_assert(SFINAEs_away<Container, Iter, Iter, BadAlloc>);
// (alloc)
//
// Cannot deduce from (alloc)
static_assert(SFINAEs_away<Container, Alloc>);
#if TEST_STD_VER >= 23
using BadRange = BadRangeT<T>;
// (from_range, range)
//
// Cannot deduce from (BAD_range)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);
// (from_range, range, alloc)
//
// Cannot deduce from (range, BAD_alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);
#endif
}
// Deduction guides should be SFINAE'd away when given:
// - a "bad" allocator (that is, a type not qualifying as an allocator);
// - an allocator instead of a container;
// - an allocator and a container that uses a different allocator;
// - a range not satisfying the `input_range` concept.
template<template<typename ...> class Container, typename InstantiatedContainer>
constexpr void ContainerAdaptorDeductionGuidesSfinaeAway() {
using T = typename InstantiatedContainer::value_type;
using Alloc [[maybe_unused]] = std::allocator<T>;
using Iter = T*;
using BadIter [[maybe_unused]] = int;
using BadAlloc = Empty;
// (container) -- no constraints.
// (container, alloc)
//
// Cannot deduce from (container, BAD_alloc)
static_assert(SFINAEs_away<Container, std::vector<T>, BadAlloc>);
// (iter, iter)
//
// Cannot deduce from (BAD_iter, BAD_iter)
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, BadIter, BadIter>);
#if TEST_STD_VER >= 23
using BadRange = BadRangeT<T>;
// (iter, iter, alloc)
//
// Cannot deduce from (BAD_iter, BAD_iter, alloc)
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, BadIter, BadIter, Alloc>);
// Cannot deduce from (iter, iter, BAD_alloc)
static_assert(SFINAEs_away<Container, Iter, Iter, BadAlloc>);
// (from_range, range)
//
// Cannot deduce from (BAD_range)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);
// (from_range, range, alloc)
//
// Cannot deduce from (range, BAD_alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);
#endif
}
// For associative containers the deduction guides should be SFINAE'd away when
// given:
// - "bad" input iterators (that is, a type not qualifying as an input
// iterator);
// - a bad allocator;
// - an allocator in place of a comparator;
// - a range not satisfying the `input_range` concept.
template<template<typename ...> class Container, typename InstantiatedContainer>
constexpr void AssociativeContainerDeductionGuidesSfinaeAway() {
using ValueType = typename InstantiatedContainer::value_type;
using Comp = std::less<int>;
using Alloc = std::allocator<ValueType>;
using Iter = ValueType*;
using InitList = std::initializer_list<ValueType>;
struct BadAlloc {};
// The only requirement in the Standard is that integral types cannot be
// considered input iterators, beyond that it is unspecified.
using BadIter = int;
#ifdef _LIBCPP_VERSION
using OutputIter = std::insert_iterator<InstantiatedContainer>;
#endif // _LIBCPP_VERSION
using AllocAsComp = Alloc;
// (iter, iter)
//
// Cannot deduce from (BAD_iter, BAD_iter)
static_assert(SFINAEs_away<Container, BadIter, BadIter>);
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter>);
// (iter, iter, comp)
//
// Cannot deduce from (BAD_iter, BAD_iter, comp)
static_assert(SFINAEs_away<Container, BadIter, BadIter, Comp>);
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, Comp>);
// (iter, iter, comp, alloc)
//
// Cannot deduce from (BAD_iter, BAD_iter, comp, alloc)
static_assert(SFINAEs_away<Container, BadIter, BadIter, Comp, Alloc>);
LIBCPP_STATIC_ASSERT(
SFINAEs_away<Container, OutputIter, OutputIter, Comp, Alloc>);
// Cannot deduce from (iter, iter, ALLOC_as_comp, alloc)
static_assert(SFINAEs_away<Container, Iter, Iter, AllocAsComp, Alloc>);
// Cannot deduce from (iter, iter, comp, BAD_alloc)
static_assert(SFINAEs_away<Container, Iter, Iter, Comp, BadAlloc>);
// (iter, iter, alloc)
//
// Cannot deduce from (BAD_iter, BAD_iter, alloc)
static_assert(SFINAEs_away<Container, BadIter, BadIter, Alloc>);
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, Alloc>);
// Note: (iter, iter, BAD_alloc) is interpreted as (iter, iter, comp)
// instead and fails upon instantiation. There is no requirement to SFINAE
// away bad comparators.
// (init_list, comp, alloc)
//
// Cannot deduce from (init_list, ALLOC_as_comp, alloc)
static_assert(SFINAEs_away<Container, InitList, AllocAsComp, Alloc>);
// Cannot deduce from (init_list, comp, BAD_alloc)
static_assert(SFINAEs_away<Container, InitList, Comp, BadAlloc>);
// (init_list, alloc)
//
// Note: (init_list, BAD_alloc) is interpreted as (init_list, comp) instead
// and fails upon instantiation. There is no requirement to SFINAE away bad
// comparators.
#if TEST_STD_VER >= 23
using Range = RangeT<ValueType>;
using BadRange = BadRangeT<ValueType>;
// (from_range, range)
//
// Can deduce from (from_range, range)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range>);
// Cannot deduce from (from_range, BAD_range)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);
// (from_range, range, comp)
//
// Can deduce from (from_range, _range, comp)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, Comp>);
// Cannot deduce from (from_range, BAD_range, comp)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, Comp>);
// (from_range, range, comp, alloc)
//
// Can deduce from (from_range, range, comp, alloc)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, Comp, Alloc>);
// Cannot deduce from (from_range, BAD_range, comp, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, Comp, Alloc>);
// Cannot deduce from (from_range, range, comp, BAD_alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, Range, Comp, BadAlloc>);
// (from_range, range, alloc)
//
// Can deduce from (from_range, range, alloc)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, Alloc>);
// Cannot deduce from (from_range, BAD_range, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, Alloc>);
// Note: (from_range, range, BAD_alloc) is interpreted as (from_range, range, comp) instead.
#endif
}
// For unordered containers the deduction guides should be SFINAE'd away when
// given:
// - "bad" input iterators (that is, a type not qualifying as an input
// iterator);
// - a bad allocator;
// - a bad hash functor (an integral type in place of a hash);
// - an allocator in place of a hash functor;
// - an allocator in place of a predicate;
// - a range not satisfying the `input_range` concept.
template<template<typename ...> class Container, typename InstantiatedContainer>
constexpr void UnorderedContainerDeductionGuidesSfinaeAway() {
using ValueType = typename InstantiatedContainer::value_type;
using Pred = std::equal_to<int>;
using Hash = std::hash<int>;
using Alloc = std::allocator<ValueType>;
using Iter = ValueType*;
using InitList = std::initializer_list<ValueType>;
using BadHash = short;
struct BadAlloc {};
// The only requirement in the Standard is that integral types cannot be
// considered input iterators, beyond that it is unspecified.
using BadIter = int;
#ifdef _LIBCPP_VERSION
using OutputIter = std::insert_iterator<InstantiatedContainer>;
#endif // _LIBCPP_VERSION
using AllocAsHash = Alloc;
using AllocAsPred = Alloc;
// (iter, iter)
//
// Cannot deduce from (BAD_iter, BAD_iter)
static_assert(SFINAEs_away<Container, BadIter, BadIter>);
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter>);
// (iter, iter, buckets)
//
// Cannot deduce from (BAD_iter, BAD_iter, buckets)
static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t>);
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, std::size_t>);
// (iter, iter, buckets, hash)
//
// Cannot deduce from (BAD_iter, BAD_iter, buckets, hash)
static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t, Hash>);
LIBCPP_STATIC_ASSERT(
SFINAEs_away<Container, OutputIter, OutputIter, std::size_t, Hash>);
// Cannot deduce from (iter, iter, buckets, BAD_hash)
static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, BadHash>);
// Note: (iter, iter, buckets, ALLOC_as_hash) is allowed -- it just calls
// (iter, iter, buckets, alloc)
// (iter, iter, buckets, hash, pred)
//
// Cannot deduce from (BAD_iter, BAD_iter, buckets, hash, pred)
static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t, Hash, Pred>);
LIBCPP_STATIC_ASSERT(
SFINAEs_away<Container, OutputIter, OutputIter, std::size_t, Hash, Pred>);
// Cannot deduce from (iter, iter, buckets, BAD_hash, pred)
static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, BadHash, Pred>);
// Cannot deduce from (iter, iter, buckets, ALLOC_as_hash, pred)
static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, AllocAsHash, Pred>);
// Note: (iter, iter, buckets, hash, ALLOC_as_pred) is allowed -- it just
// calls (iter, iter, buckets, hash, alloc)
// (iter, iter, buckets, hash, pred, alloc)
//
// Cannot deduce from (BAD_iter, BAD_iter, buckets, hash, pred, alloc)
static_assert(
SFINAEs_away<Container, BadIter, BadIter, std::size_t, Hash, Pred, Alloc>);
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter,
std::size_t, Hash, Pred, Alloc>);
// Cannot deduce from (iter, iter, buckets, BAD_hash, pred, alloc)
static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, BadHash, Pred, Alloc>);
// Cannot deduce from (iter, iter, buckets, ALLOC_as_hash, pred, alloc)
static_assert(
SFINAEs_away<Container, Iter, Iter, std::size_t, AllocAsHash, Pred, Alloc>);
// Cannot deduce from (iter, iter, buckets, hash, ALLOC_as_pred, alloc)
static_assert(
SFINAEs_away<Container, Iter, Iter, std::size_t, Hash, AllocAsPred, Alloc>);
// Cannot deduce from (iter, iter, buckets, hash, pred, BAD_alloc)
static_assert(
SFINAEs_away<Container, Iter, Iter, std::size_t, Hash, Pred, BadAlloc>);
// (iter, iter, buckets, alloc)
//
// Cannot deduce from (BAD_iter, BAD_iter, buckets, alloc)
static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t, Alloc>);
LIBCPP_STATIC_ASSERT(
SFINAEs_away<Container, OutputIter, OutputIter, std::size_t, Alloc>);
// Note: (iter, iter, buckets, BAD_alloc) is interpreted as (iter, iter,
// buckets, hash), which is valid because the only requirement for the hash
// parameter is that it's not integral.
// (iter, iter, alloc)
//
// Cannot deduce from (BAD_iter, BAD_iter, alloc)
static_assert(SFINAEs_away<Container, BadIter, BadIter, Alloc>);
LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, Alloc>);
// Cannot deduce from (iter, iter, BAD_alloc)
static_assert(SFINAEs_away<Container, Iter, Iter, BadAlloc>);
// (iter, iter, buckets, hash, alloc)
//
// Cannot deduce from (BAD_iter, BAD_iter, buckets, hash, alloc)
static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t, Hash, Alloc>);
LIBCPP_STATIC_ASSERT(
SFINAEs_away<Container, OutputIter, OutputIter, std::size_t, Hash, Alloc>);
// Cannot deduce from (iter, iter, buckets, BAD_hash, alloc)
static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, BadHash, Alloc>);
// Cannot deduce from (iter, iter, buckets, ALLOC_as_hash, alloc)
static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, AllocAsHash, Alloc>);
// Note: (iter, iter, buckets, hash, BAD_alloc) is interpreted as (iter, iter,
// buckets, hash, pred), which is valid because there are no requirements for
// the predicate.
// (init_list, buckets, hash)
//
// Cannot deduce from (init_list, buckets, BAD_hash)
static_assert(SFINAEs_away<Container, InitList, std::size_t, BadHash>);
// Note: (init_list, buckets, ALLOC_as_hash) is interpreted as (init_list,
// buckets, alloc), which is valid.
// (init_list, buckets, hash, pred)
//
// Cannot deduce from (init_list, buckets, BAD_hash, pred)
static_assert(SFINAEs_away<Container, InitList, std::size_t, BadHash, Pred>);
// Cannot deduce from (init_list, buckets, ALLOC_as_hash, pred)
static_assert(SFINAEs_away<Container, InitList, std::size_t, AllocAsHash, Pred>);
// Note: (init_list, buckets, hash, ALLOC_as_pred) is interpreted as
// (init_list, buckets, hash, alloc), which is valid.
// (init_list, buckets, hash, pred, alloc)
//
// Cannot deduce from (init_list, buckets, BAD_hash, pred, alloc)
static_assert(
SFINAEs_away<Container, InitList, std::size_t, BadHash, Pred, Alloc>);
// Cannot deduce from (init_list, buckets, ALLOC_as_hash, pred, alloc)
static_assert(
SFINAEs_away<Container, InitList, std::size_t, AllocAsHash, Pred, Alloc>);
// Cannot deduce from (init_list, buckets, hash, ALLOC_as_pred, alloc)
static_assert(
SFINAEs_away<Container, InitList, std::size_t, Hash, AllocAsPred, Alloc>);
// Cannot deduce from (init_list, buckets, hash, pred, BAD_alloc)
static_assert(
SFINAEs_away<Container, InitList, std::size_t, Hash, Pred, BadAlloc>);
// (init_list, buckets, alloc)
//
// Note: (init_list, buckets, BAD_alloc) is interpreted as (init_list,
// buckets, hash), which is valid because the only requirement for the hash
// parameter is that it's not integral.
// (init_list, buckets, hash, alloc)
//
// Cannot deduce from (init_list, buckets, BAD_hash, alloc)
static_assert(SFINAEs_away<Container, InitList, std::size_t, BadHash, Alloc>);
// Cannot deduce from (init_list, buckets, ALLOC_as_hash, alloc)
static_assert(SFINAEs_away<Container, InitList, std::size_t, AllocAsHash, Alloc>);
// (init_list, alloc)
//
// Cannot deduce from (init_list, BAD_alloc)
static_assert(SFINAEs_away<Container, InitList, BadAlloc>);
#if TEST_STD_VER >= 23
using Range = RangeT<ValueType>;
using BadRange = BadRangeT<ValueType>;
// (from_range, range)
//
// Can deduce from (from_range, range)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range>);
// Cannot deduce from (from_range, BAD_range)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);
// (from_range, range, buckets)
//
// Can deduce from (from_range, range, buckets)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t>);
// Cannot deduce from (from_range, BAD_range, buckets)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t>);
// (from_range, range, buckets, hash)
//
// Can deduce from (from_range, range, buckets, hash)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash>);
// Cannot deduce from (from_range, BAD_range, buckets, hash)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Hash>);
// Cannot deduce from (from_range, range, buckets, BAD_hash)
static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, BadHash>);
// (from_range, range, buckets, hash, pred)
//
// Can deduce from (from_range, range, buckets, hash, pred)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash, Pred>);
// Cannot deduce from (from_range, BAD_range, buckets, hash, pred)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Hash, Pred>);
// Cannot deduce from (from_range, range, buckets, BAD_hash, pred)
static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, BadHash, Pred>);
// (from_range, range, buckets, hash, pred, alloc)
//
// Can deduce from (from_range, range, buckets, hash, pred, alloc)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash, Pred, Alloc>);
// Cannot deduce from (from_range, BAD_range, buckets, hash, pred, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Hash, Pred, Alloc>);
// Cannot deduce from (from_range, range, buckets, BAD_hash, pred, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, BadHash, Pred, Alloc>);
// Cannot deduce from (from_range, range, buckets, hash, pred, BAD_alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash, Pred, BadAlloc>);
// (from_range, range, buckets, alloc)
//
// Can deduce from (from_range, range, buckets, alloc)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Alloc>);
// Cannot deduce from (from_range, BAD_range, buckets, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Alloc>);
// Note: (from_range, range, buckets, BAD_alloc) is interpreted as (from_range, range, buckets, hash), which is valid
// because the only requirement for the hash parameter is that it's not integral.
// (from_range, range, alloc)
//
// Can deduce from (from_range, range, alloc)
// TODO(LWG 2713): uncomment this test once the constructor is added.
// static_assert(!SFINAEs_away<Container, std::from_range_t, Range, Alloc>);
// Cannot deduce from (from_range, BAD_range, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, Alloc>);
// Cannot deduce from (from_range, range, BAD_alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, Range, BadAlloc>);
// (from_range, range, buckets, hash, alloc)
//
// Can deduce from (from_range, range, buckets, hash, alloc)
static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash, Alloc>);
// Cannot deduce from (from_range, BAD_range, buckets, hash, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Hash, Alloc>);
// Cannot deduce from (from_range, range, buckets, BAD_hash, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, BadHash, Alloc>);
// Cannot deduce from (from_range, range, buckets, ALLOC_as_hash, alloc)
static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, AllocAsHash, Alloc>);
// Cannot deduce from (from_range, range, buckets, hash, BAD_alloc)
// Note: (from_range, range, buckets, hash, BAD_alloc) is interpreted as (from_range, range, buckets, hash, pred),
// which is valid because the only requirement for the predicate parameter is that it does not resemble an allocator.
#endif
}
#endif // TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H
Codebase Browser
llvm