Add a buildkite for _LIBCPP_DEBUG=1.

[• Quuxplusone]

Summary

Add a debug-mode CI step.
My general roadmap is intended to be:

• Land the changes to Generic-debug-iterators.cmake, run-buildbot, and buildkite-pipeline.yml, plus marking all offending tests as UNSUPPORTED: LIBCXX-DEBUG-FIXME.
• Land the fix to support N3644 "Null Forward Iterators" in debug mode (D100881). (This is done.)
• Land a fix to <span> (D101003) and unmark those tests.
• Fix other failures, unmarking tests that pass, and changing others from UNSUPPORTED: LIBCXX-DEBUG-FIXME to UNSUPPORTED: debug_level_0, debug_level_1 as appropriate. (This is done, locally. I haven't submitted PRs for them yet though.)
• Don't leave any LIBCXX-DEBUG-FIXME tests in master at the end of this whole process.
• Remove the LIBCXX-DEBUG-FIXME feature from Generic-debug-iterators.cmake.

To run llvm-lit manually from the command line:

    
./bin/llvm-lit -sv --param std=c++2b --param cxx_under_test=`pwd`/bin/clang \
    --param debug_level=1 ../libcxx/test/

[Mordante]

Nice to see another improvement to our build pipeline, thanks for working on it! The general approach looks good to me.

libcxx/src/debug.cpp

441

This seems trivial, but I think it should land in a separate commit. (I don't mind to do that after accepting this patch.)
I assume this is what you mean with "Land the fix to support N3644 "Null Forward Iterators" in debug mode." correct?

Just curious how did you discover this?

libcxx/utils/ci/buildkite-pipeline.yml

68–69

I'm not to fond of "Debug mode", it sounds too generic for me. How do you feel about "Debug iterators"?

[• Quuxplusone]

s/Debug Mode/Debug iterators/
Fix quoting in CMake file (I hope).
Remove N3644 fix to see how many tests it affects.

[• Quuxplusone]

[libc++] [test] Stop using invalid iterators to insert into sets/maps. (Applies 4c80bfbd53caf consistently across associative and unord tests.)
[libc++] std::advance shouldn't use ADL >= on the _Distance type.

[• Quuxplusone]

[libc++] [test] Our __debug_less breaks some complexity guarantees.
[libc++] [test] Iterating a string::iterator "off the end" is UB.
[libc++] Paper over a bug in string::assign.
[libc++] <span>, like <string_view>, has no use for debug iterators.
[libc++] Constexpr char_traits::copy mustn't compare unrelated pointers.

[• Quuxplusone]

libcxx/src/debug.cpp

441

It all started with D100029. :) That led to looking at _LIBCPP_DEBUG == 2 assertions, which led to looking at all code under #if _LIBCPP_DEBUG == 2 (and incidentally D100737 too), which led to D100730, which revealed that <span> was completely broken in debug mode, we just didn't have any tests specifically for span-in-debug-mode. So, since the apparent intent is that everything should just work in debug mode... let's test it!

Running tests locally with -D_LIBCPP_DEBUG=1 turned up some failures due to N3644 immediately, so it just happened that I fixed this line before finishing the buildkite-related parts of the patch. Then I ran tests locally and marked the remaining offenders with XFAIL; but, having already fixed N3644, I didn't actually know how many tests are affected by it — just "at least one."

But now I know, and have filed D100881! :)

libcxx/utils/libcxx/test/config.py

484

I still haven't figured out why https://buildkite.com/llvm-project/libcxx-ci/builds/2676#7b1ae675-f9cd-4f9d-8b4a-6db9ec8f8e53 is so unhappy with this script now...

[curdeius]

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp

38

What's the reason for this and similar changes?

libcxx/utils/libcxx/test/config.py

484

@Quuxplusone, I have a similar failure when cmake chooses gcc 9 (without -std=c++2b flag), but it doesn't happen with a newer compiler nor with std=c++20.

[• Quuxplusone]

Try changing Generic-debug.cmake as

 set(LIBCXX_TEST_PARAMS "std=c++2b" "debug_level=1" "additional_features=LIBCXX-DEBUG-FIXME" CACHE STRING "")
-set(LIBCXXABI_TEST_PARAMS "${LIBCXX_TEST_PARAMS}" CACHE STRING "")
+set(LIBCXXABI_TEST_PARAMS "std=c++2b" CACHE STRING "")

to see if that fixes the cryptic failure.

[• Quuxplusone]

Keep trying to solve this "flag None" issue in the Python.

[• Quuxplusone]

Figured out how to run this locally, and I think I've diagnosed the problem: If you set the lit parameter std=c++2b (not via llvm-lit --param but via the weird cmake technique used in the buildbot scripts), and the system compiler doesn't support -std=c++2b, then you get this error:

AssertionError: Trying to enable compile flag None, which is not supported

Changing to std=c++20 fixes it locally for me. I'm hoping that changing the compiler to clang-tot (copied from the generic-cxx2b section of the script) will fix it just as well on buildkite, without needing to abandon C++2b. If this still fails on buildkite, my backup plan is to change it to std=c++20 for now.

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp

38

[libc++] [test] Stop using invalid iterators to insert into sets/maps. (Applies 4c80bfbd53caf consistently across associative and unord tests.)

[libc++] [test] Stop using invalid iterators to insert into sets/maps.

This simply applies Howard's commit 4c80bfbd53caf consistently
across all the associative and unordered container tests.

"unord.set/insert_hint_const_lvalue.pass.cpp" failed with `-D_LIBCPP_DEBUG=1`
before this patch; it was the only one that incorrectly reused
invalid iterator `e`. The others already used valid iterators
(generally `c.end()`); I'm just making them all match the same pattern
of usage: "e, then r, then c.end() for the rest."

libcxx/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp

36

(@curdeius : Here's the one where the test was actually using an invalidated iterator e.)

[• Quuxplusone]

Eliminate all my fixes from this review, now that buildkite is happy. Now this review consists only of what will be committed as a single commit, following my original "roadmap" idea. Tests that fail at the moment are marked XFAIL; I'll submit PRs to fix them individually.

[Mordante]

In D100866#2705673, @Quuxplusone wrote:

Eliminate all my fixes from this review, now that buildkite is happy. Now this review consists only of what will be committed as a single commit, following my original "roadmap" idea. Tests that fail at the moment are marked XFAIL; I'll submit PRs to fix them individually.

Seems you forgot to restore the removed builds from libcxx/utils/ci/buildkite-pipeline.yml
Can you update this file to give the patch a full CI run.

libcxx/src/debug.cpp

441

Thanks for the information and the new patch.

[ldionne]

This is indeed quite nice! Some comments, but I love that we're adding this.

libcxx/cmake/caches/Generic-debug.cmake

2

This shouldn't set std=c++2b explicitly, I believe we should be using the default here.

libcxx/utils/ci/run-buildbot

518

Should be clang and clang++, like the other jobs?

Also, please move close to the generic-no-debug) step.

libcxx/utils/libcxx/test/config.py

484

You can rebase on top of 3d8f2059b95d3e9d6785255949283b258d7ca121.

[• Quuxplusone]

libcxx/cmake/caches/Generic-debug.cmake

2

I want to make sure that we're testing new features as soon as they're pull-requested; testing only C++14 mode wouldn't have caught the issues with <span>. Of course we could add debug-mode testing for multiple versions, like std=c++03 AND std=c++2b and maybe something in between; I thought that was overkill, but I'd do it if you want it.

I don't think we want to be testing only C++14, though; I think we want at least C++20, and I see only upsides to testing C++2b (given that the goal here is to catch things at pull-request time, and people tend to pull-request mostly features that are enabled in '20 and '2b, not '14 anymore).

How about if I provide just generic-cxx03-debug and generic-cxx2b-debug, with those names? (This also helps to indicate that they're not the opposite of generic-no-debug, as brought up below.)

libcxx/utils/ci/run-buildbot

518

(A) clang-tot turned out to be the magic incantation that makes the std=c++2b parameter work. Compare to the generic-cxx2b) case. (If we stopped trying to test 2b pull requests and went to 20 or earlier, then this could indeed be just clang.)

(B) Will do. But notice that generic-no-debug is actually talking about a build configuration that doesn't build debug.cpp into the library; it's not the "opposite" of generic-debug. All of generic-no-{debug,filesystem,localization,random_device} have the same structure of "normal compilation, just don't link in some .cpp files to the library."

libcxx/utils/libcxx/test/config.py

484

I'll do so. But actually I'm pretty sure that all the trouble I had was completely due to writing clang/std=c++2b instead of (either clang-tot/std=c++2b or clang/std=c++20) above.

[• Quuxplusone]

Jobs for generic-cxx03-debug and generic-cxx2b-debug.
Rebase.

[• Quuxplusone]

