[clang-tidy] readability-identifier-naming - support for other case types

[JamesReynolds]

Summary

Added Camel_Snake_Case and camel_Snake_Back

class Camel_Snake_Case_Class_Name
{
  void private_Camel_Snake_Back_Method_Name();
}

[JamesReynolds]

I'm not 100% sure that my regexes are the best balance between readability and terseness - or that I've named the case types particularly well. If there are better ideas for either of those things I'm very happy to accept criticism!

[alexfh]

IIUC, Stroustrup style mandates Single_capital_letter_to_start_a_type_name (http://www.stroustrup.com/Programming/PPP-style.pdf). So both styles you're adding in this patch should not be named after Stroustrup. Also, do these come from real-life projects/requirements or is it just a desire to add eVERYpOSSIBLEsTYLEiNtHEwORLD? ;)

[JamesReynolds]

Ah, I took this from a single example in the CPP core guidelines - that PDF is indeed a very different style. An idea we toyed with was "UpperSeparated" and "UpperSeparatedBack"? Would that work?

This comes from a concession to Window developers in a large commercial codebase with a Windows origin. I'll admit it isn't my favourite style but for class names and functions it eventually grows on you. At least I got them to let go of the SHOUTING_TYPEDEFS..!

[alexfh]

In D21472#473813, @JamesReynolds wrote:

Ah, I took this from a single example in the CPP core guidelines - that PDF is indeed a very different style. An idea we toyed with was "UpperSeparated" and "UpperSeparatedBack"? Would that work?

You mean Upper_Separated and upper_Separated_Back? ;) Actually, these names are not particularly clear. I've managed to find "Camel_Snake_Case" used for exactly this naming convention (in the https://github.com/t6/camel_snake_kebab library). Maybe "camel_Snake_Back" as well?

This comes from ...

I just wanted to hear that this is actually going to be used. No objections.

[JamesReynolds]

