[libc++] [test] Remove `using std::any{,_cast}` from std/utilities/any/

[• Quuxplusone]

Summary

Drive-by refactor a little bit (mainly to turn direct-initializations into copy-initializations), and expand test coverage a tiny bit, so this is not one of the purely mechanical changes bundled into D119860. (But I still don't expect this to be a controversial cleanup.)

libcxx/test/libcxx/utilities/any/size_and_alignment.pass.cpp

 // Check that the size and alignment of any are what we expect.
 
 #include <any>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    using std::any;
-    static_assert(sizeof(any) == sizeof(void*)*4, "");
-    static_assert(alignof(any) == alignof(void*), "");
+    static_assert(sizeof(std::any) == sizeof(void*)*4, "");
+    static_assert(alignof(std::any) == alignof(void*), "");
 
   return 0;
 }

libcxx/test/libcxx/utilities/any/small_type.pass.cpp

 };
 
 struct alignas(DoubleBufferAlignment) OverSizeAndAlignedType {
     char buff[BufferSize + 1];
 };
 
 int main(int, char**)
 {
-    using std::any;
     using std::__any_imp::_IsSmallObject;
     static_assert(_IsSmallObject<small>::value, "");
     static_assert(_IsSmallObject<void*>::value, "");
     static_assert(!_IsSmallObject<SmallThrowsDtor>::value, "");
     static_assert(!_IsSmallObject<large>::value, "");
     {
         // Check a type that meets the size requirement *exactly* and has
         // a lesser alignment requirement is considered small.

libcxx/test/std/utilities/any/any.class/any.assign/copy.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
 
 // Throwing bad_any_cast is supported starting in macosx10.13
 // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12}} && !no-exceptions
 
 // <any>
 
-// any& operator=(any const &);
+// any& operator=(const any&);
 
 // Test copy assignment
 
 #include <any>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
 template <class LHS, class RHS>
 void test_copy_assign() {
     assert(LHS::count == 0);
     assert(RHS::count == 0);
     LHS::reset();
     RHS::reset();
     {
-        any lhs(LHS(1));
-        any const rhs(RHS(2));
+        std::any lhs = LHS(1);
+        const std::any rhs = RHS(2);
 
         assert(LHS::count == 1);
         assert(RHS::count == 1);
         assert(RHS::copied == 0);
 
         lhs = rhs;
 
         assert(RHS::copied == 1);
         assert(LHS::count == 0);
         assert(RHS::count == 2);
 
         assertContains<RHS>(lhs, 2);
         assertContains<RHS>(rhs, 2);
     }
     assert(LHS::count == 0);
     assert(RHS::count == 0);
 }
 
 template <class LHS>
 void test_copy_assign_empty() {
     assert(LHS::count == 0);
     LHS::reset();
     {
-        any lhs;
-        any const rhs(LHS(42));
+        std::any lhs;
+        const std::any rhs = LHS(42);
 
         assert(LHS::count == 1);
         assert(LHS::copied == 0);
 
         lhs = rhs;
 
         assert(LHS::copied == 1);
         assert(LHS::count == 2);
 
         assertContains<LHS>(lhs, 42);
         assertContains<LHS>(rhs, 42);
     }
     assert(LHS::count == 0);
     LHS::reset();
     {
-        any lhs(LHS(1));
-        any const rhs;
+        std::any lhs = LHS(1);
+        const std::any rhs;
 
         assert(LHS::count == 1);
         assert(LHS::copied == 0);
 
         lhs = rhs;
 
         assert(LHS::copied == 0);
         assert(LHS::count == 0);
 
         assertEmpty<LHS>(lhs);
         assertEmpty(rhs);
     }
     assert(LHS::count == 0);
 }
 
 void test_copy_assign_self() {
     // empty
     {
-        any a;
-        a = (any &)a;
+        std::any a;
+        a = (std::any&)a;
         assertEmpty(a);
         assert(globalMemCounter.checkOutstandingNewEq(0));
     }
     assert(globalMemCounter.checkOutstandingNewEq(0));
     // small
     {
-        any a((small(1)));
+        std::any a = small(1);
         assert(small::count == 1);
 
-        a = (any &)a;
+        a = (std::any&)a;
 
         assert(small::count == 1);
         assertContains<small>(a, 1);
         assert(globalMemCounter.checkOutstandingNewEq(0));
     }
     assert(small::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
     // large
     {
-        any a(large(1));
+        std::any a = large(1);
         assert(large::count == 1);
 
-        a = (any &)a;
+        a = (std::any&)a;
 
         assert(large::count == 1);
         assertContains<large>(a, 1);
         assert(globalMemCounter.checkOutstandingNewEq(1));
     }
     assert(large::count == 0);
     assert(globalMemCounter.checkOutstandingNewEq(0));
 }
 
 template <class Tp>
 void test_copy_assign_throws()
 {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     auto try_throw =
-    [](any& lhs, any const& rhs) {
+    [](std::any& lhs, const std::any& rhs) {
         try {
             lhs = rhs;
             assert(false);
-        } catch (my_any_exception const &) {
+        } catch (const my_any_exception&) {
             // do nothing
         } catch (...) {
             assert(false);
         }
     };
     // const lvalue to empty
     {
-        any lhs;
-        any const rhs((Tp(1)));
+        std::any lhs;
+        const std::any rhs = Tp(1);
         assert(Tp::count == 1);
 
         try_throw(lhs, rhs);
 
         assert(Tp::count == 1);
         assertEmpty<Tp>(lhs);
         assertContains<Tp>(rhs, 1);
     }
     {
-        any lhs((small(2)));
-        any const rhs((Tp(1)));
+        std::any lhs = small(2);
+        const std::any rhs = Tp(1);
         assert(small::count == 1);
         assert(Tp::count == 1);
 
         try_throw(lhs, rhs);
 
         assert(small::count == 1);
         assert(Tp::count == 1);
         assertContains<small>(lhs, 2);
         assertContains<Tp>(rhs, 1);
     }
     {
-        any lhs((large(2)));
-        any const rhs((Tp(1)));
+        std::any lhs = large(2);
+        const std::any rhs = Tp(1);
         assert(large::count == 1);
         assert(Tp::count == 1);
 
         try_throw(lhs, rhs);
 
         assert(large::count == 1);
         assert(Tp::count == 1);
         assertContains<large>(lhs, 2);

libcxx/test/std/utilities/any/any.class/any.assign/move.pass.cpp

 // Test move assignment.
 
 #include <any>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
 template <class LHS, class RHS>
 void test_move_assign() {
     assert(LHS::count == 0);
     assert(RHS::count == 0);
     {
         LHS const s1(1);
-        any a(s1);
+        std::any a = s1;
         RHS const s2(2);
-        any a2(s2);
+        std::any a2 = s2;
 
         assert(LHS::count == 2);
         assert(RHS::count == 2);
 
         a = std::move(a2);
 
         assert(LHS::count == 1);
         assert(RHS::count == 2 + a2.has_value());
         LIBCPP_ASSERT(RHS::count == 2); // libc++ leaves the object empty
 
         assertContains<RHS>(a, 2);
         if (a2.has_value())
             assertContains<RHS>(a2, 0);
         LIBCPP_ASSERT(!a2.has_value());
     }
     assert(LHS::count == 0);
     assert(RHS::count == 0);
 }
 
 template <class LHS>
 void test_move_assign_empty() {
     assert(LHS::count == 0);
     {
-        any a;
-        any a2((LHS(1)));
+        std::any a;
+        std::any a2 = LHS(1);
 
         assert(LHS::count == 1);
 
         a = std::move(a2);
 
         assert(LHS::count == 1 + a2.has_value());
         LIBCPP_ASSERT(LHS::count == 1);
 
         assertContains<LHS>(a, 1);
         if (a2.has_value())
             assertContains<LHS>(a2, 0);
         LIBCPP_ASSERT(!a2.has_value());
     }
     assert(LHS::count == 0);
     {
-        any a((LHS(1)));
-        any a2;
+        std::any a = LHS(1);
+        std::any a2;
 
         assert(LHS::count == 1);
 
         a = std::move(a2);
 
         assert(LHS::count == 0);
 
         assertEmpty<LHS>(a);
         assertEmpty(a2);
     }
     assert(LHS::count == 0);
 }
 
 void test_move_assign_noexcept() {
-    any a1;
-    any a2;
-    static_assert(
-        noexcept(a1 = std::move(a2))
-      , "any & operator=(any &&) must be noexcept"
-      );
+    std::any a1;
+    std::any a2;
+    ASSERT_NOEXCEPT(a1 = std::move(a2));
 }
 
 int main(int, char**) {
     test_move_assign_noexcept();
     test_move_assign<small1, small2>();
     test_move_assign<large1, large2>();
     test_move_assign<small, large>();
     test_move_assign<large, small>();
     test_move_assign_empty<small>();
     test_move_assign_empty<large>();
 
   return 0;
 }

libcxx/test/std/utilities/any/any.class/any.assign/value.pass.cpp

 
 #include <any>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
 template <class LHS, class RHS>
 void test_assign_value() {
     assert(LHS::count == 0);
     assert(RHS::count == 0);
     LHS::reset();
     RHS::reset();
     {
-        any lhs(LHS(1));
-        any const rhs(RHS(2));
+        std::any lhs = LHS(1);
+        const std::any rhs = RHS(2);
 
         assert(LHS::count == 1);
         assert(RHS::count == 1);
         assert(RHS::copied == 0);
 
         lhs = rhs;
 
         assert(RHS::copied == 1);
         assert(LHS::count == 0);
         assert(RHS::count == 2);
 
         assertContains<RHS>(lhs, 2);
         assertContains<RHS>(rhs, 2);
     }
     assert(LHS::count == 0);
     assert(RHS::count == 0);
     LHS::reset();
     RHS::reset();
     {
-        any lhs(LHS(1));
-        any rhs(RHS(2));
+        std::any lhs = LHS(1);
+        std::any rhs = RHS(2);
 
         assert(LHS::count == 1);
         assert(RHS::count == 1);
         assert(RHS::moved == 1);
 
         lhs = std::move(rhs);
 
         assert(RHS::moved >= 1);
void test_assign_value() {
     assert(RHS::count == 0);
 }
 
 template <class RHS>
 void test_assign_value_empty() {
     assert(RHS::count == 0);
     RHS::reset();
     {
-        any lhs;
+        std::any lhs;
         RHS rhs(42);
         assert(RHS::count == 1);
         assert(RHS::copied == 0);
 
         lhs = rhs;
 
         assert(RHS::count == 2);
         assert(RHS::copied == 1);
         assert(RHS::moved >= 0);
         assertContains<RHS>(lhs, 42);
     }
     assert(RHS::count == 0);
     RHS::reset();
     {
-        any lhs;
+        std::any lhs;
         RHS rhs(42);
         assert(RHS::count == 1);
         assert(RHS::moved == 0);
 
         lhs = std::move(rhs);
 
         assert(RHS::count == 2);
         assert(RHS::copied == 0);
         assert(RHS::moved >= 1);
         assertContains<RHS>(lhs, 42);
     }
     assert(RHS::count == 0);
     RHS::reset();
 }
 
 
 template <class Tp, bool Move = false>
 void test_assign_throws() {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     auto try_throw =
-    [](any& lhs, Tp& rhs) {
+    [](std::any& lhs, Tp& rhs) {
         try {
             Move ? lhs = std::move(rhs)
                  : lhs = rhs;
             assert(false);
-        } catch (my_any_exception const &) {
+        } catch (const my_any_exception&) {
             // do nothing
         } catch (...) {
             assert(false);
         }
     };
     // const lvalue to empty
     {
-        any lhs;
+        std::any lhs;
         Tp rhs(1);
         assert(Tp::count == 1);
 
         try_throw(lhs, rhs);
 
         assert(Tp::count == 1);
         assertEmpty<Tp>(lhs);
     }
     {
-        any lhs((small(2)));
-        Tp  rhs(1);
+        std::any lhs = small(2);
+        Tp rhs(1);
         assert(small::count == 1);
         assert(Tp::count == 1);
 
         try_throw(lhs, rhs);
 
         assert(small::count == 1);
         assert(Tp::count == 1);
         assertContains<small>(lhs, 2);
     }
     {
-        any lhs((large(2)));
+        std::any lhs = large(2);
         Tp rhs(1);
         assert(large::count == 1);
         assert(Tp::count == 1);
 
         try_throw(lhs, rhs);
 
         assert(large::count == 1);
         assert(Tp::count == 1);

libcxx/test/std/utilities/any/any.class/any.cons/copy.pass.cpp

 
 #include <any>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
 template <class Type>
 void test_copy_throws() {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     assert(Type::count == 0);
     {
-        any const a((Type(42)));
+        const std::any a = Type(42);
         assert(Type::count == 1);
         try {
-            any const a2(a);
+            const std::any a2(a);
             assert(false);
         } catch (my_any_exception const &) {
             // do nothing
         } catch (...) {
             assert(false);
         }
         assert(Type::count == 1);
         assertContains<Type>(a, 42);
     }
     assert(Type::count == 0);
 #endif
 }
 
 void test_copy_empty() {
     DisableAllocationGuard g; ((void)g); // No allocations should occur.
-    any a1;
-    any a2(a1);
+    std::any a1;
+    std::any a2(a1);
 
     assertEmpty(a1);
     assertEmpty(a2);
 }
 
 template <class Type>
 void test_copy()
 {
     // Copying small types should not perform any allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     assert(Type::count == 0);
     Type::reset();
     {
-        any a((Type(42)));
+        std::any a = Type(42);
         assert(Type::count == 1);
         assert(Type::copied == 0);
 
-        any a2(a);
+        std::any a2(a);
 
         assert(Type::copied == 1);
         assert(Type::count == 2);
         assertContains<Type>(a, 42);
         assertContains<Type>(a2, 42);
 
         // Modify a and check that a2 is unchanged
         modifyValue<Type>(a, -1);

libcxx/test/std/utilities/any/any.class/any.cons/default.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 #include "any_helpers.h"
 #include "count_new.h"
 
 int main(int, char**)
 {
-    using std::any;
     {
         static_assert(
-            std::is_nothrow_default_constructible<any>::value
+            std::is_nothrow_default_constructible<std::any>::value
           , "Must be default constructible"
           );
     }
     {
         struct TestConstexpr : public std::any {
           constexpr TestConstexpr() : std::any() {}
         };
         static TEST_CONSTINIT std::any a;
         (void)a;
     }
     {
         DisableAllocationGuard g; ((void)g);
-        any const a;
+        const std::any a;
         assertEmpty(a);
     }
 
   return 0;
 }

libcxx/test/std/utilities/any/any.class/any.cons/in_place_type.pass.cpp

 #include <any>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 #include "test_convertible.h"
 
-using std::any;
-using std::any_cast;
-
 template <class Type>
 void test_in_place_type() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     assert(Type::count == 0);
     Type::reset();
     {
-        any a(std::in_place_type<Type>);
+        std::any a(std::in_place_type<Type>);
 
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 0);
     }
     assert(Type::count == 0);
     Type::reset();
     { // Test that the in_place argument is properly decayed
-        any a(std::in_place_type<Type&>);
+        std::any a(std::in_place_type<Type&>);
 
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 0);
     }
     assert(Type::count == 0);
     Type::reset();
     {
-        any a(std::in_place_type<Type>, 101);
+        std::any a(std::in_place_type<Type>, 101);
 
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 101);
     }
     assert(Type::count == 0);
     Type::reset();
     {
-        any a(std::in_place_type<Type>, -1, 42, -1);
+        std::any a(std::in_place_type<Type>, -1, 42, -1);
 
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 42);
     }
     assert(Type::count == 0);
     Type::reset();
 }
 
 template <class Type>
 void test_in_place_type_tracked() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     {
-        any a(std::in_place_type<Type>);
+        std::any a(std::in_place_type<Type>);
         assertArgsMatch<Type>(a);
     }
     {
-        any a(std::in_place_type<Type>, -1, 42, -1);
+        std::any a(std::in_place_type<Type>, -1, 42, -1);
         assertArgsMatch<Type, int, int, int>(a);
     }
     // initializer_list constructor tests
     {
-        any a(std::in_place_type<Type>, {-1, 42, -1});
+        std::any a(std::in_place_type<Type>, {-1, 42, -1});
         assertArgsMatch<Type, std::initializer_list<int>>(a);
     }
     {
         int x = 42;
-        any a(std::in_place_type<Type&>, {-1, 42, -1}, x);
+        std::any a(std::in_place_type<Type&>, {-1, 42, -1}, x);
         assertArgsMatch<Type, std::initializer_list<int>, int&>(a);
     }
 }
 
 void test_func() {}
 
 void test_in_place_type_decayed() {
     {
         using Type = decltype(test_func);
         using DecayT = void(*)();
-        any a(std::in_place_type<Type>, test_func);
+        std::any a(std::in_place_type<Type>, test_func);
         assert(containsType<DecayT>(a));
-        assert(any_cast<DecayT>(a) == test_func);
+        assert(std::any_cast<DecayT>(a) == test_func);
     }
     {
         int my_arr[5];
         using Type = int(&)[5];
         using DecayT = int*;
-        any a(std::in_place_type<Type>, my_arr);
+        std::any a(std::in_place_type<Type>, my_arr);
         assert(containsType<DecayT>(a));
-        assert(any_cast<DecayT>(a) == my_arr);
+        assert(std::any_cast<DecayT>(a) == my_arr);
     }
     {
         using Type = int[5];
         using DecayT = int*;
-        any a(std::in_place_type<Type>);
+        std::any a(std::in_place_type<Type>);
         assert(containsType<DecayT>(a));
-        assert(any_cast<DecayT>(a) == nullptr);
+        assert(std::any_cast<DecayT>(a) == nullptr);
     }
 }
 
 void test_ctor_sfinae() {
     {
         // Test that the init-list ctor SFINAE's away properly when
         // construction would be ill-formed.
         using IL = std::initializer_list<int>;

libcxx/test/std/utilities/any/any.class/any.cons/move.pass.cpp

 #include <utility>
 #include <type_traits>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
 // Moves are always noexcept. The throws_on_move object
 // must be stored dynamically so the pointer is moved and
 // not the stored object.
 void test_move_does_not_throw()
 {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     assert(throws_on_move::count == 0);
     {
         throws_on_move v(42);
-        any a(v);
+        std::any a = v;
         assert(throws_on_move::count == 2);
         // No allocations should be performed after this point.
         DisableAllocationGuard g; ((void)g);
         try {
-            any const a2(std::move(a));
+            const std::any a2 = std::move(a);
             assertEmpty(a);
             assertContains<throws_on_move>(a2, 42);
         } catch (...) {
             assert(false);
         }
         assert(throws_on_move::count == 1);
         assertEmpty(a);
     }
     assert(throws_on_move::count == 0);
 #endif
 }
 
 void test_move_empty() {
     DisableAllocationGuard g; ((void)g); // no allocations should be performed.
 
-    any a1;
-    any a2(std::move(a1));
+    std::any a1;
+    std::any a2 = std::move(a1);
 
     assertEmpty(a1);
     assertEmpty(a2);
 }
 
 template <class Type>
 void test_move() {
     assert(Type::count == 0);
     Type::reset();
     {
-        any a((Type(42)));
+        std::any a = Type(42);
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 1);
 
         // Moving should not perform allocations since it must be noexcept.
         DisableAllocationGuard g; ((void)g);
 
-        any a2(std::move(a));
+        std::any a2 = std::move(a);
 
         assert(Type::moved == 1 || Type::moved == 2); // zero or more move operations can be performed.
         assert(Type::copied == 0); // no copies can be performed.
         assert(Type::count == 1 + a.has_value());
         assertContains<Type>(a2, 42);
         LIBCPP_ASSERT(!a.has_value()); // Moves are always destructive.
         if (a.has_value())
             assertContains<Type>(a, 0);
     }
     assert(Type::count == 0);
 }
 
 int main(int, char**)
 {
     // noexcept test
-    {
-        static_assert(
-            std::is_nothrow_move_constructible<any>::value
-          , "any must be nothrow move constructible"
-          );
-    }
+    static_assert(std::is_nothrow_move_constructible<std::any>::value);
+
     test_move<small>();
     test_move<large>();
     test_move_empty();
     test_move_does_not_throw();
 
   return 0;
 }

libcxx/test/std/utilities/any/any.class/any.cons/value.pass.cpp

 
 #include <any>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
 template <class Type>
 void test_copy_value_throws()
 {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     assert(Type::count == 0);
     {
-        Type const t(42);
+        const Type t(42);
         assert(Type::count == 1);
         try {
-            any const a2(t);
+            std::any a2 = t;
             assert(false);
-        } catch (my_any_exception const &) {
+        } catch (const my_any_exception&) {
             // do nothing
         } catch (...) {
             assert(false);
         }
         assert(Type::count == 1);
         assert(t.value == 42);
     }
     assert(Type::count == 0);
 #endif
 }
 
 void test_move_value_throws()
 {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     assert(throws_on_move::count == 0);
     {
         throws_on_move v;
         assert(throws_on_move::count == 1);
         try {
-            any const a(std::move(v));
+            std::any a = std::move(v);
             assert(false);
-        } catch (my_any_exception const &) {
+        } catch (const my_any_exception&) {
             // do nothing
         } catch (...) {
             assert(false);
         }
         assert(throws_on_move::count == 1);
     }
     assert(throws_on_move::count == 0);
 #endif
 }
 
 template <class Type>
 void test_copy_move_value() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     assert(Type::count == 0);
     Type::reset();
     {
         Type t(42);
         assert(Type::count == 1);
 
-        any a(t);
+        std::any a = t;
 
         assert(Type::count == 2);
         assert(Type::copied == 1);
         assert(Type::moved == 0);
         assertContains<Type>(a, 42);
     }
     assert(Type::count == 0);
     Type::reset();
     {
         Type t(42);
         assert(Type::count == 1);
 
-        any a(std::move(t));
+        std::any a = std::move(t);
 
         assert(Type::count == 2);
         assert(Type::copied == 0);
         assert(Type::moved == 1);
         assertContains<Type>(a, 42);
     }
 }
 

libcxx/test/std/utilities/any/any.class/any.modifiers/emplace.pass.cpp

 
 #include <any>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
 struct Tracked {
   static int count;
   Tracked()  {++count;}
   ~Tracked() { --count; }
 };
 int Tracked::count = 0;
 
 template <class Type>
 void test_emplace_type() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     assert(Type::count == 0);
     Type::reset();
     {
-        any a(std::in_place_type<Tracked>);
+        std::any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
 
         auto &v = a.emplace<Type>();
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
         assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 0);
     }
     assert(Type::count == 0);
     Type::reset();
     {
-        any a(std::in_place_type<Tracked>);
+        std::any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
 
         auto &v = a.emplace<Type>(101);
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
         assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 101);
     }
     assert(Type::count == 0);
     Type::reset();
     {
-        any a(std::in_place_type<Tracked>);
+        std::any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
 
         auto &v = a.emplace<Type>(-1, 42, -1);
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
         assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 42);
     }
     assert(Type::count == 0);
     Type::reset();
 }
 
 template <class Type>
 void test_emplace_type_tracked() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     {
-        any a(std::in_place_type<Tracked>);
+        std::any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
         auto &v = a.emplace<Type>();
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
         assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assertArgsMatch<Type>(a);
     }
     {
-        any a(std::in_place_type<Tracked>);
+        std::any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
         auto &v = a.emplace<Type>(-1, 42, -1);
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
         assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assertArgsMatch<Type, int, int, int>(a);
     }
     // initializer_list constructor tests
     {
-        any a(std::in_place_type<Tracked>);
+        std::any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
         auto &v = a.emplace<Type>({-1, 42, -1});
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
         assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assertArgsMatch<Type, std::initializer_list<int>>(a);
     }
     {
         int x = 42;
-        any a(std::in_place_type<Tracked>);
+        std::any a(std::in_place_type<Tracked>);
         assert(Tracked::count == 1);
         auto &v = a.emplace<Type>({-1, 42, -1}, x);
         static_assert( std::is_same_v<Type&, decltype(v)>, "" );
         assert(&v == std::any_cast<Type>(&a));
 
         assert(Tracked::count == 0);
         assertArgsMatch<Type, std::initializer_list<int>, int&>(a);
     }

libcxx/test/std/utilities/any/any.class/any.modifiers/reset.pass.cpp

 #include <any>
 #include <cassert>
 
 #include "test_macros.h"
 #include "any_helpers.h"
 
 int main(int, char**)
 {
-    using std::any;
-    using std::any_cast;
     // empty
     {
-        any a;
-
-        // noexcept check
-        static_assert(
-            noexcept(a.reset())
-          , "any.reset() must be noexcept"
-          );
+        std::any a;
+        ASSERT_NOEXCEPT(a.reset());
 
         assertEmpty(a);
 
         a.reset();
 
         assertEmpty(a);
     }
     // small object
     {
-        any a((small(1)));
+        std::any a = small(1);
         assert(small::count == 1);
         assertContains<small>(a, 1);
 
         a.reset();
 
         assertEmpty<small>(a);
         assert(small::count == 0);
     }
     // large object
     {
-        any a(large(1));
+        std::any a = large(1);
         assert(large::count == 1);
         assertContains<large>(a, 1);
 
         a.reset();
 
         assertEmpty<large>(a);
         assert(large::count == 0);
     }
 
   return 0;
 }

libcxx/test/std/utilities/any/any.class/any.modifiers/swap.pass.cpp

 // Test swap(large, small) and swap(small, large)
 
 #include <any>
 #include <cassert>
 
 #include "test_macros.h"
 #include "any_helpers.h"
 
-using std::any;
-using std::any_cast;
-
 template <class LHS, class RHS>
 void test_swap() {
     assert(LHS::count == 0);
     assert(RHS::count == 0);
     {
-        any a1((LHS(1)));
-        any a2(RHS{2});
+        std::any a1 = LHS(1);
+        std::any a2 = RHS(2);
         assert(LHS::count == 1);
         assert(RHS::count == 1);
 
         a1.swap(a2);
 
         assert(LHS::count == 1);
         assert(RHS::count == 1);
 
         assertContains<RHS>(a1, 2);
         assertContains<LHS>(a2, 1);
     }
     assert(LHS::count == 0);
     assert(RHS::count == 0);
     assert(LHS::copied == 0);
     assert(RHS::copied == 0);
 }
 
 template <class Tp>
 void test_swap_empty() {
     assert(Tp::count == 0);
     {
-        any a1((Tp(1)));
-        any a2;
+        std::any a1 = Tp(1);
+        std::any a2;
         assert(Tp::count == 1);
 
         a1.swap(a2);
 
         assert(Tp::count == 1);
 
         assertContains<Tp>(a2, 1);
         assertEmpty(a1);
     }
     assert(Tp::count == 0);
     {
-        any a1((Tp(1)));
-        any a2;
+        std::any a1 = Tp(1);
+        std::any a2;
         assert(Tp::count == 1);
 
         a2.swap(a1);
 
         assert(Tp::count == 1);
 
         assertContains<Tp>(a2, 1);
         assertEmpty(a1);
     }
     assert(Tp::count == 0);
     assert(Tp::copied == 0);
 }
 
 void test_noexcept()
 {
-    any a1;
-    any a2;
-    static_assert(
-        noexcept(a1.swap(a2))
-      , "any::swap(any&) must be noexcept"
-      );
+    std::any a1;
+    std::any a2;
+    ASSERT_NOEXCEPT(a1.swap(a2));
 }
 
 void test_self_swap() {
     {
         // empty
-        any a;
+        std::any a;
         a.swap(a);
         assertEmpty(a);
     }
     { // small
         using T = small;
-        any a{T{42}};
+        std::any a = T(42);
         T::reset();
         a.swap(a);
         assertContains<T>(a, 42);
         assert(T::count == 1);
         assert(T::copied == 0);
         LIBCPP_ASSERT(T::moved == 0);
     }
     assert(small::count == 0);
     { // large
         using T = large;
-        any a{T{42}};
+        std::any a = T(42);
         T::reset();
         a.swap(a);
         assertContains<T>(a, 42);
         assert(T::count == 1);
         assert(T::copied == 0);
         LIBCPP_ASSERT(T::moved == 0);
     }
     assert(large::count == 0);

libcxx/test/std/utilities/any/any.class/any.observers/has_value.pass.cpp

 #include <any>
 #include <cassert>
 
 #include "test_macros.h"
 #include "any_helpers.h"
 
 int main(int, char**)
 {
-    using std::any;
-    // noexcept test
     {
-        any a;
-        static_assert(noexcept(a.has_value()), "any::has_value() must be noexcept");
+        std::any a;
+        ASSERT_NOEXCEPT(a.has_value());
     }
     // empty
     {
-        any a;
+        std::any a;
         assert(!a.has_value());
 
         a.reset();
         assert(!a.has_value());
 
         a = 42;
         assert(a.has_value());
     }
     // small object
     {
-        small const s(1);
-        any a(s);
+        std::any a = small(1);
         assert(a.has_value());
 
         a.reset();
         assert(!a.has_value());
 
-        a = s;
+        a = small(1);
         assert(a.has_value());
     }
     // large object
     {
-        large const l(1);
-        any a(l);
+        std::any a = large(1);
         assert(a.has_value());
 
         a.reset();
         assert(!a.has_value());
 
-        a = l;
+        a = large(1);
         assert(a.has_value());
     }
 
   return 0;
 }

libcxx/test/std/utilities/any/any.class/any.observers/type.pass.cpp

 #include <any>
 #include <cassert>
 
 #include "test_macros.h"
 #include "any_helpers.h"
 
 int main(int, char**)
 {
-    using std::any;
     {
-        any const a;
+        const std::any a;
         assert(a.type() == typeid(void));
         ASSERT_NOEXCEPT(a.type());
     }
     {
-        small const s(1);
-        any const a(s);
+        std::any a = small(1);
         assert(a.type() == typeid(small));
     }
     {
-        large const l(1);
-        any const a(l);
+        std::any a = large(1);
         assert(a.type() == typeid(large));
     }
     {
         int arr[3];
-        any const a(arr);
+        std::any a = arr;
         assert(a.type() == typeid(int*));  // ensure that it is decayed
     }
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_pointer.pass.cpp

 
 #include <any>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "any_helpers.h"
 
-using std::any;
-using std::any_cast;
-
 // Test that the operators are properly noexcept.
 void test_cast_is_noexcept() {
-    any a;
-    ASSERT_NOEXCEPT(any_cast<int>(&a));
+    std::any a;
+    ASSERT_NOEXCEPT(std::any_cast<int>(&a));
 
-    any const& ca = a;
-    ASSERT_NOEXCEPT(any_cast<int>(&ca));
+    const std::any& ca = a;
+    ASSERT_NOEXCEPT(std::any_cast<int>(&ca));
 }
 
 // Test that the return type of any_cast is correct.
 void test_cast_return_type() {
-    any a;
-    ASSERT_SAME_TYPE(decltype(any_cast<int>(&a)),       int*);
-    ASSERT_SAME_TYPE(decltype(any_cast<int const>(&a)), int const*);
-
-    any const& ca = a;
-    ASSERT_SAME_TYPE(decltype(any_cast<int>(&ca)),       int const*);
-    ASSERT_SAME_TYPE(decltype(any_cast<int const>(&ca)), int const*);
+    std::any a;
+    ASSERT_SAME_TYPE(decltype(std::any_cast<int>(&a)),       int*);
+    ASSERT_SAME_TYPE(decltype(std::any_cast<int const>(&a)), int const*);
+
+    const std::any& ca = a;
+    ASSERT_SAME_TYPE(decltype(std::any_cast<int>(&ca)),       int const*);
+    ASSERT_SAME_TYPE(decltype(std::any_cast<int const>(&ca)), int const*);
 }
 
 // Test that any_cast handles null pointers.
 void test_cast_nullptr() {
-    any* a = nullptr;
-    assert(nullptr == any_cast<int>(a));
-    assert(nullptr == any_cast<int const>(a));
-
-    any const* ca = nullptr;
-    assert(nullptr == any_cast<int>(ca));
-    assert(nullptr == any_cast<int const>(ca));
+    std::any *a = nullptr;
+    assert(nullptr == std::any_cast<int>(a));
+    assert(nullptr == std::any_cast<int const>(a));
+
+    const std::any *ca = nullptr;
+    assert(nullptr == std::any_cast<int>(ca));
+    assert(nullptr == std::any_cast<int const>(ca));
 }
 
 // Test casting an empty object.
 void test_cast_empty() {
     {
-        any a;
-        assert(nullptr == any_cast<int>(&a));
-        assert(nullptr == any_cast<int const>(&a));
-
-        any const& ca = a;
-        assert(nullptr == any_cast<int>(&ca));
-        assert(nullptr == any_cast<int const>(&ca));
+        std::any a;
+        assert(nullptr == std::any_cast<int>(&a));
+        assert(nullptr == std::any_cast<int const>(&a));
+
+        const std::any& ca = a;
+        assert(nullptr == std::any_cast<int>(&ca));
+        assert(nullptr == std::any_cast<int const>(&ca));
     }
     // Create as non-empty, then make empty and run test.
     {
-        any a(42);
+        std::any a(42);
         a.reset();
-        assert(nullptr == any_cast<int>(&a));
-        assert(nullptr == any_cast<int const>(&a));
+        assert(nullptr == std::any_cast<int>(&a));
+        assert(nullptr == std::any_cast<int const>(&a));
 
-        any const& ca = a;
-        assert(nullptr == any_cast<int>(&ca));
-        assert(nullptr == any_cast<int const>(&ca));
+        const std::any& ca = a;
+        assert(nullptr == std::any_cast<int>(&ca));
+        assert(nullptr == std::any_cast<int const>(&ca));
     }
 }
 
 template <class Type>
 void test_cast() {
     assert(Type::count == 0);
     Type::reset();
     {
-        any a((Type(42)));
-        any const& ca = a;
+        std::any a = Type(42);
+        const std::any& ca = a;
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 1);
 
         // Try a cast to a bad type.
         // NOTE: Type cannot be an int.
-        assert(any_cast<int>(&a) == nullptr);
-        assert(any_cast<int const>(&a) == nullptr);
-        assert(any_cast<int const volatile>(&a) == nullptr);
+        assert(std::any_cast<int>(&a) == nullptr);
+        assert(std::any_cast<int const>(&a) == nullptr);
+        assert(std::any_cast<int const volatile>(&a) == nullptr);
 
         // Try a cast to the right type, but as a pointer.
-        assert(any_cast<Type*>(&a) == nullptr);
-        assert(any_cast<Type const*>(&a) == nullptr);
+        assert(std::any_cast<Type*>(&a) == nullptr);
+        assert(std::any_cast<Type const*>(&a) == nullptr);
 
         // Check getting a unqualified type from a non-const any.
-        Type* v = any_cast<Type>(&a);
+        Type* v = std::any_cast<Type>(&a);
         assert(v != nullptr);
         assert(v->value == 42);
 
         // change the stored value and later check for the new value.
         v->value = 999;
 
         // Check getting a const qualified type from a non-const any.
-        Type const* cv = any_cast<Type const>(&a);
+        Type const* cv = std::any_cast<Type const>(&a);
         assert(cv != nullptr);
         assert(cv == v);
         assert(cv->value == 999);
 
         // Check getting a unqualified type from a const any.
-        cv = any_cast<Type>(&ca);
+        cv = std::any_cast<Type>(&ca);
         assert(cv != nullptr);
         assert(cv == v);
         assert(cv->value == 999);
 
         // Check getting a const-qualified type from a const any.
-        cv = any_cast<Type const>(&ca);
+        cv = std::any_cast<Type const>(&ca);
         assert(cv != nullptr);
         assert(cv == v);
         assert(cv->value == 999);
 
         // Check that no more objects were created, copied or moved.
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 1);

libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_reference.pass.cpp

 #include <any>
 #include <type_traits>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-using std::bad_any_cast;
-
-
 // Test that the operators are NOT marked noexcept.
 void test_cast_is_not_noexcept() {
-    any a;
-    static_assert(!noexcept(any_cast<int>(static_cast<any&>(a))), "");
-    static_assert(!noexcept(any_cast<int>(static_cast<any const&>(a))), "");
-    static_assert(!noexcept(any_cast<int>(static_cast<any &&>(a))), "");
+    std::any a;
+    static_assert(!noexcept(std::any_cast<int>(static_cast<std::any&>(a))), "");
+    static_assert(!noexcept(std::any_cast<int>(static_cast<std::any const&>(a))), "");
+    static_assert(!noexcept(std::any_cast<int>(static_cast<std::any &&>(a))), "");
 }
 
 // Test that the return type of any_cast is correct.
 void test_cast_return_type() {
-    any a;
-    static_assert(std::is_same<decltype(any_cast<int>(a)), int>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int const>(a)), int>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int&>(a)), int&>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int const&>(a)), int const&>::value, "");
-
-    static_assert(std::is_same<decltype(any_cast<int&&>(a)), int&&>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int const&&>(a)), int const&&>::value, "");
-
-    static_assert(std::is_same<decltype(any_cast<int>(std::move(a))), int>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int const>(std::move(a))), int>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int&>(std::move(a))), int&>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int const&>(std::move(a))), int const&>::value, "");
-
-    static_assert(std::is_same<decltype(any_cast<int&&>(std::move(a))), int&&>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int const&&>(std::move(a))), int const&&>::value, "");
-
-    any const& ca = a;
-    static_assert(std::is_same<decltype(any_cast<int>(ca)), int>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int const>(ca)), int>::value, "");
-    static_assert(std::is_same<decltype(any_cast<int const&>(ca)), int const&>::value, "");
-
-    static_assert(std::is_same<decltype(any_cast<int const&&>(ca)), int const&&>::value, "");
+    std::any a;
+    static_assert(std::is_same<decltype(std::any_cast<int>(a)), int>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const>(a)), int>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int&>(a)), int&>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const&>(a)), int const&>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int&&>(a)), int&&>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const&&>(a)), int const&&>::value, "");
+
+    static_assert(std::is_same<decltype(std::any_cast<int>(std::move(a))), int>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const>(std::move(a))), int>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int&>(std::move(a))), int&>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const&>(std::move(a))), int const&>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int&&>(std::move(a))), int&&>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const&&>(std::move(a))), int const&&>::value, "");
+
+    const std::any& ca = a;
+    static_assert(std::is_same<decltype(std::any_cast<int>(ca)), int>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const>(ca)), int>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const&>(ca)), int const&>::value, "");
+    static_assert(std::is_same<decltype(std::any_cast<int const&&>(ca)), int const&&>::value, "");
 }
 
 template <class Type, class ConstT = Type>