Rebase, and change XFAIL to UNSUPPORTED.
(Many of these tests pass in C++03 mode but fail in C++11 mode, so XFAIL is wrong.)

[ldionne]

@Quuxplusone

I want to make sure that we're testing new features as soon as they're pull-requested; testing only C++14 mode wouldn't have caught the issues with <span>. Of course we could add debug-mode testing for multiple versions, like std=c++03 AND std=c++2b and maybe something in between; I thought that was overkill, but I'd do it if you want it.

We agree that testing only C++14 is bad by default, but that's not what we do. By default, the Lit configuration will test the latest supported standard anyway. I think we should have a single job with the debug mode enabled, and that job should *not* mention what standard version it's using (it should use the default one).

[• Quuxplusone]

Remove generic-cxx03-debug.
Rename generic-cxx2b-debug to generic-debug-iterators.
Use "the highest supported version" instead of hard-coding std=c++2b ... But leave this build using clang-tot instead of plain old clang, so that our "highest supported version" actually is c++2b, instead of c++20.

[• Quuxplusone]

Poke buildkite.
@ldionne ping! (assuming buildkite is still happy with this)

[ldionne]

LGTM and I don't want to be unproductive so I'll let it slip, but it still seems to me that it would be more consistent to use

export CC=clang
export CXX=clang++

And if we really want to be using ToT Clang here, then perhaps we should consider using ToT everywhere instead, and adding a single job that tests on an "older" compiler, as a means of testing that we still support those older compilers. Actually, after writing that, I think it would make sense to do it as part of the patch that will explain our compiler support policy, which I still need to write.

libcxx/cmake/caches/Generic-debug.cmake

+set(LIBCXX_TEST_PARAMS "std=c++2b" "debug_level=1" "additional_features=LIBCXX-DEBUG-FIXME" CACHE STRING "")
+set(LIBCXXABI_TEST_PARAMS "std=c++2b" CACHE STRING "")

libcxx/include/__string

char_traits<_CharT>::move(char_type* __s1, const char_type* __s2, size_t __n)
     return __r;
 }
 
 template <class _CharT>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 _CharT*
 char_traits<_CharT>::copy(char_type* __s1, const char_type* __s2, size_t __n)
 {
-    _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
     return __r;
 }
 
 template <class _CharT>
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
         {
             return __libcpp_is_constant_evaluated()
                        ? _VSTD::__move_constexpr(__s1, __s2, __n)
                        : __n == 0 ? __s1 : (char_type*)_VSTD::memmove(__s1, __s2, __n);
         }
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
         {
-            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
             return __libcpp_is_constant_evaluated()
                        ? _VSTD::__copy_constexpr(__s1, __s2, __n)
                        : __n == 0 ? __s1 : (char_type*)_VSTD::memcpy(__s1, __s2, __n);
         }
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
         {
             return __libcpp_is_constant_evaluated()
char_type* move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
         {
             return __libcpp_is_constant_evaluated()
                        ? _VSTD::__move_constexpr(__s1, __s2, __n)
                        : __n == 0 ? __s1 : _VSTD::wmemmove(__s1, __s2, __n);
         }
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     char_type* copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
         {
-            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
             return __libcpp_is_constant_evaluated()
                        ? _VSTD::__copy_constexpr(__s1, __s2, __n)
                        : __n == 0 ? __s1 : _VSTD::wmemcpy(__s1, __s2, __n);
         }
     static inline _LIBCPP_CONSTEXPR_AFTER_CXX17
     char_type* assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
         {
             return __libcpp_is_constant_evaluated()
char_type*       move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
             return __libcpp_is_constant_evaluated()
                        ? _VSTD::__move_constexpr(__s1, __s2, __n)
                        : __n == 0 ? __s1 : (char_type*)_VSTD::memmove(__s1, __s2, __n);
         }
 
     static _LIBCPP_CONSTEXPR_AFTER_CXX17
     char_type*       copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
        {
-            _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
             return __libcpp_is_constant_evaluated()
                        ? _VSTD::__copy_constexpr(__s1, __s2, __n)
                        : __n == 0 ? __s1 : (char_type*)_VSTD::memcpy(__s1, __s2, __n);
         }
 
     static _LIBCPP_CONSTEXPR_AFTER_CXX17
     char_type*       assign(char_type* __s, size_t __n, char_type __a) _NOEXCEPT
         {
char_traits<char16_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
     }
     return __r;
 }
 
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 char16_t*
 char_traits<char16_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
     return __r;
 }
 
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 char16_t*
char_traits<char32_t>::move(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
     }
     return __r;
 }
 
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 char32_t*
 char_traits<char32_t>::copy(char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT
 {
-    _LIBCPP_ASSERT(__s2 < __s1 || __s2 >= __s1+__n, "char_traits::copy overlapped range");
     char_type* __r = __s1;
     for (; __n; --__n, ++__s1, ++__s2)
         assign(*__s1, *__s2);
     return __r;
 }
 
 inline _LIBCPP_CONSTEXPR_AFTER_CXX17
 char32_t*

libcxx/include/iterator

 {
    __i += __n;
 }
 
 template <class _InputIter, class _Distance>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 void advance(_InputIter& __i, _Distance __orig_n)
 {
-    _LIBCPP_ASSERT(__orig_n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
-                   "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
     typedef decltype(_VSTD::__convert_to_integral(__orig_n)) _IntegralSize;
     _IntegralSize __n = __orig_n;
+    _LIBCPP_ASSERT(__n >= 0 || __is_cpp17_bidirectional_iterator<_InputIter>::value,
+                   "Attempt to advance(it, n) with negative n on a non-bidirectional iterator");
     _VSTD::__advance(__i, __n, typename iterator_traits<_InputIter>::iterator_category());
 }
 
 template <class _InputIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
 typename iterator_traits<_InputIter>::difference_type
 __distance(_InputIter __first, _InputIter __last, input_iterator_tag)
 {

libcxx/include/span

//  constants and types
     using element_type           = _Tp;
     using value_type             = remove_cv_t<_Tp>;
     using size_type              = size_t;
     using difference_type        = ptrdiff_t;
     using pointer                = _Tp *;
     using const_pointer          = const _Tp *;
     using reference              = _Tp &;
     using const_reference        = const _Tp &;
-    using iterator               =  __wrap_iter<pointer>;
+    using iterator               = pointer;
     using reverse_iterator       = _VSTD::reverse_iterator<iterator>;
 
     static constexpr size_type extent = _Extent;
 
 // [span.cons], span constructors, copy, assignment, and destructor
     template <size_t _Sz = _Extent, enable_if_t<_Sz == 0, nullptr_t> = nullptr>
     _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr} {}
 
//  constants and types
     using element_type           = _Tp;
     using value_type             = remove_cv_t<_Tp>;
     using size_type              = size_t;
     using difference_type        = ptrdiff_t;
     using pointer                = _Tp *;
     using const_pointer          = const _Tp *;
     using reference              = _Tp &;
     using const_reference        = const _Tp &;
-    using iterator               =  __wrap_iter<pointer>;
+    using iterator               = pointer;
     using reverse_iterator       = _VSTD::reverse_iterator<iterator>;
 
     static constexpr size_type extent = dynamic_extent;
 
 // [span.cons], span constructors, copy, assignment, and destructor
     _LIBCPP_INLINE_VISIBILITY constexpr span() noexcept : __data{nullptr}, __size{0} {}
 
     constexpr span           (const span&) noexcept = default;

libcxx/include/string

 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     size_type __cap = capacity();
     if (__cap < __n)
     {
         size_type __sz = size();
         __grow_by(__cap, __n - __cap, __sz, 0, __sz);
+        pointer __p = __get_pointer();
+        for (; __first != __last; ++__first, ++__p)
+            traits_type::assign(*__p, *__first);
+        traits_type::assign(*__p, value_type());
+        __set_size(__n);
     }
     else
+    {
+        pointer __p = __get_pointer();
+        for (; __first != __last; ++__first, ++__p)
+            traits_type::assign(*__p, *__first);
+        traits_type::assign(*__p, value_type());
+        __set_size(__n);
         __invalidate_iterators_past(__n);
-    pointer __p = __get_pointer();
-    for (; __first != __last; ++__first, ++__p)
-        traits_type::assign(*__p, *__first);
-    traits_type::assign(*__p, value_type());
-    __set_size(__n);
+    }
     return *this;
 }
 
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, size_type __pos, size_type __n)
 {
     size_type __sz = __str.size();

libcxx/src/debug.cpp

 {
 #ifndef _LIBCPP_HAS_NO_THREADS
     RLock _(mut());
 #endif
     __i_node* i = __find_iterator(__i);
     __i_node* j = __find_iterator(__j);
     __c_node* ci = i != nullptr ? i->__c_ : nullptr;
     __c_node* cj = j != nullptr ? j->__c_ : nullptr;
-    return ci != nullptr && ci == cj;
+    return ci == cj;
 }
 
 void
 __libcpp_db::swap(void* c1, void* c2)
 {
 #ifndef _LIBCPP_HAS_NO_THREADS
     WLock _(mut());
 #endif

libcxx/test/libcxx/containers/sequences/vector/robust_against_adl.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
+// UNSUPPORTED: debug_level_0, debug_level_1
 
 // <vector>
 
 #include <vector>
 
 #include "test_macros.h"
 
 struct Incomplete;

libcxx/test/libcxx/diagnostics/nodiscard_extensions.pass.cpp

 // This test intentionally leaks memory, so it is unsupported under ASAN.
 // UNSUPPORTED: asan
 
 // AppleClang9 and GCC 5 don't support C++17's implicitly synthesized
 // deduction guides from existing ctors, needed by default_searcher() below.
 // UNSUPPORTED: apple-clang-9
 // UNSUPPORTED: gcc-5
 
+// XFAIL: LIBCXX-DEBUG-FIXME
+
 // All entities to which libc++ applies [[nodiscard]] as an extension should
 // be tested here and in nodiscard_extensions.fail.cpp. They should also
 // be listed in `UsingLibcxx.rst` in the documentation for the extension.
 
 #include <algorithm>
 #include <cstddef> // to_integer
 #include <functional> // identity
 #include <iterator>

libcxx/test/std/algorithms/alg.sorting/alg.merge/inplace_merge_comp.pass.cpp

test_one(unsigned N, unsigned M)
     std::sort(ia+M, ia+N, std::greater<value_type>());
     binary_counting_predicate<std::greater<value_type>, value_type, value_type> pred((std::greater<value_type>()));
     std::inplace_merge(Iter(ia), Iter(ia+M), Iter(ia+N), std::ref(pred));
     if(N > 0)
     {
         assert(ia[0] == static_cast<int>(N)-1);
         assert(ia[N-1] == 0);
         assert(std::is_sorted(ia, ia+N, std::greater<value_type>()));
+#ifndef _LIBCPP_DEBUG
         assert(pred.count() <= (N-1));
+#endif
     }
     delete [] ia;
 }
 
 template <class Iter>
 void
 test(unsigned N)
 {

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_const_lvalue.pass.cpp

void do_insert_hint_const_lvalue_test()
     typename C::const_iterator e = c.end();
     const VT v1(3.5, 3);
     R r = c.insert(e, v1);
     assert(c.size() == 1);
     assert(r->first == 3.5);
     assert(r->second == 3);
 
     const VT v2(3.5, 4);
-    r = c.insert(c.end(), v2);
+    r = c.insert(r, v2);
     assert(c.size() == 1);
     assert(r->first == 3.5);
     assert(r->second == 3);
 
     const VT v3(4.5, 4);
     r = c.insert(c.end(), v3);
     assert(c.size() == 2);
     assert(r->first == 4.5);

libcxx/test/std/containers/unord/unord.map/unord.map.modifiers/insert_hint_rvalue.pass.cpp

int main(int, char**)
         typedef std::pair<double, short> P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3.5, static_cast<short>(3)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), P(3.5, static_cast<short>(4)));
