Implement iterator concepts

libcudacxx/.upstream-tests/test/std/iterators/iterator.primitives/iterator.traits/cxx20_iterator_traits.compile.pass.cpp

@@ -495,15 +495,13 @@ static_assert(cuda::std::same_as<InputTestIteratorTraits::reference, int&>);
 static_assert(cuda::std::same_as<InputTestIteratorTraits::pointer, int*>);
 static_assert(!has_iterator_concept_v<InputTestIteratorTraits>);
 
-#if 0
 using OutputTestIteratorTraits = cuda::std::iterator_traits<cpp17_output_iterator<int*>>;
 static_assert(cuda::std::same_as<OutputTestIteratorTraits::iterator_category, cuda::std::output_iterator_tag>);
 static_assert(cuda::std::same_as<OutputTestIteratorTraits::value_type, void>);
 static_assert(cuda::std::same_as<OutputTestIteratorTraits::difference_type, cuda::std::ptrdiff_t>);
 static_assert(cuda::std::same_as<OutputTestIteratorTraits::reference, int&>);
 static_assert(cuda::std::same_as<OutputTestIteratorTraits::pointer, int*>);
 static_assert(!has_iterator_concept_v<OutputTestIteratorTraits>);
-#endif
 
 using ForwardTestIteratorTraits = cuda::std::iterator_traits<forward_iterator<int*>>;
 static_assert(cuda::std::same_as<ForwardTestIteratorTraits::iterator_category, cuda::std::forward_iterator_tag>);
