More constexpr (re P0202) - equal and mismatch

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@322527 91177308-0d34-0410-b5e6-96231b3b80d8

include/algorithm

@@ -87,41 +87,41 @@ template <class InputIterator, class Predicate>
     count_if(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator1, class InputIterator2>
-    pair<InputIterator1, InputIterator2>
+    constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
     mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
 
 template <class InputIterator1, class InputIterator2>
-    pair<InputIterator1, InputIterator2>
+    constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2); // **C++14**
 
 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-    pair<InputIterator1, InputIterator2>
+    constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, BinaryPredicate pred);
 
 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-    pair<InputIterator1, InputIterator2>
+    constexpr pair<InputIterator1, InputIterator2>   // constexpr in C++20
     mismatch(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2,
              BinaryPredicate pred); // **C++14**
 
 template <class InputIterator1, class InputIterator2>
-    bool
+    constexpr bool      // constexpr in C++20
     equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2);
 
 template <class InputIterator1, class InputIterator2>
-    bool
+    constexpr bool      // constexpr in C++20
     equal(InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, InputIterator2 last2); // **C++14**
 
 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-    bool
+    constexpr bool      // constexpr in C++20
     equal(InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, BinaryPredicate pred);
 
 template <class InputIterator1, class InputIterator2, class BinaryPredicate>
-    bool
+    constexpr bool      // constexpr in C++20
     equal(InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, InputIterator2 last2,
           BinaryPredicate pred); // **C++14**
@@ -1268,7 +1268,7 @@ count_if(_InputIterator __first, _InputIterator __last, _Predicate __pred)
 // mismatch
 
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 pair<_InputIterator1, _InputIterator2>
 mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
          _InputIterator2 __first2, _BinaryPredicate __pred)
@@ -1280,7 +1280,7 @@ mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
 }
 
 template <class _InputIterator1, class _InputIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 pair<_InputIterator1, _InputIterator2>
 mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
 {
@@ -1291,7 +1291,7 @@ mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __fi
 
 #if _LIBCPP_STD_VER > 11
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 pair<_InputIterator1, _InputIterator2>
 mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
          _InputIterator2 __first2, _InputIterator2 __last2,
@@ -1304,7 +1304,7 @@ mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
 }
 
 template <class _InputIterator1, class _InputIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 pair<_InputIterator1, _InputIterator2>
 mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
          _InputIterator2 __first2, _InputIterator2 __last2)
@@ -1318,7 +1318,7 @@ mismatch(_InputIterator1 __first1, _InputIterator1 __last1,
 // equal
 
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred)
 {
@@ -1329,7 +1329,7 @@ equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first
 }
 
 template <class _InputIterator1, class _InputIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2)
 {
@@ -1340,7 +1340,7 @@ equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first
 
 #if _LIBCPP_STD_VER > 11
 template <class _BinaryPredicate, class _InputIterator1, class _InputIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 __equal(_InputIterator1 __first1, _InputIterator1 __last1,
         _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred,
@@ -1353,7 +1353,7 @@ __equal(_InputIterator1 __first1, _InputIterator1 __last1,
 }
 
 template <class _BinaryPredicate, class _RandomAccessIterator1, class _RandomAccessIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 __equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
         _RandomAccessIterator2 __first2, _RandomAccessIterator2 __last2, _BinaryPredicate __pred,
@@ -1367,7 +1367,7 @@ __equal(_RandomAccessIterator1 __first1, _RandomAccessIterator1 __last1,
 }
 
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 equal(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2, _BinaryPredicate __pred )
@@ -1379,7 +1379,7 @@ equal(_InputIterator1 __first1, _InputIterator1 __last1,
 }
 
 template <class _InputIterator1, class _InputIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool
 equal(_InputIterator1 __first1, _InputIterator1 __last1,
       _InputIterator2 __first2, _InputIterator2 __last2)

test/std/algorithms/alg.nonmodifying/alg.equal/equal.pass.cpp

@@ -11,8 +11,13 @@
 
 // template<InputIterator Iter1, InputIterator Iter2>
 //   requires HasEqualTo<Iter1::value_type, Iter2::value_type>
-//   bool
+//   constexpr bool     // constexpr after c++17
 //   equal(Iter1 first1, Iter1 last1, Iter2 first2);
+//
+//	Introduced in C++14:
+// template<InputIterator Iter1, InputIterator Iter2>
+//   constexpr bool     // constexpr after c++17
+//   equal(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2);
 
 #include <algorithm>
 #include <cassert>
@@ -20,6 +25,25 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool test_constexpr() {
+    int ia[] = {1, 3, 6, 7};
+    int ib[] = {1, 3};
+    int ic[] = {1, 3, 5, 7};
+    typedef input_iterator<int*>         II;
+    typedef bidirectional_iterator<int*> BI;
+
+    return !std::equal(std::begin(ia), std::end(ia), std::begin(ic))
+        && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic))
+        &&  std::equal(std::begin(ib), std::end(ib), std::begin(ic))
+        && !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic))
+
+        &&  std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic)))
+        && !std::equal(BI(std::begin(ib)), BI(std::end(ib)), BI(std::begin(ic)), BI(std::end(ic)))
+        ;
+    }
+#endif
+
 
 int main()
 {
@@ -61,4 +85,8 @@ int main()
                        random_access_iterator<const int*>(ia+s-1)));
 
 #endif
