[libc++] Refactor clang-query checks to clang-tidy checks to get less obscure error messages

[philnik]

Summary

Also remove clang-query related code, since it's unused now.

[Mordante]

I like the removal of a dependency, especially since clang-tidy shows better diagnostics.
Some questions and remarks.

libcxx/docs/TestingLibcxx.rst

101

Can we remove clang-query from the Dockerfile too or is it still needed there?

101

I think there are more dependencies for clang-tidy with the plugins, is that correct?

libcxx/include/__memory_resource/monotonic_buffer_resource.h

83 ↗

(On Diff #489398)

Is this intended in this patch? It feels completely unrelated to test refactoring.
If it's not related can you move this to a new review and let this one depend on it?

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

8–10

Not entirely related to this change, but is there any documentation describing how to use this locally.
(I tried in the past and failed, I expect I did something wrong, but couldn't figure out what quickly.)

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

37

I assume this has to to with the list of hasName above. If so let's move the comment there and please elaborate a bit more why these functions are excluded. Just to make sure that it's clear why this is needed.

A question, is std::ranges::__stable_sort also added to this list? Or only names in std:: ?

[philnik]

Address comments

libcxx/docs/TestingLibcxx.rst

101

IIRC clang-query part of the clang-tools package, which I think we still depend on. I might be wrong about that though.

101

Kind-of, depends on how your OS packages things. If the headers and object files are included within the same package, there are no additional dependencies. Added a comment.

libcxx/include/__memory_resource/monotonic_buffer_resource.h

83 ↗

(On Diff #489398)

D141864

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

8–10

No. I can write some short documentation, but I don't know how much help this will actually be, since this can be very environment-specific. I guess we could expand this with problems people had when setting it up, so others have an easier time.

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

37

I'm, not sure what you are referring to with I assume this has to do with the list of hasName above. The functions are excluded because they can't be marked [[gnu::always_inline]] for various reasons.

This check only looks through functions, so ranges::__stable_sort isn't related.

[Mordante]

libcxx/docs/TestingLibcxx.rst

101

It's indeed part of clang-tools and I think there's nothing there we use:
https://packages.debian.org/bullseye/amd64/clang-tools-11/filelist

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

8–10

If you write an initial version I'll test it on Debian and update if needed. I want to use this myself to add some additional checks; also to get a bit of experience with writing my own checks.

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

37

Can you then add a comment like These functions are excluded because they can't be marked [[gnu::always_inline]].
What happens when std::ranges::__stable_sort is a function? I forgot it was a cpo

[philnik]

Address comments

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

37

It would also be ignored: https://godbolt.org/z/YPdY6WqP7

[njames93]

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

26–36

Can you not use the hasAnyName matcher here instead?

[philnik]

Address comments

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

26–36

Thanks, I wasn't aware of that matcher.

[Mordante]

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

37

Then I think it would be better to test against the fully qualified name.

[philnik]

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

37

I don't. Testing against the fully qualified name is a lot harder AFAICT, and we don't have functions with the same name in different namespaces normally, especially the ones listed here. The proper solution would be to hide them from the ABI without having [[gnu::always_inline]] on them. Then we wouldn't have to ignore the functions here and we don't inline everything with GCC.

[ldionne]

I like this!

[Mordante]

LGTM modulo one comment.

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

37

Can you add that information to the comment. I still prefer FQN, but if that's hard let's document it.

libcxx/docs/TestingLibcxx.rst

.. code-block:: bash
      $ <build>/bin/llvm-lit -sv libcxx/test # will use your custom config file
 
 Additional tools
 ----------------
 
 The libc++ test suite uses a few optional tools to improve the code quality.
 
 These tools are:
-- clang-query
-- clang-tidy
+- clang-tidy (you might need additional dev packages to compile libc++-specific clang-tidy checks)
 
 Writing Tests
 -------------
 
 When writing tests for the libc++ test suite, you should follow a few guidelines.
 This will ensure that your tests can run on a wide variety of hardware and under
 a wide variety of configurations. We have several unusual configurations such as
 building the tests on one host but running them on a different host, which add a

libcxx/include/__memory_resource/unsynchronized_pool_resource.h

public:
 
   [[__gnu__::__pure__]] pool_options options() const;
 
 protected:
   void* do_allocate(size_t __bytes, size_t __align) override; // key function
 
   void do_deallocate(void* __p, size_t __bytes, size_t __align) override;
 
-  _LIBCPP_HIDE_FROM_ABI bool do_is_equal(const memory_resource& __other) const _NOEXCEPT override {
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL bool do_is_equal(const memory_resource& __other) const _NOEXCEPT override {
     return &__other == this;
   }
 
 private:
   memory_resource* __res_;
   __adhoc_pool __adhoc_pool_;
   __fixed_pool* __fixed_pools_;
   int __num_fixed_pools_;

libcxx/test/libcxx/clang_query.sh.cpp

-//===----------------------------------------------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-// Run clang-query on the headers - see clang_query/README.md for more information
-
-// REQUIRES: has-clang-query
-
-// The attributes hide_from_abi_of_visible.query relies on aren't applied on windows.
-// XFAIL: windows
-
-// RUN: %{clang-query} -f %S/clang_query/hide_from_abi_or_visible.query %s --use-color -- -Wno-unknown-warning-option %{compile_flags} -fno-modules > %t.output
-// RUN: cat %t.output
-// RUN: cat %t.output | wc -l | grep -Fxq 1
-
-// RUN: %{clang-query} -f %S/clang_query/abi_tag_on_virtual.query %s --use-color -- -Wno-unknown-warning-option %{compile_flags} -fno-modules > %t.output
-// RUN: cat %t.output
-// RUN: cat %t.output | wc -l | grep -Fxq 1
-
-// Prevent <ext/hash_map> from generating deprecated warnings for this test.
-#if defined(__DEPRECATED)
-#    undef __DEPRECATED
-#endif
-
-/*
-BEGIN-SCRIPT
-
-for header in public_headers:
-  print("{}#{}include <{}>{}".format(
-    '#if ' + header_restrictions[header] + '\n' if header in header_restrictions else '',
-    3 * ' ' if header in header_restrictions else '',
-    header,
-    '\n#endif' if header in header_restrictions else ''
-  ))
-
-END-SCRIPT
-*/
-
-// DO NOT MANUALLY EDIT ANYTHING BETWEEN THE MARKERS BELOW
-// GENERATED-MARKER
-#include <algorithm>
-#include <any>
-#include <array>
-#include <atomic>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <barrier>
-#endif
-#include <bit>
-#include <bitset>
-#include <cassert>
-#include <ccomplex>
-#include <cctype>
-#include <cerrno>
-#include <cfenv>
-#include <cfloat>
-#include <charconv>
-#include <chrono>
-#include <cinttypes>
-#include <ciso646>
-#include <climits>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <clocale>
-#endif
-#include <cmath>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <codecvt>
-#endif
-#include <compare>
-#include <complex>
-#include <complex.h>
-#include <concepts>
-#include <condition_variable>
-#include <coroutine>
-#include <csetjmp>
-#include <csignal>
-#include <cstdarg>
-#include <cstdbool>
-#include <cstddef>
-#include <cstdint>
-#include <cstdio>
-#include <cstdlib>
-#include <cstring>
-#include <ctgmath>
-#include <ctime>
-#include <ctype.h>
-#include <cuchar>
-#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
-#   include <cwchar>
-#endif
-#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
-#   include <cwctype>
-#endif
-#include <deque>
-#include <errno.h>
-#include <exception>
-#include <execution>
-#include <fenv.h>
-#if !defined(_LIBCPP_HAS_NO_FILESYSTEM_LIBRARY)
-#   include <filesystem>
-#endif
-#include <float.h>
-#include <format>
-#include <forward_list>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <fstream>
-#endif
-#include <functional>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <future>
-#endif
-#include <initializer_list>
-#include <inttypes.h>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <iomanip>
-#endif
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <ios>
-#endif
-#include <iosfwd>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <iostream>
-#endif
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <istream>
-#endif
-#include <iterator>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <latch>
-#endif
-#include <limits>
-#include <limits.h>
-#include <list>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <locale>
-#endif
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <locale.h>
-#endif
-#include <map>
-#include <math.h>
-#include <memory>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <mutex>
-#endif
-#include <new>
-#include <numbers>
-#include <numeric>
-#include <optional>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <ostream>
-#endif
-#include <queue>
-#include <random>
-#include <ranges>
-#include <ratio>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <regex>
-#endif
-#include <scoped_allocator>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <semaphore>
-#endif
-#include <set>
-#include <setjmp.h>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <shared_mutex>
-#endif
-#include <span>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <sstream>
-#endif
-#include <stack>
-#if __cplusplus > 202002L && !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <stdatomic.h>
-#endif
-#include <stdbool.h>
-#include <stddef.h>
-#include <stdexcept>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <streambuf>
-#endif
-#include <string>
-#include <string.h>
-#include <string_view>
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
-#   include <strstream>
-#endif
-#include <system_error>
-#include <tgmath.h>
-#if !defined(_LIBCPP_HAS_NO_THREADS)
-#   include <thread>
-#endif
-#include <tuple>
-#include <type_traits>
-#include <typeindex>
-#include <typeinfo>
-#include <uchar.h>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-#include <valarray>
-#include <variant>
-#include <vector>
-#include <version>
-#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
-#   include <wchar.h>
-#endif
-#if !defined(_LIBCPP_HAS_NO_WIDE_CHARACTERS)
-#   include <wctype.h>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/algorithm>
-#endif
-#if __cplusplus >= 201103L && !defined(_LIBCPP_HAS_NO_EXPERIMENTAL_COROUTINES)
-#   include <experimental/coroutine>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/deque>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/forward_list>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/functional>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/iterator>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/list>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/map>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/memory_resource>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/propagate_const>
-#endif
-#if !defined(_LIBCPP_HAS_NO_LOCALIZATION) && __cplusplus >= 201103L
-#   include <experimental/regex>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/set>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/simd>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/string>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/type_traits>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/unordered_map>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/unordered_set>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/utility>
-#endif
-#if __cplusplus >= 201103L
-#   include <experimental/vector>
-#endif
-#include <ext/hash_map>
-#include <ext/hash_set>
-// GENERATED-MARKER

libcxx/test/libcxx/clang_query/README.md

-
-This directory contains [AST matchers](https://clang.llvm.org/docs/LibASTMatchers.html) for clang-query.
-These allow us to enforce some rules in the libc++ source code which are hard to enforce through other means,
-like clang-tidy or regex matchers.

libcxx/test/libcxx/clang_query/abi_tag_on_virtual.query

-#===------------------------------------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
-# This clang-query test ensures that we don't place an abi_tag attribute on
-# virtual functions. This can happen by mistakenly applying a macro like
-# _LIBCPP_HIDE_FROM_ABI on a virtual function.
-#
-# The problem is that arm64e pointer authentication extensions use the mangled
-# name of the function to sign the function pointer in the vtable, which means
-# that the ABI tag effectively influences how the pointers are signed.
-#
-# This can lead to PAC failures when passing an object that holds one of these
-# pointers in its vtable across an ABI boundary if the two sides have been compiled
-# with different versions of libc++: one side will sign the pointer using one function
-# mangling (with one ABI tag), and the other side will authenticate the pointer expecting
-# it to have a different mangled name due to the ABI tag being different, which will crash.
-#
-# This test ensures that we don't re-introduce this issue in the code base.
-
-match
-cxxMethodDecl(isVirtual(),
-              hasAttr("attr::AbiTag"),
-              unless(isExpansionInSystemHeader())
-             )

libcxx/test/libcxx/clang_query/hide_from_abi_or_visible.query

-#===------------------------------------------------------------------------===#
-#
-# 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
-#
-#===------------------------------------------------------------------------===#
-
-# Check that all functions in the libc++ headers are either marked with hidden
-# visibility or default visibility
-
-# TODO: enable the check for all functions once we don't force-inline everything with GCC
-match
-functionDecl(
-  unless(
-    anyOf(
-      hasName("__introsort"),
-      hasName("__inplace_merge"),
-      hasName("__libcpp_snprintf_l"),
-      hasName("__libcpp_asprintf_l"),
-      hasName("__libcpp_sscanf_l"),
-      hasName("__tree_sub_invariant"),
-      hasName("__stable_sort_move"),
-      hasName("__stable_sort"),
-      hasName("__stable_partition"),
-      hasName("__lock_first"),
-      hasName("__stable_partition_impl"),
-      hasAttr("attr::Visibility"),
-      hasAttr("attr::AbiTag"),
-      cxxMethodDecl(), # We have explicitly instantiated classes and some of their methods don't have these attributes
-      isDeleted(),
-      isConsteval(),
-      isExpansionInSystemHeader()
-    )
-  ),
-  isDefinition()
-)

libcxx/test/tools/clang_tidy_checks/CMakeLists.txt

 
 # Look for the latest package
 set(CMAKE_FIND_PACKAGE_SORT_ORDER NATURAL)
 set(CMAKE_FIND_PACKAGE_SORT_DIRECTION DEC)
 
 find_package(Clang 16)
 
 set(SOURCES
+    abi_tag_on_virtual.cpp
+    hide_from_abi.cpp
     robust_against_adl.cpp
-    libcpp_module.cpp
     qualify_declval.cpp
-   )
 
+    libcpp_module.cpp
+   )
 
 if(NOT Clang_FOUND)
   message(STATUS "Could not find a suitable version of the Clang development package;
                   custom libc++ clang-tidy checks will not be available.")
   return()
 endif()
 
 message(STATUS "Found system-installed LLVM ${LLVM_PACKAGE_VERSION} with headers in ${LLVM_INCLUDE_DIRS}")

libcxx/test/tools/clang_tidy_checks/abi_tag_on_virtual.hpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+
+namespace libcpp {
+class abi_tag_on_virtual : public clang::tidy::ClangTidyCheck {
+public:
+  abi_tag_on_virtual(llvm::StringRef, clang::tidy::ClangTidyContext*);
+  void registerMatchers(clang::ast_matchers::MatchFinder*) override;
+  void check(const clang::ast_matchers::MatchFinder::MatchResult&) override;
+};
+} // namespace libcpp

libcxx/test/tools/clang_tidy_checks/abi_tag_on_virtual.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+#include "clang-tidy/ClangTidyModuleRegistry.h"
+
+#include "abi_tag_on_virtual.hpp"
+
+// This clang-tidy check ensures that we don't place an abi_tag attribute on
+// virtual functions. This can happen by mistakenly applying a macro like
+// _LIBCPP_HIDE_FROM_ABI on a virtual function.
+//
+// The problem is that arm64e pointer authentication extensions use the mangled
+// name of the function to sign the function pointer in the vtable, which means
+// that the ABI tag effectively influences how the pointers are signed.
+//
+// This can lead to PAC failures when passing an object that holds one of these
+// pointers in its vtable across an ABI boundary if the two sides have been compiled
+// with different versions of libc++: one side will sign the pointer using one function
+// mangling (with one ABI tag), and the other side will authenticate the pointer expecting
+// it to have a different mangled name due to the ABI tag being different, which will crash.
+//
+// This test ensures that we don't re-introduce this issue in the code base.
+
+namespace libcpp {
+abi_tag_on_virtual::abi_tag_on_virtual(llvm::StringRef name, clang::tidy::ClangTidyContext* context)
+    : clang::tidy::ClangTidyCheck(name, context) {}
+
+void abi_tag_on_virtual::registerMatchers(clang::ast_matchers::MatchFinder* finder) {
+  using namespace clang::ast_matchers;
+  finder->addMatcher(cxxMethodDecl(isVirtual(), hasAttr(clang::attr::AbiTag)).bind("abi_tag_on_virtual"), this);
+}
+
+void abi_tag_on_virtual::check(const clang::ast_matchers::MatchFinder::MatchResult& result) {
+  if (const auto* call = result.Nodes.getNodeAs<clang::CXXMethodDecl>("abi_tag_on_virtual"); call != nullptr) {
+    diag(call->getBeginLoc(),
+         "_LIBCPP_HIDE_FROM_ABI should not be used on virtual functions to avoid problems with pointer authentication. "
+         "Use _LIBCPP_HIDE_FROM_ABI_VIRTUAL instead.");
+  }
+}
+} // namespace libcpp

libcxx/test/tools/clang_tidy_checks/hide_from_abi.hpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+
+namespace libcpp {
+class hide_from_abi : public clang::tidy::ClangTidyCheck {
+public:
+  hide_from_abi(llvm::StringRef, clang::tidy::ClangTidyContext*);
+  void registerMatchers(clang::ast_matchers::MatchFinder*) override;
+  void check(const clang::ast_matchers::MatchFinder::MatchResult&) override;
+};
+} // namespace libcpp

libcxx/test/tools/clang_tidy_checks/hide_from_abi.cpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "clang-tidy/ClangTidyCheck.h"
+#include "clang-tidy/ClangTidyModuleRegistry.h"
+
+#include "hide_from_abi.hpp"
+
+namespace libcpp {
+hide_from_abi::hide_from_abi(llvm::StringRef name, clang::tidy::ClangTidyContext* context)
+    : clang::tidy::ClangTidyCheck(name, context) {}
+
+void hide_from_abi::registerMatchers(clang::ast_matchers::MatchFinder* finder) {
+  using namespace clang::ast_matchers;
+  finder->addMatcher(
+      functionDecl(
+          unless(anyOf(
+              // These functions can't be marked `[[gnu::always_inline]]` for various reasons,
+              // so we can't mark them `_LIBCPP_HIDE_FROM_ABI`. These functions are ignored in
+              // all namespaces. Checking the qualified name is a lot harder and these names
+              // should result in very few (if any) false-negatives. This is also just a
+              // temporary work-around until we can mark functions as HIDE_FROM_ABI without
+              // having to add `[[gnu::always_inline]]` with GCC.
+              hasAnyName("__introsort",
+                         "__inplace_merge",
+                         "__libcpp_snprintf_l",
+                         "__libcpp_asprintf_l",
+                         "__libcpp_sscanf_l",
+                         "__tree_sub_invariant",
+                         "__stable_sort_move",
+                         "__stable_sort",
+                         "__stable_partition",
+                         "__lock_first",
+                         "__stable_partition_impl"),
+              hasAttr(clang::attr::Visibility),
+              hasAttr(clang::attr::AbiTag),
+              cxxMethodDecl(), // We have explicitly instantiated classes and some of their methods don't have these attributes
+              isDeleted(),
+              isConsteval())),
+          isDefinition())
+          .bind("missing_hide_from_abi"),
+      this);
+}
+
+void hide_from_abi::check(const clang::ast_matchers::MatchFinder::MatchResult& result) {
+  if (const auto* call = result.Nodes.getNodeAs<clang::FunctionDecl>("missing_hide_from_abi"); call != nullptr) {
+    diag(call->getBeginLoc(), "_LIBCPP_HIDE_FROM_ABI is missing");
+  }
+}
+} // namespace libcpp

libcxx/test/tools/clang_tidy_checks/libcpp_module.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang-tidy/ClangTidyModule.h"
 #include "clang-tidy/ClangTidyModuleRegistry.h"
+
+#include "abi_tag_on_virtual.hpp"
+#include "hide_from_abi.hpp"
 #include "robust_against_adl.hpp"
 #include "qualify_declval.hpp"
 
 namespace {
 class LibcxxTestModule : public clang::tidy::ClangTidyModule {
 public:
   void addCheckFactories(clang::tidy::ClangTidyCheckFactories& check_factories) override {
+    check_factories.registerCheck<libcpp::abi_tag_on_virtual>("libcpp-avoid-abi-tag-on-virtual");
+    check_factories.registerCheck<libcpp::hide_from_abi>("libcpp-hide-from-abi");
     check_factories.registerCheck<libcpp::robust_against_adl_check>("libcpp-robust-against-adl");
     check_factories.registerCheck<libcpp::qualify_declval>("libcpp-qualify-declval");
   }
 };
 } // namespace
 
 clang::tidy::ClangTidyModuleRegistry::Add<LibcxxTestModule> libcpp_module{
     "libcpp-module", "Adds libc++-specific checks."};

libcxx/utils/ci/Dockerfile

 
 # Install llvm-dev and libclang-dev to compile custom clang-tidy checks
 RUN apt-get update && apt-get install -y llvm-$(($LLVM_HEAD_VERSION - 1))-dev     llvm-$(($LLVM_HEAD_VERSION - 2))-dev \
                                      libclang-$(($LLVM_HEAD_VERSION - 1))-dev libclang-$(($LLVM_HEAD_VERSION - 2))-dev
 
 # TODO LLVM16 Don't install llvm-16-dev explicitly
 RUN apt-get update && apt-get install -y llvm-16-dev libclang-16-dev
 
-# Install clang-tools
-RUN apt-get update && apt-get install -y clang-tools-$(($LLVM_HEAD_VERSION - 1)) clang-tools-$LLVM_HEAD_VERSION
-
 # Install the most recent GCC, like clang install the previous version as a transition.
 ENV GCC_LATEST_VERSION=12
 RUN apt-get update && apt install -y gcc-$((GCC_LATEST_VERSION - 1)) g++-$((GCC_LATEST_VERSION - 1))
 RUN apt-get update && apt install -y gcc-$GCC_LATEST_VERSION g++-$GCC_LATEST_VERSION
 
 # Install a recent CMake
 RUN wget https://github.com/Kitware/CMake/releases/download/v3.21.1/cmake-3.21.1-linux-x86_64.sh -O /tmp/install-cmake.sh
 RUN bash /tmp/install-cmake.sh --prefix=/usr --exclude-subdir --skip-license

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
   # and executes bash, but bash then can't find any other common shell
   # utilities. Test executing "bash -c 'bash --version'" to see if bash
   # manages to find binaries to execute.
   Feature(name='executor-has-no-bash',
           when=lambda cfg: runScriptExitCode(cfg, ['%{exec} bash -c \'bash --version\'']) != 0),
   Feature(name='has-clang-tidy',
           when=lambda cfg: _getSuitableClangTidy(cfg) is not None,
           actions=[AddSubstitution('%{clang-tidy}', lambda cfg: _getSuitableClangTidy(cfg))]),
-  Feature(name='has-clang-query',
-          when=lambda cfg: runScriptExitCode(cfg, ['clang-query-15 --version']) == 0,
-          actions=[AddSubstitution('%{clang-query}', 'clang-query-15')]),
 
   Feature(name='apple-clang',                                                                                                      when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}'.format(**compilerMacros(cfg)),                                          when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}.{__clang_minor__}'.format(**compilerMacros(cfg)),                        when=_isAppleClang),
   Feature(name=lambda cfg: 'apple-clang-{__clang_major__}.{__clang_minor__}.{__clang_patchlevel__}'.format(**compilerMacros(cfg)), when=_isAppleClang),
 
   Feature(name='clang',                                                                                                            when=_isClang),
   Feature(name=lambda cfg: 'clang-{__clang_major__}'.format(**compilerMacros(cfg)),                                                when=_isClang),