[libcxx][test] Add missing includes and suppress warnings

[CaseyCarter]

Summary

... from testing with MSVC's STL. Mostly truncation warnings and variables that are only used in LIBCPP_ASSERT.

[• Quuxplusone]

LGTM % comments; thanks for the cleanup!
Personally I'd like to see (or create) followups that

• eliminate TEST_IGNORE_NODISCARD in favor of (void)
• refactor concept.swappable/swappable.pass.cpp

libcxx/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp

161–164

Looks like this should be

constexpr bool check_throwable_adl_swappable_arrays() {
  throwable_adl_swappable x[] = {{0}, {1}, {2}, {3}};
  throwable_adl_swappable y[] = {{4}, {5}, {6}, {7}};
  ASSERT_NOT_NOEXCEPT(std::ranges::swap(x, y));
  assert(check_swap_22(x, y));
  return true;
}
static_assert(check_throwable_adl_swappable_arrays());

except then there's a lot more cleanup that can be done in here.
I'm guessing you don't care to tackle all that cleanup?...

libcxx/test/std/containers/sequences/vector/access.pass.cpp

51

Oh that's interesting. Looks like this macro was added in D40065, at @EricWF's request; but I've never noticed it before. In April 2021 we (I) removed a similar macro, _LIBCPP_UNUSED_VAR(x), in D100737. There are also places where we do (void)(x == y); to suppress unused-result warnings that are unrelated to [[nodiscard]].
I think we should eliminate TEST_IGNORE_NODISCARD in favor of (void), in a separate commit.
(No action required in this PR though.)

libcxx/test/std/containers/views/span.cons/initializer_list.pass.cpp

24–31

Would changing the return type to size_t silence MSVC's complaint? (Or just move it further down to where we're comparing against a signed int 10?)

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/cxx20_iter_member.pass.cpp

37

Would *pos = double(value); or *pos = static_cast<double>(value); silence the MSVC warning? If so, I think that'd be better than #pragma warning.

libcxx/test/std/numerics/bit/byteswap.pass.cpp

47–48

76

Here and above, can we get away with char(0xCD), int16_t(0xCDEF), int8_t(0xAB)? Those would be easier on the eyes.

libcxx/test/std/ranges/range.factories/range.iota.view/size.pass.cpp

67–69

Are we saying that

ASSERT_SAME_TYPE(decltype(io.size()), unsigned int);

? If so, I think we need to test that (i.e. please add that line here).

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

17–18

a < c; please swap lines 16 and 17.
(And traditionally we'd put <string> first of all, because this test is testing <string>, but I guess we've already lost that pattern in this file, which is not necessarily awful.)

libcxx/test/std/utilities/format/format.arguments/format.arg.store/class.pass.cpp

14–21

@Mordante should this entire file move to test/libcxx/?

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.pass.cpp

12

@Mordante should this entire file also move to test/libcxx/?

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_wformat_args.pass.cpp

13

@Mordante: and finally, should this file also move to test/libcxx/?

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.pass.cpp

45

