From 873dd34ebfa32e2b1c0719141be4b320fcf29bc0 Mon Sep 17 00:00:00 2001
From: Michael Schellenberger Costa <mschellenbergercosta@googlemail.com>
Date: Thu, 26 Aug 2021 14:41:46 +0200
Subject: [PATCH 1/8] Expand the allocator aware tests to also run at compile
 time and fix vector again

---
 stl/inc/vector                                |  2 +-
 .../test.cpp                                  | 79 ++++++++++---------
 2 files changed, 42 insertions(+), 39 deletions(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index 503a506f83f..e2991641c43 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -1697,7 +1697,7 @@ private:
                     _Clear_and_reserve_geometric(_Newsize);
                 }
 
-                _Mylast = _Refancy<pointer>(_Copy_memmove(_Unfancy(_First), _Unfancy(_Last), _Unfancy(_Myfirst)));
+                _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
             } else {
                 auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
 
diff --git a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
index f4cbcb8ee84..505024f2a79 100644
--- a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
+++ b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
@@ -24,72 +24,78 @@
 using namespace std;
 
 template <typename C>
-void assert_equal(const C& c, initializer_list<typename C::value_type> il) {
+_CONSTEXPR20 void assert_equal(const C& c, initializer_list<typename C::value_type> il) {
     assert(equal(c.begin(), c.end(), il.begin(), il.end()));
 }
 
 template <typename C>
-void assert_is_permutation(const C& c, initializer_list<typename C::value_type> il) {
+_CONSTEXPR20 void assert_is_permutation(const C& c, initializer_list<typename C::value_type> il) {
     assert(is_permutation(c.begin(), c.end(), il.begin(), il.end()));
 }
 
 template <typename T, typename POCCA, typename POCMA, typename POCS, typename EQUAL>
 class MyAlloc {
 private:
-    size_t m_offset;
+    size_t _offset;
 
-    size_t allocation_offset() const noexcept {
-        return is_always_equal::value ? 10 : m_offset;
+    [[nodiscard]] _CONSTEXPR20 size_t allocation_offset() const noexcept {
+        return is_always_equal::value ? 10 : _offset;
     }
 
 public:
-    size_t offset() const noexcept {
-        return m_offset;
+    [[nodiscard]] _CONSTEXPR20 size_t offset() const noexcept {
+        return _offset;
     }
 
-    typedef T value_type;
+    using value_type = T;
 
-    typedef POCCA propagate_on_container_copy_assignment;
-    typedef POCMA propagate_on_container_move_assignment;
-    typedef POCS propagate_on_container_swap;
-    typedef EQUAL is_always_equal;
+    using propagate_on_container_copy_assignment = POCCA;
+    using propagate_on_container_move_assignment = POCMA;
+    using propagate_on_container_swap            = POCS;
+    using is_always_equal                        = EQUAL;
 
-    explicit MyAlloc(const size_t off) : m_offset(off) {}
+    _CONSTEXPR20 explicit MyAlloc(const size_t off) : _offset(off) {}
 
     template <typename U>
-    MyAlloc(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) noexcept : m_offset(other.offset()) {}
+    _CONSTEXPR20 MyAlloc(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) noexcept : _offset(other.offset()) {}
 
     template <typename U>
-    bool operator==(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) const noexcept {
+    [[nodiscard]] _CONSTEXPR20 bool operator==(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) const noexcept {
         return allocation_offset() == other.allocation_offset();
     }
 
     template <typename U>
-    bool operator!=(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) const noexcept {
+    [[nodiscard]] _CONSTEXPR20 bool operator!=(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) const noexcept {
         return allocation_offset() != other.allocation_offset();
     }
 
-    T* allocate(const size_t n) {
+    _CONSTEXPR20 T* allocate(const size_t n) {
         if (n == 0) {
             return nullptr;
         }
 
         const auto allocationOffset = allocation_offset();
+        const auto _allocated       = n + allocationOffset;
 
         // Production code should check for integer overflow.
-        void* const pv = malloc((n + allocationOffset) * sizeof(T));
+        auto pv = allocator<T>{}.allocate(_allocated);
         if (!pv) {
             throw bad_alloc();
         }
 
-        memset(pv, 0xAB, (n + allocationOffset) * sizeof(T));
+#if _HAS_CXX20
+        if (!is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            memset(pv, 0xAB, (_allocated) * sizeof(T));
+        }
 
-        return static_cast<T*>(pv) + allocationOffset;
+        return pv + allocationOffset;
     }
 
-    void deallocate(T* const p, size_t) noexcept {
+    _CONSTEXPR20 void deallocate(T* const p, const size_t size) noexcept {
         if (p) {
-            free(p - allocation_offset());
+            allocator<T>{}.deallocate(p - allocation_offset(), size + allocation_offset());
         }
     }
 };
@@ -111,8 +117,7 @@ using SwapEqualAlloc = MyAlloc<T, false_type, false_type, true_type, true_type>;
 
 
 template <template <typename, typename> class Sequence>
-void test_sequence_copy_ctor() {
-
+_CONSTEXPR20 void test_sequence_copy_ctor() {
     Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(11));
     auto src_it = src.begin();
 
@@ -136,8 +141,7 @@ void test_sequence_copy_ctor() {
 }
 
 template <template <typename, typename> class Sequence>
-void test_sequence_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
-
+_CONSTEXPR20 void test_sequence_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
     Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(offset1));
     auto src_it = src.begin();
 
@@ -161,8 +165,7 @@ void test_sequence_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
 }
 
 template <template <typename, typename> class Sequence, typename Alloc>
-void test_sequence_copy_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
-
+_CONSTEXPR20 void test_sequence_copy_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
     Sequence<int, Alloc> src({10, 20, 30}, Alloc(offset1));
     Sequence<int, Alloc> dst({0, 0, 0}, Alloc(offset2));
 
@@ -190,8 +193,7 @@ void test_sequence_copy_assign(const size_t offset1, const size_t offset2, const
 }
 
 template <template <typename, typename> class Sequence>
-void test_sequence_move_ctor() {
-
+_CONSTEXPR20 void test_sequence_move_ctor() {
     Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(11));
     auto it1 = src.begin();
 
@@ -219,8 +221,7 @@ void test_sequence_move_ctor() {
 }
 
 template <template <typename, typename> class Sequence>
-void test_sequence_move_alloc_ctor(const size_t offset1, const size_t offset2) {
-
+_CONSTEXPR20 void test_sequence_move_alloc_ctor(const size_t offset1, const size_t offset2) {
     Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(offset1));
     auto it1 = src.begin();
 
@@ -253,8 +254,7 @@ void test_sequence_move_alloc_ctor(const size_t offset1, const size_t offset2) {
 }
 
 template <template <typename, typename> class Sequence, typename Alloc>
-void test_sequence_move_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
-
+_CONSTEXPR20 void test_sequence_move_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
     Sequence<int, Alloc> src({10, 20, 30}, Alloc(offset1));
     Sequence<int, Alloc> dst({0, 0, 0}, Alloc(offset2));
 
@@ -290,8 +290,7 @@ void test_sequence_move_assign(const size_t offset1, const size_t offset2, const
 }
 
 template <template <typename, typename> class Sequence, typename Alloc>
-void test_sequence_swap(const size_t offset1, const size_t offset2) {
-
+_CONSTEXPR20 void test_sequence_swap(const size_t offset1, const size_t offset2) {
     Sequence<int, Alloc> src({10, 20, 30}, Alloc(offset1));
     Sequence<int, Alloc> dst({40, 50, 60}, Alloc(offset2));
 
@@ -317,8 +316,7 @@ void test_sequence_swap(const size_t offset1, const size_t offset2) {
 }
 
 template <template <typename, typename> class Sequence>
-void test_sequence() {
-
+_CONSTEXPR20 bool test_sequence() {
     test_sequence_copy_ctor<Sequence>();
 
     test_sequence_copy_alloc_ctor<Sequence>(11, 11); // equal allocators
@@ -346,6 +344,8 @@ void test_sequence() {
     test_sequence_swap<Sequence, SwapAlloc<int>>(11, 11); // POCS, equal allocators
     test_sequence_swap<Sequence, SwapAlloc<int>>(11, 22); // POCS, non-equal allocators
     test_sequence_swap<Sequence, SwapEqualAlloc<int>>(11, 22); // POCS, always-equal allocators
+
+    return true;
 }
 
 
@@ -1675,6 +1675,9 @@ int main() {
     test_sequence<deque>();
     test_sequence<list>();
     test_sequence<vector>();
+#if _HAS_CXX20 && !defined(__EDG__)
+    static_assert(test_sequence<vector>());
+#endif // _HAS_CXX20
 
     test_flist();
     test_string();

From fe7e654cc0a2fc6a2476522706de97cd82620af1 Mon Sep 17 00:00:00 2001
From: Michael Schellenberger Costa <mschellenbergercosta@googlemail.com>
Date: Fri, 27 Aug 2021 18:49:55 +0200
Subject: [PATCH 2/8] Cleanup the test a bit

---
 .../test.cpp                                  | 554 +++++++++---------
 1 file changed, 266 insertions(+), 288 deletions(-)

diff --git a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
index 505024f2a79..523a93302b5 100644
--- a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
+++ b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
@@ -23,28 +23,29 @@
 
 using namespace std;
 
-template <typename C>
-_CONSTEXPR20 void assert_equal(const C& c, initializer_list<typename C::value_type> il) {
-    assert(equal(c.begin(), c.end(), il.begin(), il.end()));
+template <class Container>
+_CONSTEXPR20 void assert_equal(const Container& cont, initializer_list<typename Container::value_type> il) {
+    assert(equal(cont.begin(), cont.end(), il.begin(), il.end()));
 }
 
-template <typename C>
-_CONSTEXPR20 void assert_is_permutation(const C& c, initializer_list<typename C::value_type> il) {
-    assert(is_permutation(c.begin(), c.end(), il.begin(), il.end()));
+template <class Container>
+_CONSTEXPR20 void assert_is_permutation(const Container& cont, initializer_list<typename Container::value_type> il) {
+    assert(is_permutation(cont.begin(), cont.end(), il.begin(), il.end()));
 }
 
-template <typename T, typename POCCA, typename POCMA, typename POCS, typename EQUAL>
+
+template <class T, class POCCA, class POCMA, class POCS, class EQUAL>
 class MyAlloc {
 private:
-    size_t _offset;
+    size_t _id;
 
-    [[nodiscard]] _CONSTEXPR20 size_t allocation_offset() const noexcept {
-        return is_always_equal::value ? 10 : _offset;
+    [[nodiscard]] constexpr size_t equal_id() const noexcept {
+        return is_always_equal::value ? 10 : _id;
     }
 
 public:
-    [[nodiscard]] _CONSTEXPR20 size_t offset() const noexcept {
-        return _offset;
+    [[nodiscard]] constexpr size_t id() const noexcept {
+        return _id;
     }
 
     using value_type = T;
@@ -54,69 +55,47 @@ class MyAlloc {
     using propagate_on_container_swap            = POCS;
     using is_always_equal                        = EQUAL;
 
-    _CONSTEXPR20 explicit MyAlloc(const size_t off) : _offset(off) {}
+    constexpr explicit MyAlloc(const size_t _id_) : _id(_id_) {}
 
-    template <typename U>
-    _CONSTEXPR20 MyAlloc(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) noexcept : _offset(other.offset()) {}
+    template <class U>
+    constexpr MyAlloc(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) noexcept : _id(other.id()) {}
 
-    template <typename U>
-    [[nodiscard]] _CONSTEXPR20 bool operator==(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) const noexcept {
-        return allocation_offset() == other.allocation_offset();
+    template <class U>
+    [[nodiscard]] constexpr bool operator==(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) const noexcept {
+        return equal_id() == other.equal_id();
     }
 
-    template <typename U>
-    [[nodiscard]] _CONSTEXPR20 bool operator!=(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) const noexcept {
-        return allocation_offset() != other.allocation_offset();
+    template <class U>
+    [[nodiscard]] constexpr bool operator!=(const MyAlloc<U, POCCA, POCMA, POCS, EQUAL>& other) const noexcept {
+        return equal_id() != other.equal_id();
     }
 
-    _CONSTEXPR20 T* allocate(const size_t n) {
-        if (n == 0) {
-            return nullptr;
-        }
-
-        const auto allocationOffset = allocation_offset();
-        const auto _allocated       = n + allocationOffset;
-
-        // Production code should check for integer overflow.
-        auto pv = allocator<T>{}.allocate(_allocated);
-        if (!pv) {
-            throw bad_alloc();
-        }
-
-#if _HAS_CXX20
-        if (!is_constant_evaluated())
-#endif // _HAS_CXX20
-        {
-            memset(pv, 0xAB, (_allocated) * sizeof(T));
-        }
-
-        return pv + allocationOffset;
+    [[nodiscard]] constexpr T* allocate(const size_t numElements) {
+        return allocator<T>{}.allocate(numElements + equal_id()) + equal_id();
     }
 
-    _CONSTEXPR20 void deallocate(T* const p, const size_t size) noexcept {
-        if (p) {
-            allocator<T>{}.deallocate(p - allocation_offset(), size + allocation_offset());
-        }
+    constexpr void deallocate(T* const first, const size_t numElements) noexcept {
+        allocator<T>{}.deallocate(first - equal_id(), numElements + equal_id());
     }
 };
 
-template <typename T>
+template <class T>
 using StationaryAlloc = MyAlloc<T, false_type, false_type, false_type, false_type>;
-template <typename T>
+template <class T>
 using CopyAlloc = MyAlloc<T, true_type, false_type, false_type, false_type>;
-template <typename T>
+template <class T>
 using CopyEqualAlloc = MyAlloc<T, true_type, false_type, false_type, true_type>;
-template <typename T>
+template <class T>
 using MoveAlloc = MyAlloc<T, false_type, true_type, false_type, false_type>;
-template <typename T>
+template <class T>
 using MoveEqualAlloc = MyAlloc<T, false_type, true_type, false_type, true_type>;
-template <typename T>
+template <class T>
 using SwapAlloc = MyAlloc<T, false_type, false_type, true_type, false_type>;
-template <typename T>
+template <class T>
 using SwapEqualAlloc = MyAlloc<T, false_type, false_type, true_type, true_type>;
 
 
-template <template <typename, typename> class Sequence>
+template <template <class, class> class Sequence>
 _CONSTEXPR20 void test_sequence_copy_ctor() {
     Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(11));
     auto src_it = src.begin();
@@ -136,16 +115,16 @@ _CONSTEXPR20 void test_sequence_copy_ctor() {
     assert_equal(src, {40, 20, 30, 68});
     assert_equal(dst, {50, 20, 30, 79});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-template <template <typename, typename> class Sequence>
-_CONSTEXPR20 void test_sequence_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
-    Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(offset1));
+template <template <class, class> class Sequence>
+_CONSTEXPR20 void test_sequence_copy_alloc_ctor(const size_t id1, const size_t id2) {
+    Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(id1));
     auto src_it = src.begin();
 
-    Sequence<int, StationaryAlloc<int>> dst(src, StationaryAlloc<int>(offset2));
+    Sequence<int, StationaryAlloc<int>> dst(src, StationaryAlloc<int>(id2));
     auto dst_it = dst.begin();
 
     *src_it = 40;
@@ -160,14 +139,14 @@ _CONSTEXPR20 void test_sequence_copy_alloc_ctor(const size_t offset1, const size
     assert_equal(src, {40, 20, 30, 68});
     assert_equal(dst, {50, 20, 30, 79});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <template <typename, typename> class Sequence, typename Alloc>
-_CONSTEXPR20 void test_sequence_copy_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
-    Sequence<int, Alloc> src({10, 20, 30}, Alloc(offset1));
-    Sequence<int, Alloc> dst({0, 0, 0}, Alloc(offset2));
+template <template <class, class> class Sequence, typename Alloc>
+_CONSTEXPR20 void test_sequence_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
+    Sequence<int, Alloc> src({10, 20, 30}, Alloc(id1));
+    Sequence<int, Alloc> dst({0, 0, 0}, Alloc(id2));
 
     auto src_it = src.begin();
     auto dst_it = dst.begin();
@@ -188,11 +167,11 @@ _CONSTEXPR20 void test_sequence_copy_assign(const size_t offset1, const size_t o
     assert_equal(src, {40, 20, 30, 68});
     assert_equal(dst, {50, 20, 30, 79});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <template <typename, typename> class Sequence>
+template <template <class, class> class Sequence>
 _CONSTEXPR20 void test_sequence_move_ctor() {
     Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(11));
     auto it1 = src.begin();
@@ -216,18 +195,18 @@ _CONSTEXPR20 void test_sequence_move_ctor() {
     assert_equal(src, {90, 50, 60, 108});
     assert_equal(dst, {70, 80, 30, 119});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-template <template <typename, typename> class Sequence>
-_CONSTEXPR20 void test_sequence_move_alloc_ctor(const size_t offset1, const size_t offset2) {
-    Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(offset1));
+template <template <class, class> class Sequence>
+_CONSTEXPR20 void test_sequence_move_alloc_ctor(const size_t id1, const size_t id2) {
+    Sequence<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(id1));
     auto it1 = src.begin();
 
-    Sequence<int, StationaryAlloc<int>> dst(move(src), StationaryAlloc<int>(offset2));
+    Sequence<int, StationaryAlloc<int>> dst(move(src), StationaryAlloc<int>(id2));
 
-    if (offset1 != offset2) {
+    if (id1 != id2) {
         it1 = dst.begin();
     }
 
@@ -249,21 +228,21 @@ _CONSTEXPR20 void test_sequence_move_alloc_ctor(const size_t offset1, const size
     assert_equal(src, {90, 50, 60, 108});
     assert_equal(dst, {70, 80, 30, 119});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <template <typename, typename> class Sequence, typename Alloc>
-_CONSTEXPR20 void test_sequence_move_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
-    Sequence<int, Alloc> src({10, 20, 30}, Alloc(offset1));
-    Sequence<int, Alloc> dst({0, 0, 0}, Alloc(offset2));
+template <template <class, class> class Sequence, typename Alloc>
+_CONSTEXPR20 void test_sequence_move_assign(const size_t id1, const size_t id2, const size_t id3) {
+    Sequence<int, Alloc> src({10, 20, 30}, Alloc(id1));
+    Sequence<int, Alloc> dst({0, 0, 0}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
 
     dst = move(src);
 
-    if (offset1 != offset3) {
+    if (id1 != id3) {
         it1 = dst.begin();
     }
 
@@ -285,14 +264,14 @@ _CONSTEXPR20 void test_sequence_move_assign(const size_t offset1, const size_t o
     assert_equal(src, {90, 50, 60, 108});
     assert_equal(dst, {70, 80, 30, 119});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <template <typename, typename> class Sequence, typename Alloc>
-_CONSTEXPR20 void test_sequence_swap(const size_t offset1, const size_t offset2) {
-    Sequence<int, Alloc> src({10, 20, 30}, Alloc(offset1));
-    Sequence<int, Alloc> dst({40, 50, 60}, Alloc(offset2));
+template <template <class, class> class Sequence, typename Alloc>
+_CONSTEXPR20 void test_sequence_swap(const size_t id1, const size_t id2) {
+    Sequence<int, Alloc> src({10, 20, 30}, Alloc(id1));
+    Sequence<int, Alloc> dst({40, 50, 60}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
@@ -311,11 +290,11 @@ _CONSTEXPR20 void test_sequence_swap(const size_t offset1, const size_t offset2)
     assert_equal(src, {80, 50, 60, 108});
     assert_equal(dst, {70, 20, 30, 119});
 
-    assert(src.get_allocator().offset() == offset2);
-    assert(dst.get_allocator().offset() == offset1);
+    assert(src.get_allocator().id() == id2);
+    assert(dst.get_allocator().id() == id1);
 }
 
-template <template <typename, typename> class Sequence>
+template <template <class, class> class Sequence>
 _CONSTEXPR20 bool test_sequence() {
     test_sequence_copy_ctor<Sequence>();
 
@@ -368,15 +347,15 @@ void test_flist_copy_ctor() {
     assert_equal(src, {68, 40, 20, 30});
     assert_equal(dst, {79, 50, 20, 30});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-void test_flist_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
-    forward_list<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(offset1));
+void test_flist_copy_alloc_ctor(const size_t id1, const size_t id2) {
+    forward_list<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(id1));
     auto src_it = src.begin();
 
-    forward_list<int, StationaryAlloc<int>> dst(src, StationaryAlloc<int>(offset2));
+    forward_list<int, StationaryAlloc<int>> dst(src, StationaryAlloc<int>(id2));
     auto dst_it = dst.begin();
 
     *src_it = 40;
@@ -391,15 +370,15 @@ void test_flist_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_equal(src, {68, 40, 20, 30});
     assert_equal(dst, {79, 50, 20, 30});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <typename Alloc>
-void test_flist_copy_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <class Alloc>
+void test_flist_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    forward_list<int, Alloc> src({10, 20, 30}, Alloc(offset1));
-    forward_list<int, Alloc> dst({0, 0, 0}, Alloc(offset2));
+    forward_list<int, Alloc> src({10, 20, 30}, Alloc(id1));
+    forward_list<int, Alloc> dst({0, 0, 0}, Alloc(id2));
 
     auto src_it = src.begin();
     auto dst_it = dst.begin();
@@ -420,8 +399,8 @@ void test_flist_copy_assign(const size_t offset1, const size_t offset2, const si
     assert_equal(src, {68, 40, 20, 30});
     assert_equal(dst, {79, 50, 20, 30});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
 void test_flist_move_ctor() {
@@ -447,17 +426,17 @@ void test_flist_move_ctor() {
     assert_equal(src, {108, 90, 50, 60});
     assert_equal(dst, {119, 70, 80, 30});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-void test_flist_move_alloc_ctor(const size_t offset1, const size_t offset2) {
-    forward_list<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(offset1));
+void test_flist_move_alloc_ctor(const size_t id1, const size_t id2) {
+    forward_list<int, StationaryAlloc<int>> src({10, 20, 30}, StationaryAlloc<int>(id1));
     auto it1 = src.begin();
 
-    forward_list<int, StationaryAlloc<int>> dst(move(src), StationaryAlloc<int>(offset2));
+    forward_list<int, StationaryAlloc<int>> dst(move(src), StationaryAlloc<int>(id2));
 
-    if (offset1 != offset2) {
+    if (id1 != id2) {
         it1 = dst.begin();
     }
 
@@ -479,22 +458,22 @@ void test_flist_move_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_equal(src, {108, 90, 50, 60});
     assert_equal(dst, {119, 70, 80, 30});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <typename Alloc>
-void test_flist_move_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <class Alloc>
+void test_flist_move_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    forward_list<int, Alloc> src({10, 20, 30}, Alloc(offset1));
-    forward_list<int, Alloc> dst({0, 0, 0}, Alloc(offset2));
+    forward_list<int, Alloc> src({10, 20, 30}, Alloc(id1));
+    forward_list<int, Alloc> dst({0, 0, 0}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
 
     dst = move(src);
 
-    if (offset1 != offset3) {
+    if (id1 != id3) {
         it1 = dst.begin();
     }
 
@@ -516,15 +495,15 @@ void test_flist_move_assign(const size_t offset1, const size_t offset2, const si
     assert_equal(src, {108, 90, 50, 60});
     assert_equal(dst, {119, 70, 80, 30});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <typename Alloc>
-void test_flist_swap(const size_t offset1, const size_t offset2) {
+template <class Alloc>
+void test_flist_swap(const size_t id1, const size_t id2) {
 
-    forward_list<int, Alloc> src({10, 20, 30}, Alloc(offset1));
-    forward_list<int, Alloc> dst({40, 50, 60}, Alloc(offset2));
+    forward_list<int, Alloc> src({10, 20, 30}, Alloc(id1));
+    forward_list<int, Alloc> dst({40, 50, 60}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
@@ -543,8 +522,8 @@ void test_flist_swap(const size_t offset1, const size_t offset2) {
     assert_equal(src, {108, 80, 50, 60});
     assert_equal(dst, {119, 70, 20, 30});
 
-    assert(src.get_allocator().offset() == offset2);
-    assert(dst.get_allocator().offset() == offset1);
+    assert(src.get_allocator().id() == id2);
+    assert(dst.get_allocator().id() == id1);
 }
 
 void test_flist() {
@@ -600,17 +579,16 @@ void test_string_copy_ctor() {
     assert_equal(src, {40, 10, 20, 30, 68});
     assert_equal(dst, {50, 10, 20, 30, 79});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-void test_string_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
+void test_string_copy_alloc_ctor(const size_t id1, const size_t id2) {
     basic_string<char32_t, char_traits<char32_t>, StationaryAlloc<char32_t>> src(
-        {5, 10, 20, 30}, StationaryAlloc<char32_t>(offset1));
+        {5, 10, 20, 30}, StationaryAlloc<char32_t>(id1));
     auto src_it = src.begin();
 
-    basic_string<char32_t, char_traits<char32_t>, StationaryAlloc<char32_t>> dst(
-        src, StationaryAlloc<char32_t>(offset2));
+    basic_string<char32_t, char_traits<char32_t>, StationaryAlloc<char32_t>> dst(src, StationaryAlloc<char32_t>(id2));
     auto dst_it = dst.begin();
 
     *src_it = 40;
@@ -625,15 +603,15 @@ void test_string_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_equal(src, {40, 10, 20, 30, 68});
     assert_equal(dst, {50, 10, 20, 30, 79});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <typename Alloc>
-void test_string_copy_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <class Alloc>
+void test_string_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    basic_string<char32_t, char_traits<char32_t>, Alloc> src({5, 10, 20, 30}, Alloc(offset1));
-    basic_string<char32_t, char_traits<char32_t>, Alloc> dst({0, 0, 0, 0}, Alloc(offset2));
+    basic_string<char32_t, char_traits<char32_t>, Alloc> src({5, 10, 20, 30}, Alloc(id1));
+    basic_string<char32_t, char_traits<char32_t>, Alloc> dst({0, 0, 0, 0}, Alloc(id2));
 
     auto src_it = src.begin();
     auto dst_it = dst.begin();
@@ -654,8 +632,8 @@ void test_string_copy_assign(const size_t offset1, const size_t offset2, const s
     assert_equal(src, {40, 10, 20, 30, 68});
     assert_equal(dst, {50, 10, 20, 30, 79});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
 void test_string_move_ctor() {
@@ -683,17 +661,17 @@ void test_string_move_ctor() {
     assert_equal(src, {90, 40, 50, 60, 108});
     assert_equal(dst, {70, 80, 20, 30, 119});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-void test_string_move_alloc_ctor(const size_t offset1, const size_t offset2) {
+void test_string_move_alloc_ctor(const size_t id1, const size_t id2) {
     basic_string<char32_t, char_traits<char32_t>, StationaryAlloc<char32_t>> src(
-        {5, 10, 20, 30}, StationaryAlloc<char32_t>(offset1));
+        {5, 10, 20, 30}, StationaryAlloc<char32_t>(id1));
     auto it1 = src.begin();
 
     basic_string<char32_t, char_traits<char32_t>, StationaryAlloc<char32_t>> dst(
-        move(src), StationaryAlloc<char32_t>(offset2));
+        move(src), StationaryAlloc<char32_t>(id2));
     it1      = dst.begin(); // basic_string doesn't preserve iterators here
     auto it2 = next(dst.begin());
 
@@ -713,15 +691,15 @@ void test_string_move_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_equal(src, {90, 40, 50, 60, 108});
     assert_equal(dst, {70, 80, 20, 30, 119});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <typename Alloc>
-void test_string_move_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <class Alloc>
+void test_string_move_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    basic_string<char32_t, char_traits<char32_t>, Alloc> src({5, 10, 20, 30}, Alloc(offset1));
-    basic_string<char32_t, char_traits<char32_t>, Alloc> dst({0, 0, 0, 0}, Alloc(offset2));
+    basic_string<char32_t, char_traits<char32_t>, Alloc> src({5, 10, 20, 30}, Alloc(id1));
+    basic_string<char32_t, char_traits<char32_t>, Alloc> dst({0, 0, 0, 0}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
@@ -747,15 +725,15 @@ void test_string_move_assign(const size_t offset1, const size_t offset2, const s
     assert_equal(src, {90, 40, 50, 60, 108});
     assert_equal(dst, {70, 80, 20, 30, 119});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <typename Alloc>
-void test_string_swap(const size_t offset1, const size_t offset2) {
+template <class Alloc>
+void test_string_swap(const size_t id1, const size_t id2) {
 
-    basic_string<char32_t, char_traits<char32_t>, Alloc> src({5, 10, 20, 30}, Alloc(offset1));
-    basic_string<char32_t, char_traits<char32_t>, Alloc> dst({6, 40, 50, 60}, Alloc(offset2));
+    basic_string<char32_t, char_traits<char32_t>, Alloc> src({5, 10, 20, 30}, Alloc(id1));
+    basic_string<char32_t, char_traits<char32_t>, Alloc> dst({6, 40, 50, 60}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
@@ -777,8 +755,8 @@ void test_string_swap(const size_t offset1, const size_t offset2) {
     assert_equal(src, {80, 40, 50, 60, 108});
     assert_equal(dst, {70, 10, 20, 30, 119});
 
-    assert(src.get_allocator().offset() == offset2);
-    assert(dst.get_allocator().offset() == offset1);
+    assert(src.get_allocator().id() == id2);
+    assert(dst.get_allocator().id() == id1);
 }
 
 void test_string() {
@@ -834,15 +812,15 @@ void test_vb_copy_ctor() {
     assert_equal(src, {O, I, I, O, I, I, O, O});
     assert_equal(dst, {I, O, I, O, I, O, I, I});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-void test_vb_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
-    vector<bool, StationaryAlloc<bool>> src({I, I, I, O, I, I, I}, StationaryAlloc<bool>(offset1));
+void test_vb_copy_alloc_ctor(const size_t id1, const size_t id2) {
+    vector<bool, StationaryAlloc<bool>> src({I, I, I, O, I, I, I}, StationaryAlloc<bool>(id1));
     auto src_it = src.begin();
 
-    vector<bool, StationaryAlloc<bool>> dst(src, StationaryAlloc<bool>(offset2));
+    vector<bool, StationaryAlloc<bool>> dst(src, StationaryAlloc<bool>(id2));
     auto dst_it = next(dst.begin());
 
     *src_it = O;
@@ -857,15 +835,15 @@ void test_vb_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_equal(src, {O, I, I, O, I, I, O, O});
     assert_equal(dst, {I, O, I, O, I, O, I, I});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <typename Alloc>
-void test_vb_copy_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <class Alloc>
+void test_vb_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    vector<bool, Alloc> src({I, I, I, O, I, I, I}, Alloc(offset1));
-    vector<bool, Alloc> dst({O, O, O, O, O, O, O}, Alloc(offset2));
+    vector<bool, Alloc> src({I, I, I, O, I, I, I}, Alloc(id1));
+    vector<bool, Alloc> dst({O, O, O, O, O, O, O}, Alloc(id2));
 
     auto src_it = src.begin();
     auto dst_it = next(dst.begin());
@@ -886,8 +864,8 @@ void test_vb_copy_assign(const size_t offset1, const size_t offset2, const size_
     assert_equal(src, {O, I, I, O, I, I, O, O});
     assert_equal(dst, {I, O, I, O, I, O, I, I});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
 void test_vb_move_ctor() {
@@ -913,17 +891,17 @@ void test_vb_move_ctor() {
     assert_equal(src, {I, O, O, I, O, O, I, O});
     assert_equal(dst, {O, O, I, O, I, O, I, I});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-void test_vb_move_alloc_ctor(const size_t offset1, const size_t offset2) {
-    vector<bool, StationaryAlloc<bool>> src({I, I, I, O, I, I, I}, StationaryAlloc<bool>(offset1));
+void test_vb_move_alloc_ctor(const size_t id1, const size_t id2) {
+    vector<bool, StationaryAlloc<bool>> src({I, I, I, O, I, I, I}, StationaryAlloc<bool>(id1));
     auto it1 = src.begin();
 
-    vector<bool, StationaryAlloc<bool>> dst(move(src), StationaryAlloc<bool>(offset2));
+    vector<bool, StationaryAlloc<bool>> dst(move(src), StationaryAlloc<bool>(id2));
 
-    if (offset1 != offset2) {
+    if (id1 != id2) {
         it1 = dst.begin();
     }
 
@@ -945,22 +923,22 @@ void test_vb_move_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_equal(src, {I, O, O, I, O, O, I, O});
     assert_equal(dst, {O, O, I, O, I, O, I, I});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <typename Alloc>
-void test_vb_move_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <class Alloc>
+void test_vb_move_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    vector<bool, Alloc> src({I, I, I, O, I, I, I}, Alloc(offset1));
-    vector<bool, Alloc> dst({O, O, O, O, O, O, O}, Alloc(offset2));
+    vector<bool, Alloc> src({I, I, I, O, I, I, I}, Alloc(id1));
+    vector<bool, Alloc> dst({O, O, O, O, O, O, O}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
 
     dst = move(src);
 
-    if (offset1 != offset3) {
+    if (id1 != id3) {
         it1 = dst.begin();
     }
 
@@ -982,15 +960,15 @@ void test_vb_move_assign(const size_t offset1, const size_t offset2, const size_
     assert_equal(src, {I, O, O, I, O, O, I, O});
     assert_equal(dst, {O, O, I, O, I, O, I, I});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <typename Alloc>
-void test_vb_swap(const size_t offset1, const size_t offset2) {
+template <class Alloc>
+void test_vb_swap(const size_t id1, const size_t id2) {
 
-    vector<bool, Alloc> src({I, I, I, O, I, I, I}, Alloc(offset1));
-    vector<bool, Alloc> dst({O, O, O, I, O, O, O}, Alloc(offset2));
+    vector<bool, Alloc> src({I, I, I, O, I, I, I}, Alloc(id1));
+    vector<bool, Alloc> dst({O, O, O, I, O, O, O}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
@@ -1009,8 +987,8 @@ void test_vb_swap(const size_t offset1, const size_t offset2) {
     assert_equal(src, {I, O, O, I, O, O, I, I});
     assert_equal(dst, {O, I, I, O, I, O, I, O});
 
-    assert(src.get_allocator().offset() == offset2);
-    assert(dst.get_allocator().offset() == offset1);
+    assert(src.get_allocator().id() == id2);
+    assert(dst.get_allocator().id() == id1);
 }
 
 void test_vb() {
@@ -1046,27 +1024,27 @@ void test_vb() {
 
 using PCII = pair<const int, int>;
 
-template <typename K, typename V, typename C, typename A>
+template <class K, typename V, typename C, typename A>
 auto GetIter(map<K, V, C, A>& c) {
     return prev(c.end());
 }
 
-template <typename K, typename V, typename C, typename A>
+template <class K, typename V, typename C, typename A>
 auto GetIter(multimap<K, V, C, A>& c) {
     return prev(c.end());
 }
 
-template <typename K, typename V, typename H, typename P, typename A>
+template <class K, typename V, typename H, typename P, typename A>
 auto GetIter(unordered_map<K, V, H, P, A>& c) {
     return c.begin();
 }
 
-template <typename K, typename V, typename H, typename P, typename A>
+template <class K, typename V, typename H, typename P, typename A>
 auto GetIter(unordered_multimap<K, V, H, P, A>& c) {
     return c.begin();
 }
 
-template <template <typename> class Map>
+template <template <class> class Map>
 void test_map_copy_ctor() {
 
     // Special: Test the (first, last, alloc) ctor.
@@ -1090,17 +1068,17 @@ void test_map_copy_ctor() {
     assert_is_permutation(src, {{10, 100}, {20, 200}, {30, 300}, {40, 400}});
     assert_is_permutation(dst, {{10, 100}, {20, 200}, {30, 300}, {50, 500}});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-template <template <typename> class Map>
-void test_map_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
+template <template <class> class Map>
+void test_map_copy_alloc_ctor(const size_t id1, const size_t id2) {
 
-    typename Map<StationaryAlloc<PCII>>::type src({{10, 100}, {20, 200}, {30, 300}}, StationaryAlloc<PCII>(offset1));
+    typename Map<StationaryAlloc<PCII>>::type src({{10, 100}, {20, 200}, {30, 300}}, StationaryAlloc<PCII>(id1));
     auto src_it = src.begin();
 
-    typename Map<StationaryAlloc<PCII>>::type dst(src, StationaryAlloc<PCII>(offset2));
+    typename Map<StationaryAlloc<PCII>>::type dst(src, StationaryAlloc<PCII>(id2));
     auto dst_it = dst.begin();
 
     assert(src_it->first * 10 == src_it->second);
@@ -1115,15 +1093,15 @@ void test_map_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_is_permutation(src, {{10, 100}, {20, 200}, {30, 300}, {40, 400}});
     assert_is_permutation(dst, {{10, 100}, {20, 200}, {30, 300}, {50, 500}});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <template <typename> class Map, typename Alloc>
-void test_map_copy_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <template <class> class Map, typename Alloc>
+void test_map_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(offset1));
-    typename Map<Alloc>::type dst({{0, 0}, {0, 0}, {0, 0}}, Alloc(offset2));
+    typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(id1));
+    typename Map<Alloc>::type dst({{0, 0}, {0, 0}, {0, 0}}, Alloc(id2));
 
     auto src_it = src.begin();
     auto dst_it = dst.begin();
@@ -1144,11 +1122,11 @@ void test_map_copy_assign(const size_t offset1, const size_t offset2, const size
     assert_is_permutation(src, {{10, 100}, {20, 200}, {30, 300}, {40, 400}});
     assert_is_permutation(dst, {{10, 100}, {20, 200}, {30, 300}, {50, 500}});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <template <typename> class Map>
+template <template <class> class Map>
 void test_map_move_ctor() {
 
     typename Map<StationaryAlloc<PCII>>::type src({{10, 100}, {20, 200}, {30, 300}}, StationaryAlloc<PCII>(11));
@@ -1173,19 +1151,19 @@ void test_map_move_ctor() {
     assert_is_permutation(src, {{40, 400}, {50, 500}, {60, 600}, {70, 700}});
     assert_is_permutation(dst, {{10, 100}, {20, 200}, {30, 300}, {80, 800}});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-template <template <typename> class Map>
-void test_map_move_alloc_ctor(const size_t offset1, const size_t offset2) {
+template <template <class> class Map>
+void test_map_move_alloc_ctor(const size_t id1, const size_t id2) {
 
-    typename Map<StationaryAlloc<PCII>>::type src({{10, 100}, {20, 200}, {30, 300}}, StationaryAlloc<PCII>(offset1));
+    typename Map<StationaryAlloc<PCII>>::type src({{10, 100}, {20, 200}, {30, 300}}, StationaryAlloc<PCII>(id1));
     auto it1 = src.begin();
 
-    typename Map<StationaryAlloc<PCII>>::type dst(move(src), StationaryAlloc<PCII>(offset2));
+    typename Map<StationaryAlloc<PCII>>::type dst(move(src), StationaryAlloc<PCII>(id2));
 
-    if (offset1 != offset2) {
+    if (id1 != id2) {
         it1 = dst.begin();
     }
 
@@ -1207,22 +1185,22 @@ void test_map_move_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_is_permutation(src, {{40, 400}, {50, 500}, {60, 600}, {70, 700}});
     assert_is_permutation(dst, {{10, 100}, {20, 200}, {30, 300}, {80, 800}});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <template <typename> class Map, typename Alloc>
-void test_map_move_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <template <class> class Map, typename Alloc>
+void test_map_move_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(offset1));
-    typename Map<Alloc>::type dst({{0, 0}, {0, 0}, {0, 0}}, Alloc(offset2));
+    typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(id1));
+    typename Map<Alloc>::type dst({{0, 0}, {0, 0}, {0, 0}}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
 
     dst = move(src);
 
-    if (offset1 != offset3) {
+    if (id1 != id3) {
         it1 = dst.begin();
     }
 
@@ -1244,15 +1222,15 @@ void test_map_move_assign(const size_t offset1, const size_t offset2, const size
     assert_is_permutation(src, {{40, 400}, {50, 500}, {60, 600}, {70, 700}});
     assert_is_permutation(dst, {{10, 100}, {20, 200}, {30, 300}, {80, 800}});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <template <typename> class Map, typename Alloc>
-void test_map_swap(const size_t offset1, const size_t offset2) {
+template <template <class> class Map, typename Alloc>
+void test_map_swap(const size_t id1, const size_t id2) {
 
-    typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(offset1));
-    typename Map<Alloc>::type dst({{40, 400}, {50, 500}, {60, 600}}, Alloc(offset2));
+    typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(id1));
+    typename Map<Alloc>::type dst({{40, 400}, {50, 500}, {60, 600}}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
@@ -1271,11 +1249,11 @@ void test_map_swap(const size_t offset1, const size_t offset2) {
     assert_is_permutation(src, {{40, 400}, {50, 500}, {60, 600}, {70, 700}});
     assert_is_permutation(dst, {{10, 100}, {20, 200}, {30, 300}, {80, 800}});
 
-    assert(src.get_allocator().offset() == offset2);
-    assert(dst.get_allocator().offset() == offset1);
+    assert(src.get_allocator().id() == id2);
+    assert(dst.get_allocator().id() == id1);
 }
 
-template <template <typename> class Map>
+template <template <class> class Map>
 void test_map() {
 
     test_map_copy_ctor<Map>();
@@ -1307,48 +1285,48 @@ void test_map() {
     test_map_swap<Map, SwapAlloc<PCII>>(11, 22); // POCS, always-equal allocators
 }
 
-template <typename Alloc>
+template <class Alloc>
 struct OrderedMap {
     using type = map<int, int, less<>, Alloc>;
 };
 
-template <typename Alloc>
+template <class Alloc>
 struct OrderedMultimap {
     using type = multimap<int, int, less<>, Alloc>;
 };
 
-template <typename Alloc>
+template <class Alloc>
 struct UnorderedMap {
     using type = unordered_map<int, int, hash<int>, equal_to<>, Alloc>;
 };
 
-template <typename Alloc>
+template <class Alloc>
 struct UnorderedMultimap {
     using type = unordered_multimap<int, int, hash<int>, equal_to<>, Alloc>;
 };
 
 
-template <typename K, typename C, typename A>
+template <class K, typename C, typename A>
 auto GetIter(set<K, C, A>& c) {
     return prev(c.end());
 }
 
-template <typename K, typename C, typename A>
+template <class K, typename C, typename A>
 auto GetIter(multiset<K, C, A>& c) {
     return prev(c.end());
 }
 
-template <typename K, typename H, typename P, typename A>
+template <class K, typename H, typename P, typename A>
 auto GetIter(unordered_set<K, H, P, A>& c) {
     return c.begin();
 }
 
-template <typename K, typename H, typename P, typename A>
+template <class K, typename H, typename P, typename A>
 auto GetIter(unordered_multiset<K, H, P, A>& c) {
     return c.begin();
 }
 
-template <template <typename> class Set>
+template <template <class> class Set>
 void test_set_copy_ctor() {
 
     // Special: Test the (first, last, alloc) ctor.
@@ -1372,17 +1350,17 @@ void test_set_copy_ctor() {
     assert_is_permutation(src, {10, 20, 30, 40});
     assert_is_permutation(dst, {10, 20, 30, 50});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-template <template <typename> class Set>
-void test_set_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
+template <template <class> class Set>
+void test_set_copy_alloc_ctor(const size_t id1, const size_t id2) {
 
-    typename Set<StationaryAlloc<int>>::type src({10, 20, 30}, StationaryAlloc<int>(offset1));
+    typename Set<StationaryAlloc<int>>::type src({10, 20, 30}, StationaryAlloc<int>(id1));
     auto src_it = src.begin();
 
-    typename Set<StationaryAlloc<int>>::type dst(src, StationaryAlloc<int>(offset2));
+    typename Set<StationaryAlloc<int>>::type dst(src, StationaryAlloc<int>(id2));
     auto dst_it = dst.begin();
 
     assert(*src_it % 10 == 0);
@@ -1397,15 +1375,15 @@ void test_set_copy_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_is_permutation(src, {10, 20, 30, 40});
     assert_is_permutation(dst, {10, 20, 30, 50});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <template <typename> class Set, typename Alloc>
-void test_set_copy_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <template <class> class Set, typename Alloc>
+void test_set_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    typename Set<Alloc>::type src({10, 20, 30}, Alloc(offset1));
-    typename Set<Alloc>::type dst({0, 0, 0}, Alloc(offset2));
+    typename Set<Alloc>::type src({10, 20, 30}, Alloc(id1));
+    typename Set<Alloc>::type dst({0, 0, 0}, Alloc(id2));
 
     auto src_it = src.begin();
     auto dst_it = dst.begin();
@@ -1426,11 +1404,11 @@ void test_set_copy_assign(const size_t offset1, const size_t offset2, const size
     assert_is_permutation(src, {10, 20, 30, 40});
     assert_is_permutation(dst, {10, 20, 30, 50});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <template <typename> class Set>
+template <template <class> class Set>
 void test_set_move_ctor() {
 
     typename Set<StationaryAlloc<int>>::type src({10, 20, 30}, StationaryAlloc<int>(11));
@@ -1455,19 +1433,19 @@ void test_set_move_ctor() {
     assert_is_permutation(src, {40, 50, 60, 70});
     assert_is_permutation(dst, {10, 20, 30, 80});
 
-    assert(src.get_allocator().offset() == 11);
-    assert(dst.get_allocator().offset() == 11);
+    assert(src.get_allocator().id() == 11);
+    assert(dst.get_allocator().id() == 11);
 }
 
-template <template <typename> class Set>
-void test_set_move_alloc_ctor(const size_t offset1, const size_t offset2) {
+template <template <class> class Set>
+void test_set_move_alloc_ctor(const size_t id1, const size_t id2) {
 
-    typename Set<StationaryAlloc<int>>::type src({10, 20, 30}, StationaryAlloc<int>(offset1));
+    typename Set<StationaryAlloc<int>>::type src({10, 20, 30}, StationaryAlloc<int>(id1));
     auto it1 = src.begin();
 
-    typename Set<StationaryAlloc<int>>::type dst(move(src), StationaryAlloc<int>(offset2));
+    typename Set<StationaryAlloc<int>>::type dst(move(src), StationaryAlloc<int>(id2));
 
-    if (offset1 != offset2) {
+    if (id1 != id2) {
         it1 = dst.begin();
     }
 
@@ -1489,22 +1467,22 @@ void test_set_move_alloc_ctor(const size_t offset1, const size_t offset2) {
     assert_is_permutation(src, {40, 50, 60, 70});
     assert_is_permutation(dst, {10, 20, 30, 80});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset2);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id2);
 }
 
-template <template <typename> class Set, typename Alloc>
-void test_set_move_assign(const size_t offset1, const size_t offset2, const size_t offset3) {
+template <template <class> class Set, typename Alloc>
+void test_set_move_assign(const size_t id1, const size_t id2, const size_t id3) {
 
-    typename Set<Alloc>::type src({10, 20, 30}, Alloc(offset1));
-    typename Set<Alloc>::type dst({0, 0, 0}, Alloc(offset2));
+    typename Set<Alloc>::type src({10, 20, 30}, Alloc(id1));
+    typename Set<Alloc>::type dst({0, 0, 0}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
 
     dst = move(src);
 
-    if (offset1 != offset3) {
+    if (id1 != id3) {
         it1 = dst.begin();
     }
 
@@ -1526,15 +1504,15 @@ void test_set_move_assign(const size_t offset1, const size_t offset2, const size
     assert_is_permutation(src, {40, 50, 60, 70});
     assert_is_permutation(dst, {10, 20, 30, 80});
 
-    assert(src.get_allocator().offset() == offset1);
-    assert(dst.get_allocator().offset() == offset3);
+    assert(src.get_allocator().id() == id1);
+    assert(dst.get_allocator().id() == id3);
 }
 
-template <template <typename> class Set, typename Alloc>
-void test_set_swap(const size_t offset1, const size_t offset2) {
+template <template <class> class Set, typename Alloc>
+void test_set_swap(const size_t id1, const size_t id2) {
 
-    typename Set<Alloc>::type src({10, 20, 30}, Alloc(offset1));
-    typename Set<Alloc>::type dst({40, 50, 60}, Alloc(offset2));
+    typename Set<Alloc>::type src({10, 20, 30}, Alloc(id1));
+    typename Set<Alloc>::type dst({40, 50, 60}, Alloc(id2));
 
     auto it1 = src.begin();
     auto it2 = dst.begin();
@@ -1553,11 +1531,11 @@ void test_set_swap(const size_t offset1, const size_t offset2) {
     assert_is_permutation(src, {40, 50, 60, 70});
     assert_is_permutation(dst, {10, 20, 30, 80});
 
-    assert(src.get_allocator().offset() == offset2);
-    assert(dst.get_allocator().offset() == offset1);
+    assert(src.get_allocator().id() == id2);
+    assert(dst.get_allocator().id() == id1);
 }
 
-template <template <typename> class Set>
+template <template <class> class Set>
 void test_set() {
 
     test_set_copy_ctor<Set>();
@@ -1589,22 +1567,22 @@ void test_set() {
     test_set_swap<Set, SwapEqualAlloc<int>>(11, 22); // POCS, always-equal allocators
 }
 
-template <typename Alloc>
+template <class Alloc>
 struct OrderedSet {
     using type = set<int, less<>, Alloc>;
 };
 
-template <typename Alloc>
+template <class Alloc>
 struct OrderedMultiset {
     using type = multiset<int, less<>, Alloc>;
 };
 
-template <typename Alloc>
+template <class Alloc>
 struct UnorderedSet {
     using type = unordered_set<int, hash<int>, equal_to<>, Alloc>;
 };
 
-template <typename Alloc>
+template <class Alloc>
 struct UnorderedMultiset {
     using type = unordered_multiset<int, hash<int>, equal_to<>, Alloc>;
 };

From f97defad4292b3f3ba2728335be5b3bd92e046c9 Mon Sep 17 00:00:00 2001
From: Michael Schellenberger Costa <mschellenbergercosta@googlemail.com>
Date: Thu, 2 Sep 2021 17:10:53 +0200
Subject: [PATCH 3/8] Add Bug citation for EDG

---
 tests/std/tests/VSO_0000000_allocator_propagation/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
index 523a93302b5..4ec2fcf5ee4 100644
--- a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
+++ b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
@@ -1653,7 +1653,7 @@ int main() {
     test_sequence<deque>();
     test_sequence<list>();
     test_sequence<vector>();
-#if _HAS_CXX20 && !defined(__EDG__)
+#if _HAS_CXX20 && !defined(__EDG__) // TRANSITION, VSO-1273365 && VSO-1520773
     static_assert(test_sequence<vector>());
 #endif // _HAS_CXX20
 

From 4fc4765bb4031759ac15e80e6101acaf103d7a95 Mon Sep 17 00:00:00 2001
From: Casey Carter <cartec69@gmail.com>
Date: Thu, 2 Sep 2021 12:07:20 -0700
Subject: [PATCH 4/8] Typo in tests/std/tests/VSO_0000000_allocator_propagation

---
 tests/std/tests/VSO_0000000_allocator_propagation/test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
index 4ec2fcf5ee4..057fa047df3 100644
--- a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
+++ b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
@@ -1653,7 +1653,7 @@ int main() {
     test_sequence<deque>();
     test_sequence<list>();
     test_sequence<vector>();
-#if _HAS_CXX20 && !defined(__EDG__) // TRANSITION, VSO-1273365 && VSO-1520773
+#if _HAS_CXX20 && !defined(__EDG__) // TRANSITION, VSO-1273365 && DevCom-1520773
     static_assert(test_sequence<vector>());
 #endif // _HAS_CXX20
 

From 74cd839c750b6e520af89d9f862fc6664214aded Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@nuwen.net>
Date: Thu, 2 Sep 2021 18:32:51 -0700
Subject: [PATCH 5/8] Make the test classier, like a tuxedo cat!

---
 .../test.cpp                                  | 36 +++++++++----------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
index 057fa047df3..fb83fac3e11 100644
--- a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
+++ b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
@@ -143,7 +143,7 @@ _CONSTEXPR20 void test_sequence_copy_alloc_ctor(const size_t id1, const size_t i
     assert(dst.get_allocator().id() == id2);
 }
 
-template <template <class, class> class Sequence, typename Alloc>
+template <template <class, class> class Sequence, class Alloc>
 _CONSTEXPR20 void test_sequence_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
     Sequence<int, Alloc> src({10, 20, 30}, Alloc(id1));
     Sequence<int, Alloc> dst({0, 0, 0}, Alloc(id2));
@@ -232,7 +232,7 @@ _CONSTEXPR20 void test_sequence_move_alloc_ctor(const size_t id1, const size_t i
     assert(dst.get_allocator().id() == id2);
 }
 
-template <template <class, class> class Sequence, typename Alloc>
+template <template <class, class> class Sequence, class Alloc>
 _CONSTEXPR20 void test_sequence_move_assign(const size_t id1, const size_t id2, const size_t id3) {
     Sequence<int, Alloc> src({10, 20, 30}, Alloc(id1));
     Sequence<int, Alloc> dst({0, 0, 0}, Alloc(id2));
@@ -268,7 +268,7 @@ _CONSTEXPR20 void test_sequence_move_assign(const size_t id1, const size_t id2,
     assert(dst.get_allocator().id() == id3);
 }
 
-template <template <class, class> class Sequence, typename Alloc>
+template <template <class, class> class Sequence, class Alloc>
 _CONSTEXPR20 void test_sequence_swap(const size_t id1, const size_t id2) {
     Sequence<int, Alloc> src({10, 20, 30}, Alloc(id1));
     Sequence<int, Alloc> dst({40, 50, 60}, Alloc(id2));
@@ -1024,22 +1024,22 @@ void test_vb() {
 
 using PCII = pair<const int, int>;
 
-template <class K, typename V, typename C, typename A>
+template <class K, class V, class C, class A>
 auto GetIter(map<K, V, C, A>& c) {
     return prev(c.end());
 }
 
-template <class K, typename V, typename C, typename A>
+template <class K, class V, class C, class A>
 auto GetIter(multimap<K, V, C, A>& c) {
     return prev(c.end());
 }
 
-template <class K, typename V, typename H, typename P, typename A>
+template <class K, class V, class H, class P, class A>
 auto GetIter(unordered_map<K, V, H, P, A>& c) {
     return c.begin();
 }
 
-template <class K, typename V, typename H, typename P, typename A>
+template <class K, class V, class H, class P, class A>
 auto GetIter(unordered_multimap<K, V, H, P, A>& c) {
     return c.begin();
 }
@@ -1097,7 +1097,7 @@ void test_map_copy_alloc_ctor(const size_t id1, const size_t id2) {
     assert(dst.get_allocator().id() == id2);
 }
 
-template <template <class> class Map, typename Alloc>
+template <template <class> class Map, class Alloc>
 void test_map_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
 
     typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(id1));
@@ -1189,7 +1189,7 @@ void test_map_move_alloc_ctor(const size_t id1, const size_t id2) {
     assert(dst.get_allocator().id() == id2);
 }
 
-template <template <class> class Map, typename Alloc>
+template <template <class> class Map, class Alloc>
 void test_map_move_assign(const size_t id1, const size_t id2, const size_t id3) {
 
     typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(id1));
@@ -1226,7 +1226,7 @@ void test_map_move_assign(const size_t id1, const size_t id2, const size_t id3)
     assert(dst.get_allocator().id() == id3);
 }
 
-template <template <class> class Map, typename Alloc>
+template <template <class> class Map, class Alloc>
 void test_map_swap(const size_t id1, const size_t id2) {
 
     typename Map<Alloc>::type src({{10, 100}, {20, 200}, {30, 300}}, Alloc(id1));
@@ -1306,22 +1306,22 @@ struct UnorderedMultimap {
 };
 
 
-template <class K, typename C, typename A>
+template <class K, class C, class A>
 auto GetIter(set<K, C, A>& c) {
     return prev(c.end());
 }
 
-template <class K, typename C, typename A>
+template <class K, class C, class A>
 auto GetIter(multiset<K, C, A>& c) {
     return prev(c.end());
 }
 
-template <class K, typename H, typename P, typename A>
+template <class K, class H, class P, class A>
 auto GetIter(unordered_set<K, H, P, A>& c) {
     return c.begin();
 }
 
-template <class K, typename H, typename P, typename A>
+template <class K, class H, class P, class A>
 auto GetIter(unordered_multiset<K, H, P, A>& c) {
     return c.begin();
 }
@@ -1379,7 +1379,7 @@ void test_set_copy_alloc_ctor(const size_t id1, const size_t id2) {
     assert(dst.get_allocator().id() == id2);
 }
 
-template <template <class> class Set, typename Alloc>
+template <template <class> class Set, class Alloc>
 void test_set_copy_assign(const size_t id1, const size_t id2, const size_t id3) {
 
     typename Set<Alloc>::type src({10, 20, 30}, Alloc(id1));
@@ -1471,7 +1471,7 @@ void test_set_move_alloc_ctor(const size_t id1, const size_t id2) {
     assert(dst.get_allocator().id() == id2);
 }
 
-template <template <class> class Set, typename Alloc>
+template <template <class> class Set, class Alloc>
 void test_set_move_assign(const size_t id1, const size_t id2, const size_t id3) {
 
     typename Set<Alloc>::type src({10, 20, 30}, Alloc(id1));
@@ -1508,7 +1508,7 @@ void test_set_move_assign(const size_t id1, const size_t id2, const size_t id3)
     assert(dst.get_allocator().id() == id3);
 }
 
-template <template <class> class Set, typename Alloc>
+template <template <class> class Set, class Alloc>
 void test_set_swap(const size_t id1, const size_t id2) {
 
     typename Set<Alloc>::type src({10, 20, 30}, Alloc(id1));
@@ -1655,7 +1655,7 @@ int main() {
     test_sequence<vector>();
 #if _HAS_CXX20 && !defined(__EDG__) // TRANSITION, VSO-1273365 && DevCom-1520773
     static_assert(test_sequence<vector>());
-#endif // _HAS_CXX20
+#endif // _HAS_CXX20 && !defined(__EDG__)
 
     test_flist();
     test_string();

From 35c0a062a2062664bc1555a9f288ffec09020142 Mon Sep 17 00:00:00 2001
From: Michael Schellenberger Costa <mschellenbergercosta@googlemail.com>
Date: Tue, 7 Sep 2021 10:25:08 +0200
Subject: [PATCH 6/8] Cleanup move assignment

---
 stl/inc/vector | 94 ++++++++++++++++++++++++++------------------------
 1 file changed, 49 insertions(+), 45 deletions(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index 9cbffbbb89b..a4a56fcb84d 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -570,13 +570,27 @@ public:
             return *this;
         }
 
-        if (_Getal() == _Right._Getal()) {
-            _Tidy();
-            _Pocma(_Getal(), _Right._Getal());
-            _Mypair._Myval2._Take_contents(_Right._Mypair._Myval2);
-        } else if constexpr (!is_same_v<_Choose_pocma<_Alty>, _Equal_allocators>) {
-            _Move_assign_unequal_alloc(_Right);
+        _Alty& _Al       = _Getal();
+        _Alty& _Right_al = _Right._Getal();
+        if constexpr (is_same_v<_Choose_pocma<_Alty>, _No_propagate_allocators>) {
+            if (_Al != _Right_al) {
+                _Move_assign_unequal_alloc(_Right);
+                return *this;
+            }
+        }
+
+        _Tidy();
+#if _ITERATOR_DEBUG_LEVEL != 0
+        if constexpr (is_same_v<_Choose_pocma<_Alty>, _Propagate_allocators>) {
+            if (_Al != _Right_al) {
+                // intentionally slams into noexcept on OOM, TRANSITION, VSO-466800
+                _Mypair._Myval2._Reload_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Al), _GET_PROXY_ALLOCATOR(_Alty, _Right_al));
+            }
         }
+#endif // _ITERATOR_DEBUG_LEVEL != 0
+
+        _Pocma(_Al, _Right_al);
+        _Mypair._Myval2._Take_contents(_Right._Mypair._Myval2);
         return *this;
     }
 
@@ -1668,55 +1682,45 @@ private:
         _Proxy._Release();
     }
 
-    _CONSTEXPR20 void _Move_assign_unequal_alloc(vector& _Right) noexcept(
-        !is_same_v<_Choose_pocma<_Alty>, _No_propagate_allocators>) {
+    _CONSTEXPR20 void _Move_assign_unequal_alloc(vector& _Right) {
         auto& _Al         = _Getal();
         auto& _My_data    = _Mypair._Myval2;
         auto& _Right_data = _Right._Mypair._Myval2;
-        if constexpr (is_same_v<_Choose_pocma<_Alty>, _Propagate_allocators>) {
-            _Tidy();
-#if _ITERATOR_DEBUG_LEVEL != 0
-            // intentionally slams into noexcept on OOM, TRANSITION, VSO-466800
-            _My_data._Reload_proxy(_GET_PROXY_ALLOCATOR(_Alty, _Al), _GET_PROXY_ALLOCATOR(_Alty, _Right._Getal()));
-#endif // _ITERATOR_DEBUG_LEVEL != 0
-            _Pocma(_Al, _Right._Getal());
-            _My_data._Take_contents(_Right_data);
-        } else {
-            const pointer _First = _Right_data._Myfirst;
-            const pointer _Last  = _Right_data._Mylast;
-            const auto _Newsize  = static_cast<size_type>(_Last - _First);
 
-            pointer& _Myfirst = _My_data._Myfirst;
-            pointer& _Mylast  = _My_data._Mylast;
+        const pointer _First = _Right_data._Myfirst;
+        const pointer _Last  = _Right_data._Mylast;
+        const auto _Newsize  = static_cast<size_type>(_Last - _First);
 
-            _My_data._Orphan_all();
+        pointer& _Myfirst = _My_data._Myfirst;
+        pointer& _Mylast  = _My_data._Mylast;
 
-            const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
-            if constexpr (conjunction_v<bool_constant<_Ptr_copy_cat<_Ty*, _Ty*>::_Trivially_copyable>,
-                              _Uses_default_construct<_Alty, _Ty*, _Ty>, _Uses_default_destroy<_Alty, _Ty*>>) {
-                if (_Newsize > _Oldcapacity) {
-                    _Clear_and_reserve_geometric(_Newsize);
-                }
+        _My_data._Orphan_all();
 
-                _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
-            } else {
-                auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
+        if constexpr (conjunction_v<bool_constant<_Ptr_copy_cat<_Ty*, _Ty*>::_Trivially_copyable>,
+                          _Uses_default_construct<_Alty, _Ty*, _Ty>, _Uses_default_destroy<_Alty, _Ty*>>) {
+            if (_Newsize > _Oldcapacity) {
+                _Clear_and_reserve_geometric(_Newsize);
+            }
 
-                if (_Newsize > _Oldsize) {
-                    if (_Newsize > _Oldcapacity) { // reallocate
-                        _Clear_and_reserve_geometric(_Newsize);
-                        _Oldsize = 0;
-                    }
+            _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
+        } else {
+            auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
 
-                    const pointer _Mid = _First + _Oldsize;
-                    _Move_unchecked(_First, _Mid, _Myfirst);
-                    _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
-                } else {
-                    const pointer _Newlast = _Myfirst + _Newsize;
-                    _Move_unchecked(_First, _Last, _Myfirst);
-                    _Destroy_range(_Newlast, _Mylast, _Al);
-                    _Mylast = _Newlast;
+            if (_Newsize > _Oldsize) {
+                if (_Newsize > _Oldcapacity) { // reallocate
+                    _Clear_and_reserve_geometric(_Newsize);
+                    _Oldsize = 0;
                 }
+
+                const pointer _Mid = _First + _Oldsize;
+                _Move_unchecked(_First, _Mid, _Myfirst);
+                _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
+            } else {
+                const pointer _Newlast = _Myfirst + _Newsize;
+                _Move_unchecked(_First, _Last, _Myfirst);
+                _Destroy_range(_Newlast, _Mylast, _Al);
+                _Mylast = _Newlast;
             }
         }
     }

From 102e358898c52897815ce3ce476d55c7edd7b03e Mon Sep 17 00:00:00 2001
From: Michael Schellenberger Costa <mschellenbergercosta@googlemail.com>
Date: Tue, 7 Sep 2021 21:01:08 +0200
Subject: [PATCH 7/8] Clean up the different assignment helpers

---
 stl/inc/vector | 85 +++++++++++++++++---------------------------------
 1 file changed, 29 insertions(+), 56 deletions(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index a4a56fcb84d..35d6f104f44 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -983,17 +983,16 @@ public:
         pointer& _Mylast  = _My_data._Mylast;
 
         _My_data._Orphan_all();
+        const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
+        if (_Newsize > _Oldcapacity) { // reallocate
+            _Clear_and_reserve_geometric(_Newsize);
+            _Mylast = _Uninitialized_fill_n(_My_data._Myfirst, _Newsize, _Val, _Al);
+            return;
+        }
 
-        auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
         if (_Newsize > _Oldsize) {
-            const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
-            if (_Newsize > _Oldcapacity) { // reallocate
-                _Clear_and_reserve_geometric(_Newsize);
-                _Oldsize = 0;
-            } else {
-                _STD fill(_Myfirst, _Mylast, _Val);
-            }
-
+            _STD fill(_Myfirst, _Mylast, _Val);
             _Mylast = _Uninitialized_fill_n(_Mylast, _Newsize - _Oldsize, _Val, _Al);
         } else {
             const pointer _Newlast = _Myfirst + _Newsize;
@@ -1045,32 +1044,15 @@ private:
         pointer& _Myend     = _My_data._Myend;
 
         _My_data._Orphan_all();
-
-        if constexpr (conjunction_v<bool_constant<_Ptr_copy_cat<_Iter, _Ty*>::_Trivially_copyable>,
-                          _Uses_default_construct<_Alty, _Ty*, decltype(*_First)>,
-                          _Uses_default_destroy<_Alty, _Ty*>>) {
-#if _HAS_CXX20
-            if (!_STD is_constant_evaluated())
-#endif // _HAS_CXX20
-            {
-                const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
-                if (_Newsize > _Oldcapacity) {
-                    _Clear_and_reserve_geometric(_Newsize);
-                }
-
-                _Mylast = _Refancy<pointer>(_Copy_memmove(_First, _Last, _Unfancy(_Myfirst)));
-                return;
-            }
+        const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
+        if (_Newsize > _Oldcapacity) {
+            _Clear_and_reserve_geometric(_Newsize);
+            _Mylast = _Uninitialized_copy(_First, _Last, _My_data._Myfirst, _Al);
+            return;
         }
-        auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
 
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
         if (_Newsize > _Oldsize) {
-            const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
-            if (_Newsize > _Oldcapacity) { // reallocate
-                _Clear_and_reserve_geometric(_Newsize);
-                _Oldsize = 0;
-            }
-
             // performance note: traversing [_First, _Mid) twice
             const _Iter _Mid = _STD next(_First, static_cast<difference_type>(_Oldsize));
             _Copy_unchecked(_First, _Mid, _Myfirst);
@@ -1695,33 +1677,24 @@ private:
         pointer& _Mylast  = _My_data._Mylast;
 
         _My_data._Orphan_all();
-
+        _My_data._Orphan_all();
         const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
-        if constexpr (conjunction_v<bool_constant<_Ptr_copy_cat<_Ty*, _Ty*>::_Trivially_copyable>,
-                          _Uses_default_construct<_Alty, _Ty*, _Ty>, _Uses_default_destroy<_Alty, _Ty*>>) {
-            if (_Newsize > _Oldcapacity) {
-                _Clear_and_reserve_geometric(_Newsize);
-            }
+        if (_Newsize > _Oldcapacity) {
+            _Clear_and_reserve_geometric(_Newsize);
+            _Mylast = _Uninitialized_move(_First, _Last, _My_data._Myfirst, _Al);
+            return;
+        }
 
-            _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
+        const auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
+        if (_Newsize > _Oldsize) {
+            const pointer _Mid = _First + _Oldsize;
+            _Move_unchecked(_First, _Mid, _Myfirst);
+            _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
         } else {
-            auto _Oldsize = static_cast<size_type>(_Mylast - _Myfirst);
-
-            if (_Newsize > _Oldsize) {
-                if (_Newsize > _Oldcapacity) { // reallocate
-                    _Clear_and_reserve_geometric(_Newsize);
-                    _Oldsize = 0;
-                }
-
-                const pointer _Mid = _First + _Oldsize;
-                _Move_unchecked(_First, _Mid, _Myfirst);
-                _Mylast = _Uninitialized_move(_Mid, _Last, _Mylast, _Al);
-            } else {
-                const pointer _Newlast = _Myfirst + _Newsize;
-                _Move_unchecked(_First, _Last, _Myfirst);
-                _Destroy_range(_Newlast, _Mylast, _Al);
-                _Mylast = _Newlast;
-            }
+            const pointer _Newlast = _Myfirst + _Newsize;
+            _Move_unchecked(_First, _Last, _Myfirst);
+            _Destroy_range(_Newlast, _Mylast, _Al);
+            _Mylast = _Newlast;
         }
     }
 

From 5f7fb298c8bae298a150680929eadf64e54d45a5 Mon Sep 17 00:00:00 2001
From: Michael Schellenberger Costa <mschellenbergercosta@gmail.com>
Date: Wed, 8 Sep 2021 07:51:27 +0200
Subject: [PATCH 8/8] Apply suggestions from code review

Co-authored-by: Casey Carter <cartec69@gmail.com>
---
 stl/inc/vector                                             | 7 +++----
 tests/std/tests/VSO_0000000_allocator_propagation/test.cpp | 1 -
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/stl/inc/vector b/stl/inc/vector
index 35d6f104f44..d300d12e32f 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -986,7 +986,7 @@ public:
         const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
         if (_Newsize > _Oldcapacity) { // reallocate
             _Clear_and_reserve_geometric(_Newsize);
-            _Mylast = _Uninitialized_fill_n(_My_data._Myfirst, _Newsize, _Val, _Al);
+            _Mylast = _Uninitialized_fill_n(_Myfirst, _Newsize, _Val, _Al);
             return;
         }
 
@@ -1047,7 +1047,7 @@ private:
         const auto _Oldcapacity = static_cast<size_type>(_Myend - _Myfirst);
         if (_Newsize > _Oldcapacity) {
             _Clear_and_reserve_geometric(_Newsize);
-            _Mylast = _Uninitialized_copy(_First, _Last, _My_data._Myfirst, _Al);
+            _Mylast = _Uninitialized_copy(_First, _Last, _Myfirst, _Al);
             return;
         }
 
@@ -1676,12 +1676,11 @@ private:
         pointer& _Myfirst = _My_data._Myfirst;
         pointer& _Mylast  = _My_data._Mylast;
 
-        _My_data._Orphan_all();
         _My_data._Orphan_all();
         const auto _Oldcapacity = static_cast<size_type>(_My_data._Myend - _Myfirst);
         if (_Newsize > _Oldcapacity) {
             _Clear_and_reserve_geometric(_Newsize);
-            _Mylast = _Uninitialized_move(_First, _Last, _My_data._Myfirst, _Al);
+            _Mylast = _Uninitialized_move(_First, _Last, _Myfirst, _Al);
             return;
         }
 
diff --git a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
index fb83fac3e11..627143040e7 100644
--- a/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
+++ b/tests/std/tests/VSO_0000000_allocator_propagation/test.cpp
@@ -33,7 +33,6 @@ _CONSTEXPR20 void assert_is_permutation(const Container& cont, initializer_list<
     assert(is_permutation(cont.begin(), cont.end(), il.begin(), il.end()));
 }
 
-
 template <class T, class POCCA, class POCMA, class POCS, class EQUAL>
 class MyAlloc {
 private: