[libc++][C++20 modules] Tests no locale build.

[Mordante]

Summary

This fixes some missing #ifndef and implements the header restrictions
in the modules script.

Depends on D158192

libcxx/cmake/caches/Generic-no-localization.cmake

+set(LIBCXX_ENABLE_STD_MODULES ON CACHE BOOL "") # TODO MODULES Remove when enabled automatically.
 set(LIBCXX_ENABLE_LOCALIZATION OFF CACHE BOOL "")

libcxx/modules/std/chrono.inc

#if 0
     // [time.zone.link], class time_zone_link
     using std::chrono::time_zone_link;
 
     // [time.format], formatting
     using std::chrono::local_time_format;
 #endif
   } // namespace chrono
 
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
   using std::formatter;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
 
   namespace chrono {
     // using std::chrono::parse;
 
     // calendrical constants
     using std::chrono::last;
 
     using std::chrono::Friday;

libcxx/modules/std/complex.inc

export namespace std {
 
   // [complex.ops], operators
   using std::operator+;
   using std::operator-;
   using std::operator*;
   using std::operator/;
 
   using std::operator==;
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
   using std::operator>>;
   using std::operator<<;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
 
   // [complex.value.ops], values
   using std::imag;
   using std::real;
 
   using std::abs;
   using std::arg;
   using std::norm;

libcxx/modules/std/locale.inc

 // -*- C++ -*-
 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 export namespace std {
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
   // [locale], locale
   using std::has_facet;
   using std::locale;
   using std::use_facet;
 
   // [locale.convenience], convenience interfaces
   using std::isalnum;
   using std::isalpha;
#ifndef _LIBCPP_HAS_NO_LOCALIZATION
   using std::messages_base;
   using std::messages_byname;
 
   // [depr.conversions.buffer]
   using std::wbuffer_convert;
 
   // [depr.conversions.string]
   using std::wstring_convert;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
 } // namespace std

libcxx/modules/std/thread.inc

namespace this_thread {
     using std::this_thread::sleep_for;
     using std::this_thread::sleep_until;
     using std::this_thread::yield;
   } // namespace this_thread
 
   // [thread.thread.id]
   using std::operator==;
   using std::operator<=>;
+#ifndef _LIBCPP_HAS_NO_LOCALIZATION
   using std::operator<<;
+#endif // _LIBCPP_HAS_NO_LOCALIZATION
 
   using std::formatter;
 
   using std::hash;
 } // namespace std

libcxx/test/libcxx/module_std.gen.py

 # not a huge issue.
 
 # RUN: %{python} %s %{libcxx}/utils
 
 import sys
 
 sys.path.append(sys.argv[1])
 from libcxx.header_information import module_headers
+from libcxx.header_information import header_restrictions
 
 BLOCKLIT = (
     ""  # block Lit from interpreting a RUN/XFAIL/etc inside the generation script
 )
 
 # Ignore several declarations found in the includes.
 #
 # Part of these items are bugs other are not yet implemented features.

 // UNSUPPORTED{BLOCKLIT}: gcc
 
 // RUN{BLOCKLIT}: echo -n > %t.all_partitions
 """
 )
 
 # Validate all module parts.
 for header in module_headers:
+    # Some headers cannot be included when a libc++ feature is disabled.
+    # In that case include the header conditionally. The header __config
+    # ensures the libc++ feature macros are available.
+    if header in header_restrictions:
+        include = (
+            f"#include <__config>{nl}"
+            + f"#if {header_restrictions[header]}{nl}"
+            + f"#  include <{header}>{nl}"
+            + f"#endif{nl}"
+        )
+    elif header == "chrono":
+        # When localization is disabled the header string is not included.
+        # When string is included chrono's operator""s is a named declaration
+        #   using std::chrono_literals::operator""s;
+        # else it is a named declaration
+        #   using std::operator""s;
+        # TODO MODULES investigate why
+        include = f"#include <string>{nl}#include <chrono>{nl}"
+    else:
+        include = f"#include <{header}>{nl}"
+
     # Generate a module partition for the header module includes. This
     # makes it possible to verify that all headers export all their
     # named declarations.
-    #
-    # TODO MODULES This needs to take the header restrictions into account.
     print(
         f"// RUN{BLOCKLIT}: echo -e \""
         f"module;{nl}"
-        f"#include <{header}>{nl}"
+        f"{include}"
         f"{nl}"
         f"// Use __libcpp_module_<HEADER> to ensure that modules {nl}"
         f"// are not named as keywords or reserved names.{nl}"
         f"export module std:__libcpp_module_{header};{nl}"
         f'#include \\"%{{module}}/std/{header}.inc\\"{nl}'
         f"\" > %t.{header}.cppm")
 
     # Dump the information as found in the module's cppm file.
if extra_header:
         extra_header = (
             "{"
             "  key: libcpp-header-exportable-declarations.ExtraHeader, "
             f' value: "{extra_header}" '
             "}, "
         )
 
     # Clang-tidy needs a file input
-    print(f'// RUN{BLOCKLIT}: echo "#include <{header}>" > %t.{header}.cpp')
+    print(f'// RUN{BLOCKLIT}: echo -e "' f"{include}" f'" > %t.{header}.cpp')
     print(
         f"// RUN{BLOCKLIT}: %{{clang-tidy}} %t.{header}.cpp "
         "  --checks='-*,libcpp-header-exportable-declarations' "
         "  -config='{CheckOptions: [ "
         f"   {{key: libcpp-header-exportable-declarations.Filename, value: {header}}}, "
         "    {key: libcpp-header-exportable-declarations.FileType, value: Header}, "
         f"   {skip_declarations} {extra_declarations} {extra_header}, "
         "  ]}' "

libcxx/utils/ci/buildkite-pipeline.yml

- label: "No random device"
       timeout_in_minutes: 120
 
     - label: "No locale"
       command: "libcxx/utils/ci/run-buildbot generic-no-localization"
       artifact_paths:
         - "**/test-results.xml"
         - "**/*.abilist"
       env:
-          CC: "clang-${LLVM_HEAD_VERSION}"
-          CXX: "clang++-${LLVM_HEAD_VERSION}"
+          # Note: Modules require and absolute path for clang-scan-deps
+          # https://github.com/llvm/llvm-project/issues/61006
+          CC: "/usr/lib/llvm-${LLVM_HEAD_VERSION}/bin/clang"
+          CXX: "/usr/lib/llvm-${LLVM_HEAD_VERSION}/bin/clang++"
+          CMAKE: "/opt/bin/cmake"
           ENABLE_CLANG_TIDY: "On"
       agents:
         queue: "libcxx-builders"
         os: "linux"
       retry:
         automatic:
           - exit_status: -1  # Agent was lost
             limit: 2