[libc++][NFC] Move several .fail.cpp tests to .verify.cpp

[ldionne]

Summary

A few tests were also straightforward to translate to SFINAE tests
instead, so in a few cases I did that and removed the .fail.cpp test
entirely.

[ldionne]

Fix CI issue

[ldionne]

Add missing include

[ldionne]

Bootstrapping build failure is seen in other runs and is unrelated to the change.

libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.fail.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <fstream>
-
-// template<class charT, class traits = char_traits<charT>>
-//   class basic_filebuf;
-//
-// The char type of the stream and the char_type of the traits have to match
-
-// UNSUPPORTED: no-wide-characters
-
-#include <fstream>
-
-int main(int, char**)
-{
-  std::basic_filebuf<char, std::char_traits<wchar_t> > f;
-  // expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-
-  return 0;
-}

libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <fstream>
 
-// template <class charT, class traits = char_traits<charT> >
-// class basic_fstream
-
+// template<class charT, class traits = char_traits<charT>>
+//   class basic_filebuf;
+//
 // The char type of the stream and the char_type of the traits have to match
 
 // UNSUPPORTED: no-wide-characters
 
 #include <fstream>
 
-int main(int, char**)
-{
-  std::basic_fstream<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
-//  expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
-
+std::basic_filebuf<char, std::char_traits<wchar_t> > f;
+// expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
-// expected-error@istream:* {{only virtual member functions can be marked 'override'}}
-// expected-error@istream:* {{only virtual member functions can be marked 'override'}}
-
-// FIXME: As of commit r324062 Clang incorrectly generates a diagnostic about mismatching
-// exception specifications for types which are already invalid for one reason or another.
-// For now we tolerate this diagnostic.
-// expected-error@ostream:* 0-1 {{exception specification of overriding function is more lax than base version}}
-
-  return 0;
-}

libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.verify.cpp

 // class basic_fstream
 
 // The char type of the stream and the char_type of the traits have to match
 
 // UNSUPPORTED: no-wide-characters
 
 #include <fstream>
 
-int main(int, char**)
-{
-  std::basic_fstream<char, std::char_traits<wchar_t> > f;
-//  expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
-//  expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
+// expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
+// expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
 
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@fstream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@istream:* {{only virtual member functions can be marked 'override'}}
 // expected-error@istream:* {{only virtual member functions can be marked 'override'}}
 
 // FIXME: As of commit r324062 Clang incorrectly generates a diagnostic about mismatching
 // exception specifications for types which are already invalid for one reason or another.
 // For now we tolerate this diagnostic.
 // expected-error@ostream:* 0-1 {{exception specification of overriding function is more lax than base version}}
-
-  return 0;
-}

libcxx/test/libcxx/input.output/iostream.format/input.streams/traits_mismatch.verify.cpp

 // template <class charT, class traits = char_traits<charT> >
 // class basic_istream;
 
 // The char type of the stream and the char_type of the traits have to match
 
 // UNSUPPORTED: no-wide-characters
 
 #include <istream>
-#include <type_traits>
-#include <cassert>
+#include <string>
 
 struct test_istream
     : public std::basic_istream<char, std::char_traits<wchar_t> > {};
 
-
-int main(int, char**)
-{
-//  expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
-//  expected-error@istream:* {{only virtual member functions can be marked 'override'}}
-
-  return 0;
-}
+// expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
+// expected-error@istream:* {{only virtual member functions can be marked 'override'}}

libcxx/test/libcxx/input.output/iostream.format/output.streams/traits_mismatch.verify.cpp

 // template <class charT, class traits = char_traits<charT> >
 // class basic_ostream;
 
 // The char type of the stream and the char_type of the traits have to match
 
 // UNSUPPORTED: no-wide-characters
 
 #include <ostream>
-#include <type_traits>
-#include <cassert>
+#include <string>
 
 struct test_ostream
     : public std::basic_ostream<char, std::char_traits<wchar_t> > {};
 
-
-int main(int, char**)
-{
-//  expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
-//  expected-error@ostream:* {{only virtual member functions can be marked 'override'}}
-
-  return 0;
-}
+// expected-error-re@ios:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
+// expected-error@ostream:* {{only virtual member functions can be marked 'override'}}

