From 8d7c97d428cdf89c3419a4e13b62a9849feefce9 Mon Sep 17 00:00:00 2001
From: Allan Sandfeld Jensen <allan.jensen@qt.io>
Date: Thu, 4 Apr 2019 16:46:41 +0200
Subject: Remove remaining Q_DECL_NOEXCEPT/Q_DECL_NOTHROW usage

Change-Id: I91ac9e714a465cab226b211812aa46e8fe5ff2ab
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>
---
 src/corelib/tools/qpair.h | 30 +++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

(limited to 'src/corelib/tools/qpair.h')

diff --git a/src/corelib/tools/qpair.h b/src/corelib/tools/qpair.h
index 1af43d0a68..6d1e67efb7 100644
--- a/src/corelib/tools/qpair.h
+++ b/src/corelib/tools/qpair.h
@@ -52,41 +52,41 @@ struct QPair
     typedef T2 second_type;
 
     Q_DECL_CONSTEXPR QPair()
-        Q_DECL_NOEXCEPT_EXPR((std::is_nothrow_default_constructible<T1>::value &&
+        noexcept((std::is_nothrow_default_constructible<T1>::value &&
                               std::is_nothrow_default_constructible<T2>::value))
         : first(), second() {}
     Q_DECL_CONSTEXPR QPair(const T1 &t1, const T2 &t2)
-        Q_DECL_NOEXCEPT_EXPR((std::is_nothrow_copy_constructible<T1>::value &&
+        noexcept((std::is_nothrow_copy_constructible<T1>::value &&
                               std::is_nothrow_copy_constructible<T2>::value))
         : first(t1), second(t2) {}
     // compiler-generated copy/move ctor/assignment operators are fine!
 
     template <typename TT1, typename TT2>
     Q_DECL_CONSTEXPR QPair(const QPair<TT1, TT2> &p)
-        Q_DECL_NOEXCEPT_EXPR((std::is_nothrow_constructible<T1, TT1&>::value &&
+        noexcept((std::is_nothrow_constructible<T1, TT1&>::value &&
                               std::is_nothrow_constructible<T2, TT2&>::value))
         : first(p.first), second(p.second) {}
     template <typename TT1, typename TT2>
     Q_DECL_RELAXED_CONSTEXPR QPair &operator=(const QPair<TT1, TT2> &p)
-        Q_DECL_NOEXCEPT_EXPR((std::is_nothrow_assignable<T1, TT1&>::value &&
+        noexcept((std::is_nothrow_assignable<T1, TT1&>::value &&
                               std::is_nothrow_assignable<T2, TT2&>::value))
     { first = p.first; second = p.second; return *this; }
 #ifdef Q_COMPILER_RVALUE_REFS
     template <typename TT1, typename TT2>
     Q_DECL_CONSTEXPR QPair(QPair<TT1, TT2> &&p)
-        Q_DECL_NOEXCEPT_EXPR((std::is_nothrow_constructible<T1, TT1>::value &&
+        noexcept((std::is_nothrow_constructible<T1, TT1>::value &&
                               std::is_nothrow_constructible<T2, TT2>::value))
         // can't use std::move here as it's not constexpr in C++11:
         : first(static_cast<TT1 &&>(p.first)), second(static_cast<TT2 &&>(p.second)) {}
     template <typename TT1, typename TT2>
     Q_DECL_RELAXED_CONSTEXPR QPair &operator=(QPair<TT1, TT2> &&p)
-        Q_DECL_NOEXCEPT_EXPR((std::is_nothrow_assignable<T1, TT1>::value &&
+        noexcept((std::is_nothrow_assignable<T1, TT1>::value &&
                               std::is_nothrow_assignable<T2, TT2>::value))
     { first = std::move(p.first); second = std::move(p.second); return *this; }
 #endif
 
     Q_DECL_RELAXED_CONSTEXPR void swap(QPair &other)
-        Q_DECL_NOEXCEPT_EXPR(noexcept(qSwap(other.first, other.first)) && noexcept(qSwap(other.second, other.second)))
+        noexcept(noexcept(qSwap(other.first, other.first)) && noexcept(qSwap(other.second, other.second)))
     {
         // use qSwap() to pick up ADL swaps automatically:
         qSwap(first, other.first);
@@ -103,7 +103,7 @@ QPair(T1, T2) -> QPair<T1, T2>;
 #endif
 
 template <typename T1, typename T2>
-void swap(QPair<T1, T2> &lhs, QPair<T1, T2> &rhs) Q_DECL_NOEXCEPT_EXPR(noexcept(lhs.swap(rhs)))
+void swap(QPair<T1, T2> &lhs, QPair<T1, T2> &rhs) noexcept(noexcept(lhs.swap(rhs)))
 { lhs.swap(rhs); }
 
 // mark QPair<T1,T2> as complex/movable/primitive depending on the
@@ -113,45 +113,45 @@ class QTypeInfo<QPair<T1, T2> > : public QTypeInfoMerger<QPair<T1, T2>, T1, T2>
 
 template <class T1, class T2>
 Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
-    Q_DECL_NOEXCEPT_EXPR(noexcept(p1.first == p2.first && p1.second == p2.second))
+    noexcept(noexcept(p1.first == p2.first && p1.second == p2.second))
 { return p1.first == p2.first && p1.second == p2.second; }
 
 template <class T1, class T2>
 Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
-    Q_DECL_NOEXCEPT_EXPR(noexcept(!(p1 == p2)))
+    noexcept(noexcept(!(p1 == p2)))
 { return !(p1 == p2); }
 
 template <class T1, class T2>
 Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
-    Q_DECL_NOEXCEPT_EXPR(noexcept(p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second)))
+    noexcept(noexcept(p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second)))
 {
     return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second);
 }
 
 template <class T1, class T2>
 Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
-    Q_DECL_NOEXCEPT_EXPR(noexcept(p2 < p1))
+    noexcept(noexcept(p2 < p1))
 {
     return p2 < p1;
 }
 
 template <class T1, class T2>
 Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
-    Q_DECL_NOEXCEPT_EXPR(noexcept(!(p2 < p1)))
+    noexcept(noexcept(!(p2 < p1)))
 {
     return !(p2 < p1);
 }
 
 template <class T1, class T2>
 Q_DECL_CONSTEXPR Q_INLINE_TEMPLATE bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2)
-    Q_DECL_NOEXCEPT_EXPR(noexcept(!(p1 < p2)))
+    noexcept(noexcept(!(p1 < p2)))
 {
     return !(p1 < p2);
 }
 
 template <class T1, class T2>
 Q_DECL_CONSTEXPR Q_OUTOFLINE_TEMPLATE QPair<T1, T2> qMakePair(const T1 &x, const T2 &y)
-    Q_DECL_NOEXCEPT_EXPR(noexcept(QPair<T1, T2>(x, y)))
+    noexcept(noexcept(QPair<T1, T2>(x, y)))
 {
     return QPair<T1, T2>(x, y);
 }
-- 
cgit v1.2.3