Skip to content

Commit 713dd95

Browse files
StephanTLavavejStephanTLavavej
authored
Various cleanups (#5336)
1 parent 3030afb commit 713dd95

File tree

22 files changed

+65
-73
lines changed

22 files changed

+65
-73
lines changed

‎stl/inc/algorithm

+2
Original file line numberDiff line numberDiff line change
@@ -7477,11 +7477,13 @@ _NODISCARD constexpr auto _Idl_dist_add(_Diff1 _Lhs, _Diff2 _Rhs) {
74777477
return ranges::_Distance_unbounded{};
74787478
} else
74797479
#endif // _HAS_CXX20
7480+
{
74807481
if constexpr (is_same_v<_Diff1, _Distance_unknown> || is_same_v<_Diff2, _Distance_unknown>) {
74817482
return _Distance_unknown{};
74827483
} else {
74837484
return _Lhs + _Rhs;
74847485
}
7486+
}
74857487
}
74867488

74877489
_EXPORT_STD template <class _InIt1, class _InIt2, class _OutIt, class _Pr>

‎stl/inc/atomic

+1-1
Original file line numberDiff line numberDiff line change
@@ -203,7 +203,7 @@ extern "C" inline void _Atomic_thread_fence(const unsigned int _Order) noexcept
203203
if (_Order == _Atomic_memory_order_seq_cst) {
204204
volatile long _Guard; // Not initialized to avoid an unnecessary operation; the value does not matter
205205

206-
// _mm_mfence could have been used, but it is not supported on older x86 CPUs and is slower on some recent CPUs.
206+
// _mm_mfence could have been used, but it is slower on some CPUs.
207207
// The memory fence provided by interlocked operations has some exceptions, but this is fine:
208208
// std::atomic_thread_fence works with respect to other atomics only; it may not be a full fence for all ops.
209209
(void) _InterlockedIncrement(&_Guard);

‎stl/inc/bitset

+1-1
Original file line numberDiff line numberDiff line change
@@ -666,7 +666,7 @@ basic_istream<_Elem, _Tr>& operator>>(basic_istream<_Elem, _Tr>& _Istr, bitset<_
666666
}
667667

668668
_Istr.setstate(_State);
669-
_Right = bitset<_Bits>(_Buf._Buf, _Count); // convert string and store
669+
_Right = bitset<_Bits>{_Buf._Buf, _Count}; // convert string and store
670670
return _Istr;
671671
}
672672

‎stl/inc/chrono

