[clang-tidy][readability] add Leading_upper_snake_case

[MasterCopy8GB]

Summary

Add Leading_upper_snake_case to IdentifierNamingCheck naming convention.

Fixes #42451

[PiotrZSL]

• Missing documentation entry about this style.
• Missing release notes entry
• Commit title / description should be more in line with style used in project

[MasterCopy8GB]

Update documentation

[PiotrZSL]

clang-tools-extra/docs/ReleaseNotes.rst

116–118

Wrong section, add it under "Changes in existing checks".
Leading_upper_snake_case -> Leading_upper_snake_case.
allow for -> support

clang-tools-extra/docs/clang-tidy/checks/readability/identifier-naming.rst

2107

do not change this, this (an changes in line ~2121) is for a lower_case scenario...
Add some other example or explanation around line 33.

[PiotrZSL]

And add reference to issue in commit description.

[MasterCopy8GB]

Update documentation for issue 42451

[MasterCopy8GB]

Update diff with complete patch

[PiotrZSL]

Upload full path to avoid "Context not available."

clang-tools-extra/docs/ReleaseNotes.rst

256

put this entry in alphabetical order

257

wrong name, such file does not exist

257–258

this message now says nothing... rephrase tis correctly... instead of just blindly copying text.

clang-tools-extra/docs/clang-tidy/checks/readability/identifier-naming.rst

34

