P1152R4: Fix deprecation warnings in libc++ testsuite and in uses of is_invocable that would internally conjure up a deprecated function type.

[rsmith]

Summary

The implementation of P1152R4 in Clang has resulted in some deprecation warnings appearing in the libc++ and libc++abi test suite. Fix or suppress these warnings.

[ldionne]

libcxx/include/__config

966

Please document that we're talking about compiler deprecation warnings, otherwise this can be confused as also turning off library deprecation warnings. Ignoring -Wdeprecated won't have that effect, right?

// Macros to enter and leave a state where compiler deprecation warnings are suppressed. This doesn't impact library deprecation warnings.

Or something along those lines.

969

Please indent nested #defines:

#  define _LIBCPP_SUPPRESS_DEPRECATED_PUSH

libcxx/include/type_traits

1123

Wait, I don't see any volatile qualification here?

[rsmith]

Indent nested preprocessor directives.

[rsmith]

Extend comment to explain how __declval gets a volatile-qualified return type.

libcxx/include/__config

966

Ignoring -Wdeprecated turns off all deprecation warnings, regardless of whether they come from attributes or something else. (This might also be useful if libc++ wants to implement something in terms of deprecated library functionality.)

libcxx/include/type_traits

1123

The volatile comes from _Tp, specified indirectly through various callers that internally use declval. In particular, the is_invocable<volatile T> tests end up here.

[ldionne]

libcxx/include/type_traits

1123

That's what I thought, but isn't that warning broken then? Isn't any template going to produce a warning when instantiated with a volatile T? I must be misunderstanding something.

[rsmith]

libcxx/include/type_traits

1123

We warn when instantiating the second overload of __declval with _Tp = volatile T, because that causes it to have a volatile-qualified return type, which is deprecated. We don't warn on the first overload, because it doesn't have a volatile-qualified return type regardless of _Tp. Does that make more sense?

[davezarzycki]

Is there an ETA for this fix? Without it, stage two testing fails:

http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20191007/290336.html

[ldionne]

Let's not block this because I have questions about the warning implemented in Clang. Richard, you can ship this. Thanks for the fix and sorry for the delay.

libcxx/include/type_traits

1123

My question was: why don't we warn in the location where the user says std::declval<volatile Foo>(), and only there?

[rsmith]

libcxx/include/type_traits

1123

The thing that's deprecated is declaring a function with a volatile-qualified function type, so we warn at the point where that happens, which is here, inside the implementation of declval. (This warning will be "in instantiation of" something else, but we use the warning state at the location the warning is pointed at, not the warning state at the point of instantiation, which is why we need the suppression here.)

Note that decltype(_VSTD::__declval<volatile Foo>(0)) (the return type of declval below) will be (non-volatile) Foo if Foo is not a class type, because there are no volatile-qualified non-class (non-array) prvalues. So the volatile gets stripped off before we even get to std::declval. The volatile only appears here temporarily as an implementation detail. Incidentally, the only case when we'll actually select the __declval overload with a volatile-qualified return type is when calling declval<volatile void>(), because all non-volatile _Tps will call the other __declval overload.

This could possibly be fixed in a different way, by rewriting declval to follow the way the standard specifies it:

template<class T>
  add_rvalue_reference_t<T> declval() noexcept;

This would only warn when T is (possibly-const) volatile void, which seems appropriate. However, I suspect the class template instantiation in here would be significantly more expensive than the current implementation. Maybe we could add an __add_rvalue_reference builtin to Clang for use implementing declval?

libcxx/include/__config

 #endif
 
 #if _LIBCPP_STD_VER >= 17
 #  define _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_DEPRECATED
 #else
 #  define _LIBCPP_DEPRECATED_IN_CXX17
 #endif
 
+// Macros to enter and leave a state where deprecation warnings are suppressed.
+#if !defined(_LIBCPP_SUPPRESS_DEPRECATED_PUSH) && \
+    (defined(_LIBCPP_COMPILER_CLANG) || defined(_LIBCPP_COMPILER_GCC))
+#define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \
+  _Pragma("GCC diagnostic push") \
+  _Pragma("GCC diagnostic ignored \"-Wdeprecated\"")
+#define _LIBCPP_SUPPRESS_DEPRECATED_POP \
+  _Pragma("GCC diagnostic pop")
+#endif
+#if !defined(_LIBCPP_SUPPRESS_DEPRECATED_PUSH)
+#define _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+#define _LIBCPP_SUPPRESS_DEPRECATED_POP
+#endif
+
 #if _LIBCPP_STD_VER <= 11
 #  define _LIBCPP_EXPLICIT_AFTER_CXX11
 #else
 #  define _LIBCPP_EXPLICIT_AFTER_CXX11 explicit
 #endif
 
 #if _LIBCPP_STD_VER > 11 && !defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR)
 #  define _LIBCPP_CONSTEXPR_AFTER_CXX11 constexpr

