[libc++] Define _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER whenever we enable warnings in the test suite

[ldionne]

Summary

This should make CI consistent on all the compilers we support. Most of
this patch is working around various warnings emitted by GCC in our code
base, which are now being shown when we compile the tests.

After this patch, the whole test suite should be warning free on all
compilers we support and test, except for a few warnings on GCC that
we silence explicitly until we figure out the proper fix for them.

[• Quuxplusone]

libcxx/utils/libcxx/test/params.py

122–128

Do I understand correctly that this diff is intimately related to D118616?
It sounds like the status quo ante was "We use -isystem for our headers, but -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER on Clang so that in fact they aren't treated as system headers, thus we do get warnings (except, oops, -isystem is still in effect so we don't)".
And it sounds like the status after D118616 + D120684 will be "We use -I for our headers, so we get warnings, except we don't because of pragma GCC system_header, except (if we want warnings) we'll also pass -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER to nerf pragma GCC system_header so that we do get warnings."

I don't want to block either of D118616 + D120684, but I do wonder if it would be a viable followup solution to just eliminate pragma GCC system_header altogether. I mean, isn't the whole point of placing libc++ in a "system include directory" that the compiler already has heuristics for deciding what's a system header and what isn't? What was our original rationale for adding this pragma?

The pragma was already present in @howard.hinnant's first commit 3e519524c1186, and the original rationale for guarding it under _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER was apparently Win32 support, not anything at all related to warning suppression. Even the macro's name is a huge hint that we shouldn't be using it for warning suppression.

[ldionne]

libcxx/utils/libcxx/test/params.py

122–128

Yes, you are correct about the relationship between -isystem and -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER, and in particular the fact that we need both D118616 and this patch in order to really enable warnings in system headers.

I also agree that it would make sense to get rid of pragma GCC system_header altogether -- I didn't know it was for Win32 support originally. However, I am worried that removing pragma GCC system_header would break some users that are using -I include/c++/v1 and compiling with -Werror. Currently, they are not getting warnings from libc++ because of the pragma -- if we removed it, they would start getting those warnings (turned into errors). I suggest we take the shortest path towards re-enabling warnings, which is to land both this and D118616, and then we can go back and try to simply remove pragma GCC system_header altogether. I can run a build on a large code base to try to gauge the impact of it.

[• Quuxplusone]

libcxx/utils/libcxx/test/params.py

122–128

However, I am worried that removing pragma GCC system_header would break some users that are using -I include/c++/v1 and compiling with -Werror.

Good point; I agree with that concern.

I suggest we take the shortest path towards re-enabling warnings

Seems like warnings have been disabled since, like, forever, haven't they? so I'm temperamentally inclined to say "let's not move until we know exactly where we're going." But I don't actually wish to block your plan; go for it AFAIC.

One more thought: Are we sure there's no existing Clang/GCC compiler option like -Weven-in-system-headers? That's really what we... oh, bah, no, that's not what we want. We want to see errors from libc++ system headers only, but continue suppressing any errors from e.g. /usr/include/stdio.h. Yuck. In that case, your plan might get us to the best possible state, except that _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER will be somewhat misnamed; at this point it would be more like a _LIBCPP_DONT_SUPPRESS_WARNINGS.

TLDR, go for it.

[ldionne]

Fix GCC warnings

[EricWF]

Let's just turn -Wliteral-suffix off in the test suite, since it's literally not designed to be useful for standard libraries.

I really don't want to see our code littered with warning pragmas. Either we should clean up the warning everywhere, or turn it off everywhere.

[• Quuxplusone]

In D120684#3351864, @EricWF wrote:

Let's just turn -Wliteral-suffix off in the test suite

+1, assuming that would work.

[ldionne]

Address comments and rebase.

[ldionne]

Work around GCC's handling of [[deprecated]].

[ldionne]

Fix CI failure on GCC

[ldionne]

Rebase onto main (including the -I change)

[• Quuxplusone]

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp

17 ↗

