[libc++] [test] Remove epicyclic workarounds for vector/span; use T[] or std::array

[• Quuxplusone]

Summary

Simplify the test code, and drive-by also test that these algorithms return the right iterator as their return value.

This came, obliquely, out of D100866. Fixing this test now will remove the dependency on <span>, which means I won't have to mark it XFAILed in debug mode because it no longer fails.

[ldionne]

LGTM. I should really have requested that we go down that route in https://reviews.llvm.org/D90569 instead of adding a FIXME. I think this is better.

[zoecarver]

This LGTM. Thanks for the cleanup!

(Feel free to approve as libc++ yourself, then land it!)

[zoecarver]

Oh, I guess Louis beat me to it :)

[davezarzycki]

My automatically bisecting cron job identified this commit as the source of a regression on Fedora 34 (x86-64). It seems like a few dozen libc++ tests are now failing with errors like this:

FAIL: libc++ :: std/utilities/optional/iterator_concept_conformance.compile.pass.cpp (76809 of 82588)
******************** TEST 'libc++ :: std/utilities/optional/iterator_concept_conformance.compile.pass.cpp' FAILED ********************
Script:
--
: 'COMPILED WITH';  /usr/bin/clang++ /home/dave/ro_s/lp/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp -v --target=x86_64-unknown-linux-gnu -include /home/dave/ro_s/lp/libcxx/test/support/nasty_macros.h -nostdinc++ -I/tmp/_update_lc/r/include/c++/v1 -I/tmp/_update_lc/r/projects/libcxx/include/c++build -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS -I/home/dave/ro_s/lp/libcxx/test/support -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -std=c++2b -Werror -Wall -Wextra -Wshadow -Wundef -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -D_LIBCPP_DISABLE_AVAILABILITY -fcoroutines-ts -Werror=thread-safety -Wuser-defined-warnings -fmodules-cache-path=/tmp/_update_lc/r/projects/libcxx/test/std/utilities/optional/Output/iterator_concept_conformance.compile.pass.cpp.dir/t.tmp/ModuleCache -Wno-macro-redefined -D_LIBCPP_HAS_THREAD_API_PTHREAD -Wno-macro-redefined -D_LIBCPP_ABI_VERSION=1  -fsyntax-only
--
Exit Code: 1

Command Output (stderr):
--
clang version 12.0.0 (Fedora 12.0.0-0.3.rc1.fc34)
Target: x86_64-unknown-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
Found candidate GCC installation: /usr/bin/../lib/gcc/x86_64-redhat-linux/11
Found candidate GCC installation: /usr/lib/gcc/x86_64-redhat-linux/11
Selected GCC installation: /usr/lib/gcc/x86_64-redhat-linux/11
Candidate multilib: .;@m64
Candidate multilib: 32;@m32
Selected multilib: .;@m64
 (in-process)
 "/usr/bin/clang-12" -cc1 -triple x86_64-unknown-linux-gnu -fsyntax-only -disable-free -disable-llvm-verifier -discard-value-names -main-file-name iterator_concept_conformance.compile.pass.cpp -mrelocation-model static -mframe-pointer=all -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -v -nostdinc++ -resource-dir /usr/lib64/clang/12.0.0 -include /home/dave/ro_s/lp/libcxx/test/support/nasty_macros.h -I /tmp/_update_lc/r/include/c++/v1 -I /tmp/_update_lc/r/projects/libcxx/include/c++build -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -I /home/dave/ro_s/lp/libcxx/test/support -D _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER -D _LIBCPP_DISABLE_AVAILABILITY -D _LIBCPP_HAS_THREAD_API_PTHREAD -D _LIBCPP_ABI_VERSION=1 -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/12.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Werror -Wall -Wextra -Wshadow -Wundef -Wno-unused-command-line-argument -Wno-attributes -Wno-pessimizing-move -Wno-c++11-extensions -Wno-user-defined-literals -Wno-noexcept-type -Wno-atomic-alignment -Wsign-compare -Wunused-variable -Wunused-parameter -Wunreachable-code -Wno-unused-local-typedef -Werror=thread-safety -Wuser-defined-warnings -Wno-macro-redefined -Wno-macro-redefined -std=c++2b -fdeprecated-macro -fdebug-compilation-dir /tmp/_update_lc/r/projects/libcxx/test/std/utilities/optional -ferror-limit 19 -fcoroutines-ts -fgnuc-version=4.2.1 -fcxx-exceptions -fexceptions -faddrsig -x c++ /home/dave/ro_s/lp/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp
clang -cc1 version 12.0.0 based upon LLVM 12.0.0 default target x86_64-unknown-linux-gnu
ignoring nonexistent directory "/include"
#include "..." search starts here:
#include <...> search starts here:
 /tmp/_update_lc/r/include/c++/v1
 /tmp/_update_lc/r/projects/libcxx/include/c++build
 /home/dave/ro_s/lp/libcxx/test/support
 /usr/local/include
 /usr/lib64/clang/12.0.0/include
 /usr/include
End of search list.
/home/dave/ro_s/lp/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp:19:21: error: no member named 'indirectly_readable' in namespace 'std'
static_assert(!std::indirectly_readable<std::optional<int> >);
               ~~~~~^
/home/dave/ro_s/lp/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp:19:60: error: expected '(' for function-style cast or type construction
static_assert(!std::indirectly_readable<std::optional<int> >);
                                        ~~~~~~~~~~~~~~~~~~ ^
/home/dave/ro_s/lp/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp:19:61: error: expected expression
static_assert(!std::indirectly_readable<std::optional<int> >);
                                                            ^
/home/dave/ro_s/lp/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp:20:21: error: no member named 'indirectly_writable' in namespace 'std'
static_assert(!std::indirectly_writable<std::optional<int>, int>);
               ~~~~~^
/home/dave/ro_s/lp/libcxx/test/std/utilities/optional/iterator_concept_conformance.compile.pass.cpp:20:59: error: expected '(' for function-style cast or type construction
static_assert(!std::indirectly_writable<std::optional<int>, int>);
                                        ~~~~~~~~~~~~~~~~~~^
5 errors generated.

[davezarzycki]

My mistake. The bisect tripped over a unreliable test. The real problem was 04733181b5136e2b3df2b37c6bdd9e25f8afecd0 and people are already piling onto that as being broken.

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);