[libcxx][type_traits] remove `std::is_literal_type` and `std::result_of` for C++20

[Wmbat]

Summary

C++17 deprecated std::is_literal_type and std::result_of, C++20 removed them.

Implements parts of:

• P0174R2 'Deprecating Vestigial Library Parts in C++17'.
• P0619R4 'Reviewing Deprecated Facilities of C++17 for C++20'.

[cjdb]

Overall LGTM, thanks for working on this! Please also add a test to confirm that std::is_literal_type is deprecated in C++17.

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.removed.verify.cpp

8–9

16–17

Please delete these two lines.

[• Quuxplusone]

LGTM % comments, but please fix the review comments and wait for "libc++" to accept.

libcxx/include/type_traits

3721

Please remove blank lines 3721 and 3731.

libcxx/test/std/utilities/any/any.class/not_literal_type.pass.cpp

15–16

// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
(git grep -i deprecat libcxx/test/ finds this idiom quickly)

[• Quuxplusone]

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.removed.verify.cpp

17–18

Oh— you probably need to do something here to deal with non-Clang compilers. @ldionne probably knows what to do.

[Mordante]

Thanks for working on this. Please update this note https://libcxx.llvm.org/docs/Cxx2aStatus.html#note-p0619
I see some build issues, but I expect @cjdb's suggestions to fix them.

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.removed.verify.cpp

17–18

Since the test is a verify.cpp it should only be executed with the Clang compiler.

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp

50

Since we disable some tests in C++20 (and later) modes it would be nice to test some other properties. regarding copy constructible/assignable and move constructible/assignable.

[Wmbat]

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp

50

Are those (copy constructible/assignable and move constructible/assignable) really necessary to test in this file which is about dtor.pass.cpp. I have seen some tests for those properties elsewhere in the meta.unary.pop folder. Would it be possible to elaborate further on what I would have to do?

[Mordante]

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp

50

In that case these tests aren't needed. I just felt it would be nice to have tests instead of the disabled literal_type test.

50

Would it be possible to elaborate further on what I would have to do?

Not entirely sure what you mean. I marked the patch as 'needs work' due to the build failures. Others already offered suggestions how to fix these.

[Wmbat]

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp

50

Would it be possible to elaborate further on what I would have to do?

Oh, sorry for the misunderstanding. This statement was referring to adding tests for the other properties. I have been working on the build failures and all recommendation, I was just wondering about the extra tests

[Wmbat]

• Added an extra test for checking deprecation message
• Removed extra lines and other minor problems
• Replaced all instances of

#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

with

// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS

[Wmbat]

Fixes double commit problem

[Wmbat]

Fix broken is_literal_type.deprecated.fail.cpp unit test

[ldionne]

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp

40

What are we actually trying to test here? Can we instead check that std::is_trivial<Atomic> and do that under all standard modes?

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp

44–45

I don't think we're actually testing anything here, are we? I think we can just remove this without reducing coverage, since that's not how we should test that optional is constexpr-friendly. Also applies below.

[Wmbat]

Added _LIBCPP_ENABLE_CXX20_REMOVED_IS_LITERAL_TYPE macro and fixed inconsistencies in some unit tests.

[• Quuxplusone]

libcxx/docs/UsingLibcxx.rst

266–267

Excellent noticing of documentation. :) However, on closer inspection of p0619r4, I think you should:

• rename to _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS
• include result_of and result_of_t under the same switch
• (and then you won't need to alphabetize, because TY..., unlike IS..., comes after RA...)

Then you can mark p0619 section D.13 as complete.

libcxx/include/__config

1375

Same comments here (including the lack-of-need-to-alphabetize if you change the name of this macro)

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp

16

Re-remove this.

libcxx/test/std/utilities/any/any.class/not_literal_type.pass.cpp

23

I think @ldionne's comment on the optional test also applies here: This test is merely testing that std::any isn't constexpr-constructible, specifically in C++17? I don't think that's a useful test. I think this entire file should be deleted and never spoken of again. :) [Any objections?]

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.deprecated.fail.cpp

21–23

Remove lines 21-23. We're only testing the deprecation warning here, so we only need the one line, line 20.

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.pass.cpp

9

Remove this line. (This would be wrong anyway, since we never pass c++11 and c++14 and c++17 all at the same time, right?)

Instead, add above line 15:

// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.removed.verify.cpp

17–18

