[libc++] [test] Eliminate libcpp-no-noexcept-function-type and libcpp-no-structured-bindings

[• Quuxplusone]

Summary

(Following up from D113348.)

At this point, every supported compiler that claims a -std=c++17 mode should also support these features.

[ldionne]

When you grep for stuff, make sure you include libcxxabi/ and libunwind/. The test suites for those two projects often use things defined in libcxx/, especially the Lit features.

LGTM in essence, once libcxxabi and libunwind have been fixed and CI is passing. Thanks for the cleanup!

[Mordante]

Thanks for the cleanup!
LGTM after @ldionne's comments have been addressed.

[• Quuxplusone]

Deal with the two uses of no-noexcept-function-type in libcxxabi/test. @ldionne, does this LGTY if CI is happy?

[• Quuxplusone]

Poke CI.

libcxx/test/std/utilities/meta/meta.rel/is_nothrow_invocable.pass.cpp

 }
 
 template <class Ret, class Fn, class... Args>
 constexpr bool throws_invocable_r() {
   return std::is_invocable_r<Ret, Fn, Args...>::value &&
          !std::is_nothrow_invocable_r<Ret, Fn, Args...>::value;
 }
 
-// FIXME(EricWF) Don't test the where noexcept is *not* part of the type system
-// once implementations have caught up.
 void test_noexcept_function_pointers() {
   struct Dummy {
     void foo() noexcept {}
     static void bar() noexcept {}
   };
-#if !defined(__cpp_noexcept_function_type)
-  {
-    // Check that PMF's and function pointers *work*. is_nothrow_invocable will always
-    // return false because 'noexcept' is not part of the function type.
-    static_assert(throws_invocable<decltype(&Dummy::foo), Dummy&>(), "");
-    static_assert(throws_invocable<decltype(&Dummy::bar)>(), "");
-  }
-#else
-  {
-    // Check that PMF's and function pointers actually work and that
-    // is_nothrow_invocable returns true for noexcept PMF's and function
-    // pointers.
-    static_assert(
-        std::is_nothrow_invocable<decltype(&Dummy::foo), Dummy&>::value, "");
-    static_assert(std::is_nothrow_invocable<decltype(&Dummy::bar)>::value, "");
-  }
-#endif
-}
+  static_assert(std::is_nothrow_invocable<decltype(&Dummy::foo), Dummy&>::value, "");
 
 int main(int, char**) {
   using AbominableFunc = void(...) const noexcept;
   //  Non-callable things
   {
     static_assert(!std::is_nothrow_invocable<void>::value, "");
     static_assert(!std::is_nothrow_invocable<const void>::value, "");
     static_assert(!std::is_nothrow_invocable<volatile void>::value, "");

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.helper/tuple_size_structured_bindings.pass.cpp

 
 // template <class... Types> class tuple;
 
 // template <class... Types>
 //   struct tuple_size<tuple<Types...>>
 //     : public integral_constant<size_t, sizeof...(Types)> { };
 
 // UNSUPPORTED: c++03, c++11, c++14
-// UNSUPPORTED: libcpp-no-structured-bindings
 
 #include <tuple>
 #include <array>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 

libcxx/utils/libcxx/test/features.py

DEFAULT_FEATURES = [
   Feature(name='diagnose-if-support',
           when=lambda cfg: hasCompileFlag(cfg, '-Wuser-defined-warnings'),
           actions=[AddCompileFlag('-Wuser-defined-warnings')]),
 
   Feature(name='has-fblocks',                   when=lambda cfg: hasCompileFlag(cfg, '-fblocks')),
   Feature(name='-fsized-deallocation',          when=lambda cfg: hasCompileFlag(cfg, '-fsized-deallocation')),
   Feature(name='-faligned-allocation',          when=lambda cfg: hasCompileFlag(cfg, '-faligned-allocation')),
   Feature(name='fdelayed-template-parsing',     when=lambda cfg: hasCompileFlag(cfg, '-fdelayed-template-parsing')),
-  Feature(name='libcpp-no-structured-bindings', when=lambda cfg: '__cpp_structured_bindings' not in featureTestMacros(cfg)),
   Feature(name='libcpp-no-concepts',            when=lambda cfg: featureTestMacros(cfg).get('__cpp_concepts', 0) < 201907),
   Feature(name='has-fobjc-arc',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc') and
                                                                  sys.platform.lower().strip() == 'darwin'), # TODO: this doesn't handle cross-compiling to Apple platforms.
   Feature(name='objective-c++',                 when=lambda cfg: hasCompileFlag(cfg, '-xobjective-c++ -fobjc-arc')),
-  Feature(name='no-noexcept-function-type',     when=lambda cfg: featureTestMacros(cfg).get('__cpp_noexcept_function_type', 0) < 201510),
 
   Feature(name='non-lockfree-atomics',
           when=lambda cfg: sourceBuilds(cfg, """
             #include <atomic>
             struct Large { int storage[100]; };
             std::atomic<Large> x;
             int main(int, char**) { (void)x.load(); return 0; }
           """)),

libcxxabi/test/catch_function_03.pass.cpp

 //===---------------------- catch_function_03.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
 //
 //===----------------------------------------------------------------------===//
 
 // Can a noexcept function pointer be caught by a non-noexcept catch clause?
-// UNSUPPORTED: no-exceptions, no-noexcept-function-type
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: no-exceptions
 
 // Support for catching a function pointer including noexcept was shipped in macOS 10.13
 // XFAIL: use_system_cxx_lib && {{.+}}-apple-macosx10.{{9|10|11|12}}
 
 #include <cassert>
 
 template<bool Noexcept> void f() noexcept(Noexcept) {}
 template<bool Noexcept> using FnType = void() noexcept(Noexcept);

libcxxabi/test/catch_member_function_pointer_02.pass.cpp

 //===--------------- catch_member_function_pointer_02.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
 //
 //===----------------------------------------------------------------------===//
 
 // Can a noexcept member function pointer be caught by a non-noexcept catch clause?
-// UNSUPPORTED: no-exceptions, no-noexcept-function-type
+// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: no-exceptions
 
 // Support for catching a function pointer including noexcept was shipped in macOS 10.13
 // XFAIL: use_system_cxx_lib && {{.+}}-apple-macosx10.{{9|10|11|12}}
 
 // GCC supports noexcept function types but this test still fails.
 // This is likely a bug in their implementation. Investigation needed.
 // XFAIL: gcc-11