Fix a false positive in misplaced-widening-cast

[dkrupp]

Summary

bugprone-misplaced-widening-cast check
used to give a false warning to the
following example.

enum DaysEnum{

MON = 0,
TUE = 1
};

day = (DaysEnum)(day + 1);
//warning: either cast from 'int' to 'DaysEnum' is ineffective...

But i think int to enum cast is not widening neither ineffective.

[alexfh]

LG in general, but a few comments re: test.

test/clang-tidy/bugprone-misplaced-widening-cast-explicit-only.cpp

67–73 ↗

(On Diff #176557)

No need for initializers here. Please clang-format the new code.

76 ↗

(On Diff #176557)

Please use proper capitalization and punctuation in comments. And put a space between // and the text.

77–88 ↗

(On Diff #176557)

Let's make the code a bit shorter and remove unnecessary details. For example, like this:

void f(DaysEnum day){
  if (day < SUN)
      day = (DaysEnum)(day + 1);
  if (day < SUN)
      day = static_cast<DaysEnum>(day + 1);
}

[dkrupp]

Comments addressed. Please commit if looks good, I don't have commit rights.
Thanks.

[JonasToth]

Committed, Thank you for the patch! Was there a bug-report for this issue? If yes can you please close it/reference?

[dkrupp]

In D55255#1319784, @JonasToth wrote:

Committed, Thank you for the patch! Was there a bug-report for this issue? If yes can you please close it/reference?

There was not bug report for this. Thanks for committing!

clang-tools-extra/trunk/clang-tidy/bugprone/MisplacedWideningCastCheck.cpp

void MisplacedWideningCastCheck::check(const MatchFinder::MatchResult &Result) {
   // If CalcType and CastType have same size then there is no real danger, but
   // there can be a portability problem.
 
   if (Context.getIntWidth(CastType) == Context.getIntWidth(CalcType)) {
     const auto *CastBuiltinType =
         dyn_cast<BuiltinType>(CastType->getUnqualifiedDesugaredType());
     const auto *CalcBuiltinType =
         dyn_cast<BuiltinType>(CalcType->getUnqualifiedDesugaredType());
-    if (CastBuiltinType && CalcBuiltinType &&
-        !isFirstWider(CastBuiltinType->getKind(), CalcBuiltinType->getKind()))
+    if (!CastBuiltinType || !CalcBuiltinType)
+      return;
+    if (!isFirstWider(CastBuiltinType->getKind(), CalcBuiltinType->getKind()))
       return;
   }
 
   // Don't write a warning if we can easily see that the result is not
   // truncated.
   if (Context.getIntWidth(CalcType) >= getMaxCalculationWidth(Context, Calc))
     return;
 
   diag(Cast->getBeginLoc(), "either cast from %0 to %1 is ineffective, or "
                             "there is loss of precision before the conversion")
       << CalcType << CastType;
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/trunk/test/clang-tidy/bugprone-misplaced-widening-cast-explicit-only.cpp

long ret(int a) {
   }
 }
 
 // Shall not generate an assert. https://bugs.llvm.org/show_bug.cgi?id=33660
 template <class> class A {
   enum Type {};
   static char *m_fn1() { char p = (Type)(&p - m_fn1()); }
 };
+
+enum DaysEnum {
+  MON,
+  TUE,
+  WED,
+  THR,
+  FRI,
+  SAT,
+  SUN
+};
+
+// Do not warn for int to enum casts.
+void nextDay(DaysEnum day) {
+  if (day < SUN)
+    day = (DaysEnum)(day + 1);
+  if (day < SUN)
+    day = static_cast<DaysEnum>(day + 1);
+}