+
+#if TEST_STD_VER > 17
+    static_assert(test_constexpr());
+#endif
 }

test/std/algorithms/alg.nonmodifying/alg.equal/equal_pred.pass.cpp

@@ -12,8 +12,16 @@
 // template<InputIterator Iter1, InputIterator Iter2,
 //          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
 //   requires CopyConstructible<Pred>
-//   bool
+//   constexpr bool     // constexpr after c++17
 //   equal(Iter1 first1, Iter1 last1, Iter2 first2, Pred pred);
+//
+//	Introduced in C++14:
+// template<InputIterator Iter1, InputIterator Iter2,
+//          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
+//   requires CopyConstructible<Pred>
+//   constexpr bool     // constexpr after c++17
+//   equal(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred);
+
 
 #include <algorithm>
 #include <functional>
@@ -22,6 +30,28 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool eq(int a, int b) { return a == b; }
+
+TEST_CONSTEXPR bool test_constexpr() {
+    int ia[] = {1, 3, 6, 7};
+    int ib[] = {1, 3};
+    int ic[] = {1, 3, 5, 7};
+    typedef input_iterator<int*>         II;
+    typedef bidirectional_iterator<int*> BI;
+
+    return !std::equal(std::begin(ia), std::end(ia), std::begin(ic)              , eq)
+        && !std::equal(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq)
+        &&  std::equal(std::begin(ib), std::end(ib), std::begin(ic)              , eq)
+        && !std::equal(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic), eq)
+
+        &&  std::equal(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic))                  , eq)
+        && !std::equal(BI(std::begin(ib)), BI(std::end(ib)), BI(std::begin(ic)), BI(std::end(ic)), eq)
+        ;
+    }
+#endif
+
+
 int comparison_count = 0;
 template <typename T>
 bool counting_equals ( const T &a, const T &b ) {
@@ -81,4 +111,8 @@ int main()
                        random_access_iterator<const int*>(ib+s),
                        std::equal_to<int>()));
 #endif
+
+#if TEST_STD_VER > 17
+    static_assert(test_constexpr());
+#endif
 }

test/std/algorithms/alg.nonmodifying/mismatch/mismatch.pass.cpp

@@ -11,8 +11,12 @@
 
 // template<InputIterator Iter1, InputIterator Iter2>
 //   requires HasEqualTo<Iter1::value_type, Iter2::value_type>
-//   pair<Iter1, Iter2>
+//   constexpr pair<Iter1, Iter2>   // constexpr after c++17
 //   mismatch(Iter1 first1, Iter1 last1, Iter2 first2);
+//
+// template<InputIterator Iter1, InputIterator Iter2Pred>
+//   constexpr pair<Iter1, Iter2>   // constexpr after c++17
+//   mismatch(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2); // C++14
 
 #include <algorithm>
 #include <cassert>
