[libc++] Remove std::function in C++03

[philnik]

Summary

std::function has been deprecated for a few releases now. Remove it with an option to opt-back-in with a note that this option will be removed in LLVM 16.

[jloser]

I'm OK removing this extension with an opt-in knob depending on how bad the breakage is internally at Apple/Google.

To fix CI, we'll need to mark several tests with // UNSUPPORTED: c++03 now. While we're at it, let's please fix the typo in the commit title s/Remvoe/Remove; ditto for the commit message (s/with and/with an).

libcxx/docs/ReleaseNotes.rst

147

There are a few typos here. How about this, instead?

std::function has been removed in C++03. If you are using it, please remove usages or upgrade to C++11 or later. It is possible to re-enable std::function in C++03 mode by defining _LIBCPP_ENABLE_CXX03_FUNCTION. This option will be removed in LLVM 16.

[ldionne]

In D127908#3587636, @jloser wrote:

I'm OK removing this extension with an opt-in knob depending on how bad the breakage is internally at Apple/Google.

Just to make sure everyone's on the same page, we use these large code bases as guinea pigs to gauge how much breakage is likely out there -- it's not that we try to cater to these two code bases more specifically. If other vendors have the capability to run builds on large scale code bases, it would be great as well. Internal ref for me: 95412837.

Adding libc++ vendors for awareness. @EricWF Would you be able to try this out on a large code base internally? I suspect that most people are not using this extension, but who knows.

libcxx/docs/ReleaseNotes.rst

147

I like this reformulation. In particular, let's make sure to use LLVM 16, not libc++16 (which is not an official thing).

libcxx/include/__functional/function.h

1245

[philnik]

• Address comments

libcxx/docs/ReleaseNotes.rst

147

You say a few typos. Did I miss any, or was there just removed without the d?

[philnik]

• Enable std::function in the tests

[jloser]

libcxx/docs/ReleaseNotes.rst

147

I think there's one left. I'd reword "This option it" to "This option" (i.e. drop the word "it") to make this sentence read clearer IMO.

[ldionne]

LGTM. I did not see any failure at all (which is quite unusual!), so I suspect this will not impact a lot of users.

[ldionne]

Please make sure you have green CI though.

libcxx/docs/ReleaseNotes.rst

- The ``_LIBCPP_DISABLE_EXTERN_TEMPLATE`` macro is not honored anymore when defined by
   against the static version of libc++, which will result in no dependency being
   taken against the shared library.
 
 - The ``_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_VOID_SPECIALIZATION`` macro has been added to allow
   re-enabling the ``allocator<void>`` specialization. When used in conjuction with
   ``_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS``, this ensures that the members of
   ``allocator<void>`` removed in C++20 can be accessed.
 
 - The experimental versions of ``boyer_moore_searcher`` and ``boyer_moore_horspool_searcher``
   will be removed in LLVM 17. You can disable the deprecation warnings by defining
   ``_LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_SEARCHERS``.
 
+- ``std::function`` has been removed in C++03. If you are using it, please remove usages
+  or upgrade to C++11 or later. It is possible to re-enable ``std::function`` in C++03 by defining
+  ``_LIBCPP_ENABLE_CXX03_FUNCTION``. This option it will be removed in LLVM 16.
+
 ABI Changes
 -----------
 
 - The ``_LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION`` macro controlling whether we use an
   emulation for ``std::nullptr_t`` in C++03 mode has been removed. After this change,
   ``_LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION`` will not be honoured anymore and there
   will be no way to opt back into the C++03 emulation of ``std::nullptr_t``.
 

libcxx/include/__functional/function.h

 operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
 
 template <class _Rp, class... _ArgTypes>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
 {return __x.swap(__y);}
 
