[libc++] Lower clang-tidy pluging build requirements.

[Mordante]

Summary

The clang-tidy plugin is build with the system C++ Standard libary. This
has some issues:

• old versions of Clang do not work with modern libstdc++. This happened in D151814 where Clang 15 failed with libstdc++13.
• not all users have a C++20 capable system libraries. This can happen on Linux distributions. Updating libstdc++ might be quite a hassle for users.

To avoid these issues lower the requirements of the Standard library
with LLVM's general C++ version requirement of C++17.

[Mordante]

libcxx/test/tools/clang_tidy_checks/uglify_attributes.cpp

29–31

Note this transition has been there for multiple weeks so I expect ToT clang users to have a clang 17 that works.

[Mordante]

CI fixes.

[Mordante]

Not sure whether I'll pursue this, for now I move it to GH.

libcxx/docs/TestingLibcxx.rst

 Additional tools
 ----------------
 
 The libc++ test suite uses a few optional tools to improve the code quality.
 
 These tools are:
 - clang-tidy (you might need additional dev packages to compile libc++-specific clang-tidy checks)
 
+These tools are build using the system's default C++ Standard library.
+Therefore this library should meet LLVM's minimum requirement of C++17 support.
+
 Reproducing CI issues locally
 -----------------------------
 
 Libc++ has extensive CI that tests various configurations of the library. The testing for
 all these configurations is located in ``libcxx/utils/ci/run-buildbot``. Most of our
 CI jobs are being run on a Docker image for reproducibility. The definition of this Docker
 image is located in ``libcxx/utils/ci/Dockerfile``. If you are looking to reproduce the
 failure of a specific CI job locally, you should first drop into a Docker container that

libcxx/test/tools/README.md

+# The libc++ tooling
+
+These tools are used for testing libc++. The clang-tidy plugin is build with
+the system's C++ Standard library implementation. This library should match
+LLVM's minimim requirement of C++17 support.

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

if(NOT Clang_FOUND)
   return()
 endif()
 
 set(LLVM_DIR "${LLVM_DIR_SAVE}" CACHE PATH "The directory containing a CMake configuration file for LLVM." FORCE)
 set(Clang_DIR "${Clang_DIR_SAVE}" CACHE PATH "The directory containing a CMake configuration file for Clang." FORCE)
 
 message(STATUS "Found system-installed LLVM ${LLVM_PACKAGE_VERSION} with headers in ${LLVM_INCLUDE_DIRS}")
 
-set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD 17)
 
 # Link only against clangTidy itself, not anything that clangTidy uses; otherwise we run setup code multiple times
 # which results in clang-tidy crashing
 set_target_properties(clangTidy PROPERTIES INTERFACE_LINK_LIBRARIES "")
 # ClangTargets.cmake doesn't set the include paths, so we have to do it
 target_include_directories(clangTidy INTERFACE
                            ${CLANG_INCLUDE_DIRS}
                            ${LLVM_INCLUDE_DIRS}
                           )
 target_compile_options(clangTidy INTERFACE
                        -fno-rtti
                        -fno-sanitize=address,hwaddress,undefined,thread,leak # ignore any sanitizers
                       )
 
 if ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang")
   target_compile_options(clangTidy INTERFACE
                          -fno-sanitize=memory,dataflow
                         )
 endif()
 
 add_library(cxx-tidy MODULE ${SOURCES})
 target_link_libraries(cxx-tidy clangTidy)
 
 set_target_properties(cxx-tidy PROPERTIES
-                      CXX_STANDARD 20
+                      CXX_STANDARD 17
                       CXX_STANDARD_REQUIRED YES
                       CXX_EXTENSIONS NO)
 
 set_target_properties(cxx-tidy PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 set(CMAKE_SHARED_MODULE_SUFFIX_CXX .plugin) # Use a portable suffix to simplify how we can find it from Lit

libcxx/test/tools/clang_tidy_checks/header_exportable_declarations.cpp

if (Options.get("ExtraDeclarations"))
       llvm::errs() << "Modules may not have extra declarations.\n";
     break;
   case header_exportable_declarations::FileType::Unknown:
     llvm::errs() << "No file type is provided.\n";
     break;
   }
 
   std::optional<llvm::StringRef> list = Options.get("SkipDeclarations");
