[clang-tidy] Fix minor bug in bugprone-too-small-loop-variable

[PiotrZSL]

Summary

Correct issue when incorrectly matched bitfield loop
variable would still be considered valid and equal to
base type, because check didnt compare size of bitfield.

Fixes issue introduced in: D142587

clang-tools-extra/clang-tidy/bugprone/TooSmallLoopVariableCheck.cpp

 
 struct MagnitudeBits {
   unsigned WidthWithoutSignBit = 0U;
   unsigned BitFieldWidth = 0U;
 
   bool operator<(const MagnitudeBits &Other) const noexcept {
     return WidthWithoutSignBit < Other.WidthWithoutSignBit;
   }
+
+  bool operator!=(const MagnitudeBits &Other) const noexcept {
+    return WidthWithoutSignBit != Other.WidthWithoutSignBit ||
+           BitFieldWidth != Other.BitFieldWidth;
+  }
 };
 
 } // namespace
 
 TooSmallLoopVariableCheck::TooSmallLoopVariableCheck(StringRef Name,
                                                      ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       MagnitudeBitsUpperLimit(Options.get("MagnitudeBitsUpperLimit", 16U)) {}
const auto *UpperBound =
       Result.Nodes.getNodeAs<Expr>(LoopUpperBoundName)->IgnoreParenImpCasts();
   const auto *LoopIncrement =
       Result.Nodes.getNodeAs<Expr>(LoopIncrementName)->IgnoreParenImpCasts();
 
   // We matched the loop variable incorrectly.
   if (LoopVar->getType() != LoopIncrement->getType())
     return;
 
-  const QualType LoopVarType = LoopVar->getType();
-  const QualType UpperBoundType = UpperBound->getType();
-
   ASTContext &Context = *Result.Context;
 
+  const QualType LoopVarType = LoopVar->getType();
   const MagnitudeBits LoopVarMagnitudeBits =
       calcMagnitudeBits(Context, LoopVarType, LoopVar);
+
+  const MagnitudeBits LoopIncrementMagnitudeBits =
+      calcMagnitudeBits(Context, LoopIncrement->getType(), LoopIncrement);
+  // We matched the loop variable incorrectly.
+  if (LoopIncrementMagnitudeBits != LoopVarMagnitudeBits)
+    return;
+
+  const QualType UpperBoundType = UpperBound->getType();
   const MagnitudeBits UpperBoundMagnitudeBits =
       calcUpperBoundMagnitudeBits(Context, UpperBound, UpperBoundType);
 
   if ((0U == UpperBoundMagnitudeBits.WidthWithoutSignBit) ||
       (LoopVarMagnitudeBits.WidthWithoutSignBit > MagnitudeBitsUpperLimit) ||
       (LoopVarMagnitudeBits.WidthWithoutSignBit >=
        UpperBoundMagnitudeBits.WidthWithoutSignBit))
     return;
 
   diag(LoopVar->getBeginLoc(),
        "loop variable has narrower type '%0' than iteration's upper bound '%1'")
       << formatIntegralType(LoopVarType, LoopVarMagnitudeBits)
       << formatIntegralType(UpperBoundType, UpperBoundMagnitudeBits);
 }
 
 } // namespace clang::tidy::bugprone

clang-tools-extra/test/clang-tidy/checkers/bugprone/too-small-loop-variable.cpp

void badForLoopWithBitfieldOnLoopVarAndUpperBoundOnPtr() {
 
   StructWithBitField* ptr = &value;
 
   for(ptr->var = 0U; ptr->var < ptr->limit; ++ptr->var) {
   // CHECK-MESSAGES: :[[@LINE-1]]:22: warning: loop variable has narrower type 'unsigned int:5' than iteration's upper bound 'unsigned int:6' [bugprone-too-small-loop-variable]
   }
 }
 
+void goodForLoopWithBitfieldOnUpperBoundOnly() {
+  struct S {
+    int x : 4;
+  } s;
+
+  for (int i = 10; i > s.x; --i) {
+  }
+}
+
+void goodForLoopWithIntegersOnUpperBoundOnly() {
+  struct S {
+    short x;
+  } s;
+
+  for (int i = 10; i > s.x; --i) {
+  }
+}