1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
// RUN: %clang_cc1 -std=c++2c -verify=expected,both %s -fexperimental-new-constant-interpreter
// RUN: %clang_cc1 -std=c++2c -verify=ref,both %s
template <int __v> struct integral_constant {
static const int value = __v;
};
template <bool _Val> using _BoolConstant = integral_constant<_Val>;
template <class _From, class _To>
constexpr bool is_convertible_v = __is_convertible(_From, _To);
template <class _Tp> _Tp __declval(int);
template <class _Tp> decltype(__declval<_Tp>(0)) declval();
template <class _Tp, class _Up>
using _IsSame = _BoolConstant<__is_same(_Tp, _Up)>;
template <class _If> struct conditional {
using type = _If;
};
template <bool, class _IfRes, class>
using conditional_t = conditional<_IfRes>::type;
template <class _Tp, class>
concept __weakly_equality_comparable_with = requires(_Tp __t) { __t; };
template <bool, class _Tp = void> using __enable_if_t = _Tp;
template <template <class> class, class>
integral_constant<true> __sfinae_test_impl(int);
template <template <class> class _Templ, class... _Args>
using _IsValidExpansion = decltype(__sfinae_test_impl<_Templ, _Args...>(0));
template <class _Tp>
using __test_for_primary_template =
__enable_if_t<_IsSame<_Tp, typename _Tp::__primary_template>::value>;
template <class _Tp>
using __is_primary_template =
_IsValidExpansion<__test_for_primary_template, _Tp>;
template <class _Ip>
using iter_difference_t =
conditional_t<__is_primary_template<_Ip>::value, _Ip, _Ip>::difference_type;
template <int> struct _OrImpl {
template <class, class _First>
using _Result = _OrImpl<!_First::value>::template _Result<_First>;
};
template <> struct _OrImpl<false> {
template <class _Res> using _Result = _Res;
};
template <class... _Args>
using _Or = _OrImpl<sizeof...(_Args)>::template _Result<_Args...>;
struct input_iterator_tag {};
template <class _Dp, class _Bp>
concept derived_from = is_convertible_v<_Dp, _Bp>;
template <class _Ip>
concept input_or_output_iterator = requires(_Ip __i) { __i; };
template <class _Sp, class _Ip>
concept sentinel_for = __weakly_equality_comparable_with<_Sp, _Ip>;
struct __iter_concept_category_test {
template <class> using _Apply = input_iterator_tag;
};
struct __test_iter_concept
: _IsValidExpansion<__iter_concept_category_test::_Apply, int>,
__iter_concept_category_test {};
struct __iter_concept_cache {
using type = _Or<int, __test_iter_concept>;
};
template <class _Iter>
using _ITER_CONCEPT = __iter_concept_cache::type::_Apply<_Iter>;
template <class _Ip>
concept input_iterator = derived_from<_ITER_CONCEPT<_Ip>, input_iterator_tag>;
template <class _T1, class _T2> struct pair {
_T1 first;
_T2 second;
};
struct {
template <class _Tp> auto operator()(_Tp __t) { return __t.begin(); }
} begin;
template <class _Tp> using iterator_t = decltype(begin(declval<_Tp>()));
template <class _Tp>
concept __member_size = requires(_Tp __t) { __t; };
struct {
template <__member_size _Tp> constexpr void operator()(_Tp &&__t) {
__t.size(); // both-note 2{{in instantiation}}
}
} size;
template <class _Tp>
concept range = requires(_Tp __t) { __t; };
template <class _Tp>
concept input_range = input_iterator<_Tp>;
template <range _Rp>
using range_difference_t = iter_difference_t<iterator_t<_Rp>>;
struct {
template <range _Rp> constexpr range_difference_t<_Rp> operator()(_Rp &&__r) {
size(__r); // both-note 2{{in instantiation}}
} // both-warning {{does not return a value}}
} distance;
template <input_or_output_iterator _Iter, sentinel_for<_Iter> _Sent>
struct subrange {
_Iter __begin_;
_Sent __end_;
_Iter begin();
constexpr _Iter size() { __end_ - __begin_; } // both-warning {{does not return a value}} \
// both-note {{in instantiation}}
};
struct {
template <input_range _Range1, input_range _Range2>
void operator()(_Range1 &&__range1, _Range2) {
(void)(distance(__range1) != 0); // both-note 3{{in instantiation}}
}
} equal;
template <class _Owner> struct __key_value_iterator {
using difference_type = _Owner::difference_type;
constexpr friend difference_type operator-(__key_value_iterator,
__key_value_iterator &) {} // both-warning {{does not return a value}}
};
struct flat_multimap {
template <bool> using __iterator = __key_value_iterator<flat_multimap>;
using difference_type =
decltype(static_cast<int *>(nullptr) - static_cast<int *>(nullptr));
pair<__iterator<true>, __iterator<true>> equal_range(const char *);
} test_expected_range;
void test() {
flat_multimap m;
auto test_found = [](auto map, auto expected_key, int) {
auto [first, last] = map.equal_range(expected_key);
equal(subrange(first, last), test_expected_range); // both-note 3{{in instantiation}}
};
test_found(m, "", {});
}
|