-  // TODO(LLVM-17) Remove clang 15 work-around.
-#if defined(__clang_major__) && __clang_major__ < 16
+#if __cplusplus <= 201703L
   if (list) {
     std::string_view s = *list;
     auto b             = s.begin();
     auto e             = std::find(b, s.end(), ' ');
     while (b != e) {
       decls_.emplace(b, e);
       if (e == s.end())
         break;
       b = e + 1;
       e = std::find(b, s.end(), ' ');
     }
   }
-#else  // defined(__clang_major__) && __clang_major__ < 16
+#else  // __cplusplus <= 201703
   if (list)
     for (auto decl : std::views::split(*list, ' ')) {
       std::string s;
       std::ranges::copy(decl, std::back_inserter(s)); // use range based constructor
       decls_.emplace(std::move(s));
     }
-#endif // defined(__clang_major__) && __clang_major__ < 16
+#endif // __cplusplus <= 201703
 
   list = Options.get("ExtraDeclarations");
-  // TODO(LLVM-17) Remove clang 15 work-around.
-#if defined(__clang_major__) && __clang_major__ < 16
+#if __cplusplus <= 201703
   if (list) {
     std::string_view s = *list;
     auto b             = s.begin();
     auto e             = std::find(b, s.end(), ' ');
     while (b != e) {
-      std::cout << "using " << std::string_view{b, e} << ";\n";
+      std::cout << "using " << std::string{b, e} << ";\n";
       if (e == s.end())
         break;
       b = e + 1;
       e = std::find(b, s.end(), ' ');
     }
   }
-#else  // defined(__clang_major__) && __clang_major__ < 16
+#else  // __cplusplus <= 201703
   if (list)
     for (auto decl : std::views::split(*list, ' '))
       std::cout << "using " << std::string_view{decl.data(), decl.size()} << ";\n";
-#endif // defined(__clang_major__) && __clang_major__ < 16
+#endif // __cplusplus <= 201703
 }
 
 void header_exportable_declarations::registerMatchers(clang::ast_matchers::MatchFinder* finder) {
   // there are no public names in the Standard starting with an underscore, so
   // no need to check the strict rules.
   using namespace clang::ast_matchers;
 
   switch (file_type_) {

 /// \code _LIBCPP_BEGIN_NAMESPACE_STD \endcode
 /// Some examples
 /// * cstddef has bitwise operators for the type \c byte
 /// * exception has equality operators for the type \c exception_ptr
 /// * initializer_list has the functions \c begin and \c end
 static std::string get_qualified_name(const clang::NamedDecl& decl) {
   std::string result = decl.getQualifiedNameAsString();
 
-  if (result.starts_with("std::__1::"))
+  if (result.find("std::__1::") == 0)
     result.erase(5, 5);
 
   return result;
 }
 
 static bool is_viable_declaration(const clang::NamedDecl* decl) {
   // Declarations nested in records are automatically exported with the record itself.
   if (!decl->getDeclContext()->isNamespace())
if (is_reserved_name(name))
       return;
 
     // For modules (std, std.compat) only take the declarations exported from the partitions.
     // Making sure no declatations of headers are compared.
     if (file_type_ == FileType::Module)
       if (clang::Module* M = decl->getOwningModule(); M && M->Kind != clang::Module::ModulePartitionInterface)
         return;
 
-    if (decls_.contains(name))
+    if (decls_.count(name))
       return;
 
     std::cout << "using " << std::string{name} << ";\n";
     decls_.insert(name);
   }
 }
 
 } // namespace libcpp

libcxx/test/tools/clang_tidy_checks/proper_version_checks.cpp

