[libc++] Add deprecated attributes to many deprecated components

[ldionne]

Summary

This is a first step in the right direction, but I wasn't able to get an
exhaustive list of all deprecated components per standard, so there's
certainly stuff that's missing.

rdar://problem/18168350

[EricWF]

We'll also want tests that very the deprecated diagnostics are emitted correctly. To test for the production of diagnostics, Libc++ uses *.fail.cpp tests along with Clang Verify.
I went ahead and implemented [depr.adaptors.cxx11.fail.cpp](https://gist.github.com/EricWF/6355d7d59718fb749c718d3f605cfa9b) which tests that no diagnostics are emitted in C++03, and the correct diagnostics are emitted in C++11 and beyond.

libcxx/include/__config

988 ↗

(On Diff #154040)

Why are we switching the attribute from its C++11 form?

I suspect this will break MSVC builds, or other compilers that don't provide GNU attributes.

993 ↗

(On Diff #154040)

So here's a quirk you'll need to learn.

_LIBCPP_STD_VER is never less than 11, even in C++03 mode, because libc++ attempts to provide a feature complete C++11 implementation regardless of the actual language dialect.

Therefore, this macro marks C++03 components as deprecated in C++03 :-(

The macro you want to use to detect pre-C++11 is defined(_LIBCPP_CXX03_LANG).

libcxx/include/__functional_base

27 ↗

(On Diff #154040)

No TODOs in headers please, unless the intent is to remove them before the end of the review.
Instead, you should file a bug regarding the work to be done.

I know I've been guilty of this, but it's never too late to change.

libcxx/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp

26 ↗

(On Diff #154040)

How do these tests work with compilers other than Clang?

Perhaps you can add a disable_deprecated_declarations.h header, and include that instead? That way the one header can be made to handle most compilers.

[mclow.lists]

Like the "don't discard return values" patch that is currently under review (D45179), this needs to be opt-in - otherwise people will complain (loudly).
I am in favor of doing this - just not by default.

[mclow.lists]

So if someone defines (say) _LIBCXX_DEPRECATION_WARNINGS in their build flags, they get the warnings. Otherwise, not.

[ldionne]

libcxx/include/__config

988 ↗

(On Diff #154040)

This macro was not being used anywhere, and for some reason I got compilation errors when using the C++11 form. I've now tracked it down to the [[deprecated]] attribute appearing _before_ the visibility attribute. Indeed, the following won't work (live example):

template<class _Tp>
class [[deprecated]] __attribute__((__type_visibility__("default"))) auto_ptr { };

But the following does (live example):

template<class _Tp>
class __attribute__((__type_visibility__("default"))) [[deprecated]] auto_ptr { };

I'll go back to the C++11 form and put the deprecated attributes in the right spot.

Also, do we have testers on MSVC? Where can I see those? More generally, do we have something like a Travis/Appveyor CI setup I could take a look at? This would be invaluable.

993 ↗

(On Diff #154040)

Thanks. That's weird. I would have assumed that it just matched the -std=c++xx specified on the command line, i.e. the language enforced by the compiler.

libcxx/include/__functional_base

27 ↗

(On Diff #154040)

I saw your TODOs and so I decided to add mine ;-). Filed https://bugs.llvm.org/show_bug.cgi?id=38054 instead.

libcxx/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp

26 ↗

(On Diff #154040)

They must always break because we compile with -Wall -Werror. I thought the tests were only supposed to work with Clang -- I copied this pattern from another test (test/libcxx/containers/gnu_cxx/hash_map.pass.cpp).

Per Marshall's comment, those diagnostics will be disabled by default, so I won't need this header (or this pragma) anymore. I'll see if it makes sense to add the header for the other tests that depend on this pragma, and if so, I'll add it in another Phab review.

[ldionne]

Addressed reviewer feedback.

• Addressed Eric's inline comments.
• Added Clang-Verify tests per Eric's comment.
• Made the warnings opt-in per Marshall's request.

[lebedev.ri]

In D48912#1151731, @mclow.lists wrote:

Like the "don't discard return values" patch that is currently under review (D45179), this needs to be opt-in - otherwise people will complain (loudly).
I am in favor of doing this - just not by default.

In D48912#1151733, @mclow.lists wrote:

So if someone defines (say) _LIBCXX_DEPRECATION_WARNINGS in their build flags, they get the warnings. Otherwise, not.

I'm not sure this is a good/correct example.
libcxx does warn by default about nodiscard, it's not opt-in.
What D45179 does, is allows users to opt-in into nodiscard warnings with *earlier* -std=c++xy versions.

[ldionne]

FWIW, I would prefer to enable deprecation warnings by default and to have a way of turning them off -- so as to be as close to the standard as possible by default. But I'm fine either way, and this is always a choice we can revisit later by just switching the default from opt-in to opt-out.

[EricWF]

libcxx/include/__config

988 ↗

(On Diff #154120)

We should be able to assume that we have the C++11 form of [[deprecated]] without checking __has_attribute(deprecated), which only works for Clang, and is really checking for __attribute__((deprecated)) IIRC.

Also, another possibility, which is in opposition to @mclow.lists, and this would be my suggestion, is to enable it by default, and then allow users to opt out simply by defining -D_LIBCPP_DEPRECATED.

#ifndef _LIBCPP_DEPRECATED
# define _LIBCPP_DEPRECATED [[deprecated]]
#endif

But we have to agree to enable them by default first.

988 ↗

(On Diff #154040)

Yeah, C++11 attributes are a lot less tolerant about where they can appear, and so they can be a pain to apply initially.

The builders we currently have are listed here: http://libcxx.llvm.org/docs/#build-bots-and-test-coverage
The Appveyor bots are not currently passing, but the idea is to at least keep them from regressing.

libcxx/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp

26 ↗

(On Diff #154040)

The tests are actually expected to work with GCC, Clang, and MSVC (to varying degrees).

The MSVC team actually uses our test suite to test their STL, and so all tests under test/std should be written with that in mind.
However, tests under test/libcxx, as these are, only need to work against libc++ (but with both GCC and Clang except where it's not possible).

After investigating hash_map.pass.cpp it seems to be by accident that the test doesn't fail under GCC. GCC doesn't promote #warning to an error even when -Werror is specified. Additionally -W#warnings is a Clang specific flag. GCC's version is -Wcpp.

However, these tests use [[deprecated]] not #warning to produce the diagnostic, and so must be made to work with GCC.

[aaron.ballman]

In D48912#1152573, @ldionne wrote:

FWIW, I would prefer to enable deprecation warnings by default and to have a way of turning them off

I have a strong preference for this as well.

• These diagnostics are guaranteed to be true positive by definition, and some of them are even high-value beyond just "by the way, this may be removed" (like std::gets() or std::random_shuffle() for security purposes).
• Users are not likely to change their build systems to enable diagnostics they believe to already be enabled because they're enabled elsewhere. They may not even /know/ to change their build system because it's hard to notice silent behavior.
• WG21 has frequently talked about their reliance on tools to tell users about deprecations as early as possible so that they can prepare their code bases for the eventual removal. A default behavior of silencing the deprecation warnings runs contrary to that reliance and makes it harder for users to prepare their code base for those removals.

I think that silencing deprecation warnings by default does users a disservice.

[ldionne]

Regarding whether we want to enable or disable those warnings by default: it seems like we've reached consensus (on the LLVM IRC) for enabling the deprecation warnings by default. However, I suggest we keep them disabled by default in this commit, and then change the default in a subsequent change. This will make things easier from an integration perspective, and also in case we need to roll back the defaults because of some unforeseen circumstances.

libcxx/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.cpp

26 ↗

(On Diff #154040)

GCC does not accept [[deprecated]] when mixed with another __attribute__ specifier, which is problematic because most types/functions already have such attributes applied to them for visibility purposes. However, note that applying multiple __attribute__ specifiers seems to work. I'm not sure what to do here -- it seems like the easiest way forward would be to detect when we support __attribute__((deprecated)) on both Clang and GCC, and use that when available. Does that sound like an acceptable way forward?

[aaron.ballman]

In D48912#1156191, @ldionne wrote:

Regarding whether we want to enable or disable those warnings by default: it seems like we've reached consensus (on the LLVM IRC) for enabling the deprecation warnings by default. However, I suggest we keep them disabled by default in this commit, and then change the default in a subsequent change. This will make things easier from an integration perspective, and also in case we need to roll back the defaults because of some unforeseen circumstances.

This approach sounds fine to me.

[ldionne]

Made sure the attributes worked properly on GCC.

This still requires using attribute((deprecated)) whenever that's
available, both because [[deprecated]] was added only in C++14 (so won't
work for C++11 deprecations), and because of placement issue with GCC.

[ldionne]

Ping

[jfb]

In general this lgtm. First comment I think you need to fix, others can go together in a follow-up I think.

libcxx/docs/UsingLibcxx.rst

212 ↗

(On Diff #155478)

I thought you'd agreed on IRC to have it defined by default (i.e. enable deprecation warnings by default)?

On-by-default sounds right to me, since that's what the Standard is effectively asking for. I agree we'll make some developers sad, but they'll be even more sad when deprecated features get removed entirely.

libcxx/include/__config

1006 ↗

(On Diff #155478)

I assume all of the above will work with deleted things because they'll be behind a macro that #if 0's them when deleted (and then a user can turn the deleted feature back on with another macro?). Or do we just delete things outright?

libcxx/include/memory

2059 ↗

(On Diff #155478)

So here's an example where, if you define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR you can come back and get auto_ptr and then you get the deprecated warning. Should we have another macro that says (for this one) "deprecated in 11, removed in 17 but you asked to get it back, srlys why?"

[ldionne]

I still think this is good to go as-is, given my answer to JF's comments.

libcxx/docs/UsingLibcxx.rst

212 ↗

(On Diff #155478)

The plan was to do this in a follow-up patch. This patch is adding the attributes but not changing behavior, and the followup would only change the default behavior. This is because enabling this by default will require more changes (and thus a larger diff), since some tests will need fixing up, etc.

libcxx/include/__config

1006 ↗

(On Diff #155478)

By deleted, you mean removed from the standard? If so, then yes, those attributes are applied to a type/function directly. When a type/function is not declared/defined because it's been removed from the standard, the whole thing is behind a #if 0.

libcxx/include/memory

2059 ↗

(On Diff #155478)

Ah, I see what you might have meant above. In the current state of things, you'll get the deprecated warning even if you define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR. I think that's the correct thing to do. If you want to get rid of the warnings, just define _LIBCPP_DISABLE_DEPRECATION_WARNINGS (in the future, after the default has been changed). We could do otherwise, but I don't see a strong case for it, and it will complicate things quite a bit because each macro like _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR will need its own deprecation macro.

[ldionne]

Are we waiting for anything to ship this?

[EricWF]

I don't think so. Go nuts!

docs/UsingLibcxx.rst

**_LIBCPP_ENABLE_NODISCARD**:
   See :ref:`Extended Applications of [[nodiscard]] <nodiscard extension>` for
   more information.
 
 **_LIBCPP_DISABLE_NODISCARD_EXT**:
   This macro prevents the library from applying ``[[nodiscard]]`` to entities
   purely as an extension. See :ref:`Extended Applications of [[nodiscard]] <nodiscard extension>`
   for more information.
 
+**_LIBCPP_ENABLE_DEPRECATION_WARNINGS**:
+  This macro enables warnings when using deprecated components. For example,
+  when compiling in C++11 mode, using `std::auto_ptr` with the macro defined
+  will trigger a warning saying that `std::auto_ptr` is deprecated. By default,
+  this macro is not defined.
 
 C++17 Specific Configuration Macros
 -----------------------------------
 **_LIBCPP_ENABLE_CXX17_REMOVED_FEATURES**:
   This macro is used to re-enable all the features removed in C++17. The effect
   is equivalent to manually defining each macro listed below.
 
 **_LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS**:

include/__config

 #if defined(__APPLE__) || defined(__FreeBSD__)
 #define _LIBCPP_HAS_DEFAULTRUNELOCALE
 #endif
 
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)
 #define _LIBCPP_WCTYPE_IS_MASK
 #endif
 
-#if _LIBCPP_STD_VER > 11
-#  define _LIBCPP_DEPRECATED [[deprecated]]
-#else
-#  define _LIBCPP_DEPRECATED
-#endif
+// Deprecation macros.
+// Deprecations warnings are only enabled when _LIBCPP_ENABLE_DEPRECATION_WARNINGS is defined.
+#if defined(_LIBCPP_ENABLE_DEPRECATION_WARNINGS)
+#  if __has_attribute(deprecated)
+#    define _LIBCPP_DEPRECATED __attribute__ ((deprecated))
+#  elif _LIBCPP_STD_VER > 11
+#    define _LIBCPP_DEPRECATED [[deprecated]]
+#  else
+#    define _LIBCPP_DEPRECATED
+#  endif
+#else
+#  define _LIBCPP_DEPRECATED
+#endif
+
+#if !defined(_LIBCPP_CXX03_LANG)
+#  define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED
+#else
+#  define _LIBCPP_DEPRECATED_IN_CXX11
+#endif
+
+#if _LIBCPP_STD_VER >= 14
+#  define _LIBCPP_DEPRECATED_IN_CXX14 _LIBCPP_DEPRECATED
+#else
+#  define _LIBCPP_DEPRECATED_IN_CXX14
+#endif
+
+#if _LIBCPP_STD_VER >= 17
+#  define _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_DEPRECATED
+#else
+#  define _LIBCPP_DEPRECATED_IN_CXX17
+#endif
 
 #if _LIBCPP_STD_VER <= 11
 #  define _LIBCPP_EXPLICIT_AFTER_CXX11
-#  define _LIBCPP_DEPRECATED_AFTER_CXX11
 #else
 #  define _LIBCPP_EXPLICIT_AFTER_CXX11 explicit
-#  define _LIBCPP_DEPRECATED_AFTER_CXX11 [[deprecated]]
 #endif
 
 #if _LIBCPP_STD_VER > 11 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
 #  define _LIBCPP_CONSTEXPR_AFTER_CXX11 constexpr
 #else
 #  define _LIBCPP_CONSTEXPR_AFTER_CXX11
 #endif
 

include/__functional_base

 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp = void>
 #else
 template <class _Tp>
 #endif
 struct _LIBCPP_TEMPLATE_VIS less : binary_function<_Tp, _Tp, bool>
 {
-    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const _Tp& __x, const _Tp& __y) const
         {return __x < __y;}
 };
 
 #if _LIBCPP_STD_VER > 11
 template <>
 struct _LIBCPP_TEMPLATE_VIS less<void>
 {
-    template <class _T1, class _T2> 
+    template <class _T1, class _T2>
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     auto operator()(_T1&& __t, _T2&& __u) const
     _NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u)))
     -> decltype        (_VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u))
         { return        _VSTD::forward<_T1>(__t) < _VSTD::forward<_T2>(__u); }
     typedef void is_transparent;
 };
 #endif

 template <class _Tp> void cref(const _Tp&&) = delete;
 #endif
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp, class, class = void>
 struct __is_transparent : false_type {};
 
 template <class _Tp, class _Up>
-struct __is_transparent<_Tp, _Up,  
+struct __is_transparent<_Tp, _Up,
                         typename __void_t<typename _Tp::is_transparent>::type>
    : true_type {};
 #endif
 
 // allocator_arg_t
 
 struct _LIBCPP_TEMPLATE_VIS allocator_arg_t { };
 

include/algorithm

public:
     static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
 
     friend _LIBCPP_FUNC_VIS __rs_default __rs_get();
 };
 
 _LIBCPP_FUNC_VIS __rs_default __rs_get();
 
 template <class _RandomAccessIterator>
-void
+_LIBCPP_DEPRECATED_IN_CXX14 void
 random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
     typedef uniform_int_distribution<ptrdiff_t> _Dp;
     typedef typename _Dp::param_type _Pp;
     difference_type __d = __last - __first;
     if (__d > 1)
     {
         _Dp __uid;
         __rs_default __g = __rs_get();
         for (--__last, --__d; __first < __last; ++__first, --__d)
         {
             difference_type __i = __uid(__g, _Pp(0, __d));
             if (__i != difference_type(0))
                 swap(*__first, *(__first + __i));
         }
     }
 }
 
 template <class _RandomAccessIterator, class _RandomNumberGenerator>
-void
+_LIBCPP_DEPRECATED_IN_CXX14 void
 random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
 #ifndef _LIBCPP_CXX03_LANG
                _RandomNumberGenerator&& __rand)
 #else
                _RandomNumberGenerator& __rand)
 #endif
 {
     typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;

include/functional

 
 template <class T=void> // C++14
 struct bit_xor : unary_function<T, bool>
 {
     bool operator()(const T& x) const;
 };
 
 template <class Predicate>
-class unary_negate
+class unary_negate // deprecated in C++17
     : public unary_function<typename Predicate::argument_type, bool>
 {
 public:
     explicit unary_negate(const Predicate& pred);
     bool operator()(const typename Predicate::argument_type& x) const;
 };
 
-template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred);
+template <class Predicate> // deprecated in C++17
+unary_negate<Predicate> not1(const Predicate& pred);
 
 template <class Predicate>
-class binary_negate
+class binary_negate // deprecated in C++17
     : public binary_function<typename Predicate::first_argument_type,
                              typename Predicate::second_argument_type,
                              bool>
 {
 public:
     explicit binary_negate(const Predicate& pred);
     bool operator()(const typename Predicate::first_argument_type& x,
                     const typename Predicate::second_argument_type& y) const;
 };
 
-template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred);
+template <class Predicate> // deprecated in C++17
+binary_negate<Predicate> not2(const Predicate& pred);
 
 template <class F> unspecified not_fn(F&& f); // C++17
 
 template<class T> struct is_bind_expression;
 template<class T> struct is_placeholder;
 
     // See C++14 20.9.9, Function object binders
 template <class T> inline constexpr bool is_bind_expression_v
struct _LIBCPP_TEMPLATE_VIS bit_not<void>
     _NOEXCEPT_(noexcept(~_VSTD::forward<_Tp>(__x)))
     -> decltype        (~_VSTD::forward<_Tp>(__x))
         { return        ~_VSTD::forward<_Tp>(__x); }
     typedef void is_transparent;
 };
 #endif
 
 template <class _Predicate>
-class _LIBCPP_TEMPLATE_VIS unary_negate
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 unary_negate
     : public unary_function<typename _Predicate::argument_type, bool>
 {
     _Predicate __pred_;
 public:
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     explicit unary_negate(const _Predicate& __pred)
         : __pred_(__pred) {}
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const typename _Predicate::argument_type& __x) const
         {return !__pred_(__x);}
 };
 
 template <class _Predicate>
-inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 unary_negate<_Predicate>
 not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
 
 template <class _Predicate>
-class _LIBCPP_TEMPLATE_VIS binary_negate
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 binary_negate
     : public binary_function<typename _Predicate::first_argument_type,
                              typename _Predicate::second_argument_type,
                              bool>
 {
     _Predicate __pred_;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11
     binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
 
     _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
     bool operator()(const typename _Predicate::first_argument_type& __x,
                     const typename _Predicate::second_argument_type& __y) const
         {return !__pred_(__x, __y);}
 };
 
 template <class _Predicate>
-inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX17 inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
 binary_negate<_Predicate>
 not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
 template <class __Operation>
-class _LIBCPP_TEMPLATE_VIS binder1st
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder1st
     : public unary_function<typename __Operation::second_argument_type,
                             typename __Operation::result_type>
 {
 protected:
     __Operation                               op;
     typename __Operation::first_argument_type value;
 public:
     _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
                                const typename __Operation::first_argument_type __y)
         : op(__x), value(__y) {}
     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
         (typename __Operation::second_argument_type& __x) const
             {return op(value, __x);}
     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
         (const typename __Operation::second_argument_type& __x) const
             {return op(value, __x);}
 };
 
 template <class __Operation, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 binder1st<__Operation>
 bind1st(const __Operation& __op, const _Tp& __x)
     {return binder1st<__Operation>(__op, __x);}
 
 template <class __Operation>
-class _LIBCPP_TEMPLATE_VIS binder2nd
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 binder2nd
     : public unary_function<typename __Operation::first_argument_type,
                             typename __Operation::result_type>
 {
 protected:
     __Operation                                op;
     typename __Operation::second_argument_type value;
 public:
     _LIBCPP_INLINE_VISIBILITY
     binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
         : op(__x), value(__y) {}
     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
         (      typename __Operation::first_argument_type& __x) const
             {return op(__x, value);}
     _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
         (const typename __Operation::first_argument_type& __x) const
             {return op(__x, value);}
 };
 
 template <class __Operation, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 binder2nd<__Operation>
 bind2nd(const __Operation& __op, const _Tp& __x)
     {return binder2nd<__Operation>(__op, __x);}
 
 template <class _Arg, class _Result>
-class _LIBCPP_TEMPLATE_VIS pointer_to_unary_function
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_unary_function
     : public unary_function<_Arg, _Result>
 {
     _Result (*__f_)(_Arg);
 public:
     _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
         : __f_(__f) {}
     _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
         {return __f_(__x);}
 };
 
 template <class _Arg, class _Result>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 pointer_to_unary_function<_Arg,_Result>
 ptr_fun(_Result (*__f)(_Arg))
     {return pointer_to_unary_function<_Arg,_Result>(__f);}
 
 template <class _Arg1, class _Arg2, class _Result>
-class _LIBCPP_TEMPLATE_VIS pointer_to_binary_function
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 pointer_to_binary_function
     : public binary_function<_Arg1, _Arg2, _Result>
 {
     _Result (*__f_)(_Arg1, _Arg2);
 public:
     _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
         : __f_(__f) {}
     _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
         {return __f_(__x, __y);}
 };
 
 template <class _Arg1, class _Arg2, class _Result>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 pointer_to_binary_function<_Arg1,_Arg2,_Result>
 ptr_fun(_Result (*__f)(_Arg1,_Arg2))
     {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
 
 template<class _Sp, class _Tp>
-class _LIBCPP_TEMPLATE_VIS mem_fun_t : public unary_function<_Tp*, _Sp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_t
+    : public unary_function<_Tp*, _Sp>
 {
     _Sp (_Tp::*__p_)();
 public:
     _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
         {return (__p->*__p_)();}
 };
 
 template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TEMPLATE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_t
+    : public binary_function<_Tp*, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:
     _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
         {return (__p->*__p_)(__x);}
 };
 
 template<class _Sp, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 mem_fun_t<_Sp,_Tp>
 mem_fun(_Sp (_Tp::*__f)())
     {return mem_fun_t<_Sp,_Tp>(__f);}
 
 template<class _Sp, class _Tp, class _Ap>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 mem_fun1_t<_Sp,_Tp,_Ap>
 mem_fun(_Sp (_Tp::*__f)(_Ap))
     {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template<class _Sp, class _Tp>
-class _LIBCPP_TEMPLATE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun_ref_t
+    : public unary_function<_Tp, _Sp>
 {
     _Sp (_Tp::*__p_)();
 public:
     _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
         {return (__p.*__p_)();}
 };
 
 template<class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TEMPLATE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 mem_fun1_ref_t
+    : public binary_function<_Tp, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap);
 public:
     _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
         {return (__p.*__p_)(__x);}
 };
 
 template<class _Sp, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 mem_fun_ref_t<_Sp,_Tp>
 mem_fun_ref(_Sp (_Tp::*__f)())
     {return mem_fun_ref_t<_Sp,_Tp>(__f);}
 
 template<class _Sp, class _Tp, class _Ap>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 mem_fun1_ref_t<_Sp,_Tp,_Ap>
 mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
     {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_TEMPLATE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_t
+    : public unary_function<const _Tp*, _Sp>
 {
     _Sp (_Tp::*__p_)() const;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
         {return (__p->*__p_)();}
 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TEMPLATE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_t
+    : public binary_function<const _Tp*, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap) const;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
         {return (__p->*__p_)(__x);}
 };
 
 template <class _Sp, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 const_mem_fun_t<_Sp,_Tp>
 mem_fun(_Sp (_Tp::*__f)() const)
     {return const_mem_fun_t<_Sp,_Tp>(__f);}
 
 template <class _Sp, class _Tp, class _Ap>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 const_mem_fun1_t<_Sp,_Tp,_Ap>
 mem_fun(_Sp (_Tp::*__f)(_Ap) const)
     {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
 
 template <class _Sp, class _Tp>
-class _LIBCPP_TEMPLATE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun_ref_t
+    : public unary_function<_Tp, _Sp>
 {
     _Sp (_Tp::*__p_)() const;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
         {return (__p.*__p_)();}
 };
 
 template <class _Sp, class _Tp, class _Ap>
-class _LIBCPP_TEMPLATE_VIS const_mem_fun1_ref_t
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 const_mem_fun1_ref_t
     : public binary_function<_Tp, _Ap, _Sp>
 {
     _Sp (_Tp::*__p_)(_Ap) const;
 public:
     _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
         : __p_(__p) {}
     _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
         {return (__p.*__p_)(__x);}
 };
 
 template <class _Sp, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 const_mem_fun_ref_t<_Sp,_Tp>
 mem_fun_ref(_Sp (_Tp::*__f)() const)
     {return const_mem_fun_ref_t<_Sp,_Tp>(__f);}
 
 template <class _Sp, class _Tp, class _Ap>
-inline _LIBCPP_INLINE_VISIBILITY
+_LIBCPP_DEPRECATED_IN_CXX11 inline _LIBCPP_INLINE_VISIBILITY
 const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
 mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
     {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 //                                MEMFUN
 //==============================================================================

include/memory

  ForwardIterator uninitialized_value_construct_n(ForwardIterator first, Size n);
 
 template <class ForwardIterator>
  void uninitialized_default_construct(ForwardIterator first, ForwardIterator last);
 
 template <class ForwardIterator, class Size>
  ForwardIterator uninitialized_default_construct_n(ForwardIterator first, Size n);
 
-template <class Y> struct auto_ptr_ref {};      // removed in C++17
+template <class Y> struct auto_ptr_ref {};      // deprecated in C++11, removed in C++17
 
 template<class X>
-class auto_ptr                                  // removed in C++17
+class auto_ptr                                  // deprecated in C++11, removed in C++17
 {
 public:
     typedef X element_type;
 
     explicit auto_ptr(X* p =0) throw();
     auto_ptr(auto_ptr&) throw();
     template<class Y> auto_ptr(auto_ptr<Y>&) throw();
     auto_ptr& operator=(auto_ptr&) throw();
public:
     typedef true_type propagate_on_container_move_assignment;
     typedef true_type is_always_equal;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator() _NOEXCEPT {}
 
-    template <class _Up> 
+    template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator(const allocator<_Up>&) _NOEXCEPT {}
 
     _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY 
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
         {
         if (__n > max_size())
             __throw_length_error("allocator<T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
         return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), __alignof(_Tp)));
         }
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
public:
     typedef true_type is_always_equal;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator() _NOEXCEPT {}
 
     template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17 
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator(const allocator<_Up>&) _NOEXCEPT {}
 
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
     {
         if (__n > max_size())
             __throw_length_error("allocator<const T>::allocate(size_t n)"

 inline _LIBCPP_INLINE_VISIBILITY
 void return_temporary_buffer(_Tp* __p) _NOEXCEPT
 {
   _VSTD::__libcpp_deallocate((void*)__p, __alignof(_Tp));
 }
 
 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
 template <class _Tp>
-struct auto_ptr_ref
+struct _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr_ref
 {
     _Tp* __ptr_;
 };
 
 template<class _Tp>
-class _LIBCPP_TEMPLATE_VIS auto_ptr
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr
 {
 private:
     _Tp* __ptr_;
 public:
     typedef _Tp element_type;
 
     _LIBCPP_INLINE_VISIBILITY explicit auto_ptr(_Tp* __p = 0) throw() : __ptr_(__p) {}
     _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr& __p) throw() : __ptr_(__p.release()) {}
public:
     _LIBCPP_INLINE_VISIBILITY auto_ptr(auto_ptr_ref<_Tp> __p) throw() : __ptr_(__p.__ptr_) {}
     template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr_ref<_Up>() throw()
         {auto_ptr_ref<_Up> __t; __t.__ptr_ = release(); return __t;}
     template<class _Up> _LIBCPP_INLINE_VISIBILITY operator auto_ptr<_Up>() throw()
         {return auto_ptr<_Up>(release());}
 };
 
 template <>
-class _LIBCPP_TEMPLATE_VIS auto_ptr<void>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX11 auto_ptr<void>
 {
 public:
     typedef void element_type;
 };
 #endif
 
 template <class _Tp, int _Idx,
           bool _CanBeEmptyBase =

test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.cxx1z.pass.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.
 //
 //===----------------------------------------------------------------------===//
 
-// <memory>
+// <algorithm>
 
 // template <class RandomAccessIterator>
 //     void
 //     random_shuffle(RandomAccessIterator first, RandomAccessIterator last);
 //
 // template <class RandomAccessIterator, class RandomNumberGenerator>
 //     void
 //     random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
 //                    RandomNumberGenerator& rand);
 
 //
 //  In C++17, random_shuffle has been removed.
 //  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 //  is defined before including <algorithm>, then random_shuffle will be restored.
 
+// REQUIRES: verify-support
+
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 #define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 
 #include <algorithm>
 #include <vector>
 
 struct gen
 {

test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// template <class RandomAccessIterator>
+//     void
+//     random_shuffle(RandomAccessIterator first, RandomAccessIterator last);
+//
+// template <class RandomAccessIterator, class RandomNumberGenerator>
+//     void
+//     random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
+//                    RandomNumberGenerator& rand);
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
+
+#include <algorithm>
+#include <cstddef>
+
+#include "test_macros.h"
+
+struct gen
+{
+    std::ptrdiff_t operator()(std::ptrdiff_t n)
+    {
+        return n-1;
+    }
+};
+
+
+int main()
+{
+#if TEST_STD_VER < 14
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'random_shuffle<int *>' is deprecated}}
+    // expected-error@* 1 {{'random_shuffle<int *, gen &>' is deprecated}}
+#endif
+    int v[1] = {1};
+    std::random_shuffle(&v[0], &v[1]);
+    gen r;
+    std::random_shuffle(&v[0], &v[1], r);
+}

test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.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.
+//
+//===----------------------------------------------------------------------===//
+
+// <memory>
+//
+// template <class X>
+// class auto_ptr;
+//
+// class auto_ptr<void>;
+//
+// template <class X>
+// class auto_ptr_ref;
+//
+// Deprecated in C++11
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
+
+#include <memory>
+#include "test_macros.h"
+
+int main()
+{
+#if TEST_STD_VER < 11
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'auto_ptr<int>' is deprecated}}
+    // expected-error@* 1 {{'auto_ptr<void>' is deprecated}}
+    // expected-error@* 1 {{'auto_ptr_ref<int>' is deprecated}}
+#endif
+    typedef std::auto_ptr<int> AP;
+    typedef std::auto_ptr<void> APV;
+    typedef std::auto_ptr_ref<int> APR;
+}

test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.fail.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>
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+
+#include <functional>
+#include <cassert>
+#include "test_macros.h"
+
+int identity(int v) { return v; }
+int sum(int a, int b) { return a + b; }
+
+struct Foo {
+    int const_zero() const { return 0; }
+    int const_identity(int v) const { return v; }
+    int zero() { return 0; }
+    int identity(int v) { return v; }
+};
+
+int main()
+{
+#if TEST_STD_VER < 11
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'pointer_to_unary_function<int, int>' is deprecated}}
+    // expected-error@* 1 {{'pointer_to_binary_function<int, int, int>' is deprecated}}
+    // expected-error@* 1 {{'ptr_fun<int, int>' is deprecated}}
+    // expected-error@* 1 {{'ptr_fun<int, int, int>' is deprecated}}
+
+    // expected-error@* 1 {{'mem_fun_t<int, Foo>' is deprecated}}
+    // expected-error@* 1 {{'mem_fun1_t<int, Foo, int>' is deprecated}}
+    // expected-error@* 1 {{'const_mem_fun_t<int, Foo>' is deprecated}}
+    // expected-error@* 1 {{'const_mem_fun1_t<int, Foo, int>' is deprecated}}
+    // expected-error@* 2 {{'mem_fun<int, Foo>' is deprecated}}
+    // expected-error@* 2 {{'mem_fun<int, Foo, int>' is deprecated}}
+
+    // expected-error@* 1 {{'mem_fun_ref_t<int, Foo>' is deprecated}}
+    // expected-error@* 1 {{'mem_fun1_ref_t<int, Foo, int>' is deprecated}}
+    // expected-error@* 1 {{'const_mem_fun_ref_t<int, Foo>' is deprecated}}
+    // expected-error@* 1 {{'const_mem_fun1_ref_t<int, Foo, int>' is deprecated}}
+    // expected-error@* 2 {{'mem_fun_ref<int, Foo>' is deprecated}}
+    // expected-error@* 2 {{'mem_fun_ref<int, Foo, int>' is deprecated}}
+#endif
+    typedef std::pointer_to_unary_function<int, int> PUF;
+    typedef std::pointer_to_binary_function<int, int, int> PBF;
+    std::ptr_fun<int, int>(identity);
+    std::ptr_fun<int, int, int>(sum);
+
+    typedef std::mem_fun_t<int, Foo> MFT0;
+    typedef std::mem_fun1_t<int, Foo, int> MFT1;
+    typedef std::const_mem_fun_t<int, Foo> CMFT0;
+    typedef std::const_mem_fun1_t<int, Foo, int> CMFT1;
+    std::mem_fun<int, Foo>(&Foo::zero);
+    std::mem_fun<int, Foo, int>(&Foo::identity);
+    std::mem_fun<int, Foo>(&Foo::const_zero);
+    std::mem_fun<int, Foo, int>(&Foo::const_identity);
+
+    typedef std::mem_fun_ref_t<int, Foo> MFR0;
+    typedef std::mem_fun1_ref_t<int, Foo, int> MFR1;
+    typedef std::const_mem_fun_ref_t<int, Foo> CMFR0;
+    typedef std::const_mem_fun1_ref_t<int, Foo, int> CMFR1;
+    std::mem_fun_ref<int, Foo>(&Foo::zero);
+    std::mem_fun_ref<int, Foo, int>(&Foo::identity);
+    std::mem_fun_ref<int, Foo>(&Foo::const_zero);
+    std::mem_fun_ref<int, Foo, int>(&Foo::const_identity);
+}

test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.fail.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>
+//
+// bind1st
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+
+#include <functional>
+
+#include "../test_func.h"
+#include "test_macros.h"
+
+int main()
+{
+#if TEST_STD_VER < 11
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'bind1st<test_func, int>' is deprecated}}
+#endif
+    std::bind1st(test_func(1), 5);
+}