You could mark e as [[maybe_unused]] instead, since this is a C++20 test.
(I'm personally still not sold on [[maybe_unused]], but you have been using it elsewhere in this PR, and we do use it lots of places by now already.)

libcxx/test/std/utilities/format/format.functions/format.pass.cpp

70–74

Let's move all of this outside the #else, and then we don't need an #else.

libcxx/test/std/utilities/format/format.functions/format_tests.h

168

FWIW, I strongly prefer -1whatever over ~0whatever for readability. MSVC really warns on -1u? What about unsigned(-1) or simply 0xFFFFFFFF?

libcxx/test/std/utilities/format/format.functions/vformat.locale.pass.cpp

39–41

As remarked above, personally I think we should just use (void) casts throughout; but either way, please don't break the line after a cast, that's just weird. :p

TEST_IGNORE_NODISCARD std::vformat(std::locale(), fmt,
                                   std::make_format_args<context_t<CharT>>(args...));

or

(void) std::vformat(std::locale(), fmt,
                    std::make_format_args<context_t<CharT>>(args...));

(and if clang-format is complaining, which it shouldn't, then arc --no-lint)

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp

78

Please remove constexpr here, too.

libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp

383

assert(false);, surely!
Also, by comparison with the next file, I suspect this was meant to be a const member function.

libcxx/test/support/charconv_test_helpers.h

111

char(1) plz.
Also, really, MSVC? It's warning... about treating 1 as a char? That's a little aggressive, yeah?

If MSVC is giving the same warning in

• charconv_test_helpers.h
• test_constexpr_container.h
• span.cons/initializer_list.pass.cpp
• vector/access.pass.cpp
• bit/byteswap.pass.cpp

then I think you should consider just globally disabling that warning when running libc++ tests. If it's all subtly different warnings, though, then that's not so attractive an option.

[Mordante]

Thanks for the cleanups!
LGTM modulo some small nits.

libcxx/test/std/containers/sequences/vector/access.pass.cpp

51

I like this TEST_IGNORE_NODISCARD macro, but I wasn't aware it existed. Not too fond of _LIBCPP_UNUSED_VAR(x).

libcxx/test/std/utilities/format/format.arguments/format.arg.store/class.pass.cpp

14–21

Nope the file can actually be removed. I've a not-yet-ready-for-review patch to improve the format-arg-store and there I remove the file. The removal can also be done in this commit or later.

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.pass.cpp

12

No it tests whether the call to std::make_format_args is valid. Its return type is exposition only hence the LIBCPP_ASSERTs. In the aforementioned patch this file will only contain std::make_format_args(42, nullptr, false, 1.0);.

Same story for make_wformat_args.pass.cpp.

libcxx/test/std/utilities/format/format.functions/format.pass.cpp

70–74

Please do the same for similar cases in the other tests.

libcxx/test/std/utilities/format/format.functions/format_tests.h

168

I prefer unsigned(-1), or is that also a warning for MSVC?

[CaseyCarter]

Address review comments.

[CaseyCarter]

libcxx/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp

161–164

I'll take a quick stab at it.

libcxx/test/std/containers/views/span.cons/initializer_list.pass.cpp

24–31

Changing the return type works.

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/cxx20_iter_member.pass.cpp

37

You're preaching to the choir: _any_ source change is better than a #pragma. Unfortunately, this int-to-double conversion isn't the source; MSVC believes integral-to-floating conversions are generally benign. It's actually diagnosing the writes to the insert iterator on lines 45 and 46. These call insert_iterator's operator= that takes an int&& with a temporary int converted from double. As the comment on 45 makes clear, the intent is to verify that the conversion occurs.

Now that I think about it, I can correct the warning by using a simple program-defined value type instead of int, since conversions to user-defined-types are not narrowing.

libcxx/test/std/numerics/bit/byteswap.pass.cpp

76

Sadly, no - int8_t(0xAB), (int8_t)0xAB, and INT8_C(0xAB) all produce the same truncation warning.

libcxx/test/std/ranges/range.factories/range.iota.view/size.pass.cpp

67–69

The root cause here is that C1XX won't realize that the RHS is a constant expression, evaluate it, and notice that it's positive and therefore preserved by conversion to unsigned int for the comparison. The other test cases are all comparisons with literals and thus just simple enough to slip by this pre-constexpr-era warning code. Actually, I can probably hack this by storing numeric_limits<int>::max() in a local constexpr variable - I'll do that.

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.pass.cpp

17–18

Alphabet is hard.

libcxx/test/std/utilities/format/format.arguments/format.arg.store/class.pass.cpp

14–21

I'd feel weird removing this wholesale without adding make_format_args coverage elsewhere. I'll go ahead and make this change, and you all can have your way with the file after.

libcxx/test/std/utilities/format/format.functions/format_tests.h

168

Looks like we're happy with unsigned(-1). Yes, it really warns - something like "Hey, dummy, -meow isn't really negative since meow is unsigned."

libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp

383

Changed to assert, added a bogus return statement to silence warnings. Did I mention how much it bothers me that assert will _never_ be [[noreturn]] in the UCRT? (And don't call me Shirley.)

libcxx/test/support/charconv_test_helpers.h

111

The warning is for the narrowing conversion from iota's int accumulator to char when assigning through buf. And no, I think those cases represent at least four different warnings.

[CaseyCarter]

Actually, I'll go ahead and merge - shout if you dislike the general refactoring in libcxx/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp, and I'll followup.

libcxx/test/std/algorithms/alg.sorting/alg.sort/sort/sort.pass.cpp

 // template<RandomAccessIterator Iter>
 //   requires ShuffleIterator<Iter>
 //         && LessThanComparable<Iter::value_type>
 //   void
 //   sort(Iter first, Iter last);
 
 #include <algorithm>
 #include <iterator>
+#include <numeric>
 #include <random>
 #include <cassert>
 
 #include "test_macros.h"
 
 std::mt19937 randomness;
 
 template <class RI>

libcxx/test/std/concepts/concepts.lang/concept.swappable/swappable.pass.cpp

constexpr bool check_swap_23(T x, T y) {
   std::ranges::swap(x, y);
   return x == e.x && y == e.y;
 }
 // clang-format on
 
 constexpr bool check_lvalue_adl_swappable() {
   auto x = lvalue_adl_swappable(0);
   auto y = lvalue_adl_swappable(1);
-  constexpr auto is_noexcept = noexcept(std::ranges::swap(x, y));
-  return check_swap_21(x, y) && is_noexcept;
+  ASSERT_NOEXCEPT(std::ranges::swap(x, y));
+  assert(check_swap_21(x, y));
+  return true;
 }
 static_assert(check_lvalue_adl_swappable());
 
 constexpr bool check_rvalue_adl_swappable() {
-  constexpr auto is_noexcept = noexcept(
-      std::ranges::swap(rvalue_adl_swappable(0), rvalue_adl_swappable(1)));
-  return check_swap_21(rvalue_adl_swappable(0), rvalue_adl_swappable(1)) &&
-         is_noexcept;
+  ASSERT_NOEXCEPT(std::ranges::swap(rvalue_adl_swappable(0), rvalue_adl_swappable(1)));
+  assert(check_swap_21(rvalue_adl_swappable(0), rvalue_adl_swappable(1)));
+  return true;
 }
 static_assert(check_rvalue_adl_swappable());
 
 constexpr bool check_lvalue_rvalue_adl_swappable() {
   auto x = lvalue_rvalue_adl_swappable(0);
-  constexpr auto is_noexcept =
-      noexcept(std::ranges::swap(x, lvalue_rvalue_adl_swappable(1)));
-  return check_swap_21(x, lvalue_rvalue_adl_swappable(1)) && is_noexcept;
+  ASSERT_NOEXCEPT(std::ranges::swap(x, lvalue_rvalue_adl_swappable(1)));
+  assert(check_swap_21(x, lvalue_rvalue_adl_swappable(1)));
+  return true;
 }
 static_assert(check_lvalue_rvalue_adl_swappable());
 
 constexpr bool check_rvalue_lvalue_adl_swappable() {
   auto x = rvalue_lvalue_adl_swappable(0);
-  constexpr auto is_noexcept =
-      noexcept(std::ranges::swap(rvalue_lvalue_adl_swappable(1), x));
-  return check_swap_21(rvalue_lvalue_adl_swappable(1), x) && is_noexcept;
+  ASSERT_NOEXCEPT(std::ranges::swap(rvalue_lvalue_adl_swappable(1), x));
+  assert(check_swap_21(rvalue_lvalue_adl_swappable(1), x));
+  return true;
 }
 static_assert(check_rvalue_lvalue_adl_swappable());
 
 constexpr bool check_throwable_swappable() {
   auto x = throwable_adl_swappable{0};
   auto y = throwable_adl_swappable{1};
-  constexpr auto not_noexcept = !noexcept(std::ranges::swap(x, y));
-  return check_swap_21(x, y) && not_noexcept;
+  ASSERT_NOT_NOEXCEPT(std::ranges::swap(x, y));
+  assert(check_swap_21(x, y));
+  return true;
 }
 static_assert(check_throwable_swappable());
 
 constexpr bool check_non_move_constructible_adl_swappable() {
   auto x = non_move_constructible_adl_swappable{0};
   auto y = non_move_constructible_adl_swappable{1};
-  constexpr auto is_noexcept = noexcept(std::ranges::swap(x, y));
-  return check_swap_21(x, y) && is_noexcept;
+  ASSERT_NOEXCEPT(std::ranges::swap(x, y));
+  assert(check_swap_21(x, y));
+  return true;
 }
 static_assert(check_non_move_constructible_adl_swappable());
 
 constexpr bool check_non_move_assignable_adl_swappable() {
   auto x = non_move_assignable_adl_swappable{0};
   auto y = non_move_assignable_adl_swappable{1};
-  return check_swap_21(x, y) && noexcept(std::ranges::swap(x, y));
+  ASSERT_NOEXCEPT(std::ranges::swap(x, y));
+  assert(check_swap_21(x, y));
+  return true;
 }
 static_assert(check_non_move_assignable_adl_swappable());
 
 namespace swappable_namespace {
 enum unscoped { hello, world };
 void swap(unscoped&, unscoped&);
 
 enum class scoped { hello, world };
 void swap(scoped&, scoped&);
 } // namespace swappable_namespace
 
 static_assert(std::swappable<swappable_namespace::unscoped>);
 static_assert(std::swappable<swappable_namespace::scoped>);
 
 constexpr bool check_swap_arrays() {
   int x[] = {0, 1, 2, 3, 4};
   int y[] = {5, 6, 7, 8, 9};
-  return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
+  ASSERT_NOEXCEPT(std::ranges::swap(x, y));
+  assert(check_swap_22(x, y));
+  return true;
 }
 static_assert(check_swap_arrays());
 
 constexpr bool check_lvalue_adl_swappable_arrays() {
   lvalue_adl_swappable x[] = {{0}, {1}, {2}, {3}};
   lvalue_adl_swappable y[] = {{4}, {5}, {6}, {7}};
-  return check_swap_22(x, y) && noexcept(std::ranges::swap(x, y));
+  ASSERT_NOEXCEPT(std::ranges::swap(x, y));
+  assert(check_swap_22(x, y));
+  return true;
 }
 static_assert(check_lvalue_adl_swappable_arrays());
 
 constexpr bool check_throwable_adl_swappable_arrays() {
   throwable_adl_swappable x[] = {{0}, {1}, {2}, {3}};
   throwable_adl_swappable y[] = {{4}, {5}, {6}, {7}};
-  return check_swap_22(x, y) && !noexcept(std::ranges::swap(x, y));
+  ASSERT_NOT_NOEXCEPT(std::ranges::swap(x, y));
+  assert(check_swap_22(x, y));
+  return true;
 }
 static_assert(check_throwable_adl_swappable_arrays());
 
-inline auto global_x = 0;
-static_assert(check_swap_23(0, 0) &&
-              noexcept(std::ranges::swap(global_x, global_x)));
-static_assert(check_swap_23(0, 1) &&
-              noexcept(std::ranges::swap(global_x, global_x)));
-static_assert(check_swap_23(1, 0) &&
-              noexcept(std::ranges::swap(global_x, global_x)));
+auto global_x = 0;
+ASSERT_NOEXCEPT(std::ranges::swap(global_x, global_x));
+static_assert(check_swap_23(0, 0));
+static_assert(check_swap_23(0, 1));
+static_assert(check_swap_23(1, 0));
 
 constexpr bool check_swappable_references() {
   int x = 42;
   int y = 64;
-  return check_swap_23<int&>(x, y) && noexcept(std::ranges::swap(x, y));
+  ASSERT_NOEXCEPT(std::ranges::swap(x, y));
+  assert(check_swap_23(x, y));
+  return true;
 }
 static_assert(check_swappable_references());
 
 constexpr bool check_swappable_pointers() {
   char const* x = "hello";
-  return check_swap_23<char const*>(x, nullptr) &&
-         noexcept(std::ranges::swap(x, x));
+  ASSERT_NOEXCEPT(std::ranges::swap(x, x));
+  assert(check_swap_23(x, {}));
+  return true;
 }
 static_assert(check_swappable_pointers());
 
 namespace union_swap {
 union adl_swappable {
   int x;
   double y;
 };
 
 void swap(adl_swappable&, adl_swappable&);
 void swap(adl_swappable&&, adl_swappable&&);
-}; // namespace union_swap
+} // namespace union_swap
 static_assert(std::swappable<union_swap::adl_swappable>);
 static_assert(std::swappable<union_swap::adl_swappable&>);
 static_assert(std::swappable<union_swap::adl_swappable&&>);
 
 // All tests for std::swappable<T> are implicitly confirmed by `check_swap`, so we only need to
 // sanity check for a few positive cases.
 static_assert(std::swappable<int volatile&>);
 static_assert(std::swappable<int&&>);

 static_assert(std::move_constructible<swap_type>);
 static_assert(std::copy_constructible<swap_type>);
 static_assert(std::assignable_from<swap_type&, swap_type>);
 static_assert(std::assignable_from<swap_type&, swap_type&>);
 static_assert(std::assignable_from<swap_type&, swap_type const&>);
 static_assert(std::assignable_from<swap_type&, swap_type const>);
 static_assert(std::swappable<swap_type>);
 
-template <bool is_noexcept, std::swappable T>
+enum class nothrow { no, yes };
+
+template <nothrow is_noexcept, std::swappable T>
 void check_swap(expected<T> const& e) {
   auto a = e.y;
   auto b = e.x;
 
   std::ranges::swap(a, b);
   assert(a == e.x);
   assert(b == e.y);
 
   std::ranges::swap(a, b);
   assert(a == e.y);
   assert(b == e.x);
 
-  static_assert(noexcept(std::ranges::swap(a, b)) == is_noexcept);
+  static_assert(noexcept(std::ranges::swap(a, b)) == bool(is_noexcept));
 }
 
 int main(int, char**) {
   {
     auto const e = expected<std::deque<int> >{
         .x = {6, 7, 8, 9},
         .y = {0, 1, 2, 3, 4, 5},
     };
-    check_swap</*is_noexcept=*/true>(e);
+    check_swap<nothrow::yes>(e);
   }
   {
     auto const e = expected<std::map<int, std::string> >{
         .x = {{0, "whole"}, {1, "cashews"}},
         .y = {{-1, "roasted"}, {2, "&"}, {-3, "salted"}},
     };
-    check_swap</*is_noexcept=*/true>(e);
+    check_swap<nothrow::yes>(e);
   }
   {
     auto const e = expected<std::string>{
         .x = "hello there",
         .y = "general kenobi",
     };
-    check_swap</*is_noexcept=*/true>(e);
+    check_swap<nothrow::yes>(e);
   }
   {
     auto const e = expected<std::optional<lvalue_adl_swappable> >{
         .x = {10},
         .y = {20},
     };
-    check_swap</*is_noexcept=*/true>(e);
+    check_swap<nothrow::yes>(e);
   }
   {
     auto const e = expected<std::optional<throwable_adl_swappable> >{
         .x = {10},
         .y = {20},
     };
-    check_swap</*is_noexcept=*/false>(e);
+    check_swap<nothrow::no>(e);
   }
   {
     auto const e = expected<std::unordered_map<int, std::string> >{
         .x = {{0, "whole"}, {1, "cashews"}},
         .y = {{-1, "roasted"}, {2, "&"}, {-3, "salted"}},
     };
-    check_swap</*is_noexcept=*/true>(e);
+    check_swap<nothrow::yes>(e);
   }
   {
     auto const e = expected<std::vector<int> >{
         .x = {0, 1, 2, 3, 4, 5},
         .y = {6, 7, 8, 9},
     };
 
-    check_swap</*is_noexcept=*/true>(e);
+    check_swap<nothrow::yes>(e);
   }
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/reserve.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 // vector<bool>
 
 // void reserve(size_type n);
 
 #include <vector>
 #include <cassert>
+#include <stdexcept>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/sequences/vector/access.pass.cpp

 // const_reference front() const;
 //
 //       reference back();
 // const_reference back() const;
 // libc++ marks these as 'noexcept' (except 'at')
 
 #include <vector>
 #include <cassert>
+#include <stdexcept>
 
 #include "min_allocator.h"
 #include "test_macros.h"
 
 template <class C>
 C
 make(int size, int start)
 {
     C c;
     for (int i = 0; i < size; ++i)
         c.push_back(start + i);
     return c;
 }
 
 template <class Vector>
 void test_get_basic(Vector& c, int start_value) {
-    const int n = c.size();
+    const int n = static_cast<int>(c.size());
     for (int i = 0; i < n; ++i)
         assert(c[i] == start_value + i);
     for (int i = 0; i < n; ++i)
         assert(c.at(i) == start_value + i);
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
     try {
-        c.at(n);
+        TEST_IGNORE_NODISCARD c.at(n);
         assert(false);
     } catch (const std::out_of_range&) {}
 #endif
 
     assert(c.front() == start_value);
     assert(c.back() == start_value + n - 1);
 }
 

libcxx/test/std/containers/sequences/vector/vector.capacity/reserve.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
 //
 //===----------------------------------------------------------------------===//
 
 // <vector>
 
 // void reserve(size_type n);
 
 #include <vector>
 #include <cassert>
+#include <stdexcept>
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "min_allocator.h"
 #include "asan_testing.h"
 
 int main(int, char**)
 {
     {

libcxx/test/std/containers/views/span.cons/initializer_list.pass.cpp

 #include <span>
 #include <cassert>
 
 struct Sink {
     constexpr Sink() = default;
     constexpr Sink(Sink*) {}
 };
 
-constexpr int count(std::span<const Sink> sp) {
+constexpr size_t count(std::span<const Sink> sp) {
     return sp.size();
 }
 
 template<int N>
-constexpr int countn(std::span<const Sink, N> sp) {
+constexpr size_t countn(std::span<const Sink, N> sp) {
     return sp.size();
 }
 
 constexpr bool test() {
     Sink a[10];
     assert(count({a}) == 10);
     assert(count({a, a+10}) == 10);
     assert(countn<10>({a}) == 10);
     return true;
 }
 
 int main(int, char**)
 {
     test();
     static_assert(test());
 
     return 0;
 }

libcxx/test/std/iterators/predef.iterators/insert.iterators/insert.iterator/cxx20_iter_member.pass.cpp

 
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 
 struct NoIteratorAlias {
     double data_[3] = {};
-    using value_type = int;
     double *begin();
-    constexpr double *insert(double *pos, int value) {
+
+    struct value_type {
+        constexpr value_type(double d) : x(static_cast<int>(d)) {}
+        constexpr operator double() const { return x; }
+
+        int x;
+    };
+
+    template <class T>
+    constexpr double *insert(double *pos, T value) {
+        static_assert(std::is_same_v<T, value_type>);
         *pos = value;
         return pos;
     }
 };
 
 static_assert(std::is_constructible_v<std::insert_iterator<NoIteratorAlias>, NoIteratorAlias&, double*>);
-static_assert(!std::is_constructible_v<std::insert_iterator<NoIteratorAlias>, NoIteratorAlias&, int*>);
+static_assert(
+    !std::is_constructible_v<std::insert_iterator<NoIteratorAlias>, NoIteratorAlias&, NoIteratorAlias::value_type*>);
 
 constexpr bool test() {
     NoIteratorAlias c;
     double half = 0.5;
     auto it = std::insert_iterator<NoIteratorAlias>(c, c.data_);
     ASSERT_SAME_TYPE(decltype(std::inserter(c, c.data_)), std::insert_iterator<NoIteratorAlias>);
     *it++ = 1 + half;  // test that RHS is still implicitly converted to _Container::value_type
     *it++ = 2 + half;

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.hash/hash.pass.cpp

 #include <cstdint>
 #include <cassert>
 #include <functional>
 
 #include "test_macros.h"
 
 template <class C>
 void do_test(int *LHSVal, int *RHSVal) {
-  const size_t ExpectLHS = std::hash<void*>{}((LHSVal));
-  const size_t ExpectRHS = std::hash<void*>{}((RHSVal));
-  const C LHS = C::from_address((LHSVal));
-  const C RHS = C::from_address((RHSVal));
+  [[maybe_unused]] const size_t ExpectLHS = std::hash<void*>{}(LHSVal);
+  [[maybe_unused]] const size_t ExpectRHS = std::hash<void*>{}(RHSVal);
+  const C LHS = C::from_address(LHSVal);
+  const C RHS = C::from_address(RHSVal);
   const std::hash<C> h;
 
   LIBCPP_ASSERT(h(LHS) == ExpectLHS);
   LIBCPP_ASSERT(h(RHS) == ExpectRHS);
   assert((h(LHS) == h(RHS)) == (LHSVal == RHSVal));
   {
     ASSERT_SAME_TYPE(decltype(h(LHS)), size_t);
     ASSERT_NOEXCEPT(std::hash<C>{}(LHS));

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.export/from_address.pass.cpp

void do_test() {
     assert(c.address() == nullptr);
   }
   {
     char dummy = 42;
     C c = C::from_address((void*)&dummy);
     assert(c.address() == &dummy);
   }
   {
-    C::from_address((int*)nullptr);
-    C::from_address((void*)nullptr);
-    C::from_address((char*)nullptr);
+    TEST_IGNORE_NODISCARD C::from_address((int*)nullptr);
+    TEST_IGNORE_NODISCARD C::from_address((void*)nullptr);
+    TEST_IGNORE_NODISCARD C::from_address((char*)nullptr);
   }
   {
     char dummy = 42;
     C c = C::from_address(&dummy);
     int* p = (int*)c.address();
     std::coroutine_handle<> c2 = std::coroutine_handle<>::from_address(p);
     assert(c2 == c);
   }

libcxx/test/std/language.support/support.coroutines/coroutine.handle/coroutine.handle.noop/noop_coroutine.pass.cpp

int main(int, char**)
   // destroy on that handle will also have no observable
   // effects.
   base.resume();
   base.destroy();
   base();
   assert(base);
   assert(base.done() == false);
 
-  h.promise();
+  TEST_IGNORE_NODISCARD h.promise();
   assert(h.address() == base.address());
   assert(h == base);
   assert(h.address() != nullptr);
   assert(std::coroutine_handle<>::from_address(h.address()) == base);
 
   return 0;
 }

libcxx/test/std/numerics/bit/byteswap.pass.cpp

 constexpr std::pair<T, T> get_test_data() {
   switch (sizeof(T)) {
   case 2:
     return {static_cast<T>(0x1234), static_cast<T>(0x3412)};
   case 4:
     return {static_cast<T>(0x60AF8503), static_cast<T>(0x0385AF60)};
   case 8:
     return {static_cast<T>(0xABCDFE9477936406), static_cast<T>(0x0664937794FECDAB)};
-  }
+  default:
     assert(false);
+    return {}; // for MSVC, whose `assert` is tragically not [[noreturn]]
+  }
 }
 
 template <class T>
 constexpr void test_implementation_defined_size() {
   const auto [in, expected] = get_test_data<T>();
   test_num<T>(in, expected);
 }
 
 constexpr bool test() {
   test_num<uint8_t>(0xAB, 0xAB);
   test_num<uint16_t>(0xCDEF, 0xEFCD);
   test_num<uint32_t>(0x01234567, 0x67452301);
   test_num<uint64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
-  test_num<int8_t>(0xAB, 0xAB);
-  test_num<int16_t>(0xCDEF, 0xEFCD);
+  test_num<int8_t>(static_cast<int8_t>(0xAB), static_cast<int8_t>(0xAB));
+  test_num<int16_t>(static_cast<int16_t>(0xCDEF), static_cast<int16_t>(0xEFCD));
   test_num<int32_t>(0x01234567, 0x67452301);
   test_num<int64_t>(0x0123456789ABCDEF, 0xEFCDAB8967452301);
 
 #ifndef _LIBCPP_HAS_NO_INT128
   const auto in = static_cast<__uint128_t>(0x0123456789ABCDEF) << 64 | 0x13579BDF02468ACE;
   const auto expected = static_cast<__uint128_t>(0xCE8A4602DF9B5713) << 64 | 0xEFCDAB8967452301;
   test_num<__uint128_t>(in, expected);
   test_num<__int128_t>(in, expected);
 #endif
 
   test_num<bool>(true, true);
   test_num<bool>(false, false);
-  test_num<char>(0xCD, 0xCD);
+  test_num<char>(static_cast<char>(0xCD), static_cast<char>(0xCD));
   test_num<unsigned char>(0xEF, 0xEF);
   test_num<signed char>(0x45, 0x45);
   test_num<char8_t>(0xAB, 0xAB);
   test_num<char16_t>(0xABCD, 0xCDAB);
   test_num<char32_t>(0xABCDEF01, 0x01EFCDAB);
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   test_implementation_defined_size<wchar_t>();
 #endif

libcxx/test/std/ranges/range.factories/range.iota.view/range_concept_conformance.compile.pass.cpp

 
 #include "types.h"
 
 struct Decrementable {
   using difference_type = int;
 
   auto operator<=>(const Decrementable&) const = default;
 
-  constexpr Decrementable& operator++();
-  constexpr Decrementable  operator++(int);
-  constexpr Decrementable& operator--();
-  constexpr Decrementable  operator--(int);
+  Decrementable& operator++();
+  Decrementable  operator++(int);
+  Decrementable& operator--();
+  Decrementable  operator--(int);
 };
 
 struct Incrementable {
   using difference_type = int;
 
   auto operator<=>(const Incrementable&) const = default;
 
-  constexpr Incrementable& operator++();
-  constexpr Incrementable  operator++(int);
+  Incrementable& operator++();
+  Incrementable  operator++(int);
 };
 
 static_assert(std::ranges::random_access_range<std::ranges::iota_view<int>>);
 static_assert(std::ranges::random_access_range<const std::ranges::iota_view<int>>);
 static_assert(std::ranges::bidirectional_range<std::ranges::iota_view<Decrementable>>);
 static_assert(std::ranges::forward_range<std::ranges::iota_view<Incrementable>>);
 static_assert(std::ranges::input_range<std::ranges::iota_view<NotIncrementable>>);
 static_assert(std::ranges::view<std::ranges::iota_view<int>>);

libcxx/test/std/ranges/range.factories/range.iota.view/size.pass.cpp

// Both are integer like and neither less than zero.
     const std::ranges::iota_view<int, int> io(10, 10);
     assert(io.size() == 0);
   }
   {
     const std::ranges::iota_view<int, int> io(0, 0);
     assert(io.size() == 0);
   }
   {
     const std::ranges::iota_view<int, int> io(0, std::numeric_limits<int>::max());
-    assert(io.size() == std::numeric_limits<int>::max());
+    constexpr auto imax = std::numeric_limits<int>::max();
+    assert(io.size() == imax);
   }
 
   // Neither are integer like.
   {
     const std::ranges::iota_view<SomeInt, SomeInt> io(SomeInt(-20), SomeInt(-10));
     assert(io.size() == 10);
   }
   {

libcxx/test/std/strings/basic.string/string.capacity/resize_and_overwrite.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, c++11, c++14, c++17, c++20
 
 // <string>
 
 // template<class Operation>
 // void resize_and_overwrite(size_type n, Operation op)
 
+#include <algorithm>
 #include <cassert>
 #include <string>
 
 #include "make_string.h"
 #include "test_macros.h"
 
 template <class S>
 constexpr void test_appending(size_t k, size_t N, size_t new_capacity) {
   assert(N > k);
   assert(new_capacity >= N);

libcxx/test/std/utilities/format/format.arguments/format.arg.store/class.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, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 
 // <format>
 
 // template<class Context, class... Args>
 // struct format-arg-store {      // exposition only
 //   array<basic_format_arg<Context>, sizeof...(Args)> args;
 // };
 //
 // Note more testing is done in the unit test for:
 // template<class Visitor, class Context>
 //   see below visit_format_arg(Visitor&& vis, basic_format_arg<Context> arg);
 
 #include <format>
 #include <cassert>
 #include <cstddef>
 #include <type_traits>
 
 #include "test_macros.h"
 
 template <class CharT>
 void test() {
   using Context = std::basic_format_context<CharT*, CharT>;
   {
-    auto store = std::make_format_args<Context>();
+    [[maybe_unused]] auto store = std::make_format_args<Context>();
     LIBCPP_STATIC_ASSERT(
         std::is_same_v<decltype(store), std::__format_arg_store<Context>>);
     LIBCPP_STATIC_ASSERT(
         std::is_same_v<decltype(store.__args),
                        std::array<std::basic_format_arg<Context>, 0>>);
     LIBCPP_ASSERT(store.__args.size() == 0);
   }
   {
-    auto store = std::make_format_args<Context>(1);
+    [[maybe_unused]] auto store = std::make_format_args<Context>(1);
     LIBCPP_STATIC_ASSERT(
         std::is_same_v<decltype(store), std::__format_arg_store<Context, int>>);
     LIBCPP_STATIC_ASSERT(
         std::is_same_v<decltype(store.__args),
                        std::array<std::basic_format_arg<Context>, 1>>);
     LIBCPP_ASSERT(store.__args.size() == 1);
   }
   {
-    auto store = std::make_format_args<Context>(1, 'c');
+    [[maybe_unused]] auto store = std::make_format_args<Context>(1, 'c');
     LIBCPP_STATIC_ASSERT(
         std::is_same_v<decltype(store),
                        std::__format_arg_store<Context, int, char>>);
     LIBCPP_STATIC_ASSERT(
         std::is_same_v<decltype(store.__args),
                        std::array<std::basic_format_arg<Context>, 2>>);
     LIBCPP_ASSERT(store.__args.size() == 2);
   }
   {
-    auto store = std::make_format_args<Context>(1, 'c', nullptr);
+    [[maybe_unused]] auto store = std::make_format_args<Context>(1, 'c', nullptr);
     LIBCPP_STATIC_ASSERT(
         std::is_same_v<decltype(store),
                        std::__format_arg_store<Context, int, char, std::nullptr_t>>);
     LIBCPP_STATIC_ASSERT(
         std::is_same_v<decltype(store.__args),
                        std::array<std::basic_format_arg<Context>, 3>>);
     LIBCPP_ASSERT(store.__args.size() == 3);
   }

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_format_args.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, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // TODO FMT Evaluate gcc-11 status
 // UNSUPPORTED: gcc-11
 
 // <format>
 
 // template<class Context = format_context, class... Args>
 // format-arg-store<Context, Args...> make_format_args(const Args&... args);
 
 #include <cassert>
 #include <format>
 #include <iterator>
 #include <string>
 
 #include "test_basic_format_arg.h"
 #include "test_macros.h"
 
 int main(int, char**) {
-  using Context = std::basic_format_context<
+  using Context [[maybe_unused]] = std::basic_format_context<
       std::back_insert_iterator<std::basic_string<char>>, char>;
 
-  auto value = std::make_format_args(42, nullptr, false, 1.0);
+  [[maybe_unused]] auto value = std::make_format_args(42, nullptr, false, 1.0);
 
   LIBCPP_ASSERT(value.__args.size() == 4);
   LIBCPP_ASSERT(test_basic_format_arg(value.__args[0], 42));
   // Note [format.arg]/11 specifies a nullptr is stored as a const void*.
   LIBCPP_ASSERT(test_basic_format_arg(value.__args[1],
                                       static_cast<const void*>(nullptr)));
   LIBCPP_ASSERT(test_basic_format_arg(value.__args[2], false));
   LIBCPP_ASSERT(test_basic_format_arg(value.__args[3], 1.0));
 
   return 0;
 }

libcxx/test/std/utilities/format/format.arguments/format.arg.store/make_wformat_args.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, c++11, c++14, c++17
 // UNSUPPORTED: libcpp-no-concepts
 // UNSUPPORTED: libcpp-has-no-incomplete-format
 // XFAIL: libcpp-has-no-wide-characters
 // TODO FMT Evaluate gcc-11 status
 // UNSUPPORTED: gcc-11
 
 // <format>
 
 // template<class... Args>
 //   format-arg-store<wformat_context, Args...>
 //   make_wformat_args(const Args&... args);
 
 #include <cassert>
 #include <format>
 
 #include "test_basic_format_arg.h"
 #include "test_macros.h"
 
 int main(int, char**) {
-  using Context = std::basic_format_context<
+  using Context [[maybe_unused]] = std::basic_format_context<
       std::back_insert_iterator<std::basic_string<wchar_t>>, wchar_t>;
 
-  auto value = std::make_wformat_args(42, nullptr, false, 1.0);
+  [[maybe_unused]] auto value = std::make_wformat_args(42, nullptr, false, 1.0);
 
   LIBCPP_ASSERT(value.__args.size() == 4);
   LIBCPP_ASSERT(test_basic_format_arg(value.__args[0], 42));
   // Note [format.arg]/11 specifies a nullptr is stored as a const void*.
   LIBCPP_ASSERT(test_basic_format_arg(value.__args[1],
                                       static_cast<const void*>(nullptr)));
   LIBCPP_ASSERT(test_basic_format_arg(value.__args[2], false));
   LIBCPP_ASSERT(test_basic_format_arg(value.__args[3], 1.0));
 
   return 0;
 }

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/check_arg_id.pass.cpp

for (size_t i = 0; i < 10; ++i)
     context.check_arg_id(i);
 
   return true;
 }
 
 void test_exception() {
   [] {
     std::format_parse_context context("", 1);
-    context.next_arg_id();
+    TEST_IGNORE_NODISCARD context.next_arg_id();
     try {
       context.check_arg_id(0);
       assert(false);
-    } catch (const std::format_error& e) {
+    } catch ([[maybe_unused]] const std::format_error& e) {
       LIBCPP_ASSERT(strcmp(e.what(), "Using manual argument numbering in automatic "
                                      "argument numbering mode") == 0);
       return;
     }
     assert(false);
   }();
 
   auto test_arg = [](size_t num_args) {
     std::format_parse_context context("", num_args);
     // Out of bounds access is valid if !std::is_constant_evaluated()
     for (size_t i = 0; i <= num_args; ++i)

libcxx/test/std/utilities/format/format.formatter/format.parse.ctx/next_arg_id.pass.cpp

constexpr bool test() {
   return true;
 }
 
 void test_exception() {
   std::format_parse_context context("", 1);
   context.check_arg_id(0);
 
   try {
-    context.next_arg_id();
+    TEST_IGNORE_NODISCARD context.next_arg_id();
     assert(false);
-  } catch (const std::format_error& e) {
+  } catch ([[maybe_unused]] const std::format_error& e) {
     LIBCPP_ASSERT(strcmp(e.what(), "Using automatic argument numbering in manual "
                                    "argument numbering mode") == 0);
     return;
   }
   assert(false);
 }
 
 int main(int, char**) {
   test();
   test_exception();
   static_assert(test());
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/format.pass.cpp

if constexpr (std::same_as<CharT, char>)
       if (e.what() != what)
         std::cerr << "\nFormat string   " << fmt << "\nExpected exception "
                   << what << "\nActual exception   " << e.what() << '\n';
 #endif
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
-#else
+#endif
   (void)what;
   (void)fmt;
   (void)sizeof...(args);
-#endif
 };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/format_tests.h

#endif
   check_exception(
       "A format-spec width field replacement should have a positive value",
       STR("hello {:{}}"), world, 0);
   check_exception(
       "A format-spec arg-id replacement shouldn't have a negative value",
       STR("hello {:{}}"), world, -1);
   check_exception(
       "A format-spec arg-id replacement exceeds the maximum supported value",
-      STR("hello {:{}}"), world, -1u);
+      STR("hello {:{}}"), world, unsigned(-1));
   check_exception("Argument index out of bounds", STR("hello {:{}}"), world);
   check_exception(
       "A format-spec arg-id replacement argument isn't an integral type",
       STR("hello {:{}}"), world, universe);
   check_exception(
       "Using manual argument numbering in automatic argument numbering mode",
       STR("hello {:{0}}"), world, 1);
   check_exception(
#endif
   check(STR("hello "), STR("hello {:.{}}"), world, 0);
   // Precision may have leading zeros. Secondly tests the value is still base 10.
   check(STR("hello 0123456789"), STR("hello {:.000010}"), STR("0123456789abcdef"));
   check_exception(
       "A format-spec arg-id replacement shouldn't have a negative value",
       STR("hello {:.{}}"), world, -1);
   check_exception(
       "A format-spec arg-id replacement exceeds the maximum supported value",
-      STR("hello {:.{}}"), world, -1u);
+      STR("hello {:.{}}"), world, ~0u);
   check_exception("Argument index out of bounds", STR("hello {:.{}}"), world);
   check_exception(
       "A format-spec arg-id replacement argument isn't an integral type",
       STR("hello {:.{}}"), world, universe);
   check_exception(
       "Using manual argument numbering in automatic argument numbering mode",
       STR("hello {:.{0}}"), world, 1);
   check_exception(

libcxx/test/std/utilities/format/format.functions/vformat.locale.pass.cpp

std::basic_string<CharT> out = std::vformat(
       std::locale(), fmt, std::make_format_args<context_t<CharT>>(args...));
   assert(out == expected);
 };
 
 auto test_exception = []<class CharT, class... Args>(
     std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
-    std::vformat(std::locale(), fmt,
+    (void) std::vformat(std::locale(), fmt,
                         std::make_format_args<context_t<CharT>>(args...));
     assert(false);
-  } catch (std::format_error& e) {
+  } catch ([[maybe_unused]] std::format_error& e) {
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
-#else
+#endif
   (void)what;
   (void)fmt;
   (void)sizeof...(args);
-#endif
 };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/vformat.pass.cpp

std::basic_string<CharT> out =
       std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
   assert(out == expected);
 };
 
 auto test_exception = []<class CharT, class... Args>(
     std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
-    std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
+    TEST_IGNORE_NODISCARD std::vformat(fmt, std::make_format_args<context_t<CharT>>(args...));
     assert(false);
-  } catch (std::format_error& e) {
+  } catch ([[maybe_unused]] std::format_error& e) {
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
-#else
+#endif
   (void)what;
   (void)fmt;
   (void)sizeof...(args);
-#endif
 };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/vformat_to.locale.pass.cpp

 auto test_exception = []<class CharT, class... Args>(
     std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
     std::basic_string<CharT> out;
     std::vformat_to(std::back_inserter(out), std::locale(), fmt,
                     std::make_format_args<context_t<CharT>>(args...));
     assert(false);
-  } catch (std::format_error& e) {
+  } catch ([[maybe_unused]] std::format_error& e) {
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
-#else
+#endif
   (void)what;
   (void)fmt;
   (void)sizeof...(args);
-#endif
 };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/format/format.functions/vformat_to.pass.cpp

 auto test_exception = []<class CharT, class... Args>(
     std::string_view what, std::basic_string<CharT> fmt, const Args&... args) {
 #ifndef TEST_HAS_NO_EXCEPTIONS
   try {
     std::basic_string<CharT> out;
     std::vformat_to(std::back_inserter(out), fmt,
                     std::make_format_args<context_t<CharT>>(args...));
     assert(false);
-  } catch (std::format_error& e) {
+  } catch ([[maybe_unused]] std::format_error& e) {
     LIBCPP_ASSERT(e.what() == what);
     return;
   }
   assert(false);
-#else
+#endif
   (void)what;
   (void)fmt;
   (void)sizeof...(args);
-#endif
 };
 
 int main(int, char**) {
   format_tests<char>(test, test_exception);
 
 #ifndef TEST_HAS_NO_WIDE_CHARACTERS
   format_tests_char_to_wchar_t(test);
   format_tests<wchar_t>(test, test_exception);
 #endif
 
   return 0;
 }

libcxx/test/std/utilities/optional/optional.object/optional.object.ctor/explicit_const_optional_U.pass.cpp

 };
 
 int count = 0;
 
 class Z
 {
     int i_;
 public:
-    constexpr explicit Z(int i) : i_(i) { TEST_THROW(6);}
+    explicit Z(int i) : i_(i) {TEST_THROW(6);}
 
-    friend constexpr bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
+    friend bool operator==(const Z& x, const Z& y) {return x.i_ == y.i_;}
 };
 
 template<class T, class U>
 constexpr bool test_all()
 {
   {
     optional<U> rhs;
     test<T>(rhs);

libcxx/test/std/utilities/variant/variant.visit/visit.pass.cpp

void test_derived_from_variant() {
   };
 
   std::visit([](auto x) { assert(x == 12); }, EvilVariant1{12});
   std::visit([](auto x) { assert(x == 12.3); }, EvilVariant1{12.3});
 
   // Check that visit unambiguously picks the variant, even if the other base has __impl member.
   struct ImplVariantBase {
     struct Callable {
-      bool operator()();
+      bool operator()() const { assert(false); return false; }
     };
 
     Callable __impl;
   };
 
   struct EvilVariant2 : std::variant<int, long, double>, ImplVariantBase {
     using std::variant<int, long, double>::variant;
   };

libcxx/test/std/utilities/variant/variant.visit/visit_return_type.pass.cpp

std::visit<bool>(
         assert(x == 12.3);
         return true;
       },
       EvilVariant1{12.3});
 
   // Check that visit unambiguously picks the variant, even if the other base has __impl member.
   struct ImplVariantBase {
     struct Callable {
-      bool operator()();
+      bool operator()() const { assert(false); return false; }
     };
 
     Callable __impl;
   };
 
   struct EvilVariant2 : std::variant<int, long, double>, ImplVariantBase {
     using std::variant<int, long, double>::variant;
   };

libcxx/test/support/charconv_test_helpers.h

struct to_chars_test_base
     template <typename... Ts>
     void test_value(X v, Ts... args)
     {
         using std::to_chars;
         std::to_chars_result r;
 
         // Poison the buffer for testing whether a successful std::to_chars
         // doesn't modify data beyond r.ptr.
-        std::iota(buf, buf + sizeof(buf), 1);
+        std::iota(buf, buf + sizeof(buf), char(1));
         r = to_chars(buf, buf + sizeof(buf), v, args...);
         assert(r.ec == std::errc{});
         for (size_t i = r.ptr - buf; i < sizeof(buf); ++i)
             assert(buf[i] == static_cast<char>(i + 1));
         *r.ptr = '\0';
 
         auto a = fromchars(buf, r.ptr, args...);
         assert(v == a);

libcxx/test/support/test_constexpr_container.h

public:
     constexpr iterator end() { return data_ + size_; }
     constexpr const_iterator begin() const { return data_; }
     constexpr const_iterator end() const { return data_ + size_; }
     constexpr size_t size() const { return size_; }
     constexpr const T& front() const { assert(size_ >= 1); return data_[0]; }
     constexpr const T& back() const { assert(size_ >= 1); return data_[size_-1]; }
 
     constexpr iterator insert(const_iterator pos, T t) {
-        int i = (pos - data_);
+        int i = static_cast<int>(pos - data_);
         if (i != size_) {
             std::move_backward(data_ + i, data_ + size_, data_ + size_ + 1);
         }
         data_[i] = std::move(t);
         size_ += 1;
         return data_ + i;
     }
 
     constexpr void push_back(T t) { insert(end(), std::move(t)); }
     constexpr void push_front(T t) { insert(begin(), std::move(t)); }
 };
 
 #endif // TEST_STD_VER >= 14
 
 #endif // SUPPORT_TEST_CONSTEXPR_CONTAINER_H