private:
   void check_condition(clang::SourceLocation location, clang::SourceRange condition_range) {
     std::string_view condition = clang::Lexer::getSourceText(
         clang::CharSourceRange::getTokenRange(condition_range),
         preprocessor_.getSourceManager(),
         preprocessor_.getLangOpts());
     if (preprocessor_.getSourceManager().isInMainFile(location))
       return;
 
-    if (condition.starts_with("_LIBCPP_STD_VER") && condition.find(">") != std::string_view::npos &&
+    if (condition.find("_LIBCPP_STD_VER") == 0 && condition.find(">") != std::string_view::npos &&
         condition.find(">=") == std::string_view::npos)
       check_.diag(location, "_LIBCPP_STD_VER >= version should be used instead of _LIBCPP_STD_VER > prev_version");
 
-    else if (condition.starts_with("__cplusplus"))
+    else if (condition.find("__cplusplus") == 0)
       check_.diag(location, "Use _LIBCPP_STD_VER instead of __cplusplus to constrain based on the C++ version");
 
     else if (condition == "_LIBCPP_STD_VER >= 11")
       check_.diag(location, "_LIBCPP_STD_VER >= 11 is always true. Did you mean '#ifndef _LIBCPP_CXX03_LANG'?");
 
-    else if (condition.starts_with("_LIBCPP_STD_VER >= ") &&
-             std::ranges::none_of(std::array{"14", "17", "20", "23", "26"}, [&](auto val) {
-               return condition.find(val) != std::string_view::npos;
-             }))
+    else if (condition.find("_LIBCPP_STD_VER >= ") == 0) {
+      std::array a{"14", "17", "20", "23", "26"};
+      if (std ::none_of(a.begin(), a.end(), [&](auto val) { return condition.find(val) != std::string_view::npos; }))
         check_.diag(location, "Not a valid value for _LIBCPP_STD_VER. Use 14, 17, 20, 23, or 26");
     }
+  }
 
   clang::Preprocessor& preprocessor_;
   clang::tidy::ClangTidyCheck& check_;
 };
 } // namespace
 
 proper_version_checks::proper_version_checks(llvm::StringRef name, clang::tidy::ClangTidyContext* context)
     : clang::tidy::ClangTidyCheck(name, context) {}

libcxx/test/tools/clang_tidy_checks/robust_against_adl.cpp

 #include <algorithm>
 
 namespace {
 AST_MATCHER(clang::UnresolvedLookupExpr, requiresADL) { return Node.requiresADL(); }
 
 AST_MATCHER(clang::CallExpr, isOperator) { return llvm::isa<clang::CXXOperatorCallExpr>(Node); }
 
 AST_MATCHER(clang::UnresolvedLookupExpr, isCustomizationPoint) {
-  return std::ranges::any_of(
-      std::array{"swap", "make_error_code", "make_error_condition", "begin", "end", "size", "rend", "rbegin"},
-      [&](const char* func) { return Node.getName().getAsString() == func; });
+  std::array a{"swap", "make_error_code", "make_error_condition", "begin", "end", "size", "rend", "rbegin"};
+  return std::any_of(a.begin(), a.end(), [&](const char* func) { return Node.getName().getAsString() == func; });
 }
 
 AST_MATCHER(clang::CXXMethodDecl, isStatic) { return Node.isStatic(); }
 
 } // namespace
 
 namespace libcpp {
 robust_against_adl_check::robust_against_adl_check(llvm::StringRef name, clang::tidy::ClangTidyContext* context)

libcxx/test/tools/clang_tidy_checks/uglify_attributes.cpp

 bool isUgly(std::string_view str) {
   if (str.size() < 2)
     return false;
   if (str[0] == '_' && str[1] >= 'A' && str[1] <= 'Z')
     return true;
   return str.find("__") != std::string_view::npos;
 }
 
-// Starting with Clang 17 ToT C++23 support is provided by CPlusPlus23 instead
-// of C++23 support is provided by CPlusPlus2b. To allow a smooth transition for
-// libc++ use "reflection" to select the proper member. Since the change
-// happens in the development cycle it's not possible to use #ifdefs.
 template <class T>
-bool CPlusPlus23(const T& lang_opts)
-  requires requires { T::CPlusPlus2b; }
-{
-  return lang_opts.CPlusPlus2b;
-}
-
-template <class T>
-bool CPlusPlus23(const T& lang_opts)
-  requires requires { T::CPlusPlus23; }
-{
+bool CPlusPlus23(const T& lang_opts) {
   return lang_opts.CPlusPlus23;
 }
 
 std::vector<const char*> get_standard_attributes(const clang::LangOptions& lang_opts) {
   std::vector<const char*> attributes = {"noreturn", "carries_dependency"};
 
   if (lang_opts.CPlusPlus14)
     attributes.emplace_back("deprecated");