+2-2
Original file line numberDiff line numberDiff line change
@@ -1849,7 +1849,7 @@ namespace chrono {
18491849
// time zone name. In vNext, this should be a dedicated argument.
18501850
const string _Tz_arg = _Name + static_cast<char>(_Type);
18511851

1852-
const auto _Tz_len = _Name.length();
1852+
const auto _Tz_len = _Name.size();
18531853

18541854
const auto _Info =
18551855
_Make_unique_tzdb_info<__std_tzdb_get_sys_info>(_Tz_arg.c_str(), _Tz_len, _Internal_dur.count());
@@ -3493,7 +3493,7 @@ namespace chrono {
34933493

34943494
return ratio_less_equal_v<_Period1, _Period2>
34953495
&& ratio_greater_equal_v<ratio<_Max_tick, _Period2::num>, ratio_divide<ratio<1>, _Period1>>;
3496-
} else if (is_floating_point_v<_Rep1>) {
3496+
} else if constexpr (is_floating_point_v<_Rep1>) {
34973497
// With the smallest possible _Period1, ratio<1,INTMAX_MAX>, one day has a tick count of
34983498
// 86,400*INTMAX_MAX ~= 7.97e23. This is representable by float and double, so they can always represent
34993499
// at least one day. On the other hand, one second with the largest possible _Period1 needs a tick count

‎stl/inc/format

+1-1
Original file line numberDiff line numberDiff line change
@@ -3545,7 +3545,7 @@ _NODISCARD _FormatContext::iterator _Tuple_formatter_format(const tuple<formatte
35453545

35463546
const int _Width = _STD _Measure_display_width<_CharT>(_Tmp_str);
35473547
return _STD _Write_aligned(
3548-
_Fmt_ctx.out(), _Width, _Format_specs, _Fmt_align::_Left, [&](typename _FormatContext::iterator _Out) {
3548+
_Fmt_ctx.out(), _Width, _Format_specs, _Fmt_align::_Left, [&](_FormatContext::iterator _Out) {
35493549
return _STD _Fmt_write(_STD move(_Out), basic_string_view<_CharT>{_Tmp_str});
35503550
});
35513551
}

‎stl/inc/functional

+2-2
Original file line numberDiff line numberDiff line change
@@ -2132,15 +2132,15 @@ template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _Un
21322132
concept _Can_call_binder = requires(_CvFD& _Fx, _CvBoundTuple& _Bound_tuple, _UnboundTuple&& _Unbound_tuple) {
21332133
_STD _Call_binder(_Invoker_ret<_Ret>{}, _IntSeq{}, _Fx, _Bound_tuple, _STD move(_Unbound_tuple));
21342134
};
2135-
#else // ^^^ concept available / concept unavailable vvv
2135+
#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
21362136
template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _UnboundTuple, class = void>
21372137
constexpr bool _Can_call_binder = false;
21382138

21392139
template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _UnboundTuple>
21402140
constexpr bool _Can_call_binder<_Ret, _CvFD, _IntSeq, _CvBoundTuple, _UnboundTuple,
21412141
void_t<decltype(_STD _Call_binder(_Invoker_ret<_Ret>{}, _IntSeq{}, _STD declval<_CvFD&>(),
21422142
_STD declval<_CvBoundTuple&>(), _STD declval<_UnboundTuple>()))>> = true;
2143-
#endif // ^^^ concept unavailable ^^^
2143+
#endif // ^^^ !_HAS_CXX20 ^^^
21442144

21452145
template <class _Ret>
21462146
struct _Forced_result_type { // used by bind<R>()

‎stl/inc/future

+8-5
Original file line numberDiff line numberDiff line change
@@ -474,14 +474,17 @@ struct _P_arg_type<void> { // type for functions returning void
474474
using type = int;
475475
};
476476

477+
template <class _Ret>
478+
using _P_arg_type_t = typename _P_arg_type<_Ret>::type;
479+
477480
template <class>
478481
class _Packaged_state;
479482

480483
// class for managing associated asynchronous state for packaged_task
481484
template <class _Ret, class... _ArgTypes>
482-
class _Packaged_state<_Ret(_ArgTypes...)> : public _Associated_state<typename _P_arg_type<_Ret>::type> {
485+
class _Packaged_state<_Ret(_ArgTypes...)> : public _Associated_state<_P_arg_type_t<_Ret>> {
483486
public:
484-
using _Mybase = _Associated_state<typename _P_arg_type<_Ret>::type>;
487+
using _Mybase = _Associated_state<_P_arg_type_t<_Ret>>;
485488
using _Mydel = typename _Mybase::_Mydel;
486489
using _Function_type = function<_Ret(_ArgTypes...)>; // TRANSITION, ABI, should not use std::function
487490

@@ -1197,7 +1200,7 @@ template <class _Ret, class... _ArgTypes>
11971200
class packaged_task<_Ret(_ArgTypes...)> {
11981201
// class that defines an asynchronous provider that returns the result of a call to a function object
11991202
private:
1200-
using _Ptype = typename _P_arg_type<_Ret>::type;
1203+
using _Ptype = _P_arg_type_t<_Ret>;
12011204
using _MyPromiseType = _Promise<_Ptype>;
12021205
using _MyStateManagerType = _State_manager<_Ptype>;
12031206
using _MyStateType = _Packaged_state<_Ret(_ArgTypes...)>;
@@ -1344,7 +1347,7 @@ private:
13441347
};
13451348

13461349
template <class _Ret, class _Fty>
1347-
_Associated_state<typename _P_arg_type<_Ret>::type>* _Get_associated_state(launch _Psync, _Fty&& _Fnarg) {
1350+
_Associated_state<_P_arg_type_t<_Ret>>* _Get_associated_state(launch _Psync, _Fty&& _Fnarg) {
13481351
// construct associated asynchronous state object for the launch type
13491352
switch (_Psync) { // select launch type
13501353
case launch::deferred:
@@ -1360,7 +1363,7 @@ _NODISCARD_ASYNC future<_Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>>
13601363
launch _Policy, _Fty&& _Fnarg, _ArgTypes&&... _Args) {
13611364
// manages a callable object launched with supplied policy
13621365
using _Ret = _Invoke_result_t<decay_t<_Fty>, decay_t<_ArgTypes>...>;
1363-
using _Ptype = typename _P_arg_type<_Ret>::type;
1366+
using _Ptype = _P_arg_type_t<_Ret>;
13641367
_Promise<_Ptype> _Pr(
13651368
_Get_associated_state<_Ret>(_Policy, _Fake_no_copy_callable_adapter<_Fty, _ArgTypes...>(
13661369
_STD forward<_Fty>(_Fnarg), _STD forward<_ArgTypes>(_Args)...)));

‎stl/inc/random

+30-33
Original file line numberDiff line numberDiff line change
@@ -402,7 +402,7 @@ bool _Nrand_for_tr1(
402402
}
403403

404404
template <class _Gen, class = void>
405-
struct _Has_static_min_max : false_type {};
405+
struct _Has_static_min_max : false_type {}; // TRANSITION, VSO-2417491: Should be a variable template
406406

407407
// This checks a requirement of N4981 [rand.req.urng] `concept uniform_random_bit_generator` but doesn't attempt
408408
// to implement the whole concept - we just need to distinguish Standard machinery from tr1 machinery.
@@ -461,8 +461,6 @@ _NODISCARD _Real _Nrand_impl(_Gen& _Gx) { // build a floating-point value from r
461461
}
462462
}
463463

464-
#define _NRAND(eng, resty) (_Nrand_impl<resty>(eng))
465-
466464
_INLINE_VAR constexpr int _MP_len = 5;
467465
using _MP_arr = uint64_t[_MP_len];
468466

@@ -2546,7 +2544,7 @@ public:
25462544
private:
25472545
template <class _Engine>
25482546
result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
2549-
return _NRAND(_Eng, double) < _Par0._Px;
2547+
return _Nrand_impl<double>(_Eng) < _Par0._Px;
25502548
}
25512549

25522550
param_type _Par;
@@ -2713,7 +2711,7 @@ private:
27132711

27142712
_Ty1 _Val;
27152713
do {
2716-
_Val = _CSTD log(_NRAND(_Eng, _Ty1)) / _Par0._Log_1_p;
2714+
_Val = _CSTD log(_Nrand_impl<_Ty1>(_Eng)) / _Par0._Log_1_p;
27172715
} while (_Val >= _Ty1_max);
27182716
return static_cast<_Ty>(_Val);
27192717
}
@@ -2730,7 +2728,7 @@ public:
27302728
_NODISCARD _Ty operator()(_Engine& _Eng) const {
27312729
_Ty1 _Val = 1.0;
27322730
for (_Ty _Res = 0;; ++_Res) { // count repetitions
2733-
_Val *= _NRAND(_Eng, _Ty1);
2731+
_Val *= _Nrand_impl<_Ty1>(_Eng);
27342732
if (_Val <= _Gx0) {
27352733
return _Res;
27362734
}
@@ -2882,15 +2880,15 @@ private:
28822880
_Ty _Res;
28832881
_Ty1 _Yx;
28842882
for (;;) { // generate a tentative value
2885-
_Yx = static_cast<_Ty1>(_CSTD tan(_Pi_val * _NRAND(_Eng, _Ty1)));
2883+
_Yx = static_cast<_Ty1>(_CSTD tan(_Pi_val * _Nrand_impl<_Ty1>(_Eng)));
28862884
const _Ty1 _Mx{_Par0._Sqrt * _Yx + _Par0._Mean};
28872885
if (0.0 <= _Mx && _Mx < _Ty1_max) {
28882886
_Res = static_cast<_Ty>(_Mx);
28892887
break;
28902888
}
28912889
}
28922890

2893-
if (_NRAND(_Eng, _Ty1)
2891+
if (_Nrand_impl<_Ty1>(_Eng)
28942892
<= 0.9 * (1.0 + _Yx * _Yx) * _CSTD exp(_Res * _Par0._Logm - _XLgamma(_Res + 1.0) - _Par0._Gx1)) {
28952893
return _Res;
28962894
}
@@ -3050,15 +3048,15 @@ private:
30503048
if (_Par0._Tx < 25) { // generate directly
30513049
_Res = 0;
30523050
for (_Ty _Ix = 0; _Ix < _Par0._Tx; ++_Ix) {
3053-
if (_NRAND(_Eng, _Ty1) < _Par0._Px) {
3051+
if (_Nrand_impl<_Ty1>(_Eng) < _Par0._Px) {
30543052
++_Res;
30553053
}
30563054
}
30573055

30583056
return _Res;
30593057
} else if (_Par0._Mean < 1.0) {
30603058
// Events are rare, use waiting time method (Luc Devroye, Non-Uniform Random Variate Generation, p. 525).
3061-
const _Ty1 _Rand = _NRAND(_Eng, _Ty1);
3059+
const _Ty1 _Rand = _Nrand_impl<_Ty1>(_Eng);
30623060

30633061
// The exit condition is log(1 - _Rand)/t < log(1-p), which is equivalent to _Rand > 1 - (1-p)^t. If
30643062
// we have a cheap upper bound for 1-(1-p)^t, we can exit early without having to call log. We use two
@@ -3073,7 +3071,7 @@ private:
30733071
_Ty _Denom = _Par0._Tx;
30743072
_Ty1 _Sum = _CSTD log(_Ty1{1.0} - _Rand) / _Denom;
30753073
while (_Sum >= _Par0._Logp1 && --_Denom != 0) {
3076-
_Sum += _CSTD log(_Ty1{1.0} - _NRAND(_Eng, _Ty1)) / _Denom;
3074+
_Sum += _CSTD log(_Ty1{1.0} - _Nrand_impl<_Ty1>(_Eng)) / _Denom;
30773075
}
30783076
_Res = static_cast<_Ty>(_Par0._Tx - _Denom);
30793077
}
@@ -3084,14 +3082,14 @@ private:
30843082
for (;;) { // generate and reject
30853083
_Ty1 _Yx;
30863084
for (;;) { // generate a tentative value
3087-
_Yx = static_cast<_Ty1>(_CSTD tan(_Pi_val * _NRAND(_Eng, _Ty1)));
3085+
_Yx = static_cast<_Ty1>(_CSTD tan(_Pi_val * _Nrand_impl<_Ty1>(_Eng)));
30883086
const _Ty1 _Mx{_Par0._Sqrt * _Yx + _Par0._Mean};
30893087
if (0.0 <= _Mx && _Mx < _Ty1_Tx) {
30903088
_Res = static_cast<_Ty>(_Mx);
30913089
break;
30923090
}
30933091
}
3094-
if (_NRAND(_Eng, _Ty1)
3092+
if (_Nrand_impl<_Ty1>(_Eng)
30953093
<= 1.2 * _Par0._Sqrt * (1.0 + _Yx * _Yx)
30963094
* _CSTD exp(_Par0._Gx1 - _XLgamma(_Res + 1.0) - _XLgamma(_Par0._Tx - _Res + 1.0)
30973095
+ _Res * _Par0._Logp + (_Par0._Tx - _Res) * _Par0._Logp1)) {
@@ -3226,7 +3224,7 @@ public:
32263224
private:
32273225
template <class _Engine>
32283226
result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
3229-
return _NRAND(_Eng, _Ty) * (_Par0._Max - _Par0._Min) + _Par0._Min;
3227+
return _Nrand_impl<_Ty>(_Eng) * (_Par0._Max - _Par0._Min) + _Par0._Min;
32303228
}
32313229

32323230
param_type _Par;
@@ -3439,7 +3437,7 @@ public:
34393437
private:
34403438
template <class _Engine>
34413439
result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
3442-
return -_CSTD log(_Ty{1} - _NRAND(_Eng, _Ty)) / _Par0._Lambda;
3440+
return -_CSTD log(_Ty{1} - _Nrand_impl<_Ty>(_Eng)) / _Par0._Lambda;
34433441
}
34443442

34453443
param_type _Par;
@@ -3600,8 +3598,8 @@ private:
36003598
_Ty _Vx2;
36013599
_Ty _Sx;
36023600
for (;;) { // reject bad values to avoid generating NaN/Inf on the next calculations
3603-
_Vx1 = 2 * _NRAND(_Eng, _Ty) - 1;
3604-
_Vx2 = 2 * _NRAND(_Eng, _Ty) - 1;
3601+
_Vx1 = 2 * _Nrand_impl<_Ty>(_Eng) - 1;
3602+
_Vx2 = 2 * _Nrand_impl<_Ty>(_Eng) - 1;
36053603
_Sx = _Vx1 * _Vx1 + _Vx2 * _Vx2;
36063604
if (_Sx < _Ty{1} && _Vx1 != _Ty{0} && _Vx2 != _Ty{0}) {
36073605
// good values!
@@ -3779,9 +3777,9 @@ private:
37793777
if (_Par0._Alpha < 1) { // small values of alpha
37803778
// from Knuth
37813779
for (;;) { // generate and reject
3782-
_Ux = _NRAND(_Eng, _Ty);
3780+
_Ux = _Nrand_impl<_Ty>(_Eng);
37833781
do {
3784-
_Vx = _NRAND(_Eng, _Ty);
3782+
_Vx = _Nrand_impl<_Ty>(_Eng);
37853783
} while (_Vx == 0);
37863784

37873785
if (_Ux < _Par0._Px) { // small _Ux
@@ -3792,7 +3790,7 @@ private:
37923790
_Qx = _CSTD pow(_Xx, _Par0._Alpha - 1);
37933791
}
37943792

3795-
if (_NRAND(_Eng, _Ty) < _Qx) {
3793+
if (_Nrand_impl<_Ty>(_Eng) < _Qx) {
37963794
return _Par0._Beta * _Xx;
37973795
}
37983796
}
@@ -3804,10 +3802,10 @@ private:
38043802

38053803
if (_Par0._Alpha < 20.0 && (_Count = static_cast<int>(_Par0._Alpha)) == _Par0._Alpha) {
38063804
// _Alpha is small integer, compute directly
3807-
_Yx = _NRAND(_Eng, _Ty);
3805+
_Yx = _Nrand_impl<_Ty>(_Eng);
38083806
while (--_Count) { // adjust result
38093807
do {
3810-
_Ux = _NRAND(_Eng, _Ty);
3808+
_Ux = _Nrand_impl<_Ty>(_Eng);
38113809
} while (_Ux == 0);
38123810

38133811
_Yx *= _Ux;
@@ -3817,12 +3815,12 @@ private:
38173815

38183816
// no shortcuts
38193817
for (;;) { // generate and reject
3820-
_Yx = static_cast<_Ty>(_CSTD tan(_Pi_val * _NRAND(_Eng, _Ty)));
3818+
_Yx = static_cast<_Ty>(_CSTD tan(_Pi_val * _Nrand_impl<_Ty>(_Eng)));
38213819
_Xx = _Par0._Sqrt * _Yx + _Par0._Alpha - 1;
38223820
if (0 < _Xx
3823-
&& _NRAND(_Eng, _Ty) <= (1 + _Yx * _Yx)
3824-
* _CSTD exp((_Par0._Alpha - 1) * _CSTD log(_Xx / (_Par0._Alpha - 1))
3825-
- _Par0._Sqrt * _Yx)) {
3821+
&& _Nrand_impl<_Ty>(_Eng) <= (1 + _Yx * _Yx)
3822+
* _CSTD exp((_Par0._Alpha - 1) * _CSTD log(_Xx / (_Par0._Alpha - 1))
3823+
- _Par0._Sqrt * _Yx)) {
38263824
return _Par0._Beta * _Xx;
38273825
}
38283826
}
@@ -3959,7 +3957,7 @@ public:
39593957
private:
39603958
template <class _Engine>
39613959
result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { // generate pseudo-random value
3962-
_Ty _Px = (_Ty{1} - _NRAND(_Eng, _Ty));
3960+
_Ty _Px = (_Ty{1} - _Nrand_impl<_Ty>(_Eng));
39633961
return _Par0._Bx * _CSTD pow(-_CSTD log(_Px), _Ty{1} / _Par0._Ax);
39643962
}
39653963

@@ -4093,7 +4091,7 @@ public:
40934091
private:
40944092
template <class _Engine>
40954093
result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { // generate pseudo-random value
4096-
_Ty _Px = _NRAND(_Eng, _Ty);
4094+
_Ty _Px = _Nrand_impl<_Ty>(_Eng);
40974095
return _Par0._Ax - _Par0._Bx * _CSTD log(-_CSTD log(_Px));
40984096
}
40994097

@@ -4481,7 +4479,7 @@ public:
44814479
private:
44824480
template <class _Engine>
44834481
result_type _Eval(_Engine& _Eng, const param_type& _Par0) const { // generate pseudo-random value
4484-
_Ty Px = _NRAND(_Eng, _Ty);
4482+
_Ty Px = _Nrand_impl<_Ty>(_Eng);
44854483
return static_cast<_Ty>(_Par0._Ax + _Par0._Bx * _CSTD tan(_Pi_val * (Px - static_cast<_Ty>(0.5))));
44864484
}
44874485

@@ -4504,8 +4502,8 @@ public:
45044502
_Ty _Px1;
45054503
_Ty _Px2;
45064504
for (;;) { // reject large values
4507-
_Px1 = _NRAND(_Eng, _Ty);
4508-
_Px2 = _NRAND(_Eng, _Ty);
4505+
_Px1 = _Nrand_impl<_Ty>(_Eng);
4506+
_Px2 = _Nrand_impl<_Ty>(_Eng);
45094507
_Px1 = _CSTD pow(_Px1, _Ty{1} / _Ax);
45104508
_Px2 = _CSTD pow(_Px2, _Ty{1} / _Bx);
45114509
_Wx = _Px1 + _Px2;
@@ -5153,7 +5151,7 @@ public:
51535151
private:
51545152
template <class _Engine>
51555153
result_type _Eval(_Engine& _Eng, const param_type& _Par0) const {
5156-
double _Px = _NRAND(_Eng, double);
5154+
double _Px = _Nrand_impl<double>(_Eng);
51575155
const auto _First = _Par0._Pcdf.begin();
51585156
const auto _Position = _STD lower_bound(_First, _Prev_iter(_Par0._Pcdf.end()), _Px);
51595157
return static_cast<result_type>(_Position - _First);
@@ -5706,7 +5704,6 @@ _STL_RESTORE_DEPRECATED_WARNING
57065704
#endif // _HAS_TR1_NAMESPACE
57075705
_STD_END
57085706

5709-
#undef _NRAND
57105707
#undef _DISTRIBUTION_CONST
57115708

57125709
// TRANSITION, GH-183

‎stl/inc/regex

+1-1
Original file line numberDiff line numberDiff line change
@@ -533,7 +533,7 @@ private:
533533
inline bool _Is_word(unsigned char _UCh) {
534534
// special casing char to avoid branches for std::regex in this path
535535
static constexpr bool _Is_word_table[_STD _Max_limit<unsigned char>() + 1] = {
536-
// X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 XA XB XC XD XE XF
536+
// X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 XA XB XC XD XE XF
537537
/* 0X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
538538
/* 1X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
539539
/* 2X */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

‎stl/inc/variant

+1-1
Original file line numberDiff line numberDiff line change
@@ -899,7 +899,7 @@ struct _Variant_init_overload_set_<index_sequence<_Indices...>, _Types...>
899899
template <class... _Types>
900900
using _Variant_init_overload_set = _Variant_init_overload_set_<index_sequence_for<_Types...>, _Types...>;
901901

902-
template <class Enable, class _Ty, class... _Types>
902+
template <class _Enable, class _Ty, class... _Types>
903903
struct _Variant_init_helper {}; // failure case (has no member "type")
904904

905905
template <class _Ty, class... _Types>

0 commit comments

Comments
 (0)