put name into double `

[MasterCopy8GB]

Fix documentation comments

[PiotrZSL]

clang-tools-extra/docs/ReleaseNotes.rst

240–245

There is already entry for this check, so just add it to previous:

warnings when a type forward declaration precedes its definition and
added support for ``Leading_upper_snake_case`` naming convention.

[PiotrZSL]

After you update release notes entry, it could land...

[MasterCopy8GB]

Combine readability-identifier-naming improvements in release notes

[MasterCopy8GB]

Hello @PiotrZSL, I do not have rights to commit to the LLVM repository. Could you please commit these changes for me? Thank you for all of your time and effort!

[PiotrZSL]

In D158787#4621587, @MasterCopy8GB wrote:

Hello @PiotrZSL, I do not have rights to commit to the LLVM repository. Could you please commit these changes for me? Thank you for all of your time and effort!

Under which user ? Name / Email ?

[MasterCopy8GB]

In D158787#4621915, @PiotrZSL wrote:

In D158787#4621587, @MasterCopy8GB wrote:

Hello @PiotrZSL, I do not have rights to commit to the LLVM repository. Could you please commit these changes for me? Thank you for all of your time and effort!

Under which user ? Name / Email ?

MasterCopy8GB / [e-mail] Please

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.h

public:
 
   enum CaseType {
     CT_AnyCase = 0,
     CT_LowerCase,
     CT_CamelBack,
     CT_UpperCase,
     CT_CamelCase,
     CT_CamelSnakeCase,
-    CT_CamelSnakeBack
+    CT_CamelSnakeBack,
+    CT_LeadingUpperSnakeCase
   };
 
   enum HungarianPrefixType {
     HPT_Off = 0,
     HPT_On,
     HPT_LowerCase,
     HPT_CamelCase,
   };

clang-tools-extra/clang-tidy/readability/IdentifierNamingCheck.cpp

static constexpr std::pair<readability::IdentifierNamingCheck::CaseType,
           {readability::IdentifierNamingCheck::CT_AnyCase, "aNy_CasE"},
           {readability::IdentifierNamingCheck::CT_LowerCase, "lower_case"},
           {readability::IdentifierNamingCheck::CT_UpperCase, "UPPER_CASE"},
           {readability::IdentifierNamingCheck::CT_CamelBack, "camelBack"},
           {readability::IdentifierNamingCheck::CT_CamelCase, "CamelCase"},
           {readability::IdentifierNamingCheck::CT_CamelSnakeCase,
            "Camel_Snake_Case"},
           {readability::IdentifierNamingCheck::CT_CamelSnakeBack,
-           "camel_Snake_Back"}};
+           "camel_Snake_Back"},
+          {readability::IdentifierNamingCheck::CT_LeadingUpperSnakeCase,
+           "Leading_upper_snake_case"}};
   return {Mapping};
 }
 
 template <>
 struct OptionEnumMapping<
     readability::IdentifierNamingCheck::HungarianPrefixType> {
   using HungarianPrefixType =
       readability::IdentifierNamingCheck::HungarianPrefixType;
bool IdentifierNamingCheck::matchesStyle(
   static llvm::Regex Matchers[] = {
       llvm::Regex("^.*$"),
       llvm::Regex("^[a-z][a-z0-9_]*$"),
       llvm::Regex("^[a-z][a-zA-Z0-9]*$"),
       llvm::Regex("^[A-Z][A-Z0-9_]*$"),
       llvm::Regex("^[A-Z][a-zA-Z0-9]*$"),
       llvm::Regex("^[A-Z]([a-z0-9]*(_[A-Z])?)*"),
       llvm::Regex("^[a-z]([a-z0-9]*(_[A-Z])?)*"),
+      llvm::Regex("^[A-Z]([a-z0-9_]*[a-z])*$"),
   };
 
   if (!Name.consume_front(Style.Prefix))
     return false;
   if (!Name.consume_back(Style.Suffix))
     return false;
   if (IdentifierNamingCheck::HungarianPrefixType::HPT_Off != Style.HPType) {
     std::string HNPrefix = HungarianNotation.getPrefix(Decl, HNOption);
for (auto const &Word : Words) {
         Fixup += "_";
         Fixup += toupper(Word.front());
       } else {
         Fixup += tolower(Word.front());
       }
       Fixup += Word.substr(1).lower();
     }
     break;
+
+  case IdentifierNamingCheck::CT_LeadingUpperSnakeCase:
+    for (auto const &Word : Words) {
+      if (&Word != &Words.front()) {
+        Fixup += "_";
+        Fixup += Word.lower();
+      } else {
+        Fixup += toupper(Word.front());
+        Fixup += Word.substr(1).lower();
+      }
+    }
+    break;
   }
 
   return Fixup.str().str();
 }
 
 bool IdentifierNamingCheck::isParamInMainLikeFunction(
     const ParmVarDecl &ParmDecl, bool IncludeMainLike) const {
   const auto *FDecl =

clang-tools-extra/docs/ReleaseNotes.rst

- Preprocessor-level module header parsing is now disabled by default due to
   functionality using the newly added command line option
   `--enable-module-headers-parsing`.
 
 - Remove configuration option `AnalyzeTemporaryDestructors`, which was deprecated since
   :program:`clang-tidy` 16.
 
 - Improved `--dump-config` to print check options in alphabetical order.
 
 New checks
 ^^^^^^^^^^
 
 - New :doc:`bugprone-inc-dec-in-conditions
   <clang-tidy/checks/bugprone/inc-dec-in-conditions>` check.
 
   Detects when a variable is both incremented/decremented and referenced inside
   a complex condition and suggests moving them outside to avoid ambiguity in
   the variable's value.
 
 - New :doc:`bugprone-incorrect-enable-if

 
 - Improved :doc:`modernize-use-std-print
   <clang-tidy/checks/modernize/use-std-print>` check to accurately generate
   fixes for reordering arguments.
 
 - Improved :doc:`performance-faster-string-find
   <clang-tidy/checks/performance/faster-string-find>` check to properly escape
   single quotes.
 
 - Improved :doc:`performance-noexcept-swap
   <clang-tidy/checks/performance/noexcept-swap>` check to enforce a stricter
   match with the swap function signature, eliminating false-positives.
 
 - Improved :doc:`readability-braces-around-statements
   <clang-tidy/checks/readability/braces-around-statements>` check to
   ignore false-positive for ``if constexpr`` in lambda expression.
 
 - Improved :doc:`readability-container-size-empty
   <clang-tidy/checks/readability/container-size-empty>` check to
   detect comparison between string and empty string literals.
 
 - Improved :doc:`readability-identifier-naming
   <clang-tidy/checks/readability/identifier-naming>` check to emit proper
-  warnings when a type forward declaration precedes its definition.
+  warnings when a type forward declaration precedes its definition and
+  added support for ``Leading_upper_snake_case`` naming convention.
 
 - Improved :doc:`readability-implicit-bool-conversion
   <clang-tidy/checks/readability/implicit-bool-conversion>` check to take
   do-while loops into account for the `AllowIntegerConditions` and
   `AllowPointerConditions` options.
 
 - Improved :doc:`readability-non-const-parameter
   <clang-tidy/checks/readability/non-const-parameter>` check to ignore
   false-positives in initializer list of record.
 