(On Diff #412694)

How many of the diffs are just refactoring #define into ADDITIONAL_COMPILER_FLAGS: -D? I don't think that's related to the point of this patch; I also think it's uncontroversial and you could ship it right now. Or am I missing something?

(Further down, I see some where the #define was separated from the REQUIRES by several lines of code. I suggest moving it up to the line immediately after the REQUIRES.)

[ldionne]

libcxx/test/std/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.pass.cpp

17 ↗

(On Diff #412694)

Will do in a separate commit!

[ldionne]

Hopefully fix all remaining warnings

[• Quuxplusone]

libcxx/include/__algorithm/copy.h

56 ↗

(On Diff #412808)

Here and throughout: what is the compiler complaining about if you don't do this? Implicit conversion from T* to void* is absolutely part of C++ since forever, until forever; and this isn't an ADL situation either; so I can't imagine what a compiler could possibly see to warn about here.

libcxx/include/any

370

#include <__utility/unreachable.h>, right?

libcxx/include/experimental/simd

1473–1474

Just from a quick glance at this code, I'm confused. Where are the definitions of these friend functions? If they don't actually exist, then perhaps these lines should just be removed, or at least #if 0'd out.

libcxx/include/latch

94

Let's use [&] here, because that's the "default, 99% of the time" thing. We're not doing anything special here that would justify deviating from the default thing.
Optionally, inline the lambda in the one place it's used:

__cxx_atomic_wait(&__a.__a_, [&]() {
    return try_wait();
});

libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp

11–13

I don't understand this comment.

libcxx/test/support/type_classification/movable.h

71–72

I don't understand the relevance of these changes, but I certainly don't object.

[ldionne]

libcxx/include/__algorithm/copy.h

56 ↗

(On Diff #412808)

It is complaining that we're using memmove (or memcpy) on a type that doesn't have a trivial copy constructor or copy assignment operator. Above, we check for is_trivially_copy_assignable, which means that we can sometimes call this function on a type that has a trivial copy assignment, but not a trivial copy constructor.

The same goes for __construct_range_forward, but there instead we are calling memcpy on a type that has a trivial copy constructor, but no trivial copy assignment operator.

I'm not sure why GCC sees fit to warn about this. LMK if you think another approach is better to silence the warnings.

libcxx/include/experimental/simd

1473–1474

They are not defined anywhere. Our implementation of experimental::simd is not really complete. I'll #if 0 them out.

libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp

11–13

GCC produces the following warning:

In file included from /llvm/build/generic-gcc/include/c++/v1/__concepts/arithmetic.h:13,
                 from /llvm/build/generic-gcc/include/c++/v1/concepts:132,
                 from /llvm/build/generic-gcc/include/c++/v1/__iterator/incrementable_traits.h:14,
                 from /llvm/build/generic-gcc/include/c++/v1/__iterator/concepts.h:14,
                 from /llvm/build/generic-gcc/include/c++/v1/__iterator/distance.h:14,
                 from /llvm/build/generic-gcc/include/c++/v1/__algorithm/equal.h:15,
                 from /llvm/build/generic-gcc/include/c++/v1/array:111,
                 from /llvm/libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp:21:
/llvm/build/generic-gcc/include/c++/v1/type_traits: In instantiation of 'struct std::__1::is_constructible<void (Empty::* const)(const int&)>':
/llvm/build/generic-gcc/include/c++/v1/type_traits:2927:77:   required from 'constexpr const bool std::__1::is_constructible_v<void (Empty::* const)(const int&)>'
/llvm/build/generic-gcc/include/c++/v1/__concepts/constructible.h:28:26:   required from 'void test_not_const() [with T = void (Empty::*)(const int&)]'
/llvm/libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp:192:62:   required from here
/llvm/build/generic-gcc/include/c++/v1/type_traits:2922:38: error: type qualifiers ignored on cast result type [-Werror=ignored-qualifiers]
 2922 |     : public integral_constant<bool, __is_constructible(_Tp, _Args...)>
      |                                      ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
In file included from /llvm/build/generic-gcc/include/c++/v1/concepts:138,
                 from /llvm/build/generic-gcc/include/c++/v1/__iterator/incrementable_traits.h:14,
                 from /llvm/build/generic-gcc/include/c++/v1/__iterator/concepts.h:14,
                 from /llvm/build/generic-gcc/include/c++/v1/__iterator/distance.h:14,
                 from /llvm/build/generic-gcc/include/c++/v1/__algorithm/equal.h:15,
                 from /llvm/build/generic-gcc/include/c++/v1/array:111,
                 from /llvm/libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp:21:
/llvm/build/generic-gcc/include/c++/v1/__concepts/constructible.h: In instantiation of 'void test_not_const() [with T = void (Empty::*)(const int&)]':
/llvm/libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp:192:62:   required from here
/llvm/build/generic-gcc/include/c++/v1/__concepts/constructible.h:37:16: error: type qualifiers ignored on cast result type [-Werror=ignored-qualifiers]
   37 |     requires { _Tp{}; } && __default_initializable<_Tp>;
      |                ^~~~~

I believe the relevant bit here is that we're calling std::is_constructible_v<void (Empty::* const)(const int&)>, and GCC is basically saying that we don't care about the const qualifier in Empty::* const.

libcxx/test/support/type_classification/movable.h

71–72

Otherwise, GCC warns about deprecated implicit definition of the copy constructor.

[• Quuxplusone]

libcxx/include/__algorithm/copy.h

56 ↗

(On Diff #412808)

We could fix this by adding -Wno-class-memaccess to the tests.
On the one hand, -Wno-class-memaccess feels more philosophically honest; just adding a cast to void* doesn't make the UB go away, and the wording of GCC's warning message doesn't imply that they think adding the cast should shut up the warning. We might find that in GCC n+1, the compiler can see through the cast and warns anyway.
https://godbolt.org/z/K5Ex3hxP6

warning: 'void* memcpy(void*, const void*, size_t)' writing to an object
of non-trivially copyable type 'struct A'; use copy-assignment or
copy-initialization instead [-Wclass-memaccess]

On the other hand, passing -Wno-class-memaccess to our own tests doesn't fix the problem for anybody else... if there even is a problem for anyone else. We're moving to -I for the tests, but surely we expect actual users to be using -isystem and so they'll never care about this warning, right?
Also, passing -Wno-class-memaccess to the tests would fail to alert us if anywhere unintentionally ran foul of this warning.

If this were my own codebase, my preferences might be
(1) -Wno-class-memaccess globally, or
(2) #define _LIBCPP_MEMMOVE(x, y, n) std::memmove((void*)x, (const void*)y, n) and use that in the specific places where the GCC warning would come up; ditto presumably _LIBCPP_MEMCPY.
But (2) kinda sucks.

How about just doing what you're doing (cast to void*), but add a comment on the line above, like

if (__n > 0) {
    // Cast the arguments to silence GCC's -Wclass-memaccess
    std::memmove(static_cast<void*>(__result), static_cast<void const*>(__first), __n * sizeof(_Up));
}

libcxx/include/__iterator/size.h

44–51

I didn't notice this before. Isn't this just a "bug" on our and/or the standard's part? Shouldn't this be

template <class _Tp, size_t _Sz>
_LIBCPP_INLINE_VISIBILITY
constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return static_cast<ptrdiff_t>(_Sz); }

It is currently specified to take a ptrdiff_t _Sz parameter, but that's surprising, and if it causes compiler warnings, then we should just file an LWG issue to get it changed.
https://eel.is/c++draft/iterator.range#lib:ssize(T_(&array)%5bN%5d)
I'll send an email.

I think we should just preemptively change our _Sz's type to suppress the warning. I don't think the change is detectable by a conforming program.

[EricWF]

libcxx/utils/libcxx/test/params.py

122–128

No, warnings have not been disabled since forever. I was quite careful to not that that happen prior to my departure when COVID started.

Are we sure there's no existing Clang/GCC compiler option like -Weven-in-system-headers

You mean -Wsystem-headers?

[ldionne]

libcxx/utils/libcxx/test/params.py

122–128

Oooh, I wasn't aware of that flag. This is really neat, and in fact I think it does remove the need for _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER. I suggest:

1. I finish and ship this patch so that we have warnings enabled on all compilers, in all configurations.
2. I go back and investigate the removal of _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER, changing -I to -isystem in our test suite and adding -Wsystem-headers. That would be equivalent to what we have after (1) but simpler.

[• Quuxplusone]

libcxx/include/__iterator/size.h

44–51

It turns out it's not that simple. :(
I'm still hoping that we could do something like

template <class _Tp, size_t _Sz>
#ifndef _LIBCPP_HAS_NO_CONCEPTS
  requires (_Sz < numeric_limits<ptrdiff_t>::max())
#endif
_LIBCPP_INLINE_VISIBILITY
constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return _Sz; }

but the first step is to get a regression test (working on that in D121154).

libcxx/utils/libcxx/test/params.py

122–128

Oooh, I wasn't aware of that flag. This is really neat, and in fact I think it does remove the need for _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER.

Eric replied to only the first clause of my stream-of-consciousness, which continued: "... oh, bah, no, that's not what we want. We want to see errors from libc++ system headers only, but continue suppressing any errors from e.g. /usr/include/stdio.h. Yuck."

So sure, investigate the possibility, but I bet -Wsystem-headers isn't going to help us in practice.

[ldionne]

Fix CI and address a few comments.

I've decided to add some -Wno-foo when running with GCC in order to unblock this review ASAP.
The patch still improves the status quo from "no warnings whatsoever" to "all warnings except a few".

[philnik]

libcxx/include/barrier

126–129

Is this a drive-by or does any compiler complain here?

libcxx/utils/libcxx/test/params.py

26

Why are you disabling -Wshadow? I'm pretty certain this will regress very fast.

43

This doesn't look like it should be here. Why do we disable this warning?

[ldionne]

[forgot to submit some comments last time I updated the patch]

libcxx/include/__algorithm/copy.h

56 ↗

(On Diff #412808)

I'm actually going to defer solving this problem by adding -Wno-class-memaccess when running the tests with GCC, because I'd rather postpone making this decision than making the wrong call. We can investigate this warning separately without blocking this review.

This won't be a problem for users, since they should all be using -isystem anyway -- this is really just for us, and that's why I'd rather take the time to investigate this warning.

libcxx/include/__iterator/size.h

44–51

I'll keep the pragma as-is and I'll pick up D121154.

libcxx/include/barrier

126–129

This was a -Wshadow warning. I decided to turn it off because there were many benign instances of it.

libcxx/utils/libcxx/test/params.py

26

Because it results in a lot of not very useful warnings. I'll try enabling it again and give you more details.

43

Last I checked, it resulted in a *ton* of warnings because we often use typedefs in the test suite just to check that a type can be formed. Imagine for example typedef std::vector<int>::pointer Ptr just to confirm that std::vector<int>::pointer is well-formed.

[ldionne]

Address comments and re-enable -Wshadow

[ldionne]

Fix -Wshadow.

[ldionne]

This should finally be good to go. @philnik and/or @EricWF does this look OK to you?

[philnik]

I'm not perfectly happy with some of the new names, but I'm OK with them. I also don't have any better ideas for them currently.

[ldionne]

In D120684#3383749, @philnik wrote:

I'm not perfectly happy with some of the new names, but I'm OK with them. I also don't have any better ideas for them currently.

Yeah, that's the problem. -Wshadow creates the need to dance around quite a bit to get things to compile sometimes.

libcxx/include/__format/parser_std_format_spec.h

if (__r.__ptr == __end || *__r.__ptr != _CharT('}'))
     __throw_format_error("Invalid arg-id");
 
   ++__r.__ptr;
   return __r;
 }
 
 template <class _Context>
 _LIBCPP_HIDE_FROM_ABI constexpr uint32_t
-__substitute_arg_id(basic_format_arg<_Context> __arg) {
+__substitute_arg_id(basic_format_arg<_Context> _Arg) {
   return visit_format_arg(
       [](auto __arg) -> uint32_t {
         using _Type = decltype(__arg);
         if constexpr (integral<_Type>) {
           if constexpr (signed_integral<_Type>) {
             if (__arg < 0)
               __throw_format_error("A format-spec arg-id replacement shouldn't "
                                    "have a negative value");
           }
 
           using _CT = common_type_t<_Type, decltype(__format::__number_max)>;
           if (static_cast<_CT>(__arg) >
               static_cast<_CT>(__format::__number_max))
             __throw_format_error("A format-spec arg-id replacement exceeds "
                                  "the maximum supported value");
 
           return __arg;
         } else if constexpr (same_as<_Type, monostate>)
           __throw_format_error("Argument index out of bounds");
         else
           __throw_format_error("A format-spec arg-id replacement argument "
                                "isn't an integral type");
       },
-      __arg);
+      _Arg);
 }
 
 class _LIBCPP_TYPE_VIS __parser_width {
 public:
   /** Contains a width or an arg-id. */
   uint32_t __width : 31 {0};
   /** Determines whether the value stored is a width or an arg-id. */
   uint32_t __width_as_arg : 1 {0};

  * Converts a code point to the column width.
  *
  * The estimations are conforming to [format.string.general]/11
  *
  * This version expects a value less than 0x1'0000, which is a 3-byte UTF-8
  * character.
  */
 _LIBCPP_HIDE_FROM_ABI inline constexpr int __column_width_3(uint32_t __c) noexcept {
-  _LIBCPP_ASSERT(__c < 0x1'0000,
+  _LIBCPP_ASSERT(__c < 0x10000,
                  "Use __column_width_4 or __column_width for larger values");
 
   // clang-format off
   return 1 + (__c >= 0x1100 && (__c <= 0x115f ||
              (__c >= 0x2329 && (__c <= 0x232a ||
              (__c >= 0x2e80 && (__c <= 0x303e ||
              (__c >= 0x3040 && (__c <= 0xa4cf ||
              (__c >= 0xac00 && (__c <= 0xd7a3 ||
              (__c >= 0xf900 && (__c <= 0xfaff ||
              (__c >= 0xfe10 && (__c <= 0xfe19 ||
              (__c >= 0xfe30 && (__c <= 0xfe6f ||
              (__c >= 0xff00 && (__c <= 0xff60 ||
              (__c >= 0xffe0 && (__c <= 0xffe6
              ))))))))))))))))))));
   // clang-format on
 }
 
 /**
  * @overload
  *
  * This version expects a value greater than or equal to 0x1'0000, which is a
  * 4-byte UTF-8 character.
  */
 _LIBCPP_HIDE_FROM_ABI inline constexpr int __column_width_4(uint32_t __c) noexcept {
-  _LIBCPP_ASSERT(__c >= 0x1'0000,
+  _LIBCPP_ASSERT(__c >= 0x10000,
                  "Use __column_width_3 or __column_width for smaller values");
 
   // clang-format off
   return 1 + (__c >= 0x1'f300 && (__c <= 0x1'f64f ||
              (__c >= 0x1'f900 && (__c <= 0x1'f9ff ||
              (__c >= 0x2'0000 && (__c <= 0x2'fffd ||
              (__c >= 0x3'0000 && (__c <= 0x3'fffd
              ))))))));
   // clang-format on
 }
 
 /**
  * @overload
  *
  * The general case, accepting all values.
  */
 _LIBCPP_HIDE_FROM_ABI inline constexpr int __column_width(uint32_t __c) noexcept {
-  if (__c < 0x1'0000)
+  if (__c < 0x10000)
     return __column_width_3(__c);
 
   return __column_width_4(__c);
 }
 
 /**
  * Estimate the column width for the UTF-8 sequence using the fast algorithm.
  */
while (__first != __last) {
     if (__c >= 0xd800 && __c <= 0xDfff) {
       // Malformed Unicode.
       if (__last - __first < 2) [[unlikely]]
         return {__result + 1, __first + 1};
 
       __c -= 0xd800;
       __c <<= 10;
       __c += (*(__first + 1) - 0xdc00);
-      __c += 0x10'000;
+      __c += 0x10000;
 
       __result += __column_width_4(__c);
       if (__result > __maximum)
         return {__result - 2, __first};
       __first += 2;
     } else {
       __result += __column_width_3(__c);
       if (__result > __maximum)

libcxx/include/__iterator/size.h

 #if _LIBCPP_STD_VER > 17
 template <class _Cont>
 _LIBCPP_INLINE_VISIBILITY
 constexpr auto ssize(const _Cont& __c)
 _NOEXCEPT_(noexcept(static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size())))
 ->                              common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>
 { return            static_cast<common_type_t<ptrdiff_t, make_signed_t<decltype(__c.size())>>>(__c.size()); }
 
+// GCC complains about the implicit conversion from ptrdiff_t to size_t in
+// the array bound.
+_LIBCPP_DIAGNOSTIC_PUSH
+_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wsign-conversion")
 template <class _Tp, ptrdiff_t _Sz>
 _LIBCPP_INLINE_VISIBILITY
 constexpr ptrdiff_t ssize(const _Tp (&)[_Sz]) noexcept { return _Sz; }
+_LIBCPP_DIAGNOSTIC_POP
 #endif
 
 #endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ITERATOR_SIZE_H

libcxx/include/__random/linear_congruential_engine.h

private:
     result_type __x_;
 
     static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);
 
     static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters");
     static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters");
     static_assert(is_unsigned<_UIntType>::value, "_UIntType must be unsigned type");
 public:
-    static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u;
-    static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u;
+    static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u : 0u;
+    static _LIBCPP_CONSTEXPR const result_type _Max = __m - _UIntType(1u);
     static_assert(_Min < _Max,           "linear_congruential_engine invalid parameters");
 
     // engine characteristics
     static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
     static _LIBCPP_CONSTEXPR const result_type increment = __c;
     static _LIBCPP_CONSTEXPR const result_type modulus = __m;
     _LIBCPP_INLINE_VISIBILITY
     static _LIBCPP_CONSTEXPR result_type min() {return _Min;}

libcxx/include/any

 
 */
 
 #include <__availability>
 #include <__config>
 #include <__utility/forward.h>
 #include <__utility/in_place.h>
 #include <__utility/move.h>
+#include <__utility/unreachable.h>
 #include <cstdlib>
 #include <memory>
 #include <type_traits>
 #include <typeinfo>
 #include <version>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
static void* __handle(_Action __act, any const * __this, any * __other,
         case _Action::_Move:
           __move(const_cast<any &>(*__this), *__other);
           return nullptr;
         case _Action::_Get:
             return __get(const_cast<any &>(*__this), __info, __fallback_info);
         case _Action::_TypeInfo:
           return __type_info();
         }
+        __libcpp_unreachable();
     }
 
     template <class ..._Args>
     _LIBCPP_INLINE_VISIBILITY
     static _Tp& __create(any & __dest, _Args&&... __args) {
         typedef allocator<_Tp> _Alloc;
         typedef allocator_traits<_Alloc> _ATraits;
         _Alloc __a;
static void* __handle(_Action __act, any const * __this,
         case _Action::_Move:
           __move(const_cast<any &>(*__this), *__other);
           return nullptr;
         case _Action::_Get:
             return __get(const_cast<any &>(*__this), __info, __fallback_info);
         case _Action::_TypeInfo:
           return __type_info();
         }
+        __libcpp_unreachable();
     }
 
     template <class ..._Args>
     _LIBCPP_INLINE_VISIBILITY
     static _Tp& __create(any & __dest, _Args&&... __args) {
         typedef allocator<_Tp> _Alloc;
         typedef allocator_traits<_Alloc> _ATraits;
         typedef __allocator_destructor<_Alloc> _Dp;

libcxx/include/barrier

 bool __arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier,
                                      __barrier_phase_t __old_phase);
 
 _LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI
 void __destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier);
 
 template<class _CompletionF>
 class __barrier_base {
-    ptrdiff_t                                               __expected;
+    ptrdiff_t                                               __expected_;
     unique_ptr<__barrier_algorithm_base,
-               void (*)(__barrier_algorithm_base*)>         __base;
-    __atomic_base<ptrdiff_t>                                __expected_adjustment;
-    _CompletionF                                            __completion;
-    __atomic_base<__barrier_phase_t>                        __phase;
+               void (*)(__barrier_algorithm_base*)>         __base_;
+    __atomic_base<ptrdiff_t>                                __expected_adjustment_;
+    _CompletionF                                            __completion_;
+    __atomic_base<__barrier_phase_t>                        __phase_;
 
 public:
     using arrival_token = __barrier_phase_t;
 
     static constexpr ptrdiff_t max() noexcept {
         return numeric_limits<ptrdiff_t>::max();
     }
 
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
-            : __expected(__expected), __base(__construct_barrier_algorithm_base(this->__expected),
+            : __expected_(__expected), __base_(__construct_barrier_algorithm_base(this->__expected_),
                                                &__destroy_barrier_algorithm_base),
-              __expected_adjustment(0), __completion(std::move(__completion)), __phase(0)
+              __expected_adjustment_(0), __completion_(std::move(__completion)), __phase_(0)
     {
     }
     [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     arrival_token arrive(ptrdiff_t update)
     {
-        auto const __old_phase = __phase.load(memory_order_relaxed);
+        auto const __old_phase = __phase_.load(memory_order_relaxed);
         for(; update; --update)
-            if(__arrive_barrier_algorithm_base(__base.get(), __old_phase)) {
-                __completion();
-                __expected += __expected_adjustment.load(memory_order_relaxed);
-                __expected_adjustment.store(0, memory_order_relaxed);
-                __phase.store(__old_phase + 2, memory_order_release);
-                __phase.notify_all();
+            if(__arrive_barrier_algorithm_base(__base_.get(), __old_phase)) {
+                __completion_();
+                __expected_ += __expected_adjustment_.load(memory_order_relaxed);
+                __expected_adjustment_.store(0, memory_order_relaxed);
+                __phase_.store(__old_phase + 2, memory_order_release);
+                __phase_.notify_all();
             }
         return __old_phase;
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void wait(arrival_token&& __old_phase) const
     {
         auto const __test_fn = [this, __old_phase]() -> bool {
-            return __phase.load(memory_order_acquire) != __old_phase;
+            return __phase_.load(memory_order_acquire) != __old_phase;
         };
         __libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
     }
     _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void arrive_and_drop()
     {
-        __expected_adjustment.fetch_sub(1, memory_order_relaxed);
+        __expected_adjustment_.fetch_sub(1, memory_order_relaxed);
         (void)arrive(1);
     }
 };
 
 #else
 
 /*
 

libcxx/include/bitset

 }
 
 template <size_t _Size>
 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
 bitset<_Size>::to_string(_CharT __zero, _CharT __one) const
 {
     basic_string<_CharT, _Traits, _Allocator> __r(_Size, __zero);
-    for (size_t __i = 0; __i < _Size; ++__i)
+    for (size_t __i = 0; __i != _Size; ++__i)
     {
         if ((*this)[__i])
             __r[_Size - 1 - __i] = __one;
     }
     return __r;
 }
 
 template <size_t _Size>

libcxx/include/charconv

if (__neg)
         {
             __x = __complement(__x);
             std::memcpy(&__value, &__x, sizeof(__x));
             return __r;
         }
     }
     else
     {
-        if (__x <= __tl::max())
+        if (__x <= __to_unsigned_like(__tl::max()))
         {
             __value = __x;
             return __r;
         }
     }
 
     return {__r.ptr, errc::result_out_of_range};
 }
else
         return {'A' <= __c && __c < 'A' + __base - 10, __c - 'A' + 10};
 }
 
 template <typename _It, typename _Tp, typename _Fn, typename... _Ts>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __subject_seq_combinator(_It __first, _It __last, _Tp& __value, _Fn __f,
                          _Ts... __args)
 {
-    auto __find_non_zero = [](_It __first, _It __last) {
-        for (; __first != __last; ++__first)
-            if (*__first != '0')
+    auto __find_non_zero = [](_It __firstit, _It __lastit) {
+        for (; __firstit != __lastit; ++__firstit)
+            if (*__firstit != '0')
                 break;
-        return __first;
+        return __firstit;
     };
 
     auto __p = __find_non_zero(__first, __last);
     if (__p == __last || !__in_pattern(*__p, __args...))
     {
         if (__p == __first)
             return {__first, errc::invalid_argument};
         else

 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 __from_chars_atoi(const char* __first, const char* __last, _Tp& __value)
 {
     using __tx = __itoa::__traits<_Tp>;
     using __output_type = typename __tx::type;
 
     return __subject_seq_combinator(
         __first, __last, __value,
-        [](const char* __first, const char* __last,
-           _Tp& __value) -> from_chars_result {
+        [](const char* _First, const char* _Last,
+           _Tp& __val) -> from_chars_result {
             __output_type __a, __b;
-            auto __p = __tx::__read(__first, __last, __a, __b);
-            if (__p == __last || !__in_pattern(*__p))
+            auto __p = __tx::__read(_First, _Last, __a, __b);
+            if (__p == _Last || !__in_pattern(*__p))
             {
                 __output_type __m = numeric_limits<_Tp>::max();
                 if (__m >= __a && __m - __a >= __b)
                 {
-                    __value = __a + __b;
+                    __val = __a + __b;
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         });
 }
 
 template <typename _Tp, typename enable_if<is_signed<_Tp>::value, int>::type = 0>

 __from_chars_integral(const char* __first, const char* __last, _Tp& __value,
                       int __base)
 {
     if (__base == 10)
         return __from_chars_atoi(__first, __last, __value);
 
     return __subject_seq_combinator(
         __first, __last, __value,
-        [](const char* __p, const char* __lastx, _Tp& __value,
-           int __base) -> from_chars_result {
+        [](const char* __p, const char* __lastp, _Tp& __val,
+           int _Base) -> from_chars_result {
             using __tl = numeric_limits<_Tp>;
-            auto __digits = __tl::digits / log2f(float(__base));
-            _Tp __a = __in_pattern(*__p++, __base).__val, __b = 0;
+            auto __digits = __tl::digits / log2f(float(_Base));
+            _Tp __a = __in_pattern(*__p++, _Base).__val, __b = 0;
 
-            for (int __i = 1; __p != __lastx; ++__i, ++__p)
+            for (int __i = 1; __p != __lastp; ++__i, ++__p)
             {
-                if (auto __c = __in_pattern(*__p, __base))
+                if (auto __c = __in_pattern(*__p, _Base))
                 {
                     if (__i < __digits - 1)
-                        __a = __a * __base + __c.__val;
+                        __a = __a * _Base + __c.__val;
                     else
                     {
-                        if (!__itoa::__mul_overflowed(__a, __base, __a))
+                        if (!__itoa::__mul_overflowed(__a, _Base, __a))
                             ++__p;
                         __b = __c.__val;
                         break;
                     }
                 }
                 else
                     break;
             }
 
-            if (__p == __lastx || !__in_pattern(*__p, __base))
+            if (__p == __lastp || !__in_pattern(*__p, _Base))
             {
                 if (__tl::max() - __a >= __b)
                 {
-                    __value = __a + __b;
+                    __val = __a + __b;
                     return {__p, {}};
                 }
             }
             return {__p, errc::result_out_of_range};
         },
         __base);
 }
 

libcxx/include/experimental/simd

public:
   simd operator++(int);
   simd& operator--();
   simd operator--(int);
   mask_type operator!() const;
   simd operator~() const;
   simd operator+() const;
   simd operator-() const;
 
+#if 0
   // binary operators [simd.binary]
   friend simd operator+(const simd&, const simd&);
   friend simd operator-(const simd&, const simd&);
   friend simd operator*(const simd&, const simd&);
   friend simd operator/(const simd&, const simd&);
   friend simd operator%(const simd&, const simd&);
   friend simd operator&(const simd&, const simd&);
   friend simd operator|(const simd&, const simd&);
   friend simd operator^(const simd&, const simd&);
#if 0
 
   // compares [simd.comparison]
   friend mask_type operator==(const simd&, const simd&);
   friend mask_type operator!=(const simd&, const simd&);
   friend mask_type operator>=(const simd&, const simd&);
   friend mask_type operator<=(const simd&, const simd&);
   friend mask_type operator>(const simd&, const simd&);
   friend mask_type operator<(const simd&, const simd&);
+#endif
 };
 
 // [simd.mask.class]
 template <class _Tp, class _Abi>
 // TODO: implement simd_mask
 class simd_mask {
 public:
   using value_type = bool;
public:
 
   // scalar access [simd.mask.subscr]
   reference operator[](size_t);
   value_type operator[](size_t) const;
 
   // unary operators [simd.mask.unary]
   simd_mask operator!() const noexcept;
 
+#if 0
   // simd_mask binary operators [simd.mask.binary]
   friend simd_mask operator&&(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator||(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator&(const simd_mask&, const simd_mask&)noexcept;
   friend simd_mask operator|(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator^(const simd_mask&, const simd_mask&) noexcept;
 
   // simd_mask compound assignment [simd.mask.cassign]
   friend simd_mask& operator&=(simd_mask&, const simd_mask&) noexcept;
   friend simd_mask& operator|=(simd_mask&, const simd_mask&) noexcept;
   friend simd_mask& operator^=(simd_mask&, const simd_mask&) noexcept;
 
   // simd_mask compares [simd.mask.comparison]
   friend simd_mask operator==(const simd_mask&, const simd_mask&) noexcept;
   friend simd_mask operator!=(const simd_mask&, const simd_mask&) noexcept;
+#endif
 };
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD
 
 _LIBCPP_POP_MACROS
 
 #endif /* _LIBCPP_EXPERIMENTAL_SIMD */

libcxx/include/istream

#ifndef _LIBCPP_NO_EXCEPTIONS
         try
         {
 #endif
             basic_string<_CharT, _Traits> __str;
             const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
             size_t __c = 0;
             _CharT __zero = __ct.widen('0');
             _CharT __one = __ct.widen('1');
-            while (__c < _Size)
+            while (__c != _Size)
             {
                 typename _Traits::int_type __i = __is.rdbuf()->sgetc();
                 if (_Traits::eq_int_type(__i, _Traits::eof()))
                 {
                    __state |= ios_base::eofbit;
                    break;
                 }
                 _CharT __ch = _Traits::to_char_type(__i);

libcxx/include/latch

public:
     inline _LIBCPP_INLINE_VISIBILITY
     bool try_wait() const noexcept
     {
         return 0 == __a.load(memory_order_acquire);
     }
     inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void wait() const
     {
-        auto const __test_fn = [=]() -> bool {
+        __cxx_atomic_wait(&__a.__a_, [&]() -> bool {
             return try_wait();
-        };
-        __cxx_atomic_wait(&__a.__a_, __test_fn);
+        });
     }
     inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INLINE_VISIBILITY
     void arrive_and_wait(ptrdiff_t __update = 1)
     {
         count_down(__update);
         wait();
     }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
 #endif //_LIBCPP_LATCH

libcxx/include/regex

 // __r_anchor
 
 template <class _CharT>
 class __r_anchor_multiline
     : public __owns_one_state<_CharT>
 {
     typedef __owns_one_state<_CharT> base;
 
-    bool __multiline;
+    bool __multiline_;
 
 public:
     typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __r_anchor_multiline(bool __multiline, __node<_CharT>* __s)
-        : base(__s), __multiline(__multiline) {}
+        : base(__s), __multiline_(__multiline) {}
 
     virtual void __exec(__state&) const;
 };
 
 template <class _CharT>
 void
 __r_anchor_multiline<_CharT>::__exec(__state& __s) const
 {
     if (__s.__current_ == __s.__last_ &&
         !(__s.__flags_ & regex_constants::match_not_eol))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
-    else if (__multiline && __is_eol(*__s.__current_))
+    else if (__multiline_ && __is_eol(*__s.__current_))
     {
         __s.__do_ = __state::__accept_but_not_consume;
         __s.__node_ = this->first();
     }
     else
     {
         __s.__do_ = __state::__reject;
         __s.__node_ = nullptr;

libcxx/include/string

 
 // assign
 
 template <class _CharT, class _Traits, class _Allocator>
 template <bool __is_short>
 basic_string<_CharT, _Traits, _Allocator>&
 basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(
     const value_type* __s, size_type __n) {
-  size_type __cap = __is_short ? __min_cap : __get_long_cap();
+  size_type __cap = __is_short ? static_cast<size_type>(__min_cap) : __get_long_cap();
   if (__n < __cap) {
     pointer __p = __is_short ? __get_short_pointer() : __get_long_pointer();
     __is_short ? __set_short_size(__n) : __set_long_size(__n);
     traits_type::copy(_VSTD::__to_address(__p), __s, __n);
     traits_type::assign(__p[__n], value_type());
     __invalidate_iterators_past(__n);
   } else {
     size_type __sz = __is_short ? __get_short_size() : __get_long_size();

libcxx/include/tuple

 template <class ..._Types, size_t ..._I0, size_t ..._J0>
 struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
 {
     template <class _Tuple0>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
     operator()(tuple<_Types...> __t, _Tuple0&& __t0)
     {
+        (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
         return _VSTD::forward_as_tuple(
             _VSTD::forward<_Types>(_VSTD::get<_I0>(__t))...,
             _VSTD::get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
     }
 
     template <class _Tuple0, class _Tuple1, class ..._Tuples>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX11
     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
     operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
     {
+        (void)__t; // avoid unused parameter warning on GCC when _I0 is empty
         typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple0>::type _T0;
         typedef _LIBCPP_NODEBUG typename remove_reference<_Tuple1>::type _T1;
         return __tuple_cat<
             tuple<_Types...,
                   typename __apply_cv<_Tuple0, typename tuple_element<
                                                    _J0, _T0>::type>::type&&...>,
             typename __make_tuple_indices<sizeof...(_Types) +
                                           tuple_size<_T0>::value>::type,

libcxx/include/variant

 #undef _LIBCPP_VARIANT_COPY_ASSIGNMENT
 
 template <class... _Types>
 class _LIBCPP_TEMPLATE_VIS __impl
     : public __copy_assignment<__traits<_Types...>> {
   using __base_type = __copy_assignment<__traits<_Types...>>;
 
 public:
-  using __base_type::__base_type;
-  using __base_type::operator=;
+  using __base_type::__base_type; // get in_place_index_t constructor & friends
+  __impl(__impl const&) = default;
+  __impl(__impl&&) = default;
+  __impl& operator=(__impl const&) = default;
+  __impl& operator=(__impl&&) = default;
 
   template <size_t _Ip, class _Arg>
   inline _LIBCPP_INLINE_VISIBILITY
   void __assign(_Arg&& __arg) {
     this->__assign_alt(__access::__base::__get_alt<_Ip>(*this),
                        _VSTD::forward<_Arg>(__arg));
   }
 

libcxx/include/vector

void __throw_out_of_range() const {
         _VSTD::__throw_out_of_range("vector");
     }
 
     _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
     void __vallocate(size_type __n);
     void __vdeallocate() _NOEXCEPT;
     _LIBCPP_INLINE_VISIBILITY
     static size_type __align_it(size_type __new_size) _NOEXCEPT
-        {return __new_size + (__bits_per_word-1) & ~((size_type)__bits_per_word-1);}
+        {return (__new_size + (__bits_per_word-1)) & ~((size_type)__bits_per_word-1);}
     _LIBCPP_INLINE_VISIBILITY  size_type __recommend(size_type __new_size) const;
     _LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, bool __x);
     template <class _ForwardIterator>
         typename enable_if
         <
             __is_cpp17_forward_iterator<_ForwardIterator>::value,
             void
         >::type

libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.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
 
+// We voluntarily use std::default_initializable on types that have redundant
+// or ignored cv-qualifiers -- don't warn about it.
+// ADDITIONAL_COMPILE_FLAGS: -Wno-ignored-qualifiers
+
 // template<class T>
 //     concept default_initializable = constructible_from<T> &&
 //     requires { T{}; } &&
 //     is-default-initializable<T>;
 
 #include <array>
 #include <concepts>
 #include <deque>

libcxx/test/std/concepts/concepts.object/movable.compile.pass.cpp

 static_assert(std::movable<int (S::*)() const volatile && noexcept>);
 
 static_assert(std::movable<std::deque<int> >);
 static_assert(std::movable<std::forward_list<int> >);
 static_assert(std::movable<std::list<int> >);
 static_assert(std::movable<std::optional<std::vector<int> > >);
 static_assert(std::movable<std::vector<int> >);
 
-static_assert(std::movable<traditional_copy_assignment_only>);
 static_assert(std::movable<has_volatile_member>);
 static_assert(std::movable<has_array_member>);
 
 // Not objects
 static_assert(!std::movable<int&>);
 static_assert(!std::movable<int const&>);
 static_assert(!std::movable<int volatile&>);
 static_assert(!std::movable<int const volatile&>);

 
 static_assert(std::movable<cpp03_friendly>);
 static_assert(std::movable<const_move_ctor>);
 static_assert(std::movable<volatile_move_ctor>);
 static_assert(std::movable<cv_move_ctor>);
 static_assert(std::movable<multi_param_move_ctor>);
 static_assert(!std::movable<not_quite_multi_param_move_ctor>);
 
-static_assert(!std::assignable_from<copy_assign_with_mutable_parameter&,
-                                    copy_assign_with_mutable_parameter>);
-static_assert(!std::movable<copy_assign_with_mutable_parameter>);
+static_assert(!std::assignable_from<copy_with_mutable_parameter&,
+                                    copy_with_mutable_parameter>);
+static_assert(!std::movable<copy_with_mutable_parameter>);
 
 static_assert(!std::movable<const_move_assignment>);
 static_assert(std::movable<volatile_move_assignment>);
 static_assert(!std::movable<cv_move_assignment>);
 
 static_assert(!std::movable<const_move_assign_and_traditional_move_assign>);
 static_assert(!std::movable<volatile_move_assign_and_traditional_move_assign>);
 static_assert(!std::movable<cv_move_assign_and_traditional_move_assign>);

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/construct_at.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
 
-// Investigation needed
-// XFAIL: gcc
-
 // <memory>
 
 // template <class T, class ...Args>
 // constexpr T* construct_at(T* location, Args&& ...args);
 
 #include <memory>
 #include <cassert>
 #include <utility>
 
 #include "test_iterators.h"
 
 struct Foo {
-    int a;
-    char b;
-    double c;
     constexpr Foo() { }
-    constexpr Foo(int a, char b, double c) : a(a), b(b), c(c) { }
+    constexpr Foo(int a, char b, double c) : a_(a), b_(b), c_(c) { }
     constexpr Foo(int a, char b, double c, int* count) : Foo(a, b, c) { *count += 1; }
     constexpr bool operator==(Foo const& other) const {
-        return a == other.a && b == other.b && c == other.c;
+        return a_ == other.a_ && b_ == other.b_ && c_ == other.c_;
     }
+
+private:
+    int a_;
+    char b_;
+    double c_;
 };
 
 struct Counted {
     int& count_;
     constexpr Counted(int& count) : count_(count) { ++count; }
     constexpr Counted(Counted const& that) : count_(that.count_) { ++count_; }
     constexpr ~Counted() { --count_; }
 };

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/const_pair.pass.cpp

 
 #include <cassert>
 #include <memory>
 #include <tuple>
 #include <type_traits>
 #include <utility>
 
 struct NothrowCopyAssignable {
+    NothrowCopyAssignable(NothrowCopyAssignable const&) = delete;
     NothrowCopyAssignable& operator=(NothrowCopyAssignable const&) noexcept { return *this; }
 };
 struct PotentiallyThrowingCopyAssignable {
+    PotentiallyThrowingCopyAssignable(PotentiallyThrowingCopyAssignable const&) = delete;
     PotentiallyThrowingCopyAssignable& operator=(PotentiallyThrowingCopyAssignable const&) { return *this; }
 };
 
 #include "test_macros.h"
 
 TEST_CONSTEXPR_CXX20
 bool test()
 {

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.assign/convert_copy.pass.cpp

 };
 
 struct NonAssignable {
     NonAssignable& operator=(NonAssignable const&) = delete;
     NonAssignable& operator=(NonAssignable&&) = delete;
 };
 
 struct NothrowCopyAssignable {
+    NothrowCopyAssignable(NothrowCopyAssignable const&) = delete;
     NothrowCopyAssignable& operator=(NothrowCopyAssignable const&) noexcept { return *this; }
 };
 
 struct PotentiallyThrowingCopyAssignable {
+    PotentiallyThrowingCopyAssignable(PotentiallyThrowingCopyAssignable const&) = delete;
     PotentiallyThrowingCopyAssignable& operator=(PotentiallyThrowingCopyAssignable const&) { return *this; }
 };
 
 TEST_CONSTEXPR_CXX20
 bool test()
 {
     {
         typedef std::tuple<long> T0;

libcxx/test/std/utilities/variant/variant.variant/variant.assign/T.pass.cpp

#endif
     assert(std::get<0>(v) == "bar");
   }
   {
     std::variant<bool, std::unique_ptr<int>> v;
     v = nullptr;
     assert(v.index() == 1);
     assert(std::get<1>(v) == nullptr);
   }
-  {
-    std::variant<bool volatile, int> v = 42;
-    v = false;
-    assert(v.index() == 0);
-    assert(!std::get<0>(v));
-    bool lvt = true;
-    v = lvt;
-    assert(v.index() == 0);
-    assert(std::get<0>(v));
-  }
 #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
   {
     using V = std::variant<int &, int &&, long>;
     int x = 42;
     V v(43l);
     v = x;
     assert(v.index() == 0);
     assert(&std::get<0>(v) == &x);

libcxx/test/support/type_classification/movable.h

struct multi_param_move_ctor {
   multi_param_move_ctor& operator=(multi_param_move_ctor&&);
 };
 
 struct not_quite_multi_param_move_ctor {
   not_quite_multi_param_move_ctor(not_quite_multi_param_move_ctor&&, int);
   not_quite_multi_param_move_ctor& operator=(not_quite_multi_param_move_ctor&&);
 };
 
-struct traditional_copy_assignment_only {
-  traditional_copy_assignment_only&
-  operator=(traditional_copy_assignment_only const&);
-};
-
-struct copy_assign_with_mutable_parameter {
-  copy_assign_with_mutable_parameter&
-  operator=(copy_assign_with_mutable_parameter&);
+struct copy_with_mutable_parameter {
+  copy_with_mutable_parameter(copy_with_mutable_parameter&);
+  copy_with_mutable_parameter&
+  operator=(copy_with_mutable_parameter&);
 };
 
 struct const_move_assignment {
   const_move_assignment& operator=(const_move_assignment&&) const;
 };
 
 struct volatile_move_assignment {
   const_move_assignment& operator=(const_move_assignment&&) volatile;

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
   Feature(name='has-clang-tidy',
           when=_hasSuitableClangTidy),
 
   Feature(name='apple-clang',                                                                                                      when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}'.format(**compilerMacros(cfg)),                                          when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}.{__clang_minor__}'.format(**compilerMacros(cfg)),                        when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}.{__clang_minor__}.{__clang_patchlevel__}'.format(**compilerMacros(cfg)), when=_isAppleClang),
 
-  Feature(name='clang',                                                                                                            when=_isClang,
-          actions=[AddCompileFlag('-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER')]),
+  Feature(name='clang',                                                                                                            when=_isClang),
   Feature(name=lambda cfg: 'clang-{__clang_major__}'.format(**compilerMacros(cfg)),                                                when=_isClang),
   Feature(name=lambda cfg: 'clang-{__clang_major__}.{__clang_minor__}'.format(**compilerMacros(cfg)),                              when=_isClang),
   Feature(name=lambda cfg: 'clang-{__clang_major__}.{__clang_minor__}.{__clang_patchlevel__}'.format(**compilerMacros(cfg)),       when=_isClang),
 
-  Feature(name='gcc',                                                                                                              when=_isGCC),
+  # Note: Due to a GCC bug (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104760), we must disable deprecation warnings
+  #       on GCC or spurious diagnostics are issued.
+  #
+  # TODO:
+  # - Enable -Wplacement-new with GCC.
+  # - Enable -Wclass-memaccess with GCC.
+  Feature(name='gcc',                                                                                                              when=_isGCC,
+          actions=[AddCompileFlag('-D_LIBCPP_DISABLE_DEPRECATION_WARNINGS'),
+                   AddCompileFlag('-Wno-placement-new'),
+                   AddCompileFlag('-Wno-class-memaccess')]),
   Feature(name=lambda cfg: 'gcc-{__GNUC__}'.format(**compilerMacros(cfg)),                                                         when=_isGCC),
   Feature(name=lambda cfg: 'gcc-{__GNUC__}.{__GNUC_MINOR__}'.format(**compilerMacros(cfg)),                                        when=_isGCC),
   Feature(name=lambda cfg: 'gcc-{__GNUC__}.{__GNUC_MINOR__}.{__GNUC_PATCHLEVEL__}'.format(**compilerMacros(cfg)),                  when=_isGCC),
 
   Feature(name='msvc',                                                                                                             when=_isMSVC),
   Feature(name=lambda cfg: 'msvc-{}'.format(*_msvcVersion(cfg)),                                                                   when=_isMSVC),
   Feature(name=lambda cfg: 'msvc-{}.{}'.format(*_msvcVersion(cfg)),                                                                when=_isMSVC),
 ]

libcxx/utils/libcxx/test/params.py

_warningFlags = [
   '-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-aligned-allocation-unavailable',
   '-Wno-atomic-alignment',
 
   # GCC warns about places where we might want to add sized allocation/deallocation
   # functions, but we know better what we're doing/testing in the test suite.
   '-Wno-sized-deallocation',
 
+  # Turn off warnings about user-defined literals with reserved suffixes. Those are
+  # just noise since we are testing the Standard Library itself.
+  '-Wno-literal-suffix', # GCC
+  '-Wno-user-defined-literals', # Clang
+
   # These warnings should be enabled in order to support the MSVC
   # team using the test suite; They enable the warnings below and
   # expect the test suite to be clean.
   '-Wsign-compare',
   '-Wunused-variable',
   '-Wunused-parameter',
   '-Wunreachable-code',
   '-Wno-unused-local-typedef',
 ]
 
 _allStandards = ['c++03', 'c++11', 'c++14', 'c++17', 'c++20', 'c++2b']
 def getStdFlag(cfg, std):
   fallbacks = {
     'c++11': 'c++0x',
     'c++14': 'c++1y',
     'c++17': 'c++1z',
Parameter(name='stdlib', choices=['llvm-libc++', 'apple-libc++', 'libstdc++', 'msvc'], type=str, default='llvm-libc++',
                 """,
             actions=lambda stdlib: filter(None, [
               AddFeature('stdlib={}'.format(stdlib)),
               # Also add an umbrella feature 'stdlib=libc++' for all flavors of libc++, to simplify
               # the test suite.
               AddFeature('stdlib=libc++') if re.match('.+-libc\+\+', stdlib) else None
             ])),
 
   Parameter(name='enable_warnings', choices=[True, False], type=bool, default=True,
             help="Whether to enable warnings when compiling the test suite.",
-            actions=lambda warnings: [] if not warnings else [
-              AddOptionalWarningFlag(w) for w in _warningFlags
-            ]),
+            actions=lambda warnings: [] if not warnings else
+              [AddOptionalWarningFlag(w) for w in _warningFlags] +
+              [AddCompileFlag('-D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER')]
+            ),
 
   Parameter(name='debug_level', choices=['', '0', '1'], type=str, default='',
             help="The debugging level to enable in the test suite.",
             actions=lambda debugLevel: [] if debugLevel == '' else filter(None, [
               AddFeature('debug_level={}'.format(debugLevel)),
               AddCompileFlag('-Wno-macro-redefined'),
               AddCompileFlag('-D_LIBCPP_DEBUG={}'.format(debugLevel)),
               AddFeature('LIBCXX-DEBUG-FIXME') if debugLevel == '1' else None
             ])),