[clang-tidy] Add support for long double in bugprone-incorrect-roundings

[PiotrZSL]

Summary

Support all floating point representations for an 0.5 floating const.
Added missing tests.

Depend on D147906.

[PiotrZSL]

Update dependency

[PiotrZSL]

iDependency fix.

[carlosgalvezp]

Nice cleanup and increased generality, thank you!

[PiotrZSL]

Remove local variables

[PiotrZSL]

Rebase

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

 namespace clang::tidy::bugprone {
 
 static llvm::APFloat getHalf(const llvm::fltSemantics &Semantics) {
   return llvm::APFloat(Semantics, 1U) / llvm::APFloat(Semantics, 2U);
 }
 
 namespace {
 AST_MATCHER(FloatingLiteral, floatHalf) {
-  const llvm::APFloat Literal = Node.getValue();
-  if ((&Node.getSemantics()) == &llvm::APFloat::IEEEsingle())
-    return Literal == getHalf(llvm::APFloat::IEEEsingle());
-  if ((&Node.getSemantics()) == &llvm::APFloat::IEEEdouble())
-    return Literal == getHalf(llvm::APFloat::IEEEdouble());
-  return false;
+  return Node.getValue() == getHalf(Node.getSemantics());
 }
 } // namespace
 
 void IncorrectRoundingsCheck::registerMatchers(MatchFinder *MatchFinder) {
   // Match a floating literal with value 0.5.
   auto FloatHalf = floatLiteral(floatHalf());
 
   // Match a floating point expression.
   auto FloatType = expr(hasType(realFloatingPointType()));
 
-  // Match a floating literal of 0.5 or a floating literal of 0.5 implicitly.
-  // cast to floating type.
-  auto FloatOrCastHalf =
-      anyOf(FloatHalf,
-            implicitCastExpr(FloatType, has(ignoringParenImpCasts(FloatHalf))));
-
-  // Match if either the LHS or RHS is a floating literal of 0.5 or a floating
-  // literal of 0.5 and the other is of type double or vice versa.
-  auto OneSideHalf = anyOf(allOf(hasLHS(FloatOrCastHalf), hasRHS(FloatType)),
-                           allOf(hasRHS(FloatOrCastHalf), hasLHS(FloatType)));
-
   // Find expressions of cast to int of the sum of a floating point expression
   // and 0.5.
   MatchFinder->addMatcher(
       traverse(TK_AsIs,
-               implicitCastExpr(hasImplicitDestinationType(isInteger()),
-                                ignoringParenCasts(binaryOperator(
-                                    hasOperatorName("+"), OneSideHalf)))
+               implicitCastExpr(
+                   hasImplicitDestinationType(isInteger()),
+                       hasOperatorName("+"), hasOperands(FloatType, FloatType),
+                       hasEitherOperand(ignoringParenImpCasts(FloatHalf)))))
                    .bind("CastExpr")),
       this);
 }
 
 void IncorrectRoundingsCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *CastExpr = Result.Nodes.getNodeAs<ImplicitCastExpr>("CastExpr");
   diag(CastExpr->getBeginLoc(),
        "casting (double + 0.5) to integer leads to incorrect rounding; "
        "consider using lround (#include <cmath>) instead");
 }
 
 } // namespace clang::tidy::bugprone

clang-tools-extra/docs/ReleaseNotes.rst

- Deprecated check-local options `HeaderFileExtensions`
   in :doc:`bugprone-dynamic-static-initializers
   <clang-tidy/checks/bugprone/dynamic-static-initializers>` check.
   Global options of the same name should be used instead.
 
 - Improved :doc:`bugprone-fold-init-type
   <clang-tidy/checks/bugprone/fold-init-type>` to handle iterators that do not
   define `value_type` type aliases.
 