@@ -20,6 +24,40 @@
 #include "test_macros.h"
 #include "test_iterators.h"
 
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool test_constexpr() {
+    int ia[] = {1, 3, 6, 7};
+    int ib[] = {1, 3};
+    int ic[] = {1, 3, 5, 7};
+    typedef input_iterator<int*>         II;
+    typedef bidirectional_iterator<int*> BI;
+
+    auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic));
+    if (p1.first != ia+2 || p1.second != ic+2)
+        return false;
+        
+    auto p2 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic));
+    if (p2.first != ia+2 || p2.second != ic+2)
+        return false;
+    
+    auto p3 = std::mismatch(std::begin(ib), std::end(ib), std::begin(ic));
+    if (p3.first != ib+2 || p3.second != ic+2)
+        return false;
+
+    auto p4 = std::mismatch(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic));
+    if (p4.first != ib+2 || p4.second != ic+2)
+        return false;
+
+    auto p5 = std::mismatch(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic)));
+    if (p5.first != II(ib+2) || p5.second != II(ic+2))
+        return false;
+    auto p6 = std::mismatch(BI(std::begin(ib)), BI(std::end(ib)), BI(std::begin(ic)), BI(std::end(ic)));
+    if (p6.first != BI(ib+2) || p6.second != BI(ic+2))
+        return false;
+
+    return true;    
+    }
+#endif
 
 int main()
 {

test/std/algorithms/alg.nonmodifying/mismatch/mismatch_pred.pass.cpp

@@ -12,8 +12,12 @@
 // template<InputIterator Iter1, InputIterator Iter2,
 //          Predicate<auto, Iter1::value_type, Iter2::value_type> Pred>
 //   requires CopyConstructible<Pred>
-//   pair<Iter1, Iter2>
+//   constexpr pair<Iter1, Iter2>   // constexpr after c++17
 //   mismatch(Iter1 first1, Iter1 last1, Iter2 first2, Pred pred);
+//
+// template<InputIterator Iter1, InputIterator Iter2, Predicate Pred>
+//   constexpr pair<Iter1, Iter2>   // constexpr after c++17
+//   mismatch(Iter1 first1, Iter1 last1, Iter2 first2, Iter2 last2, Pred pred); // C++14
 
 #include <algorithm>
 #include <functional>
@@ -23,6 +27,44 @@
 #include "test_iterators.h"
 #include "counting_predicates.hpp"
 
+#if TEST_STD_VER > 17
+TEST_CONSTEXPR bool eq(int a, int b) { return a == b; }
+
+TEST_CONSTEXPR bool test_constexpr() {
+    int ia[] = {1, 3, 6, 7};
+    int ib[] = {1, 3};
+    int ic[] = {1, 3, 5, 7};
+    typedef input_iterator<int*>         II;
+    typedef bidirectional_iterator<int*> BI;
+
+    auto p1 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), eq);
+    if (p1.first != ia+2 || p1.second != ic+2)
+        return false;
+        
+    auto p2 = std::mismatch(std::begin(ia), std::end(ia), std::begin(ic), std::end(ic), eq);
+    if (p2.first != ia+2 || p2.second != ic+2)
+        return false;
+    
+    auto p3 = std::mismatch(std::begin(ib), std::end(ib), std::begin(ic), eq);
+    if (p3.first != ib+2 || p3.second != ic+2)
+        return false;
+
+    auto p4 = std::mismatch(std::begin(ib), std::end(ib), std::begin(ic), std::end(ic), eq);
+    if (p4.first != ib+2 || p4.second != ic+2)
+        return false;
+
+    auto p5 = std::mismatch(II(std::begin(ib)), II(std::end(ib)), II(std::begin(ic)), eq);
+    if (p5.first != II(ib+2) || p5.second != II(ic+2))
+        return false;
+    auto p6 = std::mismatch(BI(std::begin(ib)), BI(std::end(ib)), BI(std::begin(ic)), BI(std::end(ic)), eq);
+    if (p6.first != BI(ib+2) || p6.second != BI(ic+2))
+        return false;
+
+    return true;    
+    }
+#endif
+
+
 #if TEST_STD_VER > 11
 #define HAS_FOUR_ITERATOR_VERSION
 #endif