Skip to content

Commit fb9f0c3

Browse files
stmuenchstmuench
committed
[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.
1 parent 7bc16a0 commit fb9f0c3

File tree

4 files changed

+262
-6
lines changed

4 files changed

+262
-6
lines changed

‎clang-tools-extra/clang-tidy/modernize/AvoidCArraysCheck.cpp‎

Lines changed: 54 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -39,6 +39,29 @@ AST_MATCHER(clang::ParmVarDecl, isArgvOfMain) {
3939
return FD ? FD->isMain() : false;
4040
}
4141

42+
AST_MATCHER(clang::TypeLoc, isInImplicitTemplateInstantiation) {
43+
const auto IsImplicitTemplateInstantiation = [](const auto *Node) {
44+
return (Node != nullptr) &&
45+
(Node->getTemplateSpecializationKind() == TSK_ImplicitInstantiation);
46+
};
47+
48+
auto ParentNodes = Finder->getASTContext().getParents(Node);
49+
while (!ParentNodes.empty()) {
50+
const auto &ParentNode = ParentNodes[0];
51+
if (IsImplicitTemplateInstantiation(
52+
ParentNode.template get<clang::CXXRecordDecl>()) ||
53+
IsImplicitTemplateInstantiation(
54+
ParentNode.template get<clang::FunctionDecl>()) ||
55+
IsImplicitTemplateInstantiation(
56+
ParentNode.template get<clang::VarDecl>())) {
57+
return true;
58+
}
59+
ParentNodes = Finder->getASTContext().getParents(ParentNode);
60+
}
61+
62+
return false;
63+
}
64+
4265
} // namespace
4366

4467
AvoidCArraysCheck::AvoidCArraysCheck(StringRef Name, ClangTidyContext *Context)
@@ -66,22 +89,45 @@ void AvoidCArraysCheck::registerMatchers(MatchFinder *Finder) {
6689
hasParent(varDecl(isExternC())),
6790
hasParent(fieldDecl(
6891
hasParent(recordDecl(isExternCContext())))),
69-
hasAncestor(functionDecl(isExternC())))),
92+
hasAncestor(functionDecl(isExternC())),
93+
isInImplicitTemplateInstantiation())),
7094
std::move(IgnoreStringArrayIfNeededMatcher))
7195
.bind("typeloc"),
7296
this);
97+
98+
Finder->addMatcher(templateArgumentLoc(hasTypeLoc(hasType(arrayType())))
99+
.bind("template_arg_with_array_type_loc"),
100+
this);
73101
}
74102

75103
void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
76-
const auto *ArrayType = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
104+
TypeLoc ArrayTypeLoc{};
105+
106+
if (const auto *MatchedTypeLoc = Result.Nodes.getNodeAs<TypeLoc>("typeloc");
107+
MatchedTypeLoc != nullptr) {
108+
ArrayTypeLoc = *MatchedTypeLoc;
109+
}
110+
111+
if (const auto *TemplateArgLoc = Result.Nodes.getNodeAs<TemplateArgumentLoc>(
112+
"template_arg_with_array_type_loc");
113+
TemplateArgLoc != nullptr &&
114+
TemplateArgLoc->getTypeSourceInfo() != nullptr) {
115+
ArrayTypeLoc = TemplateArgLoc->getTypeSourceInfo()->getTypeLoc();
116+
}
117+
118+
// check whether an actual array type got matched (see checks above)
119+
if (ArrayTypeLoc.isNull()) {
120+
return;
121+
}
122+
77123
const bool IsInParam =
78124
Result.Nodes.getNodeAs<ParmVarDecl>("param_decl") != nullptr;
79-
const bool IsVLA = ArrayType->getTypePtr()->isVariableArrayType();
125+
const bool IsVLA = ArrayTypeLoc.getTypePtr()->isVariableArrayType();
80126
enum class RecommendType { Array, Vector, Span };
81127
llvm::SmallVector<const char *> RecommendTypes{};
82128
if (IsVLA) {
83129
RecommendTypes.push_back("'std::vector'");
84-
} else if (ArrayType->getTypePtr()->isIncompleteArrayType() && IsInParam) {
130+
} else if (ArrayTypeLoc.getTypePtr()->isIncompleteArrayType() && IsInParam) {
85131
// in function parameter, we also don't know the size of
86132
// IncompleteArrayType.
87133
if (Result.Context->getLangOpts().CPlusPlus20)
@@ -93,9 +139,11 @@ void AvoidCArraysCheck::check(const MatchFinder::MatchResult &Result) {
93139
} else {
94140
RecommendTypes.push_back("'std::array'");
95141
}
96-
diag(ArrayType->getBeginLoc(),
142+
143+
diag(ArrayTypeLoc.getBeginLoc(),
97144
"do not declare %select{C-style|C VLA}0 arrays, use %1 instead")
98-
<< IsVLA << llvm::join(RecommendTypes, " or ");
145+
<< IsVLA << llvm::join(RecommendTypes, " or ")
146+
<< ArrayTypeLoc.getSourceRange();
99147
}
100148

101149
} // namespace clang::tidy::modernize