clang-tools-extra/docs/clang-tidy/checks/readability/identifier-naming.rst

 Casing types include:
 
  - ``lower_case``,
  - ``UPPER_CASE``,
  - ``camelBack``,
  - ``CamelCase``,
  - ``camel_Snake_Back``,
  - ``Camel_Snake_Case``,
- - ``aNy_CasE``.
+ - ``aNy_CasE``,
+ - ``Leading_upper_snake_case``.
 
 It also supports a fixed prefix and suffix that will be prepended or appended
 to the identifiers, regardless of the casing.
 
 Many configuration options are available, in order to be able to create
 different rules for different kinds of identifiers. In general, the rules are
 falling back to a more generic rule if the specific case is not configured.
 
 The naming of virtual methods is reported where they occur in the base class,
 but not where they are overridden, as it can't be fixed locally there.
 This also applies for pseudo-override patterns like CRTP.
 
+``Leading_upper_snake_case`` is a naming convention where the first word is capitalized
+followed by lower case word(s) seperated by underscore(s) '_'. Examples include:
+Cap_snake_case, Cobra_case, Foo_bar_baz, and Master_copy_8gb.
+
 Options
 -------
 
 The following options are described below:
 
  - :option:`AbstractClassCase`, :option:`AbstractClassPrefix`, :option:`AbstractClassSuffix`, :option:`AbstractClassIgnoredRegexp`, :option:`AbstractClassHungarianPrefix`
  - :option:`AggressiveDependentMemberLookup`
  - :option:`ClassCase`, :option:`ClassPrefix`, :option:`ClassSuffix`, :option:`ClassIgnoredRegexp`, :option:`ClassHungarianPrefix`

 
 .. option:: StructSuffix
 
     When defined, the check will ensure struct names will add the
     suffix with the given value (regardless of casing).
 
 For example using values of:
 
    - StructCase of ``lower_case``
    - StructPrefix of ``pre_``
    - StructSuffix of ``_post``
 
 Identifies and/or transforms struct names as follows:
 
 Before:
 
 .. code-block:: c++

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

 // RUN: clang-tidy %s -checks=readability-identifier-naming \
 // RUN:   -config="{CheckOptions: {\
 // RUN:   readability-identifier-naming.FunctionCase: camelback, \
 // RUN:   readability-identifier-naming.VariableCase: camelBack, \
 // RUN:   readability-identifier-naming.ClassCase: UUPER_CASE, \
 // RUN:   readability-identifier-naming.StructCase: CAMEL, \
 // RUN:   readability-identifier-naming.EnumCase: AnY_cASe, \
+// RUN:   readability-identifier-naming.VirtualMethodCase: lEaDiNg_upper_SNAKE_CaSe, \
 // RUN:   }}" -- 2>&1 | FileCheck %s --implicit-check-not="{{warning|error}}:"
 
 // CHECK-DAG: warning: invalid configuration value 'camelback' for option 'readability-identifier-naming.FunctionCase'; did you mean 'camelBack'? [clang-tidy-config]
 // CHECK-DAG: warning: invalid configuration value 'UUPER_CASE' for option 'readability-identifier-naming.ClassCase'; did you mean 'UPPER_CASE'? [clang-tidy-config]
 // Don't try to suggest an alternative for 'CAMEL'
 // CHECK-DAG: warning: invalid configuration value 'CAMEL' for option 'readability-identifier-naming.StructCase' [clang-tidy-config]
 // This fails on the EditDistance, but as it matches ignoring case suggest the correct value
 // CHECK-DAG: warning: invalid configuration value 'AnY_cASe' for option 'readability-identifier-naming.EnumCase'; did you mean 'aNy_CasE'? [clang-tidy-config]
+// CHECK-DAG: warning: invalid configuration value 'lEaDiNg_upper_SNAKE_CaSe' for option 'readability-identifier-naming.VirtualMethodCase'; did you mean 'Leading_upper_snake_case'? [clang-tidy-config]

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

 // RUN:     readability-identifier-naming.ConstantParameterCase: camelBack, \
 // RUN:     readability-identifier-naming.ConstantParameterPrefix: 'i_', \
 // RUN:     readability-identifier-naming.ParameterPackCase: camelBack, \
 // RUN:     readability-identifier-naming.PureFunctionCase: lower_case, \
 // RUN:     readability-identifier-naming.PureMethodCase: camelBack, \
 // RUN:     readability-identifier-naming.StaticConstantCase: UPPER_CASE, \
 // RUN:     readability-identifier-naming.StaticVariableCase: camelBack, \
 // RUN:     readability-identifier-naming.StaticVariablePrefix: 's_', \
