[clang-tools-extra] [clang-tidy] add AllowedTypes to misc-const-correctness (PR #122951)
Baranov Victor via cfe-commits
cfe-commits at lists.llvm.org
Tue Jan 14 11:12:41 PST 2025
https://github.com/vbvictor created https://github.com/llvm/llvm-project/pull/122951
This PR add option `AllowedTypes` which allow users to specify types they want to exclude from const-correctness check.
Small real-world example:
```cpp
#include <mutex>
int main() {
std::mutex m;
std::lock_guard<std::mutex> l(m); // we want to ignore it since std::lock_guard is already immutable.
}
```
Closes issue https://github.com/llvm/llvm-project/issues/122592
>From 841cfec5a0ab4ce5ce64e71facfb7becaf4340e8 Mon Sep 17 00:00:00 2001
From: Victor Baranov <bar.victor.2002 at gmail.com>
Date: Tue, 14 Jan 2025 22:05:43 +0300
Subject: [PATCH] [clang-tidy] add AllowedTypes to misc-const-correctness
---
.../clang-tidy/misc/ConstCorrectnessCheck.cpp | 18 +-
.../clang-tidy/misc/ConstCorrectnessCheck.h | 2 +
clang-tools-extra/docs/ReleaseNotes.rst | 5 +
.../checks/misc/const-correctness.rst | 10 +
.../misc/const-correctness-allowed-types.cpp | 180 ++++++++++++++++++
5 files changed, 213 insertions(+), 2 deletions(-)
create mode 100644 clang-tools-extra/test/clang-tidy/checkers/misc/const-correctness-allowed-types.cpp
diff --git a/clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp b/clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp
index 71a4cee4bdc6ef..aee4a3b789863c 100644
--- a/clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp
+++ b/clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.cpp
@@ -8,6 +8,8 @@
#include "ConstCorrectnessCheck.h"
#include "../utils/FixItHintUtils.h"
+#include "../utils/Matchers.h"
+#include "../utils/OptionsUtils.h"
#include "clang/AST/ASTContext.h"
#include "clang/ASTMatchers/ASTMatchFinder.h"
#include "clang/ASTMatchers/ASTMatchers.h"
@@ -41,7 +43,9 @@ ConstCorrectnessCheck::ConstCorrectnessCheck(StringRef Name,
TransformValues(Options.get("TransformValues", true)),
TransformReferences(Options.get("TransformReferences", true)),
TransformPointersAsValues(
- Options.get("TransformPointersAsValues", false)) {
+ Options.get("TransformPointersAsValues", false)),
+ AllowedTypes(
+ utils::options::parseStringList(Options.get("AllowedTypes", ""))) {
if (AnalyzeValues == false && AnalyzeReferences == false)
this->configurationDiag(
"The check 'misc-const-correctness' will not "
@@ -57,6 +61,9 @@ void ConstCorrectnessCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
Options.store(Opts, "TransformValues", TransformValues);
Options.store(Opts, "TransformReferences", TransformReferences);
Options.store(Opts, "TransformPointersAsValues", TransformPointersAsValues);
+
+ Options.store(Opts, "AllowedTypes",
+ utils::options::serializeStringList(AllowedTypes));
}
void ConstCorrectnessCheck::registerMatchers(MatchFinder *Finder) {
@@ -73,6 +80,12 @@ void ConstCorrectnessCheck::registerMatchers(MatchFinder *Finder) {
hasType(referenceType(pointee(hasCanonicalType(templateTypeParmType())))),
hasType(referenceType(pointee(substTemplateTypeParmType()))));
+ const auto AllowedType = hasType(qualType(anyOf(
+ hasDeclaration(namedDecl(matchers::matchesAnyListedName(AllowedTypes))),
+ references(namedDecl(matchers::matchesAnyListedName(AllowedTypes))),
+ pointerType(pointee(hasDeclaration(
+ namedDecl(matchers::matchesAnyListedName(AllowedTypes))))))));
+
const auto AutoTemplateType = varDecl(
anyOf(hasType(autoType()), hasType(referenceType(pointee(autoType()))),
hasType(pointerType(pointee(autoType())))));
@@ -87,7 +100,8 @@ void ConstCorrectnessCheck::registerMatchers(MatchFinder *Finder) {
unless(anyOf(ConstType, ConstReference, TemplateType,
hasInitializer(isInstantiationDependent()), AutoTemplateType,
RValueReference, FunctionPointerRef,
- hasType(cxxRecordDecl(isLambda())), isImplicit())));
+ hasType(cxxRecordDecl(isLambda())), isImplicit(),
+ AllowedType)));
// Match the function scope for which the analysis of all local variables
// shall be run.
diff --git a/clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h b/clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h
index bba060e555d001..3b7aba7c4be384 100644
--- a/clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h
+++ b/clang-tools-extra/clang-tidy/misc/ConstCorrectnessCheck.h
@@ -45,6 +45,8 @@ class ConstCorrectnessCheck : public ClangTidyCheck {
const bool TransformValues;
const bool TransformReferences;
const bool TransformPointersAsValues;
+
+ const std::vector<StringRef> AllowedTypes;
};
} // namespace clang::tidy::misc
diff --git a/clang-tools-extra/docs/ReleaseNotes.rst b/clang-tools-extra/docs/ReleaseNotes.rst
index fa3a8e577a33ad..16be70ca944e95 100644
--- a/clang-tools-extra/docs/ReleaseNotes.rst
+++ b/clang-tools-extra/docs/ReleaseNotes.rst
@@ -260,6 +260,11 @@ Changes in existing checks
<clang-tidy/checks/cppcoreguidelines/pro-type-union-access>` check to
report a location even when the member location is not valid.
+- Improved :doc:`misc-const-correctness
+ <clang-tidy/checks/misc/const-correctness>` check by adding
+ the option ``AllowedTypes``, that excludes specified types
+ from const-correctness checking.
+
- Improved :doc:`misc-definitions-in-headers
<clang-tidy/checks/misc/definitions-in-headers>` check by rewording the
diagnostic note that suggests adding ``inline``.
diff --git a/clang-tools-extra/docs/clang-tidy/checks/misc/const-correctness.rst b/clang-tools-extra/docs/clang-tidy/checks/misc/const-correctness.rst
index 8ac1ad56bc8cf7..201f6252816f04 100644
--- a/clang-tools-extra/docs/clang-tidy/checks/misc/const-correctness.rst
+++ b/clang-tools-extra/docs/clang-tidy/checks/misc/const-correctness.rst
@@ -196,3 +196,13 @@ Options
// The following pointer may not become a 'int *const'.
int *changing_pointee = &value;
changing_pointee = &result;
+
+.. option:: AllowedTypes (default = '')
+
+ A semicolon-separated list of names of types that
+ will be excluded from const-correctness checking.
+ Regular expressions are accepted, e.g. `[Rr]ef(erence)?$` matches every type
+ with suffix `Ref`, `ref`, `Reference` and `reference`.
+ If a name in the list contains the sequence `::` it is matched against
+ the qualified typename (i.e. `namespace::Type`), otherwise it is matched
+ against only the type name (i.e. `Type`).
\ No newline at end of file
diff --git a/clang-tools-extra/test/clang-tidy/checkers/misc/const-correctness-allowed-types.cpp b/clang-tools-extra/test/clang-tidy/checkers/misc/const-correctness-allowed-types.cpp
new file mode 100644
index 00000000000000..a73b4a08d0a711
--- /dev/null
+++ b/clang-tools-extra/test/clang-tidy/checkers/misc/const-correctness-allowed-types.cpp
@@ -0,0 +1,180 @@
+// RUN: %check_clang_tidy %s misc-const-correctness %t -- \
+// RUN: -config="{CheckOptions: {\
+// RUN: misc-const-correctness.AllowedTypes: '[Pp]ointer$;[Pp]tr$;[Rr]ef(erence)?$;qualified::Type;::fully::QualifiedType;ConstTemplate', \
+// RUN: misc-const-correctness.TransformPointersAsValues: true, \
+// RUN: misc-const-correctness.TransformReferences: true, \
+// RUN: misc-const-correctness.WarnPointersAsValues: true } \
+// RUN: }" -- -fno-delayed-template-parsing
+
+struct SmartPointer {
+};
+
+struct smart_pointer {
+};
+
+struct SmartPtr {
+};
+
+struct smart_ptr {
+};
+
+struct SmartReference {
+};
+
+struct smart_reference {
+};
+
+struct SmartRef {
+};
+
+struct smart_ref {
+};
+
+struct OtherType {
+};
+
+template <typename T> struct ConstTemplate {
+};
+
+namespace qualified {
+struct Type {
+};
+} // namespace qualified
+
+namespace fully {
+struct QualifiedType {
+};
+} // namespace fully
+
+void negativeSmartPointer() {
+ SmartPointer p1 = {};
+ SmartPointer* p2 = {};
+ SmartPointer& p3 = p1;
+}
+
+void negative_smart_pointer() {
+ smart_pointer p1 = {};
+ smart_pointer* p2 = {};
+ smart_pointer& p3 = p1;
+}
+
+void negativeSmartPtr() {
+ SmartPtr p1 = {};
+ SmartPtr* p2 = {};
+ SmartPtr& p3 = p1;
+}
+
+void negative_smart_ptr() {
+ smart_ptr p1 = {};
+ smart_ptr* p2 = {};
+ smart_ptr& p3 = p1;
+}
+
+void negativeSmartReference() {
+ SmartReference p1 = {};
+ SmartReference* p2 = {};
+ SmartReference& p3 = p1;
+}
+
+void negative_smart_reference() {
+ smart_reference p1 = {};
+ smart_reference* p2 = {};
+ smart_reference& p3 = p1;
+}
+
+void negativeSmartRef() {
+ SmartRef p1 = {};
+ SmartRef* p2 = {};
+ SmartRef& p3 = p1;
+}
+
+void negative_smart_ref() {
+ smart_ref p1 = {};
+ smart_ref* p2 = {};
+ smart_ref& p3 = p1;
+}
+
+void positiveOtherType() {
+ OtherType t = {};
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 't' of type 'OtherType' can be declared 'const'
+ // CHECK-FIXES: OtherType const t = {};
+}
+
+void negativeSomeComplex() {
+ ConstTemplate<int> t1 = {};
+ ConstTemplate<int>* t2 = {};
+ ConstTemplate<int>& t3 = t1;
+}
+
+void negativeQualified() {
+ qualified::Type t1 = {};
+ qualified::Type* t2 = {};
+ qualified::Type& t3 = t1;
+
+ using qualified::Type;
+ Type t4 = {};
+ Type* t5 = {};
+ Type& t6 = t4;
+}
+
+void negativeFullyQualified() {
+ fully::QualifiedType t1 = {};
+ fully::QualifiedType* t2 = {};
+ fully::QualifiedType& t3 = t1;
+
+ using fully::QualifiedType;
+ QualifiedType t4 = {};
+ QualifiedType* t5 = {};
+ QualifiedType& t6 = t4;
+}
+
+using MySP = SmartPointer;
+using MyTemplate = ConstTemplate<int>;
+template <typename T> using MyTemplate2 = ConstTemplate<T>;
+
+void positiveTypedefs() {
+ MySP p1 = {};
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p1' of type 'MySP' (aka 'SmartPointer') can be declared 'const'
+ // CHECK-FIXES: MySP const p1 = {};
+
+ MySP* p2 = {};
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p2' of type 'MySP *' (aka 'SmartPointer *') can be declared 'const'
+ // CHECK-FIXES: MySP* const p2 = {};
+
+ MySP& p3 = p1;
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'p3' of type 'MySP &' (aka 'SmartPointer &') can be declared 'const'
+ // CHECK-FIXES: MySP const& p3 = p1;
+
+ MyTemplate t1 = {};
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 't1' of type 'MyTemplate' (aka 'ConstTemplate<int>') can be declared 'const'
+ // CHECK-FIXES: MyTemplate const t1 = {};
+
+ MyTemplate* t2 = {};
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 't2' of type 'MyTemplate *' (aka 'ConstTemplate<int> *') can be declared 'const'
+ // CHECK-FIXES: MyTemplate* const t2 = {};
+
+ MyTemplate& t3 = t1;
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 't3' of type 'MyTemplate &' (aka 'ConstTemplate<int> &') can be declared 'const'
+ // CHECK-FIXES: MyTemplate const& t3 = t1;
+
+ MyTemplate2<int> t4 = {};
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 't4' of type 'MyTemplate2<int>' (aka 'ConstTemplate<int>') can be declared 'const'
+ // CHECK-FIXES: MyTemplate2<int> const t4 = {};
+
+ MyTemplate2<int>* t5 = {};
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 't5' of type 'MyTemplate2<int> *' (aka 'ConstTemplate<int> *') can be declared 'const'
+ // CHECK-FIXES: MyTemplate2<int>* const t5 = {};
+
+ MyTemplate2<int>& t6 = t4;
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 't6' of type 'MyTemplate2<int> &' (aka 'ConstTemplate<int> &') can be declared 'const'
+ // CHECK-FIXES: MyTemplate2<int> const& t6 = t4;
+}
+
+template <typename T>
+class Vector {};
+
+void positiveSmartPtrWrapped() {
+ Vector<SmartPtr> vec = {};
+ // CHECK-MESSAGES: [[@LINE-1]]:3: warning: variable 'vec' of type 'Vector<SmartPtr>' can be declared 'const'
+ // CHECK-FIXES: Vector<SmartPtr> const vec = {};
+}
More information about the cfe-commits
mailing list