Simplify whether a header is present.

This use the status used for the Standard library modules.

Author: mordante

libcxx/test/libcxx/feature_test_macro/ftm_metadata.sh.py

@@ -21,7 +21,7 @@
 
 class Test(unittest.TestCase):
     def setUp(self):
-        self.ftm = FeatureTestMacros(TEST_DATA)
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
         self.maxDiff = None  # This causes the diff to be printed when the test fails
 
     def test_implementation(self):

libcxx/test/libcxx/feature_test_macro/generate_header_test.sh.py

@@ -23,7 +23,7 @@
 
 class Test(unittest.TestCase):
     def setUp(self):
-        self.ftm = FeatureTestMacros(TEST_DATA)
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
         self.maxDiff = None  # This causes the diff to be printed when the test fails
 
         self.expected = dict(
@@ -299,7 +299,7 @@ def setUp(self):
 
 // clang-format off
 
-#if __has_include(<charconv>)
+#if !defined(_WIN32) && __has_include(<charconv>)
 #  include <charconv>
 #endif
 #include "test_macros.h"

libcxx/test/libcxx/feature_test_macro/implemented_ftms.sh.py

@@ -21,7 +21,7 @@
 
 class Test(unittest.TestCase):
     def setUp(self):
-        self.ftm = FeatureTestMacros(TEST_DATA)
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
         self.maxDiff = None  # This causes the diff to be printed when the test fails
 
     def test_implementation(self):

libcxx/test/libcxx/feature_test_macro/implemented_standard_library_headers.sh.py

@@ -23,7 +23,7 @@ def test_error(data, type, message):
     tmp = sys.argv[2]
     with open(tmp, "w") as file:
         file.write(json.dumps(data))
-    ftm = FeatureTestMacros(tmp)
+    ftm = FeatureTestMacros(tmp, ["charconv"])
     try:
         ftm.implemented_ftms
     except type as error:

libcxx/test/libcxx/feature_test_macro/invalid.sh.py

@@ -21,7 +21,7 @@
 
 class Test(unittest.TestCase):
     def setUp(self):
-        self.ftm = FeatureTestMacros(TEST_DATA)
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
         self.maxDiff = None  # This causes the diff to be printed when the test fails
 
     def test_implementation(self):

libcxx/test/libcxx/feature_test_macro/is_implemented.sh.py

@@ -21,7 +21,7 @@
 
 class Test(unittest.TestCase):
     def setUp(self):
-        self.ftm = FeatureTestMacros(TEST_DATA)
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
         self.maxDiff = None  # This causes the diff to be printed when the test fails
 
     def test_implementation(self):

libcxx/test/libcxx/feature_test_macro/standard_ftms.sh.py

@@ -10,24 +10,35 @@
 
 import sys
 
-sys.path.append(sys.argv[1])
-from generate_feature_test_macro_components import FeatureTestMacros
-
-
-def test(output, expected):
-    assert output == expected, f"expected\n{expected}\n\noutput\n{output}"
-
-
-ftm = FeatureTestMacros(sys.argv[2])
-test(
-    sorted(ftm.standard_library_headers),
-    [
-        "algorithm",
-        "any",
-        "barrier",
-        "charconv",
-        "format",
-        "numeric",
-        "variant",
-    ],
-)
+import unittest
+
+UTILS = sys.argv[1]
+TEST_DATA = sys.argv[2]
+del sys.argv[1:3]
+
+sys.path.append(UTILS)
+from generate_feature_test_macro_components import FeatureTestMacros, Metadata
+
+
+class Test(unittest.TestCase):
+    def setUp(self):
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
+        self.maxDiff = None  # This causes the diff to be printed when the test fails
+
+    def test_implementation(self):
+        self.assertEqual(
+            sorted(self.ftm.standard_library_headers),
+            [
+                "algorithm",
+                "any",
+                "barrier",
+                "charconv",
+                "format",
+                "numeric",
+                "variant",
+            ],
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

libcxx/test/libcxx/feature_test_macro/standard_library_headers.sh.py

@@ -21,7 +21,7 @@
 
 class Test(unittest.TestCase):
     def setUp(self):
-        self.ftm = FeatureTestMacros(TEST_DATA)
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
         self.maxDiff = None  # This causes the diff to be printed when the test fails
 
     def test_implementation(self):

libcxx/test/libcxx/feature_test_macro/std_dialects.sh.py

@@ -21,7 +21,7 @@
 
 class Test(unittest.TestCase):
     def setUp(self):
-        self.ftm = FeatureTestMacros(TEST_DATA)
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
         self.maxDiff = None  # This causes the diff to be printed when the test fails
 
     def test_implementeation(self):

libcxx/test/libcxx/feature_test_macro/version_header.sh.py

@@ -21,7 +21,7 @@
 
 class Test(unittest.TestCase):
     def setUp(self):
-        self.ftm = FeatureTestMacros(TEST_DATA)
+        self.ftm = FeatureTestMacros(TEST_DATA, ["charconv"])
         self.maxDiff = None  # This causes the diff to be printed when the test fails
 
     def test_implementation(self):

libcxx/test/libcxx/feature_test_macro/version_header_implementation.sh.py

@@ -2110,8 +2110,12 @@ def generate_version_header_implementation(
 #include <{header}>\
 """
 
+# On Windows the Windows SDK is on the include path, that means the MSVC STL
+# headers can be found as well, tricking __has_include into thinking that
+# libc++ provides the header. This means the test is also not executed when
+# using this test with MSVC and MSVC STL.
 ftm_header_test_file_include_conditional = """\
-#if __has_include(<{header}>)
+#if !defined(_WIN32) && __has_include(<{header}>)
 #  include <{header}>
 #endif\
 """
@@ -2264,12 +2268,21 @@ class FeatureTestMacros:
 
     # The JSON data structure.
     __data = None
-
-    def __init__(self, filename: str):
+    # The headers not available in libc++.
+    #
+    # This could be detected based on FTM status, however that gives some odd
+    # results. For example, at the moment __cpp_lib_constexpr_cmath is not
+    # implemented, which flags `<cstdlib>` as not implemented. The availablilty
+    # of headers in maintained for the C++ Standard Libarary modules.
+    __unavailable_headers = None
+
+    def __init__(self, filename: str, not_implemented_headers: List[str]):
         """Initializes the class with the JSON data in the file 'filename'."""
         with open(filename) as f:
             self.__data = json.load(f)
 
+        self.__unavailable_headers = set(not_implemented_headers)
+
     @functools.cached_property
     def std_dialects(self) -> List[Std]:
         """Returns the C++ dialects avaiable.
@@ -2321,32 +2334,6 @@ def implemented_ftms(self) -> Dict[Ftm, Dict[Std, Optional[Value]]]:
 
         return get_ftms(self.__data, self.std_dialects, True)
 
-    @functools.cached_property
-    def implemented_standard_library_headers(self) -> Set[str]:
-        """Returns a list of headers that contain at least one paper implemented in libc++.
-
-        When a paper is implemented it means the associated header(s) should exist.
-        """
-
-        result = set()
-        for feature in self.__data:
-            for std in self.std_dialects:
-                if std in feature["values"].keys():
-                    values = feature["values"][std]
-                    assert len(values) > 0, f"{feature['name']}[{std}] has no entries"
-                    for value in values:
-                        papers = list(values[value])
-                        assert (
-                            len(papers) > 0
-                        ), f"{feature['name']}[{std}][{value}] has no entries"
-                        for paper in papers:
-                            if paper["implemented"]:
-                                for header in self.ftm_metadata[feature["name"]].headers:
-                                    result.add(header)
-                                break
-
-        return result
-
 
     def is_implemented(self, ftm: Ftm, std: Std) -> bool:
         """Has the FTM `ftm` been implemented in the dialect `std`?"""
@@ -2523,9 +2510,9 @@ def generate_header_test(self, header: str) -> str:
             lit_markup=self.generate_lit_markup(header),
             header=header,
             include=(
-                ftm_header_test_file_include_unconditional.format(header=header)
-                if header in self.implemented_standard_library_headers
-                else ftm_header_test_file_include_conditional.format(header=header)
+                ftm_header_test_file_include_conditional.format(header=header)
+                if header in self.__unavailable_headers
+                else ftm_header_test_file_include_unconditional.format(header=header)
             ),
             data=
             # FTM block before the first Standard that introduced them.
@@ -2583,7 +2570,7 @@ def main():
         ftm = FeatureTestMacros(
             os.path.join(
                 source_root, "test", "libcxx", "feature_test_macro", "test_data.json"
-            )
+            ), headers_not_available
         )
         version_header_path = os.path.join(include_path, "version")
         with open(version_header_path, "w", newline="\n") as f: