[libc++] Use Lit annotations for all .gen.py tests

[ldionne]

Summary

Instead of guarding header tests using #ifdefs inside the tests,
use Lit markup to mark all the tests as unsupported. This is simpler
but also provides better feedback about which tests are being run
when running the test suite.

[Mordante]

Thanks for working on these improvements! LGTM!

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.gen.py

33

I really like how much cruft this patch removes from these files!

[ldionne]

Rebase on top of main

[ldionne]

Fix CI.

[ldionne]

Revert FreeBSD changes to fix CI.

[ldionne]

Rebase

[ldionne]

Fix FreeBSD CI. Temporary modifications to the buildkite pipeline to avoid running parts of the CI that already passed.

[ldionne]

Rebase and revert temporary CI changes. I'll ship this now since all the CI jobs are green.

libcxx/include/__memory_resource/synchronized_pool_resource.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_RESOURCE_SYNCHRONIZED_POOL_RESOURCE_H
 #define _LIBCPP___MEMORY_RESOURCE_SYNCHRONIZED_POOL_RESOURCE_H
 
 #include <__config>
 #include <__memory_resource/memory_resource.h>
 #include <__memory_resource/pool_options.h>
 #include <__memory_resource/unsynchronized_pool_resource.h>
 #include <cstddef>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#  include <mutex>
-#endif
+#include <mutex>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 17
 
 _LIBCPP_BEGIN_NAMESPACE_STD

libcxx/test/libcxx/assertions/headers_declare_verbose_abort.gen.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
 #
 #===----------------------------------------------------------------------===##
 
 # Test that all public C++ headers define the verbose termination function, which
 # is required for users to be able to include any public header and then override
 # the function using a strong definition.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, public_headers
+from libcxx.test.header_information import lit_header_restrictions, public_headers
 
 for header in public_headers:
     # Skip C compatibility headers.
     if header.endswith('.h'):
         continue
 
-    test_condition_begin = f'#if {header_restrictions[header]}' if header in header_restrictions else ''
-    test_condition_end = '#endif' if header in header_restrictions else ''
-    XFAIL = 'XFAIL' # Make sure Lit doesn't think we are XFAILing this test
+    BLOCKLIT = '' # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
     print(f"""\
 //--- {header}.compile.pass.cpp
-// {XFAIL}: availability-verbose_abort-missing
-#include <__config>
-{test_condition_begin}
+{lit_header_restrictions.get(header, '')}
+
+// XFAIL{BLOCKLIT}: availability-verbose_abort-missing
+
 #include <{header}>
 using HandlerType = decltype(std::__libcpp_verbose_abort);
-{test_condition_end}
 """)

libcxx/test/libcxx/clang_tidy.gen.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
 #
 #===----------------------------------------------------------------------===##
 
 # Run our custom libc++ clang-tidy checks on all public headers.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, public_headers
+from libcxx.test.header_information import lit_header_restrictions, public_headers
 
 for header in public_headers:
   BLOCKLIT = '' # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
-  test_condition_begin = '#if ' + header_restrictions[header] if header in header_restrictions else ''
-  test_condition_end = '#endif' if header in header_restrictions else ''
-
   print(f"""\
 //--- {header}.sh.cpp
 
 // REQUIRES{BLOCKLIT}: has-clang-tidy
 
 // The GCC compiler flags are not always compatible with clang-tidy.
 // UNSUPPORTED{BLOCKLIT}: gcc
 
+{lit_header_restrictions.get(header, '')}
+
 // TODO: run clang-tidy with modules enabled once they are supported
 // RUN{BLOCKLIT}: %{{clang-tidy}} %s --warnings-as-errors=* -header-filter=.* --checks='-*,libcpp-*' --load=%{{test-tools}}/clang_tidy_checks/libcxx-tidy.plugin -- %{{compile_flags}} -fno-modules
 // RUN{BLOCKLIT}: %{{clang-tidy}} %s --warnings-as-errors=* -header-filter=.* --config-file=%{{libcxx}}/.clang-tidy -- -Wweak-vtables %{{compile_flags}} -fno-modules
 
-#include <__config>
-{test_condition_begin}
 #include <{header}>
-{test_condition_end}
 """)