+        r = c.insert(r, P(3.5, static_cast<short>(4)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
         r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
         assert(c.size() == 2);
         assert(r->first == 4.5);
         assert(r->second == 4);
int main(int, char**)
         typedef std::pair<MoveOnly, MoveOnly> P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3, 3));
         assert(c.size() == 1);
         assert(r->first == 3);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), P(3, 4));
+        r = c.insert(r, P(3, 4));
         assert(c.size() == 1);
         assert(r->first == 3);
         assert(r->second == 3);
 
         r = c.insert(c.end(), P(4, 4));
         assert(c.size() == 2);
         assert(r->first == 4);
         assert(r->second == 4);
int main(int, char**)
         typedef std::pair<double, short> P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3.5, static_cast<short>(3)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), P(3.5, static_cast<short>(4)));
+        r = c.insert(r, P(3.5, static_cast<short>(4)));
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
         r = c.insert(c.end(), P(4.5, static_cast<short>(4)));
         assert(c.size() == 2);
         assert(r->first == 4.5);
         assert(r->second == 4);
int main(int, char**)
         typedef std::pair<MoveOnly, MoveOnly> P;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, P(3, 3));
         assert(c.size() == 1);
         assert(r->first == 3);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), P(3, 4));
+        r = c.insert(r, P(3, 4));
         assert(c.size() == 1);
         assert(r->first == 3);
         assert(r->second == 3);
 
         r = c.insert(c.end(), P(4, 4));
         assert(c.size() == 2);
         assert(r->first == 4);
         assert(r->second == 4);
 
         r = c.insert(c.end(), P(5, 4));
         assert(c.size() == 3);
         assert(r->first == 5);
         assert(r->second == 4);
     }
     {
         typedef std::unordered_map<double, MoveOnly> C;
         typedef C::iterator R;
         C c;
         C::const_iterator e = c.end();
         R r = c.insert(e, {3.5, 3});
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
-        r = c.insert(c.end(), {3.5, 4});
+        r = c.insert(r, {3.5, 4});
         assert(c.size() == 1);
         assert(r->first == 3.5);
         assert(r->second == 3);
 
         r = c.insert(c.end(), {4.5, 4});
         assert(c.size() == 2);
         assert(r->first == 4.5);
         assert(r->second == 4);

libcxx/test/std/containers/unord/unord.multimap/unord.multimap.modifiers/insert_hint_const_lvalue.pass.cpp

void do_insert_const_lvalue_test()
     typename C::const_iterator e = c.end();
     const VT v1(3.5, 3);
     R r = c.insert(e, v1);
     assert(c.size() == 1);
     assert(r->first == 3.5);
     assert(r->second == 3);
 
     const VT v2(3.5, 4);
-    r = c.insert(c.end(), v2);
+    r = c.insert(r, v2);
     assert(c.size() == 2);
     assert(r->first == 3.5);
     assert(r->second == 4);
 
     const VT v3(4.5, 4);
     r = c.insert(c.end(), v3);
     assert(c.size() == 3);
     assert(r->first == 4.5);

libcxx/test/std/containers/unord/unord.multiset/insert_hint_const_lvalue.pass.cpp

void do_insert_hint_const_lvalue_test()
     typedef typename C::value_type VT;
     C c;
     typename C::const_iterator e = c.end();
     const VT v1(3.5);
     R r = c.insert(e, v1);
     assert(c.size() == 1);
     assert(*r == 3.5);
 
-    r = c.insert(c.end(), v1);
+    r = c.insert(r, v1);
     assert(c.size() == 2);
     assert(*r == 3.5);
 
     const VT v2(4.5);
     r = c.insert(c.end(), v2);
     assert(c.size() == 3);
     assert(*r == 4.5);
 

libcxx/test/std/containers/unord/unord.set/insert_hint_const_lvalue.pass.cpp

void do_insert_hint_const_lvalue_test()
     typedef typename C::value_type VT;
     C c;
     typename C::const_iterator e = c.end();
     const VT v1(3.5);
     R r = c.insert(e, v1);
     assert(c.size() == 1);
     assert(*r == 3.5);
 
-    r = c.insert(e, v1);
+    r = c.insert(r, v1);
     assert(c.size() == 1);
     assert(*r == 3.5);
 
     const VT v2(4.5);
-    r = c.insert(e, v2);
+    r = c.insert(c.end(), v2);
     assert(c.size() == 2);
     assert(*r == 4.5);
 
     const VT v3(5.5);
-    r = c.insert(e, v3);
+    r = c.insert(c.end(), v3);
     assert(c.size() == 3);
     assert(*r == 5.5);
 }
 
 int main(int, char**)
 {
     do_insert_hint_const_lvalue_test<std::unordered_set<double> >();
 #if TEST_STD_VER >= 11

libcxx/test/std/containers/unord/unord.set/insert_hint_rvalue.pass.cpp

 
 int main(int, char**)
 {
     {
         typedef std::unordered_set<double> C;
         typedef C::iterator R;
         typedef double P;
         C c;
-        R r = c.insert(c.end(), P(3.5));
+        typename C::const_iterator e = c.end();
+        R r = c.insert(e, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
         r = c.insert(r, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
         r = c.insert(c.end(), P(4.5));
         assert(c.size() == 2);
         assert(*r == 4.5);
 
         r = c.insert(c.end(), P(5.5));
         assert(c.size() == 3);
         assert(*r == 5.5);
     }
 #if TEST_STD_VER >= 11
     {
         typedef std::unordered_set<MoveOnly> C;
         typedef C::iterator R;
         typedef MoveOnly P;
         C c;
-        R r = c.insert(c.end(), P(3));
+        typename C::const_iterator e = c.end();
+        R r = c.insert(e, P(3));
         assert(c.size() == 1);
         assert(*r == 3);
 
         r = c.insert(r, P(3));
         assert(c.size() == 1);
         assert(*r == 3);
 
         r = c.insert(c.end(), P(4));
         assert(c.size() == 2);
         assert(*r == 4);
 
         r = c.insert(c.end(), P(5));
         assert(c.size() == 3);
         assert(*r == 5);
     }
     {
         typedef std::unordered_set<double, std::hash<double>,
                                 std::equal_to<double>, min_allocator<double>> C;
         typedef C::iterator R;
         typedef double P;
         C c;
-        R r = c.insert(c.end(), P(3.5));
+        typename C::const_iterator e = c.end();
+        R r = c.insert(e, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
         r = c.insert(r, P(3.5));
         assert(c.size() == 1);
         assert(*r == 3.5);
 
         r = c.insert(c.end(), P(4.5));
         assert(c.size() == 2);
         assert(*r == 4.5);
 
         r = c.insert(c.end(), P(5.5));
         assert(c.size() == 3);
         assert(*r == 5.5);
     }
     {
         typedef std::unordered_set<MoveOnly, std::hash<MoveOnly>,
                             std::equal_to<MoveOnly>, min_allocator<MoveOnly>> C;
         typedef C::iterator R;
         typedef MoveOnly P;
         C c;
-        R r = c.insert(c.end(), P(3));
+        typename C::const_iterator e = c.end();
+        R r = c.insert(e, P(3));
         assert(c.size() == 1);
         assert(*r == 3);
 
         r = c.insert(r, P(3));
         assert(c.size() == 1);
         assert(*r == 3);
 
         r = c.insert(c.end(), P(4));

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp

const auto In3End = In2.end();
     path p = fs::u8path(In1);
     assert(p == In1);
   }
   {
     path p = fs::u8path(In2);
     assert(p == In1);
   }
   {
-    path p = fs::u8path(In3);
+    path p = fs::u8path(In2.data());
     assert(p == In1);
   }
   {
     path p = fs::u8path(In3, In3End);
     assert(p == In1);
   }
 #if TEST_STD_VER > 17 && defined(__cpp_char8_t) && defined(_LIBCPP_VERSION) && \
     !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   const char8_t* u8In1 = u8"abcd/efg";
   const std::u8string u8In2(u8In1);
   const auto u8In3 = u8In2.begin();
   const auto u8In3End = u8In2.end();
   // Proposed in P1423, marked tested only for libc++
   {
     path p = fs::u8path(u8In1);
     assert(p == In1);
   }
   {
     path p = fs::u8path(u8In2);
     assert(p == In1);
   }
   {
-    path p = fs::u8path(u8In3);
+    path p = fs::u8path(u8In2.data());
     assert(p == In1);
   }
   {
     path p = fs::u8path(u8In3, u8In3End);
     assert(p == In1);
   }
 #endif
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/fs.op.funcs/fs.op.proximate/proximate.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+// XFAIL: LIBCXX-DEBUG-FIXME
+
 // UNSUPPORTED: c++03
 
 // <filesystem>
 
 // path proximate(const path& p, error_code &ec)
 // path proximate(const path& p, const path& base = current_path())
 // path proximate(const path& p, const path& base, error_code& ec);
 

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: clang-8
 // UNSUPPORTED: gcc-9
 
+// <numeric>
+
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T>
 //     OutputIterator exclusive_scan(InputIterator first, InputIterator last,
 //                                   OutputIterator result, T init);
 //
 
 #include <numeric>
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
 #include <iterator>
-#include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-// FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER > 17
-#include <span>
-#endif
 
-template <class Iter1, class T, class Iter2>
+template <class Iter1, class T>
 TEST_CONSTEXPR_CXX20 void
-test(Iter1 first, Iter1 last, T init, Iter2 rFirst, Iter2 rLast)
+test(Iter1 first, Iter1 last, T init, const T *rFirst, const T *rLast)
 {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-    size_t size = std::distance(first, last);
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-
-    std::vector<typename std::iterator_traits<Iter1>::value_type> v(size);
-#else
-    assert((size <= 5) && "Increment the size of the array");
-    typename std::iterator_traits<Iter1>::value_type b[5];
-    std::span<typename std::iterator_traits<Iter1>::value_type> v{b, size};
-#endif
+    assert((rLast - rFirst) <= 5);  // or else increase the size of "out"
+    T out[5];
 
-//  Not in place
-    std::exclusive_scan(first, last, v.begin(), init);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // Not in place
+    T *end = std::exclusive_scan(first, last, out, init);
+    assert(std::equal(out, end, rFirst, rLast));
 
-//  In place
-    std::copy(first, last, v.begin());
-    std::exclusive_scan(v.begin(), v.end(), v.begin(), init);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // In place
+    std::copy(first, last, out);
+    end = std::exclusive_scan(out, end, out, init);
+    assert(std::equal(out, end, rFirst, rLast));
 }
 
 template <class Iter>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
-          int ia[]   = {1, 3, 5, 7,  9};
+    int ia[]         = {1, 3, 5, 7,  9};
     const int pRes[] = {0, 1, 4, 9, 16};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
     static_assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
 
-    for (unsigned int i = 0; i < sa; ++i )
+    for (unsigned int i = 0; i < sa; ++i) {
         test(Iter(ia), Iter(ia + i), 0, pRes, pRes + i);
     }
+}
 
 constexpr size_t triangle(size_t n) { return n*(n+1)/2; }
 
 //  Basic sanity
 TEST_CONSTEXPR_CXX20 void
 basic_tests()
 {
     {

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan_init_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: clang-8
 // UNSUPPORTED: gcc-9
 
+// <numeric>
+
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     exclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,
 //                    T init, BinaryOperation binary_op); // C++17
 
 #include <numeric>
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
 #include <iterator>
-#include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-// FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER > 17
-#include <span>
-#endif
 
-template <class Iter1, class T, class Op, class Iter2>
+template <class Iter1, class T, class Op>
 TEST_CONSTEXPR_CXX20 void
-test(Iter1 first, Iter1 last, T init, Op op, Iter2 rFirst, Iter2 rLast)
+test(Iter1 first, Iter1 last, T init, Op op, const T *rFirst, const T *rLast)
 {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-    size_t size = std::distance(first, last);
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-
-    std::vector<typename std::iterator_traits<Iter1>::value_type> v(size);
-#else
-    assert((size <= 5) && "Increment the size of the array");
-    typename std::iterator_traits<Iter1>::value_type b[5];
-    std::span<typename std::iterator_traits<Iter1>::value_type> v{b, size};
-#endif
+    assert((rLast - rFirst) <= 5);  // or else increase the size of "out"
+    T out[5];
 
-//  Not in place
-    std::exclusive_scan(first, last, v.begin(), init, op);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // Not in place
+    T *end = std::exclusive_scan(first, last, out, init, op);
+    assert(std::equal(out, end, rFirst, rLast));
 
-//  In place
-    std::copy(first, last, v.begin());
-    std::exclusive_scan(v.begin(), v.end(), v.begin(), init, op);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // In place
+    std::copy(first, last, out);
+    end = std::exclusive_scan(out, end, out, init, op);
+    assert(std::equal(out, end, rFirst, rLast));
 }
 
 
 template <class Iter>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
-          int ia[]   = {1, 3, 5,  7,   9};
+    int ia[]         = {1, 3, 5,  7,   9};
     const int pRes[] = {0, 1, 4,  9,  16};
     const int mRes[] = {1, 1, 3, 15, 105};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
     static_assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
     static_assert(sa == sizeof(mRes) / sizeof(mRes[0]));       // just to be sure
 
     for (unsigned int i = 0; i < sa; ++i ) {
         test(Iter(ia), Iter(ia + i), 0, std::plus<>(),       pRes, pRes + i);
         test(Iter(ia), Iter(ia + i), 1, std::multiplies<>(), mRes, mRes + i);
-        }
 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
 //  All the iterator categories
     test<input_iterator        <const int*> >();
     test<forward_iterator      <const int*> >();
     test<bidirectional_iterator<const int*> >();
     test<random_access_iterator<const int*> >();
     test<const int*>();
     test<      int*>();
 
 //  Make sure that the calculations are done using the init typedef
     {
     std::array<unsigned char, 10> v;
     std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> res;
-    std::exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 1, std::multiplies<>());
-#else
     std::array<size_t, 10> res;
     std::exclusive_scan(v.begin(), v.end(), res.begin(), 1, std::multiplies<>());
-#endif
 
     assert(res.size() == 10);
     size_t j = 1;
     assert(res[0] == 1);
     for (size_t i = 1; i < v.size(); ++i)
     {
         j *= i;
         assert(res[i] == j);

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: clang-8
 // UNSUPPORTED: gcc-9
 
+// <numeric>
+
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T>
 //     OutputIterator inclusive_scan(InputIterator first, InputIterator last,
 //                                   OutputIterator result, T init);
 //
 
 #include <numeric>
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
 #include <iterator>
-#include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-// FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER > 17
-#include <span>
-#endif
 
-template <class Iter1, class Iter2>
+template <class Iter1, class T>
 TEST_CONSTEXPR_CXX20 void
-test(Iter1 first, Iter1 last, Iter2 rFirst, Iter2 rLast)
+test(Iter1 first, Iter1 last, const T *rFirst, const T *rLast)
 {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-    size_t size = std::distance(first, last);
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-
-    std::vector<typename std::iterator_traits<Iter1>::value_type> v(size);
-#else
-    assert((size <= 5) && "Increment the size of the array");
-    typename std::iterator_traits<Iter1>::value_type b[5];
-    std::span<typename std::iterator_traits<Iter1>::value_type> v{b, size};
-#endif
+    assert((rLast - rFirst) <= 5);  // or else increase the size of "out"
+    T out[5];
 
-//  Not in place
-    std::inclusive_scan(first, last, v.begin());
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // Not in place
+    T *end = std::inclusive_scan(first, last, out);
+    assert(std::equal(out, end, rFirst, rLast));
 
-//  In place
-    std::copy(first, last, v.begin());
-    std::inclusive_scan(v.begin(), v.end(), v.begin());
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // In place
+    std::copy(first, last, out);
+    end = std::inclusive_scan(out, end, out);
+    assert(std::equal(out, end, rFirst, rLast));
 }
 
 
 template <class Iter>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
-          int ia[]   = {1, 3, 5, 7,  9};
+    int ia[]         = {1, 3, 5, 7,  9};
     const int pRes[] = {1, 4, 9, 16, 25};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
     static_assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
 
-    for (unsigned int i = 0; i < sa; ++i )
+    for (unsigned int i = 0; i < sa; ++i ) {
         test(Iter(ia), Iter(ia + i), pRes, pRes + i);
     }
+}
 
 constexpr size_t triangle(size_t n) { return n*(n+1)/2; }
 
 //  Basic sanity
 TEST_CONSTEXPR_CXX20 void
 basic_tests()
 {
     {
basic_tests()
     std::array<size_t, 10> v;
     std::iota(v.begin(), v.end(), 1);
     std::inclusive_scan(v.begin(), v.end(), v.begin());
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == triangle(i + 1));
     }
 
     {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> v, res;
-    std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res));
-#else
     std::array<size_t, 0> v, res;
     std::inclusive_scan(v.begin(), v.end(), res.begin());
-#endif
     assert(res.empty());
     }
 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     basic_tests();

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: clang-8
 // UNSUPPORTED: gcc-9
 
+// <numeric>
+
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     inclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,
 //                    BinaryOperation binary_op); // C++17
 
 #include <numeric>
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
 #include <iterator>
-#include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-// FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER > 17
-#include <span>
-#endif
 
-template <class Iter1, class Op, class Iter2>
+template <class Iter1, class Op, class T>
 TEST_CONSTEXPR_CXX20 void
-test(Iter1 first, Iter1 last, Op op, Iter2 rFirst, Iter2 rLast)
+test(Iter1 first, Iter1 last, Op op, const T *rFirst, const T *rLast)
 {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-    size_t size = std::distance(first, last);
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-
-    std::vector<typename std::iterator_traits<Iter1>::value_type> v(size);
-#else
-    assert((size <= 5) && "Increment the size of the array");
-    typename std::iterator_traits<Iter1>::value_type b[5];
-    std::span<typename std::iterator_traits<Iter1>::value_type> v{b, size};
-#endif
+    assert((rLast - rFirst) <= 5);  // or else increase the size of "out"
+    T out[5];
 
-//  Not in place
-    std::inclusive_scan(first, last, v.begin(), op);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // Not in place
+    T *end = std::inclusive_scan(first, last, out, op);
+    assert(std::equal(out, end, rFirst, rLast));
 
-//  In place
-    std::copy(first, last, v.begin());
-    std::inclusive_scan(v.begin(), v.end(), v.begin(), op);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // In place
+    std::copy(first, last, out);
+    end = std::inclusive_scan(out, end, out, op);
+    assert(std::equal(out, end, rFirst, rLast));
 }
 
 
 template <class Iter>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
-          int ia[]   = {1, 3,  5,   7,   9};
+    int ia[]         = {1, 3,  5,   7,   9};
     const int pRes[] = {1, 4,  9,  16,  25};
     const int mRes[] = {1, 3, 15, 105, 945};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
     static_assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
     static_assert(sa == sizeof(mRes) / sizeof(mRes[0]));       // just to be sure
 
     for (unsigned int i = 0; i < sa; ++i ) {
         test(Iter(ia), Iter(ia + i), std::plus<>(),       pRes, pRes + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), mRes, mRes + i);
-        }
 }
 
 constexpr size_t triangle(size_t n) { return n*(n+1)/2; }
 
 //  Basic sanity
 TEST_CONSTEXPR_CXX20 void
 basic_tests()
 {
basic_tests()
     std::array<size_t, 10> v;
     std::iota(v.begin(), v.end(), 1);
     std::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>());
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == triangle(i + 1));
     }
 
     {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> v, res;
-    std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>());
-#else
     std::array<size_t, 0> v, res;
     std::inclusive_scan(v.begin(), v.end(), res.begin(), std::plus<>());
