[libc++][test] Silence MSVC deprecation warnings

[CaseyCarter]

Summary

... for implicitly-generated copy constructors and copy assignment operators.

[Mordante]

Thanks, LGTM!

[philnik]

I think clang also has a deprecation flag for this. Please enable it, so we don't regress.

[fsb4000]

Thanks @philnik , I found the warning: -Wdeprecated-copy-with-user-provided-dtor: https://godbolt.org/z/rr186sGYK

Oh, I read https://github.com/llvm/llvm-project/issues/60977 and check that -Wdeprecated also works.

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"
 
 struct Tracked {
     static int count;
-  Tracked()  {++count;}
+    Tracked() { ++count; }
+    Tracked(Tracked const&) noexcept { ++count; }
+    Tracked& operator=(Tracked const&) = default;
     ~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);

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/emplace.pass.cpp

 };
 
 class Y
 {
 public:
     static bool dtor_called;
     Y() = default;
     Y(int) { TEST_THROW(6);}
+    Y(const Y&) = default;
+    Y& operator=(const Y&) = default;
     ~Y() {dtor_called = true;}
 };
 
 bool Y::dtor_called = false;
 
 template <class T>
 constexpr bool test_one_arg() {
     using Opt = std::optional<T>;

libcxx/test/std/utilities/optional/optional.object/optional.object.assign/emplace_initializer_list.pass.cpp

class X
     int i_;
     int j_ = 0;
     bool* dtor_called_;
 public:
     constexpr X(bool& dtor_called) : i_(0), dtor_called_(&dtor_called) {}
     constexpr X(int i, bool& dtor_called) : i_(i), dtor_called_(&dtor_called) {}
     constexpr X(std::initializer_list<int> il, bool& dtor_called)
     : i_(il.begin()[0]), j_(il.begin()[1]), dtor_called_(&dtor_called) {}
+    X(const X&) = default;
+    X& operator=(const X&) = default;
     TEST_CONSTEXPR_CXX20 ~X() {*dtor_called_ = true;}
 
     friend constexpr bool operator==(const X& x, const X& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 class Y
 {
class Z
     int i_;
     int j_ = 0;
 public:
     static bool dtor_called;
     Z() : i_(0) {}
     Z(int i) : i_(i) {}
     Z(std::initializer_list<int> il) : i_(il.begin()[0]), j_(il.begin()[1])
         { TEST_THROW(6);}
+    Z(const Z&) = default;
+    Z& operator=(const Z&) = default;
     ~Z() {dtor_called = true;}
 
     friend bool operator==(const Z& x, const Z& y)
         {return x.i_ == y.i_ && x.j_ == y.j_;}
 };
 
 bool Z::dtor_called = false;
 

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

struct PODType {
   int value2;
 };
 
 class X
 {
 public:
     static bool dtor_called;
     X() = default;
+    X(const X&) = default;
+    X& operator=(const X&) = default;
     ~X() {dtor_called = true;}
 };
 
 bool X::dtor_called = false;
 
 int main(int, char**)
 {
     {

libcxx/test/std/utilities/optional/optional.object/optional.object.mod/reset.pass.cpp

 
 #include "test_macros.h"
 
 using std::optional;
 
 struct X
 {
     static bool dtor_called;
+    X() = default;
+    X(const X&) = default;
+    X& operator=(const X&) = default;
     ~X() {dtor_called = true;}
 };
 
 bool X::dtor_called = false;
 
 constexpr bool check_reset()
 {
     {