Fixed google-readability-casting test to work in c++17

[SureYeaah]

Summary

Fixed google-readability-casting.cpp to get tests working in c++17

[gribozavr]

I'll commit this change.

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

void AvoidCStyleCastsCheck::check(const MatchFinder::MatchResult &Result) {
   const QualType DestType = DestTypeAsWritten.getCanonicalType();
 
   auto ReplaceRange = CharSourceRange::getCharRange(
       CastExpr->getLParenLoc(), CastExpr->getSubExprAsWritten()->getBeginLoc());
 
   bool FnToFnCast =
       isFunction(SourceTypeAsWritten) && isFunction(DestTypeAsWritten);
 
+  const bool ConstructorCast = !CastExpr->getTypeAsWritten().hasQualifiers() &&
+      DestTypeAsWritten->isRecordType() &&
+      !DestTypeAsWritten->isElaboratedTypeSpecifier();
+
   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->getBeginLoc(), "redundant cast to the same type")
           << FixItHint::CreateRemoval(ReplaceRange);
if (!isa<ParenExpr>(SubExpr)) {
           ")");
     }
     Diag << FixItHint::CreateReplacement(ReplaceRange, CastText);
   };
   auto ReplaceWithNamedCast = [&](StringRef CastType) {
     Diag << CastType;
     ReplaceWithCast((CastType + "<" + DestTypeString + ">").str());
   };
-
+  auto ReplaceWithConstructorCall = [&]() {
+    Diag << "constructor call syntax";
+    // FIXME: Validate DestTypeString, maybe.
+    ReplaceWithCast(DestTypeString.str());
+  };
   // Suggest appropriate C++ cast. See [expr.cast] for cast notation semantics.
   switch (CastExpr->getCastKind()) {
   case CK_FunctionToPointerDecay:
     ReplaceWithNamedCast("static_cast");
     return;
   case CK_ConstructorConversion:
-    if (!CastExpr->getTypeAsWritten().hasQualifiers() &&
-        DestTypeAsWritten->isRecordType() &&
-        !DestTypeAsWritten->isElaboratedTypeSpecifier()) {
-      Diag << "constructor call syntax";
-      // FIXME: Validate DestTypeString, maybe.
-      ReplaceWithCast(DestTypeString.str());
+    if (ConstructorCast) {
+      ReplaceWithConstructorCall();
     } else {
       ReplaceWithNamedCast("static_cast");
     }
     return;
   case CK_NoOp:
     if (FnToFnCast) {
       ReplaceWithNamedCast("static_cast");
       return;
     }
     if (SourceType == DestType) {
       Diag << "static_cast (if needed, the cast may be redundant)";
       ReplaceWithCast(("static_cast<" + DestTypeString + ">").str());
       return;
     }
     if (needsConstCast(SourceType, DestType) &&
         pointedUnqualifiedTypesAreEqual(SourceType, DestType)) {
       ReplaceWithNamedCast("const_cast");
       return;
     }
+    if (ConstructorCast) {
+      ReplaceWithConstructorCall();
+      return;
+    }
     if (DestType->isReferenceType()) {
       QualType Dest = DestType.getNonReferenceType();
       QualType Source = SourceType.getNonReferenceType();
       if (Source == Dest.withConst() ||
           SourceType.getNonReferenceType() == DestType.getNonReferenceType()) {
         ReplaceWithNamedCast("const_cast");
         return;
       }

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

-// RUN: %check_clang_tidy -std=c++11,c++14 %s google-readability-casting %t
+// RUN: %check_clang_tidy -std=c++11-or-later %s google-readability-casting %t
 // FIXME: Fix the checker to work in C++17 mode.
 
 bool g() { return false; }
 
 enum Enum { Enum1 };
 struct X {};
 struct Y : public X {};