-#endif
     assert(res.empty());
     }
 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     basic_tests();

libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: clang-8
 // UNSUPPORTED: gcc-9
 
+// <numeric>
+
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T, class BinaryOperation>
 //     OutputIterator
 //     inclusive_scan(InputIterator first, InputIterator last,
 //                    OutputIterator result,
 //                    BinaryOperation binary_op, T init); // C++17
 
 #include <numeric>
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
 #include <iterator>
-#include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-// FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER > 17
-#include <span>
-#endif
 
-template <class Iter1, class T, class Op, class Iter2>
+template <class Iter1, class T, class Op>
 TEST_CONSTEXPR_CXX20 void
-test(Iter1 first, Iter1 last, Op op, T init, Iter2 rFirst, Iter2 rLast)
+test(Iter1 first, Iter1 last, Op op, T init, const T *rFirst, const T *rLast)
 {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-    size_t size = std::distance(first, last);
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-
-    std::vector<typename std::iterator_traits<Iter1>::value_type> v(size);
-#else
-    assert((size <= 5) && "Increment the size of the array");
-    typename std::iterator_traits<Iter1>::value_type b[5];
-    std::span<typename std::iterator_traits<Iter1>::value_type> v{b, size};
-#endif
+    assert((rLast - rFirst) <= 5);  // or else increase the size of "out"
+    T out[5];
 
-//  Not in place
-    std::inclusive_scan(first, last, v.begin(), op, init);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // Not in place
+    T *end = std::inclusive_scan(first, last, out, op, init);
+    assert(std::equal(out, end, rFirst, rLast));
 
-//  In place
-    std::copy(first, last, v.begin());
-    std::inclusive_scan(v.begin(), v.end(), v.begin(), op, init);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // In place
+    std::copy(first, last, out);
+    end = std::inclusive_scan(out, end, out, op, init);
+    assert(std::equal(out, end, rFirst, rLast));
 }
 
 
 template <class Iter>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