+- Improved :doc:`bugprone-incorrect-roundings
+  <clang-tidy/checks/bugprone/incorrect-roundings>` check by adding support for
+  other floating point representations in float constant like ``0.5L``.
+
 - Deprecated check-local options `HeaderFileExtensions` and `ImplementationFileExtensions`
   in :doc:`bugprone-suspicious-include
   <clang-tidy/checks/bugprone/suspicious-include>` check.
   Global options of the same name should be used instead.
 
 - Improved :doc:`bugprone-unchecked-optional-access
   <clang-tidy/checks/bugprone/unchecked-optional-access>` check to properly handle calls
   to ``std::forward``.

clang-tools-extra/test/clang-tidy/checkers/bugprone/incorrect-roundings.cpp

 // RUN: %check_clang_tidy %s bugprone-incorrect-roundings %t
 
 void b(int x) {}
 
 void f1() {
   float f;
   double d;
   long double ld;
   int x;
 
   x = (d + 0.5);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5) to integer leads to incorrect rounding; consider using lround (#include <cmath>) instead [bugprone-incorrect-roundings]
   x = (d + 0.5f);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
+  x = (d + 0.5L);
+  // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (f + 0.5);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (f + 0.5f);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
+  x = (f + 0.5L);
+  // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (0.5 + d);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (0.5f + d);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
+  x = (0.5L + d);
+  // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (0.5 + ld);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (0.5f + ld);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
+  x = (0.5L + ld);
+  // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (0.5 + f);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (0.5f + f);
   // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
+  x = (0.5L + f);
+  // CHECK-MESSAGES: [[@LINE-1]]:7: warning: casting (double + 0.5)
   x = (int)(d + 0.5);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(d + 0.5f);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
+  x = (int)(d + 0.5L);
+  // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(ld + 0.5);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(ld + 0.5f);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
+  x = (int)(ld + 0.5L);
+  // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(f + 0.5);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(f + 0.5f);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
+  x = (int)(f + 0.5L);
+  // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(0.5 + d);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(0.5f + d);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
+  x = (int)(0.5L + d);
+  // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(0.5 + ld);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(0.5f + ld);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
+  x = (int)(0.5L + ld);
+  // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(0.5 + f);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = (int)(0.5f + f);
   // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
+  x = (int)(0.5L + f);
+  // CHECK-MESSAGES: [[@LINE-1]]:12: warning: casting (double + 0.5)
   x = static_cast<int>(d + 0.5);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(d + 0.5f);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
+  x = static_cast<int>(d + 0.5L);
+  // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(ld + 0.5);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(ld + 0.5f);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
+  x = static_cast<int>(ld + 0.5L);
+  // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(f + 0.5);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(f + 0.5f);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
+  x = static_cast<int>(f + 0.5L);
+  // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(0.5 + d);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(0.5f + d);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
+  x = static_cast<int>(0.5L + d);
+  // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(0.5 + ld);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(0.5f + ld);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
+  x = static_cast<int>(0.5L + ld);
+  // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(0.5 + f);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
   x = static_cast<int>(0.5f + f);
   // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
+  x = static_cast<int>(0.5L + f);
+  // CHECK-MESSAGES: [[@LINE-1]]:24: warning: casting (double + 0.5)
 
   // Don't warn if constant is not 0.5.
-  x = (int)(d + 0.6);
-  x = (int)(0.6 + d);
+  x = (int)(d + 0.4999);
+  x = (int)(d + 0.4999f);
+  x = (int)(d + 0.4999L);
+  x = (int)(0.4999 + d);
+  x = (int)(0.4999f + d);
+  x = (int)(0.4999L + d);
+
+  x = (int)(d + -0.5);
+  x = (int)(-0.5 + d);
+  x = (int)(d + -0.5f);
+  x = (int)(-0.5f + d);
+  x = (int)(d + -0.5L);
+  x = (int)(-0.5L + d);
+
+  x = (int)(d + 0.5001);
+  x = (int)(d + 0.5001f);
+  x = (int)(d + 0.5001L);
+  x = (int)(0.5001 + d);
+  x = (int)(0.5001f + d);
+  x = (int)(0.5001L + d);
 
   // Don't warn if binary operator is not directly beneath cast.
   x = (int)(1 + (0.5 + f));
 }