Debian Codegraph @

clang-tools-extra/test/clang-tidy/checkers/readability/identifier-naming.cpp

raw
1 // Remove UNSUPPORTED for powerpc64le when the problem introduced by
2 // r288563 is resolved.
3 // UNSUPPORTED: target=powerpc64le{{.*}}
4 // RUN: %check_clang_tidy -std=c++20 %s readability-identifier-naming %t -- \
5 // RUN: -config='{CheckOptions: { \
6 // RUN: readability-identifier-naming.AbstractClassCase: CamelCase, \
7 // RUN: readability-identifier-naming.AbstractClassPrefix: 'A', \
8 // RUN: readability-identifier-naming.ClassCase: CamelCase, \
9 // RUN: readability-identifier-naming.ClassPrefix: 'C', \
10 // RUN: readability-identifier-naming.ClassConstantCase: CamelCase, \
11 // RUN: readability-identifier-naming.ClassConstantPrefix: 'k', \
12 // RUN: readability-identifier-naming.ClassMemberCase: CamelCase, \
13 // RUN: readability-identifier-naming.ClassMethodCase: camelBack, \
14 // RUN: readability-identifier-naming.ConceptCase: CamelCase, \
15 // RUN: readability-identifier-naming.ConstantCase: UPPER_CASE, \
16 // RUN: readability-identifier-naming.ConstantSuffix: '_CST', \
17 // RUN: readability-identifier-naming.ConstexprFunctionCase: lower_case, \
18 // RUN: readability-identifier-naming.ConstexprMethodCase: lower_case, \
19 // RUN: readability-identifier-naming.ConstexprVariableCase: lower_case, \
20 // RUN: readability-identifier-naming.EnumCase: CamelCase, \
21 // RUN: readability-identifier-naming.EnumPrefix: 'E', \
22 // RUN: readability-identifier-naming.ScopedEnumConstantCase: CamelCase, \
23 // RUN: readability-identifier-naming.EnumConstantCase: UPPER_CASE, \
24 // RUN: readability-identifier-naming.FunctionCase: camelBack, \
25 // RUN: readability-identifier-naming.GlobalConstantCase: UPPER_CASE, \
26 // RUN: readability-identifier-naming.GlobalFunctionCase: CamelCase, \
27 // RUN: readability-identifier-naming.GlobalVariableCase: lower_case, \
28 // RUN: readability-identifier-naming.GlobalVariablePrefix: 'g_', \
29 // RUN: readability-identifier-naming.InlineNamespaceCase: lower_case, \
30 // RUN: readability-identifier-naming.LocalConstantCase: CamelCase, \
31 // RUN: readability-identifier-naming.LocalConstantPrefix: 'k', \
32 // RUN: readability-identifier-naming.LocalVariableCase: lower_case, \
33 // RUN: readability-identifier-naming.MemberCase: CamelCase, \
34 // RUN: readability-identifier-naming.MemberPrefix: 'm_', \
35 // RUN: readability-identifier-naming.ConstantMemberCase: lower_case, \
36 // RUN: readability-identifier-naming.PrivateMemberPrefix: '__', \
37 // RUN: readability-identifier-naming.ProtectedMemberPrefix: '_', \
38 // RUN: readability-identifier-naming.PublicMemberCase: lower_case, \
39 // RUN: readability-identifier-naming.MethodCase: camelBack, \
40 // RUN: readability-identifier-naming.PrivateMethodPrefix: '__', \
41 // RUN: readability-identifier-naming.ProtectedMethodPrefix: '_', \
42 // RUN: readability-identifier-naming.NamespaceCase: lower_case, \
43 // RUN: readability-identifier-naming.ParameterCase: camelBack, \
44 // RUN: readability-identifier-naming.ParameterPrefix: 'a_', \
45 // RUN: readability-identifier-naming.ConstantParameterCase: camelBack, \
46 // RUN: readability-identifier-naming.ConstantParameterPrefix: 'i_', \
47 // RUN: readability-identifier-naming.ParameterPackCase: camelBack, \
48 // RUN: readability-identifier-naming.PureFunctionCase: lower_case, \
49 // RUN: readability-identifier-naming.PureMethodCase: camelBack, \
50 // RUN: readability-identifier-naming.StaticConstantCase: UPPER_CASE, \
51 // RUN: readability-identifier-naming.StaticVariableCase: camelBack, \
52 // RUN: readability-identifier-naming.StaticVariablePrefix: 's_', \
53 // RUN: readability-identifier-naming.StructCase: Leading_upper_snake_case, \
54 // RUN: readability-identifier-naming.TemplateParameterCase: UPPER_CASE, \
55 // RUN: readability-identifier-naming.TemplateTemplateParameterCase: CamelCase, \
56 // RUN: readability-identifier-naming.TemplateUsingCase: lower_case, \
57 // RUN: readability-identifier-naming.TemplateUsingPrefix: 'u_', \
58 // RUN: readability-identifier-naming.TypeTemplateParameterCase: camelBack, \
59 // RUN: readability-identifier-naming.TypeTemplateParameterSuffix: '_t', \
60 // RUN: readability-identifier-naming.TypedefCase: lower_case, \
61 // RUN: readability-identifier-naming.TypedefSuffix: '_t', \
62 // RUN: readability-identifier-naming.UnionCase: CamelCase, \
63 // RUN: readability-identifier-naming.UnionPrefix: 'U', \
64 // RUN: readability-identifier-naming.UsingCase: lower_case, \
65 // RUN: readability-identifier-naming.ValueTemplateParameterCase: camelBack, \
66 // RUN: readability-identifier-naming.VariableCase: lower_case, \
67 // RUN: readability-identifier-naming.VirtualMethodCase: Camel_Snake_Case, \
68 // RUN: readability-identifier-naming.VirtualMethodPrefix: 'v_', \
69 // RUN: readability-identifier-naming.MacroDefinitionCase: UPPER_CASE, \
70 // RUN: readability-identifier-naming.TypeAliasCase: camel_Snake_Back, \
71 // RUN: readability-identifier-naming.TypeAliasSuffix: '_t', \
72 // RUN: readability-identifier-naming.IgnoreFailedSplit: false, \
73 // RUN: readability-identifier-naming.GlobalPointerCase: CamelCase, \
74 // RUN: readability-identifier-naming.GlobalPointerSuffix: '_Ptr', \
75 // RUN: readability-identifier-naming.GlobalConstantPointerCase: UPPER_CASE, \
76 // RUN: readability-identifier-naming.GlobalConstantPointerSuffix: '_Ptr', \
77 // RUN: readability-identifier-naming.PointerParameterCase: lower_case, \
78 // RUN: readability-identifier-naming.PointerParameterPrefix: 'p_', \
79 // RUN: readability-identifier-naming.ConstantPointerParameterCase: CamelCase, \
80 // RUN: readability-identifier-naming.ConstantPointerParameterPrefix: 'cp_', \
81 // RUN: readability-identifier-naming.LocalPointerCase: CamelCase, \
82 // RUN: readability-identifier-naming.LocalPointerPrefix: 'l_', \
83 // RUN: readability-identifier-naming.LocalConstantPointerCase: CamelCase, \
84 // RUN: readability-identifier-naming.LocalConstantPointerPrefix: 'lc_', \
85 // RUN: }}' -- -fno-delayed-template-parsing -Dbad_macro \
86 // RUN: -I%S/Inputs/identifier-naming \
87 // RUN: -isystem %S/Inputs/identifier-naming/system
88
89 // clang-format off
90
91 #include <system-header.h>
92 #include <coroutines.h>
93 #include "user-header.h"
94 // NO warnings or fixes expected from declarations within header files without
95 // the -header-filter= option
96
97 namespace FOO_NS {
98 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for namespace 'FOO_NS' [readability-identifier-naming]
99 // CHECK-FIXES: {{^}}namespace foo_ns {{{$}}
100 inline namespace InlineNamespace {
101 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for inline namespace 'InlineNamespace'
102 // CHECK-FIXES: {{^}}inline namespace inline_namespace {{{$}}
103
104 SYSTEM_NS::structure g_s1;
105 // NO warnings or fixes expected as SYSTEM_NS and structure are declared in a header file
106
107 USER_NS::object g_s2;
108 // NO warnings or fixes expected as USER_NS and object are declared in a header file
109
110 SYSTEM_MACRO(var1);
111 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for global variable 'var1' [readability-identifier-naming]
112 // CHECK-FIXES: {{^}}SYSTEM_MACRO(g_var1);
113
114 USER_MACRO(var2);
115 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for global variable 'var2' [readability-identifier-naming]
116 // CHECK-FIXES: {{^}}USER_MACRO(g_var2);
117
118 #define BLA int FOO_bar
119 BLA;
120 // NO warnings or fixes expected as FOO_bar is from macro expansion
121
122 int global0;
123 #define USE_NUMBERED_GLOBAL(number) auto use_global##number = global##number
124 USE_NUMBERED_GLOBAL(0);
125 // NO warnings or fixes expected as global0 is pieced together in a macro
126 // expansion.
127
128 int global1;
129 #define USE_NUMBERED_BAL(prefix, number) \
130 auto use_##prefix##bal##number = prefix##bal##number
131 USE_NUMBERED_BAL(glo, 1);
132 // NO warnings or fixes expected as global1 is pieced together in a macro
133 // expansion.
134
135 int global2;
136 #define USE_RECONSTRUCTED(glo, bal) auto use_##glo##bal = glo##bal
137 USE_RECONSTRUCTED(glo, bal2);
138 // NO warnings or fixes expected as global2 is pieced together in a macro
139 // expansion.
140
141 int global;
142 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'global'
143 // CHECK-FIXES: {{^}}int g_global;{{$}}
144 #define USE_IN_MACRO(m) auto use_##m = m
145 USE_IN_MACRO(global);
146
147 int global3;
148 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'global3'
149 // CHECK-FIXES: {{^}}int g_global3;{{$}}
150 #define ADD_TO_SELF(m) (m) + (m)
151 int g_twice_global3 = ADD_TO_SELF(global3);
152 // CHECK-FIXES: {{^}}int g_twice_global3 = ADD_TO_SELF(g_global3);{{$}}
153
154 int g_Global4;
155 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'g_Global4'
156 // CHECK-FIXES: {{^}}int g_global4;{{$}}
157
158 enum my_enumeration {
159 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for enum 'my_enumeration'
160 // CHECK-FIXES: {{^}}enum EMyEnumeration {{{$}}
161 MyConstant = 1,
162 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'MyConstant'
163 // CHECK-FIXES: {{^}} MY_CONSTANT = 1,{{$}}
164 your_CONST = 1,
165 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'your_CONST'
166 // CHECK-FIXES: {{^}} YOUR_CONST = 1,{{$}}
167 THIS_ConstValue = 1,
168 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'THIS_ConstValue'
169 // CHECK-FIXES: {{^}} THIS_CONST_VALUE = 1,{{$}}
170 };
171
172 enum class EMyEnumeration {
173 myConstant = 1,
174 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'myConstant'
175 // CHECK-FIXES: {{^}} MyConstant = 1,{{$}}
176 your_CONST = 1,
177 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'your_CONST'
178 // CHECK-FIXES: {{^}} YourConst = 1,{{$}}
179 THIS_ConstValue = 1,
180 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'THIS_ConstValue'
181 // CHECK-FIXES: {{^}} ThisConstValue = 1,{{$}}
182 };
183
184 constexpr int ConstExpr_variable = MyConstant;
185 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for constexpr variable 'ConstExpr_variable'
186 // CHECK-FIXES: {{^}}constexpr int const_expr_variable = MY_CONSTANT;{{$}}
187
188 class my_class {
189 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_class'
190 // CHECK-FIXES: {{^}}class CMyClass {{{$}}
191 public:
192 my_class();
193 // CHECK-FIXES: {{^}} CMyClass();{{$}}
194
195 my_class(void*) : my_class() {}
196 // CHECK-FIXES: {{^}} CMyClass(void*) : CMyClass() {}{{$}}
197
198 ~
199 my_class();
200 // (space in destructor token test, we could check trigraph but they will be deprecated)
201 // CHECK-FIXES: {{^}} ~{{$}}
202 // CHECK-FIXES: {{^}} CMyClass();{{$}}
203
204 private:
205 const int MEMBER_one_1 = ConstExpr_variable;
206 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for constant member 'MEMBER_one_1'
207 // CHECK-FIXES: {{^}} const int member_one_1 = const_expr_variable;{{$}}
208 int member2 = 2;
209 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for private member 'member2'
210 // CHECK-FIXES: {{^}} int __member2 = 2;{{$}}
211 int _memberWithExtraUnderscores_ = 42;
212 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for private member '_memberWithExtraUnderscores_'
213 // CHECK-FIXES: {{^}} int __memberWithExtraUnderscores = 42;{{$}}
214
215 private:
216 int private_member = 3;
217 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for private member 'private_member'
218 // CHECK-FIXES: {{^}} int __private_member = 3;{{$}}
219
220 protected:
221 int ProtMember;
222 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for protected member 'ProtMember'
223 // CHECK-FIXES: {{^}} int _ProtMember;{{$}}
224
225 public:
226 int PubMem;
227 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for public member 'PubMem'
228 // CHECK-FIXES: {{^}} int pub_mem;{{$}}
229
230 static const int classConstant;
231 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: invalid case style for class constant 'classConstant'
232 // CHECK-FIXES: {{^}} static const int kClassConstant;{{$}}
233 static int ClassMember_2;
234 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for class member 'ClassMember_2'
235 // CHECK-FIXES: {{^}} static int ClassMember2;{{$}}
236 };
237 class my_class;
238 // No warning needed here as this is tied to the previous declaration.
239 // Just make sure the fix is applied.
240 // CHECK-FIXES: {{^}}class CMyClass;{{$}}
241
242 class my_forward_declared_class; // No warning should be triggered.
243
244 const int my_class::classConstant = 4;
245 // CHECK-FIXES: {{^}}const int CMyClass::kClassConstant = 4;{{$}}
246
247 int my_class::ClassMember_2 = 5;
248 // CHECK-FIXES: {{^}}int CMyClass::ClassMember2 = 5;{{$}}
249
250 class my_derived_class : public virtual my_class {};
251 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_derived_class'
252 // CHECK-FIXES: {{^}}class CMyDerivedClass : public virtual CMyClass {};{{$}}
253
254 class CMyWellNamedClass {};
255 // No warning expected as this class is well named.
256
257 template<typename t_t>
258 concept MyConcept = requires (t_t a_t) { {a_t++}; };
259 // No warning expected as this concept is well named.
260
261 template<typename t_t>
262 concept my_concept_2 = requires (t_t a_t) { {a_t++}; };
263 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for concept 'my_concept_2'
264 // CHECK-FIXES: {{^}}concept MyConcept2 = requires (t_t a_t) { {a_t++}; };{{$}}
265
266 template <typename t_t>
267 class CMyWellNamedClass2 : public my_class {
268 // CHECK-FIXES: {{^}}class CMyWellNamedClass2 : public CMyClass {{{$}}
269 t_t my_Bad_Member;
270 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for private member 'my_Bad_Member'
271 // CHECK-FIXES: {{^}} t_t __my_Bad_Member;{{$}}
272 int my_Other_Bad_Member = 42;
273 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for private member 'my_Other_Bad_Member'
274 // CHECK-FIXES: {{^}} int __my_Other_Bad_Member = 42;{{$}}
275 public:
276 CMyWellNamedClass2() = default;
277 CMyWellNamedClass2(CMyWellNamedClass2 const&) = default;
278 CMyWellNamedClass2(CMyWellNamedClass2 &&) = default;
279 CMyWellNamedClass2(t_t a_v, void *p_p) : my_class(p_p), my_Bad_Member(a_v) {}
280 // CHECK-FIXES: {{^}} CMyWellNamedClass2(t_t a_v, void *p_p) : CMyClass(p_p), __my_Bad_Member(a_v) {}{{$}}
281
282 CMyWellNamedClass2(t_t a_v) : my_class(), my_Bad_Member(a_v), my_Other_Bad_Member(11) {}
283 // CHECK-FIXES: {{^}} CMyWellNamedClass2(t_t a_v) : CMyClass(), __my_Bad_Member(a_v), __my_Other_Bad_Member(11) {}{{$}}
284 };
285 void InstantiateClassMethods() {
286 // Ensure we trigger the instantiation of each constructor
287 CMyWellNamedClass2<int> x;
288 CMyWellNamedClass2<int> x2 = x;
289 CMyWellNamedClass2<int> x3 = static_cast<CMyWellNamedClass2<int>&&>(x2);
290 CMyWellNamedClass2<int> x4(42);
291 CMyWellNamedClass2<int> x5(42, nullptr);
292 }
293
294 class AOverridden {
295 public:
296 virtual ~AOverridden() = default;
297 virtual void BadBaseMethod() = 0;
298 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethod'
299 // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method() = 0;
300
301 virtual void BadBaseMethodNoAttr() = 0;
302 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethodNoAttr'
303 // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method_No_Attr() = 0;
304 };
305
306 class COverriding : public AOverridden {
307 public:
308 // Overriding a badly-named base isn't a new violation.
309 void BadBaseMethod() override {}
310 // CHECK-FIXES: {{^}} void v_Bad_Base_Method() override {}
311
312 void BadBaseMethodNoAttr() /* override */ {}
313 // CHECK-FIXES: {{^}} void v_Bad_Base_Method_No_Attr() /* override */ {}
314
315 void foo() {
316 BadBaseMethod();
317 // CHECK-FIXES: {{^}} v_Bad_Base_Method();
318 this->BadBaseMethod();
319 // CHECK-FIXES: {{^}} this->v_Bad_Base_Method();
320 AOverridden::BadBaseMethod();
321 // CHECK-FIXES: {{^}} AOverridden::v_Bad_Base_Method();
322 COverriding::BadBaseMethod();
323 // CHECK-FIXES: {{^}} COverriding::v_Bad_Base_Method();
324
325 BadBaseMethodNoAttr();
326 // CHECK-FIXES: {{^}} v_Bad_Base_Method_No_Attr();
327 this->BadBaseMethodNoAttr();
328 // CHECK-FIXES: {{^}} this->v_Bad_Base_Method_No_Attr();
329 AOverridden::BadBaseMethodNoAttr();
330 // CHECK-FIXES: {{^}} AOverridden::v_Bad_Base_Method_No_Attr();
331 COverriding::BadBaseMethodNoAttr();
332 // CHECK-FIXES: {{^}} COverriding::v_Bad_Base_Method_No_Attr();
333 }
334 };
335
336 // Same test as above, now with a dependent base class.
337 template<typename some_t>
338 class ATOverridden {
339 public:
340 virtual void BadBaseMethod() = 0;
341 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethod'
342 // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method() = 0;
343
344 virtual void BadBaseMethodNoAttr() = 0;
345 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethodNoAttr'
346 // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method_No_Attr() = 0;
347 };
348
349 template<typename some_t>
350 class CTOverriding : public ATOverridden<some_t> {
351 // Overriding a badly-named base isn't a new violation.
352 // FIXME: The fixes from the base class should be propagated to the derived class here
353 // (note that there could be specializations of the template base class, though)
354 void BadBaseMethod() override {}
355
356 // Without the "override" attribute, and due to the dependent base class, it is not
357 // known whether this method overrides anything, so we get the warning here.
358 virtual void BadBaseMethodNoAttr() {};
359 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethodNoAttr'
360 // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method_No_Attr() {};
361 };
362
363 template<typename some_t>
364 void VirtualCall(AOverridden &a_vItem, ATOverridden<some_t> &a_vTitem) {
365 a_vItem.BadBaseMethod();
366 // CHECK-FIXES: {{^}} a_vItem.v_Bad_Base_Method();
367
368 // FIXME: The fixes from ATOverridden should be propagated to the following call
369 a_vTitem.BadBaseMethod();
370 }
371
372 // Same test as above, now with a dependent base class that is instantiated below.
373 template<typename some_t>
374 class ATIOverridden {
375 public:
376 virtual void BadBaseMethod() = 0;
377 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for virtual method 'BadBaseMethod'
378 // CHECK-FIXES: {{^}} virtual void v_Bad_Base_Method() = 0;
379 };
380
381 template<typename some_t>
382 class CTIOverriding : public ATIOverridden<some_t> {
383 public:
384 // Overriding a badly-named base isn't a new violation.
385 void BadBaseMethod() override {}
386 // CHECK-FIXES: {{^}} void v_Bad_Base_Method() override {}
387 };
388
389 template class CTIOverriding<int>;
390
391 void VirtualCallI(ATIOverridden<int>& a_vItem, CTIOverriding<int>& a_vCitem) {
392 a_vItem.BadBaseMethod();
393 // CHECK-FIXES: {{^}} a_vItem.v_Bad_Base_Method();
394
395 a_vCitem.BadBaseMethod();
396 // CHECK-FIXES: {{^}} a_vCitem.v_Bad_Base_Method();
397 }
398
399 template <typename derived_t>
400 class CRTPBase {
401 public:
402 void BadBaseMethod(int) {}
403 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for method 'BadBaseMethod'
404 };
405
406 class CRTPDerived : CRTPBase<CRTPDerived> {
407 public:
408 // Hiding a badly-named base isn't a new violation.
409 double BadBaseMethod(double) { return 0; }
410 };
411
412 template<typename T>
413 // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for type template parameter 'T'
414 // CHECK-FIXES: {{^}}template<typename t_t>{{$}}
415 class my_templated_class : CMyWellNamedClass {};
416 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_templated_class'
417 // CHECK-FIXES: {{^}}class CMyTemplatedClass : CMyWellNamedClass {};{{$}}
418
419 template<typename T>
420 // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for type template parameter 'T'
421 // CHECK-FIXES: {{^}}template<typename t_t>{{$}}
422 class my_other_templated_class : my_templated_class< my_class>, private my_derived_class {};
423 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_other_templated_class'
424 // CHECK-FIXES: {{^}}class CMyOtherTemplatedClass : CMyTemplatedClass< CMyClass>, private CMyDerivedClass {};{{$}}
425
426 template<typename t_t>
427 using mysuper_tpl_t = my_other_templated_class <:: FOO_NS ::my_class>;
428 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for type alias 'mysuper_tpl_t'
429 // CHECK-FIXES: {{^}}using mysuper_Tpl_t = CMyOtherTemplatedClass <:: foo_ns ::CMyClass>;{{$}}
430
431 const int global_Constant = 6;
432 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: invalid case style for global constant 'global_Constant'
433 // CHECK-FIXES: {{^}}const int GLOBAL_CONSTANT = 6;{{$}}
434 int Global_variable = 7;
435 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for global variable 'Global_variable'
436 // CHECK-FIXES: {{^}}int g_global_variable = 7;{{$}}
437
438 void global_function(int PARAMETER_1, int const CONST_parameter) {
439 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global function 'global_function'
440 // CHECK-MESSAGES: :[[@LINE-2]]:26: warning: invalid case style for parameter 'PARAMETER_1'
441 // CHECK-MESSAGES: :[[@LINE-3]]:49: warning: invalid case style for constant parameter 'CONST_parameter'
442 // CHECK-FIXES: {{^}}void GlobalFunction(int a_parameter1, int const i_constParameter) {{{$}}
443 static const int THIS_static_ConsTant = 4;
444 // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: invalid case style for static constant 'THIS_static_ConsTant'
445 // CHECK-FIXES: {{^}} static const int THIS_STATIC_CONS_TANT = 4;{{$}}
446 static int THIS_static_variable;
447 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for static variable 'THIS_static_variable'
448 // CHECK-FIXES: {{^}} static int s_thisStaticVariable;{{$}}
449 int const local_Constant = 3;
450 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for local constant 'local_Constant'
451 // CHECK-FIXES: {{^}} int const kLocalConstant = 3;{{$}}
452 int LOCAL_VARIABLE;
453 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for local variable 'LOCAL_VARIABLE'
454 // CHECK-FIXES: {{^}} int local_variable;{{$}}
455
456 int LOCAL_Array__[] = {0, 1, 2};
457 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for local variable 'LOCAL_Array__'
458 // CHECK-FIXES: {{^}} int local_array[] = {0, 1, 2};{{$}}
459
460 for (auto _ : LOCAL_Array__) {
461 }
462 }
463
464 template<typename ... TYPE_parameters>
465 // CHECK-MESSAGES: :[[@LINE-1]]:23: warning: invalid case style for type template parameter 'TYPE_parameters'
466 // CHECK-FIXES: {{^}}template<typename ... typeParameters_t>{{$}}
467 void Global_Fun(TYPE_parameters... PARAMETER_PACK) {
468 // CHECK-MESSAGES: :[[@LINE-1]]:6: warning: invalid case style for global function 'Global_Fun'
469 // CHECK-MESSAGES: :[[@LINE-2]]:36: warning: invalid case style for parameter pack 'PARAMETER_PACK'
470 // CHECK-FIXES: {{^}}void GlobalFun(typeParameters_t... parameterPack) {{{$}}
471 global_function(1, 2);
472 // CHECK-FIXES: {{^}} GlobalFunction(1, 2);{{$}}
473 FOO_bar = Global_variable;
474 // CHECK-FIXES: {{^}} FOO_bar = g_global_variable;{{$}}
475 // NO fix expected for FOO_bar declared in macro expansion
476 }
477
478 template<template<typename> class TPL_parameter, int COUNT_params, typename ... TYPE_parameters>
479 // CHECK-MESSAGES: :[[@LINE-1]]:35: warning: invalid case style for template template parameter 'TPL_parameter'
480 // CHECK-MESSAGES: :[[@LINE-2]]:54: warning: invalid case style for value template parameter 'COUNT_params'
481 // CHECK-MESSAGES: :[[@LINE-3]]:81: warning: invalid case style for type template parameter 'TYPE_parameters'
482 // CHECK-FIXES: {{^}}template<template<typename> class TplParameter, int countParams, typename ... typeParameters_t>{{$}}
483 class test_CLASS {
484 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'test_CLASS'
485 // CHECK-FIXES: {{^}}class CTestClass {{{$}}
486 };
487
488 class abstract_class {
489 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'abstract_class'
490 // CHECK-FIXES: {{^}}class AAbstractClass {{{$}}
491 virtual ~abstract_class() = 0;
492 // CHECK-FIXES: {{^}} virtual ~AAbstractClass() = 0;{{$}}
493 virtual void VIRTUAL_METHOD();
494 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for virtual method 'VIRTUAL_METHOD'
495 // CHECK-FIXES: {{^}} virtual void v_Virtual_Method();{{$}}
496 void non_Virtual_METHOD() {}
497 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for private method 'non_Virtual_METHOD'
498 // CHECK-FIXES: {{^}} void __non_Virtual_METHOD() {}{{$}}
499
500 public:
501 static void CLASS_METHOD() {}
502 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for class method 'CLASS_METHOD'
503 // CHECK-FIXES: {{^}} static void classMethod() {}{{$}}
504
505 constexpr int CST_expr_Method() { return 2; }
506 // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for constexpr method 'CST_expr_Method'
507 // CHECK-FIXES: {{^}} constexpr int cst_expr_method() { return 2; }{{$}}
508
509 private:
510 void PRIVate_Method();
511 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for private method 'PRIVate_Method'
512 // CHECK-FIXES: {{^}} void __PRIVate_Method();{{$}}
513 protected:
514 void protected_Method();
515 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for protected method 'protected_Method'
516 // CHECK-FIXES: {{^}} void _protected_Method();{{$}}
517 public:
518 void public_Method();
519 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for method 'public_Method'
520 // CHECK-FIXES: {{^}} void publicMethod();{{$}}
521 };
522
523 constexpr int CE_function() { return 3; }
524 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for constexpr function 'CE_function'
525 // CHECK-FIXES: {{^}}constexpr int ce_function() { return 3; }{{$}}
526
527 struct THIS___Structure {
528 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'THIS___Structure'
529 // CHECK-FIXES: {{^}}struct This_structure {{{$}}
530 THIS___Structure();
531 // CHECK-FIXES: {{^}} This_structure();{{$}}
532
533 union __MyUnion_is_wonderful__ {};
534 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for union '__MyUnion_is_wonderful__'
535 // CHECK-FIXES: {{^}} union UMyUnionIsWonderful {};{{$}}
536 };
537
538 typedef THIS___Structure struct_type;
539 // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for typedef 'struct_type'
540 // CHECK-FIXES: {{^}}typedef This_structure struct_type_t;{{$}}
541
542 struct_type GlobalTypedefTestFunction(struct_type a_argument1) {
543 // CHECK-FIXES: {{^}}struct_type_t GlobalTypedefTestFunction(struct_type_t a_argument1) {
544 struct_type typedef_test_1;
545 // CHECK-FIXES: {{^}} struct_type_t typedef_test_1;
546 }
547
548 using my_struct_type = THIS___Structure;
549 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for type alias 'my_struct_type'
550 // CHECK-FIXES: {{^}}using my_Struct_Type_t = This_structure;{{$}}
551
552 template<typename t_t>
553 using SomeOtherTemplate = my_other_templated_class <:: FOO_NS ::my_class>;
554 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for type alias 'SomeOtherTemplate'
555 // CHECK-FIXES: {{^}}using some_Other_Template_t = CMyOtherTemplatedClass <:: foo_ns ::CMyClass>;{{$}}
556
557 static void static_Function() {
558 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for function 'static_Function'
559 // CHECK-FIXES: {{^}}static void staticFunction() {{{$}}
560
561 ::FOO_NS::InlineNamespace::abstract_class::CLASS_METHOD();
562 // CHECK-FIXES: {{^}} ::foo_ns::inline_namespace::AAbstractClass::classMethod();{{$}}
563 ::FOO_NS::InlineNamespace::static_Function();
564 // CHECK-FIXES: {{^}} ::foo_ns::inline_namespace::staticFunction();{{$}}
565
566 using ::FOO_NS::InlineNamespace::CE_function;
567 // CHECK-FIXES: {{^}} using ::foo_ns::inline_namespace::ce_function;{{$}}
568
569 unsigned MY_LOCAL_array[] = {1,2,3};
570 // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: invalid case style for local variable 'MY_LOCAL_array'
571 // CHECK-FIXES: {{^}} unsigned my_local_array[] = {1,2,3};{{$}}
572
573 unsigned const MyConstLocal_array[] = {1,2,3};
574 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for local constant 'MyConstLocal_array'
575 // CHECK-FIXES: {{^}} unsigned const kMyConstLocalArray[] = {1,2,3};{{$}}
576
577 static unsigned MY_STATIC_array[] = {1,2,3};
578 // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: invalid case style for static variable 'MY_STATIC_array'
579 // CHECK-FIXES: {{^}} static unsigned s_myStaticArray[] = {1,2,3};{{$}}
580
581 static unsigned const MyConstStatic_array[] = {1,2,3};
582 // CHECK-MESSAGES: :[[@LINE-1]]:25: warning: invalid case style for static constant 'MyConstStatic_array'
583 // CHECK-FIXES: {{^}} static unsigned const MY_CONST_STATIC_ARRAY[] = {1,2,3};{{$}}
584
585 char MY_LOCAL_string[] = "123";
586 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for local variable 'MY_LOCAL_string'
587 // CHECK-FIXES: {{^}} char my_local_string[] = "123";{{$}}
588
589 char const MyConstLocal_string[] = "123";
590 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for local constant 'MyConstLocal_string'
591 // CHECK-FIXES: {{^}} char const kMyConstLocalString[] = "123";{{$}}
592
593 static char MY_STATIC_string[] = "123";
594 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for static variable 'MY_STATIC_string'
595 // CHECK-FIXES: {{^}} static char s_myStaticString[] = "123";{{$}}
596
597 static char const MyConstStatic_string[] = "123";
598 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for static constant 'MyConstStatic_string'
599 // CHECK-FIXES: {{^}} static char const MY_CONST_STATIC_STRING[] = "123";{{$}}
600 }
601
602 #define MY_TEST_Macro(X) X()
603 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for macro definition 'MY_TEST_Macro'
604 // CHECK-FIXES: {{^}}#define MY_TEST_MACRO(X) X()
605
606 void MY_TEST_Macro(function) {}
607 // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: invalid case style for global function 'function' [readability-identifier-naming]
608 // CHECK-FIXES: {{^}}void MY_TEST_MACRO(Function) {}
609
610 #define MY_CAT_IMPL(l, r) l ## r
611 #define MY_CAT(l, r) MY_CAT_IMPL(l, r)
612 #define MY_MACRO2(foo) int MY_CAT(awesome_, MY_CAT(foo, __COUNTER__)) = 0
613 #define MY_MACRO3(foo) int MY_CAT(awesome_, foo) = 0
614 MY_MACRO2(myglob);
615 MY_MACRO3(myglob);
616 // No suggestions should occur even though the resulting decl of awesome_myglob#
617 // or awesome_myglob are not entirely within a macro argument.
618
619 } // namespace InlineNamespace
620 } // namespace FOO_NS
621
622 template <typename t_t> struct a {
623 // CHECK-MESSAGES: :[[@LINE-1]]:32: warning: invalid case style for struct 'a'
624 // CHECK-FIXES: {{^}}template <typename t_t> struct A {{{$}}
625 typename t_t::template b<> c;
626
627 char const MY_ConstMember_string[4] = "123";
628 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'MY_ConstMember_string'
629 // CHECK-FIXES: {{^}} char const my_const_member_string[4] = "123";{{$}}
630
631 static char const MyConstClass_string[];
632 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for class constant 'MyConstClass_string'
633 // CHECK-FIXES: {{^}} static char const kMyConstClassString[];{{$}}
634 };
635
636 template<typename t_t>
637 char const a<t_t>::MyConstClass_string[] = "123";
638 // CHECK-FIXES: {{^}}char const A<t_t>::kMyConstClassString[] = "123";{{$}}
639
640 template <template <typename> class A> struct b { A<int> c; };
641 // CHECK-MESSAGES: :[[@LINE-1]]:47: warning: invalid case style for struct 'b'
642 // CHECK-FIXES:template <template <typename> class A> struct B { A<int> c; };{{$}}
643
644 unsigned MY_GLOBAL_array[] = {1,2,3};
645 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'MY_GLOBAL_array'
646 // CHECK-FIXES: {{^}}unsigned g_my_global_array[] = {1,2,3};{{$}}
647
648 unsigned const MyConstGlobal_array[] = {1,2,3};
649 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global constant 'MyConstGlobal_array'
650 // CHECK-FIXES: {{^}}unsigned const MY_CONST_GLOBAL_ARRAY[] = {1,2,3};{{$}}
651
652 int * MyGlobal_Ptr;// -> ok
653 int * my_second_global_Ptr;
654 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for global pointer 'my_second_global_Ptr'
655 // CHECK-FIXES: {{^}}int * MySecondGlobal_Ptr;{{$}}
656 int * const MyConstantGlobalPointer = nullptr;
657 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for global constant pointer 'MyConstantGlobalPointer'
658 // CHECK-FIXES: {{^}}int * const MY_CONSTANT_GLOBAL_POINTER_Ptr = nullptr;{{$}}
659
660 void MyPoiterFunction(int * p_normal_pointer, int * const constant_ptr){
661 // CHECK-MESSAGES: :[[@LINE-1]]:59: warning: invalid case style for constant pointer parameter 'constant_ptr'
662 // CHECK-FIXES: {{^}}void MyPoiterFunction(int * p_normal_pointer, int * const cp_ConstantPtr){{{$}}
663 int * l_PointerA;
664 int * const pointer_b = nullptr;
665 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for local constant pointer 'pointer_b'
666 // CHECK-FIXES: {{^}} int * const lc_PointerB = nullptr;{{$}}
667 }
668
669 using namespace FOO_NS;
670 // CHECK-FIXES: {{^}}using namespace foo_ns;
671
672 using namespace FOO_NS::InlineNamespace;
673 // CHECK-FIXES: {{^}}using namespace foo_ns::inline_namespace;
674
675 void QualifiedTypeLocTest(THIS___Structure);
676 // CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure);{{$}}
677 void QualifiedTypeLocTest(THIS___Structure &);
678 // CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure &);{{$}}
679 void QualifiedTypeLocTest(THIS___Structure &&);
680 // CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure &&);{{$}}
681 void QualifiedTypeLocTest(const THIS___Structure);
682 // CHECK-FIXES: {{^}}void QualifiedTypeLocTest(const This_structure);{{$}}
683 void QualifiedTypeLocTest(const THIS___Structure &);
684 // CHECK-FIXES: {{^}}void QualifiedTypeLocTest(const This_structure &);{{$}}
685 void QualifiedTypeLocTest(volatile THIS___Structure &);
686 // CHECK-FIXES: {{^}}void QualifiedTypeLocTest(volatile This_structure &);{{$}}
687
688 namespace redecls {
689 // We only want the warning to show up once here for the first decl.
690 // CHECK-MESSAGES: :[[@LINE+1]]:6: warning: invalid case style for global function 'badNamedFunction'
691 void badNamedFunction();
692 void badNamedFunction();
693 void badNamedFunction(){}
694 // CHECK-FIXES: {{^}}void BadNamedFunction();
695 // CHECK-FIXES-NEXT: {{^}}void BadNamedFunction();
696 // CHECK-FIXES-NEXT: {{^}}void BadNamedFunction(){}
697 void ReferenceBadNamedFunction() {
698 auto l_Ptr = badNamedFunction;
699 // CHECK-FIXES: {{^}} auto l_Ptr = BadNamedFunction;
700 l_Ptr();
701 badNamedFunction();
702 // CHECK-FIXES: {{^}} BadNamedFunction();
703 }
704
705 } // namespace redecls
706
707 namespace scratchspace {
708 #define DUP(Tok) Tok
709 #define M1(Tok) DUP(badName##Tok())
710
711 // We don't want a warning here as the call to this in Foo is in a scratch
712 // buffer so its fix-it wouldn't be applied, resulting in invalid code.
713 void badNameWarn();
714
715 void Foo() {
716 M1(Warn);
717 }
718
719 #undef M1
720 #undef DUP
721 } // namespace scratchspace
722
723 template<typename type_t>
724 auto GetRes(type_t& Param) -> decltype(Param.res());
725 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for parameter 'Param'
726 // CHECK-FIXES: auto GetRes(type_t& a_param) -> decltype(a_param.res());
727
728 // Check implicit declarations in coroutines
729
730 struct async_obj {
731 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'async_obj'
732 // CHECK-FIXES: {{^}}struct Async_obj {{{$}}
733 public:
734 never_suspend operator co_await() const noexcept;
735 };
736
737 task ImplicitDeclTest(async_obj &a_object) {
738 co_await a_object; // CHECK-MESSAGES-NOT: warning: invalid case style for local variable
739 }
740
741 // Test scenario when canonical declaration will be a forward declaration
742 struct ForwardDeclStruct;
743 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'ForwardDeclStruct' [readability-identifier-naming]
744 // CHECK-FIXES: {{^}}struct Forward_decl_struct;
745 // CHECK-FIXES: {{^}}struct Forward_decl_struct {
746 struct ForwardDeclStruct {
747 };
748
749 struct forward_declared_as_struct;
750 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for class 'forward_declared_as_struct' [readability-identifier-naming]
751 // CHECK-FIXES: {{^}}struct CForwardDeclaredAsStruct;
752 // CHECK-FIXES: {{^}}class CForwardDeclaredAsStruct {
753 class forward_declared_as_struct {
754 };
755
756 namespace pr55156 {
757
758 template<typename> struct Wrap;
759
760 typedef enum {
761 VALUE0,
762 VALUE1,
763 } ValueType;
764 // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: invalid case style for typedef 'ValueType' [readability-identifier-naming]
765 // CHECK-FIXES: {{^}}} value_type_t;
766
767 typedef ValueType (*MyFunPtr)(const ValueType&, Wrap<ValueType>*);
768 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for typedef 'MyFunPtr' [readability-identifier-naming]
769 // CHECK-FIXES: {{^}}typedef value_type_t (*my_fun_ptr_t)(const value_type_t&, Wrap<value_type_t>*);
770
771 #define STATIC_MACRO static
772 STATIC_MACRO void someFunc(ValueType a_v1, const ValueType& a_v2) {}
773 // CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(value_type_t a_v1, const value_type_t& a_v2) {}
774 STATIC_MACRO void someFunc(const ValueType** p_a_v1, ValueType (*p_a_v2)()) {}
775 // CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(const value_type_t** p_a_v1, value_type_t (*p_a_v2)()) {}
776 STATIC_MACRO ValueType someFunc() {}
777 // CHECK-FIXES: {{^}}STATIC_MACRO value_type_t someFunc() {}
778 STATIC_MACRO void someFunc(MyFunPtr, const MyFunPtr****) {}
779 // CHECK-FIXES: {{^}}STATIC_MACRO void someFunc(my_fun_ptr_t, const my_fun_ptr_t****) {}
780 #undef STATIC_MACRO
781 }
782
783 struct Some_struct {
784 int SomeMember;
785 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for public member 'SomeMember' [readability-identifier-naming]
786 // CHECK-FIXES: {{^}} int some_member;
787 };
788 Some_struct g_s1{ .SomeMember = 1 };
789 // CHECK-FIXES: {{^}}Some_struct g_s1{ .some_member = 1 };
790 Some_struct g_s2{.SomeMember=1};
791 // CHECK-FIXES: {{^}}Some_struct g_s2{.some_member=1};