-          int ia[]   = {1, 3,  5,   7,   9};
+    int ia[]         = {1, 3,  5,   7,   9};
     const int pRes[] = {1, 4,  9,  16,  25};
     const int mRes[] = {1, 3, 15, 105, 945};
     const unsigned sa = sizeof(ia) / sizeof(ia[0]);
     static_assert(sa == sizeof(pRes) / sizeof(pRes[0]));       // just to be sure
     static_assert(sa == sizeof(mRes) / sizeof(mRes[0]));       // just to be sure
 
     for (unsigned int i = 0; i < sa; ++i ) {
         test(Iter(ia), Iter(ia + i), std::plus<>(),       0, pRes, pRes + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), 1, mRes, mRes + i);
-        }
 }
 
 constexpr size_t triangle(size_t n) { return n*(n+1)/2; }
 
 //  Basic sanity
 TEST_CONSTEXPR_CXX20 void
 basic_tests()
 {
basic_tests()
     std::array<size_t, 10> v;
     std::iota(v.begin(), v.end(), 1);
     std::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), size_t{30});
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 30 + triangle(i + 1));
     }
 
     {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> v, res;
-    std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), size_t{40});
-#else
     std::array<size_t, 0> v, res;
     std::inclusive_scan(v.begin(), v.end(), res.begin(), std::plus<>(), size_t{40});