libcxx/test/libcxx/input.output/string.streams/traits_mismatch.fail.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// <sstream>
-
-//  template<class charT, class traits = char_traits<charT>,
-//           class Allocator = allocator<charT>>
-//    class basic_stringbuf;
-//
-// The char type of the stream and the char_type of the traits have to match
-
-// UNSUPPORTED: no-wide-characters
-
-#include <sstream>
-
-int main(int, char**)
-{
-  std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
-//  expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
-//  expected-error-re@string:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
-
-  // expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
-  // expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
-
-  return 0;
-}

libcxx/test/libcxx/input.output/string.streams/traits_mismatch.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// <sstream>
+
+//  template<class charT, class traits = char_traits<charT>,
+//           class Allocator = allocator<charT>>
+//    class basic_stringbuf;
+//
+// The char type of the stream and the char_type of the traits have to match
+
+// UNSUPPORTED: no-wide-characters
+
+#include <sstream>
+
+std::basic_stringbuf<char, std::char_traits<wchar_t> > sb;
+// expected-error-re@streambuf:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
+// expected-error-re@string:* {{{{(static_assert|static assertion)}} failed{{.*}}traits_type::char_type must be the same type as CharT}}
+
+// expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
+// expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
+// expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
+// expected-error@sstream:* {{only virtual member functions can be marked 'override'}}
+// expected-error@sstream:* {{only virtual member functions can be marked 'override'}}

libcxx/test/libcxx/thread/thread.mutex/thread_safety_missing_unlock.verify.cpp

 // <mutex>
 
 // ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_THREAD_SAFETY_ANNOTATIONS
 
 #include <mutex>
 
 std::mutex m;
 
