[clang-tidy] Handle c-style casts from/to enums.

[alexfh]

Summary

Convert c-style casts between integral end enum types to static_cast<>.

[klimek]

lg

clang-tidy/google/AvoidCStyleCastsCheck.cpp

85–89

Why does getTypeAsWritten not work any more? Perhaps add a comment explaining that...

[alexfh]

clang-tidy/google/AvoidCStyleCastsCheck.cpp

85–89

getTypeAsWritten().getAsString() normalizes spelling of types in certain ways, e.g. "char*" -> "char *", "SomeEnum" -> "enum SomeEnum", which we don't want to do.

[klimek]

clang-tidy/google/AvoidCStyleCastsCheck.cpp

85–89

The char* -> char * we don't really care about. The enum seems important, thus putting that into a comment would be nice.

clang-tidy/google/AvoidCStyleCastsCheck.cpp

diag(CastExpr->getLocStart(), "Redundant cast to the same type.")
         << FixItHint::CreateRemoval(ParenRange);
     return;
   }
 
   // The rest of this check is only relevant to C++.
   if (!Result.Context->getLangOpts().CPlusPlus)
     return;
 
-  std::string DestTypeString = CastExpr->getTypeAsWritten().getAsString();
+  StringRef DestTypeString = Lexer::getSourceText(
+      CharSourceRange::getTokenRange(
+          CastExpr->getLParenLoc().getLocWithOffset(1),
+          CastExpr->getRParenLoc().getLocWithOffset(-1)),
+      *Result.SourceManager, Result.Context->getLangOpts());
 
   auto diag_builder =
       diag(CastExpr->getLocStart(), "C-style casts are discouraged. %0");
 
   auto ReplaceWithCast = [&](StringRef CastType) {
     diag_builder << ("Use " + CastType + ".").str();
 
     const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
case CK_NoOp:
     }
     if (DestType->isReferenceType() &&
         (SourceType.getNonReferenceType() ==
              DestType.getNonReferenceType().withConst() ||
          SourceType.getNonReferenceType() == DestType.getNonReferenceType())) {
       ReplaceWithCast("const_cast");
       return;
     }