-void checkThrows(any& a)
+void checkThrows(std::any& a)
 {
 #if !defined(TEST_HAS_NO_EXCEPTIONS)
     try {
-        TEST_IGNORE_NODISCARD any_cast<Type>(a);
+        TEST_IGNORE_NODISCARD std::any_cast<Type>(a);
         assert(false);
-    } catch (bad_any_cast const &) {
-            // do nothing
+    } catch (const std::bad_any_cast&) {
     } catch (...) {
         assert(false);
     }
 
     try {
-        TEST_IGNORE_NODISCARD any_cast<ConstT>(static_cast<any const&>(a));
+        TEST_IGNORE_NODISCARD std::any_cast<ConstT>(static_cast<const std::any&>(a));
         assert(false);
-    } catch (bad_any_cast const &) {
-            // do nothing
+    } catch (const std::bad_any_cast&) {
     } catch (...) {
         assert(false);
     }
 
     try {
         using RefType = typename std::conditional<
             std::is_lvalue_reference<Type>::value,
             typename std::remove_reference<Type>::type&&,
             Type
         >::type;
-        TEST_IGNORE_NODISCARD any_cast<RefType>(static_cast<any&&>(a));
+        TEST_IGNORE_NODISCARD std::any_cast<RefType>(static_cast<std::any&&>(a));
         assert(false);
-    } catch (bad_any_cast const &) {
+    } catch (const std::bad_any_cast&) {
             // do nothing
     } catch (...) {
         assert(false);
     }
 #else
     (TEST_IGNORE_NODISCARD a);
 #endif
 }
 
 void test_cast_empty() {
     // None of these operations should allocate.
     DisableAllocationGuard g; (TEST_IGNORE_NODISCARD g);
-    any a;
+    std::any a;
     checkThrows<int>(a);
 }
 
 template <class Type>
 void test_cast_to_reference() {
     assert(Type::count == 0);
     Type::reset();
     {
-        any a((Type(42)));
-        any const& ca = a;
+        std::any a = Type(42);
+        const std::any& ca = a;
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 1);
 
         // Try a cast to a bad type.
         // NOTE: Type cannot be an int.
         checkThrows<int>(a);
         checkThrows<int&, int const&>(a);
         checkThrows<Type*, Type const*>(a);
         checkThrows<Type const*>(a);
 
         // Check getting a type by reference from a non-const lvalue any.
         {
-            Type& v = any_cast<Type&>(a);
+            Type& v = std::any_cast<Type&>(a);
             assert(v.value == 42);
 
-            Type const &cv = any_cast<Type const&>(a);
+            Type const &cv = std::any_cast<Type const&>(a);
             assert(&cv == &v);
         }
         // Check getting a type by reference from a const lvalue any.
         {
-            Type const& v = any_cast<Type const&>(ca);
+            Type const& v = std::any_cast<Type const&>(ca);
             assert(v.value == 42);
 
-            Type const &cv = any_cast<Type const&>(ca);
+            Type const &cv = std::any_cast<Type const&>(ca);
             assert(&cv == &v);
         }
         // Check getting a type by reference from a const rvalue any.
         {
-            Type const& v = any_cast<Type const&>(std::move(ca));
+            Type const& v = std::any_cast<Type const&>(std::move(ca));
             assert(v.value == 42);
 
-            Type const &cv = any_cast<Type const&>(std::move(ca));
+            Type const &cv = std::any_cast<Type const&>(std::move(ca));
             assert(&cv == &v);
         }
         // Check getting a type by reference from a const rvalue any.
         {
-            Type&& v = any_cast<Type&&>(std::move(a));
+            Type&& v = std::any_cast<Type&&>(std::move(a));
             assert(v.value == 42);
-            assert(any_cast<Type&>(a).value == 42);
+            assert(std::any_cast<Type&>(a).value == 42);
 
-            Type&& cv = any_cast<Type&&>(std::move(a));
+            Type&& cv = std::any_cast<Type&&>(std::move(a));
             assert(&cv == &v);
-            assert(any_cast<Type&>(a).value == 42);
+            assert(std::any_cast<Type&>(a).value == 42);
         }
         // Check getting a type by reference from a const rvalue any.
         {
-            Type const&& v = any_cast<Type const&&>(std::move(a));
+            Type const&& v = std::any_cast<Type const&&>(std::move(a));
             assert(v.value == 42);
-            assert(any_cast<Type&>(a).value == 42);
+            assert(std::any_cast<Type&>(a).value == 42);
 
-            Type const&& cv = any_cast<Type const&&>(std::move(a));
+            Type const&& cv = std::any_cast<Type const&&>(std::move(a));
             assert(&cv == &v);
-            assert(any_cast<Type&>(a).value == 42);
+            assert(std::any_cast<Type&>(a).value == 42);
         }
         // Check that the original object hasn't been changed.
         assertContains<Type>(a, 42);
 
         // Check that no objects have been created/copied/moved.
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 1);
     }
     assert(Type::count == 0);
 }
 
 template <class Type>
 void test_cast_to_value() {
     assert(Type::count == 0);
     Type::reset();
     {
-        any a((Type(42)));
+        std::any a = Type(42);
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 1);
 
         // Try a cast to a bad type.
         // NOTE: Type cannot be an int.
         checkThrows<int>(a);
         checkThrows<int&, int const&>(a);
         checkThrows<Type*, Type const*>(a);
         checkThrows<Type const*>(a);
 
         Type::reset(); // NOTE: reset does not modify Type::count
         // Check getting Type by value from a non-const lvalue any.
         // This should cause the non-const copy constructor to be called.
         {
-            Type t = any_cast<Type>(a);
+            Type t = std::any_cast<Type>(a);
 
             assert(Type::count == 2);
             assert(Type::copied == 1);
             assert(Type::const_copied == 0);
             assert(Type::non_const_copied == 1);
             assert(Type::moved == 0);
             assert(t.value == 42);
         }
         assert(Type::count == 1);
         Type::reset();
         // Check getting const Type by value from a non-const lvalue any.
         // This should cause the const copy constructor to be called.
         {
-            Type t = any_cast<Type const>(a);
+            Type t = std::any_cast<Type const>(a);
 
             assert(Type::count == 2);
             assert(Type::copied == 1);
             assert(Type::const_copied == 0);
             assert(Type::non_const_copied == 1);
             assert(Type::moved == 0);
             assert(t.value == 42);
         }
         assert(Type::count == 1);
         Type::reset();
         // Check getting Type by value from a non-const lvalue any.
         // This should cause the const copy constructor to be called.
         {
-            Type t = any_cast<Type>(static_cast<any const&>(a));
+            Type t = std::any_cast<Type>(static_cast<const std::any&>(a));
 
             assert(Type::count == 2);
             assert(Type::copied == 1);
             assert(Type::const_copied == 1);
             assert(Type::non_const_copied == 0);
             assert(Type::moved == 0);
             assert(t.value == 42);
         }
         assert(Type::count == 1);
         Type::reset();
         // Check getting Type by value from a non-const rvalue any.
         // This should cause the non-const copy constructor to be called.
         {
-            Type t = any_cast<Type>(static_cast<any &&>(a));
+            Type t = std::any_cast<Type>(static_cast<std::any&&>(a));
 
             assert(Type::count == 2);
             assert(Type::moved == 1);
             assert(Type::copied == 0);
             assert(Type::const_copied == 0);
             assert(Type::non_const_copied == 0);
             assert(t.value == 42);
-            assert(any_cast<Type&>(a).value == 0);
-            any_cast<Type&>(a).value = 42; // reset the value
+            assert(std::any_cast<Type&>(a).value == 0);
+            std::any_cast<Type&>(a).value = 42; // reset the value
         }
         assert(Type::count == 1);
         Type::reset();
         // Check getting const Type by value from a non-const rvalue any.
         // This should cause the const copy constructor to be called.
         {
-            Type t = any_cast<Type const>(static_cast<any &&>(a));
+            Type t = std::any_cast<Type const>(static_cast<std::any&&>(a));
 
             assert(Type::count == 2);
             assert(Type::copied == 0);
             assert(Type::const_copied == 0);
             assert(Type::non_const_copied == 0);
             assert(Type::moved == 1);
             assert(t.value == 42);
-            assert(any_cast<Type&>(a).value == 0);
-            any_cast<Type&>(a).value = 42; // reset the value
+            assert(std::any_cast<Type&>(a).value == 0);
+            std::any_cast<Type&>(a).value = 42; // reset the value
         }
         assert(Type::count == 1);
         Type::reset();
         // Check getting Type by value from a const rvalue any.
         // This should cause the const copy constructor to be called.
         {
-            Type t = any_cast<Type>(static_cast<any const&&>(a));
+            Type t = std::any_cast<Type>(static_cast<const std::any&&>(a));
 
             assert(Type::count == 2);
             assert(Type::copied == 1);
             assert(Type::const_copied == 1);
             assert(Type::non_const_copied == 0);
             assert(Type::moved == 0);
             assert(t.value == 42);
-            assert(any_cast<Type&>(a).value == 42);
+            assert(std::any_cast<Type&>(a).value == 42);
         }
         // Ensure we still only have 1 Type object alive.
         assert(Type::count == 1);
 
         // Check that the original object hasn't been changed.
         assertContains<Type>(a, 42);
     }
     assert(Type::count == 0);

