Short live QtPrivate::fuzzyCompare()!

Extract Method QtPrivate::fuzzyCompare() from the qFuzzyCompare()
implementations that correctly validate the preconditions of the
public qFuzzyCompare() (QMarginsF, QSizeF, QPointF), so we can more
easily apply the same technique to other in-tree callers.

In the process, replace comparison to literal 0.0 with calls to
qIsNull() so we're a) insulated from -Wfloat-compare and b) have a
customization point to extend to types other than float and double.

Amends:
- 473d069 (QMarginsF)
- fa0d77e (QPointF)
- 3ca9877 (QSizeF)

Pick-to: 6.10 6.8 6.5
Task-number: QTBUG-142020
Change-Id: Ib7ec06822f8006771a1c3a96145e98d574a29fbe
Reviewed-by: Ivan Solovev <[email protected]>

Author: marcmutz

src/corelib/global/qnumeric.h

@@ -627,6 +627,27 @@ QT_WARNING_DISABLE_FLOAT_COMPARE
 
 QT_WARNING_POP
 
+namespace QtPrivate {
+/*
+    A version of qFuzzyCompare that works for all values (qFuzzyCompare()
+    requires that neither argument is numerically 0).
+
+    It's private because we need a fix for the many qFuzzyCompare() uses that
+    ignore the precondition, even for older branches.
+
+    See QTBUG-142020 for discussion of a longer-term solution.
+*/
+template <typename T, typename S>
+[[nodiscard]] constexpr bool fuzzyCompare(const T &lhs, const S &rhs) noexcept
+{
+    static_assert(noexcept(qIsNull(lhs) && qIsNull(rhs) && qFuzzyIsNull(lhs - rhs) && qFuzzyCompare(lhs, rhs)),
+                  "The operations qIsNull(), qFuzzyIsNull() and qFuzzyCompare() must be noexcept"
+                  "for both argument types!");
+    return qIsNull(lhs) || qIsNull(rhs) ? qFuzzyIsNull(lhs - rhs) : qFuzzyCompare(lhs, rhs);
+}
+} // namespace QtPrivate
+
+
 inline int qIntCast(double f) { return int(f); }
 inline int qIntCast(float f) { return int(f); }
 

src/corelib/tools/qmargins.h

@@ -333,20 +333,13 @@ class QMarginsF
     qreal m_right;
     qreal m_bottom;
 
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_FLOAT_COMPARE
     friend constexpr bool qFuzzyCompare(const QMarginsF &lhs, const QMarginsF &rhs) noexcept
     {
-        return ((!lhs.m_left || !rhs.m_left) ? qFuzzyIsNull(lhs.m_left - rhs.m_left)
-                                             : qFuzzyCompare(lhs.m_left, rhs.m_left))
-                && ((!lhs.m_top || !rhs.m_top) ? qFuzzyIsNull(lhs.m_top - rhs.m_top)
-                                               : qFuzzyCompare(lhs.m_top, rhs.m_top))
-                && ((!lhs.m_right || !rhs.m_right) ? qFuzzyIsNull(lhs.m_right - rhs.m_right)
-                                                   : qFuzzyCompare(lhs.m_right, rhs.m_right))
-                && ((!lhs.m_bottom || !rhs.m_bottom) ? qFuzzyIsNull(lhs.m_bottom - rhs.m_bottom)
-                                                     : qFuzzyCompare(lhs.m_bottom, rhs.m_bottom));
+        return QtPrivate::fuzzyCompare(lhs.m_left,   rhs.m_left)
+            && QtPrivate::fuzzyCompare(lhs.m_top,    rhs.m_top)
+            && QtPrivate::fuzzyCompare(lhs.m_right,  rhs.m_right)
+            && QtPrivate::fuzzyCompare(lhs.m_bottom, rhs.m_bottom);
     }
-    QT_WARNING_POP
     friend constexpr bool qFuzzyIsNull(const QMarginsF &m) noexcept
     {
         return qFuzzyIsNull(m.m_left) && qFuzzyIsNull(m.m_top)

src/corelib/tools/qpoint.h

@@ -259,14 +259,11 @@ class QPointF
     }
 
 private:
-    QT_WARNING_PUSH
-    QT_WARNING_DISABLE_FLOAT_COMPARE
     friend constexpr bool qFuzzyCompare(const QPointF &p1, const QPointF &p2) noexcept
     {
-        return ((!p1.xp || !p2.xp) ? qFuzzyIsNull(p1.xp - p2.xp) : qFuzzyCompare(p1.xp, p2.xp))
-            && ((!p1.yp || !p2.yp) ? qFuzzyIsNull(p1.yp - p2.yp) : qFuzzyCompare(p1.yp, p2.yp));
+        return QtPrivate::fuzzyCompare(p1.xp, p2.xp)
+            && QtPrivate::fuzzyCompare(p1.yp, p2.yp);
     }
-    QT_WARNING_POP
     friend constexpr bool qFuzzyIsNull(const QPointF &point) noexcept
     {
         return qFuzzyIsNull(point.xp) && qFuzzyIsNull(point.yp);

src/corelib/tools/qsize.h

@@ -258,10 +258,9 @@ class Q_CORE_EXPORT QSizeF
     QT_WARNING_DISABLE_FLOAT_COMPARE
     friend constexpr bool qFuzzyCompare(const QSizeF &s1, const QSizeF &s2) noexcept
     {
-        // Cannot use qFuzzyCompare(), because it will give incorrect results
         // if one of the arguments is 0.0.
-        return ((!s1.wd || !s2.wd) ? qFuzzyIsNull(s1.wd - s2.wd) : qFuzzyCompare(s1.wd, s2.wd))
-            && ((!s1.ht || !s2.ht) ? qFuzzyIsNull(s1.ht - s2.ht) : qFuzzyCompare(s1.ht, s2.ht));
+        return QtPrivate::fuzzyCompare(s1.wd, s2.wd)
+            && QtPrivate::fuzzyCompare(s1.ht, s2.ht);
     }
     QT_WARNING_POP
     friend constexpr bool qFuzzyIsNull(const QSizeF &size) noexcept