514 lines · c
1//===----------------------------------------------------------------------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#ifndef TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H10#define TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H11 12#include <cstddef>13#include <functional>14#include <initializer_list>15#include <iterator>16#include <memory>17#include <type_traits>18#include <utility>19#include <vector>20 21#include "test_macros.h"22#if TEST_STD_VER >= 2323#include "almost_satisfies_types.h"24#endif25 26#if TEST_STD_VER >= 2327 28template <class T>29struct RangeT {30 T* begin();31 T* end();32};33static_assert(std::ranges::input_range<RangeT<int>>);34 35template <class T>36using BadRangeT = InputRangeNotDerivedFromGeneric<T>;37static_assert(std::ranges::range<BadRangeT<int>>);38static_assert(!std::ranges::input_range<BadRangeT<int>>);39 40#endif41 42// `SFINAEs_away` template variable checks whether the template arguments for43// a given template class `Instantiated` can be deduced from the given44// constructor parameter types `CtrArgs` using CTAD.45 46template<template<typename ...> class Instantiated, class ...CtrArgs,47 class = decltype(Instantiated(std::declval<CtrArgs>()...))>48std::false_type SFINAEs_away_impl(int);49 50template<template<typename ...> class Instantiated, class ...CtrArgs>51std::true_type SFINAEs_away_impl(...);52 53template<template<typename ...> class Instantiated, class ...CtrArgs>54constexpr bool SFINAEs_away =55 decltype(SFINAEs_away_impl<Instantiated, CtrArgs...>(0))::value;56 57struct Empty {};58 59// For sequence containers the deduction guides should be SFINAE'd away when60// given:61// - "bad" input iterators (that is, a type not qualifying as an input62// iterator);63// - a bad allocator;64// - a range not satisfying the `input_range` concept.65template<template<typename ...> class Container, typename InstantiatedContainer, typename BadAlloc = Empty>66constexpr void SequenceContainerDeductionGuidesSfinaeAway() {67 using T = typename InstantiatedContainer::value_type;68 using Alloc = std::allocator<T>;69 using Iter = T*;70 71 // Note: the only requirement in the Standard is that integral types cannot be72 // considered input iterators; however, this doesn't work for sequence73 // containers because they have constructors of the form `(size_type count,74 // const value_type& value)`. These constructors would be used when passing75 // two integral types and would deduce `value_type` to be an integral type.76#ifdef _LIBCPP_VERSION77 using OutputIter = std::insert_iterator<InstantiatedContainer>;78#endif // _LIBCPP_VERSION79 80 // (iter, iter)81 //82 // Cannot deduce from (BAD_iter, BAD_iter)83 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter>);84 85 // (iter, iter, alloc)86 //87 // Cannot deduce from (BAD_iter, BAD_iter, alloc)88 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, Alloc>);89 // Cannot deduce from (iter, iter, BAD_alloc)90 static_assert(SFINAEs_away<Container, Iter, Iter, BadAlloc>);91 92 // (alloc)93 //94 // Cannot deduce from (alloc)95 static_assert(SFINAEs_away<Container, Alloc>);96 97#if TEST_STD_VER >= 2398 using BadRange = BadRangeT<T>;99 100 // (from_range, range)101 //102 // Cannot deduce from (BAD_range)103 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);104 105 // (from_range, range, alloc)106 //107 // Cannot deduce from (range, BAD_alloc)108 static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);109#endif110}111 112// Deduction guides should be SFINAE'd away when given:113// - a "bad" allocator (that is, a type not qualifying as an allocator);114// - an allocator instead of a container;115// - an allocator and a container that uses a different allocator;116// - a range not satisfying the `input_range` concept.117template<template<typename ...> class Container, typename InstantiatedContainer>118constexpr void ContainerAdaptorDeductionGuidesSfinaeAway() {119 using T = typename InstantiatedContainer::value_type;120 using Alloc [[maybe_unused]] = std::allocator<T>;121 using Iter = T*;122 123 using BadIter [[maybe_unused]] = int;124 using BadAlloc = Empty;125 126 // (container) -- no constraints.127 128 // (container, alloc)129 //130 // Cannot deduce from (container, BAD_alloc)131 static_assert(SFINAEs_away<Container, std::vector<T>, BadAlloc>);132 133 // (iter, iter)134 //135 // Cannot deduce from (BAD_iter, BAD_iter)136 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, BadIter, BadIter>);137 138#if TEST_STD_VER >= 23139 using BadRange = BadRangeT<T>;140 141 // (iter, iter, alloc)142 //143 // Cannot deduce from (BAD_iter, BAD_iter, alloc)144 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, BadIter, BadIter, Alloc>);145 // Cannot deduce from (iter, iter, BAD_alloc)146 static_assert(SFINAEs_away<Container, Iter, Iter, BadAlloc>);147 148 // (from_range, range)149 //150 // Cannot deduce from (BAD_range)151 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);152 153 // (from_range, range, alloc)154 //155 // Cannot deduce from (range, BAD_alloc)156 static_assert(SFINAEs_away<Container, std::from_range_t, RangeT<int>, BadAlloc>);157#endif158}159 160// For associative containers the deduction guides should be SFINAE'd away when161// given:162// - "bad" input iterators (that is, a type not qualifying as an input163// iterator);164// - a bad allocator;165// - an allocator in place of a comparator;166// - a range not satisfying the `input_range` concept.167template<template<typename ...> class Container, typename InstantiatedContainer>168constexpr void AssociativeContainerDeductionGuidesSfinaeAway() {169 using ValueType = typename InstantiatedContainer::value_type;170 using Comp = std::less<int>;171 using Alloc = std::allocator<ValueType>;172 using Iter = ValueType*;173 using InitList = std::initializer_list<ValueType>;174 175 struct BadAlloc {};176 // The only requirement in the Standard is that integral types cannot be177 // considered input iterators, beyond that it is unspecified.178 using BadIter = int;179#ifdef _LIBCPP_VERSION180 using OutputIter = std::insert_iterator<InstantiatedContainer>;181#endif // _LIBCPP_VERSION182 using AllocAsComp = Alloc;183 184 // (iter, iter)185 //186 // Cannot deduce from (BAD_iter, BAD_iter)187 static_assert(SFINAEs_away<Container, BadIter, BadIter>);188 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter>);189 190 // (iter, iter, comp)191 //192 // Cannot deduce from (BAD_iter, BAD_iter, comp)193 static_assert(SFINAEs_away<Container, BadIter, BadIter, Comp>);194 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, Comp>);195 196 // (iter, iter, comp, alloc)197 //198 // Cannot deduce from (BAD_iter, BAD_iter, comp, alloc)199 static_assert(SFINAEs_away<Container, BadIter, BadIter, Comp, Alloc>);200 LIBCPP_STATIC_ASSERT(201 SFINAEs_away<Container, OutputIter, OutputIter, Comp, Alloc>);202 // Cannot deduce from (iter, iter, ALLOC_as_comp, alloc)203 static_assert(SFINAEs_away<Container, Iter, Iter, AllocAsComp, Alloc>);204 // Cannot deduce from (iter, iter, comp, BAD_alloc)205 static_assert(SFINAEs_away<Container, Iter, Iter, Comp, BadAlloc>);206 207 // (iter, iter, alloc)208 //209 // Cannot deduce from (BAD_iter, BAD_iter, alloc)210 static_assert(SFINAEs_away<Container, BadIter, BadIter, Alloc>);211 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, Alloc>);212 // Note: (iter, iter, BAD_alloc) is interpreted as (iter, iter, comp)213 // instead and fails upon instantiation. There is no requirement to SFINAE214 // away bad comparators.215 216 // (init_list, comp, alloc)217 //218 // Cannot deduce from (init_list, ALLOC_as_comp, alloc)219 static_assert(SFINAEs_away<Container, InitList, AllocAsComp, Alloc>);220 // Cannot deduce from (init_list, comp, BAD_alloc)221 static_assert(SFINAEs_away<Container, InitList, Comp, BadAlloc>);222 223 // (init_list, alloc)224 //225 // Note: (init_list, BAD_alloc) is interpreted as (init_list, comp) instead226 // and fails upon instantiation. There is no requirement to SFINAE away bad227 // comparators.228 229#if TEST_STD_VER >= 23230 using Range = RangeT<ValueType>;231 using BadRange = BadRangeT<ValueType>;232 233 // (from_range, range)234 //235 // Can deduce from (from_range, range)236 static_assert(!SFINAEs_away<Container, std::from_range_t, Range>);237 // Cannot deduce from (from_range, BAD_range)238 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);239 240 // (from_range, range, comp)241 //242 // Can deduce from (from_range, _range, comp)243 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, Comp>);244 // Cannot deduce from (from_range, BAD_range, comp)245 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, Comp>);246 247 // (from_range, range, comp, alloc)248 //249 // Can deduce from (from_range, range, comp, alloc)250 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, Comp, Alloc>);251 // Cannot deduce from (from_range, BAD_range, comp, alloc)252 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, Comp, Alloc>);253 // Cannot deduce from (from_range, range, comp, BAD_alloc)254 static_assert(SFINAEs_away<Container, std::from_range_t, Range, Comp, BadAlloc>);255 256 // (from_range, range, alloc)257 //258 // Can deduce from (from_range, range, alloc)259 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, Alloc>);260 // Cannot deduce from (from_range, BAD_range, alloc)261 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, Alloc>);262 // Note: (from_range, range, BAD_alloc) is interpreted as (from_range, range, comp) instead.263#endif264}265 266// For unordered containers the deduction guides should be SFINAE'd away when267// given:268// - "bad" input iterators (that is, a type not qualifying as an input269// iterator);270// - a bad allocator;271// - a bad hash functor (an integral type in place of a hash);272// - an allocator in place of a hash functor;273// - an allocator in place of a predicate;274// - a range not satisfying the `input_range` concept.275template<template<typename ...> class Container, typename InstantiatedContainer>276constexpr void UnorderedContainerDeductionGuidesSfinaeAway() {277 using ValueType = typename InstantiatedContainer::value_type;278 using Pred = std::equal_to<int>;279 using Hash = std::hash<int>;280 using Alloc = std::allocator<ValueType>;281 using Iter = ValueType*;282 using InitList = std::initializer_list<ValueType>;283 284 using BadHash = short;285 struct BadAlloc {};286 // The only requirement in the Standard is that integral types cannot be287 // considered input iterators, beyond that it is unspecified.288 using BadIter = int;289#ifdef _LIBCPP_VERSION290 using OutputIter = std::insert_iterator<InstantiatedContainer>;291#endif // _LIBCPP_VERSION292 using AllocAsHash = Alloc;293 using AllocAsPred = Alloc;294 295 // (iter, iter)296 //297 // Cannot deduce from (BAD_iter, BAD_iter)298 static_assert(SFINAEs_away<Container, BadIter, BadIter>);299 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter>);300 301 // (iter, iter, buckets)302 //303 // Cannot deduce from (BAD_iter, BAD_iter, buckets)304 static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t>);305 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, std::size_t>);306 307 // (iter, iter, buckets, hash)308 //309 // Cannot deduce from (BAD_iter, BAD_iter, buckets, hash)310 static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t, Hash>);311 LIBCPP_STATIC_ASSERT(312 SFINAEs_away<Container, OutputIter, OutputIter, std::size_t, Hash>);313 // Cannot deduce from (iter, iter, buckets, BAD_hash)314 static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, BadHash>);315 // Note: (iter, iter, buckets, ALLOC_as_hash) is allowed -- it just calls316 // (iter, iter, buckets, alloc)317 318 // (iter, iter, buckets, hash, pred)319 //320 // Cannot deduce from (BAD_iter, BAD_iter, buckets, hash, pred)321 static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t, Hash, Pred>);322 LIBCPP_STATIC_ASSERT(323 SFINAEs_away<Container, OutputIter, OutputIter, std::size_t, Hash, Pred>);324 // Cannot deduce from (iter, iter, buckets, BAD_hash, pred)325 static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, BadHash, Pred>);326 // Cannot deduce from (iter, iter, buckets, ALLOC_as_hash, pred)327 static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, AllocAsHash, Pred>);328 // Note: (iter, iter, buckets, hash, ALLOC_as_pred) is allowed -- it just329 // calls (iter, iter, buckets, hash, alloc)330 331 // (iter, iter, buckets, hash, pred, alloc)332 //333 // Cannot deduce from (BAD_iter, BAD_iter, buckets, hash, pred, alloc)334 static_assert(335 SFINAEs_away<Container, BadIter, BadIter, std::size_t, Hash, Pred, Alloc>);336 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter,337 std::size_t, Hash, Pred, Alloc>);338 // Cannot deduce from (iter, iter, buckets, BAD_hash, pred, alloc)339 static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, BadHash, Pred, Alloc>);340 // Cannot deduce from (iter, iter, buckets, ALLOC_as_hash, pred, alloc)341 static_assert(342 SFINAEs_away<Container, Iter, Iter, std::size_t, AllocAsHash, Pred, Alloc>);343 // Cannot deduce from (iter, iter, buckets, hash, ALLOC_as_pred, alloc)344 static_assert(345 SFINAEs_away<Container, Iter, Iter, std::size_t, Hash, AllocAsPred, Alloc>);346 // Cannot deduce from (iter, iter, buckets, hash, pred, BAD_alloc)347 static_assert(348 SFINAEs_away<Container, Iter, Iter, std::size_t, Hash, Pred, BadAlloc>);349 350 // (iter, iter, buckets, alloc)351 //352 // Cannot deduce from (BAD_iter, BAD_iter, buckets, alloc)353 static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t, Alloc>);354 LIBCPP_STATIC_ASSERT(355 SFINAEs_away<Container, OutputIter, OutputIter, std::size_t, Alloc>);356 // Note: (iter, iter, buckets, BAD_alloc) is interpreted as (iter, iter,357 // buckets, hash), which is valid because the only requirement for the hash358 // parameter is that it's not integral.359 360 // (iter, iter, alloc)361 //362 // Cannot deduce from (BAD_iter, BAD_iter, alloc)363 static_assert(SFINAEs_away<Container, BadIter, BadIter, Alloc>);364 LIBCPP_STATIC_ASSERT(SFINAEs_away<Container, OutputIter, OutputIter, Alloc>);365 // Cannot deduce from (iter, iter, BAD_alloc)366 static_assert(SFINAEs_away<Container, Iter, Iter, BadAlloc>);367 368 // (iter, iter, buckets, hash, alloc)369 //370 // Cannot deduce from (BAD_iter, BAD_iter, buckets, hash, alloc)371 static_assert(SFINAEs_away<Container, BadIter, BadIter, std::size_t, Hash, Alloc>);372 LIBCPP_STATIC_ASSERT(373 SFINAEs_away<Container, OutputIter, OutputIter, std::size_t, Hash, Alloc>);374 // Cannot deduce from (iter, iter, buckets, BAD_hash, alloc)375 static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, BadHash, Alloc>);376 // Cannot deduce from (iter, iter, buckets, ALLOC_as_hash, alloc)377 static_assert(SFINAEs_away<Container, Iter, Iter, std::size_t, AllocAsHash, Alloc>);378 // Note: (iter, iter, buckets, hash, BAD_alloc) is interpreted as (iter, iter,379 // buckets, hash, pred), which is valid because there are no requirements for380 // the predicate.381 382 // (init_list, buckets, hash)383 //384 // Cannot deduce from (init_list, buckets, BAD_hash)385 static_assert(SFINAEs_away<Container, InitList, std::size_t, BadHash>);386 // Note: (init_list, buckets, ALLOC_as_hash) is interpreted as (init_list,387 // buckets, alloc), which is valid.388 389 // (init_list, buckets, hash, pred)390 //391 // Cannot deduce from (init_list, buckets, BAD_hash, pred)392 static_assert(SFINAEs_away<Container, InitList, std::size_t, BadHash, Pred>);393 // Cannot deduce from (init_list, buckets, ALLOC_as_hash, pred)394 static_assert(SFINAEs_away<Container, InitList, std::size_t, AllocAsHash, Pred>);395 // Note: (init_list, buckets, hash, ALLOC_as_pred) is interpreted as396 // (init_list, buckets, hash, alloc), which is valid.397 398 // (init_list, buckets, hash, pred, alloc)399 //400 // Cannot deduce from (init_list, buckets, BAD_hash, pred, alloc)401 static_assert(402 SFINAEs_away<Container, InitList, std::size_t, BadHash, Pred, Alloc>);403 // Cannot deduce from (init_list, buckets, ALLOC_as_hash, pred, alloc)404 static_assert(405 SFINAEs_away<Container, InitList, std::size_t, AllocAsHash, Pred, Alloc>);406 // Cannot deduce from (init_list, buckets, hash, ALLOC_as_pred, alloc)407 static_assert(408 SFINAEs_away<Container, InitList, std::size_t, Hash, AllocAsPred, Alloc>);409 // Cannot deduce from (init_list, buckets, hash, pred, BAD_alloc)410 static_assert(411 SFINAEs_away<Container, InitList, std::size_t, Hash, Pred, BadAlloc>);412 413 // (init_list, buckets, alloc)414 //415 // Note: (init_list, buckets, BAD_alloc) is interpreted as (init_list,416 // buckets, hash), which is valid because the only requirement for the hash417 // parameter is that it's not integral.418 419 // (init_list, buckets, hash, alloc)420 //421 // Cannot deduce from (init_list, buckets, BAD_hash, alloc)422 static_assert(SFINAEs_away<Container, InitList, std::size_t, BadHash, Alloc>);423 // Cannot deduce from (init_list, buckets, ALLOC_as_hash, alloc)424 static_assert(SFINAEs_away<Container, InitList, std::size_t, AllocAsHash, Alloc>);425 426 // (init_list, alloc)427 //428 // Cannot deduce from (init_list, BAD_alloc)429 static_assert(SFINAEs_away<Container, InitList, BadAlloc>);430 431#if TEST_STD_VER >= 23432 using Range = RangeT<ValueType>;433 using BadRange = BadRangeT<ValueType>;434 435 // (from_range, range)436 //437 // Can deduce from (from_range, range)438 static_assert(!SFINAEs_away<Container, std::from_range_t, Range>);439 // Cannot deduce from (from_range, BAD_range)440 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange>);441 442 // (from_range, range, buckets)443 //444 // Can deduce from (from_range, range, buckets)445 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t>);446 // Cannot deduce from (from_range, BAD_range, buckets)447 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t>);448 449 // (from_range, range, buckets, hash)450 //451 // Can deduce from (from_range, range, buckets, hash)452 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash>);453 // Cannot deduce from (from_range, BAD_range, buckets, hash)454 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Hash>);455 // Cannot deduce from (from_range, range, buckets, BAD_hash)456 static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, BadHash>);457 458 // (from_range, range, buckets, hash, pred)459 //460 // Can deduce from (from_range, range, buckets, hash, pred)461 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash, Pred>);462 // Cannot deduce from (from_range, BAD_range, buckets, hash, pred)463 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Hash, Pred>);464 // Cannot deduce from (from_range, range, buckets, BAD_hash, pred)465 static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, BadHash, Pred>);466 467 // (from_range, range, buckets, hash, pred, alloc)468 //469 // Can deduce from (from_range, range, buckets, hash, pred, alloc)470 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash, Pred, Alloc>);471 // Cannot deduce from (from_range, BAD_range, buckets, hash, pred, alloc)472 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Hash, Pred, Alloc>);473 // Cannot deduce from (from_range, range, buckets, BAD_hash, pred, alloc)474 static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, BadHash, Pred, Alloc>);475 // Cannot deduce from (from_range, range, buckets, hash, pred, BAD_alloc)476 static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash, Pred, BadAlloc>);477 478 // (from_range, range, buckets, alloc)479 //480 // Can deduce from (from_range, range, buckets, alloc)481 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Alloc>);482 // Cannot deduce from (from_range, BAD_range, buckets, alloc)483 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Alloc>);484 // Note: (from_range, range, buckets, BAD_alloc) is interpreted as (from_range, range, buckets, hash), which is valid485 // because the only requirement for the hash parameter is that it's not integral.486 487 // (from_range, range, alloc)488 //489 // Can deduce from (from_range, range, alloc)490 // TODO(LWG 2713): uncomment this test once the constructor is added.491 // static_assert(!SFINAEs_away<Container, std::from_range_t, Range, Alloc>);492 // Cannot deduce from (from_range, BAD_range, alloc)493 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, Alloc>);494 // Cannot deduce from (from_range, range, BAD_alloc)495 static_assert(SFINAEs_away<Container, std::from_range_t, Range, BadAlloc>);496 497 // (from_range, range, buckets, hash, alloc)498 //499 // Can deduce from (from_range, range, buckets, hash, alloc)500 static_assert(!SFINAEs_away<Container, std::from_range_t, Range, std::size_t, Hash, Alloc>);501 // Cannot deduce from (from_range, BAD_range, buckets, hash, alloc)502 static_assert(SFINAEs_away<Container, std::from_range_t, BadRange, std::size_t, Hash, Alloc>);503 // Cannot deduce from (from_range, range, buckets, BAD_hash, alloc)504 static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, BadHash, Alloc>);505 // Cannot deduce from (from_range, range, buckets, ALLOC_as_hash, alloc)506 static_assert(SFINAEs_away<Container, std::from_range_t, Range, std::size_t, AllocAsHash, Alloc>);507 // Cannot deduce from (from_range, range, buckets, hash, BAD_alloc)508 // Note: (from_range, range, buckets, hash, BAD_alloc) is interpreted as (from_range, range, buckets, hash, pred),509 // which is valid because the only requirement for the predicate parameter is that it does not resemble an allocator.510#endif511}512 513#endif // TEST_SUPPORT_DEDUCTION_GUIDES_SFINAE_CHECKS_H514