test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.fail.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>
+//
+// bind2nd
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+
+#include <functional>
+
+#include "../test_func.h"
+#include "test_macros.h"
+
+int main()
+{
+#if TEST_STD_VER < 11
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'bind2nd<test_func, int>' is deprecated}}
+#endif
+    std::bind2nd(test_func(1), 5);
+}

test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.fail.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>
+//
+// binder1st
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+
+#include <functional>
+
+#include "../test_func.h"
+#include "test_macros.h"
+
+int main()
+{
+#if TEST_STD_VER < 11
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'binder1st<test_func>' is deprecated}}
+#endif
+    typedef std::binder1st<test_func> B1ST;
+}

test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.fail.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>
+//
+// binder2nd
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+
+#include <functional>
+
+#include "../test_func.h"
+#include "test_macros.h"
+
+int main()
+{
+#if TEST_STD_VER < 11
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'binder2nd<test_func>' is deprecated}}
+#endif
+    typedef std::binder2nd<test_func> B2ND;
+}

test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.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>
+
+// binary_negate
+//  deprecated in C++17
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct Predicate {
+    typedef int first_argument_type;
+    typedef int second_argument_type;
+    bool operator()(first_argument_type, second_argument_type) const { return true; }
+};
+
+int main() {
+#if TEST_STD_VER < 17
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'binary_negate<Predicate>' is deprecated}}
+#endif
+    std::binary_negate<Predicate> f((Predicate()));
+    (void)f;
+}

test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.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>
+
+// not1
+//  deprecated in C++17
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct Predicate {
+    typedef int argument_type;
+    bool operator()(argument_type) const { return true; }
+};
+
+int main() {
+#if TEST_STD_VER < 17
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'not1<Predicate>' is deprecated}}
+#endif
+    std::not1(Predicate());
+}

test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.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>
+
+// not2
+//  deprecated in C++17
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct Predicate {
+    typedef int first_argument_type;
+    typedef int second_argument_type;
+    bool operator()(first_argument_type, second_argument_type) const { return true; }
+};
+
+int main() {
+#if TEST_STD_VER < 17
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'not2<Predicate>' is deprecated}}
+#endif
+    std::not2(Predicate());
+}

test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.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>
+
+// unary_negate
+//  deprecated in C++17
+
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_DEPRECATION_WARNINGS
+
+#include <functional>
+
+#include "test_macros.h"
+
+struct Predicate {
+    typedef int argument_type;
+    bool operator()(argument_type) const { return true; }
+};
+
+int main() {
+#if TEST_STD_VER < 17
+    // expected-no-diagnostics
+#else
+    // expected-error@* 1 {{'unary_negate<Predicate>' is deprecated}}
+#endif
+    std::unary_negate<Predicate> f((Predicate()));
+    (void)f;
+}