[libc++] Build and test with -Wundef warning. NFC.

[curdeius]

Summary

This will avoid typos like _LIBCPP_STD_VERS (<future>) or using #if TEST_STD_VER > 17 without including "test_macros.h".

[curdeius]

libcxx/include/future

504

This was already dead code, so just commented it out in this patch.
I'll create another patch to fix this if that's wanted. However, the future_error(error_code __ec); gets called with arguments of type future_errc, so adding future_error(future_errc) ctor as future_error(future_errc _Ev) : future_error(make_error_code(_Ev) {} will not add anything.
We might however want to do something more standard conformant (mind that future(error_code) ctor is "exposition only").

[curdeius]

libcxx/CMakeLists.txt

580

Maybe that's not the best place to put this flag... Should I put it twice for clang (line 586+), and gcc (line 611+)?

[• Quuxplusone]

LGTM mod nits.
It's unfortunate that we can't build the entire library with -Wundef — or rather, if we did, we'd have to go through and replace a ton of X > Y with defined(X) && X > Y, and I don't think it'd end up being worth it. This PR shows that -Wundef does catch real bugs, though!

libcxx/CMakeLists.txt

580

It looks to me as if you should put it in the big list of "if supported" flags on lines 582–584, alongside -Wwrite-strings and -Wextra-semi.

libcxx/include/future

504

I recommend just deleting lines 504–506. That clearly preserves the existing behavior (which is not buggy AFAWCT, right?). If the existing behavior is buggy, then you should add a test that detects the bug.
I would not check in commented-out code.

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp

29–30

I recommend just omitting the TEST_STD_VER check entirely, and/or omitting the entire lines 28–30. As D99309 shows, <algorithm> is already guaranteed to include <initializer_list>; we don't have to re-include it if re-including it complicates the code (which it seems it does).

[curdeius]

• Apply review comments.
• Fix macOS build.

[curdeius]

@Quuxplusone, this change broke mac build (it defines _LIBCPP_COMPILER_CLANG but doesn't define _LIBCPP_CLANG_VER) and to fix it I've uglified what you did in D98720.
If you have a better idea, I'm all ears.

BTW, this change finds less real bugs *now* than it could, because I've fixed some tests that used TEST_STD_VER but were missing includes of "test_macros.h" a week or two ago.

[curdeius]

libcxx/include/future

504

The existing behaviour is correct but not very strict (it accepts what standard prescribes, but also more).
Precisely:

• the ctor is not explicit
• the ctor accepts not only future_errc (which is indirect through error_code), but also error_code

That's seems acceptable though (because changing that will break some code depending on this).
Anyway, it's out of scope of this patch IMO.

[• Quuxplusone]

libcxx/include/type_traits

840

These are pretty icky. I would tentatively suggest at least breaking the line as

#if __has_keyword(__is_pointer) &&                                             \
    !(defined(_LIBCPP_COMPILER_CLANG) &&                                       \
      defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1100)

but I'd also want to wait and see if anyone has a better idea (e.g. pulling out a _LIBCPP_CLANG_VER_LESS_THAN(x) macro or something).

[ldionne]

Requesting changes because of the _LIBCPP_COMPILER_CLANG comment, but this LGTM overall.

libcxx/include/future

504

I'd welcome a patch that makes the constructors strictly standard conforming. Agreed this belongs to a different patch though.

libcxx/include/type_traits

840

I think this is equivalent:

!(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1100)

In other words, I think checking for _LIBCPP_COMPILER_CLANG is redundant if you already check for _LIBCPP_CLANG_VER unless I'm mistaken.

[• Quuxplusone]

libcxx/include/type_traits

840

@ldionne: Sadly no; see D98720. Apple Clang defines _LIBCPP_COMPILER_CLANG without _LIBCPP_CLANG_VER (because their version numbers are all screwed up), and so we need to treat Apple Clang essentially as "Clang version 0.0" for the purposes of these feature tests.

Actually, is there any appetite to just #define _LIBCPP_CLANG_VER 0 on Apple Clang?

Double actually, @curdeius, isn't this change wrong? It should be

#if __has_keyword(__is_pointer) &&                                             \
    !(defined(_LIBCPP_COMPILER_CLANG) &&                                       \
      (!defined(_LIBCPP_CLANG_VER) || _LIBCPP_CLANG_VER < 1100))

So I am now more confident in my suggestion that we need either _LIBCPP_CLANG_VER_LESS_THAN or simply to define _LIBCPP_CLANG_VER as 0 on Apple Clang.

[curdeius]

• Define _LIBCPP_CLANG_VER=0 for AppleClang. Fix \#if conditions.

libcxx/include/type_traits

840

Indeed, that was too-quick-a-change from my part.
So, now I #define _LIBCPP_CLANG_VER 0 on AppleClang. It seems to be cleaner this way. It preserves the current behaviour as well.

[curdeius]

• Fix _LIBCPP_CLANG_VER check (and macOS build).

[curdeius]

libcxx/include/__config

513–514

I know, that's ugly...
Should I use __clang__ / __clang_major directly (not sure how it's defined on AppleClang though?

Or, is mapping AppleClang version to clang version somehow possible, @ldionne?

[ldionne]

libcxx/include/__config

187

I fear this will have the consequence to disable any feature guarded by #if _LIBCPP_CLANG_VER > XXXX on AppleClang, even if the compiler is perfectly able to handle that feature.

Edit: I looked and this doesn't seem to be an issue, but I would still suggest the following:

#if defined(__clang__) && !defined(__apple_build_version__)
#  define _LIBCPP_COMPILER_CLANG_BASED
#  define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
#elif defined(__apple_build_version__)
#  define _LIBCPP_COMPILER_CLANG_BASED
#  define _LIBCPP_APPLE_CLANG_VER (__clang_major__ * 100) + __clang_minor__
#elif ...

Notice the rename of _LIBCPP_COMPILER_CLANG to _LIBCPP_COMPILER_CLANG_BASED. In the few places where we currently use _LIBCPP_COMPILER_CLANG, it seems like what we really want to ask is whether the compiler is Clang-like and supports Clang-like features, which is the case on both LLVM Clang and Apple Clang.

Introducing a different macro _LIBCPP_APPLE_CLANG_VER also makes it clear that we consider it a different compiler.

[ldionne]

libcxx/include/__config

513–514

Or, is mapping AppleClang version to clang version somehow possible, @ldionne?

Not really. Since we fork at roughly arbitrary points in time, we would often fall between two official Clang releases and the mapping wouldn't be accurate.

[curdeius]

libcxx/include/__config

187

Should we really # define _LIBCPP_APPLE_CLANG_VER (__clang_major__ * 100) + __clang_minor__?

Does __clang_minor__ includes the patch number in "10.0.1"?
In the cases where this version is taken into account, we look at the patch number as well (checking __apple_build_version__ directly). E.g.:

// Literal operators ""d and ""y are supported starting with LLVM Clang 8 and AppleClang 10.0.1
#if (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 800) ||                 \
    (defined(__apple_build_version__) && __apple_build_version__ < 10010000)
#define _LIBCPP_HAS_NO_CXX20_CHRONO_LITERALS
#endif

Shouldn't it be something like: # define _LIBCPP_APPLE_CLANG_VER (__apple_build_version__ / 10000)? I.e. just removing 4 trailing zeroes (e.g. 10010000 -> 1001).

Note: I have no access to apple clang.

libcxx/include/future

504

D99567.

[curdeius]

• Define _LIBCPP_APPLE_CLANG_VER.

[ldionne]

So with the proposed changes, we'd have:

_LIBCPP_COMPILER_CLANG_BASED // defined whenever the compiler is based on Clang, i.e. LLVM Clang or Apple Clang (but there could be others). This is used to check for general capabilities available on Clang-based compilers like a few extensions or attributes.
_LIBCPP_CLANG_VER // defined to the version of LLVM Clang if the compiler is LLVM Clang, undefined otherwise
_LIBCPP_APPLE_CLANG_VER // defined to the version of Apple Clang if the compiler is Apple Clang, undefined otherwise

I think this makes sense. @curdeius @Quuxplusone I'm curious to hear if you think that makes sense too, but if so let's move forward with that. Perhaps you could also add a comment where _LIBCPP_COMPILER_CLANG_BASED is first defined to explain what I wrote above?

libcxx/include/__config

187

My definition of _LIBCPP_APPLE_CLANG_VER was indeed buggy. I agree with _LIBCPP_APPLE_CLANG_VER == (__apple_build_version__ / 10000). This way, for example AppleClang 12.0.5 would give __apple_build_version__ == 12050019, so _LIBCPP_APPLE_CLANG_VER == 1205, which is quite natural.

[• Quuxplusone]

libcxx/include/__config

195

@ldionne wrote:

_LIBCPP_COMPILER_CLANG_BASED // defined whenever the compiler is based on Clang, i.e. LLVM Clang or Apple Clang (but there could be others). This is used to check for general capabilities available on Clang-based compilers like a few extensions or attributes.
_LIBCPP_CLANG_VER // defined to the version of LLVM Clang if the compiler is LLVM Clang, undefined otherwise
_LIBCPP_APPLE_CLANG_VER // defined to the version of Apple Clang if the compiler is Apple Clang, undefined otherwise

I think this fits in well with the existing style, but I'm a little worried about how it plays with this patch specifically. Combined with -Wundef, this will lead to pretty complicated conditions. Like, let's say we wanted to enable __is_fundamental on Clang 10+ and Apple Clang 12.5+:

#if __has_keyword(__is_fundamental) &&                                         \
    !(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1000) &&               \
    !(defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER < 1205) &&   \
    !defined(_LIBCPP_CXX03_LANG)

Or let's say we wanted to enable __is_fundamental on Clang 10+ and never on Apple Clang (which is the current state of the art, because we don't know the Apple Clang version that made this work):

#if __has_keyword(__is_fundamental) &&                                         \
    !(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1000) &&               \
    !defined(_LIBCPP_APPLE_CLANG_VER) &&                                       \
    !defined(_LIBCPP_CXX03_LANG)

This isn't too bad, I guess; but it's complicated enough that we should audit the final version of this PR very carefully to make sure none of the existing conditions broke or changed behavior accidentally.

[curdeius]

Change definition of _LIBCPP_APPLE_CLANG_VER.

[curdeius]

Fix patch.

[curdeius]

libcxx/include/__config

195

There's one place only where I used _LIBCPP_APPLE_CLANG_VER instead of __apple_build_version__, line 513.
It should be pretty straightforward.

[ldionne]

libcxx/include/__config

195

If we disregard the need to make -Wundef work, we get:

#if __has_keyword(__is_fundamental) &&                                         \
    !(_LIBCPP_CLANG_VER < 1000) &&               \
    !(_LIBCPP_APPLE_CLANG_VER < 1205) &&                                       \
    !defined(_LIBCPP_CXX03_LANG)

I think that's really straightforward, so I think that design is good. I agree it doesn't play nicely with -Wundef though, as it adds a bunch of syntactic noise. In fact, I do think that -Wundef is just generally noisy.

One option (which you suggested before) would be to define macros like _LIBCPP_CLANG_VER_LESSTHAN(xxx) that is considered false if _LIBCPP_CLANG_VER isn't defined. We'd have to do it for each compiler we support, though (so we'd also have _LIBCPP_APPLE_CLANG_VER_LESSTHAN and _LIBCPP_GCC_VER_LESSTHAN, etc.).

[• Quuxplusone]

libcxx/include/__config

195

If we disregard the need to make -Wundef work ... I think that design is good. I agree it doesn't play nicely with -Wundef though ...

We're on the same page. I think this design is good except in how it interacts with -Wundef. But recall that the original point of this PR is to enable -Wundef! So. :)

It now occurs to me that it might be even better to split "Clang" and "Apple Clang" as utterly as we split "Clang" and "GCC". So we'd have

_LIBCPP_COMPILER_CLANG_BASED // defined whenever the compiler is LLVM Clang or Apple Clang or maybe others
_LIBCPP_COMPILER_CLANG // defined whenever the compiler is LLVM Clang
_LIBCPP_CLANG_VER // defined to the version of LLVM Clang if the compiler is LLVM Clang, undefined otherwise
_LIBCPP_COMPILER_APPLE_CLANG // defined whenever the compiler is Apple Clang
_LIBCPP_APPLE_CLANG_VER // defined to the version of Apple Clang if the compiler is Apple Clang, undefined otherwise

So then my two examples would look like

#if __has_keyword(__is_fundamental) &&                                             \
    !(defined(_LIBCPP_COMPILER_CLANG) && _LIBCPP_CLANG_VER < 1000) &&              \
    !(defined(_LIBCPP_COMPILER_APPLE_CLANG) && _LIBCPP_APPLE_CLANG_VER < 1205) &&  \
    !defined(_LIBCPP_CXX03_LANG)

and

#if __has_keyword(__is_fundamental) &&                                         \
    !(defined(_LIBCPP_COMPILER_CLANG) && _LIBCPP_CLANG_VER < 1000) &&          \
    !defined(_LIBCPP_COMPILER_APPLE_CLANG) &&                                  \
    !defined(_LIBCPP_CXX03_LANG)

and I think we'd probably find little use for _LIBCPP_COMPILER_CLANG_BASED.

[ldionne]

LGTM with my fixes (assuming they fix the macOS CI, which they should unless I messed up somewhere).

libcxx/include/type_traits

837–840

AppleClang 12.0.5 should contain commit b25ec4580. See comment below for more info on why this is needed.

1458–1461

We now need to handle AppleClang as well, otherwise we'll be using the intrinsic even on (slightly older) versions of AppleClang where it's broken.

Note that we need to start handling AppleClang "specially" here because we were using _LIBCPP_COMPILER_CLANG, and the proper translation of that is _LIBCPP_COMPILER_CLANG_BASED, not _LIBCPP_CLANG_VER. Previously AppleClang was kept off of this #if by means of _LIBCPP_CLANG_VER < 1300 being considered true.

I checked and we don't need this sort of fix in the other similar places where we have workarounds for Clang 10, not because we don't have this bug, but because the versions of AppleClang that would be impacted are not going to be supported for building libc++ for much longer.

[curdeius]

• Fix mac build.

[ldionne]

Thanks, ship it!

libcxx/CMakeLists.txt

 # Warning flags ===============================================================
 function(cxx_add_warning_flags target)
   target_compile_definitions(${target} PUBLIC -D_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
   if (MSVC)
     # -W4 is the cl.exe/clang-cl equivalent of -Wall. (In cl.exe and clang-cl,
     # -Wall is equivalent to -Weverything in GCC style compiler drivers.)
     target_add_compile_flags_if_supported(${target} PRIVATE -W4)
   else()
     target_add_compile_flags_if_supported(${target} PRIVATE -Wall)
   endif()
   target_add_compile_flags_if_supported(${target} PRIVATE -Wextra -W -Wwrite-strings
                                                           -Wno-unused-parameter -Wno-long-long
-                                                          -Werror=return-type -Wextra-semi)
+                                                          -Werror=return-type -Wextra-semi -Wundef)
   if ("${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
     target_add_compile_flags_if_supported(${target} PRIVATE
       -Wno-user-defined-literals
       -Wno-covered-switch-default
       -Wno-suggest-override
       -Wno-ignored-attributes # FIXME: Caused by _LIBCPP_NODEBUG_TYPE not being supported on older clangs
     )
     if (LIBCXX_TARGETING_CLANG_CL)

libcxx/include/__config

 #define __has_keyword(__x) !(__is_identifier(__x))
 
 #ifndef __has_include
 #define __has_include(...) 0
 #endif
 
 #if defined(__clang__)
 #  define _LIBCPP_COMPILER_CLANG
-#  ifndef __apple_build_version__
+#  ifdef __apple_build_version__
+#    define _LIBCPP_CLANG_VER 0
+#  else
 #    define _LIBCPP_CLANG_VER (__clang_major__ * 100 + __clang_minor__)
 #  endif
 #elif defined(__GNUC__)
 #  define _LIBCPP_COMPILER_GCC
 #elif defined(_MSC_VER)
 #  define _LIBCPP_COMPILER_MSVC
 #elif defined(__IBMCPP__)
 #  define _LIBCPP_COMPILER_IBM
 #endif
 
 #if defined(_LIBCPP_COMPILER_GCC) && __cplusplus < 201103L
 #error "libc++ does not support using GCC with C++03. Please enable C++11"
 #endif
 
 // FIXME: ABI detection should be done via compiler builtin macros. This

 #endif  // !defined(_LIBCPP_LITTLE_ENDIAN) && !defined(_LIBCPP_BIG_ENDIAN)
 
 #if __has_attribute(__no_sanitize__) && !defined(_LIBCPP_COMPILER_GCC)
 #  define _LIBCPP_NO_CFI __attribute__((__no_sanitize__("cfi")))
 #else
 #  define _LIBCPP_NO_CFI
 #endif
 
-#if __ISO_C_VISIBLE >= 2011 || __cplusplus >= 201103L
+#if (defined(__ISO_C_VISIBLE) && (__ISO_C_VISIBLE >= 2011)) || __cplusplus >= 201103L
 #  if defined(__FreeBSD__)
 #    define _LIBCPP_HAS_ALIGNED_ALLOC
 #    define _LIBCPP_HAS_QUICK_EXIT
 #    if __FreeBSD_version >= 1300064 || \
        (__FreeBSD_version >= 1201504 && __FreeBSD_version < 1300000)
 #      define _LIBCPP_HAS_TIMESPEC_GET
 #    endif
 #  elif defined(__BIONIC__)

 
 #if !__is_identifier(__has_unique_object_representations)
 #define _LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS
 #endif
 
 #define _LIBCPP_ALWAYS_INLINE __attribute__ ((__always_inline__))
 
 // Literal operators ""d and ""y are supported starting with LLVM Clang 8 and AppleClang 10.0.1
 #if (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 800) || \
     (defined(__apple_build_version__) && __apple_build_version__ < 10010000)
 #define _LIBCPP_HAS_NO_CXX20_CHRONO_LITERALS
 #endif
 
 #define _LIBCPP_DISABLE_EXTENSION_WARNING __extension__
 
 #elif defined(_LIBCPP_COMPILER_GCC)
 
 #define _ALIGNAS(x) __attribute__((__aligned__(x)))

libcxx/include/ext/hash_map

 
 #include <__config>
 #include <__hash_table>
 #include <functional>
 #include <stdexcept>
 #include <type_traits>
 #include <ext/__hash>
 
-#if __DEPRECATED
+#if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>")
 #else
 #   warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>
 #endif
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

libcxx/include/ext/hash_set

 
 */
 
 #include <__config>
 #include <__hash_table>
 #include <functional>
 #include <ext/__hash>
 
-#if __DEPRECATED
+#if defined(__DEPRECATED) && __DEPRECATED
 #if defined(_LIBCPP_WARNING)
     _LIBCPP_WARNING("Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>")
 #else
 #   warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
 #endif
 #endif
 
 namespace __gnu_cxx {

libcxx/include/future

 }
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_FUTURE_ERROR future_error
     : public logic_error
 {
     error_code __ec_;
 public:
     future_error(error_code __ec);
-#if _LIBCPP_STD_VERS > 14
-    explicit future_error(future_errc _Ev) : logic_error(), __ec_(make_error_code(_Ev)) {}
-#endif
+
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const _NOEXCEPT {return __ec_;}
 
     future_error(const future_error&) _NOEXCEPT = default;
     virtual ~future_error() _NOEXCEPT;
 };
 
 _LIBCPP_NORETURN inline _LIBCPP_INLINE_VISIBILITY

libcxx/include/type_traits

 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_array_v
     = is_array<_Tp>::value;
 #endif
 
 #endif // __has_keyword(__is_array)
 
 // is_pointer
 
 // Before Clang 11, __is_pointer didn't work for Objective-C types.
-#if __has_keyword(__is_pointer) && !(defined(_LIBCPP_COMPILER_CLANG) && _LIBCPP_CLANG_VER < 1100)
+#if __has_keyword(__is_pointer) &&                                             \
+    !(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1100)
 
 template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_pointer : _BoolConstant<__is_pointer(_Tp)> { };
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pointer_v = __is_pointer(_Tp);
 #endif
 

 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_arithmetic_v
     = is_arithmetic<_Tp>::value;
 #endif
 
 // is_fundamental
 
 // Before Clang 10, __is_fundamental didn't work for nullptr_t.
 // In C++03 nullptr_t is library-provided but must still count as "fundamental."
-#if __has_keyword(__is_fundamental) && !(defined(_LIBCPP_COMPILER_CLANG) && _LIBCPP_CLANG_VER < 1000) && !defined(_LIBCPP_CXX03_LANG)
+#if __has_keyword(__is_fundamental) &&                                         \
+    !(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1000) &&               \
+    !defined(_LIBCPP_CXX03_LANG)
 
 template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_fundamental : _BoolConstant<__is_fundamental(_Tp)> { };
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_fundamental_v = __is_fundamental(_Tp);
 #endif

 #if _LIBCPP_STD_VER > 17
 template<class _Tp> struct type_identity { typedef _Tp type; };
 template<class _Tp> using type_identity_t = typename type_identity<_Tp>::type;
 #endif
 
 // is_signed
 
 // Before Clang 10, __is_signed didn't work for floating-point types or enums.
-#if __has_keyword(__is_signed) && !(defined(_LIBCPP_COMPILER_CLANG) && _LIBCPP_CLANG_VER < 1000)
+#if __has_keyword(__is_signed) &&                                              \
+    !(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1000)
 
 template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_signed : _BoolConstant<__is_signed(_Tp)> { };
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_signed_v = __is_signed(_Tp);
 #endif

 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_signed_v
     = is_signed<_Tp>::value;
 #endif
 
 #endif // __has_keyword(__is_signed)
 
 // is_unsigned
 
 // Before Clang 13, __is_unsigned returned true for enums with signed underlying type.
-#if __has_keyword(__is_unsigned) && !(defined(_LIBCPP_COMPILER_CLANG) && _LIBCPP_CLANG_VER < 1300)
+#if __has_keyword(__is_unsigned) &&                                            \
+    !(defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER < 1300)
 
 template<class _Tp>
 struct _LIBCPP_TEMPLATE_VIS is_unsigned : _BoolConstant<__is_unsigned(_Tp)> { };
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_unsigned_v = __is_unsigned(_Tp);
 #endif
 

libcxx/test/std/atomics/types.pass.cpp

 //     typedef T                                        value_type;
 // };
 
 #include <atomic>
 #include <type_traits>
 
 #include <thread>
 #include <chrono>
+
+#include "test_macros.h"
+
 #if TEST_STD_VER >= 20
 # include <memory>
 #endif
 
-#include "test_macros.h"
-
 template <class A, bool Integral>
 struct test_atomic
 {
     test_atomic()
     {
         A a; (void)a;
 #if TEST_STD_VER >= 17
     static_assert((std::is_same_v<typename A::value_type, decltype(a.load())>), "");

libcxx/test/std/numerics/rand/rand.eng/rand.eng.mers/ctor_sseq_all_zero.pass.cpp

 //     and if each of the other resulting $X_i$ is $0$, changes $X_{-n}$ to
 //     $ 2^{w-1} $.
 
 #include <random>
 
 #include <algorithm>
 #include <cassert>
 #include <cstddef>
-#if TEST_STD_VER >= 11
-#include <initializer_list>
 
 #include "test_macros.h"
-#endif
 
 struct all_zero_seed_seq {
   typedef unsigned int result_type;
 
   all_zero_seed_seq() {}
 
   template <typename InputIterator>
   all_zero_seed_seq(InputIterator, InputIterator) {}
 #if TEST_STD_VER >= 11

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.hash/hash_shared_ptr.pass.cpp

 //     typedef shared_ptr<T>    argument_type;
 //     typedef size_t           result_type;
 //     size_t operator()(const shared_ptr<T>& p) const;
 // };
 
 #include <memory>
 #include <cassert>
 
+#include "test_macros.h"
+
 #if TEST_STD_VER >= 11
 #include "poisoned_hash_helper.h"
 
-#include "test_macros.h"
-
 struct A {};
 #endif
 
 int main(int, char**)
 {
   {
     int* ptr = new int;
     std::shared_ptr<int> p(ptr);

libcxx/test/support/test_macros.h

 #if TEST_STD_VER >= 20
 # define TEST_CONSTEXPR_CXX20 constexpr
 #else
 # define TEST_CONSTEXPR_CXX20
 #endif
 
 // Sniff out to see if the underlying C library has C11 features
 // This is cribbed from __config; but lives here as well because we can't assume libc++
-#if __ISO_C_VISIBLE >= 2011 || TEST_STD_VER >= 11
+#if (defined(__ISO_C_VISIBLE) && (__ISO_C_VISIBLE >= 2011)) ||                 \
+    TEST_STD_VER >= 11
 #  if defined(__FreeBSD__)
 #    if __FreeBSD_version >= 1300064 || \
        (__FreeBSD_version >= 1201504 && __FreeBSD_version < 1300000)
 #      define TEST_HAS_TIMESPEC_GET
 #    endif
 #    define TEST_HAS_ALIGNED_ALLOC
 #    define TEST_HAS_QUICK_EXIT
 #  elif defined(__BIONIC__)

libcxx/utils/libcxx/test/params.py

 #===----------------------------------------------------------------------===##
 #
 # 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
 #
 #===----------------------------------------------------------------------===##
 
 from libcxx.test.dsl import *
 
 _allStandards = ['c++03', 'c++11', 'c++14', 'c++17', 'c++2a', 'c++2b']
 _warningFlags = [
   '-Werror',
   '-Wall',
   '-Wextra',
   '-Wshadow',
+  '-Wundef',
   '-Wno-unused-command-line-argument',
   '-Wno-attributes',
   '-Wno-pessimizing-move',
   '-Wno-c++11-extensions',
   '-Wno-user-defined-literals',
   '-Wno-noexcept-type',
   '-Wno-aligned-allocation-unavailable',
   '-Wno-atomic-alignment',