-// RUN:     readability-identifier-naming.StructCase: lower_case, \
+// RUN:     readability-identifier-naming.StructCase: Leading_upper_snake_case, \
 // RUN:     readability-identifier-naming.TemplateParameterCase: UPPER_CASE, \
 // RUN:     readability-identifier-naming.TemplateTemplateParameterCase: CamelCase, \
 // RUN:     readability-identifier-naming.TemplateUsingCase: lower_case, \
 // RUN:     readability-identifier-naming.TemplateUsingPrefix: 'u_', \
 // RUN:     readability-identifier-naming.TypeTemplateParameterCase: camelBack, \
 // RUN:     readability-identifier-naming.TypeTemplateParameterSuffix: '_t', \
 // RUN:     readability-identifier-naming.TypedefCase: lower_case, \
 // RUN:     readability-identifier-naming.TypedefSuffix: '_t', \

 };
 
 constexpr int CE_function() { return 3; }
 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for constexpr function 'CE_function'
 // CHECK-FIXES: {{^}}constexpr int ce_function() { return 3; }{{$}}
 
 struct THIS___Structure {
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'THIS___Structure'
-// CHECK-FIXES: {{^}}struct this_structure {{{$}}
+// CHECK-FIXES: {{^}}struct This_structure {{{$}}
     THIS___Structure();
-// CHECK-FIXES: {{^}}    this_structure();{{$}}
+// CHECK-FIXES: {{^}}    This_structure();{{$}}
 
   union __MyUnion_is_wonderful__ {};
 // CHECK-MESSAGES: :[[@LINE-1]]:9: warning: invalid case style for union '__MyUnion_is_wonderful__'
 // CHECK-FIXES: {{^}}  union UMyUnionIsWonderful {};{{$}}
 };
 
 typedef THIS___Structure struct_type;
 // CHECK-MESSAGES: :[[@LINE-1]]:26: warning: invalid case style for typedef 'struct_type'
-// CHECK-FIXES: {{^}}typedef this_structure struct_type_t;{{$}}
+// CHECK-FIXES: {{^}}typedef This_structure struct_type_t;{{$}}
 
 struct_type GlobalTypedefTestFunction(struct_type a_argument1) {
 // CHECK-FIXES: {{^}}struct_type_t GlobalTypedefTestFunction(struct_type_t a_argument1) {
     struct_type typedef_test_1;
 // CHECK-FIXES: {{^}}    struct_type_t typedef_test_1;
 }
 
 using my_struct_type = THIS___Structure;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for type alias 'my_struct_type'
-// CHECK-FIXES: {{^}}using my_Struct_Type_t = this_structure;{{$}}
+// CHECK-FIXES: {{^}}using my_Struct_Type_t = This_structure;{{$}}
 
 template<typename t_t>
 using SomeOtherTemplate = my_other_templated_class  <:: FOO_NS  ::my_class>;
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for type alias 'SomeOtherTemplate'
 // CHECK-FIXES: {{^}}using some_Other_Template_t = CMyOtherTemplatedClass  <:: foo_ns  ::CMyClass>;{{$}}
 
 static void static_Function() {
 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: invalid case style for function 'static_Function'

 // CHECK-FIXES: {{^}}#define MY_TEST_MACRO(X) X()
 
 void MY_TEST_Macro(function) {}
 // CHECK-FIXES: {{^}}void MY_TEST_MACRO(function) {}
 }
 }
 
 template <typename t_t> struct a {
+// CHECK-MESSAGES: :[[@LINE-1]]:32: warning: invalid case style for struct 'a'
+// CHECK-FIXES: {{^}}template <typename t_t> struct A {{{$}}
   typename t_t::template b<> c;
 
   char const MY_ConstMember_string[4] = "123";
 // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: invalid case style for constant member 'MY_ConstMember_string'
 // CHECK-FIXES: {{^}}  char const my_const_member_string[4] = "123";{{$}}
 
   static char const MyConstClass_string[];
 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for class constant 'MyConstClass_string'
 // CHECK-FIXES: {{^}}  static char const kMyConstClassString[];{{$}}
 };
 
 template<typename t_t>
 char const a<t_t>::MyConstClass_string[] = "123";