You mean Upper_Separated and upper_Separated_Back? ;) Actually, these names are not particularly clear. I've managed to find "Camel_Snake_Case"
used for exactly this naming convention (in the https://github.com/t6/camel_snake_kebab library). Maybe "camel_Snake_Back" as well?

Thank you, a very good find! I've changed the patch accordingly.

[alexfh]

LG

[JamesReynolds]

Thank you! Can you land this for me please?

This is me done for the time being, but once our implementation gets into the swing of things I'll try and start picking up some bugs / enhancements.

clang-tidy/readability/IdentifierNamingCheck.h

public:
   void onEndOfTranslationUnit() override;
 
   enum CaseType {
     CT_AnyCase = 0,
     CT_LowerCase,
     CT_CamelBack,
     CT_UpperCase,
     CT_CamelCase,
+    CT_CamelSnakeCase,
+    CT_CamelSnakeBack
   };
 
   struct NamingStyle {
     NamingStyle() : Case(CT_AnyCase) {}
 
     NamingStyle(CaseType Case, const std::string &Prefix,
                 const std::string &Suffix)
         : Case(Case), Prefix(Prefix), Suffix(Suffix) {}

clang-tidy/readability/IdentifierNamingCheck.cpp

IdentifierNamingCheck::IdentifierNamingCheck(StringRef Name,
                                              ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context) {
   auto const fromString = [](StringRef Str) {
     return llvm::StringSwitch<CaseType>(Str)
         .Case("lower_case", CT_LowerCase)
         .Case("UPPER_CASE", CT_UpperCase)
         .Case("camelBack", CT_CamelBack)
         .Case("CamelCase", CT_CamelCase)
+        .Case("Camel_Snake_Case", CT_CamelSnakeCase)
+        .Case("camel_Snake_Back", CT_CamelSnakeBack)
         .Default(CT_AnyCase);
   };
 
   for (auto const &Name : StyleNames) {
     NamingStyles.push_back(
         NamingStyle(fromString(Options.get((Name + "Case").str(), "")),
                     Options.get((Name + "Prefix").str(), ""),
                     Options.get((Name + "Suffix").str(), "")));
auto const toString = [](CaseType Type) {
     case CT_LowerCase:
       return "lower_case";
     case CT_CamelBack:
       return "camelBack";
     case CT_UpperCase:
       return "UPPER_CASE";
     case CT_CamelCase:
       return "CamelCase";
+    case CT_CamelSnakeCase:
+      return "Camel_Snake_Case";
+    case CT_CamelSnakeBack:
+      return "camel_Snake_Back";
     }
 
     llvm_unreachable("Unknown Case Type");
   };
 
   for (size_t i = 0; i < SK_Count; ++i) {
     Options.store(Opts, (StyleNames[i] + "Case").str(),
                   toString(NamingStyles[i].Case));

 static bool matchesStyle(StringRef Name,
                          IdentifierNamingCheck::NamingStyle Style) {
   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])?)*"),
   };
 
   bool Matches = true;
   if (Name.startswith(Style.Prefix))
     Name = Name.drop_front(Style.Prefix.size());
   else
     Matches = false;
 
for (auto const &Word : Words) {
       if (&Word == &Words.front()) {
         Fixup += Word.lower();
       } else {
         Fixup += Word.substr(0, 1).upper();
         Fixup += Word.substr(1).lower();
       }
     }
     break;
+
+  case IdentifierNamingCheck::CT_CamelSnakeCase:
+    for (auto const &Word : Words) {
+      if (&Word != &Words.front())
+        Fixup += "_";
+      Fixup += Word.substr(0, 1).upper();
+      Fixup += Word.substr(1).lower();
+    }
+    break;
+
+  case IdentifierNamingCheck::CT_CamelSnakeBack:
+    for (auto const &Word : Words) {
+      if (&Word != &Words.front()) {
+        Fixup += "_";
+        Fixup += Word.substr(0, 1).upper();
+      } else {
+        Fixup += Word.substr(0, 1).lower();
+      }
+      Fixup += Word.substr(1).lower();
+    }
+    break;
   }
 
   return Fixup;
 }
 
 static std::string fixupWithStyle(StringRef Name,
                                   IdentifierNamingCheck::NamingStyle Style) {
   return Style.Prefix + fixupWithCase(Name, Style.Case) + Style.Suffix;

test/clang-tidy/readability-identifier-naming.cpp

 // RUN:     {key: readability-identifier-naming.TypeTemplateParameterSuffix, value: '_t'}, \
 // RUN:     {key: readability-identifier-naming.TypedefCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.TypedefSuffix, value: '_t'}, \
 // RUN:     {key: readability-identifier-naming.UnionCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.UnionPrefix, value: 'U'}, \
 // RUN:     {key: readability-identifier-naming.UsingCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.ValueTemplateParameterCase, value: camelBack}, \
 // RUN:     {key: readability-identifier-naming.VariableCase, value: lower_case}, \
-// RUN:     {key: readability-identifier-naming.VirtualMethodCase, value: UPPER_CASE}, \
+// RUN:     {key: readability-identifier-naming.VirtualMethodCase, value: Camel_Snake_Case}, \
 // RUN:     {key: readability-identifier-naming.VirtualMethodPrefix, value: 'v_'}, \
 // RUN:     {key: readability-identifier-naming.MacroDefinitionCase, value: UPPER_CASE}, \
-// RUN:     {key: readability-identifier-naming.TypeAliasCase, value: lower_case}, \
+// RUN:     {key: readability-identifier-naming.TypeAliasCase, value: camel_Snake_Back}, \
 // RUN:     {key: readability-identifier-naming.TypeAliasSuffix, value: '_t'}, \
 // RUN:     {key: readability-identifier-naming.IgnoreFailedSplit, value: 0} \
 // RUN:   ]}' -- -std=c++11 -fno-delayed-template-parsing \
 // RUN:   -I%S/Inputs/readability-identifier-naming \
 // RUN:   -isystem %S/Inputs/readability-identifier-naming/system
 
 // clang-format off
 

 
 class abstract_class {
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for abstract class 'abstract_class'
 // CHECK-FIXES: {{^}}class AAbstractClass {{{$}}
     virtual ~abstract_class() = 0;
 // CHECK-FIXES: {{^}}    virtual ~AAbstractClass() = 0;{{$}}
     virtual void VIRTUAL_METHOD();
 // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: invalid case style for virtual method 'VIRTUAL_METHOD'
-// CHECK-FIXES: {{^}}    virtual void v_VIRTUAL_METHOD();{{$}}
+// CHECK-FIXES: {{^}}    virtual void v_Virtual_Method();{{$}}
     void non_Virtual_METHOD() {}
 // CHECK-MESSAGES: :[[@LINE-1]]:10: warning: invalid case style for private method 'non_Virtual_METHOD'
 // CHECK-FIXES: {{^}}    void __non_Virtual_METHOD() {}{{$}}
 
 public:
     static void CLASS_METHOD() {}
 // CHECK-MESSAGES: :[[@LINE-1]]:17: warning: invalid case style for class method 'CLASS_METHOD'
 // CHECK-FIXES: {{^}}    static void classMethod() {}{{$}}

 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>;{{$}}
+// 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: {{^}}static void staticFunction() {{{$}}
 
   ::FOO_NS::InlineNamespace::abstract_class::CLASS_METHOD();
 // CHECK-FIXES: {{^}}  ::foo_ns::inline_namespace::AAbstractClass::classMethod();{{$}}
   ::FOO_NS::InlineNamespace::static_Function();