I've changed my mind about the usefulness of this test: This test is not useful. There's a reason we don't have any similar tests for other removed facilities — we want all the tests in libcxx/test/std/ to be applicable to ANY conforming standard library, including e.g. libstdc++. And AFAIK it's perfectly conforming for a standard library to provide the name std::is_literal_type even in C++20, as a conforming extension.

So, I recommend deleting this whole file.

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.pass.cpp

14

Remove this line.

[Wmbat]

libcxx/docs/UsingLibcxx.rst

266–267

result_of and result_of_t don't look deprecated or removed yet (in the type_traits header). Should I add them under the _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS macro documentation and not touch the code? I think might be missing something (likely) here.

[• Quuxplusone]

libcxx/docs/UsingLibcxx.rst

266–267

Looks to me like they were removed in C++20:
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0619r4.html#3.12
and deprecated in-or-before C++17 (might need to dig to find exactly when).
And yes, I'm saying put the whole section D.13 under that same macro, _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS. And yes this will involve touching the code as well as the documentation. :)

[Wmbat]

libcxx/docs/UsingLibcxx.rst

266–267

So, I should deprecate & remove result_of in this commit as well? Looking at the source code of type_traits. result_of hasn't been removed or deprecated yet. I would have to rename the commit as the name wouldn't imply all that is being done in it.

[Wmbat]

Now also deprecates and remove std::result_of

[• Quuxplusone]

LGTM % comments, again. @ldionne should take a look.

libcxx/include/type_traits

169–170

nit: lowercase "deprecated" and "removed" here and lines 236 and 305 below

3720–3721

Please stick to _LIBCPP_STD_VER <= 17 rather than _LIBCPP_STD_VER < 20, for consistency with the other places we do things like this. (It never really matters once the year has passed, but for example, this year, a STD_VER of 21 is supposed to behave much more like 23 than like 20. So in the past, the behavior should change as you move from 17 to 18, not as you move from 19 to 20.)

libcxx/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp

16–17 ↗

