[libc++] Add a clang-tidy check to make sure we use _Uglyfied attribute names

[ldionne]

libcxx/test/tools/clang_tidy_checks/libcpp_module.cpp

1

It would be nice to run the clang-tidy checks in all the CI jobs that run inside our Docker container.

22–26

Consider sorting alphabetically.

libcxx/include/__config

 #    define _LIBCPP_HAS_NO_CHAR8_T
 #  endif
 
 // Deprecation macros.
 //
 // Deprecations warnings are always enabled, except when users explicitly opt-out
 // by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS.
 #  if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
-#    if __has_attribute(deprecated)
-#      define _LIBCPP_DEPRECATED __attribute__((deprecated))
-#      define _LIBCPP_DEPRECATED_(m) __attribute__((deprecated(m)))
+#    if __has_attribute(__deprecated__)
+#      define _LIBCPP_DEPRECATED __attribute__((__deprecated__))
+#      define _LIBCPP_DEPRECATED_(m) __attribute__((__deprecated__(m)))
 #    elif _LIBCPP_STD_VER > 11
 #      define _LIBCPP_DEPRECATED [[deprecated]]
 #      define _LIBCPP_DEPRECATED_(m) [[deprecated(m)]]
 #    else
 #      define _LIBCPP_DEPRECATED
 #      define _LIBCPP_DEPRECATED_(m)
 #    endif
 #  else

libcxx/include/__memory/shared_ptr.h

 struct __shared_ptr_deleter_ctor_reqs
 {
     static const bool value = __compatible_with<_Tp, _Yp>::value &&
                               is_move_constructible<_Dp>::value &&
                               __well_formed_deleter<_Dp, _Tp*>::value;
 };
 
 #if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI)
-#  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((trivial_abi))
+#  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__))
 #else
 #  define _LIBCPP_SHARED_PTR_TRIVIAL_ABI
 #endif
 
 template<class _Tp>
 class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr
 {
 public:

libcxx/include/__memory/unique_ptr.h

 template <class _Deleter>
 struct __unique_ptr_deleter_sfinae<_Deleter&> {
   typedef _Deleter& __lval_ref_type;
   typedef _Deleter&& __bad_rval_ref_type;
   typedef false_type __enable_rval_overload;
 };
 
 #if defined(_LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI)
-#  define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI __attribute__((trivial_abi))
+#  define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__))
 #else
 #  define _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI
 #endif
 
 template <class _Tp, class _Dp = default_delete<_Tp> >
 class _LIBCPP_UNIQUE_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS unique_ptr {
 public:
   typedef _Tp element_type;

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
     qualify_declval.cpp
+    robust_against_adl.cpp
+    uglify_attributes.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()

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"
+#include "uglify_attributes.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");
+    check_factories.registerCheck<libcpp::uglify_attributes>("libcpp-uglify-attributes");
   }
 };
 } // namespace
 
 clang::tidy::ClangTidyModuleRegistry::Add<LibcxxTestModule> libcpp_module{
     "libcpp-module", "Adds libc++-specific checks."};

libcxx/test/tools/clang_tidy_checks/uglify_attributes.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 uglify_attributes : public clang::tidy::ClangTidyCheck {
+public:
+  uglify_attributes(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/uglify_attributes.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 "uglify_attributes.hpp"
+
+#include <algorithm>
+#include <string_view>
+
+namespace {
+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;
+}
+
+AST_MATCHER(clang::Attr, isPretty) {
+  if (Node.isKeywordAttribute())
+    return false;
+  if (Node.isCXX11Attribute() && !Node.hasScope()) // TODO: reject standard attributes that are version extensions
+    return false;
+  if (Node.hasScope())
+    if (!isUgly(Node.getScopeName()->getName()))
+      return true;
+
+  if (Node.getAttrName())
+    return !isUgly(Node.getAttrName()->getName());
+
+  return false;
+}
+
+std::optional<std::string> getUglyfiedCXX11Attr(const clang::Attr& attr) {
+  // Don't try to fix attributes with `using` in them.
+  if (std::ranges::search(std::string_view(attr.getSpelling()), std::string_view("::")).empty())
+    return std::nullopt;
+
+  std::string attr_string;
+  if (attr.isClangScope())
+    attr_string += "_Clang::";
+  else if (attr.isGNUScope())
+    attr_string += "__gnu__::";
+
+  if (!attr.getAttrName()->getName().starts_with("__")) {
+    attr_string += "__";
+    attr_string += attr.getAttrName()->getName();
+    attr_string += "__";
+  } else {
+    attr_string += attr.getAttrName()->getName();
+  }
+  return std::move(attr_string);
+}
+
+std::optional<std::string> getUglyfiedGNUAttr(const clang::Attr& attr) {
+  return "__" + attr.getAttrName()->getName().str() + "__";
+}
+
+std::optional<std::string> getUglified(const clang::Attr& attr) {
+  if (attr.isCXX11Attribute()) {
+    return getUglyfiedCXX11Attr(attr);
+  } else if (attr.isGNUAttribute()) {
+    return getUglyfiedGNUAttr(attr);
+  }
+
+  return std::nullopt;
+}
+} // namespace
+
+namespace libcpp {
+uglify_attributes::uglify_attributes(llvm::StringRef name, clang::tidy::ClangTidyContext* context)
+    : clang::tidy::ClangTidyCheck(name, context) {}
+
+void uglify_attributes::registerMatchers(clang::ast_matchers::MatchFinder* finder) {
+  using namespace clang::ast_matchers;
+  finder->addMatcher(attr(isPretty()).bind("normal_attribute"), this);
+}
+
+void uglify_attributes::check(const clang::ast_matchers::MatchFinder::MatchResult& result) {
+  if (const auto* call = result.Nodes.getNodeAs<clang::Attr>("normal_attribute"); call != nullptr) {
+    auto diagnostic = diag(call->getLoc(), "Non-standard attributes should use the _Ugly spelling");
+    auto uglified   = getUglified(*call);
+    if (uglified.has_value()) {
+      diagnostic << clang::FixItHint::CreateReplacement(call->getRange(), *uglified);
+    }
+  }
+}
+} // namespace libcpp