-#else // _LIBCPP_CXX03_LANG
+#elif defined(_LIBCPP_ENABLE_CXX03_FUNCTION)
 
 namespace __function {
 
 template<class _Fp> class __base;
 
 template<class _Rp>
 class __base<_Rp()>
 {

 operator!=(nullptr_t, const function<_Fp>& __f) {return (bool)__f;}
 
 template <class _Fp>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(function<_Fp>& __x, function<_Fp>& __y)
 {return __x.swap(__y);}
 
-#endif
+#endif // _LIBCPP_CXX03_LANG
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___FUNCTIONAL_FUNCTION_H

libcxx/test/libcxx/utilities/function.objects/func.wrap/depr_in_cxx03.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.
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // Check that libc++'s emulation of std::function is deprecated in C++03
 
 // REQUIRES: c++03
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX03_FUNCTION
+
 #include <functional>
 #include "test_macros.h"
 
 int main(int, char**) {
     // Note:
     // We use sizeof() to require it to be a complete type. We don't create a
     // variable because otherwise we get two warnings for each variable (the
     // second warning is when the destructor is implicitly called).
     (void)sizeof(std::function<void ()>); // expected-warning {{'function<void ()>' is deprecated}}
     (void)sizeof(std::function<void (int)>); // expected-warning {{'function<void (int)>' is deprecated}}
     (void)sizeof(std::function<void (int, int)>); // expected-warning {{'function<void (int, int)>' is deprecated}}
     (void)sizeof(std::function<void (int, int, int)>); // expected-warning {{'function<void (int, int, int)>' is deprecated}}
     return 0;
 }

libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/move_reentrant.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // function& operator=(function &&);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/test/libcxx/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign_reentrant.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // function& operator=(nullptr_t);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct A
 {

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/addressof.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 // Make sure we can use std::function with a type that has a hostile overload
 // of operator&().
 
 #include <functional>
 #include <cassert>
 
 #include "operator_hijacker.h"

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.alg/swap.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // template <MoveConstructible  R, MoveConstructible ... ArgTypes>
 //   void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.cap/operator_bool.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // explicit operator bool() const
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int g(int) {return 0;}

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // function(F);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 class A

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_assign.pass.cpp

 // class function<R(ArgTypes...)>
 
 // template<class F>
 //   requires CopyConstructible<F> && Callable<F, ArgTypes..>
 //         && Convertible<Callable<F, ArgTypes...>::result_type
 //   operator=(F f);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 class A

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_incomplete.pass.cpp

 
 // class function<R(ArgTypes...)>
 
 // template<class F> function(F);
 
 // Allow incomplete argument types in the __is_callable check
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 struct X{
     typedef std::function<void(X&)> callback_type;

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/F_nullptr.pass.cpp

 // class function<R(ArgTypes...)>
 
 // function(Fp);
 
 // Ensure that __not_null works for all function types.
 // See https://llvm.org/PR23589
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 //------------------------------------------------------------------------------
 // TESTING std::function<...>::__not_null(Callable)
 //
 // Concerns:
 //  1) The call __not_null(Callable) is well formed and correct for each
 //     possible 'Callable' type category. These categories include:
 //      1a) function pointers

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp

 
 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&);
 //
 // This signature was removed in C++17
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     {
     std::function<int(int)> f(std::allocator_arg, bare_allocator<int>());
     assert(!f);
     }
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++03 || c++11 || c++14
 
 // class function<R(ArgTypes...)>
 
 // template<class F, class A> function(allocator_arg_t, const A&, F);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "count_new.h"

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 // REQUIRES: c++03 || c++11 || c++14
 
 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&, const function&);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 #include "test_allocator.h"
 #include "count_new.h"

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp

 
 // class function<R(ArgTypes...)>
 
 // template<class A> function(allocator_arg_t, const A&, nullptr_t);
 //
 // This signature was removed in C++17
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 int main(int, char**)
 {
     std::function<int(int)> f(std::allocator_arg, bare_allocator<int>(), nullptr);
     assert(!f);
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // function& operator=(const function& f);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 class A {

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp

 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // function(const function&  f);
 // function(function&& f); // noexcept in C++20
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <memory>
 #include <cstdlib>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/default.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // function();
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::function<int(int)> f;
     assert(!f);
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // function(nullptr_t);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::function<int(int)> f(nullptr);
     assert(!f);
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/nullptr_t_assign.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // function& operator=(nullptr_t);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "count_new.h"
 
 #include "test_macros.h"
 

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.inv/invoke.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // R operator()(ArgTypes... args) const
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 // Address Sanitizer doesn't instrument weak symbols on Linux. When a key
 // function is defined for bad_function_call's vtable, its typeinfo and vtable
 // will be defined as strong symbols in the library and weak symbols in other
 // translation units. Only the strong symbol will be instrumented, increasing
 // its size (due to the redzone) and leading to a serious ODR violation
 // resulting in a crash.
 // Some relevant bugs:

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // template<class F, class A> void assign(F&&, const A&);
 //     This call was removed post-C++14
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 
 class A

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/swap.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // void swap(function& other);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "count_new.h"
 
 #include "test_macros.h"
 

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.nullptr/operator_==.pass.cpp

 //
 // template <MoveConstructible R, MoveConstructible ... ArgTypes>
 //   bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
 //
 // template <MoveConstructible  R, MoveConstructible ... ArgTypes>
 //   bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <cassert>
 
 #include "test_macros.h"
 
 int g(int) {return 0;}
 

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target.pass.cpp

 //   T*
 //   target();
 // template<typename T>
 //   requires Callable<T, ArgTypes...> && Convertible<Callable<T, ArgTypes...>::result_type, R>
 //   const T*
 //   target() const;
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 // UNSUPPORTED: no-rtti
 
 #include <functional>
 #include <new>
 #include <cstdlib>
 #include <cassert>
 

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.targ/target_type.pass.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // class function<R(ArgTypes...)>
 
 // const std::type_info& target_type() const;
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 // UNSUPPORTED: no-rtti
 
 #include <functional>
 #include <typeinfo>
 #include <cassert>
 
 #include "test_macros.h"

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/types.pass.cpp

 //   typedef T1 first_argument_type;    // iff sizeof...(ArgTypes) == 2 and
 //                                      // ArgTypes contains T1 and T2
 //   typedef T2 second_argument_type;   // iff sizeof...(ArgTypes) == 2 and
 //                                      // ArgTypes contains T1 and T2
 //  ...
 //  };
 
 // This test runs in C++03, but we have deprecated using std::function in C++03.
-// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS -D_LIBCPP_ENABLE_CXX03_FUNCTION
 
 #include <functional>
 #include <type_traits>
 
 #include "test_macros.h"
 
 
 template <typename T>