[libc++] Improve generate_feature_test_macro_components.py.

[Mordante]

Summary

This improves the naming of the fields depends/internal_depends. It
also adds the documentation for this script. The changes are based on
D99290 and its review comments.

[• Quuxplusone]

Generally awesome.

libcxx/utils/generate_feature_test_macro_components.py

33

@Mordante: I propose that you lose the s in libcxx_guards and test_suite_guards: just do libcxx_guard and test_suite_guard. These are single strings, not arrays of strings; and shorter is better anyway.
(Btw, I always interpreted depends as the present-tense singular verb, as in "depends on," not as an abbreviation of "dependencies.")

I would not object if someone dug up a precedent for spelling it libcxx-guard.

36–39

52

(A) why not?
(B) I think you can cut lines 44-50, and just let lines 51-52 do the talking
(C) I think you need to say explicitly that test_suite_guards is used in the generated tests (but not in the libc++ headers); whereas libcxx_guards is used in libc++'s <version> header (but not in the tests). That's the main point of these fields AIUI.

57

Is this "otherwise" codepath actually hit at the moment? Could we eliminate this whole codepath by duplicating a little bit of data in the table?

60

678–680

Let's throw in another couple asserts here like

assert all(("libcxx_guards" in tc) == ("test_suite_guards" in tc) for tc in feature_test_macros)
assert all(key in ["name", "values", "headers", "libcxx_guards", "test_suite_guards", "unimplemented"] for key in tc.keys() for tc in feature_test_macros)

