Hack for automating fixes for some -Wconversion warning instances

clang/lib/Sema/SemaChecking.cpp

 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/ExprOpenMP.h"
 #include "clang/AST/FormatString.h"
 #include "clang/AST/NSAPI.h"
 #include "clang/AST/NonTrivialTypeVisitor.h"
 #include "clang/AST/OperationKinds.h"
+#include "clang/AST/ParentMapContext.h"
 #include "clang/AST/RecordLayout.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/UnresolvedSet.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/CharInfo.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/OpenCLOptions.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Basic/Specifiers.h"
 #include "clang/Basic/SyncScope.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetCXXABI.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/Basic/TypeTraits.h"
 #include "clang/Lex/Lexer.h" // TODO: Extract static functions to fix layering.
+#include "clang/Lex/LiteralSupport.h"
+#include "clang/Lex/Preprocessor.h"
 #include "clang/Sema/Initialization.h"
 #include "clang/Sema/Lookup.h"
 #include "clang/Sema/Ownership.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/ScopeInfo.h"
 #include "clang/Sema/Sema.h"
 #include "clang/Sema/SemaInternal.h"
 #include "llvm/ADT/APFloat.h"

 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Locale.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SaveAndRestore.h"
+#include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <bitset>
 #include <cassert>
 #include <cstddef>
 #include <cstdint>
 #include <functional>
 #include <limits>
static void AnalyzeAssignment(Sema &S, BinaryOperator *E) {
 
   AnalyzeImplicitConversions(S, E->getRHS(), E->getOperatorLoc());
 
   // Diagnose implicitly sequentially-consistent atomic assignment.
   if (E->getLHS()->getType()->isAtomicType())
     S.Diag(E->getRHS()->getBeginLoc(), diag::warn_atomic_implicit_seq_cst);
 }
 
