[clang-tidy] Rename cert-mem57-cpp to bugprone-default-operator-new-on-overaligned-type

clang-tools-extra/clang-tidy/bugprone/BugproneTidyModule.cpp

@@ -24,6 +24,7 @@
 #include "CopyConstructorInitCheck.h"
 #include "CrtpConstructorAccessibilityCheck.h"
 #include "DanglingHandleCheck.h"
+#include "DefaultOperatorNewOnOveralignedTypeCheck.h"
 #include "DerivedMethodShadowingBaseMethodCheck.h"
 #include "DynamicStaticInitializersCheck.h"
 #include "EasilySwappableParametersCheck.h"
@@ -139,6 +140,8 @@ class BugproneModule : public ClangTidyModule {
  "bugprone-copy-constructor-init");
  CheckFactories.registerCheck<DanglingHandleCheck>(
  "bugprone-dangling-handle");
+ CheckFactories.registerCheck<DefaultOperatorNewOnOveralignedTypeCheck>(
+ "bugprone-default-operator-new-on-overaligned-type");
  CheckFactories.registerCheck<DerivedMethodShadowingBaseMethodCheck>(
  "bugprone-derived-method-shadowing-base-method");
  CheckFactories.registerCheck<DynamicStaticInitializersCheck>(

clang-tools-extra/clang-tidy/bugprone/CMakeLists.txt

@@ -20,6 +20,7 @@ add_clang_library(clangTidyBugproneModule STATIC
  CopyConstructorInitCheck.cpp
  CrtpConstructorAccessibilityCheck.cpp
  DanglingHandleCheck.cpp
+ DefaultOperatorNewOnOveralignedTypeCheck.cpp
  DerivedMethodShadowingBaseMethodCheck.cpp
  DynamicStaticInitializersCheck.cpp
  EasilySwappableParametersCheck.cpp

clang-tools-extra/clang-tidy/cert/DefaultOperatorNewAlignmentCheck.cpp → clang-tools-extra/clang-tidy/bugprone/DefaultOperatorNewOnOveralignedTypeCheck.cpp

@@ -6,21 +6,22 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "DefaultOperatorNewAlignmentCheck.h"
+#include "DefaultOperatorNewOnOveralignedTypeCheck.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/TargetInfo.h"
 
 using namespace clang::ast_matchers;
 
-namespace clang::tidy::cert {
+namespace clang::tidy::bugprone {
 
-void DefaultOperatorNewAlignmentCheck::registerMatchers(MatchFinder *Finder) {
+void DefaultOperatorNewOnOveralignedTypeCheck::registerMatchers(
+ MatchFinder *Finder) {
  Finder->addMatcher(
  cxxNewExpr(unless(hasAnyPlacementArg(anything()))).bind("new"), this);
 }
 
-void DefaultOperatorNewAlignmentCheck::check(
+void DefaultOperatorNewOnOveralignedTypeCheck::check(
  const MatchFinder::MatchResult &Result) {
  // Get the found 'new' expression.
  const auto *NewExpr = Result.Nodes.getNodeAs<CXXNewExpr>("new");
@@ -61,4 +62,4 @@ void DefaultOperatorNewAlignmentCheck::check(
  << (SpecifiedAlignment / CharWidth);
 }
 
-} // namespace clang::tidy::cert
+} // namespace clang::tidy::bugprone

clang-tools-extra/clang-tidy/cert/DefaultOperatorNewAlignmentCheck.h → clang-tools-extra/clang-tidy/bugprone/DefaultOperatorNewOnOveralignedTypeCheck.h

@@ -6,21 +6,22 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DEFAULTOPERATORNEWALIGNMENTCHECK_H
-#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DEFAULTOPERATORNEWALIGNMENTCHECK_H
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DEFAULTOPERATORNEWONOVERALIGNEDTYPECHECK_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DEFAULTOPERATORNEWONOVERALIGNEDTYPECHECK_H
 
 #include "../ClangTidyCheck.h"
 
-namespace clang::tidy::cert {
+namespace clang::tidy::bugprone {
 
 /// Checks if an object of type with extended alignment is allocated by using
 /// the default operator new.
 ///
 /// For the user-facing documentation see:
-/// https://clang.llvm.org/extra/clang-tidy/checks/cert/mem57-cpp.html
-class DefaultOperatorNewAlignmentCheck : public ClangTidyCheck {
+/// https://clang.llvm.org/extra/clang-tidy/checks/bugprone/bugprone-default-operator-new-on-overaligned-type.html
+class DefaultOperatorNewOnOveralignedTypeCheck : public ClangTidyCheck {
 public:
- DefaultOperatorNewAlignmentCheck(StringRef Name, ClangTidyContext *Context)
+ DefaultOperatorNewOnOveralignedTypeCheck(StringRef Name,
+ ClangTidyContext *Context)
  : ClangTidyCheck(Name, Context) {}
  bool isLanguageVersionSupported(const LangOptions &LangOpts) const override {
  return !LangOpts.CPlusPlus17;
@@ -29,6 +30,6 @@ class DefaultOperatorNewAlignmentCheck : public ClangTidyCheck {
  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
 };
 
-} // namespace clang::tidy::cert
+} // namespace clang::tidy::bugprone
 
-#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_CERT_DEFAULTOPERATORNEWALIGNMENTCHECK_H
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_DEFAULTOPERATORNEWONOVERALIGNEDTYPECHECK_H

clang-tools-extra/clang-tidy/cert/CERTTidyModule.cpp

@@ -11,6 +11,7 @@
 #include "../ClangTidyModuleRegistry.h"
 #include "../bugprone/BadSignalToKillThreadCheck.h"
 #include "../bugprone/CommandProcessorCheck.h"
+#include "../bugprone/DefaultOperatorNewOnOveralignedTypeCheck.h"
 #include "../bugprone/PointerArithmeticOnPolymorphicObjectCheck.h"
 #include "../bugprone/ReservedIdentifierCheck.h"
 #include "../bugprone/SignalHandlerCheck.h"
@@ -34,7 +35,6 @@
 #include "../performance/MoveConstructorInitCheck.h"
 #include "../readability/EnumInitialValueCheck.h"
 #include "../readability/UppercaseLiteralSuffixCheck.h"
-#include "DefaultOperatorNewAlignmentCheck.h"
 #include "DontModifyStdNamespaceCheck.h"
 #include "FloatLoopCounter.h"
 #include "LimitedRandomnessCheck.h"
@@ -265,8 +265,9 @@ class CERTModule : public ClangTidyModule {
  CheckFactories.registerCheck<misc::ThrowByValueCatchByReferenceCheck>(
  "cert-err61-cpp");
  // MEM
- CheckFactories.registerCheck<DefaultOperatorNewAlignmentCheck>(
- "cert-mem57-cpp");
+ CheckFactories
+ .registerCheck<bugprone::DefaultOperatorNewOnOveralignedTypeCheck>(
+ "cert-mem57-cpp");
  // MSC
  CheckFactories.registerCheck<LimitedRandomnessCheck>("cert-msc50-cpp");
  CheckFactories.registerCheck<ProperlySeededRandomGeneratorCheck>(

clang-tools-extra/clang-tidy/cert/CMakeLists.txt

@@ -5,7 +5,6 @@ set(LLVM_LINK_COMPONENTS
 
 add_clang_library(clangTidyCERTModule STATIC
  CERTTidyModule.cpp
- DefaultOperatorNewAlignmentCheck.cpp
  DontModifyStdNamespaceCheck.cpp
  FloatLoopCounter.cpp
  LimitedRandomnessCheck.cpp

clang-tools-extra/docs/ReleaseNotes.rst

@@ -254,6 +254,11 @@ New check aliases
  <clang-tidy/checks/bugprone/throwing-static-initialization>`
  keeping initial check as an alias to the new one.
 
+- Renamed :doc:`cert-mem57-cpp <clang-tidy/checks/cert/mem57-cpp>` to
+ :doc:`bugprone-default-operator-new-on-overaligned-type
+ <clang-tidy/checks/bugprone/default-operator-new-on-overaligned-type>`
+ keeping initial check as an alias to the new one.
+
 Changes in existing checks
 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
@@ -352,7 +357,7 @@ Changes in existing checks
 
 - Improved :doc:`misc-const-correctness
  <clang-tidy/checks/misc/const-correctness>` check to avoid false
- positives when pointers is transferred to non-const references 
+ positives when pointers is transferred to non-const references
  and avoid false positives of function pointer and fix false
  positives on return of non-const pointer.
 

clang-tools-extra/docs/clang-tidy/checks/bugprone/default-operator-new-on-overaligned-type.rst

@@ -0,0 +1,19 @@
+.. title:: clang-tidy - bugprone-default-operator-new-on-overaligned-type
+
+bugprone-default-operator-new-on-overaligned-type
+=================================================
+
+This check flags uses of default ``operator new`` where the type has extended
+alignment (an alignment greater than the fundamental alignment). (The default
+``operator new`` is guaranteed to provide the correct alignment if the
+requested alignment is less or equal to the fundamental alignment).
+Only cases are detected (by design) where the ``operator new`` is not
+user-defined and is not a placement new (the reason is that in these cases we
+assume that the user provided the correct memory allocation).
+
+References
+----------
+
+This check corresponds to the CERT C++ Coding Standard rule
+`MEM57-CPP. Avoid using default operator new for over-aligned types
+<https://wiki.sei.cmu.edu/confluence/display/cplusplus/MEM57-CPP.+Avoid+using+default+operator+new+for+over-aligned+types>`_.

clang-tools-extra/docs/clang-tidy/checks/cert/mem57-cpp.rst

@@ -3,13 +3,9 @@
 cert-mem57-cpp
 ==============
 
-This check flags uses of default ``operator new`` where the type has extended
-alignment (an alignment greater than the fundamental alignment). (The default
-``operator new`` is guaranteed to provide the correct alignment if the
-requested alignment is less or equal to the fundamental alignment).
-Only cases are detected (by design) where the ``operator new`` is not
-user-defined and is not a placement new (the reason is that in these cases we
-assume that the user provided the correct memory allocation).
+The `cert-mem57-cpp` is an aliaes, please see
+`bugprone-default-operator-new-on-overaligned-type <../bugprone/default-operator-new-on-overaligned-type>`_
+for more information.
 
 This check corresponds to the CERT C++ Coding Standard rule
 `MEM57-CPP. Avoid using default operator new for over-aligned types

clang-tools-extra/docs/clang-tidy/checks/list.rst

@@ -93,6 +93,7 @@ Clang-Tidy Checks
  :doc:`bugprone-crtp-constructor-accessibility <bugprone/crtp-constructor-accessibility>`, "Yes"
  :doc:`bugprone-dangling-handle <bugprone/dangling-handle>`,
  :doc:`bugprone-derived-method-shadowing-base-method <bugprone/derived-method-shadowing-base-method>`,
+ :doc:`bugprone-default-operator-new-on-overaligned-type <bugprone/default-operator-new-on-overaligned-type>`,
  :doc:`bugprone-dynamic-static-initializers <bugprone/dynamic-static-initializers>`,
  :doc:`bugprone-easily-swappable-parameters <bugprone/easily-swappable-parameters>`,
  :doc:`bugprone-empty-catch <bugprone/empty-catch>`,
@@ -177,7 +178,6 @@ Clang-Tidy Checks
  :doc:`cert-err33-c <cert/err33-c>`,
  :doc:`cert-err60-cpp <cert/err60-cpp>`,
  :doc:`cert-flp30-c <cert/flp30-c>`,
- :doc:`cert-mem57-cpp <cert/mem57-cpp>`,
  :doc:`cert-msc50-cpp <cert/msc50-cpp>`,
  :doc:`cert-msc51-cpp <cert/msc51-cpp>`,
  :doc:`cert-oop57-cpp <cert/oop57-cpp>`,
@@ -452,6 +452,7 @@ Check aliases
  :doc:`cert-fio38-c <cert/fio38-c>`, :doc:`misc-non-copyable-objects <misc/non-copyable-objects>`,
  :doc:`cert-flp37-c <cert/flp37-c>`, :doc:`bugprone-suspicious-memory-comparison <bugprone/suspicious-memory-comparison>`,
  :doc:`cert-int09-c <cert/int09-c>`, :doc:`readability-enum-initial-value <readability/enum-initial-value>`, "Yes"
+ :doc:`cert-mem57-cpp <cert/mem57-cpp>`, :doc:`bugprone-default-operator-new-on-overaligned-type <bugprone/default-operator-new-on-overaligned-type>`,
  :doc:`cert-msc24-c <cert/msc24-c>`, :doc:`bugprone-unsafe-functions <bugprone/unsafe-functions>`,
  :doc:`cert-msc30-c <cert/msc30-c>`, :doc:`cert-msc50-cpp <cert/msc50-cpp>`,
  :doc:`cert-msc32-c <cert/msc32-c>`, :doc:`cert-msc51-cpp <cert/msc51-cpp>`,

clang-tools-extra/test/clang-tidy/checkers/bugprone/default-operator-new-on-overaligned-type-cpp17.cpp

@@ -0,0 +1,12 @@
+// RUN: %check_clang_tidy %s -std=c++14 bugprone-default-operator-new-on-overaligned-type %t
+// RUN: clang-tidy -checks='-*,bugprone-default-operator-new-on-overaligned-type' --extra-arg=-Wno-unused-variable --warnings-as-errors='*' %s -- -std=c++17 -faligned-allocation
+// RUN: clang-tidy -checks='-*,bugprone-default-operator-new-on-overaligned-type' --extra-arg=-Wno-unused-variable --warnings-as-errors='*' %s -- -std=c++17 -faligned-allocation
+
+struct alignas(128) Vector {
+ char Elems[128];
+};
+
+void f() {
+ auto *V1 = new Vector; // CHECK-MESSAGES: warning: allocation function returns a pointer with alignment {{[0-9]+}} but the over-aligned type being allocated requires alignment 128 [bugprone-default-operator-new-on-overaligned-type]
+ auto *V1_Arr = new Vector[2]; // CHECK-MESSAGES: warning: allocation function returns a pointer with alignment {{[0-9]+}} but the over-aligned type being allocated requires alignment 128 [bugprone-default-operator-new-on-overaligned-type]
+}

clang-tools-extra/test/clang-tidy/checkers/cert/mem57-cpp.cpp → clang-tools-extra/test/clang-tidy/checkers/bugprone/default-operator-new-on-overaligned-type.cpp

@@ -1,4 +1,4 @@
-// RUN: %check_clang_tidy %s -std=c++14 cert-mem57-cpp %t
+// RUN: %check_clang_tidy %s -std=c++14 bugprone-default-operator-new-on-overaligned-type %t
 
 namespace std {
 typedef __typeof(sizeof(int)) size_t;
@@ -30,10 +30,10 @@ struct alignas(8) Vector4 {
 
 void f() {
  auto *V1 = new Vector1;
- // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: allocation function returns a pointer with alignment {{[0-9]+}} but the over-aligned type being allocated requires alignment 128 [cert-mem57-cpp]
+ // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: allocation function returns a pointer with alignment {{[0-9]+}} but the over-aligned type being allocated requires alignment 128 [bugprone-default-operator-new-on-overaligned-type]
  auto *V2 = new Vector2;
  auto *V3 = new Vector3;
  auto *V4 = new Vector4;
  auto *V1_Arr = new Vector1[2];
- // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: allocation function returns a pointer with alignment {{[0-9]+}} but the over-aligned type being allocated requires alignment 128 [cert-mem57-cpp]
+ // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: allocation function returns a pointer with alignment {{[0-9]+}} but the over-aligned type being allocated requires alignment 128 [bugprone-default-operator-new-on-overaligned-type]
 }