Граф коммитов

194 Коммитов

Автор SHA1 Сообщение Дата
Pavol Misik 10a227676c yvals_core.h: Require _MSC_VER 1925 (#430)
Fixes #422.
2020-01-24 12:07:11 -08:00
Pavol Misik 6f39aad760 Update _MSVC_STL_UPDATE value to January 2020 (#429)
Fixes #409.
2020-01-24 12:05:18 -08:00
Michael Schellenberger Costa 0e336ac737 P0935R0 Eradicating Unnecessarily Explicit Default Constructors (#415)
Fixes #41.
2020-01-24 12:01:10 -08:00
Daniil Goncharov b73a0b19a2 <complex> fix pow overload (#383)
Fixes #325.
2020-01-24 11:58:29 -08:00
Adam Bucior a46d897ac0 Finish Fixing Atomic Initialization (P0883R2) (#390)
Co-authored-by: AdamBucior https://github.com/AdamBucior
Co-authored-by: Casey Carter <cartec69@gmail.com>
Co-authored-by: Billy O'Neal <billy.oneal@gmail.com>
2020-01-23 22:50:22 -08:00
Casey Carter f96c61c346
Implement fixes from D2091R0 "Issues with Range Access CPOs" (#432)
* Implement fixes from D2091R0 "Issues with Range Access CPOs"

* Pre-existing: Correctly annotate implementations of outstanding `iter_move` LWG issues. LWG-3247 was not annotated, and LWG-3299 incorrectly annotated as LWG-3270 (the number had to be changed after submission).

* Remove the `initializer_list` poison pills for `ranges::begin`, `ranges::end`, `ranges::rbegin`, and `ranges::rend`. They were necessary only to prevent `initializer_list` from inadvertently opting-in to forwarding-range, and P1870R1 "forwarding-range<T> is too subtle" changed the opt-in.

* Always perform lookups for lvalues in `ranges::size`, `ranges::empty`, and `ranges::data` as is already the case for `ranges::begin`, `ranges::end`, `ranges::rbegin`, and `ranges::rend` post-P1870, which makes the CPOs easier to reason about and reduces template instantiations.

* Replace forwarding-reference poison pills with pairs of lvalue/const lvalue poison pills for `ranges::begin`, `ranges::end`, `ranges::rbegin`, `ranges::rend`, and `ranges::size`; the forwarding-reference versions are insufficiently poisonous and allow calls to plain `meow(auto&)`/`meow(const auto&)` templates.

* Only perform ADL probes in `ranges::begin`, `ranges::end`, `ranges::rbegin`, `ranges::rend`, and `ranges::size` for argument expressions of class or enumeration type.

* `ranges::begin`, `ranges::empty`, `ranges::data` accept (lvalue) arrays of unknown bound; `ranges::end` (and consequently `ranges::rbegin` and `ranges::rend`) rejects. Remove `range` constraint from `iterator_t`, so it works with (non-`range`) arrays of unknown bound. Add `range` constraints to the `range_meow_t` "compound" associated type traits, since they no longer get it from `iterator_t`.

* Hard error (with a pretty message) in `ranges::begin`, `ranges::end`, `ranges::rbegin`, or `ranges::rend` when the argument is an array whose element type is incomplete.
2020-01-23 18:13:06 -08:00
Casey Carter 8dc0385763
Remove workarounds for VSO-895622 (#410)
This bug is triggered when unqualified name lookup for `f` in `f(x)` finds only deleted function (template)s at template definition time, resulting in MSVC refusing to perform argument dependent lookup at template instantiation time. Unsurprisingly, all of the C++20 CPOs required workarounds.
2020-01-23 17:22:35 -08:00
Billy O'Neal 3447e56030 Implement constexpr algorithms. (#425)
* Implement constexpr algorithms.

Resolves GH-6 ( P0202R3 ), resolves GH-38 ( P0879R0 ), and drive-by fixes GH-414.

Everywhere: Add constexpr, _CONSTEXPR20, and _CONSTEXPR20_ICE to things.

skipped_tests.txt: Turn on all tests previously blocked by missing constexpr algorithms (and exchange and swap). Mark those algorithms that cannot be turned on that we have outstanding PRs for with their associated PRs.
yvals_core.h: Turn on feature test macros.
xutility:
* Move the _Ptr_cat family down to copy, and fix associated SHOUTY comments to indicate that this is really an implementation detail of copy, not something the rest of the standard library intends to use directly. Removed and clarified some of the comments as requested by Casey Carter.
* Extract _Copy_n_core which implements copy_n using only the core language (rather than memcpy-as-an-intrinsic). Note that we cannot use __builtin_memcpy or similar to avoid the is_constant_evaluated check here; builtin_memcpy only works in constexpr contexts when the inputs are of type char.
numeric: Refactor as suggested by GH-414.

* Attempt alternate fix of GH-414 suggested by Stephan.

* Stephan product code PR comments:

* _Swap_ranges_unchecked => _CONSTEXPR20
* _Idl_dist_add => _NODISCARD (and remove comments)
* is_permutation => _NODISCARD
* Add yvals_core.h comments.

* Delete unused _Copy_n_core and TRANSITION, DevCom-889321 comment.

* Put the comments in the right place and remove phantom braces.
2020-01-22 17:57:27 -08:00
Billy O'Neal 2989323bdc
Optimize the is_permutation family and _Hash::operator== for multicontainers (#423)
* Optimize the is_permutation family and _Hash::operator== for multicontaniers slightly.

<xutility>
4660: _Find_pr is a helper for is_permutation, so move it down to that area.
4684: The SHOUTY banners were attached to functions which were implmentation details of is_permutation, so I fixed them up to say is_permutation and removed the banners for helper functions.
4711: Use if constexpr to avoid a tag dispatch call for _Trim_matching_suffixes. Optimizers will like this because they generally hate reference-to-pointer, and it also serves to workaround DevCom-883631 when this algorithm is constexprized.
4766: Indicate that we are trimming matching prefixes in this loop body, and break apart comment block that was incorrectly merged by clang-format.
4817: In the dual range forward version of the algorithm, calculate the distances concurrently to avoid wasting lots of time when the distances vary by a lot. For example, is_permutation( a forward range of length 1, a forward range of length 1'000'000 ) used to do the million increments, now it stops at 1 increment.
4862: In the dual range random-access version, avoid recalculating _Last2 when it has already been supplied to us.

<xhash>
1404: Move down construction of _Bucket_hi in _Equal_range to before the first loop body using it.
1918: Added a new function to calculate equality for unordered multicontainers. We loop over the elements in the left container, find corresponding ranges in the right container, trim prefixes, then dispatch to is_permutation's helper _Check_match_counts.
Improvements over the old implementation:
* For standard containers, we no longer need to hash any elements from the left container; we know that we've found the "run" of equivalent elements because we *started* with an element in that container. We also never go "backwards" or multiply enumerate _Left (even for !_Standard), which improves cache use when the container becomes large.
* Just like the dual range is_permutation improvement above, when the equal_ranges of the containers are of wildly varying lengths, this will stop on the shorter of the lengths.
* We avoid the 3-arg is_permutation doing a linear time operation to discover _Last2 that we already had calculated in determining _Right's equal_range.
The function _Multi_equal_check_equal_range tests one equal_range from the left container against the corresponding equal_range from the right container, while _Multi_equal invokes _Multi_equal_check_equal_range for each equal_range.

Performance results:

```
Benchmark	Before (ns)	After (ns)	Percent Better
HashRandomUnequal<unordered_multimap>/1	18.7	11.7	59.83%
HashRandomUnequal<unordered_multimap>/10	137	97	41.24%
HashRandomUnequal<unordered_multimap>/100	1677	1141	46.98%
HashRandomUnequal<unordered_multimap>/512	10386	7036	47.61%
HashRandomUnequal<unordered_multimap>/4096	173807	119391	45.58%
HashRandomUnequal<unordered_multimap>/32768	2898405	1529710	89.47%
HashRandomUnequal<unordered_multimap>/100000	27441112	18602792	47.51%
HashRandomUnequal<hash_multimap>/1	18.9	11.8	60.17%
HashRandomUnequal<hash_multimap>/10	138	101	36.63%
HashRandomUnequal<hash_multimap>/100	1613	1154	39.77%
HashRandomUnequal<hash_multimap>/512	10385	7178	44.68%
HashRandomUnequal<hash_multimap>/4096	171718	120115	42.96%
HashRandomUnequal<hash_multimap>/32768	3352231	1510245	121.97%
HashRandomUnequal<hash_multimap>/100000	26532471	19209741	38.12%
HashRandomEqual<unordered_multimap>/1	16	9.4	70.21%
HashRandomEqual<unordered_multimap>/10	126	89.2	41.26%
HashRandomEqual<unordered_multimap>/100	1644	1133	45.10%
HashRandomEqual<unordered_multimap>/512	10532	7183	46.62%
HashRandomEqual<unordered_multimap>/4096	174580	120029	45.45%
HashRandomEqual<unordered_multimap>/32768	3031653	1455416	108.30%
HashRandomEqual<unordered_multimap>/100000	26100504	19240571	35.65%
HashRandomEqual<hash_multimap>/1	15.9	9.38	69.51%
HashRandomEqual<hash_multimap>/10	123	94.1	30.71%
HashRandomEqual<hash_multimap>/100	1645	1151	42.92%
HashRandomEqual<hash_multimap>/512	10177	7144	42.46%
HashRandomEqual<hash_multimap>/4096	172994	121381	42.52%
HashRandomEqual<hash_multimap>/32768	3045242	1966513	54.85%
HashRandomEqual<hash_multimap>/100000	26013781	22025482	18.11%
HashUnequalDifferingBuckets<unordered_multimap>/2	5.87	3.41	72.14%
HashUnequalDifferingBuckets<unordered_multimap>/10	12	3.39	253.98%
HashUnequalDifferingBuckets<unordered_multimap>/100	106	3.41	3008.50%
HashUnequalDifferingBuckets<unordered_multimap>/512	691	3.46	19871.10%
HashUnequalDifferingBuckets<unordered_multimap>/4096	6965	3.47	200620.46%
HashUnequalDifferingBuckets<unordered_multimap>/32768	91451	3.46	2642992.49%
HashUnequalDifferingBuckets<unordered_multimap>/100000	290430	3.52	8250752.27%
HashUnequalDifferingBuckets<hash_multimap>/2	5.97	3.4	75.59%
HashUnequalDifferingBuckets<hash_multimap>/10	11.8	3.54	233.33%
HashUnequalDifferingBuckets<hash_multimap>/100	105	3.54	2866.10%
HashUnequalDifferingBuckets<hash_multimap>/512	763	3.46	21952.02%
HashUnequalDifferingBuckets<hash_multimap>/4096	6862	3.4	201723.53%
HashUnequalDifferingBuckets<hash_multimap>/32768	94583	3.4	2781752.94%
HashUnequalDifferingBuckets<hash_multimap>/100000	287996	3.43	8396284.84%
```

Benchmark code:
```
#undef NDEBUG
#define _SILENCE_STDEXT_HASH_DEPRECATION_WARNINGS
#include <assert.h>
#include <benchmark/benchmark.h>
#include <hash_map>
#include <random>
#include <stddef.h>
#include <unordered_map>
#include <utility>
#include <vector>

using namespace std;

template <template <class...> class MapType> void HashRandomUnequal(benchmark::State &state) {
    std::minstd_rand rng(std::random_device{}());
    const auto range0 = static_cast<ptrdiff_t>(state.range(0));
    vector<pair<unsigned, unsigned>> testData;
    testData.resize(range0 * 5);
    const auto dataEnd = testData.begin() + range0;
    std::generate(testData.begin(), dataEnd, [&]() { return pair<unsigned, unsigned>{rng(), 0u}; });
    std::copy(testData.begin(), dataEnd,
              std::copy(testData.begin(), dataEnd,
                        std::copy(testData.begin(), dataEnd, std::copy(testData.begin(), dataEnd, dataEnd))));
    std::unordered_multimap<unsigned, unsigned> a(testData.begin(), testData.end());
    testData.clear();
    std::unordered_multimap<unsigned, unsigned> b = a;
    next(b.begin(), b.size() - 1)->second = 1u;
    for (auto &&_ : state) {
        (void)_;
        assert(a != b);
    }
}

BENCHMARK_TEMPLATE1(HashRandomUnequal, unordered_multimap)->Arg(1)->Arg(10)->Range(100, 100'000);
BENCHMARK_TEMPLATE1(HashRandomUnequal, hash_multimap)->Arg(1)->Arg(10)->Range(100, 100'000);

template <template <class...> class MapType> void HashRandomEqual(benchmark::State &state) {
    std::minstd_rand rng(std::random_device{}());
    const auto range0 = static_cast<ptrdiff_t>(state.range(0));
    vector<pair<unsigned, unsigned>> testData;
    testData.resize(range0 * 5);
    const auto dataEnd = testData.begin() + range0;
    std::generate(testData.begin(), dataEnd, [&]() { return pair<unsigned, unsigned>{rng(), 0}; });
    std::copy(testData.begin(), dataEnd,
              std::copy(testData.begin(), dataEnd,
                        std::copy(testData.begin(), dataEnd, std::copy(testData.begin(), dataEnd, dataEnd))));
    std::unordered_multimap<unsigned, unsigned> a(testData.begin(), testData.end());
    testData.clear();
    std::unordered_multimap<unsigned, unsigned> b = a;
    for (auto &&_ : state) {
        (void)_;
        assert(a == b);
    }
}

BENCHMARK_TEMPLATE1(HashRandomEqual, unordered_multimap)->Arg(1)->Arg(10)->Range(100, 100'000);
BENCHMARK_TEMPLATE1(HashRandomEqual, hash_multimap)->Arg(1)->Arg(10)->Range(100, 100'000);

template <template <class...> class MapType> void HashUnequalDifferingBuckets(benchmark::State &state) {
    std::unordered_multimap<unsigned, unsigned> a;
    std::unordered_multimap<unsigned, unsigned> b;
    const auto range0 = static_cast<ptrdiff_t>(state.range(0));
    for (ptrdiff_t idx = 0; idx < range0; ++idx) {
        a.emplace(0, 1);
        b.emplace(1, 0);
    }

    a.emplace(1, 0);
    b.emplace(0, 1);
    for (auto &&_ : state) {
        (void)_;
        assert(a != b);
    }
}

BENCHMARK_TEMPLATE1(HashUnequalDifferingBuckets, unordered_multimap)->Arg(2)->Arg(10)->Range(100, 100'000);
BENCHMARK_TEMPLATE1(HashUnequalDifferingBuckets, hash_multimap)->Arg(2)->Arg(10)->Range(100, 100'000);

BENCHMARK_MAIN();

* Apply a bunch of code review comments from Casey.

* clang-format

* Apply @miscco's code deduplication idea for <xhash>.

* Fix code review comments from Stephan: comments and add DMIs.
2020-01-19 12:38:04 -08:00
Michael Schellenberger Costa b3598a4f0b P0122R7 <span> (#142)
Fixes #4.
2020-01-17 19:23:11 -08:00
Casey Carter e36c3bff61
Don't assume _HAS_CONDITIONAL_EXPLICIT for __INTEL_COMPILER (#424)
This change is not a statement of support for the Intel C++ compiler by the STL, so much as an attempt to not break it gratuitously.

Fixes DevCom-744112.
2020-01-17 12:53:03 -08:00
Adam Bucior d862650bd5 Support For Incomplete Types In reference_wrapper (#393)
* Implement P0357R3
* Update LLVM to get skip of libcxx\test\std\utilities\function.objects\refwrap\weak_result.pass.cpp, and exclude "// REQUIRES: c++98 || c++03 || c++11 || c++14 || c++17" as a 'magic comment'.

Co-authored-by: Billy O'Neal <billy.oneal@gmail.com>
Co-authored-by: Casey Carter <cartec69@gmail.com>
2020-01-09 13:54:20 -08:00
Adam Bucior eb4a486c83 P1006R1 constexpr For pointer_traits<T*>::pointer_to() (#397)
Co-authored-by: Billy O'Neal <billy.oneal@gmail.com>
2020-01-09 10:38:13 -08:00
Daniil Goncharov 7ad0d63987 <numeric> Implement P1645R1 "constexpr for <numeric> algorithms" (#399)
Co-authored-by: Billy O'Neal <billy.oneal@gmail.com>
2020-01-08 19:23:30 -08:00
Daniel Marshall 48c7f31413 <utility> Deprecate std::rel_ops & resolve #403 (#402)
Co-authored-by: Casey Carter <cartec69@gmail.com>
Co-authored-by: Billy O'Neal <billy.oneal@gmail.com>
2020-01-08 19:16:40 -08:00
Casey Carter 4d5d226a72
Implement LWG-3356 (#404)
...which renames the feature-test macro `__cpp_lib_nothrow_convertible` to `__cpp_lib_is_nothrow_convertible`. We *just* added this feature-test macro which hasn't yet shipped, and therefore want to rename it quickly - ideally before customers notice it exists. LWG has tentatively approved this issue resolution.
2020-01-06 13:05:00 -08:00
Michael Schellenberger Costa 4aaa0135d9 [ranges] Implement some range concepts (#389)
P1456R1 Move-Only Views
P1870R1 safe_range
2019-12-16 21:58:58 -08:00
Daniil Goncharov 47881a869f Define _CONSTEXPR20 (#387) 2019-12-16 21:38:20 -08:00
Nikita Kniazev e59afeab79 <iterator>: reduced parsing time (#355)
* Replaced `<istream>` include with `<iosfwd>` because `[io]stream_iterator`
  needs only `basic_[io]stream` forward declaration.
* Moved `[io]streambuf_iterator` iterator definition to `<iterator>` because
  their definition has to come when `<iterator>` is included.
* Include `<iterator>` in `<xlocmon>`, `<xlocnum>`, and `<xloctime>` as
  the `[io]streambuf_iterator` definition are required there, and `<xutility>`
  already included via other includes.

Parsing times:

| header     |          clang          |           msvc          |
|------------|-------------------------|-------------------------|
| <iterator> | 0.371 -> 0.163 (-56.1%) | 0.216 -> 0.094 (-56.5%) |
| <istream>  | 0.366 -> 0.372 ( +1.6%) | 0.215 -> 0.216 ( +0.5%) |
| <xlocmon>  | 0.358 -> 0.364 ( +1.7%) | 0.211 -> 0.211 (    0%) |
| <xlocnum>  | 0.357 -> 0.360 ( +0.8%) | 0.207 -> 0.208 ( +0.5%) |
| <xloctime> | 0.364 -> 0.370 ( +1.6%) | 0.211 -> 0.214 ( +1.4%) |
2019-12-16 17:04:28 -08:00
Adam Bucior 07e85d10c0 Remove weak_equality and strong_equality (#381)
Implement WG21-P1959 Removing `weak_equality` And `strong_equality`, working towards #64.
2019-12-13 15:00:50 -08:00
Charlie Barto 70e49a0156 Explain why invoke is implemented with a macro (#368) 2019-12-11 18:06:17 -08:00
Stephan T. Lavavej d0ff26f92e
Fix #340: <functional>: _HAS_STATIC_RTTI=0 shouldn't say typeid(void) (#375)
This calls `abort()` as there's no need to invoke the terminate handler.

(This is a virtual function, so eliminating it entirely would risk ODR
violations leading to crashes. It's much safer to provide a definition
that can't be called.)

Additionally, fix `<xlocale>` to qualify `_CSTD abort()`.
2019-12-11 16:29:43 -08:00
Stephan T. Lavavej 2428e4631f
Fix #192: <cmath>: Fuse <xtgmath.h> (#374) 2019-12-11 16:28:07 -08:00
Stephan T. Lavavej 1666b7c145
Fix #347: <shared_mutex>: Do we still need the _USING_V110_SDK71_ guard? (#373)
While we must continue to support `msvcp140.dll` running on Windows XP,
we don't need to support compiling our headers with the (removed)
`v140_xp` toolset and its corresponding old Windows SDK. Accordingly,
we can unconditionally define `shared_mutex`. (This is a C++17 feature,
but it was implemented before Standard modes, so it's not guarded by
`_HAS_CXX17`.)
2019-12-11 16:27:13 -08:00
Stephan T. Lavavej 0781d10b9d
yvals_core.h: Remove "toolset update" workaround. (#372)
Currently, we're building the STL in both our Microsoft-internal MSVC
repo and in GitHub, as we work on the migration. The MSVC repo uses a
checked-in compiler (the "toolset") to build the STL and the compiler
itself. Earlier, the checked-in toolset identified itself as
19.25.28318.97 but lacked support for `is_constant_evaluated`, so we
needed to detect that exact version number. Now, the toolset has been
updated, so this workaround is no longer necessary.

When VS 2019 16.5 Preview 2 is available in the future, we'll begin
requiring it to build the GitHub sources, at which point we'll be able
to unconditionally define `__cpp_lib_is_constant_evaluated`.
2019-12-11 16:26:38 -08:00
Billy O'Neal 991ffe57d8
Reduce stack space consumption of list<T>::insert (#366)
* Avoid burning unused stack space for a T in _List_node_insert_op. Resolves #973579 and GH-365.

* Change forward_list to follow a similar pattern for consistency.

* First round of code review feedback.
2019-12-11 12:58:44 -08:00
Billy O'Neal aa0a7a3d85
Strengthen noexcept on std::exchange, which improves codegen for many move constructors and move assignments that use std::exchange. (#364)
Works toward GH-363
2019-12-09 20:33:26 -08:00
Julie Philip James 8f9431931b Fix #249: Change <hash_map> to consistently use int = 0 SFINAE (#328)
Permanently work around DevCom-848104 by simplifying hash_meow::value_type. This is what unordered_meow::value_type already does, which is why that can already use int = 0 SFINAE.
2019-12-07 01:11:26 -08:00
SasLuca ad5b80690d Use _STD addressof(_Val), update _MSVC_STL_UPDATE (#358)
* Fix #272: `<future>: promise<_Ty&>::set_value(_Ty& _Val)` should use `_STD addressof(_Val)`
* Fix #344: `<yvals_core.h>`: Update `_MSVC_STL_UPDATE` to December 2019
2019-12-06 19:38:33 -08:00
Stephan T. Lavavej da0d8cfdef Rewrap comments in <execution>. 2019-12-06 13:45:40 -08:00
Stephan T. Lavavej ef964344a8 Improve clang-format with StatementMacros. 2019-12-06 13:45:40 -08:00
Stephan T. Lavavej 19067f6752 Reorder and rewrap yvals_core.h comments. 2019-12-04 20:21:54 -08:00
Stephan T. Lavavej bef8b56dc9 Fix #156: WG21-P0595 is_constant_evaluated() 2019-12-04 20:21:54 -08:00
Stephan T. Lavavej d9d7bd808e Fix #339: WG21-P1902 Missing Feature-Test Macros 2017-2019 2019-12-04 20:21:54 -08:00
Stephan T. Lavavej 664adab3ab Fix #335: LWG-3257 Missing feature testing macro update from WG21-P0858 2019-12-04 20:21:54 -08:00
Stephan T. Lavavej bb41688bb1 Fix #70: LWG-3199 istream >> bitset<0> fails 2019-12-04 20:21:54 -08:00
Stephan T. Lavavej b01023144a Fix #332: LWG-3266 to_chars(bool) should be deleted 2019-12-04 20:21:54 -08:00
Casey Carter d42d1cd2a5 Hide std::unreachable_sentinel_t's friends harder (#352)
Hidden friends aren't hidden in C1XX's permissive mode, so let's use an alternate mechanism to make these operators truly ADL-only. (We want to avoid checking `weakly_incrementable` for every type that is compared via `==` or `!=` with a type associated with namespace `std`.)
2019-12-04 20:20:56 -08:00
Casey Carter 40017205af Improve diagnostic for std::function<void() noexcept> (#350)
Programs that include such specializations are ill-formed, since the Standard only specifies a partial specialization of `std::function<T>` for non-`noexcept` function types `T`. The current diagnostic:
```
error C2027: use of undefined type 'std::_Get_function_impl<_Fty>'
```
is not great.

Fixes DevCom-825902.

[This is a replay of Microsoft-internal MSVC-PR-215822.]
2019-12-04 20:20:28 -08:00
Krystyna Lopez 20adb42ae3 Change return type from non-const to const (#324)
Addresses #268 by changing the implementation to match the current Standardese.
2019-12-04 20:17:48 -08:00
S. B. Tam 1d39dfac99 Implement P1690R1 Refining Heterogeneous Lookup For Unordered Containers (#341)
* Implement P1690R1 Refining Heterogeneous Lookup For Unordered Containers

* Mark P1690R1 as implemented in yvals_core.h.
2019-12-02 20:34:31 -08:00
Casey Carter 1e8b8d4eef
[range.iter.ops], default_sentinel, and unreachable_sentinel (#329)
Implements iterator primitive operations `std::ranges::advance`, `std::ranges::next`, `std::ranges::prev`, and `std::ranges::distance`; as well as `std::default_sentinel` and `std::unreachable_sentinel`.

This change reworks the STL's iterator unwrapping machinery to enable unwrapping of C++20 move-only single-pass iterators (and `if constepxr`s all the things). Consequently, `_Iter_ref_t`, `_Iter_value_t`, and `_Iter_diff_t` resolve to `iter_reference_t`, `iter_value_t`, and `iter_difference_t` (respectively) in `__cpp_lib_concepts` (soon to be C++20) mode. This change necessitates some fixes to `unique_copy` and `_Fill_memset_is_safe` which both assume that `_Iter_value_t<T>` is well-formed for any iterator `T`. (`iter_value_t<T>` does not have that property: it is only well-formed when `readable<T>`.)

I notably haven't unified `default_sentinel_t` with `_Default_sentinel` out of an abundance of paranoia. Our `move_iterator` is comparable with `_Default_sentinel`, which is not the case for `std::default_sentinel`.

Drive-by:
* This change `if constexpr`-izes `unique_copy`.
2019-12-02 15:32:14 -08:00
Billy O'Neal a4034496ee
Use on/off SFINAE in std::function when not blocked by compiler bugs. (#244)
Xiang Fan of the C1XX frontend team reported that this improved throughput in a customer submitted benchmark.
2019-12-02 14:36:53 -08:00
Charlie Barto 1980e1a295 Add P0553R4 and P0556R3 to <bit> (with D1956 rename) (#310)
Resolves #25 and resolves #26. Currently active for Clang and EDG, but not C1XX.
2019-11-18 23:27:19 -08:00
Adam Bucior c5aaa28e52 P1612R1 Relocating endian To <bit> (#305)
Resolves  #61.
2019-11-18 23:13:38 -08:00
Julie Philip James 580e61a5f5 Marked _Doraise() functions as override (#302)
Improves #207.
2019-11-15 17:20:06 -08:00
S. B. Tam 6a96a3b0bc STL: Remove !_HAS_EXACT_COMPOUND_REQUIREMENT fallback (#301)
Fixes #299.
2019-11-15 17:16:01 -08:00
Krystyna Lopez 1648f3de58 <algorithm>: Use iter[idx] for clarity (#289)
Fixes #278.
2019-11-15 17:07:14 -08:00
Stephan T. Lavavej bfb96b1e12
Update __cpp_lib_concepts (see WG21-P1902). (#287)
This feature-test macro is being extensively queried, so we're updating it with high priority ahead of the other feature-test macro changes in this paper.
2019-11-11 21:25:16 -08:00
Michael Schellenberger Costa 10f1c819cc Use unqualified function calls for valarray (#286)
* Use unqualified function calls for valarray

The transcend functions require that the function is applied unqualified to each element

* Add comments to unqualified calls.

Fixes #285.
2019-11-11 21:23:24 -08:00
Daniel Marshall 1de980c54b P0340R3 SFINAE-Friendly underlying_type (#284)
Resolves #11. Implemented unconditionally.
2019-11-11 21:20:08 -08:00
Daniel Marshall eba6a71983 P0631R8 <numbers> Math Constants (#261)
Resolves #29.
2019-11-11 21:17:34 -08:00
Michael Schellenberger Costa f9b1dccd12 P0738R2 istream_iterator Cleanup (#246)
This change is unconditional.

Resolves #35.
2019-11-07 14:52:26 -08:00
Stephan T. Lavavej 5add7295ed
Enable clang-format AlignConsecutiveMacros. (#269)
* Update `.clang-format` defaults.

* Enable `AlignConsecutiveMacros`, newly supported by clang-format 9.
We often followed this style before using clang-format, and I believe
that it produces generally positive changes.

* Apply clang-format changes.

* Replace `_FITS` and `_NEXT_ALIGN` macros. clang-format didn't damage
them, it just brought them to my attention. These macros weren't
improving clarity, and the code is more systematic without them.
(For the time being, I have refrained from further overhauling the
metaprogramming here.)
2019-11-07 14:43:51 -08:00
Daniel Marshall 9d635aaef7 Use consistent phrasing of required standard mode (#252)
Fixes #250.
2019-11-05 13:12:34 -08:00
SumanjaliDamarla d0d724fb91 Update _MSVC_STL_UPDATE to 201911L (#253)
Fixes #247.
2019-11-04 11:36:54 -08:00
Michael Schellenberger Costa 3b0a1c9cfa Consistently use "int = 0" SFINAE (#226)
Fixes #187.

Add TRANSITION comments for #248 and #249, blocked by compiler bugs.

Add `_Enabled` names. When we don't have `enable_if_t`, this makes the
template parameter's purpose clearer. When we do have `enable_if_t`
but without `= 0`, this makes it somewhat clearer that we haven't
forgotten the default argument (it's simply elsewhere).
2019-11-01 18:15:37 -07:00
Daniel Marshall 28ec9a3295 P1209R0 erase_if(), erase() (#236)
Resolves #55.

* Deprecate experimental::erase

* Implement P1209R0

* Update yvals_core.h

* Update deprecations and remove <experimental/xutility>

* move and reorder erase/erase_if

* moved _Erase and remove and friends to <xmemory>

* Consistently place erase_if() definitions.
2019-11-01 14:32:39 -07:00
Casey Carter 1d094330aa
<compare> implement == for comparison categories (#242)
WG21-P1614 "The Mothership has Landed" added `==` operators to the comparison category types (`weak_equality`, `strong_equality`, `partial_ordering`, `weak_ordering`, and `strong_ordering`) defined in `<compare>`. This PR implements those operators to bring the comparison category types up to spec once again. It also implements P1614R2's removal of operators that rewrite into calls to `operator==(X, nullptr_t)` for each comparison category type `X`.

Drive-by changes:
* Move the TODO list of tasks for WG21-P0768 "Library Support for the Spaceship (Comparison) Operator" completion out of `<compare>` and into microsoft/STL#64
* Remove the `#if 0 // Not yet implemented` block from `<compare>`
2019-10-31 17:37:56 -07:00
Casey Carter b9eb320940
Update required compiler versions (#231)
* Update required compiler versions

Update required version of MSVC to VS 2019 16.4p2, and Clang/LLVM to 9.0.0.

* Tell `<yvals_core.h>` that Clang 9 implements `consteval` (WG21 hasn't yet defined a feature-test macro for `consteval`)
* Tell `<atomic>` that Clang 9 implements the `__iso_volatile_load64` intrinsic on x86

* Update mentions of VS version in `README.md`
2019-10-29 20:40:09 -07:00
Billy O'Neal f4f3acde83
Avoid self-move-assign of all elements in vector when erasing an empty range. (#228)
Resolves DevCom-776568.
2019-10-28 19:41:58 -07:00
Billy O'Neal 5bf80b41d1
Use casts for most common atomic cases (#227)
Resolves #85 / DevCom-706195

Casey applying the new atomic implementation fixed us breaking the
strict aliasing rules, but the memcpy is causing a code size regression
for non-`/Oi` customers. This change should restore code size for the
most common uses of atomic, which are `atomic<integral>` and
`atomic<pointer>`.
2019-10-28 15:49:58 -07:00
Julie Philip James 04cf94886a Changed TODO comments to TRANSITION comments (#221)
Fixes #200.
2019-10-27 14:12:14 -07:00
Nathan Ward fb7dba4b19 P0655R1 visit<R>() (#201)
Implements P0655R1 `visit<R>()` 

Resolves #31.
2019-10-25 18:48:15 -07:00
Krystyna Lopez a69a00e33b Fix #218 - remove public redundancy (#219) 2019-10-25 11:26:59 -07:00
Billy O'Neal 6b0238d703
Changes made from update to clang-format to 9.0.0. (#205) 2019-10-24 16:47:28 -07:00
Nathan Ward 447f879b13 LWG-2899 is_(nothrow_)move_constructible and tuple, optional, and unique_ptr (#193)
Resolves #68.
2019-10-22 17:50:05 -07:00
Nathan Ward a7d9526804 LWG-3158 tuple(allocator_arg_t, const Alloc&) should be conditionally explicit (#195)
Resolves #69.
2019-10-22 17:25:38 -07:00
Stanislav Ershov f05c358509 P0767R1 Deprecating is_pod (#179)
Resolves #36.
2019-10-22 17:17:11 -07:00
Nathan Ward 379e61781a P0356R5 bind_front() (#158)
Resolves #13.
2019-10-22 17:15:35 -07:00
Nathan Ward 957fe99f41 P0966R1 string::reserve() should not shrink (#176)
Fixes #42.
2019-10-17 16:06:27 -07:00
Stephan T. Lavavej 53cdb9f8a8
Fix #94 and remove compiler bug workarounds. (#175)
* Properly comment "Tukey's ninther".

* Remove workarounds for VSO-946746.

VSO-946746 "conditional explicit(bool) doesn't work with /clr:pure"
was fixed on 2019-07-23, and should be available in
VS 2019 16.4 Preview 1.

* Remove workarounds for VSO-433486.

VSO-433486 "_Count / 2 inside while (0 < _Count) loop is not
transformed into a simple shift" was fixed on 2019-08-27
and should be available in VS 2019 16.4 Preview 2.

Some shifts are still necessary, and are now commented.

* This mirrors a Microsoft-internal PR:
https://devdiv.visualstudio.com/DevDiv/_git/msvc/pullrequest/207988
2019-10-15 16:49:36 -07:00
Casey Carter 6aa3b02fde
Cleanup <any> and allow overaligned types (#173)
`<any>` cleanup:

* Prefer variable templates to class templates
* Prefer `if constexpr` to tag dispatch
* Function pointers may be `noexcept` in C++17
* Remove the layer of "symbolic member name" functions to improve debug codegen
* Conventionally use `enable_if_t<conjunction_v<meow, woof>` instead of `enable_if_t<meow::value && woof::value>`
* Apply `_NODISCARD` and `noexcept` to internal functions as appropriate
* Allow overaligned types, which are properly handled by the `_Big` representation

Resolves [DevCom-724444](https://developercommunity.visualstudio.com/content/problem/724444/meow.html).
2019-10-15 13:16:34 -07:00
Billy O'Neal 0d95d86ee7
Add back the missing unique_ptr swap (#170)
Resolves DevCom-754487 / VSO-1000729
2019-10-11 14:39:53 -07:00
Stephan T. Lavavej 712b7971bd
Update comments to follow custom autolink syntax (#168)
* Use custom autolinks.

* Also update .clang-format.

* Use ArchivedOS.
2019-10-11 13:43:06 -07:00
Casey Carter f565496875
Workaround clang __is_base_of bug in <type_traits> (#167)
Clang's `__is_base_of` intrinsic incorrectly handles some corner cases involving incomplete union types before LLVM 9. Workaround by guarding with `__is_class`.
2019-10-09 18:21:10 -07:00
Stephan T. Lavavej 50f343b458
Implement LWG 3268's PR to fix #150. (#151)
This is a back-compat fix for users who were saying things like
`std::memory_order::memory_order_relaxed`. As there is nothing
especially problematic about such usage, and LWG's ultimate resolution
is unknown, I'm not deprecating these enumerators at this time. If and
when this is voted into the WP in the deprecated clause, then we can
add deprecated attributes.

This mirrors a Microsoft-internal PR:
https://devdiv.visualstudio.com/DevDiv/_git/msvc/pullrequest/205250
2019-10-01 16:04:24 -07:00
Michael Schellenberger Costa cf55d69c40 P1227R2 Signed std::ssize() (#130)
Fixes #56.
2019-09-26 20:10:40 -07:00
Michael Schellenberger Costa 13fa3d8b0e P1357R1 is_bounded_array, is_unbounded_array (#127)
Fixes #58.
2019-09-26 19:54:23 -07:00
Andrew Fogarty 3ed27b95ce P0439R0 enum class memory_order (#124)
Fixes #17.
2019-09-26 19:51:00 -07:00
Casey Carter 1dcac20d28
Refuse to allow clang to include coroutine headers (#136)
Resolves #105.
2019-09-26 10:45:58 -07:00
Charlie Barto ff7d132b2e
implement P0325R4 to_array (#135) 2019-09-25 19:30:31 -07:00
Casey Carter 62482a6ddd
Fix regex tokenizing bug (#131)
We skip a non-match character in `regex_iterator::operator++` after a zero-length match to avoid repeat matches, resulting in incorrect behavior when tokenizing with a regex to match the delimiters between tokens.

Fixes [DevCom#733051](https://developercommunity.visualstudio.com/content/problem/733051/splitting-a-string-with-a-regex-returns-seemingly.html).
2019-09-24 15:14:39 -07:00
Billy O'Neal 44720cd5f6
Do size modifications after iterator transfer strategy selection (#129)
This was the cause of the DevCom reported bug:

https://developercommunity.visualstudio.com/content/problem/739698/vc-163-listsplice-bug.html

where we would choose the incorrect strategy to transfer iterators if and only if the number of transferred iterators was exactly half of the container.

This change replicates internal [PR 203902](https://devdiv.visualstudio.com/DevDiv/_git/msvc/pullrequest/203902)
2019-09-24 03:23:13 -07:00
Casey Carter da76ab2d5f
basic_string_view's non-member begin/end should take basic_string_view by value (#119)
... as the working draft requires. Test coverage failed to detect this issue due to [an overload resolution bug in MSVC](https://developercommunity.visualstudio.com/content/problem/739010/overload-resolution-fails-to-select-deleted-overlo.html).

Drive-by: Remove the "accepts rvalues" bit from the comment in `begin` which caused the confusion that gave rise to #104. Hopefully it is now glaringly obvious that `begin` and `end` accept both lvalues and rvalues.

Resolves #104.
2019-09-20 12:39:25 -07:00
practicalswift 7f65140761 Fix typos (#96)
* Fix typos

* Run clang-format on touched files

* Revert clang-format damage
2019-09-17 21:45:12 -06:00
Casey Carter 92508bed63 Update "old" range types
* `array`, `basic_string`, `basic_string_view`, `valarray`, and `vector` (`span` is not yet implemented) model `contiguous_range` by defining the nested type `iterator_concept` to `contiguous_iterator_tag` in `iterator` and `const_iterator`, and specializing `pointer_traits` for those types (to fulfill `contiguous_iterator`'s `std::to_address` requirement)

* `basic_string_view` (Ditto, no `span` yet) models the exposition-only *`forwarding-range`* concept (which indicates that the validity of iterators is not bound to the lifetime of the range) by defining hidden-friend overloads of `begin` and `end` that accept rvalues

* Drive-by:
  * mark the `_Unfancy` internal helper function `[[nodiscard]]`
  * Remove redundant `_Can_begin` requirement from `std::ranges::_Begin::_Cpo::_Choose`

* Add test coverage to `devcrt/P0896R4_ranges_range_machinery`:
  * tighten up `test_std_container`:
    * `data` and `cdata` reject rvalue arguments since the returned pointer could potentially dangle (`contiguous_range` codepaths were lacking coverage)
    * the `size_type` of a standard container can be other than `std::size_t` when using fancy pointers
    * we should enforce that each container's iterator type models the expected concept
  * Add test coverage to ensure that contiguous standard library containers model `contiguous_range` even when using an "old" fancy pointer type that does not model `contiguous_iterator`
2019-09-15 18:41:16 -07:00
Casey Carter 91d4b8fb89 _Has_class_or_enum_type concept should admit unions
Unions have "class type", despite that `is_class_v` is false for unions. Fixes a bug in which the behavior of `std::ranges::swap` cannot be customized for union types.
2019-09-12 12:16:34 -07:00
Casey Carter fc0ad927e9 Add <ranges>, inadvertently ommitted from #82
I experimented with different methods of preparing the dual checkin PR, and chose the wrong one.
2019-09-11 18:26:05 -07:00
Casey Carter 6fe5ae883f Suppress warning C4180 STL-wide (#84)
C4180 "qualifier applied to function type has no meaning; ignored" is emitted from `std::remove_reference<T>` when `T` is a function type or reference to such after applying the changes in #82. We could suppress it locally, but the warning is extremely low-value for the STL in general so let's simply suppress it globally.
2019-09-10 20:50:35 -07:00
Billy O'Neal 04cea50320
Implement load(8 bytes) with a 64 bit read on x86 (#87)
This depends on compiler support that will first ship in Visual Studio 2019 16.4, so it's guarded to allow the build to work with current preview releases.

Resolves https://developercommunity.visualstudio.com/content/problem/274938/index.html

Replays VSO PR 199513, this is the last substantial change I hope to do before we can work wholly in GitHub.
2019-09-10 19:46:22 -07:00
Casey Carter c5e2e3f799 Ranges <range> machinery
* Implements a selection of support machinery in `std::ranges` and adds the `<ranges>` header. Primarily consists of the range access customization point objects:
  * `ranges::begin`
  * `ranges::end`
  * `ranges::cbegin`
  * `ranges::cend`
  * `ranges::rbegin`
  * `ranges::rend`
  * `ranges::crbegin`
  * `ranges::crend`
  * `ranges::size`
  * `ranges::empty`
  * `ranges::data`
  * `ranges::cdata`

  and range concepts:

  * `ranges::range`
  * `ranges::output_range`
  * `ranges::input_range`
  * `ranges::forward_range`
  * `ranges::bidirectional_range`
  * `ranges::random_access_range`
  * `ranges::contiguous_range`
  * `ranges::sized_range`
  * `ranges::view`
  * `ranges::common_range`

  and the associated type aliases:

  * `ranges::iterator_t`
  * `ranges::sentinel_t`
  * `ranges::range_value_t`
  * `ranges::range_reference_t`
  * `ranges::range_difference_t`
  * `ranges::range_rvalue_reference_t`

* Adds `<ranges>` - which is mostly empty since the support machinery is defined in `<xutility>` so as to be visible to `<algorithm>`

* Annotates [P0896R4](https://wg21.link/p0896r4) as partially implemented in the "`_HAS_CXX20` directly controls" section of `<yvals_core.h>`.

* Touches `<regex>`, `<set>`, and `<unordered_set>` to add partial specializations of `ranges::enable_view` for `match_results` and `(unordered_)?multi?set` as mandated by the WD to override the heuristic.

* Partially implements [P1474R1 "Helpful pointers for `ContiguousIterator`"](https://wg21.link/p1474r1):
  * Push `pointer_traits` from `<xmemory>` and `to_address` from `<memory>` up into `<xutility>`
  * Add `to_address` expression requirement to `contiguous_iterator` concept, and update `P0896R4_ranges_iterator_machinery` appropriately
  * Implement the changes to `ranges::data` (but not `view_interface` since it isn't yet implemented)

* Drive-by:
  * Simplify the definition of `pointer_traits::_Reftype` by eschewing `add_lvalue_reference_t`.
  * Strengthen `reverse_iterator`'s constructors and `make_reverse_iterator` so `ranges::rbegin` and `ranges::rend` can be `noexcept` in more cases
  * Since we're using `_Rng` as the template parameter name for models of `std::ranges::range`, rename a local variable `_Rng` to `_Generator` in `<random>`
2019-09-09 15:31:26 -07:00
Billy O'Neal 892f6f580a
Remove incorrect noexcept from _Buyheadnode in <list>. (#77)
Replicates https://devdiv.visualstudio.com/DevDiv/_git/msvc/pullrequest/200975
2019-09-05 21:03:29 -07:00
Stephan T. Lavavej 219514876e Initial commit. 2019-09-04 15:57:56 -07:00