libcxx/test/libcxx/double_include.gen.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
 #
 #===----------------------------------------------------------------------===##
 
 # Test that we can include each header in two TU's and link them together.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, public_headers
+from libcxx.test.header_information import lit_header_restrictions, public_headers
 
+for header in public_headers:
   BLOCKLIT = '' # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
   print(f"""\
-//--- double_include.sh.cpp
+//--- {header}.sh.cpp
+{lit_header_restrictions.get(header, '')}
+
 // RUN{BLOCKLIT}: %{{cxx}} -c %s -o %t.first.o %{{flags}} %{{compile_flags}}
 // RUN{BLOCKLIT}: %{{cxx}} -c %s -o %t.second.o -DWITH_MAIN %{{flags}} %{{compile_flags}}
 // RUN{BLOCKLIT}: %{{cxx}} -o %t.exe %t.first.o %t.second.o %{{flags}} %{{link_flags}}
 // RUN{BLOCKLIT}: %{{run}}
-""")
 
-for header in public_headers:
-  test_condition_begin = '#if ' + header_restrictions[header] if header in header_restrictions else ''
-  test_condition_end = '#endif' if header in header_restrictions else ''
-  print(f"""\
-#include <__config>
-{test_condition_begin}
 #include <{header}>
-{test_condition_end}
-""")
 
-print("""
 #if defined(WITH_MAIN)
-int main(int, char**) { return 0; }
+int main(int, char**) {{ return 0; }}
 #endif
 """)

libcxx/test/libcxx/header_inclusions.gen.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
 #
 #===----------------------------------------------------------------------===##
 
 # Test that all headers include all the other headers they're supposed to, as
 # prescribed by the Standard.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, public_headers, mandatory_inclusions
+from libcxx.test.header_information import lit_header_restrictions, public_headers, mandatory_inclusions
 
 for header in public_headers:
-  test_condition_begin = '#if ' + header_restrictions[header] if header in header_restrictions else ''
-  test_condition_end = '#endif' if header in header_restrictions else ''
-
   header_guard = lambda h: f"_LIBCPP_{h.upper().replace('.', '_').replace('/', '_')}"
 
   # <cassert> has no header guards
   if header == 'cassert':
     checks = ''
   else:
     checks = f'''
 #ifndef {header_guard(header)}
 # error <{header}> was expected to define a header guard {header_guard(header)}
 #endif
 '''
   for includee in mandatory_inclusions.get(header, []):
     checks += f'''
 #ifndef {header_guard(includee)}
 # error <{header}> was expected to include <{includee}>
 #endif
 '''
 
   print(f"""\
 //--- {header}.compile.pass.cpp
-#include <__config>
-{test_condition_begin}
+{lit_header_restrictions.get(header, '')}
+
 #include <{header}>
 {checks}
-{test_condition_end}
 """)

libcxx/test/libcxx/modules_include.gen.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
 #
 #===----------------------------------------------------------------------===##
 
 # Test that we can include each header in a TU while using modules.
 # This is important notably because the LLDB data formatters use
 # libc++ headers with modules enabled.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, public_headers
+from libcxx.test.header_information import lit_header_restrictions, public_headers
 
 for header in public_headers:
   BLOCKLIT = '' # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
-  test_condition_begin = '#if ' + header_restrictions[header] if header in header_restrictions else ''
-  test_condition_end = '#endif' if header in header_restrictions else ''
-
   print(f"""\
 //--- {header}.compile.pass.cpp
 // RUN{BLOCKLIT}: %{{cxx}} %s %{{flags}} %{{compile_flags}} -fmodules -fcxx-modules -fmodules-cache-path=%t -fsyntax-only
 
 // GCC doesn't support -fcxx-modules
 // UNSUPPORTED{BLOCKLIT}: gcc
 
 // The Windows headers don't appear to be compatible with modules
 // UNSUPPORTED{BLOCKLIT}: windows
 // UNSUPPORTED{BLOCKLIT}: buildhost=windows
 
 // The Android headers don't appear to be compatible with modules yet
 // XFAIL{BLOCKLIT}: LIBCXX-ANDROID-FIXME
 
 // TODO: Investigate this failure
 // UNSUPPORTED{BLOCKLIT}: LIBCXX-FREEBSD-FIXME
 
-#include <__config>
-{test_condition_begin}
+{lit_header_restrictions.get(header, '')}
+
 #include <{header}>
-{test_condition_end}
 """)