libcxx/include/type_traits

 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS add_rvalue_reference
 {typedef _LIBCPP_NODEBUG_TYPE  typename __add_rvalue_reference_impl<_Tp>::type type;};
 
 #if _LIBCPP_STD_VER > 11
 template <class _Tp> using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
 #endif
 
+// Suppress deprecation notice for volatile-qualified return type.
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Tp> _Tp&& __declval(int);
 template <class _Tp> _Tp   __declval(long);
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Tp>
 decltype(_VSTD::__declval<_Tp>(0))
 declval() _NOEXCEPT;
 
 // __uncvref
 
 template <class _Tp>

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of11.pass.cpp

 #if TEST_STD_VER > 11
     ASSERT_SAME_TYPE(U,        std::result_of_t<T>);
 #endif
 #if TEST_STD_VER > 14
     test_invoke_result<T, U>::call();
 #endif
 }
 
+// Do not warn on deprecated uses of 'volatile' below.
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+
 int main(int, char**)
 {
     {
     typedef char F::*PMD;
     test_result_of_imp<PMD(F                &), char                &>();
     test_result_of_imp<PMD(F const          &), char const          &>();
     test_result_of_imp<PMD(F volatile       &), char volatile       &>();
     test_result_of_imp<PMD(F const volatile &), char const volatile &>();
int main(int, char**)
     test_result_of_imp<int (F::* (std::reference_wrapper<const F>)) () const, int>();
     test_result_of_imp<int (F::* (std::unique_ptr<F>       ))       (),       int>();
     test_result_of_imp<int (F::* (std::unique_ptr<const F> ))       () const, int>();
     }
     test_result_of_imp<decltype(&wat::foo)(wat), void>();
 
   return 0;
 }
+
+_LIBCPP_SUPPRESS_DEPRECATED_POP

libcxxabi/test/unwind_06.pass.cpp

 
 double (* volatile get)(int) = get_;
 
 volatile int counter;
 
 double try1(bool v) {
   double a = get(0);
   double b = get(1);
-  for (counter = 100; counter; --counter)
+  for (counter = 100; counter; counter = counter - 1)
     a += get(1) + b;
   if (v) throw 10;
   return get(0)+a+b;
 }
 
 double try2(bool v) {
   double a = get(0);
   double b = get(1);
   double c = get(2);
-  for (counter = 100; counter; --counter)
+  for (counter = 100; counter; counter = counter - 1)
     a += get(1) + b + c;
   if (v) throw 10;
   return get(0)+a+b+c;
 }
 
 double try3(bool v) {
   double a = get(0);
   double b = get(1);
   double c = get(2);
   double d = get(3);
-  for (counter = 100; counter; --counter)
+  for (counter = 100; counter; counter = counter - 1)
     a += get(1) + b + c + d;
   if (v) throw 10;
   return get(0)+a+b+c+d;
 }
 
 double try4(bool v) {
   double a = get(0);
   double b = get(0);
   double c = get(0);
   double d = get(0);
   double e = get(0);
-  for (counter = 100; counter; --counter)
+  for (counter = 100; counter; counter = counter - 1)
     a += get(1) + b+c+d+e;
   if (v) throw 10;
   return get(0)+a+b+c+d+e;
 }
 
 double try5(bool v) {
   double a = get(0);
   double b = get(0);
   double c = get(0);
   double d = get(0);
   double e = get(0);
   double f = get(0);
-  for (counter = 100; counter; --counter)
+  for (counter = 100; counter; counter = counter - 1)
     a += get(1) + b+c+d+e+f;
   if (v) throw 10;
   return get(0)+a+b+c+d+e+f;
 }
 
 double try6(bool v) {
   double a = get(0);
   double b = get(0);
   double c = get(0);
   double d = get(0);
   double e = get(0);
   double f = get(0);
   double g = get(0);
-  for (counter = 100; counter; --counter)
+  for (counter = 100; counter; counter = counter - 1)
     a += get(1) + b+c+d+e+f+g;
   if (v) throw 10;
   return get(0)+a+b+c+d+e+f+g;
 }
 
 double try7(bool v) {
   double a = get(0);
   double b = get(0);
   double c = get(0);
   double d = get(0);
   double e = get(0);
   double f = get(0);
   double g = get(0);
   double h = get(0);
-  for (counter = 100; counter; --counter)
+  for (counter = 100; counter; counter = counter - 1)
     a += get(1) + b+c+d+e+f+g+h;
   if (v) throw 10;
   return get(0)+a+b+c+d+e+f+g+h;
 }
 
 double try8(bool v) {
   double a = get(0);
   double b = get(0);
   double c = get(0);
   double d = get(0);
   double e = get(0);
   double f = get(0);
   double g = get(0);
   double h = get(0);
   double i = get(0);
-  for (counter = 100; counter; --counter)
+  for (counter = 100; counter; counter = counter - 1)
     a += get(1) + b+c+d+e+f+g+h+i;
   if (v) throw 10;
   return get(0)+a+b+c+d+e+f+g+h+i;
 }