-#endif
     assert(res.empty());
     }
 
 //  Make sure that the calculations are done using the init typedef
     {
     std::array<unsigned char, 10> v;
     std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> res;
-    std::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), size_t{1});
-#else
     std::array<size_t, 10> res;
     std::inclusive_scan(v.begin(), v.end(), res.begin(), std::multiplies<>(), size_t{1});
-#endif
 
     assert(res.size() == 10);
     size_t j = 1;
     assert(res[0] == 1);
     for (size_t i = 1; i < v.size(); ++i)
     {
         j *= i + 1;
         assert(res[i] == j);

libcxx/test/std/numerics/numeric.ops/transform.exclusive.scan/transform_exclusive_scan_init_bop_uop.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: clang-8
 // UNSUPPORTED: gcc-9
 
+// <numeric>
+
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result, T init,
 //                                           BinaryOperation binary_op,
 //                                           UnaryOperation unary_op);
 
 
 #include <numeric>
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
 #include <iterator>
-#include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-// FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER > 17
-#include <span>
-#endif
 
 struct add_one {
     template <typename T>
     constexpr auto operator()(T x) const noexcept {
         return static_cast<T>(x + 1);
     }
 };
 
-template <class Iter1, class BOp, class UOp, class T, class Iter2>
+template <class Iter1, class BOp, class UOp, class T>
 TEST_CONSTEXPR_CXX20 void
-test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
+test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, const T *rFirst, const T *rLast)
 {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-    size_t size = std::distance(first, last);
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-
-    std::vector<typename std::iterator_traits<Iter1>::value_type> v(size);
-#else
-    assert((size <= 5) && "Increment the size of the array");
-    typename std::iterator_traits<Iter1>::value_type b[5];
-    std::span<typename std::iterator_traits<Iter1>::value_type> v{b, size};
-#endif
+    assert((rLast - rFirst) <= 5);  // or else increase the size of "out"
+    T out[5];
 
-//  Test not in-place
-    std::transform_exclusive_scan(first, last, v.begin(), init, bop, uop);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
-
-//  Test in-place
-    std::copy(first, last, v.begin());
-    std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), init, bop, uop);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // Not in place
+    T *end = std::transform_exclusive_scan(first, last, out, init, bop, uop);
+    assert(std::equal(out, end, rFirst, rLast));
+
+    // In place
+    std::copy(first, last, out);
+    end = std::transform_exclusive_scan(out, end, out, init, bop, uop);
+    assert(std::equal(out, end, rFirst, rLast));
 }
 
-
 template <class Iter>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
-          int ia[]     = { 1,  3,  5,    7,   9 };
+    int ia[]           = { 1,  3,  5,    7,   9 };
     const int pResI0[] = { 0,  2,  6,   12,  20 };        // with add_one
     const int mResI0[] = { 0,  0,  0,    0,   0 };
     const int pResN0[] = { 0, -1, -4,   -9, -16 };        // with negate
     const int mResN0[] = { 0,  0,  0,    0,   0 };
     const int pResI2[] = { 2,  4,  8,   14,  22 };        // with add_one
     const int mResI2[] = { 2,  4, 16,   96, 768 };
     const int pResN2[] = { 2,  1,  -2,  -7, -14 };        // with negate
     const int mResN2[] = { 2, -2,   6, -30, 210 };
for (unsigned int i = 0; i < sa; ++i ) {
         test(Iter(ia), Iter(ia + i), std::plus<>(),       add_one{},       0, pResI0, pResI0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_one{},       0, mResI0, mResI0 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 0, pResN0, pResN0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       add_one{},       2, pResI2, pResI2 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_one{},       2, mResI2, mResI2 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 2, pResN2, pResN2 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
-        }
 }
 
 constexpr size_t triangle(size_t n) { return n*(n+1)/2; }
 
 //  Basic sanity
 TEST_CONSTEXPR_CXX20 void
 basic_tests()
 {
basic_tests()
     std::array<size_t, 10> v;
     std::iota(v.begin(), v.end(), 1);
     std::transform_exclusive_scan(v.begin(), v.end(), v.begin(), size_t{40}, std::plus<>(), add_one{});
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 40 + triangle(i) + i);
     }
 
     {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> v, res;
-    std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), size_t{40}, std::plus<>(), add_one{});
-#else
     std::array<size_t, 0> v, res;
     std::transform_exclusive_scan(v.begin(), v.end(), res.begin(), size_t{40}, std::plus<>(), add_one{});
-#endif
     assert(res.empty());
     }
 
 //  Make sure that the calculations are done using the init typedef
     {
     std::array<unsigned char, 10> v;
     std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> res;
-    std::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), size_t{1}, std::multiplies<>(), add_one{});
-#else
     std::array<size_t, 10> res;
     std::transform_exclusive_scan(v.begin(), v.end(), res.begin(), size_t{1}, std::multiplies<>(), add_one{});
-#endif
 
     assert(res.size() == 10);
     size_t j = 1;
     assert(res[0] == 1);
     for (size_t i = 1; i < res.size(); ++i)
     {
         j *= i + 1;
         assert(res[i] == j);

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop.pass.cpp

-
 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: clang-8
 // UNSUPPORTED: gcc-9
 
+// <numeric>
+
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result,
 //                                           BinaryOperation binary_op,
 //                                           UnaryOperation unary_op);
 
 
 #include <numeric>
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
 #include <iterator>
-#include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-// FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER > 17
-#include <span>
-#endif
 
 struct add_one {
     template <typename T>
-    constexpr auto operator()(T x) const noexcept {
-        return static_cast<T>(x + 1);
+    constexpr T operator()(T x) const {
+        return x + 1;
     }
 };
 
-template <class Iter1, class BOp, class UOp, class Iter2>
+template <class Iter1, class BOp, class UOp, class T>
 TEST_CONSTEXPR_CXX20 void
-test(Iter1 first, Iter1 last, BOp bop, UOp uop, Iter2 rFirst, Iter2 rLast)
+test(Iter1 first, Iter1 last, BOp bop, UOp uop, const T *rFirst, const T *rLast)
 {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-    size_t size = std::distance(first, last);
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-
-    std::vector<typename std::iterator_traits<Iter1>::value_type> v(size);
-#else
-    assert((size <= 5) && "Increment the size of the array");
-    typename std::iterator_traits<Iter1>::value_type b[5];
-    std::span<typename std::iterator_traits<Iter1>::value_type> v{b, size};
-#endif
+    assert((rLast - rFirst) <= 5);  // or else increase the size of "out"
+    T out[5];
 
-//  Test not in-place
-    std::transform_inclusive_scan(first, last, v.begin(), bop, uop);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
-
-//  Test in-place
-    std::copy(first, last, v.begin());
-    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), bop, uop);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // Not in place
+    T *end = std::transform_inclusive_scan(first, last, out, bop, uop);
+    assert(std::equal(out, end, rFirst, rLast));
+
+    // In place
+    std::copy(first, last, out);
+    end = std::transform_inclusive_scan(out, end, out, bop, uop);
+    assert(std::equal(out, end, rFirst, rLast));
 }
 
 
 template <class Iter>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
-          int ia[]     = {  1,  3,   5,   7,    9 };
+    int ia[]           = {  1,  3,   5,   7,    9 };
     const int pResI0[] = {  2,  6,  12,  20,   30 };        // with add_one
     const int mResI0[] = {  2,  8, 48,  384, 3840 };
     const int pResN0[] = { -1, -4,  -9, -16,  -25 };        // with negate
     const int mResN0[] = { -1,  3, -15, 105, -945 };
     const unsigned sa = sizeof(ia) / sizeof(ia[0] );
     static_assert(sa == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
     static_assert(sa == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
     static_assert(sa == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
     static_assert(sa == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
 
     for (unsigned int i = 0; i < sa; ++i ) {
         test(Iter(ia), Iter(ia + i), std::plus<>(),       add_one{},       pResI0, pResI0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_one{},       mResI0, mResI0 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), pResN0, pResN0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), mResN0, mResN0 + i);
-        }
 }
 
 constexpr size_t triangle(size_t n) { return n*(n+1)/2; }
 
 //  Basic sanity
 TEST_CONSTEXPR_CXX20 void
 basic_tests()
 {
basic_tests()
     std::array<size_t, 10> v;
     std::iota(v.begin(), v.end(), 1);
     std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), add_one{});
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == triangle(i + 1) + i + 1);
     }
 
     {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> v, res;
-    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), add_one{});
-#else
     std::array<size_t, 0> v, res;
     std::transform_inclusive_scan(v.begin(), v.end(), res.begin(), std::plus<>(), add_one{});