libcxx/test/std/utilities/any/any.nonmembers/any.cast/any_cast_request_invalid_value_category.fail.cpp

 // template <class ValueType>
 // ValueType any_cast(any &&);
 
 // Try and use the rvalue any_cast to cast to an lvalue reference
 
 #include <any>
 
 struct TestType {};
-using std::any;
-using std::any_cast;
 
 void test_const_lvalue_cast_request_non_const_lvalue()
 {
-    const any a;
+    const std::any a;
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{drops 'const' qualifier}}
-    any_cast<TestType &>(a); // expected-note {{requested here}}
+    std::any_cast<TestType &>(a); // expected-note {{requested here}}
 
-    const any a2(42);
+    const std::any a2(42);
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{drops 'const' qualifier}}
-    any_cast<int&>(a2); // expected-note {{requested here}}
+    std::any_cast<int&>(a2); // expected-note {{requested here}}
 }
 
 void test_lvalue_any_cast_request_rvalue()
 {
-    any a;
+    std::any a;
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
-    any_cast<TestType &&>(a); // expected-note {{requested here}}
+    std::any_cast<TestType &&>(a); // expected-note {{requested here}}
 
-    any a2(42);
+    std::any a2(42);
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
-    any_cast<int&&>(a2); // expected-note {{requested here}}
+    std::any_cast<int&&>(a2); // expected-note {{requested here}}
 }
 
 void test_rvalue_any_cast_request_lvalue()
 {
-    any a;
+    std::any a;
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{non-const lvalue reference to type 'TestType' cannot bind to a temporary}}
-    any_cast<TestType &>(std::move(a)); // expected-note {{requested here}}
+    std::any_cast<TestType &>(std::move(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
     // expected-error@any:* {{non-const lvalue reference to type 'int' cannot bind to a temporary}}
-    any_cast<int&>(42);
+    std::any_cast<int&>(42);
 }
 
 int main(int, char**)
 {
     test_const_lvalue_cast_request_non_const_lvalue();
     test_lvalue_any_cast_request_rvalue();
     test_rvalue_any_cast_request_lvalue();
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/const_correctness.verify.cpp

 
 #include <any>
 
 struct TestType {};
 struct TestType2 {};
 
 int main(int, char**)
 {
-    using std::any;
-    using std::any_cast;
-
-    any a;
+    std::any a;
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
-    any_cast<TestType &>(static_cast<any const&>(a)); // expected-note {{requested here}}
+    std::any_cast<TestType &>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
-    any_cast<TestType &&>(static_cast<any const&>(a)); // expected-note {{requested here}}
+    std::any_cast<TestType &&>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
-    any_cast<TestType2 &>(static_cast<any const&&>(a)); // expected-note {{requested here}}
+    std::any_cast<TestType2 &>(static_cast<std::any const&&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
-    any_cast<TestType2 &&>(static_cast<any const&&>(a)); // expected-note {{requested here}}
+    std::any_cast<TestType2 &&>(static_cast<std::any const&&>(a)); // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/not_copy_constructible.verify.cpp

 // constraints are not respected, however Clang will sometimes emit
 // additional errors while trying to instantiate the rest of any_cast
 // following the static_assert. We ignore unexpected errors in
 // clang-verify to make the test more robust to changes in Clang.
 // ADDITIONAL_COMPILE_FLAGS: -Xclang -verify-ignore-unexpected=error
 
 #include <any>
 
-using std::any;
-using std::any_cast;
-
 struct no_copy
 {
     no_copy() {}
     no_copy(no_copy &&) {}
     no_copy(no_copy const &) = delete;
 };
 
 struct no_move {
   no_move() {}
   no_move(no_move&&) = delete;
   no_move(no_move const&) {}
 };
 
 int main(int, char**) {
-    any a;
+    std::any a;
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an lvalue reference or a CopyConstructible type"}}
-    any_cast<no_copy>(static_cast<any&>(a)); // expected-note {{requested here}}
+    std::any_cast<no_copy>(static_cast<std::any&>(a)); // expected-note {{requested here}}
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be a const lvalue reference or a CopyConstructible type"}}
-    any_cast<no_copy>(static_cast<any const&>(a)); // expected-note {{requested here}}
+    std::any_cast<no_copy>(static_cast<std::any const&>(a)); // expected-note {{requested here}}
 
-    any_cast<no_copy>(static_cast<any &&>(a)); // OK
+    std::any_cast<no_copy>(static_cast<std::any &&>(a)); // OK
 
     // expected-error-re@any:* {{static_assert failed{{.*}} "ValueType is required to be an rvalue reference or a CopyConstructible type"}}
-    any_cast<no_move>(static_cast<any &&>(a));
+    std::any_cast<no_move>(static_cast<std::any &&>(a));
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/any.cast/reference_types.fail.cpp

 // template <class ValueType>
 // ValueType const* any_cast(any const *) noexcept;
 //
 // template <class ValueType>
 // ValueType * any_cast(any *) noexcept;
 
 #include <any>
 
-using std::any;
-using std::any_cast;
-
 int main(int, char**)
 {
-    any a(1);
+    std::any a = 1;
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
-    any_cast<int &>(&a); // expected-note {{requested here}}
+    std::any_cast<int &>(&a); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
-    any_cast<int &&>(&a); // expected-note {{requested here}}
+    std::any_cast<int &&>(&a); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
-    any_cast<int const &>(&a); // expected-note {{requested here}}
+    std::any_cast<int const &>(&a); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
-    any_cast<int const&&>(&a); // expected-note {{requested here}}
+    std::any_cast<int const&&>(&a); // expected-note {{requested here}}
 
-    any const& a2 = a;
+    const std::any& a2 = a;
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
-    any_cast<int &>(&a2); // expected-note {{requested here}}
+    std::any_cast<int &>(&a2); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
-    any_cast<int &&>(&a2); // expected-note {{requested here}}
+    std::any_cast<int &&>(&a2); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
-    any_cast<int const &>(&a2); // expected-note {{requested here}}
+    std::any_cast<int const &>(&a2); // expected-note {{requested here}}
 
     // expected-error-re@any:* 1 {{static_assert failed{{.*}} "_ValueType may not be a reference."}}
-    any_cast<int const &&>(&a2); // expected-note {{requested here}}
+    std::any_cast<int const &&>(&a2); // expected-note {{requested here}}
 
   return 0;
 }

libcxx/test/std/utilities/any/any.nonmembers/make_any.pass.cpp

 
 #include <any>
 #include <cassert>
 
 #include "any_helpers.h"
 #include "count_new.h"
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
-
 template <class Type>
 void test_make_any_type() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     assert(Type::count == 0);
     Type::reset();
     {
-        any a = std::make_any<Type>();
+        std::any a = std::make_any<Type>();
 
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 0);
     }
     assert(Type::count == 0);
     Type::reset();
     {
-        any a = std::make_any<Type>(101);
+        std::any a = std::make_any<Type>(101);
 
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 101);
     }
     assert(Type::count == 0);
     Type::reset();
     {
-        any a = std::make_any<Type>(-1, 42, -1);
+        std::any a = std::make_any<Type>(-1, 42, -1);
 
         assert(Type::count == 1);
         assert(Type::copied == 0);
         assert(Type::moved == 0);
         assertContains<Type>(a, 42);
     }
     assert(Type::count == 0);
     Type::reset();
 }
 
 template <class Type>
 void test_make_any_type_tracked() {
     // constructing from a small type should perform no allocations.
     DisableAllocationGuard g(isSmallType<Type>()); ((void)g);
     {
-        any a = std::make_any<Type>();
+        std::any a = std::make_any<Type>();
         assertArgsMatch<Type>(a);
     }
     {
-        any a = std::make_any<Type>(-1, 42, -1);
+        std::any a = std::make_any<Type>(-1, 42, -1);
         assertArgsMatch<Type, int, int, int>(a);
     }
     // initializer_list constructor tests
     {
-        any a = std::make_any<Type>({-1, 42, -1});
+        std::any a = std::make_any<Type>({-1, 42, -1});
         assertArgsMatch<Type, std::initializer_list<int>>(a);
     }
     {
         int x = 42;
-        any a  = std::make_any<Type>({-1, 42, -1}, x);
+        std::any a  = std::make_any<Type>({-1, 42, -1}, x);
         assertArgsMatch<Type, std::initializer_list<int>, int&>(a);
     }
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 
 struct SmallThrows {
   SmallThrows(int) { throw 42; }

libcxx/test/std/utilities/any/any.nonmembers/swap.pass.cpp

 
 // swap(...) just wraps any::swap(...). That function is tested elsewhere.
 
 #include <any>
 #include <cassert>
 
 #include "test_macros.h"
 
-using std::any;
-using std::any_cast;
-
 int main(int, char**)
 {
 
     { // test noexcept
-        any a;
+        std::any a;
         static_assert(noexcept(swap(a, a)), "swap(any&, any&) must be noexcept");
     }
     {
-        any a1(1);
-        any a2(2);
+        std::any a1 = 1;
+        std::any a2 = 2;
 
         swap(a1, a2);
 
-        assert(any_cast<int>(a1) == 2);
-        assert(any_cast<int>(a2) == 1);
+        assert(std::any_cast<int>(a1) == 2);
+        assert(std::any_cast<int>(a2) == 1);
     }
 
   return 0;
 }