+auto &GetSeenLocs() {
+  static llvm::SmallSet<SourceLocation, 16> SeenLocs;
+  return SeenLocs;
+}
+
+SourceLocation GetCorrectedEndLoc(Sema &S, SourceLocation Loc) {
+  auto &SM = S.getSourceManager();
+  if (Loc.isMacroID()) {
+    Loc = SM.getSpellingLoc(Loc);
+    assert(Loc.isFileID());
+  }
+  return S.getLocForEndOfToken(Loc);
+}
+
+static bool operator==(PresumedLoc loc1, PresumedLoc loc2) {
+  return loc1.getFileID() == loc2.getFileID() &&
+      loc1.getColumn() == loc2.getColumn() &&
+      loc1.getLine() == loc2.getLine();
+}
+
+bool endswith(std::string const &fullString, std::string const &ending) {
+  if (fullString.length() >= ending.length()) {
+    return (0 == fullString.compare (fullString.length() - ending.length(), ending.length(), ending));
+  } else {
+    return false;
+  }
+}
+
 /// Diagnose an implicit cast;  purely a helper for CheckImplicitConversion.
 static void DiagnoseImpCast(Sema &S, Expr *E, QualType SourceType, QualType T,
                             SourceLocation CContext, unsigned diag,
                             bool pruneControlFlow = false) {
+  auto &SM = S.getSourceManager();
+  auto &Ctx = S.getASTContext();
+  auto &PP = S.getPreprocessor();
+
+  SourceLocation BeginInsertLoc = E->getBeginLoc();
+  SourceLocation EndInsertLoc = E->getEndLoc();
+
+  bool InTemplatedFunc = S.getCurFunctionDecl() && (S.getCurFunctionDecl()->getTemplatedKind() != FunctionDecl::TK_NonTemplate);
+  bool InMacro = BeginInsertLoc.isMacroID() || EndInsertLoc.isMacroID();
+
+  if (SM.getPresumedLoc(BeginInsertLoc) == SM.getPresumedLoc(EndInsertLoc) &&
+      BeginInsertLoc.isMacroID() && EndInsertLoc.isMacroID()) {
+    InMacro = true;
+  } else {
+    EndInsertLoc = GetCorrectedEndLoc(S, EndInsertLoc);
+  }
+
+  if (GetSeenLocs().count(BeginInsertLoc)) {
+    // Skip this since we already apply the fixit.
+    return;
+  }
+  GetSeenLocs().insert(BeginInsertLoc);
+  auto GetTypeName = [&](QualType T) -> std::string {
+    auto CanonT = T.getCanonicalType();
+    if (CanonT == Ctx.getSizeType())
+      return "size_t";
+
+    auto Spelling = T.getAsString(S.getPrintingPolicy());
+    auto CanonSpelling = CanonT.getAsString(S.getPrintingPolicy());
+
+    if (CanonT->isSpecificBuiltinType(BuiltinType::SChar))
+      return Spelling == CanonSpelling ? Spelling : "int8_t";
+    if (CanonT->isSpecificBuiltinType(BuiltinType::UChar))
+      return Spelling == CanonSpelling ? Spelling : "uint8_t";
+    if (CanonT->isSpecificBuiltinType(BuiltinType::Short))
+      return Spelling == CanonSpelling ? Spelling : "int16_t";
+    if (CanonT->isSpecificBuiltinType(BuiltinType::UShort))
+      return Spelling == CanonSpelling ? Spelling : "uint16_t";
+    if (CanonT->isSpecificBuiltinType(BuiltinType::Int))
+      return Spelling == CanonSpelling ? Spelling : "int32_t";
+    if (CanonT->isSpecificBuiltinType(BuiltinType::UInt))
+      return Spelling == CanonSpelling ? Spelling : "uint32_t";
+    if (CanonT->isSpecificBuiltinType(BuiltinType::Long) ||
+        CanonT->isSpecificBuiltinType(BuiltinType::LongLong))
+      return Spelling == CanonSpelling ? Spelling : "int64_t";
+    if (CanonT->isSpecificBuiltinType(BuiltinType::ULong) ||
+        CanonT->isSpecificBuiltinType(BuiltinType::ULongLong))
+      return Spelling == CanonSpelling ? Spelling : "uint64_t";
+
+    return CanonSpelling;
+  };
+
+  auto Str = GetTypeName(T);
+  llvm::SmallString<16> CastStr;
+  if (S.getLangOpts().CPlusPlus) {
+    CastStr.append("static_cast<");
+    CastStr.append(Str);
+    CastStr.append(">(");
+  } else {
+    CastStr.append("(");
+    CastStr.append(Str);
+    CastStr.append(")(");
+  }
+
+  if (InTemplatedFunc || InMacro) {
+    // Warn but do not suggest fixit since it may not entirely be possible to
+    // static_cast to a dependent type here.
     if (pruneControlFlow) {
       S.DiagRuntimeBehavior(E->getExprLoc(), E,
                             S.PDiag(diag)
                                 << SourceType << T << E->getSourceRange()
-                              << SourceRange(CContext));
+                                << SourceRange(CContext)
+                                );
       return;
     }
     S.Diag(E->getExprLoc(), diag)
       << SourceType << T << E->getSourceRange() << SourceRange(CContext);
+    return;
+  }
+
+  if (pruneControlFlow) {
+    S.DiagRuntimeBehavior(E->getExprLoc(), E,
+                          S.PDiag(diag)
+                              << SourceType << T << E->getSourceRange()
+                              << SourceRange(CContext)
+                              << FixItHint::CreateInsertion(BeginInsertLoc, CastStr)
+                              << FixItHint::CreateInsertion(EndInsertLoc, ")")
+                              );
+    return;
+  }
+  S.Diag(E->getExprLoc(), diag)
+    << SourceType << T << E->getSourceRange() << SourceRange(CContext)
+    << FixItHint::CreateInsertion(BeginInsertLoc, CastStr)
+    << FixItHint::CreateInsertion(EndInsertLoc, ")");
 }
 
 /// Diagnose an implicit cast;  purely a helper for CheckImplicitConversion.
 static void DiagnoseImpCast(Sema &S, Expr *E, QualType T,
                             SourceLocation CContext,
                             unsigned diag, bool pruneControlFlow = false) {
   DiagnoseImpCast(S, E, E->getType(), T, CContext, diag, pruneControlFlow);
 }
