https://github.com/stmuench updated
https://github.com/llvm/llvm-project/pull/132924
>From 823475c91f9cdf64c816e9498a42f5ee9b2080be Mon Sep 17 00:00:00 2001
From: stmuench <stmue...@gmx.net>
Date: Tue, 25 Mar 2025 12:38:53 +0100
Subject: [PATCH] [clang-tidy] do not diagn. array types in implicit templ.
instantiations
So far, the clang-tidy check `modernize-avoid-c-arrays` also diagnosed
array types for type template parameters even though no actual array
type got written there but it got deduced to one. In such case, there
is nothing a developer can do at that location to fix the diagnostic.
Since actually, the location where the template got instantiated
would have to be adjusted. And this is in most cases some totally
distant code where implementers of a template do not have access to.
Also adding suppressions to the declaration of the template is not an
option since that would clutter the code unnecessarily and is in many
cases also simply not possible. Hence, we propose to not diagnose any
occurrence of an array type in an implicit instantiation of a template
but rather at the point where template arguments involve array types.
---
.../modernize/AvoidCArraysCheck.cpp | 61 ++++++-
.../checkers/modernize/avoid-c-arrays.cpp | 159 ++++++++++++++++++
2 files changed, 216 insertions(+), 4 deletions(-)
diff --git a/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
b/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
index 0804aa76d953c..7adfcc19bfb99 100644
--- a/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
+++ b/clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp
@@ -39,6 +39,30 @@ AST_MATCHER(clang::ParmVarDecl, isArgvOfMain) {
return FD ? FD->isMain() : false;
}
+bool isWithinImplicitTemplateInstantiation(const TypeLoc *ArrayType,
+ ASTContext *Context) {
+ const auto IsImplicitTemplateInstantiation = [](const auto *Node) {
+ return (Node != nullptr) &&
+ (Node->getTemplateSpecializationKind() ==
TSK_ImplicitInstantiation);
+ };
+
+ auto ParentNodes = Context->getParents(*ArrayType);
+ while (!ParentNodes.empty()) {
+ const auto &ParentNode = ParentNodes[0];
+ if (IsImplicitTemplateInstantiation(
+ ParentNode.template get<clang::CXXRecordDecl>()) ||
+ IsImplicitTemplateInstantiation(
+ ParentNode.template get<clang::FunctionDecl>()) ||
+ IsImplicitTemplateInstantiation(
+ ParentNode.template get<clang::VarDecl>())) {
+ return true;
+ }
+ ParentNodes = Context->getParents(ParentNode);
+ }
+
+ return false;
+}
+
} // namespace
AvoidCArraysCheck::AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context)
@@ -70,18 +94,46 @@ void AvoidCArraysCheck::registerMatchers(MatchFinder
*Finder) {
std::move(IgnoreStringArrayIfNeededMatcher))
.bind("typeloc"),
this);
+
+ // TODO: check allow string arrays in template args
+ Finder->addMatcher(templateArgumentLoc(hasTypeLoc(
+ loc(arrayType()).bind("typeloc_in_template_arg"))),
+ this);
}
void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
- const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
+ clang::TypeLoc ArrayTypeLoc{};
+
+ if (const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
+ ArrayType != nullptr &&
+ not(isWithinImplicitTemplateInstantiation(ArrayType, Result.Context))) {
+ ArrayTypeLoc = *ArrayType;
+ }
+
+ if (const auto *ArrayTypeInTemplateArg =
+ Result.Nodes.getNodeAs<TypeLoc>("typeloc_in_template_arg");
+ ArrayTypeInTemplateArg != nullptr) {
+ if (ArrayTypeInTemplateArg->getSourceRange() !=
+ ArrayTypeInTemplateArg->getLocalSourceRange()) {
+ // only in case the above condition is fulfilled, we matched a written
+ // array type and not a template type parameter which got deduced to one
+ ArrayTypeLoc = *ArrayTypeInTemplateArg;
+ }
+ }
+
+ // check whether the match result is a real array type (based on above
checks)
+ if (ArrayTypeLoc.isNull()) {
+ return;
+ }
+
const bool IsInParam =
Result.Nodes.getNodeAs<ParmVarDecl>("param_decl") != nullptr;
- const bool IsVLA = ArrayType->getTypePtr()->isVariableArrayType();
+ const bool IsVLA = ArrayTypeLoc.getTypePtr()->isVariableArrayType();
enum class RecommendType { Array, Vector, Span };
llvm::SmallVector<const char *> RecommendTypes{};
if (IsVLA) {
RecommendTypes.push_back("'std::vector'");
- } else if (ArrayType->getTypePtr()->isIncompleteArrayType() && IsInParam) {
+ } else if (ArrayTypeLoc.getTypePtr()->isIncompleteArrayType() && IsInParam) {
// in function parameter, we also don't know the size of
// IncompleteArrayType.
if (Result.Context->getLangOpts().CPlusPlus20)
@@ -93,7 +145,8 @@ void AvoidCArraysCheck::check(const MatchFinder::MatchResult
&Result) {
} else {
RecommendTypes.push_back("'std::array'");
}
- diag(ArrayType->getBeginLoc(),
+
+ diag(ArrayTypeLoc.getBeginLoc(),
"do not declare %select{C-style|C VLA}0 arrays, use %1 instead")
<< IsVLA << llvm::join(RecommendTypes, " or ");
}
diff --git
a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
index 14eb2852c639a..0b474cc69db36 100644
--- a/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
+++ b/clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp
@@ -92,3 +92,162 @@ const char name[] = "Some string";
void takeCharArray(const char name[]);
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: do not declare C-style arrays,
use 'std::array' or 'std::vector' instead [modernize-avoid-c-arrays]
+
+namespace std {
+ template<class T, class U>
+ struct is_same { constexpr static bool value{false}; };
+
+ template<class T>
+ struct is_same<T, T> { constexpr static bool value{true}; };
+
+ template<class T, class U>
+ constexpr bool is_same_v = is_same<T, U>::value;
+
+ template<class T> struct remove_const { typedef T type; };
+ template<class T> struct remove_const<const T> { typedef T type; };
+
+ template<class T>
+ using remove_const_t = typename remove_const<T>::type;
+
+ template<bool B, class T = void> struct enable_if {};
+ template<class T> struct enable_if<true, T> { typedef T type; };
+
+ template< bool B, class T = void >
+ using enable_if_t = typename enable_if<B, T>::type;
+}
+
+// below, no array type findings are expected within the template parameter
declarations since no array type gets written explicitly
+template <typename T,
+ bool = std::is_same_v<T, int>,
+ bool = std::is_same<T, int>::value,
+ bool = std::is_same_v<std::remove_const_t<T>, int>,
+ bool = std::is_same<std::remove_const_t<T>, int>::value,
+ bool = std::is_same_v<typename std::remove_const<T>::type, int>,
+ bool = std::is_same<typename std::remove_const<T>::type, int>::value,
+ std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) &&
not(std::is_same_v<typename std::remove_const<T>::type, char>), bool> = true,
+ typename std::enable_if<not(std::is_same_v<std::remove_const_t<T>,
int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>),
bool>::type = true,
+ typename =
std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) &&
not(std::is_same_v<typename std::remove_const<T>::type, char>)>,
+ typename = typename std::remove_const<T>::type,
+ typename = std::remove_const_t<T>>
+class MyClassTemplate {
+ public:
+ // here, plenty of array type findings are expected for below template
parameter declarations since array types get written explicitly
+ template <typename U = T,
+ bool = std::is_same_v<U, int[]>,
+ // CHECK-MESSAGES: :[[@LINE-1]]:38: warning: do not declare
C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ bool = std::is_same<U, int[10]>::value,
+ // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: do not declare
C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ std::enable_if_t<not(std::is_same_v<std::remove_const_t<U>,
int[]>) && not(std::is_same_v<typename std::remove_const<U>::type, char[10]>),
bool> = true,
+ // CHECK-MESSAGES: :[[@LINE-1]]:73: warning: do not declare
C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ // CHECK-MESSAGES: :[[@LINE-2]]:140: warning: do not declare
C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ typename = typename std::remove_const<int[10]>::type,
+ // CHECK-MESSAGES: :[[@LINE-1]]:51: warning: do not declare
C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ typename = std::remove_const_t<int[]>>
+ // CHECK-MESSAGES: :[[@LINE-1]]:44: warning: do not declare
C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ class MyInnerClassTemplate {
+ public:
+ MyInnerClassTemplate(const U&) {}
+ private:
+ U field[3];
+ // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: do not declare C-style
arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ };
+
+ MyClassTemplate(const T&) {}
+
+ private:
+ T field[7];
+ // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+};
+
+// an explicit instantiation
+template
+class MyClassTemplate<int[2]>;
+// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+
+using MyArrayType = int[3];
+// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+
+// another explicit instantiation
+template
+class MyClassTemplate<MyArrayType>;
+
+// below, no array type findings are expected within the template parameter
declarations since no array type gets written explicitly
+template <typename T,
+ bool = std::is_same_v<T, int>,
+ bool = std::is_same<T, int>::value,
+ bool = std::is_same_v<std::remove_const_t<T>, int>,
+ bool = std::is_same<std::remove_const_t<T>, int>::value,
+ bool = std::is_same_v<typename std::remove_const<T>::type, int>,
+ bool = std::is_same<typename std::remove_const<T>::type, int>::value,
+ std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) &&
not(std::is_same_v<typename std::remove_const<T>::type, char>), bool> = true,
+ typename std::enable_if<not(std::is_same_v<std::remove_const_t<T>,
int>) && not(std::is_same_v<typename std::remove_const<T>::type, char>),
bool>::type = true,
+ typename =
std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int>) &&
not(std::is_same_v<typename std::remove_const<T>::type, char>)>,
+ typename = typename std::remove_const<T>::type,
+ typename = std::remove_const_t<T>>
+void func(const T& param) {
+ int array1[1];
+ // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+
+ T array2[2];
+ // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+
+ T value;
+}
+
+// here, plenty of array type findings are expected for below template
parameter declarations since array types get written explicitly
+template <typename T = int[],
+ // CHECK-MESSAGES: :[[@LINE-1]]:24: warning: do not declare C-style
arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ bool = std::is_same_v<T, int[]>,
+ // CHECK-MESSAGES: :[[@LINE-1]]:36: warning: do not declare C-style
arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ bool = std::is_same<T, int[10]>::value,
+ // CHECK-MESSAGES: :[[@LINE-1]]:34: warning: do not declare C-style
arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ std::enable_if_t<not(std::is_same_v<std::remove_const_t<T>, int[]>)
&& not(std::is_same_v<typename std::remove_const<T>::type, char[10]>), bool> =
true,
+ // CHECK-MESSAGES: :[[@LINE-1]]:71: warning: do not declare C-style
arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ // CHECK-MESSAGES: :[[@LINE-2]]:138: warning: do not declare C-style
arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ typename = typename std::remove_const<int[10]>::type,
+ // CHECK-MESSAGES: :[[@LINE-1]]:49: warning: do not declare C-style
arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+ typename = std::remove_const_t<int[]>>
+ // CHECK-MESSAGES: :[[@LINE-1]]:42: warning: do not declare C-style
arrays, use 'std::array' instead [modernize-avoid-c-arrays]
+void fun(const T& param) {
+ int array3[3];
+ // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+
+ T array4[4];
+ // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+
+ T value;
+}
+
+template<typename T>
+T some_constant{};
+
+// explicit instantiation
+template
+int some_constant<int[5]>[5];
+// FIXME: why no diagnostics here?
+
+// explicit specialization
+template<>
+int some_constant<int[7]>[7]{};
+// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use
'std::array' instead [modernize-avoid-c-arrays]
+// CHECK-MESSAGES: :[[@LINE-2]]:19: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+
+void testArrayInTemplateType() {
+ int t[10];
+ // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays,
use 'std::array' instead [modernize-avoid-c-arrays]
+
+ func(t);
+ fun(t);
+
+ func<decltype(t)>({});
+ fun<decltype(t)>({});
+
+ MyClassTemplate var1{t};
+ MyClassTemplate<decltype(t)> var2{{}};
+
+ decltype(var1)::MyInnerClassTemplate var3{t};
+ decltype(var1)::MyInnerClassTemplate<decltype(t)> var4{{}};
+
+ MyClassTemplate<decltype(t)>::MyInnerClassTemplate var5{t};
+ MyClassTemplate<decltype(t)>::MyInnerClassTemplate<decltype(t)> var6{{}};
+}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
