Implement LWG2577: {shared,unique}_lock</tt> should use std::addressof

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@263506 91177308-0d34-0410-b5e6-96231b3b80d8

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_assign.pass.cpp

@@ -18,17 +18,33 @@
 
 #include <shared_mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
-std::shared_timed_mutex m0;
-std::shared_timed_mutex m1;
 
 int main()
 {
-    std::shared_lock<std::shared_timed_mutex> lk0(m0);
-    std::shared_lock<std::shared_timed_mutex> lk1(m1);
+    {
+    typedef std::shared_timed_mutex M;
+	M m0;
+	M m1;
+    std::shared_lock<M> lk0(m0);
+    std::shared_lock<M> lk1(m1);
     lk1 = std::move(lk0);
-    assert(lk1.mutex() == &m0);
+    assert(lk1.mutex() == std::addressof(m0));
     assert(lk1.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+	M m0;
+	M m1;
+    std::shared_lock<M> lk0(m0);
+    std::shared_lock<M> lk1(m1);
+    lk1 = std::move(lk0);
+    assert(lk1.mutex() == std::addressof(m0));
+    assert(lk1.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/move_ctor.pass.cpp

@@ -18,14 +18,28 @@
 
 #include <shared_mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::shared_timed_mutex m;
-    std::shared_lock<std::shared_timed_mutex> lk0(m);
-    std::shared_lock<std::shared_timed_mutex> lk = std::move(lk0);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    std::shared_lock<M> lk0(m);
+    std::shared_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::shared_lock<M> lk0(m);
+    std::shared_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_adopt_lock.pass.cpp

@@ -18,12 +18,24 @@
 
 #include <shared_mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::shared_timed_mutex m;
-    m.lock_shared();
-    std::shared_lock<std::shared_timed_mutex> lk(m, std::adopt_lock);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    m.lock();
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    m.lock();
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    }
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.shared/thread.lock.shared.cons/mutex_defer_lock.pass.cpp

@@ -18,11 +18,22 @@
 
 #include <shared_mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::shared_timed_mutex m;
-    std::shared_lock<std::shared_timed_mutex> lk(m, std::defer_lock);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::shared_timed_mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == false);
+    }
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_assign.fail.cpp

@@ -16,16 +16,18 @@
 #include <mutex>
 #include <cassert>
 
-std::mutex m0;
-std::mutex m1;
-
 int main()
 {
-    std::unique_lock<std::mutex> lk0(m0);
-    std::unique_lock<std::mutex> lk1(m1);
+    {
+    typedef std::mutex M;
+	M m0;
+	M m1;
+    std::unique_lock<M> lk0(m0);
+    std::unique_lock<M> lk1(m1);
     lk1 = lk0;
     assert(lk1.mutex() == &m0);
     assert(lk1.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/copy_ctor.fail.cpp

@@ -16,14 +16,16 @@
 #include <mutex>
 #include <cassert>
 
-std::mutex m;
-
 int main()
 {
-    std::unique_lock<std::mutex> lk0(m);
-    std::unique_lock<std::mutex> lk = lk0;
+    {
+    typedef std::mutex M;
+    M m;
+    std::unique_lock<M> lk0(m);
+    std::unique_lock<M> lk = lk0;
     assert(lk.mutex() == &m);
     assert(lk.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_assign.pass.cpp

@@ -17,19 +17,34 @@
 
 #include <mutex>
 #include <cassert>
-
-std::mutex m0;
-std::mutex m1;
+#include "nasty_containers.hpp"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    std::unique_lock<std::mutex> lk0(m0);
-    std::unique_lock<std::mutex> lk1(m1);
+    {
+    typedef std::mutex M;
+	M m0;
+	M m1;
+    std::unique_lock<M> lk0(m0);
+    std::unique_lock<M> lk1(m1);
     lk1 = std::move(lk0);
-    assert(lk1.mutex() == &m0);
+    assert(lk1.mutex() == std::addressof(m0));
     assert(lk1.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+	M m0;
+	M m1;
+    std::unique_lock<M> lk0(m0);
+    std::unique_lock<M> lk1(m1);
+    lk1 = std::move(lk0);
+    assert(lk1.mutex() == std::addressof(m0));
+    assert(lk1.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/move_ctor.pass.cpp

@@ -17,17 +17,30 @@
 
 #include <mutex>
 #include <cassert>
-
-std::mutex m;
+#include "nasty_containers.hpp"
 
 int main()
 {
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    std::unique_lock<std::mutex> lk0(m);
-    std::unique_lock<std::mutex> lk = std::move(lk0);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::mutex M;
+    M m;
+    std::unique_lock<M> lk0(m);
+    std::unique_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
     assert(lk0.mutex() == nullptr);
     assert(lk0.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::unique_lock<M> lk0(m);
+    std::unique_lock<M> lk = std::move(lk0);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    assert(lk0.mutex() == nullptr);
+    assert(lk0.owns_lock() == false);
+    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_adopt_lock.pass.cpp

@@ -17,12 +17,24 @@
 
 #include <mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::mutex m;
+    {
+    typedef std::mutex M;
+    M m;
     m.lock();
-    std::unique_lock<std::mutex> lk(m, std::adopt_lock);
-    assert(lk.mutex() == &m);
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == true);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    m.lock();
+    std::unique_lock<M> lk(m, std::adopt_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == true);
+    }
 }

test/std/thread/thread.mutex/thread.lock/thread.lock.unique/thread.lock.unique.cons/mutex_defer_lock.pass.cpp

@@ -17,11 +17,22 @@
 
 #include <mutex>
 #include <cassert>
+#include "nasty_containers.hpp"
 
 int main()
 {
-    std::mutex m;
-    std::unique_lock<std::mutex> lk(m, std::defer_lock);
-    assert(lk.mutex() == &m);
+    {
+    typedef std::mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
     assert(lk.owns_lock() == false);
+    }
+    {
+    typedef nasty_mutex M;
+    M m;
+    std::unique_lock<M> lk(m, std::defer_lock);
+    assert(lk.mutex() == std::addressof(m));
+    assert(lk.owns_lock() == false);
+    }
 }