(On Diff #348665)

Re-remove.

libcxx/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp

101–104 ↗

(On Diff #348665)

I'm ambivalent as to whether you should keep _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS at the top of the file, or simply put lines 101-104, 124-127, and 145-148 under #if TEST_STD_VER <= 17 instead. I'm not requesting a change here, but maybe @ldionne will have a stronger opinion one way or the other.

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

268–297 ↗

(On Diff #348665)

This code is from "Example 2," not "Note B," and it has literally nothing to do with common_type; it's an example demonstrating the use of invoke_result_t (presumably formerly result_of).
https://eel.is/c++draft/meta.trans.other#example-2

Since it has nothing to do with common_type.pass.cpp, I think these lines should simply be removed. (And then re-remove your added lines 13-15.)

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.deprecated.fail.cpp

9 ↗

(On Diff #348665)

I think this should be

// UNSUPPORTED: c++03, c++11, c++14
// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS

but defer to @ldionne since he just went through this with the std::iterator tests. (You could grep and check for what he did there. Maybe you already did.)

Same comment on meta.unary.prop/is_literal_type.deprecated.fail.cpp below.

libcxx/test/support/poisoned_hash_helper.h

156–158 ↗

(On Diff #348665)

We're now attaching the & on line 120, so please s/Hash const&/Hash const/ here.

[ldionne]

libcxx/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp

101–104 ↗

(On Diff #348665)

Let's keep it as-is. As a matter of policy, I also want to suggest that we don't provide those escape hatches anymore, so they'll be easier to remove if the tests are written as they are right now.

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.deprecated.fail.cpp

9 ↗

(On Diff #348665)

Agreed with Arthur - that way, we'll be running that test in all standard modes >= C++17, which is what we want (since we're enabling the removed type traits anyway). If we didn't have the _LIBCPP_ENABLE_CXX20_REMOVED_TYPE_TRAITS escape hatch, then I agree this should be // REQUIRES: c++17 instead.

[• Quuxplusone]

libcxx/test/std/utilities/function.objects/func.invoke/invoke.pass.cpp

101–104 ↗

(On Diff #348665)

@ldionne: we should take the policy thing to chat (Slack or Discord). FYI, I believe the "escape hatches" are strictly positively useful. I'd be perfectly amenable to saying "we don't really support users defining these in production." But I think they're great in terms of documenting our progress on omnibus papers like p0619, and also in terms of explaining otherwise-opaque _LIBCPP_STD_VER dependencies to the casual maintainer, and also (somewhat — maybe I'm ambivalent here) in terms of structuring the unit tests.

[Wmbat]

Implementing suggestions from @Quuxplusone

[• Quuxplusone]

LGTM again now.

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.deprecated.fail.cpp

15 ↗

(On Diff #348863)

Please move the ADDITIONAL_COMPILE_FLAGS line up to right below the UNSUPPORTED line.

[Mordante]

Thanks for the updates, LGTM!

[Wmbat]

Rebase on main + minor changes

[Wmbat]

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp

40

For some reason, this static_assert fails under the GCC/C++20 build, but passes for all Clang builds. I have no idea why

[ldionne]

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.pass.cpp

40

Okay, I dug a bit more into this and here's what I think we want:

1. Remove this static assertion, it doesn't test anything anymore.
2. Add libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/dtor.pass.cpp, and add the following to it:

template <class Tp>
struct CheckTriviallyDestructible {
    void operator()() const {
        typedef std::atomic<Tp> Atomic;
        static_assert(std::is_trivially_destructible<Atomic>::value, "");
    }
};

TestEachIntegralType<CheckTriviallyDestructible>()();
TestEachFloatingPointType<CheckTriviallyDestructible>()(); // needs to be added to `atomic_helpers.h`
TestEachPointerType< CheckTriviallyDestructible >()(); // needs to be added to `atomic_helpers.h`

3. Add libcxx/test/std/atomics/atomics.types.generic/standard_layout.compile.pass.cpp and add the following in it:

template <class Tp>
struct CheckStandardLayout {
    void operator()() const {
        typedef std::atomic<Tp> Atomic;
        static_assert(std::is_standard_layout<Atomic>::value, "");
    }
};

CheckStandardLayout<bool>();
TestEachIntegralType<CheckStandardLayout>()();
TestEachFloatingPointType<CheckStandardLayout>()();
TestEachPointerType<CheckStandardLayout>()();

In other words, make sure that std::atomic<bool|Integral|FloatingPoint|Pointer> is standard layout, and that std::atomic<Integral|FloatingPoint|Pointer> is trivially destructible. I think that's pretty much the extent of the guarantees provided by the standard.

libcxx/test/std/utilities/any/any.class/not_literal_type.pass.cpp

23

Yeah, I would remove this test entirely. I don't think it's checking anything useful anymore.

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.deprecated.fail.cpp

25–26 ↗

(On Diff #349071)

Why not write this as:

typedef std::result_of<CallableStruct(int)>::type f; // expected-warning {{'result_of<CallableStruct (int)>' is deprecated}}

Unless there is a reason for the funky indentation?

[cjdb]

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.deprecated.fail.cpp

25–26 ↗

(On Diff #349071)

clang-format doesn't like that (I suspect the line is longer than 120 chars). I do this instead:

typedef std::result_of<CallableStruct(int)>::type f;
// expected-warning@-1{{'result_of<CallableStruct (int)>' is deprecated}}

[• Quuxplusone]

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/result_of.deprecated.fail.cpp

25–26 ↗

(On Diff #349071)

Another way of writing this test is as a two-liner:

std::result_of<int(*())()> a; // expected-warning{{is deprecated}}
std::result_of_t<int(*())()> b; // expected-warning{{is deprecated}}

(and then don't even provide a main because this test is compile-only).

[Wmbat]

Changes based on recommendations.

• TestEachPointerType does not check for all pointer types yet. Open to suggestions for anything i may miss
• Fixed weird formatting in result_of.deprecated.fail.cpp

[• Quuxplusone]

Continues to LbasicallyGTM. Please rebase on trunk and re-upload the diff, so that we can get a clean buildkite run; I see the latest run failed some tests that have been fixed in main for a while already.

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.deprecated.fail.cpp

15

Please move this up to right below line 9, as in meta.trans.other/result_of.deprecated.fail.cpp.

[Wmbat]

Rebased on main

[ldionne]

Almost LGTM, the only issue I have with this is the duplication of the atomic_helpers.h header, for which there's a better solution available.

libcxx/test/std/atomics/atomic_helpers.h

1 ↗

(On Diff #354752)

Why are we duplicating this file? Instead, let's move the original file to libcxx/test/support/atomic_helpers.h and include it as just #include "atomic_helpers.h" from everywhere.

[Wmbat]

Modifications based on @ldionne's recommendations

[Wmbat]

Fixed incorrect header to atomic_helpers.h in atomic_wait.pass.cpp

[ldionne]

Thanks!

libcxx/test/support/atomic_helpers.h

142 ↗

(On Diff #355086)

As a fly-by, can you fix this comment to say // ATOMIC_HELPERS_H (missing S). Don't re-upload a patch just for that.

libcxx/docs/UsingLibcxx.rst

 
 **_LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS**:
   This macro is used to re-enable `not1`, `not2`, `unary_negate`,
   and `binary_negate`.
 
 **_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR**:
   This macro is used to re-enable `raw_storage_iterator`.
 
+**_LIBCPP_ENABLE_CXX20_REMOVED_IS_LITERAL_TYPE**:
+  This macro is used to re-enable `is_literal_type` and `is_literal_type_v`.
 
 Libc++ Extensions
 =================
 
 This section documents various extensions provided by libc++, how they're
 provided, and any information regarding how to use them.
 
 .. _nodiscard extension:

libcxx/include/__config

 #define _LIBCPP_ENABLE_CXX17_REMOVED_RANDOM_SHUFFLE
 #define _LIBCPP_ENABLE_CXX17_REMOVED_UNEXPECTED_FUNCTIONS
 #endif // _LIBCPP_ENABLE_CXX17_REMOVED_FEATURES
 
 #if defined(_LIBCPP_ENABLE_CXX20_REMOVED_FEATURES)
 #define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 #define _LIBCPP_ENABLE_CXX20_REMOVED_NEGATORS
 #define _LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR
+#define _LIBCPP_ENABLE_CXX20_REMOVED_IS_LITERAL_TYPE
 #endif // _LIBCPP_ENABLE_CXX20_REMOVED_FEATURES
 
 #if !defined(__cpp_deduction_guides) || __cpp_deduction_guides < 201611
 #define _LIBCPP_HAS_NO_DEDUCTION_GUIDES
 #endif
 
 #if !__has_keyword(__is_aggregate) && (_GNUC_VER_NEW < 7001)
 #define _LIBCPP_HAS_NO_IS_AGGREGATE

libcxx/include/type_traits

namespace std
     template <class T> struct is_bounded_array;                 // C++20
     template <class T> struct is_unbounded_array;               // C++20
 
     // Member introspection:
     template <class T> struct is_pod;
     template <class T> struct is_trivial;
     template <class T> struct is_trivially_copyable;
     template <class T> struct is_standard_layout;
-    template <class T> struct is_literal_type;
+    template <class T> struct is_literal_type; // Deprecated in C++17; removed in C++20
     template <class T> struct is_empty;
     template <class T> struct is_polymorphic;
     template <class T> struct is_abstract;
     template <class T> struct is_final; // C++14
     template <class T> struct is_aggregate; // C++17
 
     template <class T, class... Args> struct is_constructible;
     template <class T>                struct is_default_constructible;
template <size_t Len, size_t Align = most_stringent_alignment_requirement>
         struct aligned_storage;
     template <size_t Len, class... Types> struct aligned_union;
     template <class T> struct remove_cvref; // C++20
 
     template <class T> struct decay;
     template <class... T> struct common_type;
     template <class T> struct underlying_type;
     template <class> class result_of; // undefined
     template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)>;
     template <class Fn, class... ArgTypes> struct invoke_result;  // C++17
 
     // const-volatile modifications:
     template <class T>
       using remove_const_t    = typename remove_const<T>::type;  // C++14
     template <class T>
       using remove_volatile_t = typename remove_volatile<T>::type;  // C++14
     template <class T>
       using remove_cv_t       = typename remove_cv<T>::type;  // C++14

 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_pod_v
     = is_pod<_Tp>::value;
 #endif
 
 // is_literal_type;
 
-template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_literal_type
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_IS_LITERAL_TYPE)
+template <class _Tp> struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 is_literal_type
     : public integral_constant<bool, __is_literal_type(_Tp)>
     {};
 
 #if _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
 template <class _Tp>
 _LIBCPP_INLINE_VAR _LIBCPP_CONSTEXPR bool is_literal_type_v
     = is_literal_type<_Tp>::value;
-#endif
+#endif // _LIBCPP_STD_VER > 14 && !defined(_LIBCPP_HAS_NO_VARIABLE_TEMPLATES)
+#endif // _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_IS_LITERAL_TYPE)
 
 // is_standard_layout;
 
 template <class _Tp> struct _LIBCPP_TEMPLATE_VIS is_standard_layout
 #if __has_feature(is_standard_layout) || defined(_LIBCPP_COMPILER_GCC)
     : public integral_constant<bool, __is_standard_layout(_Tp)>
 #else
     : integral_constant<bool, is_scalar<typename remove_all_extents<_Tp>::type>::value>

libcxx/test/std/atomics/atomics.types.operations/atomics.types.operations.req/ctor.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
 //
 //===----------------------------------------------------------------------===//
 //
 // UNSUPPORTED: libcpp-has-no-threads
 // UNSUPPORTED: c++03
 
 // <atomic>
 
 // constexpr atomic<T>::atomic(T value)
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <atomic>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "atomic_helpers.h"
 
 struct UserType {
     int i;
 
     UserType() noexcept {}
     constexpr explicit UserType(int d) noexcept : i(d) {}
 
     friend bool operator==(const UserType& x, const UserType& y) {
         return x.i == y.i;
     }
 };
 
 template <class Tp>
 struct TestFunc {
     void operator()() const {
         typedef std::atomic<Tp> Atomic;
-        static_assert(std::is_literal_type<Atomic>::value, "");
+        static_assert(std::is_trivial<Atomic>::value, "");
         constexpr Tp t(42);
         {
             constexpr Atomic a(t);
             assert(a == t);
         }
         {
             constexpr Atomic a{t};
             assert(a == t);

libcxx/test/std/utilities/any/any.class/not_literal_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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// REQUIRES: c++17
 
 // <any>
 
 // [Note any is a not a literal type --end note]
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <any>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**) {
     static_assert(!std::is_literal_type<std::any>::value, "");
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.deprecated.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// REQUIRES: c++17
 
-// <any>
+// type_traits
 
-// [Note any is a not a literal type --end note]
+// is_literal_type
 
-#include <any>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**) {
-    static_assert(!std::is_literal_type<std::any>::value, "");
+  static_assert(std::is_literal_type<int>::value, ""); // expected-warning {{'is_literal_type<int>' is deprecated}}
+  static_assert(
+      std::is_literal_type<const int>::value, // expected-warning {{'is_literal_type<const int>' is deprecated}}
+      "");
 
   return 0;
 }

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_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
 //
 //===----------------------------------------------------------------------===//
 
+// REQUIRES: c++11, c++14, c++17
+
 // type_traits
 
 // is_literal_type
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <type_traits>
 #include <cstddef>       // for std::nullptr_t
 #include "test_macros.h"
 
 template <class T>
 void test_is_literal_type()
 {
     static_assert( std::is_literal_type<T>::value, "");

libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_literal_type.removed.verify.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
 //
 //===----------------------------------------------------------------------===//
 
-// UNSUPPORTED: c++03, c++11, c++14
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// <any>
+// type_traits
 
-// [Note any is a not a literal type --end note]
+// is_literal_type
 
-#include <any>
 #include <type_traits>
 
-#include "test_macros.h"
-
-int main(int, char**) {
-    static_assert(!std::is_literal_type<std::any>::value, "");
-
-  return 0;
-}
+using std::is_literal_type;   // expected-error {{no member named 'is_literal_type' in namespace 'std'}}
+using std::is_literal_type_v; // expected-error {{no member named 'is_literal_type_v' in namespace 'std'}}

libcxx/test/std/utilities/optional/optional.object/optional.object.dtor/dtor.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
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: c++03, c++11, c++14
 // <optional>
 
 // ~optional();
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <optional>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 using std::optional;
 

 
 bool X::dtor_called = false;
 
 int main(int, char**)
 {
     {
         typedef int T;
         static_assert(std::is_trivially_destructible<T>::value, "");
         static_assert(std::is_trivially_destructible<optional<T>>::value, "");
-        static_assert(std::is_literal_type<optional<T>>::value, "");
     }
     {
         typedef double T;
         static_assert(std::is_trivially_destructible<T>::value, "");
         static_assert(std::is_trivially_destructible<optional<T>>::value, "");
-        static_assert(std::is_literal_type<optional<T>>::value, "");
     }
     {
         typedef PODType T;
         static_assert(std::is_trivially_destructible<T>::value, "");
         static_assert(std::is_trivially_destructible<optional<T>>::value, "");
-        static_assert(std::is_literal_type<optional<T>>::value, "");
     }
     {
         typedef X T;
         static_assert(!std::is_trivially_destructible<T>::value, "");
         static_assert(!std::is_trivially_destructible<optional<T>>::value, "");
-        static_assert(!std::is_literal_type<optional<T>>::value, "");
         {
             X x;
             optional<X> opt{x};
             assert(X::dtor_called == false);
         }
         assert(X::dtor_called == true);
     }
 
   return 0;
 }