Avoid adding redundant parens.

[bkramer]

Very nice, lgtm.

[alexfh]

Closed by commit rL213149 (authored by @alexfh).

clang-tools-extra/trunk/clang-tidy/google/AvoidCStyleCastsCheck.cpp

bool pointedTypesAreEqual(QualType SourceType, QualType DestType) {
   SourceType = SourceType.getNonReferenceType();
   DestType = DestType.getNonReferenceType();
   while (SourceType->isPointerType() && DestType->isPointerType()) {
     SourceType = SourceType->getPointeeType();
     DestType = DestType->getPointeeType();
   }
   return SourceType.getUnqualifiedType() == DestType.getUnqualifiedType();
 }
+
 void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *CastExpr = Result.Nodes.getNodeAs<CStyleCastExpr>("cast");
 
   // Casting to void is an idiomatic way to mute "unused variable" and similar
   // warnings.
   if (CastExpr->getTypeAsWritten()->isVoidType())
     return;
 
void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
 
   auto diag_builder =
       diag(CastExpr->getLocStart(), "C-style casts are discouraged. %0");
 
   auto ReplaceWithCast = [&](StringRef CastType) {
     diag_builder << ("Use " + CastType + ".").str();
     if (ParenRange.getBegin().isMacroID() || ParenRange.getEnd().isMacroID())
       return;
-    diag_builder << FixItHint::CreateReplacement(
-                        ParenRange,
-                        (CastType + "<" + DestTypeString + ">(").str())
-                 << FixItHint::CreateInsertion(
-                        Lexer::getLocForEndOfToken(
-                            CastExpr->getSubExprAsWritten()->getLocEnd(), 0,
+
+    const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
+    std::string CastText = (CastType + "<" + DestTypeString + ">").str();
+    if (!isa<ParenExpr>(SubExpr)) {
+      CastText.push_back('(');
+      diag_builder << FixItHint::CreateInsertion(
+          Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0,
                                      *Result.SourceManager,
                                      Result.Context->getLangOpts()),
-                        ")");
+    }
+    diag_builder << FixItHint::CreateReplacement(ParenRange, CastText);
   };
   // Suggest appropriate C++ cast. See [expr.cast] for cast notation semantics.
   switch (CastExpr->getCastKind()) {
   case CK_NoOp:
     if (needsConstCast(SourceType, DestType) &&
         pointedTypesAreEqual(SourceType, DestType)) {
       ReplaceWithCast("const_cast");
       return;

clang-tools-extra/trunk/test/clang-tidy/avoid-c-style-casts.cpp

void f(int a, double b, const char *cpc, const void *cpv, X *pX) {
   // 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);
 
   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);
 
   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);
 
   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);
 
+  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));
+
+  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);
+
+  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));
+
+
   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]