Fix most GCC test failures.

This patch fixes almost all currently failing tests when
using GCC ToT.

The specific changes are:

(A) Workaround gcc.gnu.org/PR83921 which rejects variables w/o initializers
in constexpr contexts -- even when the variable is an empty class. This
bug has been worked around at all callsites by adding an initializer.
Additionally a new test, constexpr_init.pass.cpp, has been added to
test that Clang doesn't suffer from these bugs.

(B) Fix streambuf.assign/swap.pass.cpp. This test was never actually
calling the swap method as intended. In fact, the swap function it
intended to call was ill-formed when instantiated. GCC diagnosed
this ill-formedness w/o needing an instantiation.

(C) size_delete11.pass.cpp was fixed by adding c++2a to the list of
unsupported dialects.

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

test/std/algorithms/alg.nonmodifying/alg.find.end/find_end_pred.pass.cpp

@@ -30,14 +30,14 @@ struct count_equal
 };
 
 #if TEST_STD_VER > 17
-TEST_CONSTEXPR bool test_constexpr() {
+constexpr bool test_constexpr() {
     int ia[] = {0, 1, 2};
     int ib[] = {4, 5, 6};
     int ic[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 0, 1, 2, 3, 0, 1, 2, 0, 1, 0};
     typedef forward_iterator<int*>       FI;
     typedef bidirectional_iterator<int*> BI;
     typedef random_access_iterator<int*> RI;
-    std::equal_to<int> eq;
+    std::equal_to<int> eq{};
     return    (std::find_end(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ia)), FI(std::end(ia)), eq) == FI(ic+15))
            && (std::find_end(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ib)), FI(std::end(ib)), eq) == FI(std::end(ic)))
            && (std::find_end(BI(std::begin(ic)), BI(std::end(ic)), BI(std::begin(ia)), BI(std::end(ia)), eq) == BI(ic+15))

test/std/algorithms/alg.nonmodifying/alg.find.first.of/find_first_of_pred.pass.cpp

@@ -23,15 +23,14 @@
 #include "test_iterators.h"
 
 #if TEST_STD_VER > 17
-TEST_CONSTEXPR bool test_constexpr() {
+constexpr bool test_constexpr() {
     int ia[] = {1, 2, 3};
     int ib[] = {7, 8, 9};
     int ic[] = {0, 1, 2, 3, 4, 5, 0, 1, 2, 3};
     typedef forward_iterator<int*>       FI;
     typedef bidirectional_iterator<int*> BI;
     typedef random_access_iterator<int*> RI;
-    std::equal_to<int> eq;
-    
+    std::equal_to<int> eq{};
     return    (std::find_first_of(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ia)), FI(std::end(ia)), eq) == FI(ic+1))
            && (std::find_first_of(FI(std::begin(ic)), FI(std::end(ic)), FI(std::begin(ib)), FI(std::end(ib)), eq) == FI(std::end(ic)))
            && (std::find_first_of(BI(std::begin(ic)), BI(std::end(ic)), BI(std::begin(ia)), BI(std::end(ia)), eq) == BI(ic+1))

test/std/algorithms/alg.nonmodifying/alg.is_permutation/is_permutation_pred.pass.cpp

@@ -29,12 +29,12 @@ bool counting_equals ( const T &a, const T &b ) {
     }
 
 #if TEST_STD_VER > 17
-TEST_CONSTEXPR bool test_constexpr() {
+constexpr bool test_constexpr() {
     int ia[] = {0, 0, 0};
     int ib[] = {1, 1, 0};
     int ic[] = {1, 0, 1};
     int id[] = {1};
-    std::equal_to<int> c;
+    std::equal_to<int> c{};
     return !std::is_permutation(std::begin(ia), std::end(ia), std::begin(ib)              , c)
         && !std::is_permutation(std::begin(ia), std::end(ia), std::begin(ib), std::end(ib), c)
         &&  std::is_permutation(std::begin(ib), std::end(ib), std::begin(ic)              , c)

test/std/input.output/stream.buffers/streambuf/streambuf.protected/streambuf.assign/swap.pass.cpp

@@ -48,7 +48,6 @@ struct test
         assert(t.pptr()  == old_this.pptr());
         assert(t.epptr() == old_this.epptr());
         assert(t.getloc() == old_this.getloc());
-        return *this;
     }
 
     void setg(CharT* gbeg, CharT* gnext, CharT* gend)
@@ -66,12 +65,12 @@ int main()
     {
         test<char> t;
         test<char> t2;
-        swap(t2, t);
+        t2.swap(t);
     }
     {
         test<wchar_t> t;
         test<wchar_t> t2;
-        swap(t2, t);
+        t2.swap(t);
     }
     {
         char g1, g2, g3, p1, p3;
@@ -79,7 +78,7 @@ int main()
         t.setg(&g1, &g2, &g3);
         t.setp(&p1, &p3);
         test<char> t2;
-        swap(t2, t);
+        t2.swap(t);
     }
     {
         wchar_t g1, g2, g3, p1, p3;
@@ -87,17 +86,17 @@ int main()
         t.setg(&g1, &g2, &g3);
         t.setp(&p1, &p3);
         test<wchar_t> t2;
-        swap(t2, t);
+        t2.swap(t);
     }
     std::locale::global(std::locale(LOCALE_en_US_UTF_8));
     {
         test<char> t;
         test<char> t2;
-        swap(t2, t);
+        t2.swap(t);
     }
     {
         test<wchar_t> t;
         test<wchar_t> t2;
-        swap(t2, t);
+        t2.swap(t);
     }
 }

test/std/language.support/support.dynamic/new.delete/new.delete.single/sized_delete11.pass.cpp

@@ -12,7 +12,7 @@
 // Note that sized delete operator definitions below are simply ignored
 // when sized deallocation is not supported, e.g., prior to C++14.
 
-// UNSUPPORTED: c++14, c++17
+// UNSUPPORTED: c++14, c++17, c++2a
 // UNSUPPORTED: sanitizer-new-delete
 
 #include <new>

test/std/utilities/function.objects/comparisons/constexpr_init.pass.cpp

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11
+
+// XFAIL: gcc-7, gcc-8
+
+// <functional>
+
+// equal_to, not_equal_to, less, et al.
+
+// Test that these types can be constructed w/o an initializer in a constexpr
+// context. This is specifically testing gcc.gnu.org/PR83921
+
+
+#include <functional>
+#include "test_macros.h"
+
+template <class T>
+constexpr bool test_constexpr_context() {
+  std::equal_to<T> eq;
+  ((void)eq);
+  std::not_equal_to<T> neq;
+  ((void)neq);
+  std::less<T> l;
+  ((void)l);
+  std::less_equal<T> le;
+  ((void)le);
+  std::greater<T> g;
+  ((void)g);
+  std::greater_equal<T> ge;
+  ((void)ge);
+  return true;
+}
+
+static_assert(test_constexpr_context<int>(), "");
+static_assert(test_constexpr_context<void>(), "");
+
+
+int main() {
+
+}