‎clang-tools-extra/docs/ReleaseNotes.rst‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -180,6 +180,10 @@ Changes in existing checks
180180
excluding variables with ``thread_local`` storage class specifier from being
181181
matched.
182182

183+
- Improved :doc:`modernize-avoid-c-arrays
184+
<clang-tidy/checks/modernize/avoid-c-arrays>` to not diagnose array types
185+
which are part of an implicit instantiation of a template.
186+
183187
- Improved :doc:`modernize-use-default-member-init
184188
<clang-tidy/checks/modernize/use-default-member-init>` check by matching
185189
``constexpr`` and ``static``` values on member initialization and by detecting

‎clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays-ignores-strings.cpp‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -7,3 +7,15 @@ const char array[] = {'n', 'a', 'm', 'e', '\0'};
77

88
void takeCharArray(const char name[]);
99
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: do not declare C-style arrays, use 'std::array' or 'std::vector' instead [modernize-avoid-c-arrays]
10+
11+
template <typename T = const char[10], typename U = char[10], char[10]>
12+
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
13+
// CHECK-MESSAGES: :[[@LINE-2]]:53: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
14+
// CHECK-MESSAGES: :[[@LINE-3]]:63: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
15+
void func() {}
16+
17+
template <typename T = const char[], typename U = char[], char[]>
18+
// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
19+
// CHECK-MESSAGES: :[[@LINE-2]]:51: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
20+
// CHECK-MESSAGES: :[[@LINE-3]]:59: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
21+
void fun() {}

‎clang-tools-extra/test/clang-tidy/checkers/modernize/avoid-c-arrays.cpp‎

Lines changed: 192 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,14 @@ array<int[4], 2> d;
3232
using k = int[4];
3333
// CHECK-MESSAGES: :[[@LINE-1]]:11: warning: do not declare C-style arrays, use 'std::array' instead
3434

35+
k ak;
36+
// no diagnostic expected here since no concrete c-array type is written here
37+
3538
array<k, 2> dk;
39+
// no diagnostic expected here since no concrete c-array type is written here
40+
41+
array<decltype(ak), 3> ek;
42+
// no diagnostic expected here since no concrete c-array type is written here
3643

3744
template <typename T>
3845
class unique_ptr {
@@ -92,3 +99,188 @@ const char name[] = "Some string";
9299

93100
void takeCharArray(const char name[]);
94101
// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: do not declare C-style arrays, use 'std::array' or 'std::vector' instead [modernize-avoid-c-arrays]
102+
103+
namespace std {
104+
template<class T, class U>
105+
struct is_same { constexpr static bool value{false}; };
106+
107+
template<class T>
108+
struct is_same<T, T> { constexpr static bool value{true}; };
109+
110+
template<class T, class U>
111+
constexpr bool is_same_v = is_same<T, U>::value;
112+
113+
template<class T> struct remove_const { typedef T type; };
114+
template<class T> struct remove_const<const T> { typedef T type; };
115+
116+
template<class T>
117+
using remove_const_t = typename remove_const<T>::type;
118+
119+
template<bool B, class T = void> struct enable_if {};
120+
template<class T> struct enable_if<true, T> { typedef T type; };
121+
122+
template< bool B, class T = void >
123+
using enable_if_t = typename enable_if<B, T>::type;
124+
}
125+
126+
// below, no array type findings are expected within the template parameter declarations since no array type gets written explicitly
127+
template <typename T,
128+
bool = std::is_same_v<T, int>,
129+
bool = std::is_same<T, int>::value,
130+
bool = std::is_same_v<std::remove_const_t<T>, int>,
131+
bool = std::is_same<std::remove_const_t<T>, int>::value,
132+
bool = std::is_same_v<typename std::remove_const<T>::type, int>,
133+
bool = std::is_same<typename std::remove_const<T>::type, int>::value,
134+
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,
135+
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,
136+
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>)>,
137+
typename = typename std::remove_const<T>::type,
138+
typename = std::remove_const_t<T>>
139+
class MyClassTemplate {
140+
public:
141+
// here, plenty of array type findings are expected for below template parameter declarations since array types get written explicitly
142+
template <typename U = T,
143+
bool = std::is_same_v<U, int[]>,
144+
// CHECK-MESSAGES: :[[@LINE-1]]:38: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
145+
bool = std::is_same<U, int[10]>::value,
146+
// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
147+
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,
148+
// CHECK-MESSAGES: :[[@LINE-1]]:73: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
149+
// CHECK-MESSAGES: :[[@LINE-2]]:140: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
150+
typename = typename std::remove_const<int[10]>::type,
151+
// CHECK-MESSAGES: :[[@LINE-1]]:51: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
152+
typename = std::remove_const_t<int[]>>
153+
// CHECK-MESSAGES: :[[@LINE-1]]:44: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
154+
class MyInnerClassTemplate {
155+
public:
156+
MyInnerClassTemplate(const U&) {}
157+
private:
158+
U field[3];
159+
// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
160+
};
161+
162+
MyClassTemplate(const T&) {}
163+
164+
private:
165+
T field[7];
166+
// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
167+
};
168+
169+
// an explicit instantiation
170+
template
171+
class MyClassTemplate<int[2]>;
172+
// CHECK-MESSAGES: :[[@LINE-1]]:23: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
173+
174+
using MyArrayType = int[3];
175+
// CHECK-MESSAGES: :[[@LINE-1]]:21: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
176+
177+
// another explicit instantiation
178+
template
179+
class MyClassTemplate<MyArrayType>;
180+
// no diagnostic is expected here since no C-style array type got written here
181+
182+
// below, no array type findings are expected within the template parameter declarations since no array type gets written explicitly
183+
template <typename T,
184+
bool = std::is_same_v<T, int>,
185+
bool = std::is_same<T, int>::value,
186+
bool = std::is_same_v<std::remove_const_t<T>, int>,
187+
bool = std::is_same<std::remove_const_t<T>, int>::value,
188+
bool = std::is_same_v<typename std::remove_const<T>::type, int>,
189+
bool = std::is_same<typename std::remove_const<T>::type, int>::value,
190+
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,
191+
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,
192+
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>)>,
193+
typename = typename std::remove_const<T>::type,
194+
typename = std::remove_const_t<T>>
195+
void func(const T& param) {
196+
int array1[1];
197+
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
198+
199+
T array2[2];
200+
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
201+
202+
T value;
203+
}
204+
205+
// here, plenty of array type findings are expected for below template parameter declarations since array types get written explicitly
206+
template <typename T = int[],
207+
// CHECK-MESSAGES: :[[@LINE-1]]:24: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
208+
bool = std::is_same_v<T, int[]>,
209+
// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
210+
bool = std::is_same<T, int[10]>::value,
211+
// CHECK-MESSAGES: :[[@LINE-1]]:34: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
212+
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,
213+
// CHECK-MESSAGES: :[[@LINE-1]]:71: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
214+
// CHECK-MESSAGES: :[[@LINE-2]]:138: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
215+
typename = typename std::remove_const<int[10]>::type,
216+
// CHECK-MESSAGES: :[[@LINE-1]]:49: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
217+
typename = std::remove_const_t<int[]>>
218+
// CHECK-MESSAGES: :[[@LINE-1]]:42: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
219+
void fun(const T& param) {
220+
int array3[3];
221+
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
222+
223+
T array4[4];
224+
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
225+
226+
T value;
227+
}
228+
229+
template<typename T>
230+
T some_constant{};
231+
232+
// explicit instantiations
233+
template
234+
int some_constant<int[5]>[5];
235+
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
236+
237+
template
238+
int some_constant<decltype(ak)>[4];
239+
// no diagnostic is expected here since explicit instantiations aren't represented as `TypeLoc` in the AST and we hence cannot match them as such
240+
241+
MyArrayType mk;
242+
// no diagnostic is expected here since no C-style array type got written here
243+
244+
// explicit specializations
245+
template<>
246+
int some_constant<int[7]>[7]{};
247+
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
248+
// CHECK-MESSAGES: :[[@LINE-2]]:19: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
249+
250+
template<>
251+
int some_constant<decltype(mk)>[3]{};
252+
// CHECK-MESSAGES: :[[@LINE-1]]:1: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
253+
254+
void testArrayInTemplateType() {
255+
int t[10];
256+
// CHECK-MESSAGES: :[[@LINE-1]]:3: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
257+
258+
func(t);
259+
fun(t);
260+
261+
func<decltype(t)>({});
262+
fun<decltype(t)>({});
263+
264+
func<int[1]>({});
265+
// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
266+
fun<int[1]>({});
267+
// CHECK-MESSAGES: :[[@LINE-1]]:7: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
268+
269+
MyClassTemplate var{t};
270+
MyClassTemplate<decltype(t)> var1{{}};
271+
MyClassTemplate<int[2]> var2{{}};
272+
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
273+
274+
decltype(var1)::MyInnerClassTemplate var3{t};
275+
decltype(var1)::MyInnerClassTemplate<decltype(t)> var4{{}};
276+
decltype(var1)::MyInnerClassTemplate<char[5]> var5{{}};
277+
// CHECK-MESSAGES: :[[@LINE-1]]:40: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
278+
279+
MyClassTemplate<decltype(t)>::MyInnerClassTemplate var6{t};
280+
MyClassTemplate<decltype(t)>::MyInnerClassTemplate<decltype(t)> var7{{}};
281+
MyClassTemplate<decltype(t)>::MyInnerClassTemplate<char[8]> var8{{}};
282+
// CHECK-MESSAGES: :[[@LINE-1]]:54: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
283+
MyClassTemplate<int[9]>::MyInnerClassTemplate<char[9]> var9{{}};
284+
// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
285+
// CHECK-MESSAGES: :[[@LINE-2]]:49: warning: do not declare C-style arrays, use 'std::array' instead [modernize-avoid-c-arrays]
286+
}

0 commit comments

Comments
 (0)