-    if (SourceType->isBuiltinType() && DestType->isBuiltinType()) {
+    // FALLTHROUGH
+  case clang::CK_IntegralCast:
+    // Convert integral and no-op casts between builtin types and enums to
+    // static_cast. A cast from enum to integer may be unnecessary, but it's
+    // still retained.
+    if ((SourceType->isBuiltinType() || SourceType->isEnumeralType()) &&
+        (DestType->isBuiltinType() || DestType->isEnumeralType())) {
       ReplaceWithCast("static_cast");
       return;
     }
     break;
   case CK_BitCast:
     // FIXME: Suggest const_cast<...>(reinterpret_cast<...>(...)) replacement.
     if (!needsConstCast(SourceType, DestType)) {
       ReplaceWithCast("reinterpret_cast");

test/clang-tidy/avoid-c-style-casts.cpp

 // RUN: $(dirname %s)/check_clang_tidy_fix.sh %s google-readability-casting %t
 // REQUIRES: shell
 
 bool g() { return false; }
 
+enum Enum { Enum1 };
 struct X {};
 struct Y : public X {};
 
 void f(int a, double b, const char *cpc, const void *cpv, X *pX) {
   const char *cpc2 = (const char*)cpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: Redundant cast to the same type. [google-readability-casting]
   // CHECK-FIXES: const char *cpc2 = cpc;
 
   char *pc = (char*)cpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged. Use const_cast. {{.*}}
-  // CHECK-FIXES: char *pc = const_cast<char *>(cpc);
+  // CHECK-FIXES: char *pc = const_cast<char*>(cpc);
 
   char *pc2 = (char*)(cpc + 33);
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: C-style casts are discouraged. Use const_cast. {{.*}}
-  // CHECK-FIXES: char *pc2 = const_cast<char *>(cpc + 33);
+  // CHECK-FIXES: char *pc2 = const_cast<char*>(cpc + 33);
 
   const char &crc = *cpc;
   char &rc = (char&)crc;
   // CHECK-MESSAGES: :[[@LINE-1]]:14: warning: C-style casts are discouraged. Use const_cast. {{.*}}
-  // CHECK-FIXES: char &rc = const_cast<char &>(crc);
+  // CHECK-FIXES: char &rc = const_cast<char&>(crc);
 
   char &rc2 = (char&)*cpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: C-style casts are discouraged. Use const_cast. {{.*}}
-  // CHECK-FIXES: char &rc2 = const_cast<char &>(*cpc);
+  // CHECK-FIXES: char &rc2 = const_cast<char&>(*cpc);
 
   char ** const* const* ppcpcpc;
   char ****ppppc = (char****)ppcpcpc;
   // CHECK-MESSAGES: :[[@LINE-1]]:20: warning: C-style casts are discouraged. Use const_cast. {{.*}}
-  // CHECK-FIXES: char ****ppppc = const_cast<char ****>(ppcpcpc);
+  // CHECK-FIXES: char ****ppppc = const_cast<char****>(ppcpcpc);
 
   char ***pppc = (char***)*(ppcpcpc);
   // CHECK-MESSAGES: :[[@LINE-1]]:18: warning: C-style casts are discouraged. Use const_cast. {{.*}}
-  // CHECK-FIXES: char ***pppc = const_cast<char ***>(*(ppcpcpc));
+  // CHECK-FIXES: char ***pppc = const_cast<char***>(*(ppcpcpc));
 
   char ***pppc2 = (char***)(*ppcpcpc);
   // CHECK-MESSAGES: :[[@LINE-1]]:19: warning: C-style casts are discouraged. Use const_cast. {{.*}}
-  // CHECK-FIXES: char ***pppc2 = const_cast<char ***>(*ppcpcpc);
+  // CHECK-FIXES: char ***pppc2 = const_cast<char***>(*ppcpcpc);
 
   char *pc5 = (char*)(const char*)(cpv);
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: C-style casts are discouraged. Use const_cast. {{.*}}
   // CHECK-MESSAGES: :[[@LINE-2]]:22: warning: C-style casts are discouraged. Use reinterpret_cast. {{.*}}
-  // CHECK-FIXES: char *pc5 = const_cast<char *>(reinterpret_cast<const char *>(cpv));
+  // CHECK-FIXES: char *pc5 = const_cast<char*>(reinterpret_cast<const char*>(cpv));
 
-
   int b1 = (int)b;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: C-style casts are discouraged. Use static_cast. [google-readability-casting]
   // CHECK-FIXES: int b1 = static_cast<int>(b);
 
   Y *pB = (Y*)pX;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: C-style casts are discouraged. Use static_cast/const_cast/reinterpret_cast. [google-readability-casting]
   Y &rB = (Y&)*pX;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: C-style casts are discouraged. Use static_cast/const_cast/reinterpret_cast. [google-readability-casting]
 
   const char *pc3 = (const char*)cpv;
   // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: C-style casts are discouraged. Use reinterpret_cast. [google-readability-casting]
-  // CHECK-FIXES: const char *pc3 = reinterpret_cast<const char *>(cpv);
+  // CHECK-FIXES: const char *pc3 = reinterpret_cast<const char*>(cpv);
 
   char *pc4 = (char*)cpv;
   // CHECK-MESSAGES: :[[@LINE-1]]:15: warning: C-style casts are discouraged. Use static_cast/const_cast/reinterpret_cast. [google-readability-casting]
   // CHECK-FIXES: char *pc4 = (char*)cpv;
 
+  b1 = (int)Enum1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: C-style casts are discouraged. Use static_cast. [google-readability-casting]
+  // CHECK-FIXES: b1 = static_cast<int>(Enum1);
+
+  Enum e = (Enum)b1;
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: C-style casts are discouraged. Use static_cast. [google-readability-casting]
+  // CHECK-FIXES: Enum e = static_cast<Enum>(b1);
+
   // CHECK-MESSAGES-NOT: warning:
   int b2 = int(b);
   int b3 = static_cast<double>(b);
   int b4 = b;
   double aa = a;
   (void)b2;
   return (void)g();
 }