-#endif
     assert(res.empty());
     }
 }
 
 TEST_CONSTEXPR_CXX20 bool
 test()
 {
     basic_tests();

libcxx/test/std/numerics/numeric.ops/transform.inclusive.scan/transform_inclusive_scan_bop_uop_init.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// <numeric>
 // UNSUPPORTED: c++03, c++11, c++14
 // UNSUPPORTED: clang-8
 // UNSUPPORTED: gcc-9
 
+// <numeric>
+
 // Became constexpr in C++20
 // template<class InputIterator, class OutputIterator, class T,
 //          class BinaryOperation, class UnaryOperation>
 //   OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last,
 //                                           OutputIterator result,
 //                                           BinaryOperation binary_op,
 //                                           UnaryOperation unary_op,
 //                                           T init);
 
 
 #include <numeric>
 #include <algorithm>
 #include <array>
 #include <cassert>
 #include <functional>
 #include <iterator>
-#include <vector>
 
 #include "test_macros.h"
 #include "test_iterators.h"
-// FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER > 17
-#include <span>
-#endif
 
 struct add_one {
     template <typename T>
-    constexpr auto operator()(T x) const noexcept {
-        return static_cast<T>(x + 1);
+    constexpr T operator()(T x) const {
+        return x + 1;
     }
 };
 
-template <class Iter1, class BOp, class UOp, class T, class Iter2>
+template <class Iter1, class BOp, class UOp, class T>
 TEST_CONSTEXPR_CXX20 void
-test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
+test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, const T *rFirst, const T *rLast)
 {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-    size_t size = std::distance(first, last);
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-
-    std::vector<typename std::iterator_traits<Iter1>::value_type> v(size);
-#else
-    assert((size <= 5) && "Increment the size of the array");
-    typename std::iterator_traits<Iter1>::value_type b[5];
-    std::span<typename std::iterator_traits<Iter1>::value_type> v{b, size};
-#endif
+    assert((rLast - rFirst) <= 5);  // or else increase the size of "out"
+    T out[5];
 
-//  Test not in-place
-    std::transform_inclusive_scan(first, last, v.begin(), bop, uop, init);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
-
-//  Test in-place
-    std::copy(first, last, v.begin());
-    std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), bop, uop, init);
-    assert(std::equal(v.begin(), v.end(), rFirst, rLast));
+    // Not in place
+    T *end = std::transform_inclusive_scan(first, last, out, bop, uop, init);
+    assert(std::equal(out, end, rFirst, rLast));
+
+    // In place
+    std::copy(first, last, out);
+    end = std::transform_inclusive_scan(out, end, out, bop, uop, init);
+    assert(std::equal(out, end, rFirst, rLast));
 }
 
 
 template <class Iter>
 TEST_CONSTEXPR_CXX20 void
 test()
 {
-          int ia[]     = {  1,  3,   5,    7,     9 };
+    int ia[]           = {  1,  3,   5,    7,     9 };
     const int pResI0[] = {  2,  6,  12,   20,    30 };        // with add_one
     const int mResI0[] = {  0,  0,   0,    0,     0 };
     const int pResN0[] = { -1, -4,  -9,  -16,   -25 };        // with negate
     const int mResN0[] = {  0,  0,   0,    0,     0 };
     const int pResI2[] = {  4,  8,  14,   22,    32 };        // with add_one
     const int mResI2[] = {  4, 16,  96,  768,  7680 };
     const int pResN2[] = {  1, -2,  -7,  -14,   -23 };        // with negate
     const int mResN2[] = { -2,  6, -30,  210, -1890 };
for (unsigned int i = 0; i < sa; ++i ) {
         test(Iter(ia), Iter(ia + i), std::plus<>(),       add_one{},       0, pResI0, pResI0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_one{},       0, mResI0, mResI0 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 0, pResN0, pResN0 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 0, mResN0, mResN0 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       add_one{},       2, pResI2, pResI2 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), add_one{},       2, mResI2, mResI2 + i);
         test(Iter(ia), Iter(ia + i), std::plus<>(),       std::negate<>(), 2, pResN2, pResN2 + i);
         test(Iter(ia), Iter(ia + i), std::multiplies<>(), std::negate<>(), 2, mResN2, mResN2 + i);
-        }
 }
 
 constexpr size_t triangle(size_t n) { return n*(n+1)/2; }
 
 //  Basic sanity
 TEST_CONSTEXPR_CXX20 void
 basic_tests()
 {
basic_tests()
     std::array<size_t, 10> v;
     std::iota(v.begin(), v.end(), 1);
     std::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<>(), add_one{}, size_t{40});
     for (size_t i = 0; i < v.size(); ++i)
         assert(v[i] == 40 + triangle(i + 1) + i + 1);
     }
 
     {
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> v, res;
-    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<>(), add_one{}, size_t{1});
-#else
     std::array<size_t, 0> v, res;
     std::transform_inclusive_scan(v.begin(), v.end(), res.begin(), std::plus<>(), add_one{}, size_t{1});
-#endif
     assert(res.empty());
     }
 
 //  Make sure that the calculations are done using the init typedef
     {
     std::array<unsigned char, 10> v;
     std::iota(v.begin(), v.end(), static_cast<unsigned char>(1));
-    // C++17 doesn't test constexpr so can use a vector.
-    // C++20 can use vector in constexpr evaluation, but both libc++ and MSVC
-    // don't have the support yet. In these cases use a std::span for the test.
-    // FIXME Remove constexpr vector workaround introduced in D90569
-#if TEST_STD_VER < 20 || \
-    (defined(__cpp_lib_constexpr_vector) && __cpp_lib_constexpr_vector >= 201907L)
-    std::vector<size_t> res;
-    std::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::multiplies<>(), add_one{}, size_t{1});
-#else
     std::array<size_t, 10> res;
     std::transform_inclusive_scan(v.begin(), v.end(), res.begin(), std::multiplies<>(), add_one{}, size_t{1});
-#endif
 
     assert(res.size() == 10);
     size_t j = 2;
     assert(res[0] == 2);
     for (size_t i = 1; i < res.size(); ++i)
     {
         j *= i + 2;
         assert(res[i] == j);

libcxx/test/std/strings/basic.string/string.iterators/iterators.pass.cpp

 // const_iterator cbegin() const;
 // const_iterator cend()   const;
 
 #include <string>
 #include <cassert>
 
 #include "test_macros.h"
 
-int main(int, char**)
+template<class C>
+void test()
 {
     { // N3644 testing
-        typedef std::string C;
-        C::iterator ii1{}, ii2{};
-        C::iterator ii4 = ii1;
-        C::const_iterator cii{};
+        typename C::iterator ii1{}, ii2{};
+        typename C::iterator ii4 = ii1;
+        typename C::const_iterator cii{};
         assert ( ii1 == ii2 );
         assert ( ii1 == ii4 );
-        assert ( ii1 == cii );
-        assert ( !(ii1 != ii2 ));
-        assert ( !(ii1 != cii ));
-    }
 
-    { // N3644 testing
-        typedef std::wstring C;
-        C::iterator ii1{}, ii2{};
-        C::iterator ii4 = ii1;
-        C::const_iterator cii{};
-        assert ( ii1 == ii2 );
-        assert ( ii1 == ii4 );
-        assert ( ii1 == cii );
-        assert ( !(ii1 != ii2 ));
-        assert ( !(ii1 != cii ));
-    }
+        assert (!(ii1 != ii2 ));
+
+        assert ( (ii1 == cii ));
+        assert ( (cii == ii1 ));
+        assert (!(ii1 != cii ));
+        assert (!(cii != ii1 ));
+        assert (!(ii1 <  cii ));
+        assert (!(cii <  ii1 ));
+        assert ( (ii1 <= cii ));
+        assert ( (cii <= ii1 ));
+        assert (!(ii1 >  cii ));
+        assert (!(cii >  ii1 ));
+        assert ( (ii1 >= cii ));
+        assert ( (cii >= ii1 ));
+        assert (cii - ii1 == 0);
+        assert (ii1 - cii == 0);
+    }
 
-#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
-    {
-        typedef std::u8string C;
-        C::iterator ii1{}, ii2{};
-        C::iterator ii4 = ii1;
-        C::const_iterator cii{};
-        assert ( ii1 == ii2 );
-        assert ( ii1 == ii4 );
-        assert ( ii1 == cii );
-        assert ( !(ii1 != ii2 ));
-        assert ( !(ii1 != cii ));
-    }
-#endif
+int main(int, char**)
+    test<std::string>();
+    test<std::wstring>();
 
-    { // N3644 testing
-        typedef std::u16string C;
-        C::iterator ii1{}, ii2{};
-        C::iterator ii4 = ii1;
-        C::const_iterator cii{};
-        assert ( ii1 == ii2 );
-        assert ( ii1 == ii4 );
-        assert ( ii1 == cii );
-        assert ( !(ii1 != ii2 ));
-        assert ( !(ii1 != cii ));
-    }
+#if defined(__cpp_lib_char8_t) && __cpp_lib_char8_t >= 201811L
+    test<std::u8string>();
+#endif
 
-    { // N3644 testing
-        typedef std::u32string C;
-        C::iterator ii1{}, ii2{};
-        C::iterator ii4 = ii1;
-        C::const_iterator cii{};
-        assert ( ii1 == ii2 );
-        assert ( ii1 == ii4 );
-        assert ( ii1 == cii );
-        assert ( !(ii1 != ii2 ));
-        assert ( !(ii1 != cii ));
-    }
+    test<std::u16string>();
+    test<std::u32string>();
 
     return 0;
 }

libcxx/utils/ci/buildkite-pipeline.yml

steps:
 
   #
   # General testing with the default configuration, under all the supported
   # Standard modes, with Clang and GCC and on Apple. This catches most issues
   # upfront.
   #
   - wait
 
-  - label: "C++03"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx03"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "C++11"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx11"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "C++14"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx14"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "C++17"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx17"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "C++20"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx20"
-    artifact_paths:
-      - "**/test-results.xml"
-      - "**/*.abilist"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
   - label: "C++2b"
     command: "libcxx/utils/ci/run-buildbot generic-cxx2b"
     artifact_paths:
       - "**/test-results.xml"
       - "**/*.abilist"
     agents:
       queue: "libcxx-builders"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
 
-  - label: "MacOS C++20"
-    command: "libcxx/utils/ci/run-buildbot generic-cxx20"
+  - label: "Debug iterators"
+    command: "libcxx/utils/ci/run-buildbot generic-debug"
     artifact_paths:
       - "**/test-results.xml"
       - "**/*.abilist"
     agents:
-      queue: "libcxx-builders-macos"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "GCC/C++20"
-    command: "libcxx/utils/ci/run-buildbot generic-gcc"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  #
-  # All other supported configurations of libc++.
-  #
-  - wait
-
-  - label: "-fno-exceptions"
-    command: "libcxx/utils/ci/run-buildbot generic-noexceptions"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Static libraries"
-    command: "libcxx/utils/ci/run-buildbot generic-static"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "ASAN"
-    command: "libcxx/utils/ci/run-buildbot generic-asan"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "TSAN"
-    command: "libcxx/utils/ci/run-buildbot generic-tsan"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "UBSAN"
-    command: "libcxx/utils/ci/run-buildbot generic-ubsan"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "With LLVM's libunwind"
-    command: "libcxx/utils/ci/run-buildbot generic-with_llvm_unwinder"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Single-threaded"
-    command: "libcxx/utils/ci/run-buildbot generic-singlethreaded"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "No debug mode"
-    command: "libcxx/utils/ci/run-buildbot generic-no-debug"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "No Filesystem"
-    command: "libcxx/utils/ci/run-buildbot generic-no-filesystem"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "No random device"
-    command: "libcxx/utils/ci/run-buildbot generic-no-random_device"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "No locale"
-    command: "libcxx/utils/ci/run-buildbot generic-no-localization"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Benchmarks"
-    command: "libcxx/utils/ci/run-buildbot benchmarks"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Documentation"
-    command: "libcxx/utils/ci/run-buildbot documentation"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Legacy standalone build"
-    command: "libcxx/utils/ci/run-buildbot legacy-standalone"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
       queue: "libcxx-builders"
     retry:
       automatic:
         - exit_status: -1  # Agent was lost
           limit: 2
-
-  - label: "Unified standalone build"
-    command: "libcxx/utils/ci/run-buildbot unified-standalone"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Runtimes build"
-    command: "libcxx/utils/ci/run-buildbot runtimes-build"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Windows"
-    # TODO: The CI runner doesn't have bash in the path currently. Once it
-    # has that, remove the absolute path and just call 'bash' here.
-    command: "\"\\Program Files\\Git\\usr\\bin\\bash\" libcxx/utils/ci/run-buildbot generic-win"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "windows"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  # Build with the configuration we use to generate libc++.dylib on Apple platforms
-  - label: "Apple system"
-    command: "libcxx/utils/ci/run-buildbot x86_64-apple-system"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-macos"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Apple system -fno-exceptions"
-    command: "libcxx/utils/ci/run-buildbot x86_64-apple-system-noexceptions"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-macos"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  # Test back-deployment to older Apple platforms
-  - label: "Apple back-deployment macosx10.9"
-    command: "libcxx/utils/ci/run-buildbot x86_64-apple-system-backdeployment-10.9"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-macos10.15" # TODO: For now, we're running the back-deployment tests for 10.9 on 10.15, because we don't have proper 10.9 machines
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Apple back-deployment macosx10.15"
-    command: "libcxx/utils/ci/run-buildbot x86_64-apple-system-backdeployment-10.15"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-macos10.15"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "AArch64"
-    command: "libcxx/utils/ci/run-buildbot aarch64"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-linaro-arm"
-      arch: "aarch64"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "AArch64 -fno-exceptions"
-    command: "libcxx/utils/ci/run-buildbot aarch64-noexceptions"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-linaro-arm"
-      arch: "aarch64"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Armv8"
-    command: "libcxx/utils/ci/run-buildbot armv8"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-linaro-arm"
-      arch: "armv8l"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Armv8 -fno-exceptions"
-    command: "libcxx/utils/ci/run-buildbot armv8-noexceptions"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-linaro-arm"
-      arch: "armv8l"
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Armv7"
-    command: "libcxx/utils/ci/run-buildbot armv7"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-linaro-arm"
-      arch: "armv8l" # Compiling for v7, running on v8 hardware
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2
-
-  - label: "Armv7 -fno-exceptions"
-    command: "libcxx/utils/ci/run-buildbot armv7-noexceptions"
-    artifact_paths:
-      - "**/test-results.xml"
-    agents:
-      queue: "libcxx-builders-linaro-arm"
-      arch: "armv8l" # Compiling for v7, running on v8 hardware
-    retry:
-      automatic:
-        - exit_status: -1  # Agent was lost
-          limit: 2

libcxx/utils/ci/run-buildbot

cmake -S "${MONOREPO_ROOT}/libcxx" \
           -DLIBCXX_ENABLE_EXPERIMENTAL_LIBRARY=NO \
           -DLIBCXX_ENABLE_FILESYSTEM=YES \
           -DCMAKE_CXX_FLAGS="-D_LIBCPP_HAS_NO_INT128" \
           -DLIBCXX_TEST_COMPILER_FLAGS="-D_LIBCPP_HAS_NO_INT128" \
           -DLIBCXX_TEST_LINKER_FLAGS="-loldnames"
     echo "+++ Running the libc++ tests"
     ${NINJA} -vC "${BUILD_DIR}" check-cxx
 ;;
+generic-debug)
+    clean
+    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-debug.cmake"
+    check-cxx-cxxabi
+;;
 *)
     echo "${BUILDER} is not a known configuration"
     exit 1
 ;;
 esac

libcxx/utils/libcxx/test/config.py

class Configuration(object):
     def configure_debug_mode(self):
         debug_level = self.get_lit_conf('debug_level', None)
         if not debug_level:
             return
         if debug_level not in ['0', '1']:
             self.lit_config.fatal('Invalid value for debug_level "%s".'
                                   % debug_level)
         self.cxx.compile_flags += ['-D_LIBCPP_DEBUG=%s' % debug_level]
+        self.config.available_features.add('debug_level_%s' % debug_level)
 
     def configure_sanitizer(self):
         san = self.get_lit_conf('use_sanitizer', '').strip()
         if san:
             # Search for llvm-symbolizer along the compiler path first
             # and then along the PATH env variable.
             symbolizer_search_paths = os.environ.get('PATH', '')
             cxx_path = libcxx.util.which(self.cxx.path)

libcxx/utils/libcxx/test/dsl.py

 class AddFlag(ConfigAction):
   """
   This action adds the given flag to the %{flags} substitution.
 
   The flag can be a string or a callable, in which case it is called with the
   configuration to produce the actual flag (as a string).
   """
   def __init__(self, flag):
+    print('AddFlag.__init__: flag is %r' % flag)
+    assert flag is not None
     self._getFlag = lambda config: flag(config) if callable(flag) else flag
 
   def applyTo(self, config):
+    print('AddFlag.applyTo: config is %r' % config)
     flag = self._getFlag(config)
     assert hasCompileFlag(config, flag), "Trying to enable flag {}, which is not supported".format(flag)
     config.substitutions = _appendToSubstitution(config.substitutions, '%{flags}', flag)
 
   def pretty(self, config, litParams):
     return 'add {} to %{{flags}}'.format(self._getFlag(config))