@@ -529,15 +527,13 @@ static_assert(cuda::std::same_as<RandomAccessTestIteratorTraits::reference, int&
 static_assert(cuda::std::same_as<RandomAccessTestIteratorTraits::pointer, int*>);
 static_assert(!has_iterator_concept_v<RandomAccessTestIteratorTraits>);
 
-#ifdef _LIBCUDACXX_HAS_RANGES
 using ContiguousTestIteratorTraits = cuda::std::iterator_traits<contiguous_iterator<int*>>;
 static_assert(cuda::std::same_as<ContiguousTestIteratorTraits::iterator_category, cuda::std::contiguous_iterator_tag>);
 static_assert(cuda::std::same_as<ContiguousTestIteratorTraits::value_type, int>);
 static_assert(cuda::std::same_as<ContiguousTestIteratorTraits::difference_type, cuda::std::ptrdiff_t>);
 static_assert(cuda::std::same_as<ContiguousTestIteratorTraits::reference, int&>);
 static_assert(cuda::std::same_as<ContiguousTestIteratorTraits::pointer, int*>);
 static_assert(!has_iterator_concept_v<ContiguousTestIteratorTraits>);
-#endif
 
 using Cpp17BasicIteratorTraits = cuda::std::iterator_traits<iterator_traits_cpp17_iterator>;
 static_assert(cuda::std::same_as<Cpp17BasicIteratorTraits::iterator_category, cuda::std::output_iterator_tag>);

libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.compile.pass.cpp

@@ -0,0 +1,86 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14
+
+// template<class In, class Out>
+// concept indirectly_copyable;
+
+#include <cuda/std/iterator>
+
+#include "MoveOnly.h"
+#include "test_macros.h"
+
+struct CopyOnly {
+  CopyOnly() = default;
+
+  CopyOnly(CopyOnly const&) = default;
+  CopyOnly& operator=(CopyOnly const&) = default;
+
+  CopyOnly(CopyOnly&&) = delete;
+  CopyOnly& operator=(CopyOnly&&) = delete;
+};
+
+// Can copy the underlying objects between pointers.
+static_assert( cuda::std::indirectly_copyable<int*, int*>);
+static_assert( cuda::std::indirectly_copyable<const int*, int *>);
+
+// Can't copy if the output pointer is const.
+static_assert(!cuda::std::indirectly_copyable<int*, const int *>);
+static_assert(!cuda::std::indirectly_copyable<const int*, const int *>);
+
+// Can copy from a pointer into an array but arrays aren't considered indirectly copyable-from.
+static_assert( cuda::std::indirectly_copyable<int*, int[2]>);
+static_assert(!cuda::std::indirectly_copyable<int[2], int*>);
+static_assert(!cuda::std::indirectly_copyable<int[2], int[2]>);
+static_assert(!cuda::std::indirectly_copyable<int(&)[2], int(&)[2]>);
+
+// Can't copy between non-pointer types.
+static_assert(!cuda::std::indirectly_copyable<int*, int>);
+static_assert(!cuda::std::indirectly_copyable<int, int*>);
+static_assert(!cuda::std::indirectly_copyable<int, int>);
+
+// Check some less common types.
+static_assert(!cuda::std::indirectly_movable<void*, void*>);
+static_assert(!cuda::std::indirectly_movable<int*, void*>);
+static_assert(!cuda::std::indirectly_movable<int(), int()>);
+static_assert(!cuda::std::indirectly_movable<int*, int()>);
+static_assert(!cuda::std::indirectly_movable<void, void>);
+
+// Can't copy move-only objects.
+static_assert(!cuda::std::indirectly_copyable<MoveOnly*, MoveOnly*>);
+static_assert(!cuda::std::indirectly_copyable<MoveOnly*, const MoveOnly*>);
+static_assert(!cuda::std::indirectly_copyable<const MoveOnly*, MoveOnly*>);
+static_assert(!cuda::std::indirectly_copyable<const MoveOnly*, const MoveOnly*>);
+
+// Can copy copy-only objects.
+static_assert( cuda::std::indirectly_copyable<CopyOnly*, CopyOnly*>);
+static_assert(!cuda::std::indirectly_copyable<CopyOnly*, const CopyOnly*>);
+static_assert( cuda::std::indirectly_copyable<const CopyOnly*, CopyOnly*>);
+static_assert(!cuda::std::indirectly_copyable<const CopyOnly*, const CopyOnly*>);
+
+template<class T>
+struct PointerTo {
+  using value_type = T;
+  __host__ __device__ T& operator*() const;
+};
+
+// Can copy through a dereferenceable class.
+static_assert( cuda::std::indirectly_copyable<int*, PointerTo<int>>);
+static_assert(!cuda::std::indirectly_copyable<int*, PointerTo<const int>>);
+static_assert( cuda::std::indirectly_copyable<PointerTo<int>, PointerTo<int>>);
+static_assert(!cuda::std::indirectly_copyable<PointerTo<int>, PointerTo<const int>>);
+static_assert( cuda::std::indirectly_copyable<CopyOnly*, PointerTo<CopyOnly>>);
+static_assert( cuda::std::indirectly_copyable<PointerTo<CopyOnly>, CopyOnly*>);
+static_assert( cuda::std::indirectly_copyable<PointerTo<CopyOnly>, PointerTo<CopyOnly>>);
+
+int main(int, char**)
+{
+  return 0;
+}

libcudacxx/.upstream-tests/test/std/iterators/iterator.requirements/alg.req.ind.copy/indirectly_copyable.subsumption.compile.pass.cpp

@@ -0,0 +1,35 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: c++20
+// nvbug 3885350
+
+// template<class In, class Out>
+// concept indirectly_copyable;
+
+#include <cuda/std/iterator>
+
+template<cuda::std::indirectly_readable I, class O>
+__host__ __device__ constexpr bool indirectly_copyable_subsumption() {
+  return false;
+}
+
+template<class I, class O>
+  requires cuda::std::indirectly_copyable<I, O>
+__host__ __device__ constexpr bool indirectly_copyable_subsumption() {
+  return true;
+}
+
+static_assert(indirectly_copyable_subsumption<int*, int*>());
+
+int main(int, char**)
+{
+  return 0;
+}