The first one allows you to remove the assert from line 755.
The second one guards against the fact that it's way easier to carelessly misspell libcxx_guards than it was to misspell depends.
(I don't actually understand the assert on line 759.)

[ldionne]

I'm fine with this either as-is or with Arthur's suggestions. I'll let you folks go back-and-forth, but feel free to commit this once Arthur is satisfied.

@Quuxplusone When you accept, please accept as libc++ too.

libcxx/utils/generate_feature_test_macro_components.py

52

(A) why not?

Because the test suite is supposed to work even on non-libc++ standard libraries.

[Mordante]

Thanks for the reviews, will commit an update shortly.

libcxx/utils/generate_feature_test_macro_components.py

33

I used the naming Louis proposed in D99290 but I don't mind to make it the name singular.

36–39

I like your wording, but I dislike abbreviations in a text so will replace them.

52

(B) I think you can cut lines 44-50, and just let lines 51-52 do the talking

I'll look at removing some fluff of 44-50, but I think it's good to state a more explicitly what's expected for this field.

(C) I think you need to say explicitly that test_suite_guards is used in the generated tests (but not in the libc++ headers); whereas libcxx_guards is used in libc++'s <version> header (but not in the tests). That's the main point of these fields AIUI.

Good point.

57

Not entirely sure what you mean. This means you need to write to write the same value for ibcxx_guards and test_suite_guards. For example see line 68-69 with both depend on the CMake defined macro "!defined(_LIBCPP_HAS_NO_THREADS)"

678–680

Let's throw in another couple asserts here like

assert all(key in ["name", "values", "headers", "libcxx_guards", "test_suite_guards", "unimplemented"] for key in tc.keys() for tc in feature_test_macros)

This one doesn't work, I adjusted it to a working version. My Python is a bit rusty, so please have a look at it.

The first one allows you to remove the assert from line 755.

I like this.

(I don't actually understand the assert on line 759.)

Me neither, so I'll just keep it.

[Mordante]

Addresses the review comments.

[• Quuxplusone]

libcxx/utils/generate_feature_test_macro_components.py

36–39

Python calls the type dict, though. The situation is analogous to a comment about C++ saying "This parameter is an int" versus "This parameter is an integer" — yes in some sense int was once short for "integer," but IMHO it's taken on enough of a life of its own that we should use the more precise technical term.
(If this were JavaScript, I'd equally be pushing to call it an object instead of a dictionary.)

57

Oh, I see what you were going for now. I had interpreted this section as saying, "If you provide libcxx_guard (with a value based on include/__config macros), then the script will use it. Otherwise, the script will use the value of test_suite_guard instead." So I was saying, can't we just duplicate the data in the table? which is exactly what old lines 68-69 actually do!

So I think you should just change this section to avoid my misinterpretation: I'd say something like

# test_suite_guard  An optional string field. When this field is provided,
#                   `libcxx_guard` must also be provided. This field is used
#                   only to generate the unit tests for the feature-test macros.
#                   It must never depend on anything defined in <__config>,
#                   but it may depend on
#                    * macros defined by the compiler itself
#                    * macros generated by CMake
#                    * macros defined in <__availability>
# libcxx_guard      An optional string field. When this field is provided,
#                   `test_suite_guard` must also be provided. This field is used
#                   only to guard the feature-test macro in <version>. It may
#                   be the same as `test_suite_guard`, or it may depend on
#                   macros defined in <__config>.

I guess my next question (about the pre-existing code) is, why would we ever want the two definitions to differ? Maybe @ldionne and @cjdb can recap the situation that led to them being different for __cpp_lib_math_constants (and/or __cpp_lib_char8_t).

[Mordante]

libcxx/utils/generate_feature_test_macro_components.py

36–39

https://docs.python.org/3/c-api/dict.html has the Dictonary in the title so used that as basis to use dictionary. But I'll change it.

57

So I think you should just change this section to avoid my misinterpretation: I'd say something like

Your version is a bit compacter and seems to convey the same message, so that's nice. I only like to use

#                    * macros defined by the compiler itself,
#                    * macros generated by CMake, or
#                    * macros defined in <__availability>.

I guess my next question (about the pre-existing code) is, why would we ever want the two definitions to differ? Maybe @ldionne and @cjdb can recap the situation that led to them being different for __cpp_lib_math_constants (and/or __cpp_lib_char8_t).

For __cpp_lib_math_constants we test in the test suite for defined(__cpp_concepts) && __cpp_concepts >= 201907L" which should work with all compilers. In <__config> we may define _LIBCPP_HAS_NO_CONCEPTS so that can be used in <version>. Whether or not the macro is defined depends on the value and availability of __cpp_concepts.

[Mordante]

Addresses review comments.

[• Quuxplusone]

libcxx/utils/generate_feature_test_macro_components.py

57

Ah, right, the libcxx_guard expression can use things that are defined only inside libc++, whereas test_suite_guard needs to be an expression that works on all vendors' compilers and libraries, because the generated tests go into test/std/, not test/libcxx/.
Can you add a sentence to that effect? Maybe use the word "portable." I'm almost tempted to rename "test_suite_guard" into "portable_guard" — but I think I still agree that its being used only in the generated tests is its primary characteristic, and needing to be portable across libraries is sort of a logical corollary of that. (But not an obvious corollary, which is why I'm asking you to add a sentence about it!)

[Mordante]

libcxx/utils/generate_feature_test_macro_components.py

57

I'll do that. I think it also explains why it can't depend on <__config>. Explaining why is always good :-)

[Mordante]

Adresses the review comments.

[• Quuxplusone]

LGTM at this point, modulo my remaining comments (and my suggested edit resolves all of my remaining comments).
I'd say it makes sense to get this landed expeditiously and deal with the TODOs separately.

Please make sure the script still runs and produces no unexpected git diffs, of course. :)

libcxx/utils/generate_feature_test_macro_components.py

42–58

I've taken the liberty of providing a suggested edit I'd be happy with. I think anything close to this is probably OK.

49

Based on the explanation below, I think this bullet point is wrong: other library vendors won't have libc++'s <__availability>. Also, <__availability> is included from libc++ top-level headers like <any>... but won't be included from other vendors' <any>. So I don't see why <__availability> is treated any different from <__config> here.