libcxx/test/libcxx/nasty_macros.gen.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
 #
 #===----------------------------------------------------------------------===##
 
 # Test that headers are not tripped up by the surrounding code defining various
 # alphabetic macros.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, public_headers
+from libcxx.test.header_information import lit_header_restrictions, public_headers
 
 for header in public_headers:
-  test_condition_begin = '#if ' + header_restrictions[header] if header in header_restrictions else ''
-  test_condition_end = '#endif' if header in header_restrictions else ''
-
   print(f"""\
 //--- {header}.compile.pass.cpp
+{lit_header_restrictions.get(header, '')}
+
 #define NASTY_MACRO This should not be expanded!!!
 
 // libc++ does not use single-letter names as a matter of principle.
 // But Windows' own <wchar.h>, <math.h>, and <exception> use many of these
 // (at least C,E,F,I,M,N,P,S,X,Y,Z) as uglified function parameter names,
 // so don't define these on Windows.
 //
 #ifndef _WIN32

 #define X NASTY_MACRO
 #define Xp NASTY_MACRO
 #define Xs NASTY_MACRO
 
 // The classic Windows min/max macros
 #define min NASTY_MACRO
 #define max NASTY_MACRO
 
-#include <__config>
-{test_condition_begin}
 #include <{header}>
-{test_condition_end}
 """)

libcxx/test/libcxx/no_assert_include.gen.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
 #
 #===----------------------------------------------------------------------===##
 
 # Ensure that none of the standard C++ headers implicitly include cassert or
 # assert.h (because assert() is implemented as a macro).
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, public_headers
+from libcxx.test.header_information import lit_header_restrictions, public_headers
 
 for header in public_headers:
   if header == 'cassert':
     continue
 
-  test_condition_begin = '#if ' + header_restrictions[header] if header in header_restrictions else ''
-  test_condition_end = '#endif' if header in header_restrictions else ''
-
   print(f"""\
 //--- {header}.compile.pass.cpp
+{lit_header_restrictions.get(header, '')}
 
-#include <__config>
-{test_condition_begin}
 #include <{header}>
+
 #ifdef assert
 # error "Do not include cassert or assert.h in standard header files"
 #endif
-{test_condition_end}
 """)

libcxx/test/libcxx/private_headers.gen.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
 #
 #===----------------------------------------------------------------------===##
 
 # This test ensures that we produce a diagnostic when we use a private header
 # from user code.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, private_headers, private_headers_still_public_in_modules
+from libcxx.test.header_information import lit_header_restrictions, private_headers, private_headers_still_public_in_modules
 
 for header in private_headers:
   # Skip headers that are not private yet in the modulemap
   if header in private_headers_still_public_in_modules:
     continue
 
   # Skip private headers that start with __support -- those are not in the modulemap yet
   if header.startswith('__support'):
     continue
 
   # Skip the locale API headers, since they are platform-specific and thus inherently non-modular
   if 'locale_base_api' in header:
     continue
 
   # TODO: Stop skipping PSTL headers once their integration is finished.
   if header.startswith('__pstl'):
     continue
 
-  test_condition_begin = '#if ' + header_restrictions[header] if header in header_restrictions else ''
-  test_condition_end = '#endif' if header in header_restrictions else ''
   BLOCKLIT = '' # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
-
   print(f"""\
 //--- {header}.verify.cpp
 // REQUIRES{BLOCKLIT}: modules-build
+{lit_header_restrictions.get(header, '')}
 
-#include <__config>
-{test_condition_begin}
 #include <{header}> // expected-error@*:* {{{{use of private header from outside its module: '{header}'}}}}
-{test_condition_end}
 """)

libcxx/test/libcxx/transitive_includes.gen.py

 # This is not meant to block libc++ from removing unused transitive includes
 # forever, however we do try to group removals for a couple of releases
 # to avoid breaking users at every release.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 sys.path.append(sys.argv[1])
