[libc++] Fix modules builds when features are removed

[ldionne]

Summary

When some headers are not available because we removed features like
localization or threads, the compiler should not try to include these
headers when building modules. To avoid that from happening, add a
requires-declaration that is never satisfied when the configuration
in use doesn't support a header.

rdar://93777687

[ldionne]

Remove modules requirement that was incorrectly added during rebase.

[ldionne]

Fix bootstrapping build.

[ldionne]

Rebase to trigger CI -- I can't reproduce the failure locally.

[ldionne]

Poke CI

libcxx/docs/Contributing.rst

 sure you don't forget anything:
 
 - Do you have tests for every public class and/or function you're adding or modifying?
 - Did you update the synopsis of the relevant headers?
 - Did you update the relevant files to track implementation status (in ``docs/Status/``)?
 - Did you mark all functions and type declarations with the :ref:`proper visibility macro <visibility-macros>`?
 - If you added a header:
 
-  - Did you add it to ``include/module.modulemap``?
+  - Did you add it to ``include/module.modulemap.in``?
   - Did you add it to ``include/CMakeLists.txt``?
   - If it's a public header, did you add a test under ``test/libcxx`` that the new header defines ``_LIBCPP_VERSION``? See ``test/libcxx/algorithms/version.pass.cpp`` for an example. NOTE: This should be automated.
   - If it's a public header, did you update ``utils/generate_header_inclusion_tests.py``?
 
 - Did you add the relevant feature test macro(s) for your feature? Did you update the ``generate_feature_test_macro_components.py`` script with it?
 - Did you run the ``libcxx-generate-files`` target and verify its output?
 
 The review process

libcxx/include/CMakeLists.txt