-int main(int, char**) {
+void f() {
   m.lock();
-
-  return 0;
 } // expected-error {{mutex 'm' is still held at the end of function}}

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <tuple>
 
-// See llvm.org/PR20855
+// See https://llvm.org/PR20855
 
 #include <tuple>
 #include <string>
 
 #include "test_macros.h"
 
 template <class Tp>
 struct ConvertsTo {

 template <class T> struct CannotDeduce {
  using type = T;
 };
 
 template <class ...Args>
 void F(typename CannotDeduce<std::tuple<Args...>>::type const&) {}
 
 
-int main(int, char**) {
+void f() {
 #if TEST_HAS_BUILTIN_IDENTIFIER(__reference_binds_to_temporary)
   // Test that we emit our diagnostic from the library.
   // expected-error@tuple:* 8 {{Attempted construction of reference element binds to a temporary whose lifetime has ended}}
 
   // Good news everybody! Clang now diagnoses this for us!
   // expected-error@tuple:* 0+ {{reference member '__value_' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
 
   {
// expected-error@tuple:* 0+ {{reference member '__value_' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
     std::allocator<int> alloc;
     std::tuple<std::string &&> t2("hello"); // expected-note {{requested here}}
     std::tuple<std::string &&> t3(std::allocator_arg, alloc, "hello"); // expected-note {{requested here}}
   }
 #else
 #error force failure
 // expected-error@-1 {{force failure}}
 #endif
-
-  return 0;
 }

libcxx/test/libcxx/utilities/utility/pairs/pairs.pair/pair.tuple_element.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // tuple_element<I, pair<T1, T2> >::type
 
 #include <utility>
 
-int main(int, char**)
-{
-    {
-    typedef std::pair<int, double> P;
-    std::tuple_element<2, P>::type foo; // expected-note {{requested here}}
-        // expected-error-re@*:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '2U[L]{0,2} < 2')?}}{{.*}}Index out of bounds in std::tuple_element<std::pair<T1, T2>>}}
-    }
-
-  return 0;
-}
+void f() {

libcxx/test/std/containers/sequences/array/array.tuple/get.verify.cpp

 // template <size_t I, class T, size_t N> T& get(array<T, N>& a);
 
 // Prevent -Warray-bounds from issuing a diagnostic when testing with clang verify.
 // ADDITIONAL_COMPILE_FLAGS: -Wno-array-bounds
 
 #include <array>
 #include <cassert>
 
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        C c = {1, 2, 3.5};
-        std::get<3>(c) = 5.5; // expected-note {{requested here}}
-        // expected-error-re@array:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::get<> (std::array)}}
-    }
-
-  return 0;
-}
+void f() {

libcxx/test/std/containers/sequences/array/array.tuple/tuple_element.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <array>
 
 // tuple_element<I, array<T, N> >::type
 
 #include <array>
 #include <cassert>
 
-int main(int, char**)
-{
-    {
-        typedef double T;
-        typedef std::array<T, 3> C;
-        std::tuple_element<3, C> foo; // expected-note {{requested here}}
-        // expected-error-re@array:* {{{{(static_assert|static assertion)}} failed{{( due to requirement '3U[L]{0,2} < 3U[L]{0,2}')?}}{{.*}}Index out of bounds in std::tuple_element<> (std::array)}}
-    }
-
-  return 0;
-}

libcxx/test/std/containers/views/views.span/span.cons/array.fail.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// <span>
-
-// template<size_t N>
-//     constexpr span(element_type (&arr)[N]) noexcept;
-// template<size_t N>
-//     constexpr span(array<value_type, N>& arr) noexcept;
-// template<size_t N>
-//     constexpr span(const array<value_type, N>& arr) noexcept;
-//
-// Remarks: These constructors shall not participate in overload resolution unless:
-//   - extent == dynamic_extent || N == extent is true, and
-//   - remove_pointer_t<decltype(data(arr))>(*)[] is convertible to ElementType(*)[].
-//
-
-
-#include <span>
-#include <cassert>
-#include <string>
-
-#include "test_macros.h"
-
-               int   arr[] = {1,2,3};
-const          int  carr[] = {4,5,6};
-      volatile int  varr[] = {7,8,9};
-const volatile int cvarr[] = {1,3,5};
-
-int main(int, char**)
-{
-//  Size wrong
-    {
-    std::span<int, 2>   s1(arr); // expected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
-    }
-
-//  Type wrong
-    {
-    std::span<float>    s1(arr);   // expected-error {{no matching constructor for initialization of 'std::span<float>'}}
-    std::span<float, 3> s2(arr);   // expected-error {{no matching constructor for initialization of 'std::span<float, 3>'}}
-    }
-
-//  CV wrong (dynamically sized)
-    {
-    std::span<               int> s1{ carr};    // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s2{ varr};    // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<               int> s3{cvarr};    // expected-error {{no matching constructor for initialization of 'std::span<int>'}}
-    std::span<const          int> s4{ varr};    // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<const          int> s5{cvarr};    // expected-error {{no matching constructor for initialization of 'std::span<const int>'}}
-    std::span<      volatile int> s6{ carr};    // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    std::span<      volatile int> s7{cvarr};    // expected-error {{no matching constructor for initialization of 'std::span<volatile int>'}}
-    }
-
-//  CV wrong (statically sized)
-    {
-    std::span<               int,3> s1{ carr};  // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<               int,3> s2{ varr};  // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<               int,3> s3{cvarr};  // expected-error {{no matching constructor for initialization of 'std::span<int, 3>'}}
-    std::span<const          int,3> s4{ varr};  // expected-error {{no matching constructor for initialization of 'std::span<const int, 3>'}}
-    std::span<const          int,3> s5{cvarr};  // expected-error {{no matching constructor for initialization of 'std::span<const int, 3>'}}
-    std::span<      volatile int,3> s6{ carr};  // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
-    std::span<      volatile int,3> s7{cvarr};  // expected-error {{no matching constructor for initialization of 'std::span<volatile int, 3>'}}
-    }
-
-  return 0;
-}

libcxx/test/std/containers/views/views.span/span.cons/array.pass.cpp

 // template<size_t N>
 //     constexpr span(element_type (&arr)[N]) noexcept;
 //
 // Remarks: These constructors shall not participate in overload resolution unless:
 //   - extent == dynamic_extent || N == extent is true, and
 //   - remove_pointer_t<decltype(data(arr))>(*)[] is convertible to ElementType(*)[].
 //
 
-
-#include <span>
 #include <cassert>
+#include <span>
 #include <string>
+#include <type_traits>
 
 #include "test_macros.h"
 
 
 void checkCV()
 {
                    int   arr[] = {1,2,3};
     const          int  carr[] = {4,5,6};
int main(int, char**)
     testSpan<std::string>();
 
     static_assert(testSpan<int>());
     static_assert(testSpan<double>());
     static_assert(testSpan<A>());
 
     checkCV();
 
+    // Size wrong
+    {
+        static_assert(!std::is_constructible<std::span<int, 2>, int (&)[3]>::value, "");
+    }
+
+    // Type wrong
+    {
+        static_assert(!std::is_constructible<std::span<float>,    int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<float, 3>, int (&)[3]>::value, "");
+    }
+
+    // CV wrong (dynamically sized)
+    {
+        static_assert(!std::is_constructible<std::span<int>, const int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<int>, volatile int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<int>, const volatile int (&)[3]>::value, "");
+
+        static_assert(!std::is_constructible<std::span<const int>, volatile int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<const int>, const volatile int (&)[3]>::value, "");
+
+        static_assert(!std::is_constructible<std::span<volatile int>, const int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<volatile int>, const volatile int (&)[3]>::value, "");
+    }
+
+    // CV wrong (statically sized)
+    {
+        static_assert(!std::is_constructible<std::span<int, 3>, const int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<int, 3>, volatile int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<int, 3>, const volatile int (&)[3]>::value, "");
+
+        static_assert(!std::is_constructible<std::span<const int, 3>, volatile int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<const int, 3>, const volatile int (&)[3]>::value, "");
+
+        static_assert(!std::is_constructible<std::span<volatile int, 3>, const int (&)[3]>::value, "");
+        static_assert(!std::is_constructible<std::span<volatile int, 3>, const volatile int (&)[3]>::value, "");
+    }
+
     return 0;
 }

libcxx/test/std/containers/views/views.span/span.cons/default.fail.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-// UNSUPPORTED: c++03, c++11, c++14, c++17
-
-// <span>
-
-// constexpr span() noexcept;
-//
-//  Remarks: This constructor shall not participate in overload resolution
-//          unless Extent == 0 || Extent == dynamic_extent is true.
-
-
-#include <span>
-#include <cassert>
-#include <string>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-  std::span<int, 2> s; // expected-error {{no matching constructor for initialization of 'std::span<int, 2>'}}
-
-  return 0;
-}

libcxx/test/std/language.support/support.dynamic/nothrow_t.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 //                     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++03
 
 // struct nothrow_t {
 //   explicit nothrow_t() = default;
 // };
 // extern const nothrow_t nothrow;
 
-// This test checks for LWG 2510.
+// This test checks for https://wg21.link/LWG2510.
 
 #include <new>
 
-
 std::nothrow_t f() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
-
-int main(int, char**) {
-    return 0;
-}

libcxx/test/std/thread/thread.mutex/thread.lock/types.verify.cpp

 // UNSUPPORTED: no-threads
 
 // <mutex>
 
 // struct defer_lock_t { explicit defer_lock_t() = default; };
 // struct try_to_lock_t { explicit try_to_lock_t() = default; };
 // struct adopt_lock_t { explicit adopt_lock_t() = default; };
 
-// This test checks for LWG 2510.
+// This test checks for https://wg21.link/LWG2510.
 
 #include <mutex>
 
-
 std::defer_lock_t f1() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::try_to_lock_t f2() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::adopt_lock_t f3() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
-
-int main(int, char**) {
-    return 0;
-}

libcxx/test/std/utilities/memory/allocator.tag/allocator_arg.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <memory>
 
 // struct allocator_arg_t { explicit allocator_arg_t() = default; };
 // const allocator_arg_t allocator_arg = allocator_arg_t();
 
-// This test checks for LWG 2510.
+// This test checks for https://wg21.link/LWG2510.
 
 #include <memory>
 
-
 std::allocator_arg_t f() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
-
-int main(int, char**) {
-    return 0;
-}

libcxx/test/std/utilities/optional/optional.syn/optional_in_place_t.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // A program that necessitates the instantiation of template optional for
 // (possibly cv-qualified) in_place_t is ill-formed.
 
 #include <optional>
 
-int main(int, char**)
-{
-    using std::optional;
-    using std::in_place_t;
-    using std::in_place;
-
-    optional<in_place_t> opt; // expected-note {{requested here}}
+void f() {
+    std::optional<std::in_place_t> opt; // expected-note {{requested here}}
     // expected-error@optional:* {{instantiation of optional with in_place_t is ill-formed}}
-
-  return 0;
 }

libcxx/test/std/utilities/optional/optional.syn/optional_nullopt_t.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
+
 // <optional>
 
 // A program that necessitates the instantiation of template optional for
 // (possibly cv-qualified) nullopt_t is ill-formed.
 
 #include <optional>
 
-int main(int, char**)
-{
-    using std::optional;
-    using std::nullopt_t;
-    using std::nullopt;
-
-    optional<nullopt_t> opt; // expected-note 1 {{requested here}}
-    optional<const nullopt_t> opt1; // expected-note 1 {{requested here}}
-    optional<nullopt_t &> opt2; // expected-note 1 {{requested here}}
-    optional<nullopt_t &&> opt3; // expected-note 1 {{requested here}}
+void f() {
+    std::optional<std::nullopt_t> opt; // expected-note 1 {{requested here}}
+    std::optional<const std::nullopt_t> opt1; // expected-note 1 {{requested here}}
+    std::optional<std::nullopt_t &> opt2; // expected-note 1 {{requested here}}
+    std::optional<std::nullopt_t &&> opt3; // expected-note 1 {{requested here}}
     // expected-error@optional:* 4 {{instantiation of optional with nullopt_t is ill-formed}}
-
-  return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_element.verify.cpp

 // struct tuple_element<I, tuple<Types...> >
 // {
 //     typedef Ti type;
 // };
 
 // UNSUPPORTED: c++03
 
 #include <tuple>
-#include <type_traits>
 
-int main(int, char**)
-{
-    using T =  std::tuple<int, long, void*>;
-    using E1 = typename std::tuple_element<1, T &>::type; // expected-error{{undefined template}}
-    using E2 = typename std::tuple_element<3, T>::type;
-    using E3 = typename std::tuple_element<4, T const>::type;
-        // expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}}
-
-  return 0;
-}
+using E3 = typename std::tuple_element<4, T const>::type; // expected-error-re@*:* 2 {{{{(static_assert|static assertion)}} failed}}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size.verify.cpp

 // template <class... Types>
 //   class tuple_size<tuple<Types...>>
 //     : public integral_constant<size_t, sizeof...(Types)> { };
 
 // Expect failures with a reference type, pointer type, and a non-tuple type.
 
 #include <tuple>
 
-int main(int, char**)
-{
+void f() {
     (void)std::tuple_size<std::tuple<> &>::value; // expected-error {{implicit instantiation of undefined template}}
     (void)std::tuple_size<int>::value; // expected-error {{implicit instantiation of undefined template}}
     (void)std::tuple_size<std::tuple<>*>::value; // expected-error {{implicit instantiation of undefined template}}
-
-  return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_incomplete.verify.cpp

 struct std::tuple_size<Dummy2> {
 public:
   static void value() {}
 };
 
 template <>
 struct std::tuple_size<Dummy3> {};
 
-int main(int, char**)
-{
+void f() {
   // Test that tuple_size<const T> is not incomplete when tuple_size<T>::value
   // is well-formed but not a constant expression.
   {
     // expected-error@*:* 1 {{is not a constant expression}}
     (void)std::tuple_size<const Dummy1>::value; // expected-note {{here}}
   }
   // Test that tuple_size<const T> is not incomplete when tuple_size<T>::value
   // is well-formed but not convertible to size_t.
   {
     // expected-error@*:* 1 {{value of type 'void ()' is not implicitly convertible to}}
     (void)std::tuple_size<const Dummy2>::value; // expected-note {{here}}
   }
   // Test that tuple_size<const T> generates an error when tuple_size<T> is
   // complete but ::value isn't a constant expression convertible to size_t.
   {
     // expected-error@*:* 1 {{no member named 'value'}}
     (void)std::tuple_size<const Dummy3>::value; // expected-note {{here}}
   }
-
-  return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_v.verify.cpp

 // <tuple>
 
 // template <class T> constexpr size_t tuple_size_v = tuple_size<T>::value;
 
 // Expect failures with a reference type, pointer type, and a non-tuple type.
 
 #include <tuple>
 
-int main(int, char**)
-{
+void f() {
     (void)std::tuple_size_v<std::tuple<> &>; // expected-note {{requested here}}
     (void)std::tuple_size_v<int>; // expected-note {{requested here}}
     (void)std::tuple_size_v<std::tuple<>*>; // expected-note {{requested here}}
     // expected-error@tuple:* 3 {{implicit instantiation of undefined template}}
-
-  return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc.verify.cpp

 #include <memory>
 
 
 struct ExplicitDefault { explicit ExplicitDefault() { } };
 
 std::tuple<ExplicitDefault> explicit_default_test() {
     return {std::allocator_arg, std::allocator<int>()}; // expected-error {{chosen constructor is explicit in copy-initialization}}
 }
-
-int main(int, char**) {
-    return 0;
-}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.verify.cpp

std::tuple<ExplicitCopy> const_explicit_copy_test() {
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
 std::tuple<ExplicitCopy> non_const_explicity_copy_test() {
     ExplicitCopy e(42);
     return {std::allocator_arg, std::allocator<int>{}, e};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
-int main(int, char**)
-{
-    const_explicit_copy_test();
-    non_const_explicity_copy_test();
-
-  return 0;
-}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.verify.cpp

std::tuple<ExplicitCopy> const_explicit_copy_test() {
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
 std::tuple<ExplicitCopy> non_const_explicit_copy_test() {
     std::tuple<int> t1(42);
     return {std::allocator_arg, std::allocator<int>{}, t1};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
-
-int main(int, char**)
-{
-
-
-  return 0;
-}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.verify.cpp

struct ExplicitCopy {
   explicit ExplicitCopy(ExplicitCopy const&) {}
 };
 
 std::tuple<ExplicitCopy> explicit_move_test() {
     std::tuple<int> t1(42);
     return {std::allocator_arg, std::allocator<int>{}, std::move(t1)};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
-
-int main(int, char**)
-{
-
-
-  return 0;
-}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/const_Types.verify.cpp

std::tuple<ExplicitCopy> non_const_explicit_copy() {
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
 std::tuple<ExplicitCopy> const_explicit_copy_no_brace() {
     const ExplicitCopy e(42);
     return e;
     // expected-error@-1 {{no viable conversion}}
 }
-
-int main(int, char**)
-{
-
-  return 0;
-}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/default.verify.cpp

 std::tuple<Implicit, Implicit, Implicit> test8() { return {}; }
 std::tuple<Implicit, Implicit, Explicit> test9() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::tuple<Implicit, Explicit, Implicit> test10() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::tuple<Implicit, Explicit, Explicit> test11() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::tuple<Explicit, Implicit, Implicit> test12() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::tuple<Explicit, Implicit, Explicit> test13() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::tuple<Explicit, Explicit, Implicit> test14() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::tuple<Explicit, Explicit, Explicit> test15() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
-
-int main(int, char**) {
-    return 0;
-}

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.elem/get_const_rv.verify.cpp

 
 #include <tuple>
 
 template <class T> void cref(T const&) {}
 template <class T> void cref(T const&&) = delete;
 
 std::tuple<int> const tup4() { return std::make_tuple(4); }
 
-int main(int, char**)
-{
+void f() {
     // LWG2485: tuple should not open a hole in the type system, get() should
     // imitate [expr.ref]'s rules for accessing data members
     {
-        cref(std::get<0>(tup4()));  // expected-error {{call to deleted function 'cref'}}
+        cref(std::get<0>(tup4())); // expected-error {{call to deleted function 'cref'}}
     }
-
-  return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.elem/tuple.by.type.verify.cpp

 }
 
 void test_bad_return_type() {
     typedef std::unique_ptr<int> upint;
     std::tuple<upint> t;
     upint p = std::get<upint>(t); // expected-error{{deleted copy constructor}}
 }
 
-int main(int, char**)
-{
+void f() {
     test_bad_index();
     test_bad_return_type();
-
-  return 0;
 }

libcxx/test/std/utilities/utility/pairs/pair.piecewise/piecewise_construct_t.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03
 
 // <utility>
 
 // struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
 // constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 
-// This test checks for LWG 2510.
+// This test checks for https://wg21.link/LWG2510.
 
 #include <utility>
 
 std::piecewise_construct_t f() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}

libcxx/test/std/utilities/utility/pairs/pairs.pair/ctor.default.explicit_LWG2510.verify.cpp

 
 // <utility>
 
 // template <class T1, class T2> struct pair
 
 // explicit(see-below) constexpr pair();
 
 // This test checks the conditional explicitness of std::pair's default
-// constructor as introduced by the resolution of LWG 2510.
+// constructor as introduced by the resolution of https://wg21.link/LWG2510.
 
 #include <utility>
 
 
 struct ImplicitlyDefaultConstructible {
     ImplicitlyDefaultConstructible() = default;
 };
 
 struct ExplicitlyDefaultConstructible {
     explicit ExplicitlyDefaultConstructible() = default;
 };
 
 std::pair<ImplicitlyDefaultConstructible, ExplicitlyDefaultConstructible> test1() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::pair<ExplicitlyDefaultConstructible, ImplicitlyDefaultConstructible> test2() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::pair<ExplicitlyDefaultConstructible, ExplicitlyDefaultConstructible> test3() { return {}; } // expected-error 1 {{chosen constructor is explicit in copy-initialization}}
 std::pair<ImplicitlyDefaultConstructible, ImplicitlyDefaultConstructible> test4() { return {}; }