-from libcxx.test.header_information import header_restrictions, public_headers
+from libcxx.test.header_information import lit_header_restrictions, public_headers
 
 import re
 
 # To re-generate the list of expected headers, temporarily set this to True, and run this test.
 # Note that this needs to be done for all supported language versions of libc++:
 # for std in c++03 c++11 c++14 c++17 c++20 c++23 c++26; do <build>/bin/llvm-lit --param std=$std ${path_to_this_file}; done
 regenerate_expected_results = False
 
for header in public_headers:
     if header.endswith('.h'): # Skip C compatibility or detail headers
       continue
 
     # Escape slashes for the awk command below
     escaped_header = header.replace('/', '\/')
 
     print(f"""\
 //--- {header}.sh.cpp
+{lit_header_restrictions.get(header, '')}
 
-// This test doesn't support being run when some headers are not available, since we
-// would need to add significant complexity to make that work.
-// UNSUPPORTED{BLOCKLIT}: no-localization, no-threads, no-wide-characters, no-filesystem
+// TODO: Fix this test to make it work with filesystem, localization or wide characters disabled
+// UNSUPPORTED{BLOCKLIT}: no-filesystem, no-localization, no-wide-characters
 
 // When built with modules, this test doesn't work because --trace-includes doesn't
 // report the stack of includes correctly.
 // UNSUPPORTED{BLOCKLIT}: modules-build
 
 // This test uses --trace-includes, which is not supported by GCC.
 // UNSUPPORTED{BLOCKLIT}: gcc
 

libcxx/utils/libcxx/test/header_information.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
 #
 # ===----------------------------------------------------------------------===##
 
 import os, pathlib
 
-header_restrictions = {
-    "barrier": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "future": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "latch": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "semaphore": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "shared_mutex": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "stdatomic.h": "__cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS)",
-    "stop_token": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "thread": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "filesystem": "!defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)",
-    # TODO(LLVM-17): simplify this to __cplusplus >= 202002L
-    "coroutine": "(defined(__cpp_impl_coroutine) && __cpp_impl_coroutine >= 201902L) || (defined(__cpp_coroutines) && __cpp_coroutines >= 201703L)",
-    "clocale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "codecvt": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "fstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION) && !defined(_LIBCPP_HAS_NO_FSTREAM)",
-    "iomanip": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "ios": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "iostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "istream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "locale.h": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "locale": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "ostream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "regex": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "sstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "streambuf": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "strstream": "!defined(_LIBCPP_HAS_NO_LOCALIZATION)",
-    "wctype.h": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
-    "cwctype": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
-    "cwchar": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
-    "wchar.h": "!defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)",
-    "experimental/algorithm": "__cplusplus >= 201103L",
-    "experimental/deque": "__cplusplus >= 201103L",
-    "experimental/forward_list": "__cplusplus >= 201103L",
-    "experimental/functional": "__cplusplus >= 201103L",
-    "experimental/iterator": "__cplusplus >= 201103L",
-    "experimental/list": "__cplusplus >= 201103L",
-    "experimental/map": "__cplusplus >= 201103L",
-    "experimental/memory_resource": "__cplusplus >= 201103L",
-    "experimental/propagate_const": "__cplusplus >= 201103L",
-    "experimental/regex": "!defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L",
-    "experimental/set": "__cplusplus >= 201103L",
-    "experimental/simd": "__cplusplus >= 201103L",
-    "experimental/span": "__cplusplus >= 201103L",
-    "experimental/string": "__cplusplus >= 201103L",
-    "experimental/type_traits": "__cplusplus >= 201103L",
-    "experimental/unordered_map": "__cplusplus >= 201103L",
-    "experimental/unordered_set": "__cplusplus >= 201103L",
-    "experimental/utility": "__cplusplus >= 201103L",
-    "experimental/vector": "__cplusplus >= 201103L",
-}
-
 lit_header_restrictions = {
     "barrier": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17",
     "stop_token": "// UNSUPPORTED: no-threads, c++03, c++11, c++14, c++17",
     "clocale": "// UNSUPPORTED: no-localization",
     "codecvt": "// UNSUPPORTED: no-localization",
     "coroutine": "// UNSUPPORTED: c++03, c++11, c++14, c++17",
     "cwchar": "// UNSUPPORTED: no-wide-characters",
     "cwctype": "// UNSUPPORTED: no-wide-characters",