Changes to satisfy GCC's -Wdeprecated-copy in the test suite.

* Add the missing of copy constructor or copy assignment operator to all
classes GCC complains about in the warning, for C++11 only (since the
deprecation is C++11 and up), with the default meaning that they had
since forever.
* Add missing move operations to cuda::vector (how did *that* happen?).

Bug 200582781

Reviewed-by: Bryce Adelstein Lelbach aka wash <brycelelbach@gmail.com>

Author: griwes

examples/scan_matrix_by_rows.cu

@@ -1,5 +1,6 @@
 #include <thrust/device_vector.h>
 #include <thrust/scan.h>
+#include <thrust/sequence.h>
 #include <thrust/iterator/transform_iterator.h>
 #include <thrust/iterator/counting_iterator.h>
 
@@ -20,7 +21,7 @@ void scan_matrix_by_rows0(thrust::device_vector<int>& u, int n, int m) {
 
 // We can batch the operation using `thrust::inclusive_scan_by_key`, which
 // scans each group of consecutive equal keys. All we need to do is generate
-// the right key sequence. We want the keys for elements on the same row to 
+// the right key sequence. We want the keys for elements on the same row to
 // be identical.
 
 // So first, we define an unary function object which takes the index of an

examples/uninitialized_vector.cu

@@ -29,6 +29,10 @@ template<typename T>
   __host__
   ~uninitialized_allocator() {}
 
+#if THRUST_CPP_DIALECT >= 2011
+  uninitialized_allocator & operator=(const uninitialized_allocator &) = default;
+#endif
+
   // for correctness, you should also redefine rebind when you inherit
   // from an allocator type; this way, if the allocator is rebound somewhere,
   // it's going to be rebound to the correct type - and not to its base

testing/fill.cu

@@ -22,25 +22,25 @@ void TestFillSimple(void)
     ASSERT_EQUAL(v[2], 7);
     ASSERT_EQUAL(v[3], 7);
     ASSERT_EQUAL(v[4], 4);
-    
+
     thrust::fill(v.begin() + 0, v.begin() + 3, (T) 8);
-    
+
     ASSERT_EQUAL(v[0], 8);
     ASSERT_EQUAL(v[1], 8);
     ASSERT_EQUAL(v[2], 8);
     ASSERT_EQUAL(v[3], 7);
     ASSERT_EQUAL(v[4], 4);
-    
+
     thrust::fill(v.begin() + 2, v.end(), (T) 9);
-    
+
     ASSERT_EQUAL(v[0], 8);
     ASSERT_EQUAL(v[1], 8);
     ASSERT_EQUAL(v[2], 9);
     ASSERT_EQUAL(v[3], 9);
     ASSERT_EQUAL(v[4], 9);
 
     thrust::fill(v.begin(), v.end(), (T) 1);
-    
+
     ASSERT_EQUAL(v[0], 1);
     ASSERT_EQUAL(v[1], 1);
     ASSERT_EQUAL(v[2], 1);
@@ -70,14 +70,14 @@ void TestFillMixedTypes(void)
     Vector v(4);
 
     thrust::fill(v.begin(), v.end(), bool(true));
-    
+
     ASSERT_EQUAL(v[0], 1);
     ASSERT_EQUAL(v[1], 1);
     ASSERT_EQUAL(v[2], 1);
     ASSERT_EQUAL(v[3], 1);
-    
+
     thrust::fill(v.begin(), v.end(), char(20));
-    
+
     ASSERT_EQUAL(v[0], 20);
     ASSERT_EQUAL(v[1], 20);
     ASSERT_EQUAL(v[2], 20);
@@ -101,17 +101,17 @@ void TestFill(size_t n)
     thrust::fill(d_data.begin() + std::min((size_t)117, n), d_data.begin() + std::min((size_t)367, n), (T) 1);
 
     ASSERT_EQUAL(h_data, d_data);
-    
+
     thrust::fill(h_data.begin() + std::min((size_t)8, n), h_data.begin() + std::min((size_t)259, n), (T) 2);
     thrust::fill(d_data.begin() + std::min((size_t)8, n), d_data.begin() + std::min((size_t)259, n), (T) 2);
 
     ASSERT_EQUAL(h_data, d_data);
-    
+
     thrust::fill(h_data.begin() + std::min((size_t)3, n), h_data.end(), (T) 3);
     thrust::fill(d_data.begin() + std::min((size_t)3, n), d_data.end(), (T) 3);
 
     ASSERT_EQUAL(h_data, d_data);
-    
+
     thrust::fill(h_data.begin(), h_data.end(), (T) 4);
     thrust::fill(d_data.begin(), d_data.end(), (T) 4);
 
@@ -135,18 +135,18 @@ void TestFillNSimple(void)
     ASSERT_EQUAL(v[3], 7);
     ASSERT_EQUAL(v[4], 4);
     ASSERT_EQUAL_QUIET(v.begin() + 4, iter);
-    
+
     iter = thrust::fill_n(v.begin() + 0, 3, (T) 8);
-    
+
     ASSERT_EQUAL(v[0], 8);
     ASSERT_EQUAL(v[1], 8);
     ASSERT_EQUAL(v[2], 8);
     ASSERT_EQUAL(v[3], 7);
     ASSERT_EQUAL(v[4], 4);
     ASSERT_EQUAL_QUIET(v.begin() + 3, iter);
-    
+
     iter = thrust::fill_n(v.begin() + 2, 3, (T) 9);
-    
+
     ASSERT_EQUAL(v[0], 8);
     ASSERT_EQUAL(v[1], 8);
     ASSERT_EQUAL(v[2], 9);
@@ -155,7 +155,7 @@ void TestFillNSimple(void)
     ASSERT_EQUAL_QUIET(v.end(), iter);
 
     iter = thrust::fill_n(v.begin(), v.size(), (T) 1);
-    
+
     ASSERT_EQUAL(v[0], 1);
     ASSERT_EQUAL(v[1], 1);
     ASSERT_EQUAL(v[2], 1);
@@ -192,15 +192,15 @@ void TestFillNMixedTypes(void)
     Vector v(4);
 
     typename Vector::iterator iter = thrust::fill_n(v.begin(), v.size(), bool(true));
-    
+
     ASSERT_EQUAL(v[0], 1);
     ASSERT_EQUAL(v[1], 1);
     ASSERT_EQUAL(v[2], 1);
     ASSERT_EQUAL(v[3], 1);
     ASSERT_EQUAL_QUIET(v.end(), iter);
-    
+
     iter = thrust::fill_n(v.begin(), v.size(), char(20));
-    
+
     ASSERT_EQUAL(v[0], 20);
     ASSERT_EQUAL(v[1], 20);
     ASSERT_EQUAL(v[2], 20);
@@ -227,19 +227,19 @@ void TestFillN(size_t n)
     thrust::fill_n(d_data.begin() + begin_offset, std::min((size_t)367, n) - begin_offset, (T) 1);
 
     ASSERT_EQUAL(h_data, d_data);
-    
+
     begin_offset = std::min<size_t>(8, n);
     thrust::fill_n(h_data.begin() + begin_offset, std::min((size_t)259, n) - begin_offset, (T) 2);
     thrust::fill_n(d_data.begin() + begin_offset, std::min((size_t)259, n) - begin_offset, (T) 2);
 
     ASSERT_EQUAL(h_data, d_data);
-    
+
     begin_offset = std::min<size_t>(3, n);
     thrust::fill_n(h_data.begin() + begin_offset, h_data.size() - begin_offset, (T) 3);
     thrust::fill_n(d_data.begin() + begin_offset, d_data.size() - begin_offset, (T) 3);
 
     ASSERT_EQUAL(h_data, d_data);
-    
+
     thrust::fill_n(h_data.begin(), h_data.size(), (T) 4);
     thrust::fill_n(d_data.begin(), d_data.size(), (T) 4);
 
@@ -301,7 +301,7 @@ void TestFillWithTrivialAssignment(void)
 
     thrust::host_vector<T>   h(1);
     thrust::device_vector<T> d(1);
-    
+
     ASSERT_EQUAL(h[0].x, 0);
     ASSERT_EQUAL(h[0].y, 0);
     ASSERT_EQUAL(h[0].z, 0);
@@ -334,6 +334,10 @@ struct TypeWithNonTrivialAssigment
   __host__ __device__
   TypeWithNonTrivialAssigment() : x(0), y(0), z(0) {}
 
+#if THRUST_CPP_DIALECT >= 2011
+  TypeWithNonTrivialAssigment(const TypeWithNonTrivialAssigment &) = default;
+#endif
+
   __host__ __device__
   TypeWithNonTrivialAssigment& operator=(const TypeWithNonTrivialAssigment& t)
   {
@@ -342,7 +346,7 @@ struct TypeWithNonTrivialAssigment
     z = t.x + t.y;
     return *this;
   }
-  
+
   __host__ __device__
   bool operator==(const TypeWithNonTrivialAssigment& t) const
   {
@@ -356,7 +360,7 @@ void TestFillWithNonTrivialAssignment(void)
 
     thrust::host_vector<T>   h(1);
     thrust::device_vector<T> d(1);
-    
+
     ASSERT_EQUAL(h[0].x, 0);
     ASSERT_EQUAL(h[0].y, 0);
     ASSERT_EQUAL(h[0].z, 0);

testing/swap_ranges.cu

@@ -1,6 +1,6 @@
 #include <unittest/unittest.h>
 #include <thrust/swap.h>
-#include <thrust/iterator/iterator_traits.h> 
+#include <thrust/iterator/iterator_traits.h>
 #include <thrust/iterator/retag.h>
 #include <thrust/system/cpp/memory.h>
 
@@ -68,7 +68,7 @@ void TestSwapRangesSimple(void)
     ASSERT_EQUAL(v1[2], 7);
     ASSERT_EQUAL(v1[3], 8);
     ASSERT_EQUAL(v1[4], 9);
-    
+
     ASSERT_EQUAL(v2[0], 0);
     ASSERT_EQUAL(v2[1], 1);
     ASSERT_EQUAL(v2[2], 2);
@@ -88,11 +88,11 @@ void TestSwapRanges(const size_t n)
     thrust::host_vector<T>    h2 = a2;
     thrust::device_vector<T>  d1 = a1;
     thrust::device_vector<T>  d2 = a2;
-  
+
     thrust::swap_ranges(h1.begin(), h1.end(), h2.begin());
     thrust::swap_ranges(d1.begin(), d1.end(), d2.begin());
 
-    ASSERT_EQUAL(h1, a2);  
+    ASSERT_EQUAL(h1, a2);
     ASSERT_EQUAL(d1, a2);
     ASSERT_EQUAL(h2, a1);
     ASSERT_EQUAL(d2, a1);
@@ -147,6 +147,10 @@ struct type_with_swap
     return m_x == other.m_x && m_swapped == other.m_swapped;
   }
 
+#if THRUST_CPP_DIALECT >= 2011
+  type_with_swap & operator=(const type_with_swap &) = default;
+#endif
+
   int m_x;
   bool m_swapped;
 };

