[clang-tidy] Add scoped enum constants to identifier naming check

[njames93]

Summary

Added option ScopedEnumConstant(Prefix|Case|Suffix) to readability-identitied-naming.
This controls the style for constants in scoped enums, declared as enum (class|struct).
If this option is unspecified the EnumConstant style will be used instead.

[njames93]

Small tweak to the docs

[njames93]

Removed runtime check in release mode that EnumConstant DeclContext is a EnumDecl

[Eugene.Zelenko]

I think will be good idea to add test for suffix/prefix too.

[njames93]

In D89407#2333560, @Eugene.Zelenko wrote:

I think will be good idea to add test for suffix/prefix too.

Not strictly necessary, there are tests that make sure prefixes and suffixes are applied correctly. Then there are tests that make sure a type of decl is correctly matched against its style, this is one of these tests. You'll find that's the convention with most of the style types tests in here.

[aaron.ballman]

LGTM aside from a minor nit.

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

410

There's no need for this assertion, the use of cast<> below will assert if the type is wrong.

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

 
 namespace readability {
 
 // clang-format off
 #define NAMING_KEYS(m) \
     m(Namespace) \
     m(InlineNamespace) \
     m(EnumConstant) \
+    m(ScopedEnumConstant) \
     m(ConstexprVariable) \
     m(ConstantMember) \
     m(PrivateMember) \
     m(ProtectedMember) \
     m(PublicMember) \
     m(Member) \
     m(ClassConstant) \
     m(ClassMember) \
if (const auto *Decl = dyn_cast<NamespaceDecl>(D)) {
 
     if (NamingStyles[SK_Namespace])
       return SK_Namespace;
   }
 
   if (isa<EnumDecl>(D) && NamingStyles[SK_Enum])
     return SK_Enum;
 
-  if (isa<EnumConstantDecl>(D)) {
+  if (const auto *EnumConst = dyn_cast<EnumConstantDecl>(D)) {
+    assert(isa<EnumDecl>(EnumConst->getDeclContext()) &&
+           "DeclContext of EnumConstant should be EnumDecl");
+
+    if (cast<EnumDecl>(EnumConst->getDeclContext())->isScoped() &&
+        NamingStyles[SK_ScopedEnumConstant])
+      return SK_ScopedEnumConstant;
+
     if (NamingStyles[SK_EnumConstant])
       return SK_EnumConstant;
 
     if (NamingStyles[SK_Constant])
       return SK_Constant;
 
     return SK_Invalid;
   }

clang-tools-extra/docs/ReleaseNotes.rst

 ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 - Improved :doc:`readability-identifier-naming
   <clang-tidy/checks/readability-identifier-naming>` check.
 
   Added an option `GetConfigPerFile` to support including files which use
   different naming styles.
 
+  Added support for specifying the style of scoped ``enum`` constants. If 
+  unspecified, will fall back to the style for regular ``enum`` constants.
+
 - Removed `google-runtime-references` check because the rule it checks does
   not exist in the Google Style Guide anymore.
 
 Improvements to include-fixer
 -----------------------------
 
 The improvements are...
 

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

  - :option:`ParameterPackCase`, :option:`ParameterPackPrefix`, :option:`ParameterPackSuffix`
  - :option:`PointerParameterCase`, :option:`PointerParameterPrefix`, :option:`PointerParameterSuffix`
  - :option:`PrivateMemberCase`, :option:`PrivateMemberPrefix`, :option:`PrivateMemberSuffix`
  - :option:`PrivateMethodCase`, :option:`PrivateMethodPrefix`, :option:`PrivateMethodSuffix`
  - :option:`ProtectedMemberCase`, :option:`ProtectedMemberPrefix`, :option:`ProtectedMemberSuffix`
  - :option:`ProtectedMethodCase`, :option:`ProtectedMethodPrefix`, :option:`ProtectedMethodSuffix`
  - :option:`PublicMemberCase`, :option:`PublicMemberPrefix`, :option:`PublicMemberSuffix`
  - :option:`PublicMethodCase`, :option:`PublicMethodPrefix`, :option:`PublicMethodSuffix`
+ - :option:`ScopedEnumConstantCase`, :option:`ScopedEnumConstantPrefix`, :option:`ScopedEnumConstantSuffix`
  - :option:`StaticConstantCase`, :option:`StaticConstantPrefix`, :option:`StaticConstantSuffix`
  - :option:`StaticVariableCase`, :option:`StaticVariablePrefix`, :option:`StaticVariableSuffix`
  - :option:`StructCase`, :option:`StructPrefix`, :option:`StructSuffix`
  - :option:`TemplateParameterCase`, :option:`TemplateParameterPrefix`, :option:`TemplateParameterSuffix`
  - :option:`TemplateTemplateParameterCase`, :option:`TemplateTemplateParameterPrefix`, :option:`TemplateTemplateParameterSuffix`
  - :option:`TypeAliasCase`, :option:`TypeAliasPrefix`, :option:`TypeAliasSuffix`
  - :option:`TypedefCase`, :option:`TypedefPrefix`, :option:`TypedefSuffix`
  - :option:`TypeTemplateParameterCase`, :option:`TypeTemplateParameterPrefix`, :option:`TypeTemplateParameterSuffix`

 
 .. code-block:: c++
 
     class Foo {
     public:
       int pre_member_method_post();
     }
 
+.. option:: ScopedEnumConstantCase
+
+    When defined, the check will ensure scoped enum constant names conform to 
+    the selected casing.
+
+.. option:: ScopedEnumConstantPrefix
+
+    When defined, the check will ensure scoped enum constant names will add the
+    prefixed with the given value (regardless of casing).
+
+.. option:: ScopedEnumConstantSuffix
+
+    When defined, the check will ensure scoped enum constant names will add the
+    suffix with the given value (regardless of casing).
+
+For example using values of:
+
+   - ScopedEnumConstantCase of ``lower_case``
+   - ScopedEnumConstantPrefix of ``pre_``
+   - ScopedEnumConstantSuffix of ``_post``
+
+Identifies and/or transforms enumeration constant names as follows:
+
+Before:
+
+.. code-block:: c++
+
+    enum class FOO { One, Two, Three };
+
+After:
+
+.. code-block:: c++
+
+    enum class FOO { pre_One_post, pre_Two_post, pre_Three_post };
+
 .. option:: StaticConstantCase
 
     When defined, the check will ensure static constant names conform to the
     selected casing.
 
 .. option:: StaticConstantPrefix
 
     When defined, the check will ensure static constant names will add the

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

 // RUN:     {key: readability-identifier-naming.ClassMethodCase, value: camelBack}, \
 // RUN:     {key: readability-identifier-naming.ConstantCase, value: UPPER_CASE}, \
 // RUN:     {key: readability-identifier-naming.ConstantSuffix, value: '_CST'}, \
 // RUN:     {key: readability-identifier-naming.ConstexprFunctionCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.ConstexprMethodCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.ConstexprVariableCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.EnumCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.EnumPrefix, value: 'E'}, \
+// RUN:     {key: readability-identifier-naming.ScopedEnumConstantCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.EnumConstantCase, value: UPPER_CASE}, \
 // RUN:     {key: readability-identifier-naming.FunctionCase, value: camelBack}, \
 // RUN:     {key: readability-identifier-naming.GlobalConstantCase, value: UPPER_CASE}, \
 // RUN:     {key: readability-identifier-naming.GlobalFunctionCase, value: CamelCase}, \
 // RUN:     {key: readability-identifier-naming.GlobalVariableCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.GlobalVariablePrefix, value: 'g_'}, \
 // RUN:     {key: readability-identifier-naming.InlineNamespaceCase, value: lower_case}, \
 // RUN:     {key: readability-identifier-naming.LocalConstantCase, value: CamelCase}, \
// CHECK-FIXES: {{^}}    MY_CONSTANT = 1,{{$}}
     your_CONST = 1,
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'your_CONST'
 // CHECK-FIXES: {{^}}    YOUR_CONST = 1,{{$}}
     THIS_ConstValue = 1,
 // CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for enum constant 'THIS_ConstValue'
 // CHECK-FIXES: {{^}}    THIS_CONST_VALUE = 1,{{$}}
 };
 
+enum class EMyEnumeration {
+    myConstant = 1,
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'myConstant'
+// CHECK-FIXES: {{^}}    MyConstant = 1,{{$}}
+    your_CONST = 1,
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'your_CONST'
+// CHECK-FIXES: {{^}}    YourConst = 1,{{$}}
+    THIS_ConstValue = 1,
+// CHECK-MESSAGES: :[[@LINE-1]]:5: warning: invalid case style for scoped enum constant 'THIS_ConstValue'
+// CHECK-FIXES: {{^}}    ThisConstValue = 1,{{$}}
+};
+
 constexpr int ConstExpr_variable = MyConstant;
 // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: invalid case style for constexpr variable 'ConstExpr_variable'
 // CHECK-FIXES: {{^}}constexpr int const_expr_variable = MY_CONSTANT;{{$}}
 
 class my_class {
 // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: invalid case style for class 'my_class'
 // CHECK-FIXES: {{^}}class CMyClass {{{$}}
 public: