[libc++] Enable deprecation warnings by default

[ldionne]

Summary

In r342843, I added deprecation warnings to some facilities that were
deprectated in C++14 and C++17. However, those deprecation warnings
were not enabled by default.

After discussing this on IRC, we had finally gotten consensus to enable
those warnings by default, and I'm getting around to doing that only
now.

[ldionne]

I'd like to enable this early in the LLVM 9 cycle.

[ldionne]

Added missing #defines in tests

[aaron.ballman]

This seems sensible to me, but I leave it to the libc++ maintainers to sign off on the review. Thank you for working on this!

[ldionne]

Ping.

[ldionne]

Last ping. We discussed this on the IRC months ago and other maintainers were fine with it. I'll commit this at the end of the week unless somebody changed their mind.

[mclow.lists]

Go for it. I'm curious to see how it works out :-)

libcxx/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.
+**_LIBCPP_DISABLE_DEPRECATION_WARNINGS**:
+  This macro disables warnings when using deprecated components. For example,
+  using `std::auto_ptr` when compiling in C++11 mode will normally trigger a
+  warning saying that `std::auto_ptr` is deprecated. If the macro is defined,
+  no warning will be emitted. 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**:

libcxx/include/__config

 #define _LIBCPP_WCTYPE_IS_MASK
 #endif
 
 #if _LIBCPP_STD_VER <= 17 || !defined(__cpp_char8_t)
 #define _LIBCPP_NO_HAS_CHAR8_T
 #endif
 
 // Deprecation macros.
-// Deprecations warnings are only enabled when _LIBCPP_ENABLE_DEPRECATION_WARNINGS is defined.
-#if defined(_LIBCPP_ENABLE_DEPRECATION_WARNINGS)
+//
+// Deprecations warnings are always enabled, except when users explicitly opt-out
+// by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS.
+#if !defined(_LIBCPP_DISABLE_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

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

 //  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
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <algorithm>
 #include <vector>
 
 struct gen
 {
     std::ptrdiff_t operator()(std::ptrdiff_t n)
     {

libcxx/test/libcxx/algorithms/alg.modifying.operations/alg.random.shuffle/random_shuffle.depr_in_cxx14.fail.cpp

 //     void
 //     random_shuffle(RandomAccessIterator first, RandomAccessIterator last,
 //                    RandomNumberGenerator& rand);
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11
 // 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

libcxx/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.cxx1z.pass.cpp

 // template <class X>
 // class auto_ptr;
 //
 //  In C++17, auto_ptr has been removed.
 //  However, for backwards compatibility, if _LIBCPP_NO_REMOVE_AUTOPTR
 //  is defined before including <memory>, then auto_ptr will be restored.
 
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
-
 #define _LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <memory>
 #include <type_traits>
 
 int main(int, char**)
 {
     std::auto_ptr<int> p;
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.auto.ptr/auto.ptr/auto_ptr.depr_in_cxx11.fail.cpp

 // class auto_ptr_ref;
 //
 // Deprecated in C++11
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // 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(int, char**)
 {
     typedef std::auto_ptr<int> AP; // expected-error{{'auto_ptr<int>' is deprecated}}
     typedef std::auto_ptr<void> APV; // expected-error{{'auto_ptr<void>' is deprecated}}
     typedef std::auto_ptr_ref<int> APR; // expected-error{{'auto_ptr_ref<int>' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.function.objects/adaptors.depr_in_cxx11.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // 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; }

libcxx/test/libcxx/depr/depr.function.objects/depr.adaptors.cxx1z.pass.cpp

 
 
 //  In C++17, the function adapters mem_fun/mem_fun_ref, etc have been removed.
 //  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 //  is defined before including <functional>, then they will be restored.
 
 // MODULES_DEFINES: _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
 #define _LIBCPP_ENABLE_CXX17_REMOVED_BINDERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <functional>
 #include <cassert>
 
 int identity(int v) { return v; }
 int sum(int a, int b) { return a + b; }
 
 struct Foo {

libcxx/test/std/depr/depr.lib.binders/depr.lib.bind.1st/bind1st.depr_in_cxx11.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // bind1st
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // 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(int, char**)
 {
     std::bind1st(test_func(1), 5); // expected-error{{'bind1st<test_func, int>' is deprecated}}
 
   return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.bind.2nd/bind2nd.depr_in_cxx11.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // bind2nd
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // 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(int, char**)
 {
     std::bind2nd(test_func(1), 5); // expected-error{{'bind2nd<test_func, int>' is deprecated}}
 
   return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.binder.1st/binder1st.depr_in_cxx11.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // binder1st
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // 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(int, char**)
 {
     typedef std::binder1st<test_func> B1ST; // expected-error{{'binder1st<test_func>' is deprecated}}
 
   return 0;
 }

libcxx/test/std/depr/depr.lib.binders/depr.lib.binder.2nd/binder2nd.depr_in_cxx11.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
 //
 //===----------------------------------------------------------------------===//
 
 // <functional>
 //
 // binder2nd
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03
 // 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(int, char**)
 {
     typedef std::binder2nd<test_func> B2ND; // expected-error{{'binder2nd<test_func>' is deprecated}}
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/negators/binary_negate.depr_in_cxx17.fail.cpp

 
 // binary_negate
 //  deprecated in C++17
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // 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(int, char**) {
     std::binary_negate<Predicate> f((Predicate())); // expected-error{{'binary_negate<Predicate>' is deprecated}}
     (void)f;
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/negators/binary_negate.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>
 
 // binary_negate
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 int main(int, char**)
 {
     typedef std::binary_negate<std::logical_and<int> > F;
     const F f = F(std::logical_and<int>());

libcxx/test/std/utilities/function.objects/negators/not1.depr_in_cxx17.fail.cpp

 
 // not1
 //  deprecated in C++17
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // 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(int, char**) {
     std::not1(Predicate()); // expected-error{{'not1<Predicate>' is deprecated}}
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/negators/not1.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>
 
 // not1
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 int main(int, char**)
 {
     typedef std::logical_not<int> F;
     assert(std::not1(F())(36));
     assert(!std::not1(F())(0));
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/negators/not2.depr_in_cxx17.fail.cpp

 
 // not2
 //  deprecated in C++17
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // 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(int, char**) {
     std::not2(Predicate()); // expected-error{{'not2<Predicate>' is deprecated}}
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/negators/not2.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>
 
 // not2
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <cassert>
 
 int main(int, char**)
 {
     typedef std::logical_and<int> F;
     assert(!std::not2(F())(36, 36));
     assert( std::not2(F())(36, 0));
     assert( std::not2(F())(0, 36));
     assert( std::not2(F())(0, 0));
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/negators/unary_negate.depr_in_cxx17.fail.cpp

 
 // unary_negate
 //  deprecated in C++17
 
 // UNSUPPORTED: clang-4.0
 // UNSUPPORTED: c++98, c++03, c++11, c++14
 // 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(int, char**) {
     std::unary_negate<Predicate> f((Predicate())); // expected-error{{'unary_negate<Predicate>' is deprecated}}
     (void)f;
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/negators/unary_negate.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>
 
 // unary_negate
 
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <functional>
 #include <type_traits>
 #include <cassert>
 
 int main(int, char**)
 {
     typedef std::unary_negate<std::logical_not<int> > F;
     const F f = F(std::logical_not<int>());
     static_assert((std::is_same<F::argument_type, int>::value), "" );
     static_assert((std::is_same<F::result_type, bool>::value), "" );
     assert(f(36));
     assert(!f(0));
 
   return 0;
 }