if (const auto *OVE = dyn_cast<OpaqueValueExpr>(Ignored))
     Ignored = OVE->getSourceExpr();
   bool NeedsParens = isa<AbstractConditionalOperator>(Ignored) ||
                      isa<BinaryOperator>(Ignored) ||
                      isa<CXXOperatorCallExpr>(Ignored);
   SourceLocation EndLoc = S.getLocForEndOfToken(SourceExpr->getEndLoc());
   if (NeedsParens)
     Builder << FixItHint::CreateInsertion(SourceExpr->getBeginLoc(), "(")
             << FixItHint::CreateInsertion(EndLoc, ")");
   Builder << FixItHint::CreateInsertion(EndLoc, " ? YES : NO");
 }
 
 /// Diagnose an implicit cast from a floating point value to an integer value.
 static void DiagnoseFloatingImpCast(Sema &S, Expr *E, QualType T,
                                     SourceLocation CContext) {
   const bool IsBool = T->isSpecificBuiltinType(BuiltinType::Bool);
   const bool PruneWarnings = S.inTemplateInstantiation();
 
   Expr *InnerE = E->IgnoreParenImpCasts();
   // We also want to warn on, e.g., "int i = -1.234"
   if (UnaryOperator *UOp = dyn_cast<UnaryOperator>(InnerE))
     if (UOp->getOpcode() == UO_Minus || UOp->getOpcode() == UO_Plus)
       InnerE = UOp->getSubExpr()->IgnoreParenImpCasts();
 
   const bool IsLiteral =
       isa<FloatingLiteral>(E) || isa<FloatingLiteral>(InnerE);
 
   llvm::APFloat Value(0.0);
   bool IsConstant =
     E->EvaluateAsFloat(Value, S.Context, Expr::SE_AllowSideEffects);
   if (!IsConstant) {
     if (isObjCSignedCharBool(S, T)) {
       return adornObjCBoolConversionDiagWithTernaryFixit(
           S, E,
           S.Diag(CContext, diag::warn_impcast_float_to_objc_signed_char_bool)
               << E->getType());
     }
 
     return DiagnoseImpCast(S, E, T, CContext,
                            diag::warn_impcast_float_integer, PruneWarnings);
   }
if (Value.isZero()) {  // Skip -0.0 to 0 conversion.
                              diag::warn_impcast_float_integer, PruneWarnings);
     }
     // Warn on non-zero to zero conversion.
     DiagID = diag::warn_impcast_float_to_integer_zero;
   } else {
     if (IntegerValue.isUnsigned()) {
       if (!IntegerValue.isMaxValue()) {
         return DiagnoseImpCast(S, E, T, CContext,
                                diag::warn_impcast_float_integer, PruneWarnings);
       }
     } else {  // IntegerValue.isSigned()
       if (!IntegerValue.isMaxSignedValue() &&
           !IntegerValue.isMinSignedValue()) {
         return DiagnoseImpCast(S, E, T, CContext,
                                diag::warn_impcast_float_integer, PruneWarnings);
       }
     }
     // Warn on evaluatable floating point expression to integer conversion.
     DiagID = diag::warn_impcast_float_to_integer;
   }
 
   SmallString<16> PrettyTargetValue;
   if (IsBool)
     PrettyTargetValue = Value.isZero() ? "false" : "true";
   else
     IntegerValue.toString(PrettyTargetValue);
 
   if (PruneWarnings) {
     S.DiagRuntimeBehavior(E->getExprLoc(), E,
                           S.PDiag(DiagID)
                               << E->getType() << T.getUnqualifiedType()
                               << PrettySourceValue << PrettyTargetValue
                               << E->getSourceRange() << SourceRange(CContext));
   } else {
     S.Diag(E->getExprLoc(), DiagID)
         << E->getType() << T.getUnqualifiedType() << PrettySourceValue
         << PrettyTargetValue << E->getSourceRange() << SourceRange(CContext);

clang/test/Frontend/fuchsia-wconversion-fixes.cpp

+// RUN: %clang_cc1 -fsyntax-only -verify -Wconversion %s
+// RUN: %clang_cc1 -Wconversion %s -fixit-to-temporary -fixit-recompile -o - -E | FileCheck %s
+
+// FIXME: Add something that triggers the check here.
+//void f();
+
+// FIXME: Verify the applied fix.
+//   * Make the CHECK patterns specific enough and try to make verified lines
+//     unique to avoid incorrect matches.
+//   * Use {{}} for regular expressions.
+
+// FIXME: Add something that doesn't trigger the check here.
+//void awesome_f2();
+
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+static_assert(sizeof(uint32_t) == 4, "");
+static_assert(sizeof(uint64_t) == 8, "");
+
+typedef unsigned long size_t;
+
+typedef signed int int32_t;
+typedef signed long long int64_t;
+static_assert(sizeof(int32_t) == 4, "");
+static_assert(sizeof(int64_t) == 8, "");
+
+uint32_t func(uint64_t x) {
+  return x + 1;  // expected-warning{{implicit conversion loses integer precision}}
+// CHECK:     uint32_t func(uint64_t x) {
+// CHECK-NEXT:  return static_cast<uint32_t>(x + 1);
+}
+
+uint32_t func2(uint64_t x) {
+  return static_cast<uint32_t>(x + 1);
+}
+
+signed char func3(unsigned char x) {
+  return x;  // expected-warning{{implicit conversion changes signedness}}
+// CHECK:     signed char func3(unsigned char x) {
+// CHECK-NEXT:  return static_cast<signed char>(x);
+}
+
+constexpr signed int kSysError = 0xabDECADE;  // expected-warning{{implicit conversion changes signedness}}
+// CHECK: constexpr signed int kSysError = static_cast<const int>(0xabDECADE);
+
+#define MACRO(x) ((x) + 1)
+
+int32_t intfunc();
+#define MACRO2(x) intfunc()
+#define MACRO3(x) static_cast<int64_t>(intfunc())
+
+namespace std {
+namespace __2 {
+struct array {
+  using size_type = size_t;
+  int &operator[](size_type s);
+};
+}
+}
+
+int u32func(uint32_t);
+
+template <typename T>
+struct Arr {
+  T *begin() const;
+  T *end() const;
+};
+
+void func4(uint32_t offset, int32_t bytes_read, float f, std::__2::array &a,
+           int i, Arr<int32_t> arr) {
+  offset += bytes_read;  // expected-warning{{implicit conversion changes signedness}}
+// CHECK: offset += static_cast<unsigned int>(bytes_read);
+
+  struct {
+    int32_t st_size;
+  } stat_buffer;
+  uint64_t size = stat_buffer.st_size;  // expected-warning{{implicit conversion changes signedness}}
+// CHECK: uint64_t size = static_cast<uint64_t>(stat_buffer.st_size);
+
+  int32_t abc = 1, xyz = 2;
+  uint32_t x = abc - xyz;  // expected-warning{{implicit conversion changes signedness}}
+// CHECK: uint32_t x = static_cast<uint32_t>(abc - xyz);
+
+  u32func(abc - xyz);  // expected-warning{{implicit conversion changes signedness}}
+// CHECK: u32func(static_cast<uint32_t>(abc - xyz));
+
+  MACRO(u32func(abc - xyz));  // expected-warning{{implicit conversion changes signedness}}
+
+  x = MACRO2(intfunc());  // expected-warning{{implicit conversion changes signedness}}
+
+  if (f) return;  // expected-warning{{implicit conversion turns floating-point number into integer: 'float' to 'bool'}}
+// CHECK: if (static_cast<bool>(f)) return;
+
+  x = MACRO3(x);  // expected-warning{{implicit conversion loses integer precision}}
+
+  a[i] = 2;  // expected-warning{{implicit conversion changes signedness}}
+// CHECK: a[static_cast<size_t>(i)] = 2;
+
+  //for (uint32_t elem : arr) {
+  //  u32func(elem);
+  //}
+}
+
+template <typename Callable, typename Arg>
+struct Target {
+  static void invoke(Callable target, Arg arg) {
+    target(arg);  // expected-warning{{implicit conversion loses integer precision}}
+  }
+};
+
+void voidfunc(int32_t);
+
+void func5(uint64_t i) {
+  Target<decltype(voidfunc), uint64_t> target;
+  target.invoke(voidfunc, i);  // expected-note{{in instantiation of member function}}
+}