thrust/detail/config/simple_defines.h

@@ -24,5 +24,7 @@
 #define THRUST_FALSE   0
 #define THRUST_TRUE    1
 
+#define THRUST_UNUSED_VAR(expr) do { (void)(expr); } while (0)
+
 #define THRUST_PREVENT_MACRO_SUBSTITUTION
 

thrust/detail/reference.h

@@ -61,6 +61,10 @@ template<typename Element, typename Pointer, typename Derived>
     __host__ __device__
     explicit reference(const pointer &ptr);
 
+#if THRUST_CPP_DIALECT >= 2011
+    reference(const reference &) = default;
+#endif
+
     template<typename OtherElement, typename OtherPointer, typename OtherDerived>
     __host__ __device__
     reference(const reference<OtherElement,OtherPointer,OtherDerived> &other,

thrust/detail/tuple.inl

@@ -309,6 +309,10 @@ template <class HT, class TT>
   inline __host__ __device__
   cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}
 
+#if THRUST_CPP_DIALECT >= 2011
+  cons(const cons &) = default;
+#endif
+
   __thrust_exec_check_disable__
   template <class HT2, class TT2>
   inline __host__ __device__
@@ -412,6 +416,10 @@ template <class HT>
   inline __host__ __device__
   cons( const cons<HT2, null_type>& u ) : head(u.head) {}
 
+#if THRUST_CPP_DIALECT >= 2011
+  cons(const cons &) = default;
+#endif
+
   __thrust_exec_check_disable__
   template <class HT2>
   inline __host__ __device__

thrust/device_allocator.h

@@ -130,6 +130,10 @@ class device_allocator
     __host__
     device_allocator(const device_allocator<U>& other) : base(other) {}
 
+#if THRUST_CPP_DIALECT >= 2011
+    device_allocator & operator=(const device_allocator &) = default;
+#endif
+
     /*! Destructor has no effect. */
     __host__
     ~device_allocator() {}

thrust/device_malloc_allocator.h

@@ -108,12 +108,16 @@ template<typename T>
     __host__ __device__
     inline device_malloc_allocator(device_malloc_allocator<U> const&) {}
 
+#if THRUST_CPP_DIALECT >= 2011
+    device_malloc_allocator & operator=(const device_malloc_allocator &) = default;
+#endif
+
     /*! Returns the address of an allocated object.
      *  \return <tt>&r</tt>.
      */
     __host__ __device__
     inline pointer address(reference r) { return &r; }
-    
+
     /*! Returns the address an allocated object.
      *  \return <tt>&r</tt>.
      */