set(files
   limits
   limits.h
   list
   locale
   locale.h
   map
   math.h
   memory
-  module.modulemap
   mutex
   new
   numbers
   numeric
   optional
   ostream
   queue
   random
set(files
   valarray
   variant
   vector
   version
   wchar.h
   wctype.h
   )
 
+foreach(feature LIBCXX_ENABLE_FILESYSTEM LIBCXX_ENABLE_LOCALIZATION LIBCXX_ENABLE_THREADS LIBCXX_ENABLE_WIDE_CHARACTERS)
+  if (NOT ${${feature}})
+    set(requires_${feature} "requires LIBCXX_CONFIGURED_WITHOUT_SUPPORT_FOR_THIS_HEADER")
+  endif()
+endforeach()
+
 configure_file("__config_site.in" "${LIBCXX_GENERATED_INCLUDE_TARGET_DIR}/__config_site" @ONLY)
+configure_file("module.modulemap.in" "${LIBCXX_GENERATED_INCLUDE_DIR}/module.modulemap" @ONLY)
 
-set(_all_includes "${LIBCXX_GENERATED_INCLUDE_TARGET_DIR}/__config_site")
+set(_all_includes "${LIBCXX_GENERATED_INCLUDE_TARGET_DIR}/__config_site"
+                  "${LIBCXX_GENERATED_INCLUDE_DIR}/module.modulemap")
 foreach(f ${files})
   set(src "${CMAKE_CURRENT_SOURCE_DIR}/${f}")
   set(dst "${LIBCXX_GENERATED_INCLUDE_DIR}/${f}")
   add_custom_command(OUTPUT ${dst}
     DEPENDS ${src}
     COMMAND ${CMAKE_COMMAND} -E copy_if_different ${src} ${dst}
     COMMENT "Copying CXX header ${f}")
   list(APPEND _all_includes "${dst}")

libcxx/include/csignal

 int raise(int sig);
 
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
-#include <signal.h>
+
+#if __has_include(<signal.h>)
+# include <signal.h>
+#endif
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 using ::sig_atomic_t _LIBCPP_USING_IF_EXISTS;
 using ::signal _LIBCPP_USING_IF_EXISTS;
 using ::raise _LIBCPP_USING_IF_EXISTS;
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_CSIGNAL

libcxx/include/module.modulemap.in

module depr [extern_c] {
     module inttypes_h {
       header "inttypes.h"
       export stdint_h
       export *
     }
     // <iso646.h> provided by compiler.
     // <limits.h> provided by compiler or C library.
     module locale_h {
+      @requires_LIBCXX_ENABLE_LOCALIZATION@
       header "locale.h"
       export *
     }
     module math_h {
       header "math.h"
       export *
     }
     module setjmp_h {
       header "setjmp.h"
       export *
     }
     module stdatomic_h {
+      @requires_LIBCXX_ENABLE_THREADS@
       requires cplusplus23
       header "stdatomic.h"
       export *
     }
     // FIXME: <stdalign.h> is missing.
     // <signal.h> provided by C library.
     // <stdarg.h> provided by compiler.
     // <stdbool.h> provided by compiler.
module string_h {
       export *
     }
     module uchar_h {
       header "uchar.h"
       export *
     }
     // <time.h> provided by C library.
     module wchar_h {
+      @requires_LIBCXX_ENABLE_WIDE_CHARACTERS@
       // <wchar.h>'s __need_* macros require textual inclusion.
       textual header "wchar.h"
       export *
     }
     module wctype_h {
+      @requires_LIBCXX_ENABLE_WIDE_CHARACTERS@
       header "wctype.h"
       export *
     }
   }
 
   // <complex.h> and <tgmath.h> are not C headers in any real sense, do not
   // allow their use in extern "C" contexts.
   module complex_h {
module ciso646 {
       header "ciso646"
       export *
     }
     module climits {
       header "climits"
       export *
     }
     module clocale {
+      @requires_LIBCXX_ENABLE_LOCALIZATION@
       header "clocale"
       export *
     }
     module cmath {
       header "cmath"
       export *
     }
     module csetjmp {
module ctime {
       header "ctime"
       export *
     }
     module cuchar {
       header "cuchar"
       export *
     }
     module cwchar {
+      @requires_LIBCXX_ENABLE_WIDE_CHARACTERS@
       header "cwchar"
       export depr.stdio_h
       export *
     }
     module cwctype {
+      @requires_LIBCXX_ENABLE_WIDE_CHARACTERS@
       header "cwctype"
       export *
     }
   }
 
   module algorithm {
     header "algorithm"
     export initializer_list
module array {
     export initializer_list
     export *
   }
   module atomic {
     header "atomic"
     export *
   }
   module barrier {
+    @requires_LIBCXX_ENABLE_THREADS@
     header "barrier"
     export *
   }
   module bit {
     header "bit"
     export *
 
     module __bit {
module chrono {
 
     module __chrono {
       module calendar              { private header "__chrono/calendar.h" }
       module convert_to_timespec   { private header "__chrono/convert_to_timespec.h" }
       module day                   { private header "__chrono/day.h" }
       module duration              { private header "__chrono/duration.h" }
       module file_clock            { private header "__chrono/file_clock.h" }
       module hh_mm_ss              { private header "__chrono/hh_mm_ss.h" }
-      module high_resolution_clock { private header "__chrono/high_resolution_clock.h" }
+      module high_resolution_clock {
+        private header "__chrono/high_resolution_clock.h"
+        export steady_clock
+        export system_clock
+      }
       module literals              { private header "__chrono/literals.h" }
       module month                 { private header "__chrono/month.h" }
       module month_weekday         { private header "__chrono/month_weekday.h" }
       module monthday              { private header "__chrono/monthday.h" }
       module steady_clock          { private header "__chrono/steady_clock.h" }
       module system_clock          { private header "__chrono/system_clock.h" }
       module time_point            { private header "__chrono/time_point.h" }
       module weekday               { private header "__chrono/weekday.h" }
       module year                  { private header "__chrono/year.h" }
       module year_month            { private header "__chrono/year_month.h" }
       module year_month_day        { private header "__chrono/year_month_day.h" }
       module year_month_weekday    { private header "__chrono/year_month_weekday.h" }
     }
   }
   module codecvt {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "codecvt"
     export *
   }
   module compare {
     header "compare"
     export *
 
     module __compare {
module exception {
     header "exception"
     export *
   }
   module execution {
     header "execution"
     export *
   }
   module filesystem {
+    @requires_LIBCXX_ENABLE_FILESYSTEM@
     header "filesystem"
     export *
 
     module __filesystem {
       module copy_options                 { private header "__filesystem/copy_options.h" }
       module directory_entry              { private header "__filesystem/directory_entry.h" }
       module directory_iterator           { private header "__filesystem/directory_iterator.h" }
       module directory_options            { private header "__filesystem/directory_options.h" }
module format {
     }
   }
   module forward_list {
     header "forward_list"
     export initializer_list
     export *
   }
   module fstream {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "fstream"
     export *
   }
   module functional {
     header "functional"
     export *
 
     module __functional {
module __functional {
       module reference_wrapper          { private header "__functional/reference_wrapper.h" }
       module unary_function             { private header "__functional/unary_function.h" }
       module unary_negate               { private header "__functional/unary_negate.h" }
       module unwrap_ref                 { private header "__functional/unwrap_ref.h" }
       module weak_result_type           { private header "__functional/weak_result_type.h" }
     }
   }
   module future {
+    @requires_LIBCXX_ENABLE_THREADS@
     header "future"
     export *
   }
   module initializer_list {
     header "initializer_list"
     export *
   }
   module iomanip {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "iomanip"
     export *
   }
   module ios {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "ios"
     export iosfwd
     export *
 
     module __ios {
       module fpos { private header "__ios/fpos.h" }
     }
   }
   module iosfwd {
     header "iosfwd"
     export *
   }
   module iostream {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "iostream"
     export ios
     export streambuf
     export istream
     export ostream
     export *
   }
   module istream {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "istream"
     // FIXME: should re-export ios, streambuf?
     export *
   }
   module iterator {
     header "iterator"
     export *
 
module __iterator {
       module reverse_iterator      { private header "__iterator/reverse_iterator.h" }
       module size                  { private header "__iterator/size.h" }
       module sortable              { private header "__iterator/sortable.h" }
       module unreachable_sentinel  { private header "__iterator/unreachable_sentinel.h" }
       module wrap_iter             { private header "__iterator/wrap_iter.h" }
     }
   }
   module latch {
+    @requires_LIBCXX_ENABLE_THREADS@
     header "latch"
     export *
   }
   module limits {
     header "limits"
     export *
   }
   module list {
     header "list"
     export initializer_list
     export *
   }
   module locale {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "locale"
     export *
   }
   module map {
     header "map"
     export initializer_list
     export *
   }
module __memory {
       module temporary_buffer                { private header "__memory/temporary_buffer.h" }
       module uninitialized_algorithms        { private header "__memory/uninitialized_algorithms.h" }
       module unique_ptr                      { private header "__memory/unique_ptr.h" }
       module uses_allocator                  { private header "__memory/uses_allocator.h" }
       module voidify                         { private header "__memory/voidify.h" }
     }
   }
   module mutex {
+    @requires_LIBCXX_ENABLE_THREADS@
     header "mutex"
     export *
   }
   module new {
     header "new"
     export *
   }
   module numbers {
module __numeric {
       module transform_reduce         { private header "__numeric/transform_reduce.h" }
     }
   }
   module optional {
     header "optional"
     export *
   }
   module ostream {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "ostream"
     // FIXME: should re-export ios, streambuf?
     export *
   }
   module queue {
     header "queue"
     export initializer_list
     export *
module __ranges {
       module zip_view               { private header "__ranges/zip_view.h" }
     }
   }
   module ratio {
     header "ratio"
     export *
   }
   module regex {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "regex"
     export initializer_list
     export *
   }
   module scoped_allocator {
     header "scoped_allocator"
     export *
   }
   module semaphore {
+    @requires_LIBCXX_ENABLE_THREADS@
     header "semaphore"
     export *
   }
   module set {
     header "set"
     export initializer_list
     export *
   }
   module shared_mutex {
+    @requires_LIBCXX_ENABLE_THREADS@
     header "shared_mutex"
     export version
   }
   module span {
     header "span"
     export ranges.__ranges.enable_borrowed_range
     export version
     module span_fwd { private header "__fwd/span.h" }
   }
   module sstream {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "sstream"
     // FIXME: should re-export istream, ostream, ios, streambuf, string?
     export *
   }
   module stack {
     header "stack"
     export initializer_list
     export *
   }
   module stdexcept {
     header "stdexcept"
     export *
   }
   module streambuf {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "streambuf"
     export *
   }
   module string {
     header "string"
     export initializer_list
     export string_view
     export __string
     export *
   }
   module string_view {
     header "string_view"
     export initializer_list
     export __string
     export *
     module string_view_fwd { private header "__fwd/string_view.h" }
   }
   module strstream {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
     header "strstream"
     export *
   }
   module system_error {
     header "system_error"
     export *
   }
   module thread {
+    @requires_LIBCXX_ENABLE_THREADS@
     header "thread"
     export *
 
     module __thread {
       module poll_with_backoff    { private header "__thread/poll_with_backoff.h" }
       module timed_backoff_policy { private header "__thread/timed_backoff_policy.h" }
     }
   }
module vector {
     export initializer_list
     export *
   }
   module version {
     header "version"
     export *
   }
 
-  // __config not modularised due to a bug in Clang
   // FIXME: These should be private.
   module __assert            {         header "__assert"            export * }
   module __availability      { private header "__availability"      export * }
   module __bit_reference     { private header "__bit_reference"     export * }
   module __bits              { private header "__bits"              export * }
   module __debug             {         header "__debug"             export * }
   module __errc              { private header "__errc"              export * }
   module __hash_table        {         header "__hash_table"        export * }
-  module __locale            { private header "__locale"            export * }
+  module __locale            {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
+    private header "__locale" export *
+  }
   module __mbstate_t         { private header "__mbstate_t.h"       export * }
   module __mutex_base        { private header "__mutex_base"        export * }
   module __node_handle       { private header "__node_handle"       export * }
   module __split_buffer      { private header "__split_buffer"      export * }
-  module __std_stream        { private header "__std_stream"        export * }
+  module __std_stream        {
+    @requires_LIBCXX_ENABLE_LOCALIZATION@
+    private header "__std_stream" export *
+  }
   module __string            { private header "__string"            export * }
   module __threading_support {         header "__threading_support" export * }
   module __tree              {         header "__tree"              export * }
   module __tuple             { private header "__tuple"             export * }
   module __undef_macros      {         header "__undef_macros"      export * }
 
   module experimental {
     requires cplusplus11
module memory_resource {
       header "experimental/memory_resource"
       export *
     }
     module propagate_const {
       header "experimental/propagate_const"
       export *
     }
     module regex {
+      @requires_LIBCXX_ENABLE_LOCALIZATION@
       header "experimental/regex"
       export *
     }
     module simd {
       header "experimental/simd"
       export *
     }
     module set {

libcxx/test/libcxx/lint/lint_headers.sh.py

 # RUN: %{python} %s
 
 # Verify that each run of consecutive #include directives
 # in each libcxx/include/ header is maintained in alphabetical order.
 
 import glob
 import os
 import re
 
 
 def exclude_from_consideration(path):
     return (
         path.endswith('.txt') or
-        path.endswith('.modulemap') or
+        path.endswith('.modulemap.in') or
         os.path.basename(path) == '__config' or
         os.path.basename(path) == '__config_site.in' or
         not os.path.isfile(path)
     )
 
 
 def check_for_pragma_GCC_system_header(pretty_fname, lines):
     if pretty_fname not in ['__undef_macros']:

libcxx/test/libcxx/lint/lint_modulemap.sh.py

 # RUN: %{python} %s
 
-# Verify that each list of private submodules in libcxx/include/module.modulemap
+# Verify that each list of private submodules in libcxx/include/module.modulemap.in
 # is maintained in alphabetical order.
 
 import os
 import re
 
 
 if __name__ == '__main__':
     libcxx_test_libcxx_lint = os.path.dirname(os.path.abspath(__file__))
     libcxx = os.path.abspath(os.path.join(libcxx_test_libcxx_lint, '../../..'))
-    modulemap_name = os.path.join(libcxx, 'include/module.modulemap')
+    modulemap_name = os.path.join(libcxx, 'include/module.modulemap.in')
     assert os.path.isfile(modulemap_name)
 
     okay = True
     prevline = None
     with open(modulemap_name, 'r') as f:
         for line in f.readlines():
             if re.match(r'^\s*module.*[{]\s*private', line):
                 # Check that these lines are all of the expected format.
                 # This incidentally checks for typos in the module name.
                 if re.match(r'^\s*module (\w+)\s+[{] private header "\1(.h)?"\s+export [*] [}]', line):
                     # It's a top-level private header, such as <__bit_reference>.
                     pass
                 elif re.match(r'^\s*module (\w+)\s+[{] private header "__\w+/\1[.]h" [}]', line):
                     # It's a private submodule, such as <__utility/swap.h>.
                     pass
                 elif re.match(r'^\s*module (\w+)_fwd\s+[{] private header "__fwd/\1[.]h" [}]', line):
                     # It's a private submodule with forward declarations, such as <__fwd/span.h>.
                     pass
                 else:
                     okay = False
-                    print("LINE DOESN'T MATCH REGEX in libcxx/include/module.modulemap!")
+                    print("LINE DOESN'T MATCH REGEX in libcxx/include/module.modulemap.in!")
                     print(line)
                 # Check that these lines are alphabetized.
                 if (prevline is not None) and (line < prevline):
                     okay = False
-                    print('LINES OUT OF ORDER in libcxx/include/module.modulemap!')
+                    print('LINES OUT OF ORDER in libcxx/include/module.modulemap.in!')
                     print(prevline)
                     print(line)
                 prevline = line
             else:
                 prevline = None
     assert okay

libcxx/test/libcxx/modules_include.sh.cpp

 // XFAIL: LIBCXX-AIX-FIXME
 
 // GCC doesn't support -fcxx-modules
 // UNSUPPORTED: gcc
 
 // The Windows headers don't appear to be compatible with modules
 // UNSUPPORTED: windows
 
-// TODO: Some headers produce errors when we include them and the library has been
-//       configured without support for them, which breaks the modules build.
-// UNSUPPORTED: no-localization, no-filesystem, no-threads, no-wide-characters
-
 // Prevent <ext/hash_map> from generating deprecated warnings for this test.
 #if defined(__DEPRECATED)
 #    undef __DEPRECATED
 #endif
 
 #include <__config>
 
 /*

libcxx/utils/generate_header_tests.py

def produce(test_file, variables):
     script = find_script(test_file)
     result = execute_script(script, variables)
     new_content = generate_new_file(test_file, result)
     with open(test_file, 'w', newline='\n') as f:
         f.write(new_content)
 
 def is_header(file):
     """Returns whether the given file is a header (i.e. not a directory or the modulemap file)."""
-    return not file.is_dir() and not file.name == 'module.modulemap'
+    return not file.is_dir() and not file.name == 'module.modulemap.in'
 
 def main():
     monorepo_root = pathlib.Path(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
     include = pathlib.Path(os.path.join(monorepo_root, 'libcxx', 'include'))
     test = pathlib.Path(os.path.join(monorepo_root, 'libcxx', 'test'))
     assert(monorepo_root.exists())
 
     toplevel_headers     = sorted(str(p.relative_to(include)) for p in include.glob('[a-z]*') if is_header(p))

libcxx/utils/libcxx/test/dsl.py

def compilerMacros(config, flags=''):
   The keys are strings representing macros, and the values are strings
   representing what each macro is defined to.
 
   If the optional `flags` argument (a string) is provided, these flags will
   be added to the compiler invocation when generating the macros.
   """
   with _makeConfigTest(config) as test:
     with open(test.getSourcePath(), 'w') as sourceFile:
-      # Make sure files like <__config> are included, since they can define
-      # additional macros.
-      sourceFile.write("#include <stddef.h>")
+      sourceFile.write("""
+      #if __has_include(<__config_site>)
+      #  include <__config_site>
+      #endif
+      """)
     unparsedOutput, err, exitCode, _ = _executeScriptInternal(test, [
       "%{{cxx}} %s -dM -E %{{flags}} %{{compile_flags}} {}".format(flags)
     ])
     if exitCode != 0:
       raise ConfigurationCompilationError("Failed to retrieve compiler macros, stderr is:\n{}".format(err))
     parsedMacros = dict()
     defines = (l.strip() for l in unparsedOutput.split('\n') if l.startswith('#define '))
     for line in defines:

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
   Feature(name='cant-build-shared-library',
           when=lambda cfg: not sourceBuilds(cfg, """
             void f() { new int(3); }
           """, ['-shared'])),
 
   # Check for a Windows UCRT bug (fixed in UCRT/Windows 10.0.20348.0):
   # https://developercommunity.visualstudio.com/t/utf-8-locales-break-ctype-functions-for-wchar-type/1653678
   Feature(name='win32-broken-utf8-wchar-ctype',
-          when=lambda cfg: '_WIN32' in compilerMacros(cfg) and not programSucceeds(cfg, """
+          when=lambda cfg: not '_LIBCPP_HAS_NO_LOCALIZATION' in compilerMacros(cfg) and '_WIN32' in compilerMacros(cfg) and not programSucceeds(cfg, """
             #include <locale.h>
             #include <wctype.h>
             int main(int, char**) {
               setlocale(LC_ALL, "en_US.UTF-8");
               return towlower(L'\\xDA') != L'\\xFA';
             }
           """)),
 
   # Check for a Windows UCRT bug (fixed in UCRT/Windows 10.0.19041.0).
   # https://developercommunity.visualstudio.com/t/printf-formatting-with-g-outputs-too/1660837
   Feature(name='win32-broken-printf-g-precision',
-          when=lambda cfg: '_WIN32' in compilerMacros(cfg) and not programSucceeds(cfg, """
+          when=lambda cfg: not '_LIBCPP_HAS_NO_LOCALIZATION' in compilerMacros(cfg) and '_WIN32' in compilerMacros(cfg) and not programSucceeds(cfg, """
             #include <stdio.h>
             #include <string.h>
             int main(int, char**) {
               char buf[100];
               snprintf(buf, sizeof(buf), "%#.*g", 0, 0.0);
               return strcmp(buf, "0.");
             }
           """)),