-// CHECK-FIXES: {{^}}char const a<t_t>::kMyConstClassString[] = "123";{{$}}
+// CHECK-FIXES: {{^}}char const A<t_t>::kMyConstClassString[] = "123";{{$}}
 
 template <template <typename> class A> struct b { A<int> c; };
+// CHECK-MESSAGES: :[[@LINE-1]]:47: warning: invalid case style for struct 'b'
+// CHECK-FIXES:template <template <typename> class A> struct B { A<int> c; };{{$}}
 
 unsigned MY_GLOBAL_array[] = {1,2,3};
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for global variable 'MY_GLOBAL_array'
 // CHECK-FIXES: {{^}}unsigned g_my_global_array[] = {1,2,3};{{$}}
 
 unsigned const MyConstGlobal_array[] = {1,2,3};
 // CHECK-MESSAGES: :[[@LINE-1]]:16: warning: invalid case style for global constant 'MyConstGlobal_array'
 // CHECK-FIXES: {{^}}unsigned const MY_CONST_GLOBAL_ARRAY[] = {1,2,3};{{$}}

 
 using namespace FOO_NS;
 // CHECK-FIXES: {{^}}using namespace foo_ns;
 
 using namespace FOO_NS::InlineNamespace;
 // CHECK-FIXES: {{^}}using namespace foo_ns::inline_namespace;
 
 void QualifiedTypeLocTest(THIS___Structure);
-// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(this_structure);{{$}}
+// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure);{{$}}
 void QualifiedTypeLocTest(THIS___Structure &);
-// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(this_structure &);{{$}}
+// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure &);{{$}}
 void QualifiedTypeLocTest(THIS___Structure &&);
-// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(this_structure &&);{{$}}
+// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(This_structure &&);{{$}}
 void QualifiedTypeLocTest(const THIS___Structure);
-// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(const this_structure);{{$}}
+// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(const This_structure);{{$}}
 void QualifiedTypeLocTest(const THIS___Structure &);
-// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(const this_structure &);{{$}}
+// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(const This_structure &);{{$}}
 void QualifiedTypeLocTest(volatile THIS___Structure &);
-// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(volatile this_structure &);{{$}}
+// CHECK-FIXES: {{^}}void QualifiedTypeLocTest(volatile This_structure &);{{$}}
 
 namespace redecls {
 // We only want the warning to show up once here for the first decl.
 // CHECK-MESSAGES: :[[@LINE+1]]:6: warning: invalid case style for global function 'badNamedFunction'
 void badNamedFunction();
 void badNamedFunction();
 void badNamedFunction(){}
 //      CHECK-FIXES: {{^}}void BadNamedFunction();

 template<typename type_t>
 auto GetRes(type_t& Param) -> decltype(Param.res());
 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: invalid case style for parameter 'Param'
 // CHECK-FIXES: auto GetRes(type_t& a_param) -> decltype(a_param.res());
 
 // Check implicit declarations in coroutines
 
 struct async_obj {
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'async_obj'
+// CHECK-FIXES: {{^}}struct Async_obj {{{$}}
 public:
   never_suspend operator co_await() const noexcept;
 };
 
 task ImplicitDeclTest(async_obj &a_object) {
   co_await a_object;  // CHECK-MESSAGES-NOT: warning: invalid case style for local variable
 }
 
 // Test scenario when canonical declaration will be a forward declaration
 struct ForwardDeclStruct;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for struct 'ForwardDeclStruct' [readability-identifier-naming]
-// CHECK-FIXES: {{^}}struct forward_decl_struct;
-// CHECK-FIXES: {{^}}struct forward_decl_struct {
+// CHECK-FIXES: {{^}}struct Forward_decl_struct;
+// CHECK-FIXES: {{^}}struct Forward_decl_struct {
 struct ForwardDeclStruct {
 };
 
 struct forward_declared_as_struct;
 // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: invalid case style for class 'forward_declared_as_struct' [readability-identifier-naming]
 // CHECK-FIXES: {{^}}struct CForwardDeclaredAsStruct;
 // CHECK-FIXES: {{^}}class CForwardDeclaredAsStruct {
 class forward_declared_as_struct {
 };