[clang-tidy] Ignore blank spaces between cast's ")" and its sub expr.

[hokein]

Summary

Before the change:

auto i = (Enum) 5; => auto i = static_cast<Enum>( 5);

After the change:

auto i = (Enum) 5; => auto i = static_cast<Enum>(5);

[alexfh]

Sorry, missed your patch somehow. LG with one nit.

clang-tidy/google/AvoidCStyleCastsCheck.cpp

139 ↗

(On Diff #94165)

Why is this only done on non-parenthesized expressions? Will (int) (b) turn into static_cast<int> (b) as well?

[alexfh]

You might want to commit this at some point ;]

[hokein]

Support more cases.

[hokein]

You might want to commit this at some point ;]

I somewhat forgot this minor patch.

clang-tidy/google/AvoidCStyleCastsCheck.cpp

139 ↗

(On Diff #94165)

Good point, I have updated the patch to cover more cases. Please take a look again.

[alexfh]

LG. Thanks!

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

while ((T1->isPointerType() && T2->isPointerType()) ||
     T1 = T1->getPointeeType();
     T2 = T2->getPointeeType();
   }
   return T1.getUnqualifiedType() == T2.getUnqualifiedType();
 }
 
 void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *CastExpr = Result.Nodes.getNodeAs<CStyleCastExpr>("cast");
-  auto ParenRange = CharSourceRange::getTokenRange(CastExpr->getLParenLoc(),
-                                                   CastExpr->getRParenLoc());
+
   // Ignore casts in macros.
-  if (ParenRange.getBegin().isMacroID() || ParenRange.getEnd().isMacroID())
+  if (CastExpr->getExprLoc().isMacroID())
     return;
 
   // Casting to void is an idiomatic way to mute "unused variable" and similar
   // warnings.
   if (CastExpr->getCastKind() == CK_ToVoid)
     return;
 
   auto isFunction = [](QualType T) {
     T = T.getCanonicalType().getNonReferenceType();
     return T->isFunctionType() || T->isFunctionPointerType() ||
            T->isMemberFunctionPointerType();
   };
 
   const QualType DestTypeAsWritten =
       CastExpr->getTypeAsWritten().getUnqualifiedType();
   const QualType SourceTypeAsWritten =
       CastExpr->getSubExprAsWritten()->getType().getUnqualifiedType();
   const QualType SourceType = SourceTypeAsWritten.getCanonicalType();
   const QualType DestType = DestTypeAsWritten.getCanonicalType();
 
+  auto ReplaceRange = CharSourceRange::getCharRange(
+      CastExpr->getLParenLoc(), CastExpr->getSubExprAsWritten()->getLocStart());
+
   bool FnToFnCast =
       isFunction(SourceTypeAsWritten) && isFunction(DestTypeAsWritten);
 
   if (CastExpr->getCastKind() == CK_NoOp && !FnToFnCast) {
     // Function pointer/reference casts may be needed to resolve ambiguities in
     // case of overloaded functions, so detection of redundant casts is trickier
     // in this case. Don't emit "redundant cast" warnings for function
     // pointer/reference types.
     if (SourceTypeAsWritten == DestTypeAsWritten) {
       diag(CastExpr->getLocStart(), "redundant cast to the same type")
-          << FixItHint::CreateRemoval(ParenRange);
+          << FixItHint::CreateRemoval(ReplaceRange);
       return;
     }
   }
 
   // The rest of this check is only relevant to C++.
   if (!getLangOpts().CPlusPlus)
     return;
   // Ignore code inside extern "C" {} blocks.
auto ReplaceWithCast = [&](std::string CastText) {
     const Expr *SubExpr = CastExpr->getSubExprAsWritten()->IgnoreImpCasts();
     if (!isa<ParenExpr>(SubExpr)) {
       CastText.push_back('(');
       Diag << FixItHint::CreateInsertion(
           Lexer::getLocForEndOfToken(SubExpr->getLocEnd(), 0, SM,
                                      getLangOpts()),
           ")");
     }
-    Diag << FixItHint::CreateReplacement(ParenRange, CastText);
+    Diag << FixItHint::CreateReplacement(ReplaceRange, CastText);
   };
   auto ReplaceWithNamedCast = [&](StringRef CastType) {
     Diag << CastType;
     ReplaceWithCast((CastType + "<" + DestTypeString + ">").str());
   };
 
   // Suggest appropriate C++ cast. See [expr.cast] for cast notation semantics.
   switch (CastExpr->getCastKind()) {

clang-tools-extra/trunk/test/clang-tidy/google-readability-casting.cpp

void f(int a, double b, const char *cpc, const void *cpv, X *pX) {
 
   int b1 = (int)b;
   // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: {{.*}}; use static_cast [
   // CHECK-FIXES: int b1 = static_cast<int>(b);
   b1 = (const int&)b;
   // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
   // CHECK-FIXES: b1 = (const int&)b;
 
+  b1 = (int) b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
+  // CHECK-FIXES: b1 = static_cast<int>(b);
+
+  b1 = (int)         b;
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
+  // CHECK-FIXES: b1 = static_cast<int>(b);
+
+  b1 = (int) (b);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
+  // CHECK-FIXES: b1 = static_cast<int>(b);
+
+  b1 = (int)         (b);
+  // CHECK-MESSAGES: :[[@LINE-1]]:8: warning: {{.*}}; use static_cast {{.*}}
+  // CHECK-FIXES: b1 = static_cast<int>(b);
+
   Y *pB = (Y*)pX;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
   Y &rB = (Y&)*pX;
   // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: {{.*}}; use static_cast/const_cast/reinterpret_cast [
 
   const char *pc3 = (const char*)cpv;
   // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: {{.*}}; use static_cast [
   // CHECK-FIXES: const char *pc3 = static_cast<const char*>(cpv);
void f(int a, double b, const char *cpc, const void *cpv, X *pX) {
   e = (Enum)Enum1;
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
   // CHECK-FIXES: {{^}}  e = Enum1;
 
   e = (Enum)e;
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
   // CHECK-FIXES: {{^}}  e = e;
 
+  e = (Enum)           e;
+  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
+  // CHECK-FIXES: {{^}}  e = e;
+
+  e = (Enum)           (e);
+  // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: redundant cast to the same type
+  // CHECK-FIXES: {{^}}  e = (e);
+
   static const int kZero = 0;
   (int)kZero;
   // CHECK-MESSAGES: :[[@LINE-1]]:3: warning: redundant cast to the same type
   // CHECK-FIXES: {{^}}  kZero;
 
   int b2 = int(b);
   int b3 = static_cast<double>(b);
   int b4 = b;