IOW, I don't understand why it's not a bug that we use the libc++-specific macro _LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait to control the tests for __cpp_lib_atomic_wait. (I'm content to leave a TODO comment and punt on this, rather than block this PR specifically, because I suspect this is a deep question.)

Orthogonally, you should add a bullet point for macros defined in "test/support/test_macros.h", because we use those a lot in the data table. (E.g. TEST_STD_VER and TEST_HAS_BUILTIN.) These are kosher in test_suite_guard but absolutely not in libcxx_guard.

[Mordante]

Thanks a lot for your review comments @Quuxplusone, it really helps to get the documentation is a better shape!

libcxx/utils/generate_feature_test_macro_components.py

42–58

I disagree with the TODO. I think using <__availability> is fine. I'll update the patch with the reason why.

[Mordante]

Addresses review comments. Instead of adding a TODO explain what's valid for
<__availability>

[curdeius]

libcxx/utils/generate_feature_test_macro_components.py

52

This phrase is repeated just before the bullet list.

[• Quuxplusone]

libcxx/utils/generate_feature_test_macro_components.py

56–59

Wonky English grammar here; also, this logic applies equally well to any libc++ header (that libc++ headers define things that aren't defined by other library implementations).
I think you should add a TODO and come back to this; i.e., take my suggested fix verbatim.
These macros were all introduced in @ldionne's D94983, btw.

[• Quuxplusone]

libcxx/utils/generate_feature_test_macro_components.py

56–59

Ah, D94983 enlightens me that the FTM in these macro names stands specifically for "feature-test macro"!
So I'd write it like this:

# test_suite_guard  An optional string field. When this field is provided,
#                   `libcxx_guard` must also be provided. This field is used
#                   only to generate the unit tests for the feature-test macros.
#                   It can't depend on macros defined in <__config> because the
#                   `test/std/` parts of the test suite are intended to be
#                   portable to any C++ standard library implementation, not
#                   just libc++. It may depend on
#                    * macros defined by the compiler itself,
#                    * macros generated by CMake, or
#                   In some cases we add `&& !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM_...)`
#                   in order to make libc++ pass the tests on OSX; see D94983.

Anyway, I still say ship it and handle the cleanup post-commit.

Notice that you've got two copies of libcxx_guard now; delete the second copy.

[Mordante]

libcxx/utils/generate_feature_test_macro_components.py

52

Thanks, fixed.

56–59

I like your text, will change CMake, or to CMake.
As suggested I'll then land this patch.

[ldionne]

libcxx/utils/generate_feature_test_macro_components.py

49

IOW, I don't understand why it's not a bug that we use the libc++-specific macro _LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait to control the tests for __cpp_lib_atomic_wait. (I'm content to leave a TODO comment and punt on this, rather than block this PR specifically, because I suspect this is a deep question.)

It is indeed a "bug". Normally, I would have added a "mode" for the test suite where it runs but doesn't assume that atomic_wait is available. I would then turn that on only when running the tests for back-deploying to a platform that doesn't support it. I didn't do it for simplicity, but it's indeed the correct way to do that IMO.

libcxx/utils/generate_feature_test_macro_components.py

 def has_header(h):
   h_path = os.path.join(include_path, h)
   return os.path.exists(h_path)
 
 def add_version_header(tc):
   tc["headers"].append("version")
   return tc
 
+# ================  ============================================================
+# Field             Description
+# ================  ============================================================
+# name              The name of the feature-test macro.
+# values            A dict whose keys are C++ versions and whose values are the
+#                   value of the feature-test macro for that C++ version.
+#                   (TODO: This isn't a very clean model for feature-test
+#                   macros affected by multiple papers.)
+# headers           An array with the headers that should provide the
+#                   feature-test macro.
+# test_suite_guard  An optional string field. When this field is provided,
+#                   `libcxx_guard` must also be provided. This field is used
+#                   only to generate the unit tests for the feature-test macros.
+#                   It can't depend on macros defined in <__config> because the
+#                   `test/std/` parts of the test suite are intended to be
+#                   portable to any C++ standard library implementation, not
+#                   just libc++. It may depend on
+#                    * macros defined by the compiler itself,
+#                    * macros generated by CMake, or
+#                    * `AVAILABILITY_DISABLE` macros defined in <__availability>.
+#                   It can't depend on <__config> since the test suite should
+#                   be portable. Using libc++ specific features will cause unit
+#                   test failures when using other implementations of the
+#                   C++ standard library.
+#                   It's possible to use the `AVAILABILITY_DISABLE` macros of
+#                   <__availability> since it defines libc++ specific macros,
+#                   that aren't defined by other C++ standard library
+#                   implementations.
+# libcxx_guard      An optional string field. When this field is provided,
+#                   `test_suite_guard` must also be provided. This field is used
+#                   only to guard the feature-test macro in <version>. It may
+#                   be the same as `test_suite_guard`, or it may depend on
+#                   macros defined in <__config>.
+# unimplemented     An optional Boolean field with the value `True`. This field
+#                   is only used when a feature isn't fully implemented. Once
+#                   you've fully implemented the feature, you should remove
+#                   this field.
+# ================  ============================================================
 feature_test_macros = [ add_version_header(x) for x in [
   {
     "name": "__cpp_lib_addressof_constexpr",
     "values": { "c++17": 201603 },
     "headers": ["memory"],
-    "depends": "TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_BUILTIN_ADDRESSOF)",
+    "test_suite_guard": "TEST_HAS_BUILTIN(__builtin_addressof) || TEST_GCC_VER >= 700",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_BUILTIN_ADDRESSOF)",
   }, {
     "name": "__cpp_lib_allocator_traits_is_always_equal",
     "values": { "c++17": 201411 },
     "headers": ["deque", "forward_list", "list", "map", "memory", "scoped_allocator", "set", "string", "unordered_map", "unordered_set", "vector"],
   }, {
     "name": "__cpp_lib_any",
     "values": { "c++17": 201606 },
     "headers": ["any"],
feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_assume_aligned",
     "values": { "c++20": 201811 },
     "headers": ["memory"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_atomic_flag_test",
     "values": { "c++20": 201907 },
     "headers": ["atomic"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
   }, {
     "name": "__cpp_lib_atomic_float",
     "values": { "c++20": 201711 },
     "headers": ["atomic"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_atomic_is_always_lock_free",
     "values": { "c++17": 201603 },
     "headers": ["atomic"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
   }, {
     "name": "__cpp_lib_atomic_lock_free_type_aliases",
     "values": { "c++20": 201907 },
     "headers": ["atomic"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
   }, {
     "name": "__cpp_lib_atomic_ref",
     "values": { "c++20": 201806 },
     "headers": ["atomic"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_atomic_shared_ptr",
     "values": { "c++20": 201711 },
     "headers": ["atomic"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_atomic_value_initialization",
     "values": { "c++20": 201911 },
     "headers": ["atomic", "memory"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_atomic_wait",
     "values": { "c++20": 201907 },
     "headers": ["atomic"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait)",
   }, {
     "name": "__cpp_lib_barrier",
     "values": { "c++20": 201907 },
     "headers": ["barrier"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)",
   }, {
     "name": "__cpp_lib_bind_front",
     "values": { "c++20": 201907 },
     "headers": ["functional"],
   }, {
     "name": "__cpp_lib_bit_cast",
     "values": { "c++20": 201806 },
     "headers": ["bit"],
feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_byte",
     "values": { "c++17": 201603 },
     "headers": ["cstddef"],
   }, {
     "name": "__cpp_lib_char8_t",
     "values": { "c++20": 201811 },
     "headers": ["atomic", "filesystem", "istream", "limits", "locale", "ostream", "string", "string_view"],
-    "depends": "defined(__cpp_char8_t)",
-    "internal_depends": "!defined(_LIBCPP_NO_HAS_CHAR8_T)",
+    "test_suite_guard": "defined(__cpp_char8_t)",
+    "libcxx_guard": "!defined(_LIBCPP_NO_HAS_CHAR8_T)",
   }, {
     "name": "__cpp_lib_chrono",
     "values": { "c++17": 201611 },
     "headers": ["chrono"],
   }, {
     "name": "__cpp_lib_chrono_udls",
     "values": { "c++14": 201304 },
     "headers": ["chrono"],
feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_coroutine",
     "values": { "c++20": 201902 },
     "headers": ["coroutine"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_destroying_delete",
     "values": { "c++20": 201806 },
     "headers": ["new"],
-    "depends": "TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
-    "internal_depends": "_LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
+    "test_suite_guard": "TEST_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
+    "libcxx_guard": "_LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L",
   }, {
     "name": "__cpp_lib_enable_shared_from_this",
     "values": { "c++17": 201603 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_endian",
     "values": { "c++20": 201907 },
     "headers": ["bit"],
feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_execution",
     "values": { "c++17": 201603, "c++20": 201902 },
     "headers": ["execution"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_filesystem",
     "values": { "c++17": 201703 },
     "headers": ["filesystem"],
-    "depends": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)",
-    "internal_depends": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)"
+    "test_suite_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)",
+    "libcxx_guard": "!defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)"
   }, {
     "name": "__cpp_lib_format",
     "values": { "c++20": 201907 },
     "headers": ["format"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_gcd_lcm",
     "values": { "c++17": 201606 },
feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_hardware_interference_size",
     "values": { "c++17": 201703 },
     "headers": ["new"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_has_unique_object_representations",
     "values": { "c++17": 201606 },
     "headers": ["type_traits"],
-    "depends": "TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700",
-    "internal_depends": "defined(_LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS)",
+    "test_suite_guard": "TEST_HAS_BUILTIN_IDENTIFIER(__has_unique_object_representations) || TEST_GCC_VER >= 700",
+    "libcxx_guard": "defined(_LIBCPP_HAS_UNIQUE_OBJECT_REPRESENTATIONS)",
   }, {
     "name": "__cpp_lib_hypot",
     "values": { "c++17": 201603 },
     "headers": ["cmath"],
   }, {
     "name": "__cpp_lib_incomplete_container_elements",
     "values": { "c++17": 201505 },
     "headers": ["forward_list", "list", "vector"],
feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_invoke",
     "values": { "c++17": 201411 },
     "headers": ["functional"],
   }, {
     "name": "__cpp_lib_is_aggregate",
     "values": { "c++17": 201703 },
     "headers": ["type_traits"],
-    "depends": "TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_IS_AGGREGATE)",
+    "test_suite_guard": "TEST_HAS_BUILTIN_IDENTIFIER(__is_aggregate) || TEST_GCC_VER_NEW >= 7001",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_IS_AGGREGATE)",
   }, {
     "name": "__cpp_lib_is_constant_evaluated",
     "values": { "c++20": 201811 },
     "headers": ["type_traits"],
-    "depends": "TEST_HAS_BUILTIN(__builtin_is_constant_evaluated) || TEST_GCC_VER >= 900",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)",
+    "test_suite_guard": "TEST_HAS_BUILTIN(__builtin_is_constant_evaluated) || TEST_GCC_VER >= 900",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)",
   }, {
     "name": "__cpp_lib_is_final",
     "values": { "c++14": 201402 },
     "headers": ["type_traits"],
   }, {
     "name": "__cpp_lib_is_invocable",
     "values": { "c++17": 201703 },
     "headers": ["type_traits"],
feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_is_swappable",
     "values": { "c++17": 201603 },
     "headers": ["type_traits"],
   }, {
     "name": "__cpp_lib_jthread",
     "values": { "c++20": 201911 },
     "headers": ["stop_token", "thread"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS)",
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_latch",
     "values": { "c++20": 201907 },
     "headers": ["latch"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)",
   }, {
     "name": "__cpp_lib_launder",
     "values": { "c++17": 201606 },
     "headers": ["new"],
   }, {
     "name": "__cpp_lib_list_remove_return_type",
     "values": { "c++20": 201806 },
     "headers": ["forward_list", "list"],
feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_map_try_emplace",
     "values": { "c++17": 201411 },
     "headers": ["map"],
   }, {
     "name": "__cpp_lib_math_constants",
     "values": { "c++20": 201907 },
     "headers": ["numbers"],
-    "depends": "defined(__cpp_concepts) && __cpp_concepts >= 201907L",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_CONCEPTS)",
+    "test_suite_guard": "defined(__cpp_concepts) && __cpp_concepts >= 201907L",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_CONCEPTS)",
   }, {
     "name": "__cpp_lib_math_special_functions",
     "values": { "c++17": 201603 },
     "headers": ["cmath"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_memory_resource",
     "values": { "c++17": 201603 },
feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_scoped_lock",
     "values": { "c++17": 201703 },
     "headers": ["mutex"],
   }, {
     "name": "__cpp_lib_semaphore",
     "values": { "c++20": 201907 },
     "headers": ["semaphore"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)",
   }, {
     "name": "__cpp_lib_shared_mutex",
     "values": { "c++17": 201505 },
     "headers": ["shared_mutex"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_mutex)",
   }, {
     "name": "__cpp_lib_shared_ptr_arrays",
     "values": { "c++17": 201611 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_shared_ptr_weak_type",
     "values": { "c++17": 201606 },
     "headers": ["memory"],
   }, {
     "name": "__cpp_lib_shared_timed_mutex",
     "values": { "c++14": 201402 },
     "headers": ["shared_mutex"],
-    "depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)",
-    "internal_depends": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)",
+    "test_suite_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)",
+    "libcxx_guard": "!defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_shared_timed_mutex)",
   }, {
     "name": "__cpp_lib_shift",
     "values": { "c++20": 201806 },
     "headers": ["algorithm"],
   }, {
     "name": "__cpp_lib_smart_ptr_for_overwrite",
     "values": { "c++20": 202002 },
     "headers": ["memory"],
feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_void_t",
     "values": { "c++17": 201411 },
     "headers": ["type_traits"],
   }
 ]]
 
 assert feature_test_macros == sorted(feature_test_macros, key=lambda tc: tc["name"])
 assert all(tc["headers"] == sorted(tc["headers"]) for tc in feature_test_macros)
+assert all(("libcxx_guard" in tc) == ("test_suite_guard" in tc) for tc in feature_test_macros)
+assert all(all(key in ["name", "values", "headers", "libcxx_guard", "test_suite_guard", "unimplemented"] for key in tc.keys()) for tc in feature_test_macros)
 
 # Map from each header to the Lit annotations that should be used for
 # tests that include that header.
 #
 # For example, when threads are not supported, any feature-test-macro test
 # that includes <thread> should be marked as UNSUPPORTED, because including
 # <thread> is a hard error in that case.
 lit_markup = {

 
 def produce_macros_definition_for_std(std):
   result = ""
   indent = 55
   for tc in feature_test_macros:
     if std not in tc["values"]:
       continue
     inner_indent = 1
-    if 'depends' in tc.keys():
-      assert 'internal_depends' in tc.keys()
-      result += "# if %s\n" % tc["internal_depends"]
+    if 'test_suite_guard' in tc.keys():
+      result += "# if %s\n" % tc["libcxx_guard"]
       inner_indent += 2
     if get_value_before(tc["values"], std) is not None:
-      assert 'depends' not in tc.keys()
+      assert 'test_suite_guard' not in tc.keys()
       result += "# undef  %s\n" % tc["name"]
     line = "#%sdefine %s" % ((" " * inner_indent), tc["name"])
     line += " " * (indent - len(line))
     line += " %sL" % tc["values"][std]
     if 'unimplemented' in tc.keys():
       line = "// " + line
     result += line
     result += "\n"
-    if 'depends' in tc.keys():
+    if 'test_suite_guard' in tc.keys():
       result += "# endif\n"
   return result.strip()
 
 def produce_macros_definitions():
   macro_definition_template = """#if _LIBCPP_STD_VER > {previous_std_number}
 {macro_definition}
 #endif"""
 

 
 test_types = {
   "undefined": """
 # ifdef {name}
 #   error "{name} should not be defined before {std_first}"
 # endif
 """,
 
-  "depends": """
-# if {depends}
+  "test_suite_guard": """
+# if {test_suite_guard}
 #   ifndef {name}
 #     error "{name} should be defined in {std}"
 #   endif
 #   if {name} != {value}
 #     error "{name} should have the value {value} in {std}"
 #   endif
 # else
 #   ifdef {name}
-#     error "{name} should not be defined when {depends} is not defined!"
+#     error "{name} should not be defined when {test_suite_guard} is not defined!"
 #   endif
 # endif
 """,
 
   "unimplemented": """
 # if !defined(_LIBCPP_VERSION)
 #   ifndef {name}
 #     error "{name} should be defined in {std}"
def generate_std_test(test_list, std):
   for tc in test_list:
     val = get_for_std(tc["values"], std)
     if val is not None:
       val = "%sL" % val
     if val is None:
       result += test_types["undefined"].format(name=tc["name"], std_first=get_first_std(tc["values"]))
     elif 'unimplemented' in tc.keys():
       result += test_types["unimplemented"].format(name=tc["name"], value=val, std=std)
-    elif "depends" in tc.keys():
-      result += test_types["depends"].format(name=tc["name"], value=val, std=std, depends=tc["depends"])
+    elif "test_suite_guard" in tc.keys():
+      result += test_types["test_suite_guard"].format(name=tc["name"], value=val, std=std, test_suite_guard=tc["test_suite_guard"])
     else:
       result +=  test_types["defined"].format(name=tc["name"], value=val, std=std)
   return result.strip()
 
 def generate_std_tests(test_list):
   std_tests_template = """#if TEST_STD_VER < {first_std_number}
 
 {pre_std_test}